internal static int PolygonText(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt32 paths, com.epl.geometry.AttributeStreamOfInt8 path_flags, int total_point_count , com.epl.geometry.WktParser wkt_parser) { // At start of PolygonText int current_token = wkt_parser.CurrentToken(); if (current_token == com.epl.geometry.WktParser.WktToken.empty) { return(total_point_count); } bool b_first_line_string = true; current_token = wkt_parser.NextToken(); while (current_token != com.epl.geometry.WktParser.WktToken.right_paren) { // At start of LineStringText int point_count = LineStringText(true, zs, ms, position, paths, path_flags, wkt_parser); if (point_count != 0) { if (b_first_line_string) { b_first_line_string = false; path_flags.SetBits(path_flags.Size() - 2, unchecked ((byte)com.epl.geometry.PathFlags.enumOGCStartPolygon)); } path_flags.SetBits(path_flags.Size() - 2, unchecked ((byte)com.epl.geometry.PathFlags.enumClosed)); total_point_count += point_count; } current_token = wkt_parser.NextToken(); } return(total_point_count); }
internal override void ApplyTransformation(com.epl.geometry.Transformation3D transform) { if (IsEmpty()) { return; } _verifyAllStreams(); AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z); _verifyAllStreams(); com.epl.geometry.AttributeStreamOfDbl points = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; com.epl.geometry.AttributeStreamOfDbl zs = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[1]; com.epl.geometry.Point3D pt3 = new com.epl.geometry.Point3D(); for (int ipoint = 0; ipoint < m_pointCount; ipoint++) { pt3.x = points.Read(ipoint * 2); pt3.y = points.Read(ipoint * 2 + 1); pt3.z = zs.Read(ipoint); com.epl.geometry.Point3D res = transform.Transform(pt3); points.Write(ipoint * 2, res.x); points.Write(ipoint * 2 + 1, res.y); zs.Write(ipoint, res.z); } // REFACTOR: reset the exact envelope only and transform the loose // envelope NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates); }
public override bool Equals(com.epl.geometry.AttributeStreamBase other, int start, int end) { if (other == null) { return(false); } if (!(other is com.epl.geometry.AttributeStreamOfDbl)) { return(false); } com.epl.geometry.AttributeStreamOfDbl _other = (com.epl.geometry.AttributeStreamOfDbl)other; int size = Size(); int sizeOther = _other.Size(); if (end > size || end > sizeOther && (size != sizeOther)) { return(false); } if (end > size) { end = size; } for (int i = start; i < end; i++) { if (Read(i) != _other.Read(i)) { return(false); } } return(true); }
internal static int MultiPointText(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.WktParser wkt_parser) { // At start of MultiPointText int current_token = wkt_parser.CurrentToken(); int point_count = 0; if (current_token == com.epl.geometry.WktParser.WktToken.empty) { return(point_count); } current_token = wkt_parser.NextToken(); while (current_token != com.epl.geometry.WktParser.WktToken.right_paren) { // At start of PointText point_count += PointText(zs, ms, position, wkt_parser); if (current_token == com.epl.geometry.WktParser.WktToken.left_paren || current_token == com.epl.geometry.WktParser.WktToken.empty) { current_token = wkt_parser.NextToken(); } else { // ogc standard current_token = wkt_parser.CurrentToken(); } } // not ogc standard. // treat as // linestring return(point_count); }
// Checked vs. Jan 11, 2011 internal virtual int QueryCoordinates(com.epl.geometry.Point3D[] dst, int dstSize, int beginIndex, int endIndex) { int endIndexC = endIndex < 0 ? m_pointCount : endIndex; endIndexC = System.Math.Min(endIndexC, beginIndex + dstSize); if (beginIndex < 0 || beginIndex >= m_pointCount || endIndexC < beginIndex) { // TODO replace geometry exc throw new System.ArgumentException(); } com.epl.geometry.AttributeStreamOfDbl xy = (com.epl.geometry.AttributeStreamOfDbl)GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); com.epl.geometry.AttributeStreamOfDbl z = null; double v = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z); bool bHasZ = HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z); if (bHasZ) { z = (com.epl.geometry.AttributeStreamOfDbl)GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z); } int j = 0; for (int i = beginIndex; i < endIndexC; i++, j++) { dst[j].x = xy.Read(2 * i); dst[j].y = xy.Read(2 * i + 1); dst[j].z = bHasZ ? z.Read(i) : v; dst[j] = GetXYZ(i); } return(endIndexC); }
internal virtual com.epl.geometry.Proximity2DResult MultiVertexGetNearestVertex(com.epl.geometry.MultiVertexGeometry geom, com.epl.geometry.Point2D inputPoint) { com.epl.geometry.MultiVertexGeometryImpl mpImpl = (com.epl.geometry.MultiVertexGeometryImpl)geom._getImpl(); com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)mpImpl.GetAttributeStreamRef((com.epl.geometry.VertexDescription.Semantics.POSITION)); int pointCount = geom.GetPointCount(); int closestIndex = 0; double closestx = 0.0; double closesty = 0.0; double closestDistanceSq = com.epl.geometry.NumberUtils.DoubleMax(); for (int i = 0; i < pointCount; i++) { com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D(); position.Read(2 * i, pt); double distanceSq = com.epl.geometry.Point2D.SqrDistance(pt, inputPoint); if (distanceSq < closestDistanceSq) { closestx = pt.x; closesty = pt.y; closestIndex = i; closestDistanceSq = distanceSq; } } com.epl.geometry.Proximity2DResult result = new com.epl.geometry.Proximity2DResult(); result._setParams(closestx, closesty, closestIndex, System.Math.Sqrt(closestDistanceSq)); return(result); }
private ConvexHull(com.epl.geometry.AttributeStreamOfDbl stream, int n) { m_tree_hull = new com.epl.geometry.Treap(); m_tree_hull.SetCapacity(System.Math.Min(20, n)); m_stream = stream; m_call_back = new com.epl.geometry.ConvexHull.CallBackStream(this); }
internal static com.epl.geometry.Geometry MultiPointTaggedText(int import_flags, com.epl.geometry.WktParser wkt_parser) { com.epl.geometry.MultiPoint multi_point; com.epl.geometry.MultiPointImpl multi_point_impl; com.epl.geometry.AttributeStreamOfDbl zs = null; com.epl.geometry.AttributeStreamOfDbl ms = null; com.epl.geometry.AttributeStreamOfDbl position; position = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0); multi_point = new com.epl.geometry.MultiPoint(); multi_point_impl = (com.epl.geometry.MultiPointImpl)multi_point._getImpl(); int current_token = wkt_parser.NextToken(); if (current_token == com.epl.geometry.WktParser.WktToken.attribute_z) { zs = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN); multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z); wkt_parser.NextToken(); } else { if (current_token == com.epl.geometry.WktParser.WktToken.attribute_m) { ms = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN); multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M); wkt_parser.NextToken(); } else { if (current_token == com.epl.geometry.WktParser.WktToken.attribute_zm) { zs = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN); ms = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN); multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z); multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M); wkt_parser.NextToken(); } } } int point_count = MultiPointText(zs, ms, position, wkt_parser); if (point_count != 0) { System.Diagnostics.Debug.Assert((2 * point_count == position.Size())); multi_point_impl.Resize(point_count); multi_point_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION, position); if (zs != null) { multi_point_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z, zs); } if (ms != null) { multi_point_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M, ms); } multi_point_impl.NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyAll); } return(multi_point); }
internal static com.epl.geometry.Geometry MultiPointSymDiffPoint_(com.epl.geometry.MultiPoint multi_point, com.epl.geometry.Point point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker) { com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl()); com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)(multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION)); int point_count = multi_point.GetPointCount(); com.epl.geometry.Point2D point2D = point.GetXY(); com.epl.geometry.MultiPoint new_multipoint = (com.epl.geometry.MultiPoint)(multi_point.CreateInstance()); double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001; com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D(); multi_point.QueryEnvelope2D(env); env.Inflate(tolerance_cluster, tolerance_cluster); if (env.Contains(point2D)) { double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster; bool b_found_covered = false; bool[] covered = new bool[point_count]; for (int i = 0; i < point_count; i++) { covered[i] = false; } for (int i_1 = 0; i_1 < point_count; i_1++) { double x = position.Read(2 * i_1); double y = position.Read(2 * i_1 + 1); double dx = x - point2D.x; double dy = y - point2D.y; if (dx * dx + dy * dy <= tolerance_cluster_sq) { b_found_covered = true; covered[i_1] = true; } } if (!b_found_covered) { new_multipoint.Add(multi_point, 0, point_count); new_multipoint.Add(point); } else { for (int i_2 = 0; i_2 < point_count; i_2++) { if (!covered[i_2]) { new_multipoint.Add(multi_point, i_2, i_2 + 1); } } } } else { new_multipoint.Add(multi_point, 0, point_count); new_multipoint.Add(point); } return(new_multipoint); }
// Checked vs. Jan 11, 2011 /// <summary>\internal Updates x, y intervals.</summary> public virtual void _updateXYImpl(bool bExact) { m_envelope.SetEmpty(); com.epl.geometry.AttributeStreamOfDbl stream = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D(); for (int i = 0; i < m_pointCount; i++) { stream.Read(2 * i, pt); m_envelope.Merge(pt); } }
internal virtual void CalculateEnvelope2D(com.epl.geometry.Envelope2D env, bool bExact) { env.SetEmpty(); com.epl.geometry.AttributeStreamOfDbl stream = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D(); for (int i = 0; i < m_pointCount; i++) { stream.Read(2 * i, pt); env.Merge(pt); } }
// Mirrors wkt private static void ExportPolylineToGeoJson_(int export_flags, com.epl.geometry.Polyline polyline, com.epl.geometry.JsonWriter json_writer) { com.epl.geometry.MultiPathImpl polyline_impl = (com.epl.geometry.MultiPathImpl)polyline._getImpl(); int point_count = polyline_impl.GetPointCount(); int path_count = polyline_impl.GetPathCount(); if (point_count > 0 && path_count == 0) { throw new com.epl.geometry.GeometryException("corrupted geometry"); } int precision = 17 - (31 & (export_flags >> 13)); bool bFixedPoint = (com.epl.geometry.GeoJsonExportFlags.geoJsonExportPrecisionFixedPoint & export_flags) != 0; bool b_export_zs = polyline_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (export_flags & com.epl.geometry.GeoJsonExportFlags.geoJsonExportStripZs) == 0; bool b_export_ms = polyline_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (export_flags & com.epl.geometry.GeoJsonExportFlags.geoJsonExportStripMs) == 0; if (!b_export_zs && b_export_ms) { throw new System.ArgumentException("invalid argument"); } com.epl.geometry.AttributeStreamOfDbl position = null; com.epl.geometry.AttributeStreamOfDbl zs = null; com.epl.geometry.AttributeStreamOfDbl ms = null; com.epl.geometry.AttributeStreamOfInt8 path_flags = null; com.epl.geometry.AttributeStreamOfInt32 paths = null; if (point_count > 0) { position = (com.epl.geometry.AttributeStreamOfDbl)polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); path_flags = polyline_impl.GetPathFlagsStreamRef(); paths = polyline_impl.GetPathStreamRef(); if (b_export_zs) { if (polyline_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z)) { zs = (com.epl.geometry.AttributeStreamOfDbl)polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z); } } if (b_export_ms) { if (polyline_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M)) { ms = (com.epl.geometry.AttributeStreamOfDbl)polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M); } } } if ((export_flags & com.epl.geometry.GeoJsonExportFlags.geoJsonExportPreferMultiGeometry) == 0 && path_count <= 1) { LineStringTaggedText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, json_writer); } else { MultiLineStringTaggedText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, json_writer); } }
public override void GetXY(int index, com.epl.geometry.Point2D pt) { if (index < 0 || index >= GetPointCount()) { throw new System.IndexOutOfRangeException(); } _verifyAllStreams(); // AttributeStreamOfDbl v = (AttributeStreamOfDbl) // m_vertexAttributes[0]; com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; v.Read(index * 2, pt); }
internal static void ExportPolylineToWkt(int export_flags, com.epl.geometry.Polyline polyline, System.Text.StringBuilder @string) { com.epl.geometry.MultiPathImpl polyline_impl = (com.epl.geometry.MultiPathImpl)polyline._getImpl(); int point_count = polyline_impl.GetPointCount(); int path_count = polyline_impl.GetPathCount(); if (point_count > 0 && path_count == 0) { throw new com.epl.geometry.GeometryException("corrupted geometry"); } int precision = 17 - (7 & (export_flags >> 13)); bool b_export_zs = polyline_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (export_flags & com.epl.geometry.WktExportFlags.wktExportStripZs) == 0; bool b_export_ms = polyline_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (export_flags & com.epl.geometry.WktExportFlags.wktExportStripMs) == 0; com.epl.geometry.AttributeStreamOfDbl position = null; com.epl.geometry.AttributeStreamOfDbl zs = null; com.epl.geometry.AttributeStreamOfDbl ms = null; com.epl.geometry.AttributeStreamOfInt8 path_flags = null; com.epl.geometry.AttributeStreamOfInt32 paths = null; if (point_count > 0) { position = (com.epl.geometry.AttributeStreamOfDbl)polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); path_flags = polyline_impl.GetPathFlagsStreamRef(); paths = polyline_impl.GetPathStreamRef(); if (b_export_zs) { if (polyline_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z)) { zs = (com.epl.geometry.AttributeStreamOfDbl)(polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z)); } } if (b_export_ms) { if (polyline_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M)) { ms = (com.epl.geometry.AttributeStreamOfDbl)(polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M)); } } } if ((export_flags & com.epl.geometry.WktExportFlags.wktExportLineString) != 0) { if (path_count > 1) { throw new System.ArgumentException("Cannot export a LineString with specified export flags: " + export_flags); } LineStringTaggedText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, @string); } else { MultiLineStringTaggedText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, @string); } }
internal static void AddToStreams(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, double x, double y, double z, double m) { position.Add(x); position.Add(y); if (zs != null) { zs.Add(z); } if (ms != null) { ms.Add(m); } }
// Checked vs. Jan 11, 2011 public override void SetXY(int index, com.epl.geometry.Point2D pt) { if (index < 0 || index >= m_pointCount) { // TODO exception throw new System.IndexOutOfRangeException(); } _verifyAllStreams(); // AttributeStreamOfDbl v = (AttributeStreamOfDbl) // m_vertexAttributes[0]; com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; v.Write(index * 2, pt); NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates); }
// Checked vs. Jan 11, 2011 internal override void SetXYZ(int index, com.epl.geometry.Point3D pt) { if (index < 0 || index >= GetPointCount()) { throw new System.IndexOutOfRangeException(); } AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z); _verifyAllStreams(); NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates); com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; v.Write(index * 2, pt.x); v.Write(index * 2 + 1, pt.y); m_vertexAttributes[1].WriteAsDbl(index, pt.z); }
/// <summary>Creates a new attribute stream of given persistence type and size.</summary> /// <param name="persistence">The persistence type of the stream (see VertexDescription).</param> /// <param name="size"> /// The number of elements (floats, doubles, or 32 bit integers) /// of the given type in the stream. /// </param> /// <param name="defaultValue">The default value to fill the stream with.</param> public static com.epl.geometry.AttributeStreamBase CreateAttributeStreamWithPersistence(int persistence, int size, double defaultValue) { com.epl.geometry.AttributeStreamBase newStream; switch (persistence) { case (com.epl.geometry.VertexDescription.Persistence.enumFloat): { newStream = new com.epl.geometry.AttributeStreamOfFloat(size, (float)defaultValue); break; } case (com.epl.geometry.VertexDescription.Persistence.enumDouble): { newStream = new com.epl.geometry.AttributeStreamOfDbl(size, (double)defaultValue); break; } case (com.epl.geometry.VertexDescription.Persistence.enumInt32): { newStream = new com.epl.geometry.AttributeStreamOfInt32(size, (int)defaultValue); break; } case (com.epl.geometry.VertexDescription.Persistence.enumInt64): { newStream = new com.epl.geometry.AttributeStreamOfInt64(size, (long)defaultValue); break; } case (com.epl.geometry.VertexDescription.Persistence.enumInt8): { newStream = new com.epl.geometry.AttributeStreamOfInt8(size, unchecked ((byte)defaultValue)); break; } case (com.epl.geometry.VertexDescription.Persistence.enumInt16): { newStream = new com.epl.geometry.AttributeStreamOfInt16(size, (short)defaultValue); break; } default: { throw new com.epl.geometry.GeometryException("Internal Error"); } } return(newStream); }
public AttributeStreamOfDbl(com.epl.geometry.AttributeStreamOfDbl other, int maxSize) { m_size = other.Size(); if (m_size > maxSize) { m_size = maxSize; } int sz = m_size; if (sz < 2) { sz = 2; } m_buffer = new double[sz]; System.Array.Copy(other.m_buffer, 0, m_buffer, 0, m_size); }
internal void ShiftPath(com.epl.geometry.MultiPath inputGeom, int iPath, double shift) { com.epl.geometry.MultiVertexGeometryImpl vertexGeometryImpl = (com.epl.geometry.MultiVertexGeometryImpl)inputGeom._getImpl(); com.epl.geometry.AttributeStreamOfDbl xyStream = (com.epl.geometry.AttributeStreamOfDbl)vertexGeometryImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); int i1 = inputGeom.GetPathStart(iPath); int i2 = inputGeom.GetPathEnd(iPath); com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D(); while (i1 < i2) { xyStream.Read(i1, pt); pt.x += shift; xyStream.Write(i1, pt); i1++; } }
// Checked vs. Jan 11, 2011 public virtual void SetXY(int index, double x, double y) { if (index < 0 || index >= m_pointCount) { // TODO exc throw new System.IndexOutOfRangeException(); } _verifyAllStreams(); // AttributeStreamOfDbl v = (AttributeStreamOfDbl) // m_vertexAttributes[0]; // TODO ask sergey about casts com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; v.Write(index * 2, x); v.Write(index * 2 + 1, y); NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates); }
public override void ReplaceNaNs(int semantics, double value) { AddAttribute(semantics); if (IsEmpty()) { return; } bool modified = false; int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(semantics); for (int i = 0; i < ncomps; i++) { com.epl.geometry.AttributeStreamBase streamBase = GetAttributeStreamRef(semantics); if (streamBase is com.epl.geometry.AttributeStreamOfDbl) { com.epl.geometry.AttributeStreamOfDbl dblStream = (com.epl.geometry.AttributeStreamOfDbl)streamBase; for (int ivert = 0, n = m_pointCount * ncomps; ivert < n; ivert++) { double v = dblStream.Read(ivert); if (double.IsNaN(v)) { dblStream.Write(ivert, value); modified = true; } } } else { for (int ivert = 0, n = m_pointCount * ncomps; ivert < n; ivert++) { double v = streamBase.ReadAsDbl(ivert); if (double.IsNaN(v)) { streamBase.WriteAsDbl(ivert, value); modified = true; } } } } if (modified) { NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates); } }
internal static void ExportMultiPointToWkt(int export_flags, com.epl.geometry.MultiPoint multipoint, System.Text.StringBuilder @string) { com.epl.geometry.MultiPointImpl multipoint_impl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl(); int point_count = multipoint_impl.GetPointCount(); int precision = 17 - (7 & (export_flags >> 13)); bool b_export_zs = multipoint_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (export_flags & com.epl.geometry.WktExportFlags.wktExportStripZs) == 0; bool b_export_ms = multipoint_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (export_flags & com.epl.geometry.WktExportFlags.wktExportStripMs) == 0; com.epl.geometry.AttributeStreamOfDbl position = null; com.epl.geometry.AttributeStreamOfDbl zs = null; com.epl.geometry.AttributeStreamOfDbl ms = null; if (point_count > 0) { position = (com.epl.geometry.AttributeStreamOfDbl)(multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION)); if (b_export_zs) { if (multipoint_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z)) { zs = (com.epl.geometry.AttributeStreamOfDbl)(multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z)); } } if (b_export_ms) { if (multipoint_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M)) { ms = (com.epl.geometry.AttributeStreamOfDbl)(multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M)); } } } if ((export_flags & com.epl.geometry.WktExportFlags.wktExportPoint) != 0) { if (point_count > 1) { throw new System.ArgumentException("Cannot export a Point with specified export flags: " + export_flags); } PointTaggedTextFromMultiPoint_(precision, b_export_zs, b_export_ms, zs, ms, position, @string); } else { MultiPointTaggedText_(precision, b_export_zs, b_export_ms, zs, ms, position, point_count, @string); } }
internal static com.epl.geometry.Geometry MultiPointMinusPoint_(com.epl.geometry.MultiPoint multi_point, com.epl.geometry.Point point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker) { com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl()); com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)(multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION)); int point_count = multi_point.GetPointCount(); com.epl.geometry.Point2D point2D = point.GetXY(); com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D(); bool b_found_covered = false; bool[] covered = new bool[point_count]; for (int i = 0; i < point_count; i++) { covered[i] = false; } double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001; double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster; for (int i_1 = 0; i_1 < point_count; i_1++) { position.Read(2 * i_1, pt); double sqr_dist = com.epl.geometry.Point2D.SqrDistance(pt, point2D); if (sqr_dist <= tolerance_cluster_sq) { b_found_covered = true; covered[i_1] = true; } } if (!b_found_covered) { return(multi_point); } com.epl.geometry.MultiPoint new_multipoint = (com.epl.geometry.MultiPoint)(multi_point.CreateInstance()); for (int i_2 = 0; i_2 < point_count; i_2++) { if (!covered[i_2]) { new_multipoint.Add(multi_point, i_2, i_2 + 1); } } return(new_multipoint); }
internal static int MultiPolygonText(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt32 paths, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.WktParser wkt_parser) { // At start of MultiPolygonText int current_token = wkt_parser.CurrentToken(); int total_point_count = 0; if (current_token == com.epl.geometry.WktParser.WktToken.empty) { return(total_point_count); } current_token = wkt_parser.NextToken(); while (current_token != com.epl.geometry.WktParser.WktToken.right_paren) { // At start of PolygonText total_point_count = PolygonText(zs, ms, position, paths, path_flags, total_point_count, wkt_parser); current_token = wkt_parser.NextToken(); } return(total_point_count); }
public override void ApplyTransformation(com.epl.geometry.Transformation2D transform) { if (IsEmpty()) { return; } _verifyAllStreams(); com.epl.geometry.AttributeStreamOfDbl points = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; com.epl.geometry.Point2D pt2 = new com.epl.geometry.Point2D(); for (int ipoint = 0; ipoint < m_pointCount; ipoint++) { pt2.x = points.Read(ipoint * 2); pt2.y = points.Read(ipoint * 2 + 1); transform.Transform(pt2, pt2); points.Write(ipoint * 2, pt2.x); points.Write(ipoint * 2 + 1, pt2.y); } // REFACTOR: reset the exact envelope only and transform the loose // envelope NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates); }
internal override int QueryCoordinates(com.epl.geometry.Point2D[] dst, int dstSize, int beginIndex, int endIndex) { int endIndexC = endIndex < 0 ? m_pointCount : endIndex; endIndexC = System.Math.Min(endIndexC, beginIndex + dstSize); if (beginIndex < 0 || beginIndex >= m_pointCount || endIndexC < beginIndex || dst.Length != dstSize) { throw new System.ArgumentException(); } // GEOMTHROW(invalid_argument); com.epl.geometry.AttributeStreamOfDbl xy = (com.epl.geometry.AttributeStreamOfDbl)GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); int pointCountToRead = endIndexC - beginIndex; double[] dstArray = new double[pointCountToRead * 2]; xy.ReadRange(2 * beginIndex, pointCountToRead * 2, dstArray, 0, true); for (int i = 0; i < pointCountToRead; i++) { dst[i] = new com.epl.geometry.Point2D(dstArray[i * 2], dstArray[i * 2 + 1]); } return(endIndexC); }
internal virtual com.epl.geometry.Proximity2DResult[] MultiVertexGetNearestVertices(com.epl.geometry.MultiVertexGeometry geom, com.epl.geometry.Point2D inputPoint, double searchRadius, int maxVertexCountToReturn) { com.epl.geometry.Proximity2DResult[] resultArray; if (maxVertexCountToReturn == 0) { resultArray = new com.epl.geometry.Proximity2DResult[0]; return(resultArray); } com.epl.geometry.MultiVertexGeometryImpl mpImpl = (com.epl.geometry.MultiVertexGeometryImpl)geom._getImpl(); com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)mpImpl.GetAttributeStreamRef((com.epl.geometry.VertexDescription.Semantics.POSITION)); int pointCount = geom.GetPointCount(); System.Collections.Generic.List <com.epl.geometry.Proximity2DResult> v = new System.Collections.Generic.List <com.epl.geometry.Proximity2DResult>(maxVertexCountToReturn); int count = 0; double searchRadiusSq = searchRadius * searchRadius; for (int i = 0; i < pointCount; i++) { double x = position.Read(2 * i); double y = position.Read(2 * i + 1); double xDiff = inputPoint.x - x; double yDiff = inputPoint.y - y; double distanceSq = xDiff * xDiff + yDiff * yDiff; if (distanceSq <= searchRadiusSq) { com.epl.geometry.Proximity2DResult result = new com.epl.geometry.Proximity2DResult(); result._setParams(x, y, i, System.Math.Sqrt(distanceSq)); count++; v.Add(result); } } int vsize = v.Count; v.Sort(new com.epl.geometry.Proximity2DResultComparator()); if (maxVertexCountToReturn >= vsize) { return(v.ToArray()); } return(v.GetRange(0, maxVertexCountToReturn - 0).ToArray()); }
internal static com.epl.geometry.Geometry PointMinusMultiPoint_(com.epl.geometry.Point point, com.epl.geometry.MultiPoint multi_point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker) { com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl()); com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); int point_count = multi_point.GetPointCount(); com.epl.geometry.Point2D point2D = point.GetXY(); com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D(); double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001; double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster; for (int i = 0; i < point_count; i++) { position.Read(2 * i, pt); double sqr_dist = com.epl.geometry.Point2D.SqrDistance(pt, point2D); if (sqr_dist <= tolerance_cluster_sq) { return(point.CreateInstance()); } } // return an empty point. return(point); }
// Checked vs. Jan 11, 2011 internal override com.epl.geometry.Point3D GetXYZ(int index) { if (index < 0 || index >= GetPointCount()) { throw new System.IndexOutOfRangeException(); } _verifyAllStreams(); com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0]; com.epl.geometry.Point3D pt = new com.epl.geometry.Point3D(); pt.x = v.Read(index * 2); pt.y = v.Read(index * 2 + 1); // TODO check excluded if statement componenet if (HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z)) { // && (m_vertexAttributes[1] != null)) pt.z = m_vertexAttributes[1].ReadAsDbl(index); } else { pt.z = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z); } return(pt); }