private bool Initialize_() { m_envelope_handle_a = -1; m_envelope_handle_b = -1; if (m_envelopes_red.Count < 10) { m_sweep_index_red = m_envelopes_red.Count; m_function = com.epl.geometry.Envelope2DIntersectorImpl.State.sweepBruteForce; return(true); } if (m_interval_tree_red == null) { m_interval_tree_red = new com.epl.geometry.IntervalTreeImpl(true); m_sorted_end_indices_red = new com.epl.geometry.AttributeStreamOfInt32(0); } m_interval_tree_red.AddEnvelopesRef(m_envelopes_red); if (m_iterator_red == null) { m_iterator_red = m_interval_tree_red.GetIterator(); } m_sorted_end_indices_red.Reserve(2 * m_envelopes_red.Count); m_sorted_end_indices_red.Resize(0); for (int i = 0; i < 2 * m_envelopes_red.Count; i++) { m_sorted_end_indices_red.Add(i); } SortYEndIndices_(m_sorted_end_indices_red, 0, 2 * m_envelopes_red.Count, true); m_sweep_index_red = 2 * m_envelopes_red.Count; m_function = com.epl.geometry.Envelope2DIntersectorImpl.State.sweep; // overwrite initialize_ return(true); }
internal static void LineStringTaggedText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, System.Text.StringBuilder @string) { @string.Append("LINESTRING "); if (b_export_zs && b_export_ms) { @string.Append("ZM "); } else { if (b_export_zs && !b_export_ms) { @string.Append("Z "); } else { if (!b_export_zs && b_export_ms) { @string.Append("M "); } } } if (position == null) { @string.Append("EMPTY"); return; } bool b_closed = ((path_flags.Read(0) & com.epl.geometry.PathFlags.enumClosed) != 0); LineStringText_(false, b_closed, precision, b_export_zs, b_export_ms, zs, ms, position, paths, 0, @string); }
internal JsonStringWriter() { m_jsonString = new System.Text.StringBuilder(); m_functionStack = new com.epl.geometry.AttributeStreamOfInt32(0); m_functionStack.Add(com.epl.geometry.JsonWriter.State.accept); m_functionStack.Add(com.epl.geometry.JsonWriter.State.start); }
public AttributeStreamOfInt32(com.epl.geometry.AttributeStreamOfInt32 other) { // for (int i = 0; i < size; i++) // m_buffer[i] = defaultValue; m_buffer = (int[])other.m_buffer.Clone(); m_size = other.m_size; }
internal static void MultiLineStringTaggedText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags , com.epl.geometry.AttributeStreamOfInt32 paths, int path_count, System.Text.StringBuilder @string) { @string.Append("MULTILINESTRING "); if (b_export_zs && b_export_ms) { @string.Append("ZM "); } else { if (b_export_zs && !b_export_ms) { @string.Append("Z "); } else { if (!b_export_zs && b_export_ms) { @string.Append("M "); } } } if (position == null) { @string.Append("EMPTY"); return; } @string.Append('('); MultiLineStringText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, @string); @string.Append(')'); }
public override bool Equals(com.epl.geometry.AttributeStreamBase other, int start, int end) { if (other == null) { return(false); } if (!(other is com.epl.geometry.AttributeStreamOfInt32)) { return(false); } com.epl.geometry.AttributeStreamOfInt32 _other = (com.epl.geometry.AttributeStreamOfInt32)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); }
/// <summary>Creates a new attribute stream for storing vertex indices.</summary> /// <param name="size">The number of elements in the stream.</param> /// <param name="defaultValue">The default value to fill the stream with.</param> public static com.epl.geometry.AttributeStreamBase CreateIndexStream(int size, int defaultValue) { int persistence = com.epl.geometry.VertexDescription.Persistence.enumInt32; // VertexDescription.getPersistenceFromInt(NumberUtils::SizeOf((int)0)); com.epl.geometry.AttributeStreamBase newStream; switch (persistence) { 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; } default: { throw new com.epl.geometry.GeometryException("Internal Error"); } } return(newStream); }
public BucketSort() { m_buckets = new com.epl.geometry.AttributeStreamOfInt32(0); m_bucketed_indices = new com.epl.geometry.AttributeStreamOfInt32(0); m_min_value = 1; m_max_value = -1; m_dy = com.epl.geometry.NumberUtils.TheNaN; }
internal void ResetParser(string @string) { if (m_function_stack == null) { m_function_stack = new com.epl.geometry.AttributeStreamOfInt32(0); } Reset_(); m_wkt_string = @string; }
// *********** Helpers for Bucket sort************** private void SortYEndIndices_(com.epl.geometry.AttributeStreamOfInt32 end_indices, int begin_, int end_, bool b_red) { if (m_bucket_sort == null) { m_bucket_sort = new com.epl.geometry.BucketSort(); } com.epl.geometry.Envelope2DIntersectorImpl.Envelope2DBucketSortHelper sorter = new com.epl.geometry.Envelope2DIntersectorImpl.Envelope2DBucketSortHelper(this, b_red); m_bucket_sort.Sort(end_indices, begin_, end_, sorter); }
public IndexHashTable(int size, com.epl.geometry.IndexHashTable.HashFunction hashFunction) { //this is aimed to speedup the find //operation and allows to have less buckets. // Create hash table. size is the bin count in the table. The hashFunction // is the function to use. m_hashBuckets = new com.epl.geometry.AttributeStreamOfInt32(size, NullNode()); m_lists = new com.epl.geometry.IndexMultiList(); m_hash = hashFunction; m_bit_filter = new int[(size * 10 + 31) >> 5]; }
// 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); } }
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); } }
// Mirrors wkt private static void MultiLineStringText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, int path_count, com.epl.geometry.JsonWriter json_writer) { bool b_closed = ((path_flags.Read(0) & com.epl.geometry.PathFlags.enumClosed) != 0); LineStringText_(false, b_closed, precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, 0, paths.Read(1), json_writer); for (int path = 1; path < path_count; path++) { b_closed = ((path_flags.Read(path) & com.epl.geometry.PathFlags.enumClosed) != 0); int istart = paths.Read(path); int iend = paths.Read(path + 1); LineStringText_(false, b_closed, precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, istart, iend, json_writer); } }
internal virtual void StartRedConstruction() { Reset_(); m_b_add_red = true; if (m_envelopes_red == null) { m_elements_red = new com.epl.geometry.AttributeStreamOfInt32(0); m_envelopes_red = new System.Collections.Generic.List <com.epl.geometry.Envelope2D>(0); } else { m_elements_red.ResizePreserveCapacity(0); m_envelopes_red.Clear(); } }
/// <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 AttributeStreamOfInt32(com.epl.geometry.AttributeStreamOfInt32 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 int[sz]; System.Array.Copy(other.m_buffer, 0, m_buffer, 0, m_size); }
// Mirrors wkt private static void LineStringTaggedText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, com.epl.geometry.JsonWriter json_writer) { json_writer.AddFieldName("type"); json_writer.AddValueString("LineString"); json_writer.AddFieldName("coordinates"); if (position == null) { json_writer.StartArray(); json_writer.EndArray(); return; } bool b_closed = ((path_flags.Read(0) & com.epl.geometry.PathFlags.enumClosed) != 0); LineStringText_(false, b_closed, precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, 0, paths.Read(1), json_writer); }
// Mirrors wkt private static void MultiLineStringTaggedText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, int path_count, com.epl.geometry.JsonWriter json_writer) { json_writer.AddFieldName("type"); json_writer.AddValueString("MultiLineString"); json_writer.AddFieldName("coordinates"); if (position == null) { json_writer.StartArray(); json_writer.EndArray(); return; } json_writer.StartArray(); MultiLineStringText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, json_writer); json_writer.EndArray(); }
internal virtual void ProcessBunchForRingOrientationRemoveEdges_(com.epl.geometry.AttributeStreamOfInt32 bunch) { // remove all nodes that go out of scope for (int i = 0, n = bunch.Size(); i < n; i++) { int vertex = bunch.Get(i); int node1 = m_shape.GetUserIndex(vertex, m_node_1_user_index); int node2 = m_shape.GetUserIndex(vertex, m_node_2_user_index); if (node1 != -1) { int edge = m_AET.GetElement(node1); m_edges.FreeEdge(edge); m_shape.SetUserIndex(vertex, m_node_1_user_index, -1); } if (node2 != -1) { int edge = m_AET.GetElement(node2); m_edges.FreeEdge(edge); m_shape.SetUserIndex(vertex, m_node_2_user_index, -1); } int reused_node = -1; if (node1 != -1 && node2 != -1) { // terminating vertex m_AET.DeleteNode(node1, -1); m_AET.DeleteNode(node2, -1); bunch.Set(i, -1); } else { reused_node = node1 != -1 ? node1 : node2; } if (reused_node != -1) { // this vertex is a part of vertical chain. // Sorted order in AET did not change, so // reuse the AET node. if (!InsertEdge_(vertex, reused_node)) { m_AET.DeleteNode(reused_node, -1); } // horizontal edge was not // inserted bunch.Set(i, -1); } } }
// Mirrors wkt private static void MultiPolygonText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, int polygon_count, int path_count, com.epl.geometry.JsonWriter json_writer) { int polygon_start = 0; int polygon_end = 1; while (polygon_end < path_count && ((int)path_flags.Read(polygon_end) & com.epl.geometry.PathFlags.enumOGCStartPolygon) == 0) { polygon_end++; } PolygonText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, paths, polygon_start, polygon_end, json_writer); for (int ipolygon = 1; ipolygon < polygon_count; ipolygon++) { polygon_start = polygon_end; polygon_end++; while (polygon_end < path_count && ((int)path_flags.Read(polygon_end) & com.epl.geometry.PathFlags.enumOGCStartPolygon) == 0) { polygon_end++; } PolygonText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, paths, polygon_start, polygon_end, json_writer); } }
private bool InitializeBlue_() { m_envelope_handle_a = -1; m_envelope_handle_b = -1; if (m_envelopes_red.Count < 10 || m_envelopes_blue.Count < 10) { m_sweep_index_red = m_envelopes_red.Count; m_function = com.epl.geometry.Envelope2DIntersectorImpl.State.sweepRedBlueBruteForce; return(true); } if (m_interval_tree_blue == null) { m_interval_tree_blue = new com.epl.geometry.IntervalTreeImpl(true); m_sorted_end_indices_blue = new com.epl.geometry.AttributeStreamOfInt32(0); } m_interval_tree_blue.AddEnvelopesRef(m_envelopes_blue); if (m_iterator_blue == null) { m_iterator_blue = m_interval_tree_blue.GetIterator(); } m_sorted_end_indices_blue.Reserve(2 * m_envelopes_blue.Count); m_sorted_end_indices_blue.Resize(0); for (int i = 0; i < 2 * m_envelopes_blue.Count; i++) { m_sorted_end_indices_blue.Add(i); } SortYEndIndices_(m_sorted_end_indices_blue, 0, m_sorted_end_indices_blue.Size(), false); m_sweep_index_blue = m_sorted_end_indices_blue.Size(); if (m_queued_list_blue != -1) { m_queued_envelopes.DeleteList(m_queued_list_blue); m_queued_indices_blue.Resize(0); m_queued_list_blue = -1; } m_function = com.epl.geometry.Envelope2DIntersectorImpl.State.sweepRedBlue; // overwrite initialize_ return(ResetRed_()); }
internal int NewEdge(int vertex) { if (m_first_free != -1) { int index = m_first_free; m_first_free = m_end_1_nodes.Get(index); m_end_1_nodes.Set(index, vertex); m_end_2_nodes.Set(index, m_shape.GetNextVertex(vertex)); return(index); } else { if (m_end_1_nodes == null) { m_end_1_nodes = new com.epl.geometry.AttributeStreamOfInt32(0); m_end_2_nodes = new com.epl.geometry.AttributeStreamOfInt32(0); } } int index_1 = m_end_1_nodes.Size(); m_end_1_nodes.Add(vertex); m_end_2_nodes.Add(m_shape.GetNextVertex(vertex)); return(index_1); }
public static void CompareGeometryContent(com.epl.geometry.MultiVertexGeometry geom1, com.epl.geometry.MultiVertexGeometry geom2) { // Geometry types NUnit.Framework.Assert.IsTrue(geom1.GetType().Value() == geom2.GetType().Value()); // Envelopes com.epl.geometry.Envelope2D env1 = new com.epl.geometry.Envelope2D(); geom1.QueryEnvelope2D(env1); com.epl.geometry.Envelope2D env2 = new com.epl.geometry.Envelope2D(); geom2.QueryEnvelope2D(env2); NUnit.Framework.Assert.IsTrue(env1.xmin == env2.xmin && env1.xmax == env2.xmax && env1.ymin == env2.ymin && env1.ymax == env2.ymax); int type = geom1.GetType().Value(); if (type == com.epl.geometry.Geometry.GeometryType.Polyline || type == com.epl.geometry.Geometry.GeometryType.Polygon) { // Part Count int partCount1 = ((com.epl.geometry.MultiPath)geom1).GetPathCount(); int partCount2 = ((com.epl.geometry.MultiPath)geom2).GetPathCount(); NUnit.Framework.Assert.IsTrue(partCount1 == partCount2); // Part indices for (int i = 0; i < partCount1; i++) { int start1 = ((com.epl.geometry.MultiPath)geom1).GetPathStart(i); int start2 = ((com.epl.geometry.MultiPath)geom2).GetPathStart(i); NUnit.Framework.Assert.IsTrue(start1 == start2); int end1 = ((com.epl.geometry.MultiPath)geom1).GetPathEnd(i); int end2 = ((com.epl.geometry.MultiPath)geom2).GetPathEnd(i); NUnit.Framework.Assert.IsTrue(end1 == end2); } } // Point count int pointCount1 = geom1.GetPointCount(); int pointCount2 = geom2.GetPointCount(); NUnit.Framework.Assert.IsTrue(pointCount1 == pointCount2); if (type == com.epl.geometry.Geometry.GeometryType.MultiPoint || type == com.epl.geometry.Geometry.GeometryType.Polyline || type == com.epl.geometry.Geometry.GeometryType.Polygon) { // POSITION com.epl.geometry.AttributeStreamBase positionStream1 = ((com.epl.geometry.MultiVertexGeometryImpl)geom1._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); com.epl.geometry.AttributeStreamOfDbl position1 = (com.epl.geometry.AttributeStreamOfDbl)(positionStream1); com.epl.geometry.AttributeStreamBase positionStream2 = ((com.epl.geometry.MultiVertexGeometryImpl)geom2._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); com.epl.geometry.AttributeStreamOfDbl position2 = (com.epl.geometry.AttributeStreamOfDbl)(positionStream2); for (int i = 0; i < pointCount1; i++) { double x1 = position1.Read(2 * i); double x2 = position2.Read(2 * i); NUnit.Framework.Assert.IsTrue(x1 == x2); double y1 = position1.Read(2 * i + 1); double y2 = position2.Read(2 * i + 1); NUnit.Framework.Assert.IsTrue(y1 == y2); } // Zs bool bHasZs1 = geom1.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z); bool bHasZs2 = geom2.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z); NUnit.Framework.Assert.IsTrue(bHasZs1 == bHasZs2); if (bHasZs1) { com.epl.geometry.AttributeStreamBase zStream1 = ((com.epl.geometry.MultiVertexGeometryImpl)geom1._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z); com.epl.geometry.AttributeStreamOfDbl zs1 = (com.epl.geometry.AttributeStreamOfDbl)(zStream1); com.epl.geometry.AttributeStreamBase zStream2 = ((com.epl.geometry.MultiVertexGeometryImpl)geom2._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z); com.epl.geometry.AttributeStreamOfDbl zs2 = (com.epl.geometry.AttributeStreamOfDbl)(zStream2); for (int i_1 = 0; i_1 < pointCount1; i_1++) { double z1 = zs1.Read(i_1); double z2 = zs2.Read(i_1); NUnit.Framework.Assert.IsTrue(z1 == z2); } } // Ms bool bHasMs1 = geom1.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M); bool bHasMs2 = geom2.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M); NUnit.Framework.Assert.IsTrue(bHasMs1 == bHasMs2); if (bHasMs1) { com.epl.geometry.AttributeStreamBase mStream1 = ((com.epl.geometry.MultiVertexGeometryImpl)geom1._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M); com.epl.geometry.AttributeStreamOfDbl ms1 = (com.epl.geometry.AttributeStreamOfDbl)(mStream1); com.epl.geometry.AttributeStreamBase mStream2 = ((com.epl.geometry.MultiVertexGeometryImpl)geom2._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M); com.epl.geometry.AttributeStreamOfDbl ms2 = (com.epl.geometry.AttributeStreamOfDbl)(mStream2); for (int i_1 = 0; i_1 < pointCount1; i_1++) { double m1 = ms1.Read(i_1); double m2 = ms2.Read(i_1); NUnit.Framework.Assert.IsTrue(m1 == m2); } } // IDs bool bHasIDs1 = geom1.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID); bool bHasIDs2 = geom2.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID); NUnit.Framework.Assert.IsTrue(bHasIDs1 == bHasIDs2); if (bHasIDs1) { com.epl.geometry.AttributeStreamBase idStream1 = ((com.epl.geometry.MultiVertexGeometryImpl)geom1._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.ID); com.epl.geometry.AttributeStreamOfInt32 ids1 = (com.epl.geometry.AttributeStreamOfInt32)(idStream1); com.epl.geometry.AttributeStreamBase idStream2 = ((com.epl.geometry.MultiVertexGeometryImpl)geom2._getImpl()).GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.ID); com.epl.geometry.AttributeStreamOfInt32 ids2 = (com.epl.geometry.AttributeStreamOfInt32)(idStream2); for (int i_1 = 0; i_1 < pointCount1; i_1++) { int id1 = ids1.Read(i_1); int id2 = ids2.Read(i_1); NUnit.Framework.Assert.IsTrue(id1 == id2); } } } }
// no cuts private void Generate_polygon_cuts_() { com.epl.geometry.AttributeStreamOfInt32 cutHandles = new com.epl.geometry.AttributeStreamOfInt32(0); com.epl.geometry.EditShape shape = new com.epl.geometry.EditShape(); int sideIndex = shape.CreateGeometryUserIndex(); int cutteeHandle = shape.AddGeometry(m_cuttee); int cutterHandle = shape.AddGeometry(m_cutter); com.epl.geometry.TopologicalOperations topoOp = new com.epl.geometry.TopologicalOperations(); try { topoOp.SetEditShapeCrackAndCluster(shape, m_tolerance, m_progressTracker); topoOp.Cut(sideIndex, cutteeHandle, cutterHandle, cutHandles); com.epl.geometry.Polygon cutteeRemainder = (com.epl.geometry.Polygon)shape.GetGeometry(cutteeHandle); com.epl.geometry.MultiPath left = new com.epl.geometry.Polygon(); com.epl.geometry.MultiPath right = new com.epl.geometry.Polygon(); m_cuts.Clear(); m_cuts.Add(left); m_cuts.Add(right); for (int icutIndex = 0; icutIndex < cutHandles.Size(); icutIndex++) { com.epl.geometry.Geometry cutGeometry; { // intersection com.epl.geometry.EditShape shapeIntersect = new com.epl.geometry.EditShape(); int geometryA = shapeIntersect.AddGeometry(cutteeRemainder); int geometryB = shapeIntersect.AddGeometry(shape.GetGeometry(cutHandles.Get(icutIndex))); topoOp.SetEditShape(shapeIntersect, m_progressTracker); int intersectHandle = topoOp.Intersection(geometryA, geometryB); cutGeometry = shapeIntersect.GetGeometry(intersectHandle); if (cutGeometry.IsEmpty()) { continue; } int side = shape.GetGeometryUserIndex(cutHandles.Get(icutIndex), sideIndex); if (side == 2) { left.Add((com.epl.geometry.MultiPath)cutGeometry, false); } else { if (side == 1) { right.Add((com.epl.geometry.MultiPath)cutGeometry, false); } else { m_cuts.Add((com.epl.geometry.MultiPath)cutGeometry); } } } { // Undefined // difference com.epl.geometry.EditShape shapeDifference = new com.epl.geometry.EditShape(); int geometryA = shapeDifference.AddGeometry(cutteeRemainder); int geometryB = shapeDifference.AddGeometry(shape.GetGeometry(cutHandles.Get(icutIndex))); topoOp.SetEditShape(shapeDifference, m_progressTracker); cutteeRemainder = (com.epl.geometry.Polygon)shapeDifference.GetGeometry(topoOp.Difference(geometryA, geometryB)); } } if (!cutteeRemainder.IsEmpty() && cutHandles.Size() > 0) { m_cuts.Add((com.epl.geometry.MultiPath)cutteeRemainder); } if (left.IsEmpty() && right.IsEmpty()) { m_cuts.Clear(); } } finally { // no cuts topoOp.RemoveShape(); } }
/// <summary>Executes sort on the Bucket_sort.</summary> /// <remarks> /// Executes sort on the Bucket_sort. The result is fed into the indices /// array in the range between begin (inclusive) and end (exclusive). Uses /// user supplied sorter to execute sort on each bucket. Users either supply /// the sorter and use this method of Bucket_sort class, or use other methods /// to form the buckets and take care of bucket sorting themselves. /// </remarks> public void Sort(com.epl.geometry.AttributeStreamOfInt32 indices, int begin, int end, com.epl.geometry.ClassicSort sorter) { if (end - begin < 32) { sorter.UserSort(begin, end, indices); return; } bool b_fallback = true; try { double miny = com.epl.geometry.NumberUtils.PositiveInf(); double maxy = com.epl.geometry.NumberUtils.NegativeInf(); for (int i = begin; i < end; i++) { double y = sorter.GetValue(indices.Get(i)); if (y < miny) { miny = y; } if (y > maxy) { maxy = y; } } if (Reset(end - begin, miny, maxy, end - begin)) { for (int i_1 = begin; i_1 < end; i_1++) { int vertex = indices.Get(i_1); double y = sorter.GetValue(vertex); int bucket = GetBucket(y); m_buckets.Set(bucket, m_buckets.Get(bucket) + 1); // counting // values // in a // bucket. m_bucketed_indices.Write(i_1 - begin, vertex); } // Recalculate buckets to contain start positions of buckets. int c = m_buckets.Get(0); m_buckets.Set(0, 0); for (int i_2 = 1, n = m_buckets.Size(); i_2 < n; i_2++) { int b = m_buckets.Get(i_2); m_buckets.Set(i_2, c); c += b; } for (int i_3 = begin; i_3 < end; i_3++) { int vertex = m_bucketed_indices.Read(i_3 - begin); double y = sorter.GetValue(vertex); int bucket = GetBucket(y); int bucket_index = m_buckets.Get(bucket); indices.Set(bucket_index + begin, vertex); m_buckets.Set(bucket, bucket_index + 1); } b_fallback = false; } } catch (System.Exception) { m_buckets.Resize(0); m_bucketed_indices.Resize(0); } if (b_fallback) { sorter.UserSort(begin, end, indices); return; } int j = 0; for (int i_4 = 0, n = m_buckets.Size(); i_4 < n; i_4++) { int j0 = j; j = m_buckets.Get(i_4); if (j > j0) { sorter.UserSort(begin + j0, begin + j, indices); } } System.Diagnostics.Debug.Assert((j == end)); if (GetBucketCount() > 100) { // some heuristics to preserve memory m_buckets.Resize(0); m_bucketed_indices.Resize(0); } }
private static int ExportMultiPathToESRIShape(bool bPolygon, int exportFlags, com.epl.geometry.MultiPath multipath, System.IO.BinaryWriter shapeBuffer) { com.epl.geometry.MultiPathImpl multipathImpl = (com.epl.geometry.MultiPathImpl)multipath._getImpl(); bool bExportZs = multipathImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripZs) == 0; bool bExportMs = multipathImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripMs) == 0; bool bExportIDs = multipathImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripIDs) == 0; bool bHasCurves = multipathImpl.HasNonLinearSegments(); bool bArcViewNaNs = (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportTrueNaNs) == 0; int partCount = multipathImpl.GetPathCount(); int pointCount = multipathImpl.GetPointCount(); if (!bPolygon) { for (int ipart = 0; ipart < partCount; ipart++) { if (multipath.IsClosedPath(ipart)) { pointCount++; } } } else { pointCount += partCount; } int size = (4) + (4 * 8) + (4) + (4) + (partCount * 4) + pointCount * 2 * 8; /* type */ /* envelope */ /* part count */ /* point count */ /* start indices */ /* xy coordinates */ if (bExportZs) { size += (2 * 8) + (pointCount * 8); } /* min max */ /* zs */ if (bExportMs) { size += (2 * 8) + (pointCount * 8); } /* min max */ /* ms */ if (bExportIDs) { size += pointCount * 4; } /* ids */ if (bHasCurves) { } // to-do: curves if (size >= com.epl.geometry.NumberUtils.IntMax()) { throw new com.epl.geometry.GeometryException("invalid call"); } if (shapeBuffer == null) { return(size); } else { if (((System.IO.MemoryStream)shapeBuffer.BaseStream).Capacity < size) { throw new com.epl.geometry.GeometryException("buffer is too small"); } } int offset = 0; // Determine the shape type int type; if (!bExportZs && !bExportMs) { if (bExportIDs || bHasCurves) { type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline; if (bExportIDs) { type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs; } if (bHasCurves) { type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves; } } else { type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygon : com.epl.geometry.ShapeType.ShapePolyline; } } else { if (bExportZs && !bExportMs) { if (bExportIDs || bHasCurves) { type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline; type |= com.epl.geometry.ShapeModifiers.ShapeHasZs; if (bExportIDs) { type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs; } if (bHasCurves) { type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves; } } else { type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygonZ : com.epl.geometry.ShapeType.ShapePolylineZ; } } else { if (bExportMs && !bExportZs) { if (bExportIDs || bHasCurves) { type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline; type |= com.epl.geometry.ShapeModifiers.ShapeHasMs; if (bExportIDs) { type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs; } if (bHasCurves) { type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves; } } else { type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygonM : com.epl.geometry.ShapeType.ShapePolylineM; } } else { if (bExportIDs || bHasCurves) { type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline; type |= com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasMs; if (bExportIDs) { type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs; } if (bHasCurves) { type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves; } } else { type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygonZM : com.epl.geometry.ShapeType.ShapePolylineZM; } } } } // write type shapeBuffer.Write(type); offset += 4; // write Envelope com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D(); multipathImpl.QueryEnvelope2D(env); // calls _VerifyAllStreams shapeBuffer.Write(env.xmin); offset += 8; shapeBuffer.Write(env.ymin); offset += 8; shapeBuffer.Write(env.xmax); offset += 8; shapeBuffer.Write(env.ymax); offset += 8; // write part count shapeBuffer.Write(partCount); offset += 4; // to-do: return error if larger than 2^32 - 1 // write pointCount shapeBuffer.Write(pointCount); offset += 4; // write start indices for each part int pointIndexDelta = 0; for (int ipart = 0; ipart < partCount; ipart++) { int istart = multipathImpl.GetPathStart(ipart) + pointIndexDelta; shapeBuffer.Write(istart); offset += 4; if (bPolygon || multipathImpl.IsClosedPath(ipart)) { pointIndexDelta++; } } if (pointCount > 0) { // write xy coordinates com.epl.geometry.AttributeStreamBase positionStream = multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)positionStream; for (int ipart = 0; ipart < partCount; ipart++) { int partStart = multipathImpl.GetPathStart(ipart); int partEnd = multipathImpl.GetPathEnd(ipart); for (int i = partStart; i < partEnd; i++) { double x = position.Read(2 * i); double y = position.Read(2 * i + 1); shapeBuffer.Write(x); offset += 8; shapeBuffer.Write(y); offset += 8; } // If the part is closed, then we need to duplicate the start // point if (bPolygon || multipathImpl.IsClosedPath(ipart)) { double x = position.Read(2 * partStart); double y = position.Read(2 * partStart + 1); shapeBuffer.Write(x); offset += 8; shapeBuffer.Write(y); offset += 8; } } } // write Zs if (bExportZs) { com.epl.geometry.Envelope1D zInterval = multipathImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmin) : zInterval.vmin); offset += 8; shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmax) : zInterval.vmax); offset += 8; if (pointCount > 0) { if (multipathImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z)) { com.epl.geometry.AttributeStreamOfDbl zs = (com.epl.geometry.AttributeStreamOfDbl)multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z); for (int ipart = 0; ipart < partCount; ipart++) { int partStart = multipathImpl.GetPathStart(ipart); int partEnd = multipathImpl.GetPathEnd(ipart); for (int i = partStart; i < partEnd; i++) { double z = zs.Read(i); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(z) : z); offset += 8; } // If the part is closed, then we need to duplicate the // start z if (bPolygon || multipathImpl.IsClosedPath(ipart)) { double z = zs.Read(partStart); shapeBuffer.Write(z); offset += 8; } } } else { double z = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z); if (bArcViewNaNs) { z = com.epl.geometry.Interop.TranslateToAVNaN(z); } for (int i = 0; i < pointCount; i++) { shapeBuffer.Write(z); } offset += 8; } } } // write Ms if (bExportMs) { com.epl.geometry.Envelope1D mInterval = multipathImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.M, 0); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmin) : mInterval.vmin); offset += 8; shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmax) : mInterval.vmax); offset += 8; if (pointCount > 0) { if (multipathImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M)) { com.epl.geometry.AttributeStreamOfDbl ms = (com.epl.geometry.AttributeStreamOfDbl)multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M); for (int ipart = 0; ipart < partCount; ipart++) { int partStart = multipathImpl.GetPathStart(ipart); int partEnd = multipathImpl.GetPathEnd(ipart); for (int i = partStart; i < partEnd; i++) { double m = ms.Read(i); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(m) : m); offset += 8; } // If the part is closed, then we need to duplicate the // start m if (bPolygon || multipathImpl.IsClosedPath(ipart)) { double m = ms.Read(partStart); shapeBuffer.Write(m); offset += 8; } } } else { double m = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.M); if (bArcViewNaNs) { m = com.epl.geometry.Interop.TranslateToAVNaN(m); } for (int i = 0; i < pointCount; i++) { shapeBuffer.Write(m); } offset += 8; } } } // write Curves if (bHasCurves) { } // to-do: We'll finish this later // write IDs if (bExportIDs) { if (pointCount > 0) { if (multipathImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.ID)) { com.epl.geometry.AttributeStreamOfInt32 ids = (com.epl.geometry.AttributeStreamOfInt32)multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.ID); for (int ipart = 0; ipart < partCount; ipart++) { int partStart = multipathImpl.GetPathStart(ipart); int partEnd = multipathImpl.GetPathEnd(ipart); for (int i = partStart; i < partEnd; i++) { int id = ids.Read(i); shapeBuffer.Write(id); offset += 4; } // If the part is closed, then we need to duplicate the // start id if (bPolygon || multipathImpl.IsClosedPath(ipart)) { int id = ids.Read(partStart); shapeBuffer.Write(id); offset += 4; } } } else { int id = (int)com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.ID); for (int i = 0; i < pointCount; i++) { shapeBuffer.Write(id); } offset += 4; } } } return(offset); }
private static int ExportMultiPointToESRIShape(int exportFlags, com.epl.geometry.MultiPoint multipoint, System.IO.BinaryWriter shapeBuffer) { com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl(); bool bExportZs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripZs) == 0; bool bExportMs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripMs) == 0; bool bExportIDs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripIDs) == 0; bool bArcViewNaNs = (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportTrueNaNs) == 0; int pointCount = multipointImpl.GetPointCount(); int size = (4) + (4 * 8) + (4) + (pointCount * 2 * 8); /* type */ /* envelope */ /* point count */ /* xy coordinates */ if (bExportZs) { size += (2 * 8) + (pointCount * 8); } /* min max */ /* zs */ if (bExportMs) { size += (2 * 8) + (pointCount * 8); } /* min max */ /* ms */ if (bExportIDs) { size += pointCount * 4; } /* ids */ if (size >= com.epl.geometry.NumberUtils.IntMax()) { throw new com.epl.geometry.GeometryException("invalid call"); } if (shapeBuffer == null) { return(size); } else { if (((System.IO.MemoryStream)shapeBuffer.BaseStream).Capacity < size) { throw new com.epl.geometry.GeometryException("buffer is too small"); } } int type; // Determine the shape type if (!bExportZs && !bExportMs) { if (bExportIDs) { type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasIDs; } else { type = com.epl.geometry.ShapeType.ShapeMultiPoint; } } else { if (bExportZs && !bExportMs) { if (bExportIDs) { type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasIDs; } else { type = com.epl.geometry.ShapeType.ShapeMultiPointZ; } } else { if (bExportMs && !bExportZs) { if (bExportIDs) { type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasMs | com.epl.geometry.ShapeModifiers.ShapeHasIDs; } else { type = com.epl.geometry.ShapeType.ShapeMultiPointM; } } else { if (bExportIDs) { type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasMs | com.epl.geometry.ShapeModifiers.ShapeHasIDs; } else { type = com.epl.geometry.ShapeType.ShapeMultiPointZM; } } } } // write type int offset = 0; shapeBuffer.Write(type); offset += 4; // write Envelope com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D(); multipointImpl.QueryEnvelope2D(env); // calls _VerifyAllStreams shapeBuffer.Write(env.xmin); offset += 8; shapeBuffer.Write(env.ymin); offset += 8; shapeBuffer.Write(env.xmax); offset += 8; shapeBuffer.Write(env.ymax); offset += 8; // write point count shapeBuffer.Write(pointCount); offset += 4; if (pointCount > 0) { // write xy coordinates com.epl.geometry.AttributeStreamBase positionStream = multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION); com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)positionStream; for (int i = 0; i < pointCount; i++) { double x = position.Read(2 * i); double y = position.Read(2 * i + 1); shapeBuffer.Write(x); offset += 8; shapeBuffer.Write(y); offset += 8; } } // write Zs if (bExportZs) { com.epl.geometry.Envelope1D zInterval = multipointImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmin) : zInterval.vmin); offset += 8; shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmax) : zInterval.vmax); offset += 8; if (pointCount > 0) { if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z)) { com.epl.geometry.AttributeStreamOfDbl zs = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z); for (int i = 0; i < pointCount; i++) { double z = zs.Read(i); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(z) : z); offset += 8; } } else { double z = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z); if (bArcViewNaNs) { z = com.epl.geometry.Interop.TranslateToAVNaN(z); } // Can we write a function that writes all these values at // once instead of doing a for loop? for (int i = 0; i < pointCount; i++) { shapeBuffer.Write(z); } offset += 8; } } } // write Ms if (bExportMs) { com.epl.geometry.Envelope1D mInterval = multipointImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.M, 0); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmin) : mInterval.vmin); offset += 8; shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmax) : mInterval.vmax); offset += 8; if (pointCount > 0) { if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M)) { com.epl.geometry.AttributeStreamOfDbl ms = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M); for (int i = 0; i < pointCount; i++) { double m = ms.Read(i); shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(m) : m); offset += 8; } } else { double m = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.M); if (bArcViewNaNs) { m = com.epl.geometry.Interop.TranslateToAVNaN(m); } for (int i = 0; i < pointCount; i++) { shapeBuffer.Write(m); } offset += 8; } } } // write IDs if (bExportIDs) { if (pointCount > 0) { if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.ID)) { com.epl.geometry.AttributeStreamOfInt32 ids = (com.epl.geometry.AttributeStreamOfInt32)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.ID); for (int i = 0; i < pointCount; i++) { int id = ids.Read(i); shapeBuffer.Write(id); offset += 4; } } else { int id = (int)com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.ID); for (int i = 0; i < pointCount; i++) { shapeBuffer.Write(id); } offset += 4; } } } return(offset); }
internal static void PolygonText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, int polygon_start, int polygon_end, System.Text.StringBuilder @string) { @string.Append('('); LineStringText_(true, true, precision, b_export_zs, b_export_ms, zs, ms, position, paths, polygon_start, @string); for (int path = polygon_start + 1; path < polygon_end; path++) { @string.Append(", "); LineStringText_(true, true, precision, b_export_zs, b_export_ms, zs, ms, position, paths, path, @string); } @string.Append(')'); }
internal static void LineStringText_(bool bRing, bool b_closed, int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt32 paths, int path, System.Text.StringBuilder @string) { int istart = paths.Read(path); int iend = paths.Read(path + 1); if (istart == iend) { @string.Append("EMPTY"); return; } @string.Append('('); if (bRing) { Point_(precision, b_export_zs, b_export_ms, zs, ms, position, istart, @string); @string.Append(", "); for (int point = iend - 1; point >= istart + 1; point--) { Point_(precision, b_export_zs, b_export_ms, zs, ms, position, point, @string); @string.Append(", "); } Point_(precision, b_export_zs, b_export_ms, zs, ms, position, istart, @string); } else { for (int point = istart; point < iend - 1; point++) { Point_(precision, b_export_zs, b_export_ms, zs, ms, position, point, @string); @string.Append(", "); } Point_(precision, b_export_zs, b_export_ms, zs, ms, position, iend - 1, @string); if (b_closed) { @string.Append(", "); Point_(precision, b_export_zs, b_export_ms, zs, ms, position, istart, @string); } } @string.Append(')'); }