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);
 }
Example #2
0
        /// <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;
        }
Example #3
0
		/// <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));
 }
Example #6
0
 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);
        }
Example #9
0
//		#region Methods

		/// <summary>
		/// Converts a Geometry to its Well-known Text representation.
		/// </summary>
		/// <param name="geometry">A Geometry to write.</param>
		/// <returns>A &lt;Geometry Tagged Text&gt; 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();
		}
Example #10
0
        /// <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;
		}
Example #13
0
        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);;
        }
Example #15
0
 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);
     }
 }
Example #17
0
 /// <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;
 }
Example #20
0
        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;
 }
Example #23
0
		/// <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;
        }
Example #26
0
 /// <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();
 }
Example #27
0
 /// <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);
 }
Example #31
0
        //鼠标点击-空间查询
        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)));
        }
Example #33
0
 /// <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);
 }
Example #34
0
            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);
        }
Example #36
0
        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);
        }
Example #37
0
 /// <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));
 }
Example #38
0
        /***************************************************/
        /**** Public Methods - Interfaces               ****/
        /***************************************************/

        public static IGeometry ITransform(this IGeometry geometry, TransformMatrix transform)
        {
            return(Transform(geometry as dynamic, transform));
        }
Example #39
0
            public static bool ContainsProperly(IGeometry g1, IGeometry g2)
            {
                var prepGeom = PreparedGeometryFactory.Prepare(g1);

                return(prepGeom.ContainsProperly(g2));
            }
Example #40
0
        /***************************************************/
        /**** Public Methods - Interfaces               ****/
        /***************************************************/

        public static IEnumerable <IGeometry> ISubParts(this IGeometry geometry)
        {
            return(SubParts(geometry as dynamic));
        }
Example #41
0
        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);
        }
Example #42
0
        /// <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 &lt;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);
        }
Example #43
0
        /***************************************************/
        /**** 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));
        }
Example #48
0
        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)));
 }