Changeset 30284 in osm for applications/editors/josm/plugins/smed2/src/s57

Timestamp:

2014-02-16T11:17:53+01:00 (11 years ago)

Author:

malcolmh

Message:

save

Location:

applications/editors/josm/plugins/smed2/src/s57

Files:

• S57dat.java (modified) (1 diff)
• S57dec.java (added)
• S57map.java (modified) (2 diffs)

applications/editors/josm/plugins/smed2/src/s57/S57dat.java

@@ -134 +134 @@
         }
 
+        private static final EnumMap<S57field, String> FldStr = new EnumMap<S57field, String>(S57field.class);
+        static {
+                FldStr.put(S57field.I8RI, "0001");
+                FldStr.put(S57field.DSID, "DSID"); FldStr.put(S57field.DSSI, "DSSI"); FldStr.put(S57field.DSPM, "DSPM"); FldStr.put(S57field.DSPR, "DSPR");
+                FldStr.put(S57field.DSRC, "DSRC"); FldStr.put(S57field.DSHT, "DSHT"); FldStr.put(S57field.DSAC, "DSAC"); FldStr.put(S57field.CATD, "CATD");
+                FldStr.put(S57field.CATX, "CATX"); FldStr.put(S57field.DDDF, "DDDF"); FldStr.put(S57field.DDDR, "DDDR"); FldStr.put(S57field.DDDI, "DDDI");
+                FldStr.put(S57field.DDOM, "DDOM"); FldStr.put(S57field.DDRF, "DDRF"); FldStr.put(S57field.DDSI, "DDSI"); FldStr.put(S57field.DDSC, "DDSC");
+                FldStr.put(S57field.FRID, "FRID"); FldStr.put(S57field.FOID, "FOID"); FldStr.put(S57field.ATTF, "ATTF"); FldStr.put(S57field.NATF, "NATF");
+                FldStr.put(S57field.FFPC, "FFPC"); FldStr.put(S57field.FFPT, "FFPT"); FldStr.put(S57field.FFPC, "FFPC"); FldStr.put(S57field.FSPT, "FSPT");
+                FldStr.put(S57field.VRID, "VRID"); FldStr.put(S57field.ATTV, "ATTV"); FldStr.put(S57field.VRPC, "VRPC"); FldStr.put(S57field.VRPT, "VRPT");
+                FldStr.put(S57field.SGCC, "SGCC"); FldStr.put(S57field.SG2D, "SG2D"); FldStr.put(S57field.SG3D, "SG3D"); FldStr.put(S57field.ARCC, "ARCC");
+                FldStr.put(S57field.AR2D, "AR2D"); FldStr.put(S57field.EL2D, "EL2D"); FldStr.put(S57field.CT2D, "CT2D"); 
+        }
+        
+        public static String stringField (S57field field) {
+                return FldStr.get(field);
+        }
+        
+        public static S57field enumField (String field) {
+                for (S57field fld : FldStr.keySet()) {
+                        if (FldStr.get(fld).equals(field))
+                                return fld;
+                }
+                return null;
+        }
+
         private static byte[] buffer;
         private static int offset;

applications/editors/josm/plugins/smed2/src/s57/S57map.java

@@ -20 +20 @@
 
 public class S57map {
+        
+        public class MapBounds {
+                public double minlat;
+                public double minlon;
+                public double maxlat;
+                public double maxlon;
+                public MapBounds() {
+                        minlat = 90;
+                        minlon = 180;
+                        maxlat = -90;
+                        maxlon = -180;
+                }
+        }
 
         public enum Nflag {
@@ -526 +539 @@
         // Utility methods
         
+        public void sortGeom() {
+                for (long id : index.keySet()) {
+                        feature = index.get(id);
+                        Geom sort = new Geom(feature.geom.prim);
+                        long first = 0;
+                        long last = 0;
+                        Comp comp = null;
+                        boolean next = true;
+                        if ((feature.geom.prim == Pflag.LINE) || (feature.geom.prim == Pflag.AREA)) {
+                                int sweep = feature.geom.elems.size();
+                                while (!feature.geom.elems.isEmpty()) {
+                                        Prim prim = feature.geom.elems.remove(0);
+                                        Edge edge = edges.get(prim.id);
+                                        if (next == true) {
+                                                next = false;
+                                                if (prim.forward) {
+                                                        first = edge.first;
+                                                        last = edge.last;
+                                                } else {
+                                                        first = edge.last;
+                                                        last = edge.first;
+                                                }
+                                                sort.elems.add(prim);
+                                                if (prim.outer) {
+                                                        sort.outers++;
+                                                } else {
+                                                        sort.inners++;
+                                                }
+                                                comp = new Comp(ref++, 1);
+                                                sort.refs.add(comp);
+                                        } else {
+                                                if (prim.forward) {
+                                                        if (edge.first == last) {
+                                                                sort.elems.add(prim);
+                                                                last = edge.last;
+                                                                comp.size++;
+                                                        } else if (edge.last == first) {
+                                                                sort.elems.add(0, prim);
+                                                                first = edge.first;
+                                                                comp.size++;
+                                                        } else {
+                                                                feature.geom.elems.add(prim);
+                                                        }
+                                                } else {
+                                                        if (edge.last == last) {
+                                                                sort.elems.add(prim);
+                                                                last = edge.first;
+                                                                comp.size++;
+                                                        } else if (edge.first == first) {
+                                                                sort.elems.add(0, prim);
+                                                                first = edge.last;
+                                                                comp.size++;
+                                                        } else {
+                                                                feature.geom.elems.add(prim);
+                                                        }
+                                                }
+                                        }
+                                        if (--sweep == 0) {
+                                                next = true;
+                                                sweep = feature.geom.elems.size();
+                                        }
+                                }
+                                if ((sort.prim == Pflag.LINE) && (sort.outers == 1) && (sort.inners == 0) && (first == last)) {
+                                        sort.prim = Pflag.AREA;
+                                }
+                                feature.geom = sort;
+                        } 
+                        if (feature.geom.prim == Pflag.AREA) {
+                                ArrayList<Prim> outers = new ArrayList<Prim>();
+                                ArrayList<Prim> inners = new ArrayList<Prim>();
+                                for (Prim prim : feature.geom.elems) {
+                                        if (prim.outer) {
+                                                outers.add(prim);
+                                        } else {
+                                                inners.add(prim);
+                                        }
+                                }
+                                ArrayList<Prim> sorting = outers;
+                                ArrayList<Prim> closed = null;
+                                sort = new Geom(feature.geom.prim);
+                                sort.outers = feature.geom.outers;
+                                sort.inners = feature.geom.inners;
+                                sort.refs = feature.geom.refs;
+                                next = true;
+                                while (!sorting.isEmpty()) {
+                                        Prim prim = sorting.remove(0);
+                                        Edge edge = edges.get(prim.id);
+                                        if (next == true) {
+                                                next = false;
+                                                closed = new ArrayList<Prim>();
+                                                closed.add(prim);
+                                                if (prim.forward) {
+                                                        first = edge.first;
+                                                        last = edge.last;
+                                                } else {
+                                                        first = edge.last;
+                                                        last = edge.first;
+                                                }
+                                        } else {
+                                                if (prim.forward) {
+                                                        if (edge.first == last) {
+                                                                last = edge.last;
+                                                                closed.add(prim);
+                                                        } else {
+                                                                sorting.add(0, prim);
+                                                                next = true;
+                                                        }
+                                                } else {
+                                                        if (edge.last == last) {
+                                                                last = edge.first;
+                                                                closed.add(prim);
+                                                        } else {
+                                                                sorting.add(0, prim);
+                                                                next = true;
+                                                        }
+                                                }
+                                        }
+                                        if (first == last) {
+                                                sort.elems.addAll(closed);
+                                                next = true;
+                                        }
+                                        if (sorting.isEmpty() && sorting == outers) {
+                                                sorting = inners;
+                                                next = true;
+                                        }
+                                }
+                                feature.geom = sort;
+                        }
+                }
+        }
+        
         public boolean cmpGeoms (Geom g1, Geom g2) {
                 return ((g1.prim == g2.prim) && (g1.outers == g2.outers) && (g1.inners == g2.inners) && (g1.elems.size() == g2.elems.size()));