/// <summary> /// Removes the common coordinate bits from a Geometry. /// The coordinates of the Geometry are changed. /// </summary> /// <param name="geom">The Geometry from which to remove the common coordinate bits.</param> /// <returns>The shifted Geometry.</returns> public virtual Geometry RemoveCommonBits(Geometry geom) { if (commonCoord.X == 0.0 && commonCoord.Y == 0.0) return geom; Coordinate invCoord = new Coordinate(commonCoord); invCoord.X = -invCoord.X; invCoord.Y = -invCoord.Y; Translater trans = new Translater(invCoord); geom.Apply(trans); geom.GeometryChanged(); return geom; }
/// <summary> /// Allows each geometry to control any custom behavior that cannot be solved with MemberwiseClone. /// The Coordinates of the geometry are already duplicated. /// </summary> /// <param name="copy"></param> protected virtual void OnCopy(Geometry copy) { }
/// <summary> /// Handles the duplication process for geometry collections /// </summary> /// <returns></returns> protected override void OnCopy(Geometry copy) { GeometryCollection gc = copy as GeometryCollection; if (gc == null) return; gc._geometries = new Geometry[_geometries.Length]; for (int i = 0; i < _geometries.Length; i++) gc._geometries[i] = (Geometry) _geometries[i].Clone(); }
/// <summary> /// /// </summary> /// <param name="parentGeometry"></param> public IsValidOp(Geometry parentGeometry) { this.parentGeometry = parentGeometry; }
/// <summary> /// Creates a copy of this Point with the same factory /// specifications and values. /// </summary> /// <returns></returns> protected override void OnCopy(Geometry copy) { base.OnCopy(copy); Point p = copy as Point; if(p != null) { p._coordinate = _coordinate.Copy(); } }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="distanceTolerance"></param> /// <returns></returns> public static IGeometry Simplify(Geometry geom, double distanceTolerance) { DouglasPeuckerSimplifier tss = new DouglasPeuckerSimplifier(geom); tss.DistanceTolerance = distanceTolerance; return tss.GetResultGeometry(); }
/// <summary> /// Computes the buffer for a point for a given buffer distance /// and accuracy of approximation. /// </summary> /// <param name="g">The point to buffer.</param> /// <param name="distance">The buffer distance.</param> /// <param name="quadrantSegments">The number of segments used to approximate a quarter circle.</param> /// <returns>The buffer of the input point.</returns> public static IGeometry Buffer(Geometry g, double distance, int quadrantSegments) { BufferOp bufOp = new BufferOp(g); bufOp.QuadrantSegments = quadrantSegments; IGeometry geomBuf = bufOp.GetResultGeometry(distance); return geomBuf; }
/// <summary> /// Sets corrent length for Byte Stream. /// </summary> /// <param name="geometry"></param> /// <returns></returns> protected virtual int SetByteStreamLength(Geometry geometry) { if (geometry is Point) return SetByteStreamLength(geometry as Point); if (geometry is LineString) return SetByteStreamLength(geometry as LineString); if (geometry is Polygon) return SetByteStreamLength(geometry as Polygon); if (geometry is MultiPoint) return SetByteStreamLength(geometry as MultiPoint); if (geometry is MultiLineString) return SetByteStreamLength(geometry as MultiLineString); if (geometry is MultiPolygon) return SetByteStreamLength(geometry as MultiPolygon); if (geometry is GeometryCollection) return SetByteStreamLength(geometry as GeometryCollection); throw new ArgumentException("ShouldNeverReachHere"); }
/// <summary> /// Advances the IDataReader to the next record. /// </summary> /// <returns>true if there are more rows; otherwise, false.</returns> public bool Read() { bool moreDbfRecords = _dbfEnumerator.MoveNext(); bool moreShpRecords = _shpEnumerator.MoveNext(); if(!moreDbfRecords) { int a = 0; a++; } if(!moreShpRecords) { int b = 0; b++; } _moreRecords = moreDbfRecords && moreShpRecords; // get current shape geometry = (Geometry)_shpEnumerator.Current; // get current dbase record _columnValues = (ArrayList)_dbfEnumerator.Current; return _moreRecords; // moreDbfRecords && moreShpRecords; }
public static IGeometry Buffer(Geometry geom, double distance) { ApplicationException originalEx = null; try { Geometry result = (Geometry)geom.Buffer(distance); return result; } catch (ApplicationException ex) { originalEx = ex; } /* * If we are here, the original op encountered a precision problem * (or some other problem). Retry the operation with * enhanced precision to see if it succeeds */ try { CommonBitsOp cbo = new CommonBitsOp(true); IGeometry resultEP = cbo.Buffer(geom, distance); // check that result is a valid point after the reshift to orginal precision if (!resultEP.IsValid) throw originalEx; return resultEP; } catch (ApplicationException) { throw originalEx; } }
/// <summary> /// Same as <c>write</c>, but with newlines and spaces to make the /// well-known text more readable. /// </summary> /// <param name="geometry">A <c>Geometry</c> to process</param> /// <param name="writer"></param> /// <returns> /// A Geometry Tagged Text string (see the OpenGIS Simple /// Features Specification), with newlines and spaces. /// </returns> public virtual void WriteFormatted(Geometry geometry, TextWriter writer) { WriteFormatted(geometry, true, writer); }
/// <summary> /// Same as <c>write</c>, but with newlines and spaces to make the /// well-known text more readable. /// </summary> /// <param name="geometry">A <c>Geometry</c> to process</param> /// <returns> /// A "Geometry Tagged Text" string (see the OpenGIS Simple /// Features Specification), with newlines and spaces. /// </returns> public virtual string WriteFormatted(Geometry geometry) { TextWriter sw = new StringWriter(); try { WriteFormatted(geometry, true, sw); } catch (IOException) { Assert.ShouldNeverReachHere(); } return sw.ToString(); }
/// <summary> /// /// </summary> /// <param name="geometry"></param> /// <param name="attributes"></param> public NTSFeature(Geometry geometry, IAttributesTable attributes) : this() { this.geometry = geometry; this.attributes = attributes; }
/// <summary> /// /// </summary> /// <param name="inputGeom"></param> public DouglasPeuckerSimplifier(Geometry inputGeom) { _inputGeom = inputGeom; }
/// <summary> /// Returns a list containing a Coordinate from each Polygon, LineString, and Point /// found inside the specified point. Thus, if the specified point is /// not a GeometryCollection, an empty list will be returned. /// </summary> public static IList GetCoordinates(Geometry geom) { IList pts = new ArrayList(); geom.Apply(new ConnectedElementPointFilter(pts)); return pts; }
/// <summary> /// Adds a Geometry to be processed. May be called multiple times. /// Any dimension of Geometry may be added; the constituent linework will be /// extracted. /// </summary> /// <param name="geometry"></param> public virtual void Add(Geometry geometry) { geometry.Apply(new AnonymousGeometryComponentFilterImpl(this)); }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <returns></returns> private bool IsSimpleLinearGeometry(Geometry geom) { if (geom.IsEmpty) return true; GeometryGraph graph = new GeometryGraph(0, geom); LineIntersector li = new RobustLineIntersector(); SegmentIntersector si = graph.ComputeSelfNodes(li, true); // if no self-intersection, must be simple if (!si.HasIntersection) return true; if (si.HasProperIntersection) return false; if (HasNonEndpointIntersection(graph)) return false; if (HasClosedEndpointIntersection(graph)) return false; return true; }
/// <summary> /// Computes the buffer of a point for a given buffer distance, /// using the given Cap Style for borders of the point. /// </summary> /// <param name="g">The point to buffer.</param> /// <param name="distance">The buffer distance.</param> /// <param name="endCapStyle">Cap Style to use for compute buffer.</param> /// <returns> The buffer of the input point.</returns> public static IGeometry Buffer(Geometry g, double distance, BufferStyles endCapStyle) { BufferOp gBuf = new BufferOp(g); gBuf.EndCapStyle = endCapStyle; IGeometry geomBuf = gBuf.GetResultGeometry(distance); return geomBuf; }
/// <summary> /// Returns a copy of this ILineString /// </summary> /// <returns>A Copy of this ILineString</returns> protected override void OnCopy(Geometry copy) { base.OnCopy(copy); LineString ls = copy as LineString; if (ls == null) return; ls.Coordinates = new List<Coordinate>(); foreach (Coordinate coordinate in _points) { ls.Coordinates.Add(coordinate); } }
/// <summary> /// /// </summary> /// <param name="reader"></param> /// <returns></returns> protected virtual IGeometry ReadGeometryCollection(BinaryReader reader) { int numGeometries = reader.ReadInt32(); IGeometry[] geometries = new Geometry[numGeometries]; for (int i = 0; i < numGeometries; i++) { ReadByteOrder(reader); WkbGeometryTypes geometryType = (WkbGeometryTypes)reader.ReadInt32(); switch (geometryType) { case WkbGeometryTypes.Point: geometries[i] = ReadPoint(reader); break; case WkbGeometryTypes.LineString: geometries[i] = ReadLineString(reader); break; case WkbGeometryTypes.Polygon: geometries[i] = ReadPolygon(reader); break; case WkbGeometryTypes.MultiPoint: geometries[i] = ReadMultiPoint(reader); break; case WkbGeometryTypes.MultiLineString: geometries[i] = ReadMultiLineString(reader); break; case WkbGeometryTypes.MultiPolygon: geometries[i] = ReadMultiPolygon(reader); break; case WkbGeometryTypes.GeometryCollection: geometries[i] = ReadGeometryCollection(reader); break; default: throw new ArgumentException("Should never reach here!"); } } return Factory.CreateGeometryCollection(geometries); }
/// <summary> /// Occurs during the copy process and ensures that the shell and holes are all duplicated and not direct references /// </summary> /// <param name="copy"></param> protected override void OnCopy(Geometry copy) { base.OnCopy(copy); Polygon poly = copy as Polygon; if (poly == null) return; poly.Shell = _shell.Copy(); poly.Holes = new ILinearRing[_holes.Length]; for (int i = 0; i < _holes.Length; i++) poly.Holes[i] = Holes[i].Copy(); }