Ignore:
Timestamp:
2014-02-14T19:49:05+01:00 (11 years ago)
Author:
malcolmh
Message:

save

Location:
applications/editors/josm/plugins/smed2/src/s57
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r30269 r30280  
    173173       
    174174        public static boolean more() {
    175                 return ((offset < maxoff) && (buffer[offset] != 0x1e));
     175                return (offset < maxoff);
    176176        }
    177177       

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

    r30269 r30280  
    224224        public FtrTab index;
    225225
     226        public long ref;
    226227        private Feature feature;
    227228        private Edge edge;
    228         private long ref;
    229229
    230230        public S57map() {
    … …  
    307307
    308308        public void endFile() {
    309                 sortGeom();
     309                for (long id : index.keySet()) {
     310                        Feature feature = index.get(id);
     311                        if ((feature.geom.prim == Pflag.LINE) || (feature.geom.prim == Pflag.AREA)) {
     312                                feature.geom.outers = 1;
     313                                feature.geom.inners = 0;
     314                                feature.geom.refs = new ArrayList<Comp>();
     315                                Comp comp = new Comp(ref++, 0);
     316                                feature.geom.refs.add(comp);
     317                                ListIterator<S57map.Prim> ite = feature.geom.elems.listIterator();
     318                                while (ite.hasNext()) {
     319                                        Prim prim = ite.next();
     320                                        if (prim.outer) {
     321                                                comp.size++;
     322                                               
     323                                        }
     324                                }
     325                        }
     326                }
    310327                for (long id : index.keySet()) {
    311328                        Feature feature = index.get(id);
    … …  
    495512        // Utility methods
    496513       
    497         public void sortGeom() {
    498                 for (long id : index.keySet()) {
    499                         feature = index.get(id);
    500                         Geom sort = new Geom(feature.geom.prim);
    501                         long first = 0;
    502                         long last = 0;
    503                         Comp comp = null;
    504                         boolean next = true;
    505                         if ((feature.geom.prim == Pflag.LINE) || (feature.geom.prim == Pflag.AREA)) {
    506                                 int sweep = feature.geom.elems.size();
    507                                 while (!feature.geom.elems.isEmpty()) {
    508                                         Prim prim = feature.geom.elems.remove(0);
    509                                         Edge edge = edges.get(prim.id);
    510                                         if (next == true) {
    511                                                 next = false;
    512                                                 if (prim.forward) {
    513                                                         first = edge.first;
    514                                                         last = edge.last;
    515                                                 } else {
    516                                                         first = edge.last;
    517                                                         last = edge.first;
    518                                                 }
    519                                                 sort.elems.add(prim);
    520                                                 if (prim.outer) {
    521                                                         sort.outers++;
    522                                                 } else {
    523                                                         sort.inners++;
    524                                                 }
    525                                                 comp = new Comp(ref++, 1);
    526                                                 sort.refs.add(comp);
    527                                         } else {
    528                                                 if (prim.forward) {
    529                                                         if (edge.first == last) {
    530                                                                 sort.elems.add(prim);
    531                                                                 last = edge.last;
    532                                                                 comp.size++;
    533                                                         } else if (edge.last == first) {
    534                                                                 sort.elems.add(0, prim);
    535                                                                 first = edge.first;
    536                                                                 comp.size++;
    537                                                         } else {
    538                                                                 feature.geom.elems.add(prim);
    539                                                         }
    540                                                 } else {
    541                                                         if (edge.last == last) {
    542                                                                 sort.elems.add(prim);
    543                                                                 last = edge.first;
    544                                                                 comp.size++;
    545                                                         } else if (edge.first == first) {
    546                                                                 sort.elems.add(0, prim);
    547                                                                 first = edge.last;
    548                                                                 comp.size++;
    549                                                         } else {
    550                                                                 feature.geom.elems.add(prim);
    551                                                         }
    552                                                 }
    553                                         }
    554                                         if (--sweep == 0) {
    555                                                 next = true;
    556                                                 sweep = feature.geom.elems.size();
    557                                         }
    558                                 }
    559                                 if ((sort.prim == Pflag.LINE) && (sort.outers == 1) && (sort.inners == 0) && (first == last)) {
    560                                         sort.prim = Pflag.AREA;
    561                                 }
    562                                 feature.geom = sort;
    563                         }
    564                         if (feature.geom.prim == Pflag.AREA) {
    565                                 ArrayList<Prim> outers = new ArrayList<Prim>();
    566                                 ArrayList<Prim> inners = new ArrayList<Prim>();
    567                                 for (Prim prim : feature.geom.elems) {
    568                                         if (prim.outer) {
    569                                                 outers.add(prim);
    570                                         } else {
    571                                                 inners.add(prim);
    572                                         }
    573                                 }
    574                                 ArrayList<Prim> sorting = outers;
    575                                 ArrayList<Prim> closed = null;
    576                                 sort = new Geom(feature.geom.prim);
    577                                 sort.outers = feature.geom.outers;
    578                                 sort.inners = feature.geom.inners;
    579                                 sort.refs = feature.geom.refs;
    580                                 next = true;
    581                                 while (!sorting.isEmpty()) {
    582                                         Prim prim = sorting.remove(0);
    583                                         Edge edge = edges.get(prim.id);
    584                                         if (next == true) {
    585                                                 next = false;
    586                                                 closed = new ArrayList<Prim>();
    587                                                 closed.add(prim);
    588                                                 if (prim.forward) {
    589                                                         first = edge.first;
    590                                                         last = edge.last;
    591                                                 } else {
    592                                                         first = edge.last;
    593                                                         last = edge.first;
    594                                                 }
    595                                         } else {
    596                                                 if (prim.forward) {
    597                                                         if (edge.first == last) {
    598                                                                 last = edge.last;
    599                                                                 closed.add(prim);
    600                                                         } else {
    601                                                                 sorting.add(0, prim);
    602                                                                 next = true;
    603                                                         }
    604                                                 } else {
    605                                                         if (edge.last == last) {
    606                                                                 last = edge.first;
    607                                                                 closed.add(prim);
    608                                                         } else {
    609                                                                 sorting.add(0, prim);
    610                                                                 next = true;
    611                                                         }
    612                                                 }
    613                                         }
    614                                         if (first == last) {
    615                                                 sort.elems.addAll(closed);
    616                                                 next = true;
    617                                         }
    618                                         if (sorting.isEmpty() && sorting == outers) {
    619                                                 sorting = inners;
    620                                                 next = true;
    621                                         }
    622                                 }
    623                                 feature.geom = sort;
    624                         }
    625                 }
    626         }
    627        
    628514        public boolean cmpGeoms (Geom g1, Geom g2) {
    629515                return ((g1.prim == g2.prim) && (g1.outers == g2.outers) && (g1.inners == g2.inners) && (g1.elems.size() == g2.elems.size()));
    … …  
    684570                Prim prim;
    685571                EdgeIterator eit;
    686                 ListIterator<S57map.Prim> it;
    687                 int cc, ec;
     572                ListIterator<S57map.Prim> ite;
     573                ListIterator<Comp> itc;
    688574                Comp comp;
     575                int ec;
    689576                long lastref;
    690577               
    691578                public GeomIterator(Geom g) {
    692579                        geom = g;
    693                         eit = null;
    694                         cc = ec = 0;
    695                         comp = null;
    696580                        lastref = 0;
    697                         if ((geom.prim != Pflag.NOSP) && (geom.prim != Pflag.POINT)) {
    698                                 it = geom.elems.listIterator();
    699                         } else {
    700                                 it = null;
    701                         }
    702                 }
    703                
    704                 public boolean hasMore() {
    705                         return (cc < geom.refs.size());
    706                 }
    707                
    708                 public long getMore() {
    709                         comp = geom.refs.get(cc++);
    710                         ec = 0;
     581                        ite = geom.elems.listIterator();
     582                        itc = geom.refs.listIterator();
     583                }
     584               
     585                public boolean hasComp() {
     586                        return (itc.hasNext());
     587                }
     588               
     589                public long nextComp() {
     590                        comp = itc.next();
     591                        ec = comp.size;
     592                        lastref = 0;
    711593                        return comp.ref;
    712594                }
    713595               
    714                 public boolean hasNext() {
    715                         if (eit == null) {
    716                                 return (ec < comp.size);
    717                         } else {
    718                                 return (eit.hasNext());
    719                         }
     596                public boolean hasEdge() {
     597                        return (ec > 0) && ite.hasNext();
     598                }
     599               
     600                public long nextEdge() {
     601                        prim = ite.next();
     602                        eit = new EdgeIterator(edges.get(prim.id), prim.forward);
     603                        ec--;
     604                        return prim.id;
     605                }
     606               
     607                public boolean hasNode() {
     608                        return (eit.hasNext());
    720609                }
    721610               
    722611                public long nextRef() {
    723                         if ((eit == null) && (ec < comp.size)) {
    724                                 prim = geom.elems.get(ec++);
    725                                 eit = new EdgeIterator(edges.get(prim.id), prim.forward);
    726                         }
    727612                        long ref = eit.nextRef();
    728613                        if (ref == lastref) {
    … …  
    730615                        }
    731616                        lastref = ref;
    732                         if (!eit.hasNext()) {
    733                                 eit = null;
    734                         }
    735617                        return ref;
    736618                }
    … …  
    747629                double sigma = 0;
    748630                GeomIterator it = new GeomIterator(geom);
    749                 it.getMore();
    750                 while (it.hasNext()) {
     631                it.nextComp();
     632                while (it.hasNode()) {
    751633                        llon = lon;
    752634                        llat = lat;
    … …  
    773655                double sigma = 0;
    774656                GeomIterator it = new GeomIterator(geom);
    775                 it.getMore();
    776                 if (it.hasNext()) {
     657                it.nextComp();
     658                if (it.hasNode()) {
    777659                        node = it.next();
    778660                        lat = node.lat;
    779661                        lon = node.lon;
    780                         while (it.hasNext()) {
     662                        while (it.hasNode()) {
    781663                                llon = lon;
    782664                                llat = lat;
    … …  
    800682                case LINE:
    801683                        GeomIterator it = new GeomIterator(feature.geom);
    802                         it.getMore();
    803                         while (it.hasNext()) {
     684                        it.nextComp();
     685                        while (it.hasNode()) {
    804686                                Snode node = it.next();
    805687                                lat = node.lat;
    … …  
    817699                        first = true;
    818700                        it = new GeomIterator(feature.geom);
    819                         while (it.hasNext()) {
    820                                 it.getMore();
     701                        while (it.hasNode()) {
     702                                it.nextComp();
    821703                                Snode node = it.next();
    822704                                lat = node.lat;
    … …  
    836718                case AREA:
    837719                        GeomIterator bit = new GeomIterator(feature.geom);
    838                         bit.getMore();
    839                         while (bit.hasNext()) {
     720                        bit.nextComp();
     721                        while (bit.hasNode()) {
    840722                                Snode node = bit.next();
    841723                                lat = node.lat;
Note: See TracChangeset for help on using the changeset viewer.