Segmentize Class Reference

Segmentizes a LineString into segments given a segment length. More...

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)

Detailed Description

Segmentizes a LineString into segments given a segment length.

Member Function Documentation

createSegments()

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

                                                                                                                                           {
 
        //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;
    }

Referenced by Segmentize.relation().

evaluate()

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

inherited

                                                                                                            {
                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");
        }

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

Referenced by DensifyTest.testDensify(), EnsureClosedTest.testEnsureClosed(), EnsureClosedTest.testEnsureClosed2(), RemoveGeometryTest.testRemoveGeometry1(), RemoveGeometryTest.testRemoveGeometry1Z(), RemoveGeometryTest.testRemoveGeometry2(), RemoveGeometryTest.testRemoveGeometry2Z(), RemoveRepeatedPointsTest.testRemoveRepeatedPoints(), SimplifyTest.testSimplify(), and SimplifyVWTest.testSimplifyVW().

getURI()

String getURI

(

)

                               {
                return POSTGIS.st_segmentize.stringValue();
        }

References POSTGIS.st_segmentize.

relation()

Geometry relation ( Geometry  geom, Double  value  )

protected

Reimplemented from GeometricModifierDoubleFunction.

                                                                 {
        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;
 }

References Segmentize.createSegments().