/// <summary> /// Creates a new <c>FindOverlapsQuery</c> (and executes it). The result of the query /// can then be obtained through the <c>Result</c> property. /// </summary> /// <param name="index">The spatial index to search</param> /// <param name="closedShape">The closed shape defining the search area.</param> /// <param name="spatialType">The type of objects to look for.</param> internal FindOverlapsQuery(ISpatialIndex index, IPosition[] closedShape, SpatialType spatialType) { m_ClosedShape = new ClosedShape(closedShape); m_Points = new List<PointFeature>(100); m_Result = new List<ISpatialObject>(100); // If we are looking for points or lines, locate points that overlap. Note that // if the user does not actually want points in the result, we still do a point // search, since it helps with the selection of lines. if ((spatialType & SpatialType.Point)!=0 || (spatialType & SpatialType.Line)!=0) { index.QueryWindow(m_ClosedShape.Extent, SpatialType.Point, OnPointFound); // Remember the points in the result if the caller wants them if ((spatialType & SpatialType.Point)!=0) m_Result.AddRange(m_Points.ToArray()); } // Find lines (this automatically includes lines connected to the points we just found) if ((spatialType & SpatialType.Line)!=0) index.QueryWindow(m_ClosedShape.Extent, SpatialType.Line, OnLineFound); // Find any overlapping text if ((spatialType & SpatialType.Text)!=0) index.QueryWindow(m_ClosedShape.Extent, SpatialType.Text, OnTextFound); m_Result.TrimExcess(); m_Points = null; }
internal EntityTranslationForm(string alias, SpatialType type) { InitializeComponent(); m_Alias = alias; m_Type = type; m_Result = null; }
private static IDictionary <String, Object> GetExpectedGeoJson(SpatialType type, params object[] members) { var json = new Dictionary <String, Object>(); AddType(json, type); json.Add(type == SpatialType.Collection ? "geometries" : "coordinates", members); return(json); }
internal SpatialTreeBuilder <T> .SpatialBuilderNode CreateChildren(SpatialType type) { SpatialTreeBuilder <T> .SpatialBuilderNode item = new SpatialTreeBuilder <T> .SpatialBuilderNode { Parent = (SpatialTreeBuilder <T> .SpatialBuilderNode) this, Type = type }; this.Children.Add(item); return(item); }
/// <summary> /// Create a child node /// </summary> /// <param name="type">The node type</param> /// <returns>The child node</returns> internal SpatialBuilderNode CreateChildren(SpatialType type) { var node = new SpatialBuilderNode { Parent = this, Type = type }; this.Children.Add(node); return(node); }
private static Geometry EmptyGeometry(SpatialType type) { var b = new GeometryBuilderImplementation(implementation); b.SetCoordinateSystem(CoordinateSystem.DefaultGeometry); b.BeginGeometry(type); b.EndGeometry(); return(b.ConstructedGeometry); }
/// <summary> /// Translates the coordinates member value of a MultiPoint, MultiLineString, or MultiPolygon object into method calls on the spatial pipeline. /// </summary> /// <param name="containedSpatialType">Type of the shape contained in the Multi shape.</param> /// <param name="coordinates">Parsed coordinates array.</param> private void SendMultiShape(SpatialType containedSpatialType, IEnumerable coordinates) { Debug.Assert( containedSpatialType == SpatialType.Point || containedSpatialType == SpatialType.LineString || containedSpatialType == SpatialType.Polygon, "SendMultiShape only expects to write Point, LineString, or Polygon contained shapes."); SendArrayOfArray(coordinates, (containedShapeCoordinates) => this.SendShape(containedSpatialType, containedShapeCoordinates)); }
protected override SpatialType OnBeginGeometry(SpatialType shape) { if ((this.depth > 0) && this.processingGeography) { throw new FormatException(Strings.Validator_UnexpectedGeography); } this.processingGeography = false; this.BeginShape(shape); return(shape); }
/// <summary> /// Begin Geo /// </summary> /// <param name="type">The spatial type</param> protected virtual void BeginGeo(SpatialType type) { // close on nesting types until we find a container suitable for the current type while (!this.CanContain(type)) { this.EndGeo(); } this.containers.Push(type); }
/// <summary> /// End Geography/Geometry /// </summary> private void EndGeo() { SpatialType type = this.parentStack.Pop(); switch (type) { case SpatialType.MultiPoint: case SpatialType.MultiLineString: case SpatialType.MultiPolygon: case SpatialType.Collection: if (!this.shouldWriteContainerWrapper) { // container wrapper has been written, end it this.writer.WriteEndElement(); } this.writer.WriteEndElement(); // On EndGeo we should turn off wrapper, nested empty collection types relies on this call. this.shouldWriteContainerWrapper = false; break; case SpatialType.Point: if (!figureWritten) { // empty point needs an empty pos this.WriteStartElement(GmlConstants.Position); this.writer.WriteEndElement(); } this.writer.WriteEndElement(); break; case SpatialType.LineString: if (!figureWritten) { // empty linestring needs an empty posList this.WriteStartElement(GmlConstants.PositionList); this.writer.WriteEndElement(); } this.writer.WriteEndElement(); break; case SpatialType.Polygon: case SpatialType.FullGlobe: this.writer.WriteEndElement(); break; default: Debug.Assert(false, "Unknown type in stack, mismatch switch between BeginGeo() and EndGeo()?"); break; } }
private IEntity GetEntityType(Ntx.Feature f, SpatialType type) { if (m_Translator == null) { return(null); } string fc = f.FeatureCode; return(m_Translator.FindEntityTypeByExternalName(fc, type)); }
internal GetEntityForm(ILayer layer, SpatialType t, int defaultEntityId) { if (layer==null) throw new ArgumentNullException("Map layer must be specified"); InitializeComponent(); m_Layer = layer; m_Type = t; m_SelectedEntity = null; m_DefaultEntityId = defaultEntityId; }
/// <summary> /// Creates a new <c>DrawQuery</c> that refers to the specified feature type(s), /// drawing the results of the spatial query to the specified display. /// </summary> /// <param name="index">The index to query</param> /// <param name="display">The display to draw to</param> /// <param name="style">The drawing style</param> /// <param name="types">The type(s) of spatial feature to draw</param> public DrawQuery(ISpatialIndex index, ISpatialDisplay display, IDrawStyle style, SpatialType types) { m_Display = display; m_Style = style; m_DoPaint = false; Timer t = new Timer(500); t.Elapsed += new ElapsedEventHandler(Timer_Elapsed); t.Start(); index.QueryWindow(m_Display.Extent, types, OnQueryHit); t.Close(); display.PaintNow(); }
private Geography CreateGeography <T>(SpatialType type, T data, Action <GeographyPipeline, T> writer) { var builder = SpatialImplementation.CurrentImplementation.CreateBuilder(); builder.GeographyPipeline.SetCoordinateSystem(CoordinateSystem.DefaultGeography); builder.GeographyPipeline.BeginGeography(type); writer(builder.GeographyPipeline, data); builder.GeographyPipeline.EndGeography(); return(builder.ConstructedGeography); }
public override void Select(ISpatialDisplay display, IPosition p, SpatialType spatialType) { ISpatialObject so = SelectObject(display, p, spatialType); if (so != null) { SetSelection(new Selection(so, p)); } else { SetSelection(null); } }
public virtual void Select(ISpatialDisplay display, IPosition p, SpatialType spatialType) { if (m_Data == null) { return; } // Use a tolerance of 2mm at the map scale of the supplied display ILength size = new Length(0.002 * display.MapScale); ISpatialObject so = m_Data.QueryClosest(p, size, spatialType); SetSelection(new SpatialSelection(so)); }
private static XmlReader ExpectedEmptyGml(SpatialType type, CoordinateSystem coordinateSystem) { StringBuilder payloadBuilder = new StringBuilder(); switch (type) { case SpatialType.Point: payloadBuilder.Append(GmlShapeElement("Point", coordinateSystem.EpsgId)); payloadBuilder.Append(GmlElement("pos")); payloadBuilder.Append(GmlEndElement("pos")); payloadBuilder.Append(GmlEndElement("Point")); break; case SpatialType.LineString: payloadBuilder.Append(GmlShapeElement("LineString", coordinateSystem.EpsgId)); payloadBuilder.Append(GmlElement("posList")); payloadBuilder.Append(GmlEndElement("posList")); payloadBuilder.Append(GmlEndElement("LineString")); break; case SpatialType.Polygon: case SpatialType.MultiPoint: payloadBuilder.Append(GmlShapeElement(type.ToString(), coordinateSystem.EpsgId)); payloadBuilder.Append(GmlEndElement(type.ToString())); break; case SpatialType.MultiLineString: payloadBuilder.Append(GmlShapeElement("MultiCurve", coordinateSystem.EpsgId)); payloadBuilder.Append(GmlEndElement("MultiCurve")); break; case SpatialType.MultiPolygon: payloadBuilder.Append(GmlShapeElement("MultiSurface", coordinateSystem.EpsgId)); payloadBuilder.Append(GmlEndElement("MultiSurface")); break; case SpatialType.Collection: payloadBuilder.Append(GmlShapeElement("MultiGeometry", coordinateSystem.EpsgId)); payloadBuilder.Append(GmlEndElement("MultiGeometry")); break; default: Assert.True(false, "unknown spatial type"); break; } XElement xel = XElement.Parse(payloadBuilder.ToString()); return(xel.CreateReader()); }
internal GetEntityForm(ILayer layer, SpatialType t, int defaultEntityId) { if (layer == null) { throw new ArgumentNullException("Map layer must be specified"); } InitializeComponent(); m_Layer = layer; m_Type = t; m_SelectedEntity = null; m_DefaultEntityId = defaultEntityId; }
internal override void BeginGeo(SpatialType type) { if (this.currentNode == null) { SpatialBuilderNode node = new SpatialBuilderNode { Type = type }; this.currentNode = node; this.lastConstructedNode = null; } else { this.currentNode = this.currentNode.CreateChildren(type); } }
private static string GetDataName(SpatialType type) { switch (type) { case SpatialType.Point: case SpatialType.LineString: case SpatialType.Polygon: case SpatialType.MultiPoint: case SpatialType.MultiLineString: case SpatialType.MultiPolygon: return("coordinates"); case SpatialType.Collection: return("geometries"); } throw new NotImplementedException(); }
/// <summary> /// Selects stuff within the current limit line. This makes a private selection /// over and above any previous selection. /// </summary> void SelectLimit() { // Nothing to do if there is no limit line. if (m_Limit == null) { return; } // Empty out the current limit selection. m_LimSel.Clear(); // Nothing to do if there's only one position. if (m_Limit.Count <= 1) { return; } // If we have just 2 positions, select everything that // intersects the line. Otherwise select inside the shape. try { // Close the limit line. m_Limit.Add(m_Limit[0]); // Select only lines if the limit line consists of only 2 points (otherwise select // whatever is currently visible on the active display) SpatialType types = (m_Limit.Count == 2 ? SpatialType.Line : m_Controller.VisibleFeatureTypes); // Make the selection. ISpatialIndex index = CadastralMapModel.Current.Index; List <ISpatialObject> res = new FindOverlapsQuery(index, m_Limit.ToArray(), types).Result; m_LimSel.AddRange(res); } catch { } finally { // Remove the closing point. int lastIndex = m_Limit.Count - 1; m_Limit.RemoveAt(lastIndex); } }
private void BeginShape(SpatialType type, CoordinateSystem defaultCoordinateSystem) { if (this.currentCoordinateSystem == null) { this.currentCoordinateSystem = defaultCoordinateSystem; } if (this.ShapeHasObjectScope) { this.WriteShapeHeader(type); } if (TypeHasArrayScope(type)) { this.StartArrayScope(); } this.stack.Push(type); this.figureDrawn = false; }
private void ParseMultiGeoText(SpatialType innerType, Action innerReader) { if (!this.ReadEmptySet()) { this.ReadToken(WellKnownTextTokenType.LeftParen, null); this.pipeline.BeginGeo(innerType); innerReader(); this.pipeline.EndGeo(); while (this.ReadOptionalToken(WellKnownTextTokenType.Comma, null)) { this.pipeline.BeginGeo(innerType); innerReader(); this.pipeline.EndGeo(); } this.ReadToken(WellKnownTextTokenType.RightParen, null); } }
private static string GetDataName(SpatialType type) { switch (type) { case SpatialType.Point: case SpatialType.LineString: case SpatialType.Polygon: case SpatialType.MultiPoint: case SpatialType.MultiLineString: case SpatialType.MultiPolygon: return "coordinates"; case SpatialType.Collection: return "geometries"; } throw new NotImplementedException(); }
/// <summary> /// write tagged text for type /// </summary> /// <param name="type">the spatial type</param> private void WriteTaggedText(SpatialType type) { switch (type) { case SpatialType.Point: this.writer.Write(WellKnownTextConstants.WktPoint); break; case SpatialType.LineString: this.writer.Write(WellKnownTextConstants.WktLineString); break; case SpatialType.Polygon: this.writer.Write(WellKnownTextConstants.WktPolygon); break; case SpatialType.Collection: this.shapeWritten = false; this.writer.Write(WellKnownTextConstants.WktCollection); break; case SpatialType.MultiPoint: this.shapeWritten = false; this.writer.Write(WellKnownTextConstants.WktMultiPoint); break; case SpatialType.MultiLineString: this.shapeWritten = false; this.writer.Write(WellKnownTextConstants.WktMultiLineString); break; case SpatialType.MultiPolygon: this.shapeWritten = false; this.writer.Write(WellKnownTextConstants.WktMultiPolygon); break; case SpatialType.FullGlobe: this.writer.Write(WellKnownTextConstants.WktFullGlobe); break; } if (type != SpatialType.FullGlobe) { this.writer.Write(WellKnownTextConstants.WktWhitespace); } }
/// <summary> /// Translates the coordinates member value into method calls on the spatial pipeline. /// </summary> /// <param name="spatialType">SpatialType of the GeoJSON object.</param> /// <param name="contentMembers">Coordinates value of the GeoJSON object, or inner geometries for collection</param> private void SendCoordinates(SpatialType spatialType, IEnumerable contentMembers) { if (EnumerableAny(contentMembers)) { // non-empty shape switch (spatialType) { case SpatialType.Point: SendPoint(contentMembers); break; case SpatialType.LineString: SendLineString(contentMembers); break; case SpatialType.Polygon: SendPolygon(contentMembers); break; case SpatialType.MultiPoint: SendMultiShape(SpatialType.Point, contentMembers); break; case SpatialType.MultiLineString: SendMultiShape(SpatialType.LineString, contentMembers); break; case SpatialType.MultiPolygon: SendMultiShape(SpatialType.Polygon, contentMembers); break; case SpatialType.Collection: foreach (IDictionary <string, object> collectionMember in contentMembers) { SendToPipeline(collectionMember, false); } break; default: Debug.Assert(false, "SendCoordinates has not been implemented for SpatialType " + spatialType); break; } } }
private void WriteTaggedText(SpatialType type) { switch (type) { case SpatialType.Point: this.writer.Write("POINT"); break; case SpatialType.LineString: this.writer.Write("LINESTRING"); break; case SpatialType.Polygon: this.writer.Write("POLYGON"); break; case SpatialType.MultiPoint: this.shapeWritten = false; this.writer.Write("MULTIPOINT"); break; case SpatialType.MultiLineString: this.shapeWritten = false; this.writer.Write("MULTILINESTRING"); break; case SpatialType.MultiPolygon: this.shapeWritten = false; this.writer.Write("MULTIPOLYGON"); break; case SpatialType.Collection: this.shapeWritten = false; this.writer.Write("GEOMETRYCOLLECTION"); break; case SpatialType.FullGlobe: this.writer.Write("FULLGLOBE"); break; } if (type != SpatialType.FullGlobe) { this.writer.Write(" "); } }
private void BeginShape(SpatialType type) { this.depth++; switch (type) { case SpatialType.Point: this.Execute(PipelineCall.BeginPoint); return; case SpatialType.LineString: this.Execute(PipelineCall.BeginLineString); return; case SpatialType.Polygon: this.Execute(PipelineCall.BeginPolygon); return; case SpatialType.MultiPoint: this.Execute(PipelineCall.BeginMultiPoint); return; case SpatialType.MultiLineString: this.Execute(PipelineCall.BeginMultiLineString); return; case SpatialType.MultiPolygon: this.Execute(PipelineCall.BeginMultiPolygon); return; case SpatialType.Collection: this.Execute(PipelineCall.BeginCollection); return; case SpatialType.FullGlobe: if (!this.processingGeography) { throw new FormatException(Strings.Validator_InvalidType(type)); } this.Execute(PipelineCall.BeginFullGlobe); return; } throw new FormatException(Strings.Validator_InvalidType(type)); }
private void BeginGeo(SpatialType type) { SpatialType type2 = (this.parentStack.Count == 0) ? SpatialType.Unknown : this.parentStack.Peek(); switch (type2) { case SpatialType.MultiPoint: case SpatialType.MultiLineString: case SpatialType.MultiPolygon: case SpatialType.Collection: this.writer.Write(this.shapeWritten ? ", " : "("); break; } if ((type2 == SpatialType.Unknown) || (type2 == SpatialType.Collection)) { this.WriteTaggedText(type); } this.figureWritten = false; this.parentStack.Push(type); }
/// <summary> /// Begin a new spatial type /// </summary> /// <param name="type">The spatial type</param> internal override void BeginGeo(SpatialType type) { Debug.Assert(type != SpatialType.Unknown, "cannot build unknown type - should have validated this call"); // traverse down the tree); if (this.currentNode == null) { this.currentNode = new SpatialBuilderNode { Type = type }; // we are just getting started, clear the last built this.lastConstructedNode = null; } else { this.currentNode = this.currentNode.CreateChildren(type); } }
private void SendCoordinates(SpatialType spatialType, IEnumerable contentMembers) { if (EnumerableAny(contentMembers)) { switch (spatialType) { case SpatialType.Point: this.SendPoint(contentMembers); return; case SpatialType.LineString: this.SendLineString(contentMembers); return; case SpatialType.Polygon: this.SendPolygon(contentMembers); return; case SpatialType.MultiPoint: this.SendMultiShape(SpatialType.Point, contentMembers); return; case SpatialType.MultiLineString: this.SendMultiShape(SpatialType.LineString, contentMembers); return; case SpatialType.MultiPolygon: this.SendMultiShape(SpatialType.Polygon, contentMembers); return; case SpatialType.Collection: foreach (IDictionary <string, object> dictionary in contentMembers) { this.SendToPipeline(dictionary, false); } break; default: return; } } }
/// <summary> /// Start to write a new Geography/Geometry /// </summary> /// <param name="type">The SpatialType to write</param> private void BeginGeo(SpatialType type) { SpatialType parentType = this.parentStack.Count == 0 ? SpatialType.Unknown : this.parentStack.Peek(); if (parentType == SpatialType.MultiPoint || parentType == SpatialType.MultiLineString || parentType == SpatialType.MultiPolygon || parentType == SpatialType.Collection) { // container, first element should write out (, subsequent ones write out "," this.writer.Write(this.shapeWritten ? WellKnownTextConstants.WktDelimiterWithWhiteSpace : WellKnownTextConstants.WktOpenParen); } // Write tagged text // Only write if toplevel, or the parent is a collection type if (parentType == SpatialType.Unknown || parentType == SpatialType.Collection) { this.WriteTaggedText(type); } this.figureWritten = false; this.parentStack.Push(type); }
/// <summary> /// The schemas that relate to the specified spatial type and mapping layer. /// </summary> /// <param name="t">The type(s) of interest</param> /// <param name="layer">The layer of interest (null for all layers)</param> /// <returns>The schemas associated with the entity types that apply to the specified /// spatial type and mapping layer</returns> public static ITable[] Schemas(SpatialType t, ILayer layer) { List <ITable> result = new List <ITable>(); IEntity[] ents = EntityTypes(t, layer); foreach (IEntity e in ents) { ITable[] entSchemas = e.DefaultTables; foreach (ITable schema in entSchemas) { if (!result.Contains(schema)) { result.Add(schema); } } } return(result.ToArray()); }
/// <summary> /// Gets the name of the GeoJson member to use when writing the body of the spatial object. /// </summary> /// <param name="type">SpatialType being written.</param> /// <returns>Name of the GeoJson member to use when writing the body of the spatial object.</returns> private static string GetDataName(SpatialType type) { switch (type) { case SpatialType.Point: case SpatialType.LineString: case SpatialType.Polygon: case SpatialType.MultiPoint: case SpatialType.MultiLineString: case SpatialType.MultiPolygon: return(GeoJsonConstants.CoordinatesMemberName); case SpatialType.Collection: return(GeoJsonConstants.GeometriesMemberName); default: Debug.Assert(false, "SpatialType " + type + " is not currently supported in GeoJsonWriter."); throw new NotImplementedException(); } }
/// <summary> /// Creates a new <c>FindClosestQuery</c> (and executes it). The result of the query /// can then be obtained through the <c>Result</c> property. /// </summary> /// <param name="index">The spatial index to search</param> /// <param name="p">The search position.</param> /// <param name="radius">The search tolerance (expected to be greater than zero).</param> /// <param name="types">The type of objects to look for.</param> internal FindClosestQuery(ISpatialIndex index, IPosition p, ILength radius, SpatialType types) { if (types==0) throw new ArgumentNullException("Spatial type(s) not specified"); // If the user hasn't been specific, ensure we don't search for polygons! SpatialType useTypes = (types==SpatialType.All ? SpatialType.Feature : types); Debug.Assert((useTypes & SpatialType.Polygon)==0); // It's important to round off to the nearest micron. Otherwise you might not // get the desired results in situations where the search radius is zero. m_Position = PositionGeometry.Create(p); m_Radius = radius; m_Types = types; m_Result = null; m_Distance = m_Radius.Meters; // The query will actually involve a square window, not a circle. IWindow x = new Window(m_Position, radius.Meters * 2.0); index.QueryWindow(x, useTypes, OnQueryHit); }
public IEntity FindEntityTypeByExternalName(string alias, SpatialType type) { IEntity result = (m_Translator==null ? null : m_Translator.Translate(alias)); if (result!=null) return result; // Ask the user to pick a suitable translation EntityTranslationForm dial = new EntityTranslationForm(alias, type); dial.ShowDialog(); result = dial.Result; dial.Dispose(); // Remember what was specified if (result!=null) { if (m_Translator==null) m_Translator = new TranslationFile(); m_Translator.Add(alias, result); } return result; }
private static string GetGeoJsonTypeName(SpatialType spatialType) { if(spatialType == SpatialType.Collection) { return "GeometryCollection"; } return Enum.GetName(spatialType.GetType(), spatialType); }
private static IDictionary<string, object> GetJsonMembers(SpatialType spatialType, IEnumerable<object> coordinates, IDictionary<string, object> crs) { var members = new Dictionary<string, object>(); members.Add(GeoJsonConstants.TypeMemberName, GetGeoJsonTypeName(spatialType)); if (coordinates != null) { members.Add(GeoJsonConstants.CoordinatesMemberName, coordinates); } if (crs != null) { members.Add(GeoJsonConstants.CrsMemberName, crs); } return members; }
void SetDefaultEntity(SpatialType t) { ILayer layer = ActiveLayer; if (layer==null) return; IEntity e = CadastralMapModel.Current.GetDefaultEntity(t); int entId = (e == null ? 0 : e.Id); GetEntityForm dial = new GetEntityForm(layer, t, entId); if (dial.ShowDialog() == DialogResult.OK) { e = dial.SelectedEntity; CadastralMapModel.Current.SetDefaultEntity(t, e); } dial.Dispose(); }
private static void TestSendToPipeline(SpatialType spatialType, List<object> coordinates, Func<List<object>, bool, ICommonLoggingPipeline> getExpectedPipeline) { // Test with both Geography and Geometry pipelines TestSendToPipeline(spatialType, coordinates, true, getExpectedPipeline); TestSendToPipeline(spatialType, coordinates, false, getExpectedPipeline); }
public override void BeginGeography(SpatialType type) { logger.BeginShape(PipelineMethod.BeginGeography, type); }
private static void TestErrorOnUnexpectedNumeric(SpatialType spatialType, List<object> coordinates) { SpatialTestUtils.VerifyExceptionThrown<ParseErrorException>(() => ExecuteSendToPipeline(spatialType, coordinates), Strings.GeoJsonReader_ExpectedArray); }
public void BeginShape(SpatialType spatialType) { this.drawGeography.BeginGeography(spatialType); }
public void BeginShape(SpatialType spatialType) { this.drawGeometry.BeginGeometry(spatialType); }
private static CallSequenceLoggingPipeline ExecuteSendToPipeline(SpatialType spatialType, IEnumerable<object> coordinates, bool isGeography = true, IDictionary<string, object> crs = null) { var members = GetJsonMembers(spatialType, coordinates, crs); var actualPipeline = new CallSequenceLoggingPipeline(); SendToPipeline(members, actualPipeline, isGeography); return actualPipeline; }
private static Dictionary<string, object> GetGeoJson(SpatialType? spatialType, List<object> coordinates, out int expectedPropertyCount, int? epsgId = null) { expectedPropertyCount = 0; //var geoJsonBuilder = new StringBuilder(); var jsonObject = new Dictionary<string, object>(); // Write the start of the object //geoJsonBuilder.Append("\n \t{ "); // Write the "type" member if one was specified if (spatialType != null) { expectedPropertyCount++; //geoJsonBuilder.AppendFormat("{0}type{0} : {1}{2}{1}", memberQuoteChar, typeValueQuoteChar, spatialType != SpatialType.Collection ? spatialType.ToString() : "GeometryCollection"); jsonObject.Add("type", GetGeoJsonTypeName(spatialType.Value)); } // Write the "coordinates" member if one was specified if (coordinates != null) { //if (spatialType != null) //{ // geoJsonBuilder.Append(", "); //} expectedPropertyCount++; jsonObject.Add("coordinates", coordinates); //geoJsonBuilder.AppendFormat("{0}coordinates{0}: ", memberQuoteChar); //WriteArray(geoJsonBuilder, coordinates); } // write the CRS member if an SRID was given if (epsgId != null) { //if (coordinates != null || spatialType != null) //{ // geoJsonBuilder.Append(", "); //} //geoJsonBuilder.AppendFormat(" {0}crs{0} : {{ {0}properties{0}: {{ {0}name{0} : {1}EPSG:{2}{1} }}, {0}type{0} : {1}name{1} }}", memberQuoteChar, typeValueQuoteChar, epsgId.Value); jsonObject.Add("crs", GetCrsObject(epsgId)); expectedPropertyCount++; } // Write the end of the object //geoJsonBuilder.Append(" \n}\n\r "); //geoJsonInput = geoJsonBuilder.ToString(); //return expectedPropertyCount; return jsonObject; }
internal override void BeginGeo(SpatialType type) { this.output.BeginGeography(type); }
private static void TestSendToPipeline(SpatialType spatialType, List<object> coordinates, bool isGeography, Func<List<object>, bool, ICommonLoggingPipeline> getExpectedPipeline) { // Set up expected call sequence var expectedPipeline = getExpectedPipeline(coordinates, isGeography); // Execute actual write to pipeline var actualPipeline = ExecuteSendToPipeline(spatialType, coordinates, isGeography); expectedPipeline.VerifyPipeline(actualPipeline); }
public virtual void Select(ISpatialDisplay display, IPosition p, SpatialType spatialType) { if (m_Data==null) return; // Use a tolerance of 2mm at the map scale of the supplied display ILength size = new Length(0.002 * display.MapScale); ISpatialObject so = m_Data.QueryClosest(p, size, spatialType); SetSelection(new SpatialSelection(so)); }
/// <summary> /// Begin drawing a spatial object /// </summary> /// <param name="type">The spatial type of the object</param> /// <returns>The type to be passed down the pipeline</returns> protected virtual SpatialType OnBeginGeometry(SpatialType type) { return type; }
/// <summary> /// Begin drawing a spatial object /// </summary> /// <param name="type">The spatial type of the object</param> public override void BeginGeometry(SpatialType type) { both.OnBeginGeometry(type); }
public bool IsValid(SpatialType t) { return (((t & SpatialType.Point)!=0 && IsPointValid) || ((t & SpatialType.Line) !=0 && IsLineValid) || ((t & SpatialType.Text) !=0 && IsTextValid) || ((t & SpatialType.Polygon)!=0 && IsPolygonValid)); }
public override void BeginGeography(SpatialType type) { }
private void BeginShape(PipelineMethod pipelineMethod, SpatialType type) { CheckAlwaysThrow(); LogMethodCall(pipelineMethod, type); }
private static Dictionary<string, object> GetGeoJson(SpatialType[] collectionTypes, List<object>[] coordinates, out int expectedPropertyCount, int? epsgId = null) { expectedPropertyCount = 2; var geoJsonBuilder = new StringBuilder(); var jsonObject = new Dictionary<string, object>(); jsonObject.Add("type", "GeometryCollection"); // Write the start of the object //geoJsonBuilder.Append("\n \t{ "); //geoJsonBuilder.AppendFormat("{0}type{0} : {1}GeometryCollection{1}", memberQuoteChar, typeValueQuoteChar); if (epsgId != null) { jsonObject.Add("crs", GetCrsObject(epsgId)); //geoJsonBuilder.Append(", "); //geoJsonBuilder.AppendFormat(" {0}crs{0} : {{ {0}properties{0}: {{ {0}name{0} : {1}EPSG:{2}{1} }}, {0}type{0} : {1}name{1} }}", memberQuoteChar, typeValueQuoteChar, epsgId.Value); expectedPropertyCount++; } List<Dictionary<string, object>> geometryObjects = new List<Dictionary<string, object>>(); //geoJsonBuilder.AppendFormat(", {0}geometries{0}: [", memberQuoteChar); for (var i = 0; i < collectionTypes.Length; ++i) { //string innerJson; int throwAwayPropertyCount; var innerObject = GetGeoJson(collectionTypes[i], coordinates[i], out throwAwayPropertyCount); geometryObjects.Add(innerObject); //geoJsonBuilder.Append(innerJson); //if (i != collectionTypes.Length - 1) //{ // geoJsonBuilder.Append(", "); //} } jsonObject.Add("geometries", geometryObjects); //geoJsonBuilder.Append("\n]\n}\n\r"); //geoJsonInput = geoJsonBuilder.ToString(); //return expectedPropertyCount; return jsonObject; }
private static ICommonLoggingPipeline GetExpectedPipeline(SpatialType spatialType, CoordinateSystem coordinateSystem, bool isGeography, Action<ICommonLoggingPipeline> writeShape) { ICommonLoggingPipeline expectedPipeline; if (isGeography) { expectedPipeline = new GeographyLoggingPipeline(); } else { expectedPipeline = new GeometryLoggingPipeline(); } expectedPipeline.SetCoordinateSystem(coordinateSystem); expectedPipeline.BeginShape(spatialType); writeShape(expectedPipeline); expectedPipeline.EndShape(); return expectedPipeline; }
public override void BeginGeometry(SpatialType type) { }