Ignore:
Timestamp:
2016-02-27T09:09:45+01:00 (10 years ago)
Author:
malcolmh
Message:

[seachart] update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/seachart/src/s57/S57box.java

    r31846 r32082  
    1818       
    1919        enum Ext {I, N, W, S, E }
     20       
     21        static Ext getExt(S57map map, double lat, double lon) {
     22                if ((lat >= map.bounds.maxlat) && (lon < map.bounds.maxlon)) {
     23                        return Ext.N;
     24                } else if (lon <= map.bounds.minlon) {
     25                        return Ext.W;
     26                } else if (lat <= map.bounds.minlat) {
     27                        return Ext.S;
     28                } else if (lon >= map.bounds.maxlon) {
     29                        return Ext.E;
     30                }               return Ext.I;
     31        }
    2032       
    2133        public static void bBox(S57map map) {
    … …  
    105117                        }
    106118                        for (Land land : lands) {
    107                                 GeomIterator git = map.new GeomIterator(land.land.geom);
    108                                 Snode prev = null;
    109                                 Ext bprev = Ext.I;
    110                                 Ext ext;
    111                                 land.ebound = land.sbound = Ext.I;
    112                                 while (git.hasComp()) {
    113                                         git.nextComp();
    114                                         while (git.hasEdge()) {
    115                                                 git.nextEdge();
    116                                                 while (git.hasNode()) {
    117                                                         long ref = git.nextRef(false);
    118                                                         Snode node = map.nodes.get(ref);
    119                                                         if (node == null)
    120                                                                 continue;
    121                                                         if (land.first == 0) {
    122                                                                 land.first = ref;
    123                                                         }
    124                                                         if (prev == null) {
    125                                                                 prev = node;
    126                                                         }
    127                                                         if ((node.lat >= map.bounds.maxlat) && (node.lon < map.bounds.maxlon)) {
    128                                                                 ext = Ext.N;
    129                                                         } else if (node.lon <= map.bounds.minlon) {
    130                                                                 ext = Ext.W;
    131                                                         } else if (node.lat <= map.bounds.minlat) {
    132                                                                 ext = Ext.S;
    133                                                         } else if (node.lon >= map.bounds.maxlon) {
    134                                                                 ext = Ext.E;
    135                                                         } else {
    136                                                                 ext = Ext.I;
    137                                                         }
    138                                                         if (ext == Ext.I) {
    139                                                                 if (land.start == null) {
    140                                                                         land.start = prev;
    141                                                                         land.sbound = bprev;
    142                                                                 }
    143                                                                 land.end = null;
    144                                                                 land.ebound = Ext.I;
    145                                                         } else {
    146                                                                 if ((land.start != null) && (land.end == null)) {
    147                                                                         land.end = node;
    148                                                                         land.ebound = ext;
    149                                                                 }
    150                                                         }
    151                                                         prev = node;
    152                                                         bprev = ext;
    153                                                         land.last = ref;
    154                                                 }
    155                                         }
    156                                 }
     119                                land.first = map.edges.get(land.land.geom.elems.get(0).id).first;
     120                                land.start = map.nodes.get(land.first);
     121                                land.sbound = getExt(map, land.start.lat, land.start.lon);
     122                                land.last = map.edges.get(land.land.geom.elems.get(land.land.geom.comps.get(0).size - 1).id).last;
     123                                land.end = map.nodes.get(land.last);
     124                                land.ebound = getExt(map, land.end.lat, land.end.lon);
    157125                        }
    158126                        islands = new ArrayList<>();
    … …  
    165133                                lands.remove(island);
    166134                        }
    167                         while (lands.size() > 0) {
    168                                 Land land = lands.get(0);
     135                        for (Land land : lands) {
    169136                                Edge nedge = map.new Edge();
    170137                                nedge.first = land.last;
     138                                nedge.last = land.first;
    171139                                Ext bound = land.ebound;
    172                                 Snode last = land.end;
    173                                 double delta = Math.PI;
    174                                 int idx = -1;
    175                                 Land next = null;
    176                                 while (idx < 0) {
    177                                         for (int i = 0; i < lands.size(); i++) {
    178                                                 next = lands.get(i);
    179                                                 if (next.sbound == bound) {
    180                                                         double diff = -Math.PI;
    181                                                         switch (bound) {
    182                                                         case N:
    183                                                                 diff = last.lon - next.start.lon;
    184                                                                 break;
    185                                                         case W:
    186                                                                 diff = last.lat - next.start.lat;
    187                                                                 break;
    188                                                         case S:
    189                                                                 diff = next.start.lon - last.lon;
    190                                                                 break;
    191                                                         case E:
    192                                                                 diff = next.start.lat - last.lat;
    193                                                                 break;
    194                                                         default:
    195                                                                 continue;
    196                                                         }
    197                                                         if ((diff >= 0.0) && (diff < delta)) {
    198                                                                 delta = diff;
    199                                                                 idx = i;
    200                                                         }
    201                                                 }
    202                                         }
    203                                         if (idx < 0) {
    204                                                 long ref = (long) bound.ordinal();
    205                                                 last = map.nodes.get(ref);
    206                                                 nedge.nodes.add(ref);
    207                                                 ref = ref < 4 ? ++ref : 1;
    208                                                 for (Ext e : Ext.values()) {
    209                                                         if (ref == e.ordinal()) {
    210                                                                 bound = e;
    211                                                                 break;
    212                                                         }
    213                                                 }
     140                                while (bound != land.sbound) {
     141                                        switch (bound) {
     142                                        case N:
     143                                                nedge.nodes.add(1l);
     144                                                bound = Ext.W;
     145                                                break;
     146                                        case W:
     147                                                nedge.nodes.add(2l);
     148                                                bound = Ext.S;
     149                                                break;
     150                                        case S:
     151                                                nedge.nodes.add(3l);
     152                                                bound = Ext.E;
     153                                                break;
     154                                        case E:
     155                                                nedge.nodes.add(4l);
     156                                                bound = Ext.N;
     157                                                break;
     158                                        default:
     159                                                continue;
    214160                                        }
    215161                                }
    216                                 next = lands.get(idx);
    217                                 nedge.last = next.first;
    218162                                map.edges.put(++map.xref, nedge);
    219163                                land.land.geom.elems.add(map.new Prim(map.xref));
    220                                 if (next != land) {
    221                                         land.land.geom.elems.addAll(next.land.geom.elems);
    222                                         land.ebound = next.ebound;
    223                                         land.end = next.end;
    224                                         land.last = next.last;
    225                                         lands.remove(idx);
    226                                 }
    227                                 map.sortGeom(land.land);
    228                                 if (land.land.geom.prim == Pflag.AREA) {
    229                                         map.features.get(Obj.LNDARE).add(land.land);
    230                                         lands.remove(land);
    231                                 }
     164                                land.land.geom.comps.get(0).size++;
     165                                land.land.geom.prim = Pflag.AREA;
     166                                map.features.get(Obj.LNDARE).add(land.land);
    232167                        }
    233168                }
Note: See TracChangeset for help on using the changeset viewer.