Ignore:
Timestamp:
2016-10-09T04:25:33+02:00 (8 years ago)
Author:
donvip
Message:

checkstyle

File:
1 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/seachartedit/src/panels/PanelS57.java

    r32370 r33030  
    1212import java.awt.Color;
    1313import java.awt.Dimension;
    14 import java.io.*;
     14import java.io.File;
     15import java.io.FileInputStream;
     16import java.io.IOException;
    1517import java.util.ArrayList;
    1618import java.util.HashMap;
    … …  
    2426import org.openstreetmap.josm.data.Bounds;
    2527import org.openstreetmap.josm.data.coor.LatLon;
    26 import org.openstreetmap.josm.data.osm.*;
     28import org.openstreetmap.josm.data.osm.DataSet;
     29import org.openstreetmap.josm.data.osm.Node;
     30import org.openstreetmap.josm.data.osm.OsmPrimitive;
     31import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     32import org.openstreetmap.josm.data.osm.Relation;
     33import org.openstreetmap.josm.data.osm.RelationMember;
     34import org.openstreetmap.josm.data.osm.Way;
    2735import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2836
    2937import s57.S57att;
     38import s57.S57att.Att;
    3039import s57.S57dec;
     40import s57.S57map;
     41import s57.S57map.AttMap;
     42import s57.S57map.Feature;
     43import s57.S57map.GeomIterator;
     44import s57.S57map.ObjTab;
     45import s57.S57map.Pflag;
     46import s57.S57map.Prim;
     47import s57.S57map.Rflag;
     48import s57.S57map.Snode;
    3149import s57.S57obj;
    32 import s57.S57map;
     50import s57.S57obj.Obj;
    3351import s57.S57val;
    34 import s57.S57att.Att;
    35 import s57.S57map.*;
    36 import s57.S57obj.*;
    3752import s57.S57val.AttVal;
    3853
    3954public class PanelS57 extends JPanel {
    4055
    41         ArrayList<Obj> types = new ArrayList<Obj>();
    42         S57map map;
    43         HashMap<Long, Long> uids = new HashMap<Long, Long>();
    44        
    45         public PanelS57() {
    46                 setLayout(null);
    47                 setSize(new Dimension(480, 480));
    48                 setVisible(false);
    49         }
    50 
    51         public void startImport(File inf) throws IOException {
    52                 FileInputStream in = new FileInputStream(inf);
    53                 PanelMain.setStatus("Select OSM types file", Color.yellow);
    54                 JFileChooser ifc = new JFileChooser(Main.pref.get("smed2plugin.typesfile"));
    55                 ifc.setSelectedFile(new File(Main.pref.get("smed2plugin.typesfile")));
    56                 int returnVal = ifc.showOpenDialog(Main.parent);
    57                 if (returnVal == JFileChooser.APPROVE_OPTION) {
    58                         Main.pref.put("smed2plugin.typesfile", ifc.getSelectedFile().getPath());
    59                         Scanner tin = new Scanner(new FileInputStream(ifc.getSelectedFile()));
    60                         while (tin.hasNext()) {
    61                                 Obj type = S57obj.enumType(tin.next());
    62                                 if (type != Obj.UNKOBJ)
    63                                         types.add(type);
    64                         }
    65                         tin.close();
    66                 }
    67                 map = new S57map(true);
    68                 S57dec.decodeChart(in, map);
    69 
    70                 in.close();
    71                
    72                 DataSet data = new DataSet();
    73                 data.setUploadDiscouraged(true);
    74                
    75                 for (long id : map.index.keySet()) {
    76                         Feature feature = map.index.get(id);
    77                         String type = S57obj.stringType(feature.type);
    78                         if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
    79                                 if (feature.reln == Rflag.MASTER) {
    80                                         if (feature.geom.prim == Pflag.POINT) {
    81                                                 for (Prim prim : feature.geom.elems) {
    82                                                         long ref = prim.id;
    83                                                         Snode snode;
    84                                                         while ((snode = map.nodes.get(ref)) != null) {
    85                                                                 if (!uids.containsKey(ref)) {
    86                                                                         Node node = new Node(0, 1);
    87                                                                         node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
    88                                                                         data.addPrimitive(node);
    89                                                                         addKeys(node, feature, type);
    90                                                                         uids.put(ref, node.getUniqueId());
    91                                                                 }
    92                                                                 ref++;
    93                                                         }
    94                                                 }
    95                                         }
    96                                 }
    97                         }
    98                 }
    99                 for (long id : map.index.keySet()) {
    100                         Feature feature = map.index.get(id);
    101                         String type = S57obj.stringType(feature.type);
    102                         if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
    103                                 if (feature.reln == Rflag.MASTER) {
    104                                         if ((feature.geom.prim == Pflag.LINE) || ((feature.geom.prim == Pflag.AREA) && (feature.geom.outers == 1) && (feature.geom.inners == 0))) {
    105                                                 GeomIterator git = map.new GeomIterator(feature.geom);
    106                                                 while (git.hasComp()) {
    107                                                         git.nextComp();
    108                                                         while (git.hasEdge()) {
    109                                                                 git.nextEdge();
    110                                                                 while (git.hasNode()) {
    111                                                                         long ref = git.nextRef();
    112                                                                         Snode snode = map.nodes.get(ref);
    113                                                                         if (!uids.containsKey(ref)) {
    114                                                                                 Node node = new Node(0, 1);
    115                                                                                 node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
    116                                                                                 data.addPrimitive(node);
    117                                                                                 uids.put(ref, node.getUniqueId());
    118                                                                         }
    119                                                                 }
    120                                                         }
    121                                                 }
    122                                                 git = map.new GeomIterator(feature.geom);
    123                                                 while (git.hasComp()) {
    124                                                         git.nextComp();
    125                                                         Way way = new Way(0, 1);
    126                                                         data.addPrimitive(way);
    127                                                         while (git.hasEdge()) {
    128                                                                 git.nextEdge();
    129                                                                 while (git.hasNode()) {
    130                                                                         long ref = git.nextRef();
    131                                                                         way.addNode((Node)data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
    132                                                                 }
    133                                                         }
    134                                                         addKeys(way, feature, type);
    135                                                 }
    136                                         } else if (feature.geom.prim == Pflag.AREA) {
    137                                                 GeomIterator git = map.new GeomIterator(feature.geom);
    138                                                 while (git.hasComp()) {
    139                                                         git.nextComp();
    140                                                         while (git.hasEdge()) {
    141                                                                 git.nextEdge();
    142                                                                 while (git.hasNode()) {
    143                                                                         long ref = git.nextRef();
    144                                                                         Snode snode = map.nodes.get(ref);
    145                                                                         if (!uids.containsKey(ref)) {
    146                                                                                 Node node = new Node(0, 1);
    147                                                                                 node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
    148                                                                                 data.addPrimitive(node);
    149                                                                                 uids.put(ref, node.getUniqueId());
    150                                                                         }
    151                                                                 }
    152                                                         }
    153                                                 }
    154                                                 git = map.new GeomIterator(feature.geom);
    155                                                 while (git.hasComp()) {
    156                                                         long ref = git.nextComp();
    157                                                         Way way = new Way(0, 1);
    158                                                         uids.put(ref, way.getUniqueId());
    159                                                         data.addPrimitive(way);
    160                                                         while (git.hasEdge()) {
    161                                                                 git.nextEdge();
    162                                                                 while (git.hasNode()) {
    163                                                                         ref = git.nextRef();
    164                                                                         way.addNode((Node) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
    165                                                                 }
    166                                                         }
    167                                                 }
    168                                                 Relation rel = new Relation(0, 1);
    169                                                 data.addPrimitive(rel);
    170                                                 git = map.new GeomIterator(feature.geom);
    171                                                 int outers = feature.geom.outers;
    172                                                 while (git.hasComp()) {
    173                                                         long ref = git.nextComp();
    174                                                         if (outers-- > 0) {
    175                                                                 rel.addMember(new RelationMember("outer", (Way) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
    176                                                         } else {
    177                                                                 rel.addMember(new RelationMember("inner", (Way) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
    178                                                         }
    179                                                 }
    180                                                 addKeys(rel, feature, type);
    181                                         }
    182                                 }
    183                         }
    184                 }
    185 
    186                 OsmDataLayer layer = new OsmDataLayer(data, "S-57 Import", null);
    187                 Main.getLayerManager().addLayer(layer);
    188                 Main.map.mapView.zoomTo(new Bounds(Math.toDegrees(map.bounds.minlat), Math.toDegrees(map.bounds.minlon), Math.toDegrees(map.bounds.maxlat), Math.toDegrees(map.bounds.maxlon)));
    189                 PanelMain.setStatus("Import done", Color.green);
    190         }
    191 
    192         void addKeys(OsmPrimitive prim, Feature feature, String type) {
    193                 HashMap<String,String> keys = new HashMap<String,String>();
    194                 if (prim instanceof Relation) {
    195                         keys.put("type", "multipolygon");
    196                 }
    197                 keys.put("seamark:type", type);
    198                 if (feature.type == Obj.SOUNDG) {
    199                         Snode snode = map.nodes.get(feature.geom.elems.get(0).id);
    200                         if (snode.flg == S57map.Nflag.DPTH) {
    201                                 keys.put("seamark:sounding:depth", ((Double)((Snode)snode).val).toString());
    202                         }
    203                 }
    204                 for (Map.Entry<Att, AttVal<?>> item : feature.atts.entrySet()) {
    205                         String attstr = S57att.stringAttribute(item.getKey());
    206                         String valstr = S57val.stringValue(item.getValue(), item.getKey());
    207                         if (!attstr.isEmpty() && !valstr.isEmpty()) {
    208                                         keys.put(("seamark:" + type + ":" + attstr), valstr);
    209                         }
    210                 }
    211                 for (Obj obj : feature.objs.keySet()) {
    212                         ObjTab tab = feature.objs.get(obj);
    213                         for (int ix : tab.keySet()) {
    214                                 type = S57obj.stringType(obj);
    215                                 AttMap atts = tab.get(ix);
    216                                 for (Map.Entry<Att, AttVal<?>> item : atts.entrySet()) {
    217                                         String attstr = S57att.stringAttribute(item.getKey());
    218                                         String valstr = S57val.stringValue(item.getValue(), item.getKey());
    219                                         if (!attstr.isEmpty() && !valstr.isEmpty()) {
    220                                                 if ((ix == 0) && (tab.size() == 1)) {
    221                                                         keys.put(("seamark:" + type + ":" + attstr), valstr);
    222                                                 } else {
    223                                                         keys.put(("seamark:" + type + ":" + (ix+1) + ":" + attstr), valstr);
    224                                                 }
    225                                         }
    226                                 }
    227                         }
    228                 }
    229                 prim.setKeys(keys);
    230         }
    231 
    232        
    233         public void startExport(File outf) throws IOException {
    234                
    235         }
     56    ArrayList<Obj> types = new ArrayList<>();
     57    S57map map;
     58    HashMap<Long, Long> uids = new HashMap<>();
     59
     60    public PanelS57() {
     61        setLayout(null);
     62        setSize(new Dimension(480, 480));
     63        setVisible(false);
     64    }
     65
     66    public void startImport(File inf) throws IOException {
     67        FileInputStream in = new FileInputStream(inf);
     68        PanelMain.setStatus("Select OSM types file", Color.yellow);
     69        JFileChooser ifc = new JFileChooser(Main.pref.get("smed2plugin.typesfile"));
     70        ifc.setSelectedFile(new File(Main.pref.get("smed2plugin.typesfile")));
     71        int returnVal = ifc.showOpenDialog(Main.parent);
     72        if (returnVal == JFileChooser.APPROVE_OPTION) {
     73            Main.pref.put("smed2plugin.typesfile", ifc.getSelectedFile().getPath());
     74            Scanner tin = new Scanner(new FileInputStream(ifc.getSelectedFile()));
     75            while (tin.hasNext()) {
     76                Obj type = S57obj.enumType(tin.next());
     77                if (type != Obj.UNKOBJ)
     78                    types.add(type);
     79            }
     80            tin.close();
     81        }
     82        map = new S57map(true);
     83        S57dec.decodeChart(in, map);
     84
     85        in.close();
     86
     87        DataSet data = new DataSet();
     88        data.setUploadDiscouraged(true);
     89
     90        for (long id : map.index.keySet()) {
     91            Feature feature = map.index.get(id);
     92            String type = S57obj.stringType(feature.type);
     93            if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
     94                if (feature.reln == Rflag.MASTER) {
     95                    if (feature.geom.prim == Pflag.POINT) {
     96                        for (Prim prim : feature.geom.elems) {
     97                            long ref = prim.id;
     98                            Snode snode;
     99                            while ((snode = map.nodes.get(ref)) != null) {
     100                                if (!uids.containsKey(ref)) {
     101                                    Node node = new Node(0, 1);
     102                                    node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
     103                                    data.addPrimitive(node);
     104                                    addKeys(node, feature, type);
     105                                    uids.put(ref, node.getUniqueId());
     106                                }
     107                                ref++;
     108                            }
     109                        }
     110                    }
     111                }
     112            }
     113        }
     114        for (long id : map.index.keySet()) {
     115            Feature feature = map.index.get(id);
     116            String type = S57obj.stringType(feature.type);
     117            if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
     118                if (feature.reln == Rflag.MASTER) {
     119                    if ((feature.geom.prim == Pflag.LINE) || ((feature.geom.prim == Pflag.AREA)
     120                            && (feature.geom.outers == 1) && (feature.geom.inners == 0))) {
     121                        GeomIterator git = map.new GeomIterator(feature.geom);
     122                        while (git.hasComp()) {
     123                            git.nextComp();
     124                            while (git.hasEdge()) {
     125                                git.nextEdge();
     126                                while (git.hasNode()) {
     127                                    long ref = git.nextRef();
     128                                    Snode snode = map.nodes.get(ref);
     129                                    if (!uids.containsKey(ref)) {
     130                                        Node node = new Node(0, 1);
     131                                        node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
     132                                        data.addPrimitive(node);
     133                                        uids.put(ref, node.getUniqueId());
     134                                    }
     135                                }
     136                            }
     137                        }
     138                        git = map.new GeomIterator(feature.geom);
     139                        while (git.hasComp()) {
     140                            git.nextComp();
     141                            Way way = new Way(0, 1);
     142                            data.addPrimitive(way);
     143                            while (git.hasEdge()) {
     144                                git.nextEdge();
     145                                while (git.hasNode()) {
     146                                    long ref = git.nextRef();
     147                                    way.addNode((Node) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
     148                                }
     149                            }
     150                            addKeys(way, feature, type);
     151                        }
     152                    } else if (feature.geom.prim == Pflag.AREA) {
     153                        GeomIterator git = map.new GeomIterator(feature.geom);
     154                        while (git.hasComp()) {
     155                            git.nextComp();
     156                            while (git.hasEdge()) {
     157                                git.nextEdge();
     158                                while (git.hasNode()) {
     159                                    long ref = git.nextRef();
     160                                    Snode snode = map.nodes.get(ref);
     161                                    if (!uids.containsKey(ref)) {
     162                                        Node node = new Node(0, 1);
     163                                        node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
     164                                        data.addPrimitive(node);
     165                                        uids.put(ref, node.getUniqueId());
     166                                    }
     167                                }
     168                            }
     169                        }
     170                        git = map.new GeomIterator(feature.geom);
     171                        while (git.hasComp()) {
     172                            long ref = git.nextComp();
     173                            Way way = new Way(0, 1);
     174                            uids.put(ref, way.getUniqueId());
     175                            data.addPrimitive(way);
     176                            while (git.hasEdge()) {
     177                                git.nextEdge();
     178                                while (git.hasNode()) {
     179                                    ref = git.nextRef();
     180                                    way.addNode((Node) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
     181                                }
     182                            }
     183                        }
     184                        Relation rel = new Relation(0, 1);
     185                        data.addPrimitive(rel);
     186                        git = map.new GeomIterator(feature.geom);
     187                        int outers = feature.geom.outers;
     188                        while (git.hasComp()) {
     189                            long ref = git.nextComp();
     190                            if (outers-- > 0) {
     191                                rel.addMember(new RelationMember("outer", data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
     192                            } else {
     193                                rel.addMember(new RelationMember("inner", data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
     194                            }
     195                        }
     196                        addKeys(rel, feature, type);
     197                    }
     198                }
     199            }
     200        }
     201
     202        OsmDataLayer layer = new OsmDataLayer(data, "S-57 Import", null);
     203        Main.getLayerManager().addLayer(layer);
     204        Main.map.mapView.zoomTo(new Bounds(Math.toDegrees(map.bounds.minlat), Math.toDegrees(map.bounds.minlon),
     205                                           Math.toDegrees(map.bounds.maxlat), Math.toDegrees(map.bounds.maxlon)));
     206        PanelMain.setStatus("Import done", Color.green);
     207    }
     208
     209    void addKeys(OsmPrimitive prim, Feature feature, String type) {
     210        HashMap<String, String> keys = new HashMap<>();
     211        if (prim instanceof Relation) {
     212            keys.put("type", "multipolygon");
     213        }
     214        keys.put("seamark:type", type);
     215        if (feature.type == Obj.SOUNDG) {
     216            Snode snode = map.nodes.get(feature.geom.elems.get(0).id);
     217            if (snode.flg == S57map.Nflag.DPTH) {
     218                keys.put("seamark:sounding:depth", ((Double) snode.val).toString());
     219            }
     220        }
     221        for (Map.Entry<Att, AttVal<?>> item : feature.atts.entrySet()) {
     222            String attstr = S57att.stringAttribute(item.getKey());
     223            String valstr = S57val.stringValue(item.getValue(), item.getKey());
     224            if (!attstr.isEmpty() && !valstr.isEmpty()) {
     225                    keys.put(("seamark:" + type + ":" + attstr), valstr);
     226            }
     227        }
     228        for (Obj obj : feature.objs.keySet()) {
     229            ObjTab tab = feature.objs.get(obj);
     230            for (int ix : tab.keySet()) {
     231                type = S57obj.stringType(obj);
     232                AttMap atts = tab.get(ix);
     233                for (Map.Entry<Att, AttVal<?>> item : atts.entrySet()) {
     234                    String attstr = S57att.stringAttribute(item.getKey());
     235                    String valstr = S57val.stringValue(item.getValue(), item.getKey());
     236                    if (!attstr.isEmpty() && !valstr.isEmpty()) {
     237                        if ((ix == 0) && (tab.size() == 1)) {
     238                            keys.put(("seamark:" + type + ":" + attstr), valstr);
     239                        } else {
     240                            keys.put(("seamark:" + type + ":" + (ix+1) + ":" + attstr), valstr);
     241                        }
     242                    }
     243                }
     244            }
     245        }
     246        prim.setKeys(keys);
     247    }
     248
     249    public void startExport(File outf) throws IOException {
     250
     251    }
    236252}
Note: See TracChangeset for help on using the changeset viewer.