Application: gvSIG desktop » gvSIG tools: Vector editing

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.vectorediting.lib.prov.chamfer;

import java.util.Iterator;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

/**

 *

 * @author fdiaz

 */

public class SegmentData {

    public static final int SEGMENT_POSITION_FIRST = 0;

    public static final int SEGMENT_POSITION_MIDDLE = 1;

    public static final int SEGMENT_POSITION_LAST = 2;

    private Feature feature = null;

    //        private Geometry geometry;

    //If the geometry is an Aggregate, this is the primitive that contains the projected point, if not, it is the geometry itself

    private Primitive primitive = null;

    //Projected point on the primitive of the input point

    private Point projectedPoint = null;

    //Line with only two vertices, represents the segment in which the projected point is located

    private Line line = null;

    //Index on the primitive of the first vertex of the segment

    private Integer idxVertex = null;

    //Three possible values: 0 (first), 1 (middle), 2 (last)

    //        Integer position;

    public SegmentData(Feature feature, Point inputPoint) {

        this.feature = feature;

        if (!fill(feature.getDefaultGeometry(), inputPoint)) {

            this.primitive = null;

            this.projectedPoint = null;

            this.line = null;

            this.idxVertex = null;

        }

    }

    public Feature getFeature() {

        return this.feature;

    }

    public Geometry getGeometry() {

        return this.feature.getDefaultGeometry();

    }

    public Primitive getPrimitive() {

        return this.primitive;

    }

    public Point getProjectedPoint() {

        return this.projectedPoint;

    }

    public Line getLine() {

        return this.line;

    }

    public Integer getIdxVertex() {

        return this.idxVertex;

    }

    private boolean fill(Geometry geometry, Point inputPoint) {

        //            double distance = Double.POSITIVE_INFINITY;

        try {

            Iterator<Point> it; // = null;

            switch (geometry.getType()) {

                case Geometry.TYPES.LINE:

                    primitive = (Primitive) geometry;

                    break;

                case Geometry.TYPES.POLYGON:

                    primitive = (Primitive) geometry;

                    break;

                case Geometry.TYPES.MULTILINE:

                case Geometry.TYPES.MULTIPOLYGON:

                    Aggregate aggregate = (Aggregate) geometry;

                    primitive = getNearestPrimitive(aggregate, inputPoint);

                    if (primitive == null) {

                        return false;

                    }

                    break;

                default:

                    return false;

            }

            switch (primitive.getType()) {

                case Geometry.TYPES.LINE:

                    it = ((Line) primitive).iterator();

                    break;

                case Geometry.TYPES.POLYGON:

                    it = ((Polygon) primitive).iterator();

                    break;

                default:

                    return false;

            }

            projectedPoint = (Point) primitive.toLines().closestPoints(inputPoint)[0];

            Integer auxPosition = SEGMENT_POSITION_FIRST;

            Line auxLine = null;

            Line tmpLine; // = null;

            int idx = 0;

            if (it != null && it.hasNext()) {

                Point prevVertex = it.next().cloneGeometry();

                double distance = Double.POSITIVE_INFINITY;

                while (it.hasNext()) {

                    Point currentVertex = it.next().cloneGeometry();

                    tmpLine = GeometryUtils.createLine(prevVertex, currentVertex, geometry.getGeometryType().getSubType());

                    double d = tmpLine.distance(projectedPoint);

                    if (d < distance) {

                        idxVertex = idx;

                        distance = d;

                        auxLine = tmpLine;

                    }

                    prevVertex = currentVertex;

                    idx++;

                }

            }

            if (idxVertex != null) {

                line = auxLine;

                return true;

            }

        } catch (GeometryException | GeometryOperationNotSupportedException | GeometryOperationException ex) {

            //TODO:

            return false;

        }

        return false;

    }

    private int primitiveNumVertices() {

        switch (primitive.getType()) {

            case Geometry.TYPES.LINE:

                return ((Line) primitive).getNumVertices();

            case Geometry.TYPES.POLYGON:

                return ((Polygon) primitive).getNumVertices();

            default:

                return 0;

        }

    }

    private Primitive getNearestPrimitive(Aggregate aggregate, Point point) throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (aggregate == null || point == null) {

            throw new IllegalArgumentException("Parameters should not be null");

        }

        double distance = Double.POSITIVE_INFINITY;

        Primitive nearestPrimitive = null;

        for (Geometry geometry : aggregate) {

            if (geometry instanceof Aggregate) {

                return getNearestPrimitive((Aggregate) geometry, point);

            }

            Primitive prim = (Primitive) geometry;

            double d = prim.distance(point);

            if (d < distance) {

                distance = d;

                nearestPrimitive = (Primitive) prim.cloneGeometry();

            }

        }

        return nearestPrimitive;

    }

    public Integer getPosition() throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (idxVertex != null) {

            if (primitive.getType() == Geometry.TYPES.LINE && primitiveNumVertices() == 2) {

                if (((Line) primitive).getVertex(0).distance(projectedPoint) <= ((Line) primitive).getVertex(1).distance(projectedPoint)) {

                    return SEGMENT_POSITION_LAST;

                } else {

                    return SEGMENT_POSITION_FIRST;

                }

            }

            if (idxVertex == 0) {

                return SEGMENT_POSITION_FIRST;

            } else if (idxVertex >= primitiveNumVertices() - 2) {

                return SEGMENT_POSITION_LAST;

            }

            return SEGMENT_POSITION_MIDDLE;

        }

        return null;

    }

    public boolean isFilled() {

        return this.feature != null && this.primitive != null && this.projectedPoint != null && this.line != null && this.idxVertex != null;

    }

}