Changeset 30284 in osm for applications/editors


Ignore:
Timestamp:
2014-02-16T11:17:53+01:00 (11 years ago)
Author:
malcolmh
Message:

save

Location:
applications/editors/josm/plugins/smed2
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/smed2/js57toosm/build.xml

    r30269 r30284  
    33  <property name="build" location="build"/>
    44  <property name="jarfile" location="./js57toosm.jar"/>
    5 
     5  <property name="ant.build.javac.target" value="1.6"/>
     6  <property name="ant.build.javac.source" value="1.6"/>
     7   
    68  <target name="init">
    79    <mkdir dir="${build}"/>

  • applications/editors/josm/plugins/smed2/js57toosm/src/js57toosm/Js57toosm.java

    r30283 r30284  
    1313import java.util.*;
    1414
    15 import s57.S57map.Prim;
    1615import s57.S57obj;
    1716import s57.S57obj.*;
    … …  
    2019import s57.S57val;
    2120import s57.S57val.*;
    22 import s57.S57dat;
    23 import s57.S57dat.*;
    2421import s57.S57map;
    2522import s57.S57map.*;
     23import s57.S57dec;
    2624
    2725public class Js57toosm {
    … …  
    3331        public static void main(String[] args) throws IOException {
    3432
     33                ArrayList<Long> done = new ArrayList<Long>();
     34
    3535                if (args.length < 1) {
    3636                        System.err.println("Usage: java -jar js57toosm.jar S57_filename [types_filename]");
    … …  
    4949               
    5050                map = new S57map();
    51                 S57dat.rnum = 0;
    52 
    53                 byte[] leader = new byte[24];
    54                 boolean ddr = false;
    55                 int length;
    56                 int fields;
    57                 int mapfl, mapfp, mapts, entry;
    58                 String tag;
    59                 int len;
    60                 int pos;
    61                 boolean inFeature = false;
    62 
    63                 double comf = 1;
    64                 double somf = 1;
    65                 long name = 0;
    66                 S57map.Nflag nflag = Nflag.ANON;
    67                 S57map.Pflag pflag = S57map.Pflag.NOSP;
    68                 long objl = 0;
    69                 double minlat = 90, minlon = 180, maxlat = -90, maxlon = -180;
    70                
    71                 ArrayList<Long> done = new ArrayList<Long>();
    72 
    73                 while (in.read(leader) == 24) {
    74                         length = Integer.parseInt(new String(leader, 0, 5)) - 24;
    75                         ddr = (leader[6] == 'L');
    76                         fields = Integer.parseInt(new String(leader, 12, 5)) - 24;
    77                         mapfl = leader[20] - '0';
    78                         mapfp = leader[21] - '0';
    79                         mapts = leader[23] - '0';
    80                         entry = mapfl + mapfp + mapts;
    81                         byte[] record = new byte[length];
    82                         if (in.read(record) != length)
    83                                 break;
    84                         for (int idx = 0; idx < fields-1; idx += entry) {
    85                                 tag = new String(record, idx, mapts);
    86                                 len = Integer.parseInt(new String(record, idx+mapts, mapfl));
    87                                 pos = Integer.parseInt(new String(record, idx+mapts+mapfl, mapfp));
    88                                 if (!ddr) {
    89                                         switch (tag) {
    90                                         case "0001":
    91                                                 int i8rn = ((Long) S57dat.getSubf(record, fields + pos, S57field.I8RI, S57subf.I8RN)).intValue();
    92                                                 if (i8rn != ++S57dat.rnum) {
    93                                                         out.println("Out of order record ID");
    94                                                         in.close();
    95                                                         System.exit(-1);
    96                                                 }
    97                                                 break;
    98                                         case "DSPM":
    99                                                 comf = (double) (Long) S57dat.getSubf(record, fields + pos, S57field.DSPM, S57subf.COMF);
    100                                                 somf = (double) (Long) S57dat.getSubf(S57subf.SOMF);
    101                                                 break;
    102                                         case "FRID":
    103                                                 inFeature = true;
    104                                                 switch ((int)((long)S57dat.getSubf(record, fields + pos, S57field.FRID, S57subf.PRIM))) {
    105                                                 case 1:
    106                                                         pflag = S57map.Pflag.POINT;
    107                                                         break;
    108                                                 case 2:
    109                                                         pflag = S57map.Pflag.LINE;
    110                                                         break;
    111                                                 case 3:
    112                                                         pflag = S57map.Pflag.AREA;
    113                                                         break;
    114                                                 default:
    115                                                         pflag = S57map.Pflag.NOSP;
    116                                                 }
    117                                                 objl = (long)S57dat.getSubf(S57subf.OBJL);
    118                                                 break;
    119                                         case "FOID":
    120                                                 name = (long) S57dat.getSubf(record, fields + pos, S57field.FOID, S57subf.LNAM);
    121                                                 map.newFeature(name, pflag, objl);
    122                                                 break;
    123                                         case "ATTF":
    124                                                 S57dat.setField(record, fields + pos, S57field.ATTF, len);
    125                                                 do {
    126                                                         long attl = (long) S57dat.getSubf(S57subf.ATTL);
    127                                                         String atvl = (String) S57dat.getSubf(S57subf.ATVL);
    128                                                         if (!atvl.isEmpty()) {
    129                                                                 map.newAtt(attl, atvl);
    130                                                         }
    131                                                 } while (S57dat.more());
    132                                                 break;
    133                                         case "FFPT":
    134                                                 S57dat.setField(record, fields + pos, S57field.FFPT, len);
    135                                                 do {
    136                                                         name = (long) S57dat.getSubf(S57subf.LNAM);
    137                                                         int rind = ((Long) S57dat.getSubf(S57subf.RIND)).intValue();
    138                                                         S57dat.getSubf(S57subf.COMT);
    139                                                         map.newObj(name, rind);
    140                                                 } while (S57dat.more());
    141                                                 break;
    142                                         case "FSPT":
    143                                                 S57dat.setField(record, fields + pos, S57field.FSPT, len);
    144                                                 do {
    145                                                         name = (Long) S57dat.getSubf(S57subf.NAME) << 16;
    146                                                         map.newPrim(name, (long) S57dat.getSubf(S57subf.ORNT), (long) S57dat.getSubf(S57subf.USAG));
    147                                                         S57dat.getSubf(S57subf.MASK);
    148                                                 } while (S57dat.more());
    149                                                 break;
    150                                         case "VRID":
    151                                                 inFeature = false;
    152                                                 name = (long) S57dat.getSubf(record, fields + pos, S57field.VRID, S57subf.RCNM);
    153                                                 switch ((int) name) {
    154                                                 case 110:
    155                                                         nflag = Nflag.ISOL;
    156                                                         break;
    157                                                 case 120:
    158                                                         nflag = Nflag.CONN;
    159                                                         break;
    160                                                 default:
    161                                                         nflag = Nflag.ANON;
    162                                                         break;
    163                                                 }
    164                                                 name <<= 32;
    165                                                 name += (Long) S57dat.getSubf(S57subf.RCID);
    166                                                 name <<= 16;
    167                                                 if (nflag == Nflag.ANON) {
    168                                                         map.newEdge(name);
    169                                                 }
    170                                                 break;
    171                                         case "VRPT":
    172                                                 S57dat.setField(record, fields + pos, S57field.VRPT, len);
    173                                                 do {
    174                                                         long conn = (Long) S57dat.getSubf(S57subf.NAME) << 16;
    175                                                         int topi = ((Long) S57dat.getSubf(S57subf.TOPI)).intValue();
    176                                                         map.addConn(conn, topi);
    177                                                         S57dat.getSubf(S57subf.MASK);
    178                                                 } while (S57dat.more());
    179                                                 break;
    180                                         case "SG2D":
    181                                                 S57dat.setField(record, fields + pos, S57field.SG2D, len);
    182                                                 do {
    183                                                         double lat = (double) ((Long) S57dat.getSubf(S57subf.YCOO)) / comf;
    184                                                         double lon = (double) ((Long) S57dat.getSubf(S57subf.XCOO)) / comf;
    185                                                         if (nflag == Nflag.ANON) {
    186                                                                 map.newNode(++name, lat, lon, nflag);
    187                                                         } else {
    188                                                                 map.newNode(name, lat, lon, nflag);
    189                                                         }
    190                                                         if (lat < minlat)
    191                                                                 minlat = lat;
    192                                                         if (lat > maxlat)
    193                                                                 maxlat = lat;
    194                                                         if (lon < minlon)
    195                                                                 minlon = lon;
    196                                                         if (lon > maxlon)
    197                                                                 maxlon = lon;
    198                                                 } while (S57dat.more());
    199                                                 break;
    200                                         case "SG3D":
    201                                                 S57dat.setField(record, fields + pos, S57field.SG3D, len);
    202                                                 do {
    203                                                         double lat = (double) ((Long) S57dat.getSubf(S57subf.YCOO)) / comf;
    204                                                         double lon = (double) ((Long) S57dat.getSubf(S57subf.XCOO)) / comf;
    205                                                         double depth = (double) ((Long) S57dat.getSubf(S57subf.VE3D)) / somf;
    206                                                         map.newNode(name++, lat, lon, depth);
    207                                                         if (lat < minlat)
    208                                                                 minlat = lat;
    209                                                         if (lat > maxlat)
    210                                                                 maxlat = lat;
    211                                                         if (lon < minlon)
    212                                                                 minlon = lon;
    213                                                         if (lon > maxlon)
    214                                                                 maxlon = lon;
    215                                                 } while (S57dat.more());
    216                                                 break;
    217                                         }
    218                                 }
    219                                 if (inFeature) {
    220                                         map.endFeature();
    221                                         inFeature = false;
    222                                 }
    223                         }
    224                 }
    225                 map.endFile();
    226                 in.close();
    227 
    228                 out.println("<?xml version='1.0' encoding='UTF-8'?>");
    229                 out.println("<osm version='0.6' generator='js57toosm'>");
    230                 out.println("<bounds minlat='" + minlat + "' minlon='" + minlon + "' maxlat='" + maxlat + "' maxlon='" + maxlon + "'/>");
     51                MapBounds bounds = S57dec.decodeFile(in, types, map);
     52
     53                out.format("<?xml version='1.0' encoding='UTF-8'?>");
     54                out.format("<osm version='0.6' generator='js57toosm'>");
     55                out.format("<bounds minlat='%.8f' minlon='%.8f' maxlat='%.8f' maxlon='%.8f'/>", bounds.minlat, bounds.minlon, bounds.maxlat, bounds.maxlon);
    23156
    23257                for (long id : map.index.keySet()) {
    … …  
    26186                        if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
    26287                                if (feature.reln == Rflag.MASTER) {
    263                                         if (feature.geom.prim == Pflag.LINE) {
     88                                        if ((feature.geom.prim == Pflag.LINE) || ((feature.geom.prim == Pflag.AREA) && (feature.geom.outers == 1) && (feature.geom.inners == 0))) {
    26489                                                GeomIterator git = map.new GeomIterator(feature.geom);
    26590                                                while (git.hasComp()) {

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

    r30280 r30284  
    134134        }
    135135
     136        private static final EnumMap<S57field, String> FldStr = new EnumMap<S57field, String>(S57field.class);
     137        static {
     138                FldStr.put(S57field.I8RI, "0001");
     139                FldStr.put(S57field.DSID, "DSID"); FldStr.put(S57field.DSSI, "DSSI"); FldStr.put(S57field.DSPM, "DSPM"); FldStr.put(S57field.DSPR, "DSPR");
     140                FldStr.put(S57field.DSRC, "DSRC"); FldStr.put(S57field.DSHT, "DSHT"); FldStr.put(S57field.DSAC, "DSAC"); FldStr.put(S57field.CATD, "CATD");
     141                FldStr.put(S57field.CATX, "CATX"); FldStr.put(S57field.DDDF, "DDDF"); FldStr.put(S57field.DDDR, "DDDR"); FldStr.put(S57field.DDDI, "DDDI");
     142                FldStr.put(S57field.DDOM, "DDOM"); FldStr.put(S57field.DDRF, "DDRF"); FldStr.put(S57field.DDSI, "DDSI"); FldStr.put(S57field.DDSC, "DDSC");
     143                FldStr.put(S57field.FRID, "FRID"); FldStr.put(S57field.FOID, "FOID"); FldStr.put(S57field.ATTF, "ATTF"); FldStr.put(S57field.NATF, "NATF");
     144                FldStr.put(S57field.FFPC, "FFPC"); FldStr.put(S57field.FFPT, "FFPT"); FldStr.put(S57field.FFPC, "FFPC"); FldStr.put(S57field.FSPT, "FSPT");
     145                FldStr.put(S57field.VRID, "VRID"); FldStr.put(S57field.ATTV, "ATTV"); FldStr.put(S57field.VRPC, "VRPC"); FldStr.put(S57field.VRPT, "VRPT");
     146                FldStr.put(S57field.SGCC, "SGCC"); FldStr.put(S57field.SG2D, "SG2D"); FldStr.put(S57field.SG3D, "SG3D"); FldStr.put(S57field.ARCC, "ARCC");
     147                FldStr.put(S57field.AR2D, "AR2D"); FldStr.put(S57field.EL2D, "EL2D"); FldStr.put(S57field.CT2D, "CT2D");
     148        }
     149       
     150        public static String stringField (S57field field) {
     151                return FldStr.get(field);
     152        }
     153       
     154        public static S57field enumField (String field) {
     155                for (S57field fld : FldStr.keySet()) {
     156                        if (FldStr.get(fld).equals(field))
     157                                return fld;
     158                }
     159                return null;
     160        }
     161
    136162        private static byte[] buffer;
    137163        private static int offset;

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

    r30283 r30284  
    2020
    2121public class S57map {
     22       
     23        public class MapBounds {
     24                public double minlat;
     25                public double minlon;
     26                public double maxlat;
     27                public double maxlon;
     28                public MapBounds() {
     29                        minlat = 90;
     30                        minlon = 180;
     31                        maxlat = -90;
     32                        maxlon = -180;
     33                }
     34        }
    2235
    2336        public enum Nflag {
    … …  
    526539        // Utility methods
    527540       
     541        public void sortGeom() {
     542                for (long id : index.keySet()) {
     543                        feature = index.get(id);
     544                        Geom sort = new Geom(feature.geom.prim);
     545                        long first = 0;
     546                        long last = 0;
     547                        Comp comp = null;
     548                        boolean next = true;
     549                        if ((feature.geom.prim == Pflag.LINE) || (feature.geom.prim == Pflag.AREA)) {
     550                                int sweep = feature.geom.elems.size();
     551                                while (!feature.geom.elems.isEmpty()) {
     552                                        Prim prim = feature.geom.elems.remove(0);
     553                                        Edge edge = edges.get(prim.id);
     554                                        if (next == true) {
     555                                                next = false;
     556                                                if (prim.forward) {
     557                                                        first = edge.first;
     558                                                        last = edge.last;
     559                                                } else {
     560                                                        first = edge.last;
     561                                                        last = edge.first;
     562                                                }
     563                                                sort.elems.add(prim);
     564                                                if (prim.outer) {
     565                                                        sort.outers++;
     566                                                } else {
     567                                                        sort.inners++;
     568                                                }
     569                                                comp = new Comp(ref++, 1);
     570                                                sort.refs.add(comp);
     571                                        } else {
     572                                                if (prim.forward) {
     573                                                        if (edge.first == last) {
     574                                                                sort.elems.add(prim);
     575                                                                last = edge.last;
     576                                                                comp.size++;
     577                                                        } else if (edge.last == first) {
     578                                                                sort.elems.add(0, prim);
     579                                                                first = edge.first;
     580                                                                comp.size++;
     581                                                        } else {
     582                                                                feature.geom.elems.add(prim);
     583                                                        }
     584                                                } else {
     585                                                        if (edge.last == last) {
     586                                                                sort.elems.add(prim);
     587                                                                last = edge.first;
     588                                                                comp.size++;
     589                                                        } else if (edge.first == first) {
     590                                                                sort.elems.add(0, prim);
     591                                                                first = edge.last;
     592                                                                comp.size++;
     593                                                        } else {
     594                                                                feature.geom.elems.add(prim);
     595                                                        }
     596                                                }
     597                                        }
     598                                        if (--sweep == 0) {
     599                                                next = true;
     600                                                sweep = feature.geom.elems.size();
     601                                        }
     602                                }
     603                                if ((sort.prim == Pflag.LINE) && (sort.outers == 1) && (sort.inners == 0) && (first == last)) {
     604                                        sort.prim = Pflag.AREA;
     605                                }
     606                                feature.geom = sort;
     607                        }
     608                        if (feature.geom.prim == Pflag.AREA) {
     609                                ArrayList<Prim> outers = new ArrayList<Prim>();
     610                                ArrayList<Prim> inners = new ArrayList<Prim>();
     611                                for (Prim prim : feature.geom.elems) {
     612                                        if (prim.outer) {
     613                                                outers.add(prim);
     614                                        } else {
     615                                                inners.add(prim);
     616                                        }
     617                                }
     618                                ArrayList<Prim> sorting = outers;
     619                                ArrayList<Prim> closed = null;
     620                                sort = new Geom(feature.geom.prim);
     621                                sort.outers = feature.geom.outers;
     622                                sort.inners = feature.geom.inners;
     623                                sort.refs = feature.geom.refs;
     624                                next = true;
     625                                while (!sorting.isEmpty()) {
     626                                        Prim prim = sorting.remove(0);
     627                                        Edge edge = edges.get(prim.id);
     628                                        if (next == true) {
     629                                                next = false;
     630                                                closed = new ArrayList<Prim>();
     631                                                closed.add(prim);
     632                                                if (prim.forward) {
     633                                                        first = edge.first;
     634                                                        last = edge.last;
     635                                                } else {
     636                                                        first = edge.last;
     637                                                        last = edge.first;
     638                                                }
     639                                        } else {
     640                                                if (prim.forward) {
     641                                                        if (edge.first == last) {
     642                                                                last = edge.last;
     643                                                                closed.add(prim);
     644                                                        } else {
     645                                                                sorting.add(0, prim);
     646                                                                next = true;
     647                                                        }
     648                                                } else {
     649                                                        if (edge.last == last) {
     650                                                                last = edge.first;
     651                                                                closed.add(prim);
     652                                                        } else {
     653                                                                sorting.add(0, prim);
     654                                                                next = true;
     655                                                        }
     656                                                }
     657                                        }
     658                                        if (first == last) {
     659                                                sort.elems.addAll(closed);
     660                                                next = true;
     661                                        }
     662                                        if (sorting.isEmpty() && sorting == outers) {
     663                                                sorting = inners;
     664                                                next = true;
     665                                        }
     666                                }
     667                                feature.geom = sort;
     668                        }
     669                }
     670        }
     671       
    528672        public boolean cmpGeoms (Geom g1, Geom g2) {
    529673                return ((g1.prim == g2.prim) && (g1.outers == g2.outers) && (g1.inners == g2.inners) && (g1.elems.size() == g2.elems.size()));
Note: See TracChangeset for help on using the changeset viewer.