Segmentize Class Reference

Inheritance diagram for Segmentize:

Collaboration diagram for Segmentize:

Public Member Functions
String	getURI ()
List< LineString >	createSegments (Geometry track, double segmentLength) throws NoSuchAuthorityCodeException, FactoryException
Value	evaluate (ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException

Protected Member Functions
Geometry	relation (Geometry geom, Double value)

Member Function Documentation

createSegments()

List<LineString> createSegments	(	Geometry	track,
		double	segmentLength
	)		throws NoSuchAuthorityCodeException, FactoryException

Referenced by Segmentize.relation().

                                                                                                                                           {

        //GeometryFactory geometryFactory = new GeometryFactory(new PrecisionModel(PrecisionModel.FLOATING));
        List<LineString> segments = new ArrayList<>();
        /*SRSInfo srsInfo = track.getSrsInfo();

        List<Coordinate> coordinates = new ArrayList<>(track.getCoordinates().length);
        Collections.addAll(coordinates, track.getCoordinates());

        double accumulatedLength = 0;
        List<Coordinate> lastSegment = new ArrayList<>();
 
        Iterator<Coordinate> itCoordinates = coordinates.iterator();

        for (int i = 0; itCoordinates.hasNext() && i < coordinates.size() - 1; i++) {
            Coordinate c1 = coordinates.get(i);
            Coordinate c2 = coordinates.get(i + 1);

            lastSegment.add(c1);

            double length;
            //Check for geographic or planar distance.
            //Does the rest of the calculation take into consideration geographic is non-linear in X/Y relationship?
            if (srsInfo.isGeographic()) {
                length = GreatCircleDistance.haversineFormula(c1, c2);
            } else {
                length = c1.distance(c2);
            }

            if (length + accumulatedLength >= segmentLength) {
                double offsetLength = segmentLength - accumulatedLength;
                double ratio = offsetLength / length;
                double dx = c2.x - c1.x;
                double dy = c2.y - c1.y;

                Coordinate segmentationPoint = new Coordinate(c1.x + (dx * ratio), c1.y + (dy * ratio));

                lastSegment.add(segmentationPoint); // Last point of the segment is the segmentation point
                segments.add(geometryFactory.createLineString(lastSegment.toArray(new Coordinate[lastSegment.size()])));

                lastSegment = new ArrayList<>(); // Resets the variable since a new segment will be built
                accumulatedLength = 0D;
                coordinates.add(i + 1, segmentationPoint);
            } else {
                accumulatedLength += length;
            }
        }

        lastSegment.add(coordinates.get(coordinates.size() - 1)); // Because the last one is never added in the loop above
        segments.add(geometryFactory.createLineString(lastSegment.toArray(new Coordinate[lastSegment.size()])));
                */
        return segments;
    }

evaluate()

Value evaluate ( ValueFactory  valueFactory, Value...  args  ) throws ValueExprEvaluationException

inherited

References LiteralRegistry.getLiteral(), and GeometricModifierDoubleFunction.relation().

                                                                                                            {
                if (args.length != 2) {
                        throw new ValueExprEvaluationException(getURI() + " requires exactly 2 arguments, got " + args.length);
                }

                LiteralType l=LiteralRegistry.getLiteral(((Literal)args[0]).getDatatype().toString());
                Double value=Double.valueOf(args[1].stringValue());
                if(l instanceof VectorLiteral) {
                        Geometry geom=((VectorLiteral)l).read(args[0].stringValue());
                        Geometry result = relation(geom,value);
                        return valueFactory.createLiteral(((VectorLiteral) l).unparse(result),((Literal)args[0]).getDatatype());
                }
                throw new ValueExprEvaluationException("Argument given is not a geometry literal");
        }

getURI()

String getURI

(

)

References POSTGIS.st_segmentize.

                               {
                return POSTGIS.st_segmentize.stringValue();
        }

relation()

Geometry relation ( Geometry  geom, Double  value  )

protected

References Segmentize.createSegments().

                                                                 {
        double segmentLength = value;

        List<LineString> linestrings;
        try {
                        linestrings = createSegments(geom, segmentLength);
                GeometryFactory fac=new GeometryFactory();
                return fac.createMultiLineString(linestrings.toArray(new LineString[0]));       
        } catch (FactoryException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        return null;
 }