Changeset 24061 in osm for applications

Timestamp:

2010-11-04T16:14:43+01:00 (14 years ago)

Author:

extropy

Message:

Pdfimport: bug fixes.

Location:

applications/editors/josm/plugins/pdfimport/src/pdfimport

Files:

• PathOptimizer.java (modified) (3 diffs)
• PdfPath.java (modified) (1 diff)

applications/editors/josm/plugins/pdfimport/src/pdfimport/PathOptimizer.java

@@ -53 +53 @@
 
         public void filterByColor(Color color) {
+
+                int rgb = color.getRGB() & 0xffffff;
+
                 List<LayerContents> newLayers = new ArrayList<LayerContents>();
                 for(LayerContents l: this.layers) {
@@ -58 +61 @@
                         boolean good = false;
 
-                        if (l.info.fill != null && l.info.fill.equals(color)) {
+
+                        if (l.info.fill != null && (l.info.fill.getRGB() & 0xffffff) == rgb) {
                                 good = true;
                         }
 
-                        if (l.info.stroke != null && l.info.stroke.equals(color)) {
+                        if (l.info.stroke != null && (l.info.stroke.getRGB() & 0xffffff) == rgb) {
                                 good = true;
                         }
@@ -277 +281 @@
          */
         private void concatenatePaths(LayerContents layer) {
-                Map<Point2D, PdfPath> pathEndpoints = new HashMap<Point2D, PdfPath>();
+                Map<Point2D, List<PdfPath>> pathEndpoints = new HashMap<Point2D, List<PdfPath>>();
                 Set<PdfPath> mergedPaths = new HashSet<PdfPath>();
-
+                List<PdfPath> newPaths = new ArrayList<PdfPath>();
+
+                //fill pathEndpoints map
                 for(PdfPath pp: layer.paths){
-
-                        PdfPath path = pp;
+                        if (pp.isClosed()) {
+                                newPaths.add(pp);
+                                continue;
+                        }
+
+                        List<PdfPath> paths = pathEndpoints.get(pp.firstPoint());
+                        if (paths == null){
+                                paths = new ArrayList<PdfPath>(2);
+                                pathEndpoints.put(pp.firstPoint(), paths);
+                        }
+                        paths.add(pp);
+
+                        paths = pathEndpoints.get(pp.lastPoint());
+                        if (paths == null){
+                                paths = new ArrayList<PdfPath>(2);
+                                pathEndpoints.put(pp.lastPoint(), paths);
+                        }
+                        paths.add(pp);
+                }
+
+                List<PdfPath> pathChain = new ArrayList<PdfPath>(2);
+                Set<Point2D> pointsInPath = new HashSet<Point2D>();
+
+                //join the paths
+                for(PdfPath pp: layer.paths) {
+
+                        if (pp.isClosed() || mergedPaths.contains(pp)) {
+                                continue;
+                        }
+
                         boolean changed = true;
 
-                        while (changed && !path.isClosed()) {
-                                changed  = false;
-
-                                if (pathEndpoints.containsKey(path.firstPoint())) {
-
-                                        PdfPath p1 = pathEndpoints.get(path.firstPoint());
-
-                                        if (this.isSubpathOf(p1, path)){
-                                                continue;
+                        PdfPath firstPath = pp;
+                        PdfPath lastPath = pp;
+                        Point2D firstPoint = pp.firstPoint();
+                        Point2D lastPoint = pp.lastPoint();
+
+
+                        pathChain.clear();
+                        pathChain.add(pp);
+                        pointsInPath.clear();
+                        pointsInPath.add(firstPoint);
+                        pointsInPath.add(lastPoint);
+
+                        //process last point
+                        while (changed && firstPoint != lastPoint) {
+                                changed = false;
+
+                                List<PdfPath> adjacentPaths = pathEndpoints.get(lastPoint);
+                                PdfPath nextPath = findNextPath(adjacentPaths, lastPath);
+
+                                if (nextPath != null) {
+                                        Point2D nextPoint = nextPath.getOtherEnd(lastPoint);
+
+                                        lastPoint = nextPoint;
+                                        lastPath = nextPath;
+                                        pathChain.add(lastPath);
+
+                                        if (!pointsInPath.contains(lastPoint)) {
+                                                pointsInPath.add(lastPoint);
+                                                changed = true;
                                         }
-
-                                        pathEndpoints.remove(p1.firstPoint());
-                                        pathEndpoints.remove(p1.lastPoint());
-
-                                        List<Point2D> newNodes = tryMergeNodeLists(path.points, p1.points);
-
-                                        if (newNodes == null)
+                                        else
                                         {
-                                                int a = 10;
-                                                a++;
+                                                //closed path found
+                                                //remove excess segments from start of chain
+                                                while (lastPoint != firstPoint) {
+                                                        PdfPath pathToRemove = pathChain.get(0);
+                                                        firstPoint = pathToRemove.getOtherEnd(firstPoint);
+                                                }
+
+                                                changed = false;
                                         }
-
-                                        path.points = newNodes;
-                                        mergedPaths.add(p1);
-                                        changed = true;
                                 }
-
-                                if (pathEndpoints.containsKey(path.lastPoint())) {
-                                        PdfPath p1 = pathEndpoints.get(path.lastPoint());
-
-                                        if (this.isSubpathOf(p1, path)){
-                                                continue;
+                        }
+
+
+                        //process first point
+                        changed = true;
+                        while (changed && firstPoint != lastPoint) {
+                                changed = false;
+
+                                List<PdfPath> adjacentPaths = pathEndpoints.get(firstPoint);
+                                PdfPath nextPath = findNextPath(adjacentPaths, firstPath);
+
+                                if (nextPath != null) {
+                                        Point2D nextPoint = nextPath.getOtherEnd(firstPoint);
+
+                                        firstPoint = nextPoint;
+                                        firstPath = nextPath;
+                                        pathChain.add(0, firstPath);
+
+                                        if (!pointsInPath.contains(nextPoint)) {
+                                                pointsInPath.add(firstPoint);
+                                                changed = true;
                                         }
-
-                                        pathEndpoints.remove(p1.firstPoint());
-                                        pathEndpoints.remove(p1.lastPoint());
-
-                                        List<Point2D> newNodes = tryMergeNodeLists(path.points, p1.points);
-                                        path.points = newNodes;
-                                        mergedPaths.add(p1);
-                                        changed = true;
+                                        else
+                                        {
+                                                //closed path found
+                                                //remove excess segments from end of chain
+                                                while (lastPoint != firstPoint) {
+                                                        PdfPath pathToRemove = pathChain.get(pathChain.size() - 1);
+                                                        lastPoint = pathToRemove.getOtherEnd(lastPoint);
+                                                }
+
+                                                changed = false;
+                                        }
                                 }
                         }
 
-                        if (!path.isClosed()){
-                                pathEndpoints.put(path.firstPoint(), path);
-                                pathEndpoints.put(path.lastPoint(), path);
-                        }
-                }
-
-                List<PdfPath> resultPaths = new ArrayList<PdfPath>();
-
-                for(PdfPath path: layer.paths) {
-                        if (!mergedPaths.contains(path)){
-                                resultPaths.add(path);
-                        }
-                }
-
-                layer.paths = resultPaths;
-        }
+                        //construct path
+
+                        //remove from map
+                        for (PdfPath path: pathChain) {
+                                pathEndpoints.get(path.firstPoint()).remove(path);
+                                pathEndpoints.get(path.lastPoint()).remove(path);
+                        }
+
+                        PdfPath path = pathChain.get(0);
+
+                        for (int pos = 1; pos < pathChain.size(); pos ++) {
+                                path.points = tryMergeNodeLists(path.points, pathChain.get(pos).points);
+
+                                if (path.points == null) {
+                                        throw new RuntimeException();
+                                }
+
+                                mergedPaths.add(pathChain.get(pos));
+                        }
+
+                        newPaths.add(path);
+                }
+
+                layer.paths = newPaths;
+        }
+
+        private PdfPath findNextPath(List<PdfPath> adjacentPaths, PdfPath firstPath) {
+                for (int pos = 0; pos < adjacentPaths.size(); pos ++) {
+                        PdfPath p = adjacentPaths.get(pos);
+                        if (p != firstPath && !isSubpathOf(firstPath, p)){
+                                return p;
+                        }
+                }
+
+                return null;
+        }
+
 
         /**

applications/editors/josm/plugins/pdfimport/src/pdfimport/PdfPath.java

@@ -7 +7 @@
         public List<Point2D> points;
         public double length;
-        
+
         LayerContents layer;
         public int nr;
-        
-        
+
+
         public PdfPath(List<Point2D> nodes) {
-                points = nodes;         
+                points = nodes;
         }
 
-        public boolean isClosed() {             
-                return points.size() > 1 && points.get(0) == points.get(points.size() - 1); 
+        public boolean isClosed() {
+                return points.size() > 1 && points.get(0) == points.get(points.size() - 1);
         }
 
         public Point2D firstPoint() {
-                return points.get(0);   
+                return points.get(0);
         }
 
         public Point2D lastPoint() {
-                return points.get(points.size() - 1);   
+                return points.get(points.size() - 1);
         }
-        
+
         public void calculateLength() {
                 double len = 0;
-                
+
                 for(int pos =1; pos < points.size(); pos ++) {
                         len += points.get(pos).distance(points.get(pos -1));
                 }
-                
+
                 this.length = len;
         }
+
+        public Point2D getOtherEnd(Point2D endPoint) {
+                if (this.firstPoint() == endPoint) {
+                        return this.lastPoint();
+                }
+
+                if (this.lastPoint() == endPoint) {
+                        return this.firstPoint();
+                }
+
+                throw new RuntimeException("Unexpected point");
+
+        }
 }