Application: gvSIG desktop

 * SimpleLineSymbol is the most basic symbol for the representation of line

 * objects. Allows to define the width of the line, the color and the drawn

 * pattern.

    private static final Logger LOG = LoggerFactory.getLogger(SimpleLineSymbol.class);

    SimpleLineSymbol symbolForSelection;

    private static final GeometryManager geomManager = GeometryLocator.getGeometryManager();

    public SimpleLineSymbol() {

        super();

        setLineWidth(1d);

    }

    public ISymbol getSymbolForSelection() {

        if (symbolForSelection == null) {

            symbolForSelection = (SimpleLineSymbol) cloneForSelection();

        } else {

            symbolForSelection.setColor(MapContext.getSelectionColor());

        }

        return symbolForSelection;

    }

    public void draw(Graphics2D g, AffineTransform affineTransform,

            Geometry geom, Feature feature, Cancellable cancel) {

        if (true) {

                if (env2.getLength(0) < 1.5 && env2.getLength(1) < 1.5) {

            } catch (Exception ex) {

                LOG.warn("Error optimizing the drawing of the geometry. Continues with normal drawing.", ex);

        Geometry geomToDraw = geom;

        g.setStroke(getLineStyle().getStroke());

        if (getLineStyle()!=null && getLineStyle().getOffset() != 0) {

            double offset = getLineStyle().getOffset();

            try {

                geomToDraw = geomToDraw.offset(offset);

            } catch (Exception e) {

                LOG.warn("Error creating a polygon with an offset", e);

            }

        }

        g.setColor(getColor());

        g.draw(geomToDraw.getShape(affineTransform));

        ArrowDecoratorStyle arrowDecorator = (ArrowDecoratorStyle) getLineStyle().getArrowDecorator();

        if (arrowDecorator != null) {

            try {

                arrowDecorator.draw(g, affineTransform, geomToDraw, feature);

            } catch (CreateGeometryException e) {

                LOG.warn("Error drawing geometry.", e);

            }

        }

    }

    public int getOnePointRgb() {

        return getColor().getRGB();

    }

    public void drawInsideRectangle(Graphics2D g,

            AffineTransform scaleInstance, Rectangle r, PrintAttributes properties) throws SymbolDrawingException {

        g.setColor(getColor());

        g.setStroke(getLineStyle().getStroke());

        super.drawInsideRectangle(g, scaleInstance, r, properties);

    }

    public void setLineWidth(double width) {

        getLineStyle().setLineWidth((float) width);

    }

    public double getLineWidth() {

        return getLineStyle().getLineWidth();

    }

    public Object clone() throws CloneNotSupportedException {

        SimpleLineSymbol copy = (SimpleLineSymbol) super.clone();

        if (symbolForSelection != null) {

            copy.symbolForSelection = (SimpleLineSymbol) symbolForSelection

                    .clone();

        }

        return copy;

    }

        if (this.symbolForSelection != null) {

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(SIMPLE_LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager.addDefinition(

                        SimpleLineSymbol.class,

                        SIMPLE_LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME,

                        SIMPLE_LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

                        null,

                        null

                );

                // Extend the LineSymbol base definition

                definition.extend(manager.getDefinition(LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME));

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterSymbol implements Callable {

        public Object call() throws Exception {

            int[] shapeTypes;

            SymbolManager manager = MapContextLocator.getSymbolManager();

            shapeTypes = new int[]{Geometry.TYPES.CURVE, Geometry.TYPES.ARC,

                Geometry.TYPES.MULTICURVE, Geometry.TYPES.CIRCUMFERENCE,

                Geometry.TYPES.PERIELLIPSE, Geometry.TYPES.SPLINE,

                Geometry.TYPES.LINE, Geometry.TYPES.MULTILINE};

            manager.registerSymbol(ILineSymbol.SYMBOL_NAME,

                    shapeTypes,

                    SimpleLineSymbol.class);

            return Boolean.TRUE;

        }

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style;

import java.awt.Shape;

import java.awt.geom.Line2D;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.LineSegment;

/**

 *

 * Line2DOffset.java

 *

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es Jan 3, 2008

 *

 */

public class Line2DOffset_DEPRECATED {

    final static private Logger logger = LoggerFactory.getLogger(Line2DOffset_DEPRECATED.class);

    public static GeneralPathX offsetLine(Shape p, double offset) {

        if (Math.abs(offset) < 1) {

            return new GeneralPathX(p.getPathIterator(null));

        }

        PathIterator pi = p.getPathIterator(null);

        double[] dataCoords = new double[6];

        Coordinate from = null, first = null;

        List<LineSegment> segments = new ArrayList<LineSegment>();

        GeneralPathX offsetSegments = new GeneralPathX();

        LineSegment line;

        try {

            while (!pi.isDone()) {

                // while not done

                int type = pi.currentSegment(dataCoords);

                switch (type) {

                    case PathIterator.SEG_MOVETO:

                        if (from == null) {

                            from = new Coordinate(dataCoords[0], dataCoords[1]);

                            first = from;

                            break;

                        } else {

                            /* Puede significar un agujero en un pol?gono o un salto en una linea.

						 * Entonces, consumimos los segmentos que llevamos

						 * y empezamos un nuevo pol?gono o una nueva linea.

                             */

                            try {

                                if (((Geometry) p).getType() == Geometry.TYPES.SURFACE) {

                                    offsetSegments.append(offsetAndConsumeClosedSegments(offset, segments).getPathIterator(null),

                                            false);

                                } else {

                                    offsetSegments.append(offsetAndConsumeSegments(offset, segments).getPathIterator(null),

                                            false);

                                }

                            } catch (NotEnoughSegmentsToClosePathException e) {

                                logger.error(

                                        e.getMessage(), e);

                            }

                            segments.clear();

                            from = new Coordinate(dataCoords[0], dataCoords[1]);

                            first = from;

                            break;

                        }

                    case PathIterator.SEG_LINETO:

                        // System.out.println("SEG_LINETO");

                        Coordinate to = new Coordinate(dataCoords[0], dataCoords[1]);

                        if (from.compareTo(to) != 0) {

                            line = new LineSegment(from, to);

                            segments.add(line);

                            from = to;

                        }

                        break;

                    case PathIterator.SEG_CLOSE:

                        line = new LineSegment(from, first);

                        segments.add(line);

                        //					from = first;

                        try {

                            offsetSegments.append(offsetAndConsumeClosedSegments(

                                    offset, segments).getPathIterator(null), false);

                        } catch (NotEnoughSegmentsToClosePathException e) {

                            logger.error(

                                    e.getMessage(), e);

                        }

                        segments.clear();

                        first = null;

                        from = null;

                        break;

                } // end switch

                pi.next();

            }

            offsetSegments.append(offsetAndConsumeSegments(offset, segments)

                    .getPathIterator(null), false);

            return offsetSegments;

        } catch (ParallelLinesCannotBeResolvedException e) {

            logger.error(e.getMessage(), e);

            return new GeneralPathX(p.getPathIterator(null));

        }

    }

    private static GeneralPathX offsetAndConsumeSegments(double offset,

            List<LineSegment> segments)

            throws ParallelLinesCannotBeResolvedException {

        Map<LineSegment, LineEquation> offsetLines

                = new HashMap<LineSegment, LineEquation>();

        int segmentCount = segments.size();

        // first calculate offset lines with the starting point

        for (int i = 0; i < segmentCount; i++) {

            LineSegment segment = (LineSegment) segments.get(i);

            double theta = segment.angle();

            //FIXME: ?Esto para qu? es?

            //			if (Math.abs(theta) % (Math.PI*0.5) < 0.00001){

            //				theta=theta+0.00000000000001;

            //			}

            double xOffset = offset * Math.sin(theta);

            double yOffset = offset * Math.cos(theta);

            Coordinate p0 = segment.p0;

            double x0 = p0.x + xOffset;

            double y0 = p0.y - yOffset;

            Coordinate p1 = segment.p1;

            double x1 = p1.x + xOffset;

            double y1 = p1.y - yOffset;

            LineEquation offsetLine = new LineEquation(theta, x0, y0, x1, y1);

            offsetLines.put(segment, offsetLine);

        }

        /*

		 * let's now calculate the end point of each segment with the point

		 * where each line crosses the next one. this point will be the end

		 * point of the first line, and the start point of its next one.

         */

        Point2D pIni = null;

        Point2D pEnd = null;

        GeneralPathX gpx = new GeneralPathX();

        for (int i = 0; i < segmentCount; i++) {

            LineSegment segment = (LineSegment) segments.get(0);

            LineEquation eq = (LineEquation) offsetLines.get(segment);

            if (i == 0) {

                pIni = new Point2D.Double(eq.x, eq.y);

            } else {

                pIni = pEnd;

            }

            if (i < segmentCount - 1) {

                LineEquation eq1 = (LineEquation) offsetLines.get(segments.get(1));

                try {

                    pEnd = eq.resolve(eq1);

                } catch (ParallelLinesCannotBeResolvedException e) { //Las lineas son paralelas y NO son la misma.

                    pEnd = new Point2D.Double(eq.xEnd, eq.yEnd);

                    gpx.append(new Line2D.Double(pIni, pEnd)

                            .getPathIterator(null), true); // a?adimos una linea

                    // hasta el final

                    // del primer

                    // segmento

                    //					 y asignamos como punto final el principio del siguiente segmento

                    //					 para que en la siguiente iteraci?n lo tome como punto inicial.

                    pIni = pEnd;

                    pEnd = new Point2D.Double(eq1.x, eq1.y);

                    segments.remove(0);

                    continue;

                }

            } else {

                pEnd = new Point2D.Double(eq.xEnd, eq.yEnd);

            }

            gpx.append(new Line2D.Double(pIni, pEnd).getPathIterator(null), true);

            segments.remove(0);

        }

        return gpx;

    }

    private static GeneralPathX offsetAndConsumeClosedSegments(double offset,

            List<LineSegment> segments)

            throws ParallelLinesCannotBeResolvedException, NotEnoughSegmentsToClosePathException {

        int segmentCount = segments.size();

        if (segmentCount > 1) {

            Map<LineSegment, LineEquation> offsetLines = new HashMap<LineSegment, LineEquation>();

            // first calculate offset lines with the starting point

            for (int i = 0; i < segmentCount; i++) {

                LineSegment segment = (LineSegment) segments.get(i);

                double theta = segment.angle();

                //FIXME: ?Esto para qu? es?

                //			if (Math.abs(theta) % (Math.PI*0.5) < 0.00001){

                //				theta=theta+0.00000000000001;

                //			}

                double xOffset = offset * Math.sin(theta);

                double yOffset = offset * Math.cos(theta);

                Coordinate p0 = segment.p0;

                double x0 = p0.x + xOffset;

                double y0 = p0.y - yOffset;

                Coordinate p1 = segment.p1;

                double x1 = p1.x + xOffset;

                double y1 = p1.y - yOffset;

                LineEquation offsetLine = new LineEquation(theta, x0, y0, x1, y1);

                offsetLines.put(segment, offsetLine);

            }

            /*

			 * let's now calculate the end point of each segment with the point

			 * where each line crosses the next one. this point will be the end

			 * point of the first line, and the start point of its next one.

             */

            Point2D pIni = null;

            Point2D pEnd = null;

            Point2D firstP = null;

            GeneralPathX gpx = new GeneralPathX();

            for (int i = 0; i < segmentCount; i++) {

                LineSegment segment = (LineSegment) segments.get(0);

                LineEquation eq = offsetLines.get(segment);

                if (i == 0) { //Calculo de la intersecci?n entre el primer segmento y el ?ltimo

                    LineEquation eq0 = offsetLines.get((LineSegment) segments.get(segmentCount - 1));

                    try {

                        pIni = eq0.resolve(eq);

                    } catch (ParallelLinesCannotBeResolvedException e) { //Las lineas son paralelas y NO son la misma.

                        //						pIni = new Point2D.Double(eq0.xEnd, eq0.yEnd);

                        pIni = new Point2D.Double(eq.x, eq.y);

                    }

                    firstP = pIni;

                } else {

                    pIni = pEnd;

                }

                if (i < segmentCount - 1) {

                    LineEquation eq1 = offsetLines.get((LineSegment) segments.get(1));

                    try {

                        pEnd = eq.resolve(eq1);

                    } catch (ParallelLinesCannotBeResolvedException e) { //Las lineas son paralelas y NO son la misma.

                        pEnd = new Point2D.Double(eq.xEnd, eq.yEnd);

                        gpx.append(new Line2D.Double(pIni, pEnd).getPathIterator(null), true); // a?adimos una linea hasta el final del primer segmento

                        //					 y asignamos como punto final el principio del siguiente segmento

                        //					 para que en la siguiente iteraci?n lo tome como punto inicial.

                        pIni = pEnd;

                        pEnd = new Point2D.Double(eq1.x, eq1.y);

                        segments.remove(0);

                        continue;

                    }

                } else {

                    //					pEnd = new Point2D.Double(eq.xEnd, eq.yEnd);

                    pEnd = new Point2D.Double(firstP.getX(), firstP.getY());

                }

                gpx.append(new Line2D.Double(pIni, pEnd).getPathIterator(null), true);

                segments.remove(0);

            }

            return gpx;

        }

        throw new NotEnoughSegmentsToClosePathException(segments);

    }

    //	private static GeneralPathX offsetAndConsumeClosedSegments(double offset,

    //			List<LineSegment> segments)

    //	throws ParallelLinesCannotBeResolvedException,

    //	NotEnoughSegmentsToClosePathException {

    //		int segmentCount = segments.size();

    //		if (segmentCount > 1) {

    //			GeneralPathX openPath = offsetAndConsumeSegments(offset, segments);

    //			openPath.closePath();

    //			return openPath;

    //		}

    //		throw new NotEnoughSegmentsToClosePathException(segments);

    //	}

private static class LineEquation {

    double theta, m, x, y;

    double xEnd, yEnd; // just for simplicity of code

    public LineEquation(double theta, double x, double y, double xEnd,

            double yEnd) {

        //		this.theta = Math.tan(theta); //Esto es un error, no podemos confundir el angulo de la recta con su pendiente

        this.theta = theta;

        this.m = Math.tan(theta);

        this.x = x;

        this.y = y;

        this.xEnd = xEnd;

        this.yEnd = yEnd;

    }

    public Point2D resolve(LineEquation otherLine)

            throws ParallelLinesCannotBeResolvedException {

        /*

		 * line1 (this): y - y0 = m*(x - x0)

		 * line2 (otherLine): y' - y'0 = m'*(x' - x'0)

         */

        double X;

        double Y;

        if (Math.abs(this.x - this.xEnd) < 0.00001) { //Esta linea es vertical

            //			System.out.println("1 VERTICAL");

            X = this.xEnd;

            if (Math.abs(otherLine.x - otherLine.xEnd) < 0.00001) {//La otra linea es vertical

                //				System.out.println("    2 PERPENDICULAR");

                if (Math.abs(this.x - otherLine.x) < 0.00001) { //Son la misma linea, devolvemos el primer punto de la otra linea.

                    //					System.out.println("        MISMA LINEA");

                    Y = otherLine.y;

                } else { //No son la misma linea, entonces son paralelas, excepcion.

                    //					System.out.println("        CASCO POR 1");

                    throw new ParallelLinesCannotBeResolvedException(this, otherLine);

                }

            } else if (Math.abs(otherLine.y - otherLine.yEnd) < 0.00001) { //La otra linea es horizontal

                //				System.out.println("    2 HORIZONTAL");

                Y = otherLine.y;

            } else { //Si no

                //				System.out.println("    2 CUALQUIERA");

                Y = otherLine.m * (X - otherLine.x) + otherLine.y;

            }

        } else if (Math.abs(this.y - this.yEnd) < 0.00001) { //Esta linea es horizontal

            //			System.out.println("1 HORIZONTAL");

            Y = this.yEnd;

            if (Math.abs(otherLine.y - otherLine.yEnd) < 0.00001) { //La otra linea es horizontal

                //				System.out.println("    2 HORIZONTAL");

                if (Math.abs(this.y - otherLine.y) < 0.00001) { //Son la misma linea, devolvemos el primer punto de la otra linea.

                    //					System.out.println("        MISMA LINEA");

                    X = otherLine.x;

                } else { //No son la misma linea, entonces son paralelas, excepcion.

                    //					System.out.println("        CASCO POR 2");

                    throw new ParallelLinesCannotBeResolvedException(this, otherLine);

                }

            } else if (Math.abs(otherLine.x - otherLine.xEnd) < 0.00001) {//La otra linea es vertical

                //				System.out.println("    2 VERTICAL");

                X = otherLine.x;

            } else { //Si no

                //				System.out.println("    2 CUALQUIERA");

                X = (Y - otherLine.y) / otherLine.m + otherLine.x;

            }

        } else { //Esta linea no es ni vertical ni horizontal

            //			System.out.println("1 CUALQUIERA");

            if (Math.abs(otherLine.y - otherLine.yEnd) < 0.00001) { //La otra linea es horizontal

                //				System.out.println("    2 HORIZONTAL");

                Y = otherLine.y;

                X = (Y - this.y) / this.m + this.x;

            } else if (Math.abs(otherLine.x - otherLine.xEnd) < 0.00001) {//La otra linea es vertical

                //				System.out.println("    2 VERTICAL");

                X = otherLine.x;

                Y = this.m * (X - this.x) + this.y;

            } else if ((Math.abs(otherLine.m - this.m) < 0.00001)) { //Tienen la misma pendiente

                //				System.out.println("    MISMA PENDIENTE");

                Y = otherLine.m * (this.x - otherLine.x) + otherLine.y;

                if (Math.abs(this.y - Y) < 0.00001) { //Las lineas son la misma

                    //					System.out.println("        MISMA LINEA");

                    X = otherLine.x;

                    Y = otherLine.y;

                } else {

                    //					System.out.println("        CASCO POR 3");

                    throw new ParallelLinesCannotBeResolvedException(this, otherLine);

                }

            } else {

                //				System.out.println("    AMBAS CUALESQUIERA");

                double mTimesX = this.m * this.x;

                X = (mTimesX - this.y - otherLine.m * otherLine.x + otherLine.y) / (this.m - otherLine.m);

                Y = this.m * X - mTimesX + this.y;

            }

        }

        //		System.out.println("DEVOLVEMOS X = "+X+" Y = "+Y);

        return new Point2D.Double(X, Y);

    }

    public String toString() {

        return "Y - " + y + " = " + m + "*(X - " + x + ")";

    }

}

private static class NotEnoughSegmentsToClosePathException extends Exception {

    private static final long serialVersionUID = 95503944546535L;

    public NotEnoughSegmentsToClosePathException(List<LineSegment> segments) {

        super("Need at least 2 segments to close a path. I've got "

                + segments.size() + ".");

    }

}

private static class ParallelLinesCannotBeResolvedException extends Exception {

    private static final long serialVersionUID = 8322556508820067641L;

    public ParallelLinesCannotBeResolvedException(LineEquation eq1,

            LineEquation eq2) {

        super("Lines '" + eq1 + "' and '" + eq2

                + "' are parallel and don't share any point!");

    }

}

}

//public class Line2DOffset {

//private static final double TOL = 1E-8;

//private static final double ANGLE_TOL = 0.01/180*Math.PI;

//public static GeneralPathX offsetLine(Shape p, double offset) {

//PathIterator pi = p.getPathIterator(null);

//double[] dataCoords = new double[6];

//Coordinate from = null, first = null;

//ArrayList<LineSegment> segments = new ArrayList<LineSegment>();

//GeneralPathX offsetSegments = new GeneralPathX();

//try {

//while (!pi.isDone()) {

//// while not done

//int type = pi.currentSegment(dataCoords);

//switch (type) {

//case PathIterator.SEG_MOVETO:

//from = new Coordinate(dataCoords[0], dataCoords[1]);

//first = from;

//break;

//case PathIterator.SEG_LINETO:

//// System.out.println("SEG_LINETO");

//Coordinate to = new Coordinate(dataCoords[0], dataCoords[1]);

//LineSegment line = new LineSegment(from, to);

//int size = segments.size();

//if (size>0) {

//LineSegment prev = segments.get(size-1);

//if (line.angle() == prev.angle()) {

//if (Math.abs(line.p0.x - prev.p1.x) < TOL &&

//Math.abs(line.p0.y - prev.p1.y) < TOL) {

//prev.p1 = line.p1;

//break;

//}

//}

//}

//from = to;

//segments.add(line);

//break;

//case PathIterator.SEG_CLOSE:

//line = new LineSegment(from, first);

//segments.add(line);

//from = first;

//try {

//offsetSegments.append(offsetAndConsumeClosedSegments(offset, segments), false);

//} catch (NotEnoughSegmentsToClosePathException e) {

//Logger.getLogger(Line2DOffset.class).error(e.getMessage(), e);

//}

//break;

//} // end switch

//pi.next();

//}

//offsetSegments.append(offsetAndConsumeSegments(offset, segments), true);

//return offsetSegments;

//} catch (ParallelLinesCannotBeResolvedException e) {

//Logger.getLogger(Line2DOffset.class).error(e.getMessage(), e);

//return new GeneralPathX(p);

//}

//}

//private static GeneralPathX offsetAndConsumeSegments(double offset, ArrayList<LineSegment> segments)  {

//Hashtable<LineSegment, LineEquation> offsetLines = new Hashtable<LineSegment, LineEquation>();

//int segmentCount = segments.size();

//// first calculate offset lines with the starting point

//for (int i = 0; i < segmentCount; i++) {

//LineSegment segment = segments.get(i);

//double theta = segment.angle();

//double xOffset = offset*Math.sin(theta);

//double yOffset = offset*Math.cos(theta);

//Coordinate p0 = segment.p0;

//double x0 = p0.x + xOffset;

//double y0 = p0.y - yOffset;

//Coordinate p1 = segment.p1;

//double x1 = p1.x + xOffset;

//double y1 = p1.y - yOffset;

//LineEquation offsetLine = new LineEquation(theta, x0, y0, x1, y1, offset);

//offsetLines.put(segment, offsetLine);

//}

///*

//* let's now calculate the end point of each segment with

//* the point where each line crosses the next one.

//* this point will be the end point of the first line, and

//* the start point of its next one.

//*/

//Point2D pIni = null;

//Point2D pEnd = null;

//GeneralPathX gpx = new GeneralPathX();

//for (int i = 0; i < segmentCount; i++) {

//LineSegment segment = segments.get(0);

//LineEquation eq = offsetLines.get(segment);

//Point2D pAux = null;

//if (i < segmentCount -1) {

//try {

//pAux = eq.resolve(offsetLines.get(segments.get(1)));

//if (i == 0) {

//pIni = new Point2D.Double(eq.x, eq.y);

//} else {

//pIni = pEnd;

//}

//} catch (ParallelLinesCannotBeResolvedException e) {

//segments.remove(0);

//continue;

//}

//}

//if (pAux != null) {

//pEnd = pAux;

//} else {

//pEnd = new Point2D.Double(eq.xEnd, eq.yEnd);

//}

//gpx.append(new Line2D.Double(pIni, pEnd), true);

//segments.remove(0);