/// <summary> /// Applies the flip filter. /// </summary> /// <remarks> /// The following calculation is performed on the Y coordinate. /// <code> /// coord.Y = (_max - coord.Y) + _min; /// </code> /// </remarks> /// <param name="geometry">The geometry object to apply the filter to.</param> public void Filter(Geometry geometry) { /*if (geometry is Polygon) { Polygon polygon = (Polygon)geometry; Filter(polygon.Shell); foreach(LinearRing linearring in polygon.Holes) { Filter(linearring); } } else*/ if (geometry is LinearRing || geometry is LineString || geometry is Point) { Coordinates coords = geometry.GetCoordinates(); for (int i=0; i < coords.Count; i++) { coords[i].Y = (_max - coords[i].Y) + _min; } } /*else if (geometry is GeometryCollection) { Filter(geometry); } else { throw new NotSupportedException(geometry.GetType().Name); } geometry.GeometryChanged();*/ }
/// <summary> /// Initializes a new instance of the BufferOp class. /// </summary> /// <param name="g0"></param> public BufferOp(Geometry g0) : base(g0) { _graph = new PlanarGraph(new OverlayNodeFactory()); _geomFact = new GeometryFactory( g0.PrecisionModel, g0.GetSRID() ); }
/// <summary> /// Given a geomtry object, returns the equilivent shape file type. /// </summary> /// <param name="geom">A Geometry object.</param> /// <returns>The equilivent for the geometry object.</returns> public static ShapeType GetShapeType(Geometry geom) { if (geom is Point) { return ShapeType.Point; } if (geom is Polygon) { return ShapeType.Polygon; } if (geom is MultiPolygon) { return ShapeType.Polygon; } if (geom is LineString) { return ShapeType.Arc; } if (geom is MultiLineString) { return ShapeType.Arc; } return ShapeType.Undefined; }
public void Filter(Geometry geom) { if (geom is Point || geom is LineString || geom is Polygon ) _pts.Add( geom.GetCoordinate() ); }
} // public static int Locate(Coordinate p, Geometry geom) private static bool ContainsPoint(Coordinate p, Geometry geom) { if( geom is Polygon ) { return ContainsPointInPolygon( p, (Polygon)geom ); } else if( geom is GeometryCollection ) { GeometryCollection gc = geom as GeometryCollection; foreach( Geometry g2 in gc ) { if ( g2 != geom ) // TODO: what is this line trying to do??? { if ( ContainsPoint( p, g2 ) ) { return true; } } } // foreach( Geometry g2 in geom ) } // else if( geom is GeometryCollection ) return false; } // private static bool ContainsPoint(Coordinate p, Geometry geom)
/// <summary> /// Constructs an Operation object. /// </summary> /// <param name="g0"></param> public GeometryGraphOperation(Geometry g0) { SetComputationPrecision( g0.PrecisionModel ); _arg = new GeometryGraph[1]; _arg[0] = new GeometryGraph(0, g0);; }
/// <summary> /// Determines the topological relationship (location) of a single point /// to a Geometry. It handles both single-element and multi-element Geometries. /// The algorithm for multi-part Geometries is more complex, since it has /// to take into account the boundaryDetermination rule. /// </summary> /// <param name="p"></param> /// <param name="geom"></param> /// <returns>Returns the location of the point relative to the input Geometry.</returns> public int Locate( Coordinate p, Geometry geom ) { if ( geom.IsEmpty() ) return Location.Exterior; if ( geom is LineString ) { return Locate( p, (LineString) geom ); } if ( geom is LinearRing ) { return Locate( p, (LinearRing) geom ); } else if ( geom is Polygon ) { return Locate( p, (Polygon) geom ); } _isIn = false; _numBoundaries = 0; ComputeLocation( p, geom ); if ( GeometryGraph.IsInBoundary( _numBoundaries ) ) { return Location.Boundary; } if ( _numBoundaries > 0 || _isIn) { return Location.Interior; } return Location.Exterior; } // public int Locate( Coordinate p, Geometry geom )
/// <summary> /// Calls the methods (property get) on the geometries that are properties of the geometry. /// </summary> /// <param name="a">The A geometry object.</param> /// <param name="arg">A string containing the name of the geometry. "A" or "B"</param> /// <param name="testToRun">The property to call.</param> private void RunGeometryPropertyTest(Geometry a, Geometry b, string arg, string testToRun) { Geotools.Geometries.Geometry c = a; if (arg == "B") { arg = "B"; c = b; } switch (testToRun) { case "numpoints": int numberOfPoints = 0; // set the name of the operation for viewing in the textbox... this._testResult.Operation = arg + ".NumPoints"; // call the property function... numberOfPoints = c.GetNumPoints(); // store the string version of the value returned for comparison later... this._testResult.PropertyTestResult = numberOfPoints.ToString(); // test for pass or failure... TestForPassFailPropertyTestResult(); break; case "dimension": int dimension = 0; // set the name of the operation for viewing in the textbox... this._testResult.Operation = arg + ".Dimension"; dimension = c.GetDimension(); // store the string version of the value returned for comparison later... this._testResult.PropertyTestResult = dimension.ToString(); // test for pass or failure... TestForPassFailPropertyTestResult(); break; } }
public static Geometry GetBuffer(Geometry g, double distance) { BufferOp gBuf = new BufferOp(g); Geometry geomBuf = gBuf.GetResultGeometry(distance); return geomBuf; }
/// <summary> /// Constructs an Operation object. /// </summary> /// <param name="g0"></param> /// <param name="g1"></param> public GeometryGraphOperation(Geometry g0, Geometry g1) { SetComputationPrecision( g0.PrecisionModel ); _arg = new GeometryGraph[2]; _arg[0] = new GeometryGraph(0, g0); _arg[1] = new GeometryGraph(1, g1); }
/// <summary> /// Converts the geometry to svg and writes the svg to a file. /// </summary> /// <param name="filename">The name of the svg file.</param> /// <param name="pm">The precision model for the geometries</param> /// <param name="a">The geometry to be written to svg.</param> public void CreateSVG(string filename, Geotools.Geometries.PrecisionModel pm, Geometry a) { GeometrySVGWriter svgWriter = new GeometrySVGWriter(pm); StreamWriter sw = new StreamWriter(filename); double minx, miny, maxx, maxy; a.Extent2D(out minx, out miny, out maxx, out maxy); sw.WriteLine(String.Format("<svg viewBox=\"{0} {1} {2} {3}\">",minx,miny,maxx,maxy*1.2)); svgWriter.Write(a,sw,"fill-rule:evenodd;","fill:ltgray;stroke:blue;stroke-width:1;fill-opacity:0.2"); sw.WriteLine("</svg>"); sw.Close(); }
/// <summary> /// Locate is the main location function. It handles both single-element /// and multi-element Geometries. The algorithm for multi-element Geometries /// is more complex, since it has to take into account the boundaryDetermination rule /// </summary> /// <param name="p"></param> /// <param name="geom"></param> /// <returns></returns> public static int Locate(Coordinate p, Geometry geom) { if ( geom.IsEmpty() ) return Location.Exterior; if ( ContainsPoint( p, geom ) ) { return Location.Interior; } return Location.Exterior; } // public static int Locate(Coordinate p, Geometry geom)
/// <summary> /// Initializes a GeometryCollection. /// </summary> /// <param name="geometries"> /// The Geometries for this GeometryCollection, or null or an /// empty array to create the empty geometry. Elements may be empty /// Geometries, but not nulls. /// </param> /// <param name="precisionModel"> /// The specification of the grid of allowable points for this GeometryCollection. /// </param> /// <param name="SRID"> /// The ID of the Spatial Reference System used by this GeometryCollection. /// </param> public GeometryCollection(Geometry[] geometries, PrecisionModel precisionModel, int SRID) : base(precisionModel,SRID) { if(geometries == null) { geometries = new Geometry[]{}; } if(HasNullElements(geometries)) { throw new ArgumentException("Geometries must not contain null elements."); } this._geometries = geometries; }
/// <summary> /// Writes three geometries to an svg file /// </summary> /// <param name="filename">The path of the svg file.</param> /// <param name="a">The A geometry</param> /// <param name="b">The B geometry</param> /// <param name="c">The C geometry</param> public void DisplayTest(string filename, Geometry a, Geometry b, Geometry c) { Geotools.Geometries.PrecisionModel pm = new Geotools.Geometries.PrecisionModel(1, 0, 0); GeometryFactory fact = new GeometryFactory(pm, 0); GeometrySVGWriter svgWriter = new GeometrySVGWriter(fact.PrecisionModel); StreamWriter sw = new StreamWriter(filename); GeometryCollection geomCollection= fact.CreateGeometryCollection(new Geometry[]{a,b,c}); double minx, miny, maxx, maxy; geomCollection.Extent2D(out minx, out miny, out maxx, out maxy); sw.WriteLine(String.Format("<svg viewBox=\"{0} {1} {2} {3}\">",minx,miny,maxx,maxy*1.2)); svgWriter.Write(a,sw,"fill-rule:evenodd;","fill:none;stroke:blue;stroke-width:1;fill-opacity:0.2"); svgWriter.Write(b,sw,"fill-rule:evenodd;","fill:none;stroke:red;stroke-width:1;fill-opacity:0.2"); svgWriter.Write(c,sw,"fill-rule:evenodd;","fill:yellow;stroke:green;stroke-width:2;fill-opacity:0.5;stroke-dasharray:2,2"); sw.WriteLine("</svg>"); sw.Close(); }
/// <summary> /// The binary write method. /// </summary> /// <param name="geometry">The geometry to be written.</param> /// <param name="bWriter">The binary writer to be used.</param> /// <param name="format">The format employed (big/little endian).</param> public BinaryWriter Write(Geometry geometry, BinaryWriter bWriter, byte format) { //Create the binary writer. _bWriter = bWriter; //Write the format. _bWriter.Write(format); //Write the type of this geometry WriteType(geometry); //Write the geometry WriteGeometry(geometry, format); return _bWriter; }
public bool HasRepeatedPoint(Geometry g) { if ( g.IsEmpty() ) return false; if (g is Point) return false; else if (g is MultiPoint) return false; // LineString also handles LinearRings else if (g is LineString) { return HasRepeatedPoint(((LineString) g).GetCoordinates() ); } else if (g is Polygon) return HasRepeatedPoint((Polygon) g); else if (g is GeometryCollection) return HasRepeatedPoint((GeometryCollection) g); else throw new NotSupportedException(g.GetType().Name); }
/// <summary> /// Runs the methods on the geometries that return a boolean property. /// </summary> /// <param name="aGeometry">the A Geometry object</param> /// <param name="bGeometry">The B geometry object</param> /// <param name="arg">A string containing the name (A or B) of the geometry to call the method on.</param> /// <param name="testToRun">The name of the test to run.</param> private void RunBooleanReturnPropertyFunction(Geometry aGeometry, Geometry bGeometry, string arg, string testToRun) { string argToRun = "A"; Geotools.Geometries.Geometry c = aGeometry; if (arg == "B") { argToRun = "B"; c = bGeometry; } _timer.Start(); switch (testToRun) { case "isempty": this._testResult.Operation = argToRun + ".IsEmpty"; this._testResult.PredicateResult = c.IsEmpty(); this._testResult.SetPredicateResultString(); TestForPassFailBooleanResult(); break; case "issimple": // set the name of the operation in the TestResult... this._testResult.Operation = argToRun + ".IsSimple"; // call the predicate on the geometry and store the result... this._testResult.PredicateResult = c.IsSimple(); // set the string value of the predicate result for comparison... this._testResult.SetPredicateResultString(); // test for pass or fail... TestForPassFailBooleanResult(); break; case "isvalid": // set the name of the operation in the TestResult... this._testResult.Operation = argToRun + ".IsValid"; // call the predicate on the geometry and store the result... this._testResult.PredicateResult = c.IsValid(); // set the string value of the predicate result for comparison... this._testResult.SetPredicateResultString(); // test for pass or fail... TestForPassFailBooleanResult(); break; } // stop the timer... _timer.Stop(); this._testResult.TestDuration = _timer.Seconds; }
/// <summary> /// Gets the convex hull for the given geometry. /// </summary> /// <param name="geometry"></param> /// <returns></returns> public Geometry GetConvexHull(Geometry geometry) { this._geometry = geometry; UniqueCoordinateArrayFilter filter = new UniqueCoordinateArrayFilter(); geometry.Apply(filter); Coordinates pts = filter.GetCoordinates(); if (pts.Count == 0) { return new GeometryCollection(new Geometry[]{}, geometry.PrecisionModel, geometry.GetSRID()); } if (pts.Count == 1) { return new Point(pts[0], geometry.PrecisionModel, geometry.GetSRID()); } if (pts.Count == 2) { return new LineString(pts, geometry.PrecisionModel, geometry.GetSRID()); } // sort points for Graham scan. Coordinates pspts; if (pts.Count > 10) { //Probably should be somewhere between 50 and 100? Coordinates rpts = Reduce(pts); pspts = PreSort(rpts); } else { pspts = PreSort(pts); } // Use Graham scan to find convex hull. Stack cHS = GrahamScan(pspts); // Convert stack to an array. Coordinates cH = ToCoordinateArray(cHS); // Convert array to linear ring. //awcreturn lineOrPolygon(cH); return LineOrPolygon(cH); }
/// <summary> /// Applies the projection to the coordinates. /// </summary> /// <param name="geometry">The geometry object to apply the filter to.</param> public void Filter(Geometry geometry) { /*if (geometry is Polygon) { Polygon polygon = (Polygon)geometry; Filter(polygon.Shell); foreach(LinearRing linearring in polygon.Holes) { Filter(linearring); } }*/ if (geometry is LinearRing || geometry is LineString || geometry is Point) { int sourceSRID = int.Parse(_coordinateTransform.SourceCS.AuthorityCode); int targetSRID = int.Parse(_coordinateTransform.TargetCS.AuthorityCode); MapProjection projection = (MapProjection)_coordinateTransform.MathTransform; Coordinates projectedCoordinates = new Coordinates(); double x=0.0; double y=0.0; Coordinate coordinate; for(int i=0; i < geometry.GetCoordinates().Count; i++) { coordinate = geometry.GetCoordinates()[i]; if (geometry.GetSRID() == sourceSRID) { projection.MetersToDegrees(coordinate.X, coordinate.Y, out x, out y); } else if (geometry.GetSRID() == targetSRID) { projection.DegreesToMeters(coordinate.X, coordinate.Y, out x, out y); } coordinate.X = x; coordinate.Y = y; } } /*else { throw new NotSupportedException(geometry.GetType().Name); }*/ }
public static Geometry Buffer(Geometry g, double distance, int quadrantSegments) { BufferOp gBuf = new BufferOp(g); Geometry geomBuf = gBuf.GetResultGeometry(distance, quadrantSegments); return geomBuf; }
private void ComputeBuffer(double distance, int quadrantSegments) { if (_makePrecise) { double scale = GetArgGeometry(0).PrecisionModel.Scale; distance *= scale; } BufferEdgeBuilder bufEdgeBuilder = new BufferEdgeBuilder(_cga, _li, distance, _makePrecise, quadrantSegments); ArrayList bufferEdgeList = bufEdgeBuilder.GetEdges(GetArgGeometry(0)); // DEBUGGING ONLY //WKTWriter wktWriter = new WKTWriter(); //Debug.println("Rings: " + wktWriter.write(toLineStrings(bufferEdgeList.iterator()))); ArrayList nodedEdges = this.NodeEdges(bufferEdgeList); //TESTING - node again to ensure edges are noded completely /* List nodedEdges2 = nodeEdges(nodedEdges); List nodedEdges3 = nodeEdges(nodedEdges2); List nodedEdges4 = nodeEdges(nodedEdges3); List nodedEdges5 = nodeEdges(nodedEdges4); List nodedEdges6 = nodeEdges(nodedEdges5); */ //for (Iterator i = nodedEdges.iterator(); i.hasNext(); ) foreach(object obj in nodedEdges) { Edge e = (Edge) obj; InsertEdge(e); } ReplaceCollapsedEdges(); // DEBUGGING ONLY //Debug.println("Noded: " + wktWriter.write(toLineStrings(edgeList.iterator()))); _graph.AddEdges(_edgeList); ArrayList subgraphList = CreateSubgraphs(); PolygonBuilder polyBuilder = new PolygonBuilder(_geomFact, _cga); BuildSubgraphs(subgraphList, polyBuilder); ArrayList resultPolyList = polyBuilder.GetPolygons(); _resultGeom = ComputeGeometry(resultPolyList); //computeBufferLine(graph); }
public bool Read() { _geometry = null; bool result= _reader.Read(); if (result) { byte[] wkb = (byte[])_reader["wkbgeometry"]; _geometry = _wkbReader.Create(wkb); } return result; }
private GeometryCollection CreateCollection4() { //this is used to prevent having to rewrite this code over & over //create a new coordinate Coordinate coordinate = new Coordinate(); //create a new point GeometryFactory gf = new GeometryFactory(_precMod, _sRID); Point point = gf.CreatePoint(coordinate); //create a new geometries array Geometry[] geom = new Geometry[10]; int c = 0; //fill with points for(int i = 9; i < 19 ; i++) { //if this isn't here the coordinates for all the points are reset every time the coordinate is reset coordinate = new Coordinate(); //make the x coordinate equal to the iterator coordinate.X = (double)i; //make the y coordinate equal to the iterator plus 10 coordinate.Y = (double)i + 10; //create a new point to put in the geometry point = gf.CreatePoint(coordinate); //put the point in the geometies geom[c] = point; c++; } //put the geometries into a geometry collection GeometryCollection geoColl = gf.CreateGeometryCollection(geom); return geoColl; }
private GeometryCollection CreateCollection3() { //create a new geometries array Geometry[] geom = new Geometry[10]; Coordinate coordinate = new Coordinate(); Coordinates coords = new Coordinates(); GeometryFactory gf = new GeometryFactory(_precMod, _sRID); Point point = gf.CreatePoint(coordinate); LineString lineString = gf.CreateLineString(coords); for(int c = 0; c < 5; c++) { for(int i = c; i < c+5; i++) { //if this isn't here the coordinates for all the points are reset every time the coordinate is reset coordinate = new Coordinate(); //make the x coordinate equal to the iterator coordinate.X = (double)i; //make the y coordinate equal to the iterator plus 10 coordinate.Y = (double)i + 10; coords.Add(coordinate); } lineString = gf.CreateLineString(coords); geom[c] = lineString; } for(int i = 5; i < 10; i++) { //if this isn't here the coordinates for all the points are reset every time the coordinate is reset coordinate = new Coordinate(); //make the x coordinate equal to the iterator coordinate.X = (double)i; //make the y coordinate equal to the iterator plus 10 coordinate.Y = (double)i + 10; //create a new point to put in the geometry point = gf.CreatePoint(coordinate); //put the point in the geometies geom[i] = point; } //put the geometries into a geometry collection GeometryCollection geoColl = gf.CreateGeometryCollection(geom); return geoColl; }
/// <summary> /// Gets the length in bytes the Geometry will need when written as a shape file record. /// </summary> /// <param name="geometry">The Geometry object to use.</param> /// <returns>The length in bytes the Geometry will use when represented as a shape file record.</returns> public abstract int GetLength(Geometry geometry); //length in 16bit words
/// <summary> /// Writes to the given stream the equilivent shape file record given a Geometry object. /// </summary> /// <param name="geometry">The geometry object to write.</param> /// <param name="file">The stream to write to.</param> /// <param name="geometryFactory">The geometry factory to use.</param> public abstract void Write(Geometry geometry, System.IO.BinaryWriter file, GeometryFactory geometryFactory);
} // public int Locate( Coordinate p, Geometry geom ) private void ComputeLocation(Coordinate p, Geometry geom) { if ( geom is LineString ) { UpdateLocationInfo( Locate( p, (LineString) geom ) ); } if ( geom is LinearRing ) { UpdateLocationInfo( Locate( p, (LinearRing) geom ) ); } else if ( geom is Polygon ) { UpdateLocationInfo( Locate( p, (Polygon) geom ) ); } else if ( geom is MultiLineString ) { MultiLineString ml = (MultiLineString) geom; for ( int i = 0; i < ml.GetNumGeometries(); i++ ) { LineString l = (LineString) ml.GetGeometryN( i ); UpdateLocationInfo( Locate( p, l ) ); } // for ( int i = 0; i < ml.NumGeometries; i++ ) } else if ( geom is MultiPolygon ) { MultiPolygon mpoly = (MultiPolygon) geom; for (int i = 0; i < mpoly.GetNumGeometries(); i++) { Polygon poly = (Polygon) mpoly.GetGeometryN( i ); UpdateLocationInfo( Locate( p, poly ) ); } // for (int i = 0; i < mpoly.NumGeometries; i++) } else if ( geom is GeometryCollection ) { GeometryCollection gc = geom as GeometryCollection; foreach( Geometry g2 in gc ) { if ( g2 != geom ) { ComputeLocation( p, g2 ); } } // foreach( Geometry g2 in gc ) } // else if ( geom is GeometryCollection ) } // private void ComputeLocation(Coordinate p, Geometry geom)
public void Filter(Geometry geom) { if (geom is LineString) _lines.Add(geom); }
public static ArrayList GetLines(Geometry geom) { ArrayList lines = new ArrayList(); geom.Apply(new LineExtracterFilter(lines)); return lines; }
private int GetNumParts(Geometry geometry) { int numParts=1; if (geometry is MultiLineString) { numParts = ((MultiLineString)geometry).Count; } return numParts; }
/// <summary> /// Writes to the given stream the equilivent shape file record given a Geometry object. /// </summary> /// <param name="geometry">The geometry object to write.</param> /// <param name="file">The stream to write to.</param> /// <param name="geometryFactory">The geometry factory to use.</param> public override void Write(Geometry geometry, System.IO.BinaryWriter file, GeometryFactory geometryFactory) { MultiLineString multi = (MultiLineString) geometry; file.Write(int.Parse(Enum.Format(typeof(ShapeType),this.ShapeType,"d"))); Envelope box = multi.GetEnvelopeInternal(); file.Write(box.MinX); file.Write(box.MinY); file.Write(box.MaxX); file.Write(box.MaxY); int numParts = multi.GetNumGeometries(); int numPoints = multi.GetNumPoints(); file.Write(numParts); file.Write(numPoints); //LineString[] lines = new LineString[numParts]; // write the offsets int offset=0; for (int i = 0; i < numParts; i++) { Geometry g = multi.GetGeometryN(i); file.Write( offset ); offset = offset + g.GetNumPoints(); } Coordinate external; for (int part = 0; part < numParts; part++) { Coordinates points = multi.GetGeometryN(part).GetCoordinates(); for (int i = 0; i < points.Count; i++) { external = geometryFactory.PrecisionModel.ToExternal(points[i]); file.Write(external.X); file.Write(external.Y); } } }
/// <summary> /// Gets the length in bytes the Geometry will need when written as a shape file record. /// </summary> /// <param name="geometry">The Geometry object to use.</param> /// <returns>The length in bytes the Geometry will use when represented as a shape file record.</returns> public override int GetLength(Geometry geometry) { int numParts=GetNumParts(geometry); return (22 + (2 * numParts) + geometry.GetNumPoints() * 8); }