public static IGeometry Circumcentre(IGeometry g) { Coordinate[] pts = TrianglePts(g); Coordinate cc = Triangle.Circumcentre(pts[0], pts[1], pts[2]); IGeometryFactory geomFact = FunctionsUtil.GetFactoryOrDefault(g); return geomFact.CreatePoint(cc); }
/// <summary> /// Method to set <see cref="Geometry"/> to <paramref name="converted"/> /// </summary> /// <param name="converted">The converted geometry</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="converted"/> is <value>null</value></exception> public void SetGeometry(IGeometry converted) { if (converted == null) throw new ArgumentNullException("converted"); Geometry = converted; }
/// <summary> /// Writes a Geometry to the given binary wirter. /// </summary> /// <param name="geometry">The geometry to write.</param> /// <param name="file">The file stream to write to.</param> /// <param name="geometryFactory">The geometry factory to use.</param> public override void Write(IGeometry geometry, System.IO.BinaryWriter file, IGeometryFactory geometryFactory) { if(!(geometry is IMultiPoint)) throw new ArgumentException("Geometry Type error: MultiPoint expected, but the type retrieved is " + geometry.GetType().Name); // Slow and maybe not useful... // if (!geometry.IsValid) // Trace.WriteLine("Invalid multipoint being written."); IMultiPoint mpoint = geometry as IMultiPoint; file.Write(int.Parse(Enum.Format(typeof(ShapeGeometryTypes), this.ShapeType, "d"))); IEnvelope box = geometry.EnvelopeInternal; IEnvelope bounds = ShapeHandler.GetEnvelopeExternal(geometryFactory.PrecisionModel, box); file.Write(bounds.MinX); file.Write(bounds.MinY); file.Write(bounds.MaxX); file.Write(bounds.MaxY); int numPoints = mpoint.NumPoints; file.Write(numPoints); // write the points for (int i = 0; i < numPoints; i++) { IPoint point = (IPoint) mpoint.Geometries[i]; file.Write(point.X); file.Write(point.Y); } }
private static Coordinate[] TrianglePts(IGeometry g) { Coordinate[] pts = g.Coordinates; if (pts.Length < 3) throw new ArgumentException("Input geometry must have at least 3 points"); return pts; }
protected void CheckEqual(IGeometry expected, IGeometry actual) { var actualNorm = actual.Normalized(); var expectedNorm = expected.Normalized(); var equal = actualNorm.EqualsExact(expectedNorm); Assert.That(equal, Is.True, String.Format("Expected = {0}\nactual = {1}", expected, actual)); }
public Pond(long fid, string name, string type, IGeometry shores) { this.Fid = fid; this.Name = name; this.Type = type; this.Shores = shores; }
/// <summary> /// Computes the set-theoretic union of two <c>Geometry</c>s, using enhanced precision. /// </summary> /// <param name="geom0">The first Geometry.</param> /// <param name="geom1">The second Geometry.</param> /// <returns>The Geometry representing the set-theoretic union of the input Geometries.</returns> public static IGeometry Union(IGeometry geom0, IGeometry geom1) { ApplicationException originalEx; try { IGeometry result = geom0.Union(geom1); return result; } catch (ApplicationException ex) { originalEx = ex; } /* * If we are here, the original op encountered a precision problem * (or some other problem). Retry the operation with * enhanced precision to see if it succeeds */ try { CommonBitsOp cbo = new CommonBitsOp(true); IGeometry resultEp = cbo.Union(geom0, geom1); // check that result is a valid point after the reshift to orginal precision if (!resultEp.IsValid) throw originalEx; return resultEp; } catch (ApplicationException) { throw originalEx; } }
public static IGeometry Grid(IGeometry g, int nCells) { var geoms = new List<IGeometry>(); var env = FunctionsUtil.GetEnvelopeOrDefault(g); var geomFact = FunctionsUtil.GetFactoryOrDefault(g); var nCellsOnSide = (int) Math.Sqrt(nCells) + 1; var cellSizeX = env.Width/nCellsOnSide; var cellSizeY = env.Height/nCellsOnSide; for (var i = 0; i < nCellsOnSide; i++) { for (var j = 0; j < nCellsOnSide; j++) { var x1 = env.MinX + i * cellSizeX; var y1 = env.MinY + j * cellSizeY; var x2 = env.MinX + (i+1) * cellSizeX; var y2 = env.MinY + (j+1) * cellSizeY; var cellEnv = new Envelope(x1, x2, y1, y2); geoms.Add(geomFact.ToGeometry(cellEnv)); } } return geomFact.BuildGeometry(geoms); }
// #region Methods /// <summary> /// Converts a Geometry to its Well-known Text representation. /// </summary> /// <param name="geometry">A Geometry to write.</param> /// <returns>A <Geometry Tagged Text> string (see the OpenGIS Simple /// Features Specification)</returns> public static string Write(IGeometry geometry) { return new WKTWriter().Write(geometry); // StringWriter sw = new StringWriter(); // Write(geometry, sw); // return sw.ToString(); }
/// <summary> /// Writes a geometry to a byte array using the specified encoding. /// </summary> /// <param name="g">The geometry to write</param> /// <param name="wkbByteOrder">Byte order</param> /// <returns>WKB representation of the geometry</returns> public static byte[] Write(IGeometry g, WkbByteOrder wkbByteOrder) { ByteOrder order; switch (wkbByteOrder) { case WkbByteOrder.Xdr: order = ByteOrder.BigEndian; break; case WkbByteOrder.Ndr: order = ByteOrder.LittleEndian; break; default: throw new ArgumentOutOfRangeException("wkbByteOrder"); } WKBWriter wkb = new WKBWriter(order); return wkb.Write(g); /* MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); //Write the byteorder format. bw.Write((byte) wkbByteOrder); //Write the type of this geometry WriteType(g, bw, wkbByteOrder); //Write the geometry WriteGeometry(g, bw, wkbByteOrder); return ms.ToArray(); */ }
/// <summary> /// Tests whether the given Geometry intersects the query rectangle. /// </summary> /// <param name="geom">The Geometry to test (may be of any type)</param> /// <returns><value>true</value> if an intersection must occur /// or <value>false</value> if no conclusion about intersection can be made</returns> public bool Intersects(IGeometry geom) { if (!_rectEnv.Intersects(geom.EnvelopeInternal)) return false; /** * Test if rectangle envelope intersects any component envelope. * This handles Point components as well */ var visitor = new EnvelopeIntersectsVisitor(_rectEnv); visitor.ApplyTo(geom); if (visitor.Intersects) return true; /** * Test if any rectangle vertex is contained in the target geometry */ var ecpVisitor = new GeometryContainsPointVisitor(_rectangle); ecpVisitor.ApplyTo(geom); if (ecpVisitor.ContainsPoint) return true; /** * Test if any target geometry line segment intersects the rectangle */ var riVisitor = new RectangleIntersectsSegmentVisitor(_rectangle); riVisitor.ApplyTo(geom); return riVisitor.Intersects; }
protected override void OnTestFixtureSetUp() { DataGenerator.Generate(sessions); this.filter = Wkt.Read(FilterString); this.filter.SRID = 4326; }
public void GetHashCodeShouldBeComputedLazyAndShouldBeVeryFast() { var geometryCount = 1000000; var geometries = new IGeometry[geometryCount]; for (int i = 0; i < geometryCount; i++) { geometries[i] = new Polygon(new LinearRing(new[] { new Coordinate(1.0, 2.0), new Coordinate(2.0, 3.0), new Coordinate(3.0, 4.0), new Coordinate(1.0, 2.0) })); } var polygon = new Polygon(new LinearRing(new[] { new Coordinate(1.0, 2.0), new Coordinate(2.0, 3.0), new Coordinate(3.0, 4.0), new Coordinate(1.0, 2.0) })); // computes hash code every call var t0 = DateTime.Now; for (int i = 0; i < geometryCount; i++) { geometries[i].GetHashCode(); } var t1 = DateTime.Now; var dt1 = t1 - t0; // computes hash code only first time (lazy) t0 = DateTime.Now; for (int i = 0; i < geometryCount; i++) { polygon.GetHashCode(); } t1 = DateTime.Now; var dt2 = t1 - t0; Assert.IsTrue(dt2.TotalMilliseconds < 15 * dt1.TotalMilliseconds); }
/// <summary> /// /// </summary> /// <param name="g0"></param> public GeometryGraphOperation(IGeometry g0) { ComputationPrecision = g0.PrecisionModel; arg = new GeometryGraph[1]; arg[0] = new GeometryGraph(0, g0);; }
private static AndroidBitmap ToAndroidBitmap(IGeometry geometry) { var raster = (IRaster)geometry; var rasterData = raster.Data.ToArray(); var bitmap = BitmapFactory.DecodeByteArray(rasterData, 0, rasterData.Length); return bitmap; }
public static void ComputeDistance(IGeometry geom, Coordinate pt, PointPairDistance ptDist) { if (geom is ILineString) { ComputeDistance((ILineString) geom, pt, ptDist); } else if (geom is IPolygon) { ComputeDistance((IPolygon) geom, pt, ptDist); } else if (geom is IGeometryCollection) { var gc = (IGeometryCollection) geom; for (var i = 0; i < gc.NumGeometries; i++) { var g = gc.GetGeometryN(i); ComputeDistance(g, pt, ptDist); } } else { // assume geom is Point ptDist.SetMinimum(geom.Coordinate, pt); } }
/// <summary> /// ���캯�� /// </summary> /// <param name="bRead">�Ƿ��Ƕ�ȡ</param> /// <param name="strFilePathName">�����ļ�����</param> /// <param name="pCutGeometry">���з�Χ</param> /// <param name="pCutGeometry">���з�Χ</param> public MDBFile(bool bRead, string strFilePathName,bool bCut,IGeometry pCutGeometry) { this.m_bRead = bRead; this.m_strFilePathName = strFilePathName; base.m_dataType = ArcDataType.MDB; base.m_CutGeometry = pCutGeometry; base.m_bCut = bCut; if (this.m_bRead == true) { //�ж�MDB�ļ��Ƿ���� if (File.Exists(this.m_strFilePathName) == true) { //����MDB����Դ this.Workspace = ConnectWorkspace(); } } else { //�ж�MDB�ļ��Ƿ���� if (File.Exists(this.m_strFilePathName) == true) { //����MDB����Դ this.Workspace = ConnectWorkspace(); } else { //����MDB����Դ this.Workspace = CreateWorkspace(); } } }
/// <summary> /// /// </summary> /// <param name="g0"></param> public GeometryGraphOperation(IGeometry g0) { ComputationPrecision = new PrecisionModel(g0.PrecisionModel); Arg = new GeometryGraph[1]; Arg[0] = new GeometryGraph(0, g0); }
///<summary>Checks whether the geometry buffer is valid, and returns an error message if not. ///</summary> /// <param name="g"></param> /// <param name="distance"></param> /// <param name="result"></param> /// <returns>An appropriate error message<br/> /// or <c>null</c>if the buffer is valid</returns> /// public static String IsValidMessage(IGeometry g, double distance, IGeometry result) { var validator = new BufferResultValidator(g, distance, result); if (!validator.IsValid()) return validator.ErrorMessage; return null; }
public virtual void Move(IGeometry targetGeometry, IGeometry sourceGeometry, IList<IGeometry> geometries, IList<int> handleIndices, int mouseIndex, double deltaX, double deltaY) { if ((targetGeometry != null) && (sourceGeometry != null)) { if (targetGeometry.Coordinates.Length != sourceGeometry.Coordinates.Length) { throw new ArgumentException("Source and target geometries should have same number of coordinates."); } //for performance reasons, get the coordinates once: for example for polygons this is a heavy call var targetCoordinates = targetGeometry.Coordinates; var sourceCoordinates = sourceGeometry.Coordinates; for (int i = 0; i < handleIndices.Count; i++) { GeometryHelper.MoveCoordinate(targetCoordinates, sourceCoordinates, handleIndices[i], deltaX, deltaY); targetGeometry.GeometryChangedAction(); if (null != geometries) { IGeometry tracker = geometries[handleIndices[i]]; GeometryHelper.MoveCoordinate(tracker, 0, deltaX, deltaY); tracker.GeometryChangedAction(); } } } }
public static bool IsValid(IGeometry g, double distance, IGeometry result) { BufferResultValidator validator = new BufferResultValidator(g, distance, result); if (validator.IsValid()) return true; return false; }
private IGeometry BufferUnion(IGeometry g0, IGeometry g1) { IGeometryFactory factory = g0.Factory; IGeometry gColl = factory.CreateGeometryCollection(new IGeometry[] { g0, g1 }); IGeometry unionAll = gColl.Buffer(0.0); return unionAll; }
/// <summary> /// Writes a geometry to a byte array using the specified encoding. /// </summary> /// <param name="g">The geometry to write</param> /// <param name="wkbByteOrder">Byte order</param> /// <returns>WKB representation of the geometry</returns> public static byte[] Write(IGeometry geometry, WkbByteOrder wkbByteOrder) { byte[] result = null; switch (wkbByteOrder) { case WkbByteOrder.Ndr: result = new WKBWriter(ByteOrder.LittleEndian).Write(geometry); break; case WkbByteOrder.Xdr: result = new WKBWriter(ByteOrder.BigEndian).Write(geometry); break; } return result; // MemoryStream ms = new MemoryStream(); // BinaryWriter bw = new BinaryWriter(ms); // // //Write the byteorder format. // bw.Write((byte)wkbByteOrder); // // //Write the type of this geometry // WriteType(g, bw, wkbByteOrder); // // //Write the geometry // WriteGeometry(g, bw, wkbByteOrder); // // return ms.ToArray(); }
public static IGeometry BufferMitredJoin(IGeometry g, double distance) { BufferParameters bufParams = new BufferParameters(); bufParams.JoinStyle = JoinStyle.Mitre; return BufferOp.Buffer(g, distance, bufParams); }
protected override byte[] Write(IGeometry gIn) { var geoWriter = new MsSql2008GeometryWriter(); var b = geoWriter.WriteGeometry(gIn); var b2 = geoWriter.Write(gIn); using( var conn = new SqlConnection(ConnectionString)) { conn.Open(); using (var cmd = conn.CreateCommand()) { cmd.CommandText = "INSERT INTO [nts_io_geometry] VALUES(@P1, @P2, @P3);"; var p1 = new SqlParameter("P1", SqlDbType.Int) { SqlValue = Counter }; var p2 = new SqlParameter("P2", SqlDbType.Text) { SqlValue = gIn.AsText() }; var p3 = new SqlParameter("P3", SqlDbType.Udt) { UdtTypeName = "geometry", SqlValue = b }; cmd.Parameters.AddRange(new[] { p1, p2, p3 }); cmd.ExecuteNonQuery(); /* p1.SqlValue = 100000 + Counter; cmd.Parameters.Remove(p3); p3 = new SqlParameter("P3", SqlDbType.Image) { SqlValue = b }; cmd.Parameters.Add(p3); p3.SqlValue = b2; cmd.ExecuteNonQuery(); */ } } return b2; }
/// <summary> /// Writes a GML feature into a generic <c>Stream</c>, such a <c>FileStream</c> or other streams. /// </summary> /// <param name="geometry"></param> /// <param name="stream"></param> public virtual void Write(IGeometry geometry, Stream stream) { XmlTextWriter writer = new XmlTextWriter(stream, null); writer.Formatting = Formatting.Indented; Write(geometry, writer); writer.Close(); }
/// <summary> /// /// </summary> /// <param name="p"></param> /// <param name="geom"></param> private void ComputeLocation(Coordinate p, IGeometry geom) { if (geom is ILineString) UpdateLocationInfo(Locate(p, geom)); else if (geom is IPolygon) UpdateLocationInfo(Locate(p, geom)); else if (geom is IMultiLineString) { IMultiLineString ml = (IMultiLineString)geom; foreach (ILineString l in ml.Geometries) UpdateLocationInfo(Locate(p, l)); } else if (geom is IMultiPolygon) { IMultiPolygon mpoly = (IMultiPolygon)geom; foreach (IPolygon poly in mpoly.Geometries) UpdateLocationInfo(Locate(p, poly)); } else if (geom is IGeometryCollection) { IEnumerator geomi = new GeometryCollection.Enumerator((IGeometryCollection)geom); while (geomi.MoveNext()) { IGeometry g2 = (IGeometry)geomi.Current; if (g2 != geom) ComputeLocation(p, g2); } } }
public SimplePointCursor(string filePath, IFields fields, int OID, System.Array fieldMap, IEnvelope queryEnv, esriGeometryType geomType) { //HIGHLIGHT: 0 - Set up cursor m_bIsFinished = false; m_pStreamReader = new System.IO.StreamReader(filePath); m_fields = fields; m_iOID = OID; m_fieldMap = fieldMap; m_searchEnv = queryEnv; switch (geomType) { case esriGeometryType.esriGeometryPolygon: m_wkGeom = new Polygon() as IGeometry; m_workPts = new PointClass[5]; for (int i = 0; i < m_workPts.Length; i++) m_workPts[i] = new PointClass(); break; case esriGeometryType.esriGeometryPolyline: m_wkGeom = new PolylineClass() as IGeometry; m_workPts = new PointClass[5]; for (int i = 0; i < m_workPts.Length; i++) m_workPts[i] = new PointClass(); break; case esriGeometryType.esriGeometryPoint: m_wkGeom = new PointClass() as IGeometry; break; default: //doesn't need to set worker geometry if it is table break; } //advance cursor so data is readily available this.NextRecord(); }
public static IGeometry MergeLines(IGeometry g) { LineMerger merger = new LineMerger(); merger.Add(g); IList<IGeometry> lines = merger.GetMergedLineStrings(); return g.Factory.BuildGeometry(lines); }
public static IGeometry densifiedDiscreteHausdorffDistanceLine(IGeometry a, IGeometry b, double frac) { var hausDist = new DiscreteHausdorffDistance(a, b); hausDist.DensifyFraction = frac; hausDist.Distance(); return a.Factory.CreateLineString(hausDist.Coordinates); }
//鼠标点击-空间查询 private void axMapControl1_OnMouseDown(object sender, ESRI.ArcGIS.Controls.IMapControlEvents2_OnMouseDownEvent e) { //1、高亮 axMapControl1.MousePointer = esriControlsMousePointer.esriPointerDefault; IActiveView pActiveView; IPoint pPoint; double length; //获取视图范围 pActiveView = this.axMapControl1.ActiveView; //获取鼠标点击屏幕坐标 pPoint = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(e.x, e.y); //屏幕距离转换为地图距离 length = ConvertPixelToMapUnits(pActiveView, 2); ITopologicalOperator pTopoOperator; IGeometry pGeoBuffer; //根据缓冲半径生成空间过滤器 pTopoOperator = pPoint as ITopologicalOperator; pGeoBuffer = pTopoOperator.Buffer(length); ILayer iLayer; //iLayer = Tool.GetLayerByName(axMapControl1.get_Layer(0).Name, axMapControl1); iLayer = axMapControl1.get_Layer(2);//地图图层编号!!! IFeatureLayer iFeatureLayer = (IFeatureLayer)iLayer; iFeatureLayer.Selectable = false;//地图不可选择 IMap pMap = axMapControl1.Map; //IGeometry pGeometry = axMapControl1.TrackRectangle(); //获取几何图框范围 ISelectionEnvironment pSelectionEnv = new SelectionEnvironment(); //新建选择环境 /*选择图层*/ IRgbColor pColor = new RgbColor(); pColor.Red = 200; pColor.Green = 155; pColor.Blue = 180; //调整高亮显示的颜色 pSelectionEnv.DefaultColor = pColor; //设置高亮显示的颜色 pMap.SelectByShape(pGeoBuffer, pSelectionEnv, false); //选择图形SelectByShape方法 //高亮后获得ID /*获取ID*/ ISelection selection = pMap.FeatureSelection; /*获取ID*/ IEnumFeatureSetup enumFeatureSetup = selection as IEnumFeatureSetup; //这里很必要 /*获取ID*/ enumFeatureSetup.AllFields = true; //这里很必要 IEnumFeature enumFeature = enumFeatureSetup as IEnumFeature; enumFeature.Reset(); //feature赋值 IFeature feature = enumFeature.Next(); //IFeatureClass pFeatureClass = pFeature.Class as IFeatureClass; while (feature != null) { stringvalue = feature.get_Value(0).ToString();//就可以得到任意字段的值了 feature = enumFeature.Next(); } axMapControl1.Refresh(esriViewDrawPhase.esriViewGeoSelection, null, null); // Thread.Sleep(2000); //2、省份查询 this.axMapControl1.MousePointer = esriControlsMousePointer.esriPointerCrosshair; //记录查询到的要素名称 string strNames = ""; //查询的字段名称 string strFieldName = "NL_NAME_1"; //点查询 //读取shp线 string strFielPath = @"res\RouteShp\" + stringvalue + ".shp";//D:\\NewShp\\line1.shp FileInfo fileInfo = new FileInfo(strFielPath); string fileDirectoryName = fileInfo.DirectoryName; string fileName = fileInfo.Name; //IWorkspaceFactory workspaceFactory = new ShapefileWorkspaceFactoryClass(); IWorkspaceFactory workspaceFactory = new ShapefileWorkspaceFactory(); IWorkspace workspace = workspaceFactory.OpenFromFile(fileDirectoryName, 0); IFeatureWorkspace featureWorkspace = workspace as IFeatureWorkspace; IFeatureClass featureClass = featureWorkspace.OpenFeatureClass(fileName); IFeatureCursor featureCursor = featureClass.Search(null, false); //访问要素类的一系列要素 对要素类进行查询返回的一个游标(即指向搜素结果集的一个指针) IFeature feature_q = featureCursor.NextFeature(); //将游标移动到结果集下一个要素并返回当前要素,这里将返回结果赋值给了pFeature while (feature_q != null) { IGeometry geoMetry = feature_q.Shape;//得到的每个数据 feature_q = featureCursor.NextFeature(); //提示框 strNames = strNames + QuerySpatial(this.axMapControl1, geoMetry, strFieldName); //提示框显示提示 this.lab_info.Text = strNames; } //3、获取所选路径终点名、花费 switch (stringvalue) { case "0": //七星鲁王宫 endPointname = "七星鲁王宫"; cost = "5542公里"; break; case "1": //西沙海底墓 endPointname = "西沙海底墓"; cost = "3284公里"; break; case "2": //秦岭神树 endPointname = "秦岭神树"; cost = "1867公里"; break; case "3": //西王母宫 endPointname = "西王母宫"; cost = "3433公里"; break; case "4": //张家鼓楼 endPointname = "张家鼓楼"; cost = "7528公里"; break; default: break; } lab_start.Text = startPointname; lab_end.Text = endPointname; lab_costAll.Text = cost; }
public static IGeometry FindNodePoints(IGeometry geom) { IList <Coordinate> intPts = FastNodingValidator.ComputeIntersections(SegmentStringUtil.ExtractNodedSegmentStrings(geom)); return(FunctionsUtil.GetFactoryOrDefault(null).CreateMultiPoint(CoordinateArrays.ToCoordinateArray(intPts))); }
/// <summary> /// Returns the boundary of this geometry. /// </summary> /// <param name="shape">The current geometry.</param> /// <returns></returns> public static IGeometry Boundary(this IGeometry shape) { return(((ITopologicalOperator)shape).Boundary); }
public static bool Covers(IGeometry g1, IGeometry g2) { var prepGeom = PreparedGeometryFactory.Prepare(g1); return(prepGeom.Covers(g2)); }
public static bool IsNodingValid(IGeometry geom) { FastNodingValidator nv = new FastNodingValidator(SegmentStringUtil.ExtractNodedSegmentStrings(geom)); return(nv.IsValid); }
public static Offset <Geometry> BuildGeometry(FlatBufferBuilder builder, IGeometry geometry) { // TODO: introspect? uint dimensions = 2; var coordinates = geometry.Coordinates .SelectMany(c => new double[] { c.X, c.Y }) .ToArray(); var coordsOffset = Geometry.CreateCoordsVector(builder, coordinates); var types = CreateTypes(geometry, dimensions); VectorOffset?typesOffset = null; if (types != null) { typesOffset = Geometry.CreateTypesVector(builder, types.ToArray()); } var lengths = CreateLengths(geometry, dimensions); VectorOffset?lengthsOffset = null; if (lengths != null) { lengthsOffset = Geometry.CreateLengthsVector(builder, lengths.ToArray()); } var ringLengths = CreateRingLengths(geometry, dimensions); VectorOffset?ringLengthsOffset = null; if (ringLengths != null) { ringLengthsOffset = Geometry.CreateRingLengthsVector(builder, ringLengths.ToArray()); } VectorOffset?ringCountsOffset = null; if (geometry is IGeometryCollection && geometry.NumGeometries > 1 && (geometry as IGeometryCollection).Geometries.Any(g => g is IPolygon)) { var gc = geometry as IGeometryCollection; var ringCounts = gc.Geometries .Where(g => g is IPolygon) .Select(g => g as IPolygon) .Select(p => (uint)p.InteriorRings.Length + 1); ringCountsOffset = Geometry.CreateRingCountsVector(builder, ringCounts.ToArray()); } Geometry.StartGeometry(builder); if (typesOffset.HasValue) { Geometry.AddTypes(builder, typesOffset.Value); } if (lengthsOffset.HasValue) { Geometry.AddLengths(builder, lengthsOffset.Value); } if (ringLengthsOffset.HasValue) { Geometry.AddRingLengths(builder, ringLengthsOffset.Value); } if (ringCountsOffset.HasValue) { Geometry.AddRingCounts(builder, ringCountsOffset.Value); } Geometry.AddCoords(builder, coordsOffset); var offset = Geometry.EndGeometry(builder); return(offset); }
/// <summary> /// Invokes the named operation /// </summary> /// <param name="opName"></param> /// <param name="geometry"></param> /// <param name="args"></param> /// <returns>The result</returns> /// <exception cref="Exception"></exception> /// <seealso cref="IGeometryOperation.Invoke"/> public IResult Invoke(XmlTestType opName, IGeometry geometry, Object[] args) { return(Invoke(opName.ToString(), geometry, args)); }
/***************************************************/ /**** Public Methods - Interfaces ****/ /***************************************************/ public static IGeometry ITransform(this IGeometry geometry, TransformMatrix transform) { return(Transform(geometry as dynamic, transform)); }
public static bool ContainsProperly(IGeometry g1, IGeometry g2) { var prepGeom = PreparedGeometryFactory.Prepare(g1); return(prepGeom.ContainsProperly(g2)); }
/***************************************************/ /**** Public Methods - Interfaces ****/ /***************************************************/ public static IEnumerable <IGeometry> ISubParts(this IGeometry geometry) { return(SubParts(geometry as dynamic)); }
public static IList <StrassenabschnittGIS> GenerateStrassenabschnittGIS(ISession session, ErfassungsPeriod currentPeriod, IList <AchsenSegment> achsensegmente) { var belastungskategories = session.Query <Belastungskategorie>().ToList(); var Massnahmen = session.Query <MassnahmenvorschlagKatalog>().Where(mvk => mvk.ErfassungsPeriod.Id == currentPeriod.Id).ToList(); Random rnd = new Random(); int achsensegmente_count = achsensegmente.Count; var generator = new RandomGenerator(); var strassenabschnittBuilder = Builder <StrassenabschnittGIS> .CreateListOfSize(achsensegmente_count) .All() .With(s => s.Belastungskategorie = Pick <Belastungskategorie> .RandomItemFrom(belastungskategories)) .With(s => s.Mandant = currentPeriod.Mandant) .With(s => s.ErfassungsPeriod = currentPeriod) .With(s => s.Strassenname = generator.Phrase(20)) .With(s => s.IsLocked = false) .With(s => s.Trottoir = Pick <TrottoirTyp> .RandomItemFrom(Enum.GetValues(typeof(TrottoirTyp)).Cast <TrottoirTyp>().ToList())); var strassenabschnitte = strassenabschnittBuilder.Build(); var pageSize = 1; var index = 0; foreach (var strassenabschnitt in strassenabschnitte) { strassenabschnitt.Shape = achsensegmente[index].Shape; IGeometry shape = strassenabschnitt.Shape; foreach (Coordinate coord in shape.Coordinates) { coord.Z = double.NaN; } switch (strassenabschnitt.Trottoir) { case TrottoirTyp.Links: strassenabschnitt.BreiteTrottoirLinks = (decimal)rnd.NextDouble() + 1; break; case TrottoirTyp.Rechts: strassenabschnitt.BreiteTrottoirRechts = (decimal)rnd.NextDouble() + 1; break; case TrottoirTyp.BeideSeiten: strassenabschnitt.BreiteTrottoirLinks = (decimal)rnd.NextDouble() + 1; strassenabschnitt.BreiteTrottoirRechts = (decimal)rnd.NextDouble() + 1; break; case TrottoirTyp.NochNichtErfasst: case TrottoirTyp.KeinTrottoir: default: break; } LengthIndexedLine indexedLine = new LengthIndexedLine(shape); strassenabschnitt.Laenge = Convert.ToDecimal(Math.Round(indexedLine.EndIndex, 1)); strassenabschnitt.ReferenzGruppe = new ReferenzGruppe(); strassenabschnitt.ReferenzGruppe.StrassenabschnittGISList.Add(strassenabschnitt); AchsenReferenz achsenreferenz = new AchsenReferenz(); achsenreferenz.ReferenzGruppe = strassenabschnitt.ReferenzGruppe; achsenreferenz.AchsenSegment = achsensegmente[index]; achsenreferenz.Shape = achsensegmente[index].Shape; achsenreferenz.ReferenzGruppe = strassenabschnitt.ReferenzGruppe; strassenabschnitt.ReferenzGruppe.AddAchsenReferenz(achsenreferenz); double linelength = indexedLine.EndIndex; for (int i = 0; i < pageSize; i++) { ZustandsabschnittGIS zustandsabschnitt = new ZustandsabschnittGIS(); zustandsabschnitt.StrassenabschnittGIS = strassenabschnitt; zustandsabschnitt.ReferenzGruppe = new ReferenzGruppe(); zustandsabschnitt.ReferenzGruppe.ZustandsabschnittGISList.Add(zustandsabschnitt); AchsenReferenz achsenreferenzzustandsabschnitt = new AchsenReferenz(); achsenreferenzzustandsabschnitt.ReferenzGruppe = zustandsabschnitt.ReferenzGruppe; achsenreferenzzustandsabschnitt.AchsenSegment = achsensegmente[index]; IGeometry subline = indexedLine.ExtractLine(linelength / pageSize * i, linelength / pageSize * (i + 1)); achsenreferenzzustandsabschnitt.Shape = subline; zustandsabschnitt.Shape = subline; zustandsabschnitt.Laenge = decimal.Parse(new LengthIndexedLine(subline).EndIndex.ToString()); zustandsabschnitt.Zustandsindex = Pick <decimal> .RandomItemFrom(new List <decimal> { 0, 1, 2, 3, 4, 5 }); zustandsabschnitt.Erfassungsmodus = ZustandsErfassungsmodus.Manuel; achsenreferenzzustandsabschnitt.ReferenzGruppe = zustandsabschnitt.ReferenzGruppe; zustandsabschnitt.ReferenzGruppe.AddAchsenReferenz(achsenreferenzzustandsabschnitt); zustandsabschnitt.Aufnahmedatum = DateTime.Now.Date; zustandsabschnitt.Aufnahmeteam = generator.Phrase(20); zustandsabschnitt.Bemerkung = generator.Phrase(40); zustandsabschnitt.BezeichnungVon = strassenabschnitt.BezeichnungVon + generator.Phrase(10); zustandsabschnitt.BezeichnungBis = strassenabschnitt.BezeichnungBis + generator.Phrase(10); strassenabschnitt.Zustandsabschnitten.Add(zustandsabschnitt); zustandsabschnitt.MassnahmenvorschlagFahrbahn = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Fahrbahn && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList()); zustandsabschnitt.DringlichkeitFahrbahn = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList()); switch (strassenabschnitt.Trottoir) { case TrottoirTyp.Links: zustandsabschnitt.MassnahmenvorschlagTrottoirLinks = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList()); zustandsabschnitt.ZustandsindexTrottoirLinks = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList()); zustandsabschnitt.DringlichkeitTrottoirLinks = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList()); break; case TrottoirTyp.Rechts: zustandsabschnitt.MassnahmenvorschlagTrottoirRechts = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList()); zustandsabschnitt.ZustandsindexTrottoirRechts = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList()); zustandsabschnitt.DringlichkeitTrottoirRechts = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList()); break; case TrottoirTyp.BeideSeiten: zustandsabschnitt.MassnahmenvorschlagTrottoirLinks = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList()); zustandsabschnitt.MassnahmenvorschlagTrottoirRechts = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList()); zustandsabschnitt.ZustandsindexTrottoirLinks = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList()); zustandsabschnitt.ZustandsindexTrottoirRechts = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList()); zustandsabschnitt.DringlichkeitTrottoirLinks = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList()); zustandsabschnitt.DringlichkeitTrottoirRechts = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList()); break; case TrottoirTyp.NochNichtErfasst: case TrottoirTyp.KeinTrottoir: default: break; } session.Save(zustandsabschnitt); } session.Save(strassenabschnitt); index++; } var test = strassenabschnitte.Where(s => s.IsLocked == true); return(strassenabschnitte); }
/// <summary> /// Creates a <c>Geometry</c> using the next token in the stream. /// </summary> /// <param name="tokens"> /// Tokenizer over a stream of text in Well-known Text /// format. The next tokens must form a <Geometry Tagged Text. /// </param> /// <returns>A <c>Geometry</c> specified by the next token /// in the stream.</returns> private IGeometry ReadGeometryTaggedText(IList tokens) { /* * A new different implementation by Marc Jacquin: * this code manages also SRID values. */ IGeometry returned = null; string sridValue = null; string type = tokens[0].ToString(); if (type == "SRID") { sridValue = tokens[2].ToString(); // tokens.RemoveRange(0, 4); tokens.RemoveAt(0); tokens.RemoveAt(0); tokens.RemoveAt(0); tokens.RemoveAt(0); } else { type = GetNextWord(tokens); } if (type.Equals("POINT")) { returned = ReadPointText(tokens); } else if (type.Equals("LINESTRING")) { returned = ReadLineStringText(tokens); } else if (type.Equals("LINEARRING")) { returned = ReadLinearRingText(tokens); } else if (type.Equals("POLYGON")) { returned = ReadPolygonText(tokens); } else if (type.Equals("MULTIPOINT")) { returned = ReadMultiPointText(tokens); } else if (type.Equals("MULTILINESTRING")) { returned = ReadMultiLineStringText(tokens); } else if (type.Equals("MULTIPOLYGON")) { returned = ReadMultiPolygonText(tokens); } else if (type.Equals("GEOMETRYCOLLECTION")) { returned = ReadGeometryCollectionText(tokens); } else { throw new ParseException("Unknown type: " + type); } if (returned == null) { throw new NullReferenceException("Error reading geometry"); } if (sridValue != null) { returned.SRID = Convert.ToInt32(sridValue); } return(returned); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private static IEnumerable <IGeometry> SubParts(this IGeometry geometry) { return(new List <IGeometry> { geometry }); }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformLineString(ILineString geom, IGeometry parent) { // should check for 1-point sequences and downgrade them to points return(factory.CreateLineString(TransformCoordinates(geom.CoordinateSequence, geom))); }
///<summary>Computes the <c>containsProperly</c> predicate between a <see cref="PreparedPolygon"/> and a <see cref="IGeometry"/>. ///</summary> /// <param name="prep">The prepared polygon</param> ///<param name="geom">A test geometry</param> /// <returns>true if the polygon properly contains the geometry</returns> public static bool ContainsProperly(PreparedPolygon prep, IGeometry geom) { PreparedPolygonContainsProperly polyInt = new PreparedPolygonContainsProperly(prep); return(polyInt.ContainsProperly(geom)); }
/// <summary> /// /// </summary> /// <param name="coords"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual ICoordinateSequence TransformCoordinates(ICoordinateSequence coords, IGeometry parent) { return(Copy(coords)); }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent) { ArrayList transGeomList = new ArrayList(); for (int i = 0; i < geom.NumGeometries; i++) { IGeometry transformGeom = Transform(geom.GetGeometryN(i)); if (transformGeom == null) { continue; } if (pruneEmptyGeometry && transformGeom.IsEmpty) { continue; } transGeomList.Add(transformGeom); } if (preserveGeometryCollectionType) { return(factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList))); } return(factory.BuildGeometry(transGeomList)); }
public static void Draw(SKCanvas canvas, IViewport viewport, IStyle style, IFeature feature, IGeometry geometry, float layerOpacity) { if (style is LabelStyle) { var worldCenter = geometry.GetBoundingBox().GetCentroid(); var center = viewport.WorldToScreen(worldCenter); LabelRenderer.Draw(canvas, (LabelStyle)style, feature, (float)center.X, (float)center.Y, layerOpacity); } else { var polygon = (Polygon)geometry; float lineWidth = 1; var lineColor = Color.Black; // default var fillColor = Color.Gray; // default var vectorStyle = style as VectorStyle; if (vectorStyle != null) { lineWidth = (float)vectorStyle.Outline.Width; lineColor = vectorStyle.Outline.Color; fillColor = vectorStyle.Fill?.Color; } using (var path = ToSkia(viewport, polygon)) { using (var paint = new SKPaint()) { paint.IsAntialias = true; paint.StrokeWidth = lineWidth; paint.Style = SKPaintStyle.Fill; paint.Color = fillColor.ToSkia(layerOpacity); canvas.DrawPath(path, paint); paint.Style = SKPaintStyle.Stroke; paint.Color = lineColor.ToSkia(layerOpacity); canvas.DrawPath(path, paint); } } } }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformPoint(IPoint geom, IGeometry parent) { return(factory.CreatePoint(TransformCoordinates(geom.CoordinateSequence, geom))); }