C# Geometry.GetType方法代码示例

		/// <summary>
		/// Transforms a <see cref="SharpMap.Geometries.Geometry"/>.
		/// </summary>
		/// <param name="g">Geometry to transform</param>
		/// <param name="transform">MathTransform</param>
		/// <returns>Transformed Geometry</returns>
		public static Geometry TransformGeometry(Geometry g, IMathTransform transform)
		{
			if (g==null)
				return null;
			else if (g is Point)
				return TransformPoint(g as Point, transform);
			else if (g is LineString)
				return TransformLineString(g as LineString, transform);
			else if (g is Polygon)
				return TransformPolygon(g as Polygon, transform);
			else if (g is MultiPoint)
				return TransformMultiPoint(g as MultiPoint, transform);
			else if (g is MultiLineString)
				return TransformMultiLineString(g as MultiLineString, transform);
			else if (g is MultiPolygon)
				return TransformMultiPolygon(g as MultiPolygon, transform);
			else
				throw new ArgumentException("Could not transform geometry type '" + g.GetType().ToString() +"'");
		}

 /// <summary>
 /// Transforms a <see cref="SharpMap.Geometries.Geometry"/>.
 /// </summary>
 /// <param name="g">Geometry to transform</param>
 /// <param name="from">Source Projection</param>
 /// <param name="to">Target Projection</param>
 /// <returns>Transformed Geometry</returns>
 public static Geometry TransformGeometry(Geometry g, ProjectionInfo from, ProjectionInfo to)
 {
     if (g == null)
         return null;
     if (g is Point)
         return TransformPoint(g as Point, from, to);
     if (g is LineString)
         return TransformLineString(g as LineString, from, to);
     if (g is Polygon)
         return TransformPolygon(g as Polygon, from, to);
     if (g is MultiPoint)
         return TransformMultiPoint(g as MultiPoint, from, to);
     if (g is MultiLineString)
         return TransformMultiLineString(g as MultiLineString, from, to);
     if (g is MultiPolygon)
         return TransformMultiPolygon(g as MultiPolygon, from, to);
     if (g is GeometryCollection)
         return TransformGeometryCollection(g as GeometryCollection, from, to);
     throw new ArgumentException("Could not transform geometry type '" + g.GetType() + "'");
 }

 /// <summary>
 /// Returns true if otherGeometry is of the same type and defines the same point set as the source geometry.
 /// </summary>
 /// <param name="g1">source geometry</param>
 /// <param name="g2">other Geometry</param>
 /// <returns></returns>
 public static bool Equals(Geometry g1, Geometry g2)
 {
     if (g1 == null && g2 == null)
         return true;
     if (g1 == null || g2 == null)
         return false;
     if (g1.GetType() != g2.GetType())
         return false;
     if (g1 is Point)
         return (g1 as Point).Equals(g2 as Point);
     if (g1 is LineString)
         return (g1 as LineString).Equals(g2 as LineString);
     if (g1 is Polygon)
         return (g1 as Polygon).Equals(g2 as Polygon);
     if (g1 is MultiPoint)
         return (g1 as MultiPoint).Equals(g2 as MultiPoint);
     if (g1 is MultiLineString)
         return (g1 as MultiLineString).Equals(g2 as MultiLineString);
     if (g1 is MultiPolygon)
         return (g1 as MultiPolygon).Equals(g2 as MultiPolygon);
     throw new ArgumentException("The method or operation is not implemented on this geometry type.");
 }

 /// <summary>
 /// Returns the distance between this geometry instance and another geometry, as
 /// measured in the spatial reference system of this instance.
 /// </summary>
 /// <param name="geom"></param>
 /// <returns></returns>
 public override double Distance(Geometry geom)
 {
     if (geom.GetType() == typeof (Point3D))
     {
         var p = geom as Point3D;
         return Math.Sqrt(Math.Pow(X - p.X, 2) + Math.Pow(Y - p.Y, 2) + Math.Pow(Z - p.Z, 2));
     }
     return base.Distance(geom);
 }

 /// <summary>
 ///     Writes the type number for this geometry.
 /// </summary>
 /// <param name="geometry">The geometry to determine the type of.</param>
 /// <param name="bWriter">Binary Writer</param>
 /// <param name="byteorder">Byte order</param>
 private static void WriteType(Geometry geometry, BinaryWriter bWriter, WkbByteOrder byteorder)
 {
     //Determine the type of the geometry.
     switch (geometry.GetType().FullName)
     {
         //Points are type 1.
         case "Mapsui.Geometries.Point":
             WriteUInt32((uint) WKBGeometryType.WKBPoint, bWriter, byteorder);
             break;
         //Linestrings are type 2.
         case "Mapsui.Geometries.LineString":
             WriteUInt32((uint) WKBGeometryType.WKBLineString, bWriter, byteorder);
             break;
         //Polygons are type 3.
         case "Mapsui.Geometries.Polygon":
             WriteUInt32((uint) WKBGeometryType.WKBPolygon, bWriter, byteorder);
             break;
         //Mulitpoints are type 4.
         case "Mapsui.Geometries.MultiPoint":
             WriteUInt32((uint) WKBGeometryType.WKBMultiPoint, bWriter, byteorder);
             break;
         //Multilinestrings are type 5.
         case "Mapsui.Geometries.MultiLineString":
             WriteUInt32((uint) WKBGeometryType.WKBMultiLineString, bWriter, byteorder);
             break;
         //Multipolygons are type 6.
         case "Mapsui.Geometries.MultiPolygon":
             WriteUInt32((uint) WKBGeometryType.WKBMultiPolygon, bWriter, byteorder);
             break;
         //Geometrycollections are type 7.
         case "Mapsui.Geometries.GeometryCollection":
             WriteUInt32((uint) WKBGeometryType.WKBGeometryCollection, bWriter, byteorder);
             break;
         //If the type is not of the above 7 throw an exception.
         default:
             throw new ArgumentException("Invalid Geometry Type");
     }
 }

 /// <summary>
 ///     Writes the geometry to the binary writer.
 /// </summary>
 /// <param name="geometry">The geometry to be written.</param>
 /// <param name="bWriter"></param>
 /// <param name="byteorder">Byte order</param>
 private static void WriteGeometry(Geometry geometry, BinaryWriter bWriter, WkbByteOrder byteorder)
 {
     switch (geometry.GetType().FullName)
     {
         //Write the point.
         case "Mapsui.Geometries.Point":
             WritePoint((Point) geometry, bWriter, byteorder);
             break;
         case "Mapsui.Geometries.LineString":
             var ls = (LineString) geometry;
             WriteLineString(ls, bWriter, byteorder);
             break;
         case "Mapsui.Geometries.Polygon":
             WritePolygon((Polygon) geometry, bWriter, byteorder);
             break;
         //Write the Multipoint.
         case "Mapsui.Geometries.MultiPoint":
             WriteMultiPoint((MultiPoint) geometry, bWriter, byteorder);
             break;
         //Write the Multilinestring.
         case "Mapsui.Geometries.MultiLineString":
             WriteMultiLineString((MultiLineString) geometry, bWriter, byteorder);
             break;
         //Write the Multipolygon.
         case "Mapsui.Geometries.MultiPolygon":
             WriteMultiPolygon((MultiPolygon) geometry, bWriter, byteorder);
             break;
         //Write the Geometrycollection.
         case "Mapsui.Geometries.GeometryCollection":
             WriteGeometryCollection((GeometryCollection) geometry, bWriter, byteorder);
             break;
         //If the type is not of the above 7 throw an exception.
         default:
             throw new ArgumentException("Invalid Geometry Type");
     }
 }

        /// <summary>
        /// Converts a Geometry to &lt;Geometry Tagged Text &gt; format, then Appends it to the writer.
        /// </summary>
        /// <param name="geometry">The Geometry to process.</param>
        /// <param name="level"></param>
        /// <param name="writer">The output stream to Append to.</param>
        protected void AppendGeometryTaggedText(Geometry geometry, int level, StringWriter writer)
        {
            Indent(level, writer);

            if (geometry is Point)
            {
                Point point = (Point) geometry;
                AppendPointTaggedText(point.getCoordinate(), level, writer, point.getPrecisionModel() );
            }
            else if (geometry is LineString)
            {
                AppendLineStringTaggedText((LineString) geometry, level, writer);
            }
            else if (geometry is Polygon)
            {
                AppendPolygonTaggedText((Polygon) geometry, level, writer);
            }
            else if (geometry is MultiPoint)
            {
                AppendMultiPointTaggedText((MultiPoint) geometry, level, writer);
            }
            else if (geometry is MultiLineString)
            {
                AppendMultiLineStringTaggedText((MultiLineString) geometry, level, writer);
            }
            else if (geometry is MultiPolygon)
            {
                AppendMultiPolygonTaggedText((MultiPolygon) geometry, level, writer);
            }
            else if (geometry is GeometryCollection)
            {
                AppendGeometryCollectionTaggedText((GeometryCollection) geometry, level, writer);
            }
            else
            {
                throw new NotSupportedException("Unsupported Geometry implementation:"+ geometry.GetType().Name);
            }
        }

 private void RenderGeometry(System.Drawing.Graphics g, Map map, Geometry feature, SharpMap.Styles.VectorStyle style)
 {
     switch (feature.GetType().FullName)
     {
         case "SharpMap.Geometries.Polygon":
             if (style.EnableOutline)
                 SharpMap.Rendering.VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, style.Outline, _ClippingEnabled, map);
             else
                 SharpMap.Rendering.VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, null, _ClippingEnabled, map);
             break;
         case "SharpMap.Geometries.MultiPolygon":
             if (style.EnableOutline)
                 SharpMap.Rendering.VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, style.Outline, _ClippingEnabled, map);
             else
                 SharpMap.Rendering.VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, null, _ClippingEnabled, map);
             break;
         case "SharpMap.Geometries.LineString":
             SharpMap.Rendering.VectorRenderer.DrawLineString(g, (LineString)feature, style.Line, map);
             break;
         case "SharpMap.Geometries.MultiLineString":
             SharpMap.Rendering.VectorRenderer.DrawMultiLineString(g, (MultiLineString)feature, style.Line, map);
             break;
         case "SharpMap.Geometries.Point":
             SharpMap.Rendering.VectorRenderer.DrawPoint(g, (Point)feature, style.Symbol, style.SymbolScale, style.SymbolOffset, style.SymbolRotation, map);
             break;
         case "SharpMap.Geometries.MultiPoint":
             SharpMap.Rendering.VectorRenderer.DrawMultiPoint(g, (MultiPoint)feature, style.Symbol, style.SymbolScale, style.SymbolOffset, style.SymbolRotation, map);
             break;
         case "SharpMap.Geometries.GeometryCollection":
             foreach (Geometries.Geometry geom in (GeometryCollection)feature)
                 RenderGeometry(g, map, geom, style);
             break;
         case "SharpMap.Geometries.GISCircle":
             SharpMap.Rendering.VectorRenderer.DrawCircle(g, (GISCircle)feature, style.Fill, style.Line, false, map);
             SharpMap.Rendering.VectorRenderer.DrawPoint(g, (Point)feature, style.Symbol, style.SymbolScale, style.SymbolOffset, style.SymbolRotation, map);
             break;
         default:
             break;
     }
 }

		/// <summary>
		/// Returns true if otherGeometry is of the same type and defines the same point set as the source geometry.
		/// </summary>
		/// <param name="g1">source geometry</param>
		/// <param name="g2">other Geometry</param>
		/// <returns></returns>
		public static bool Equals(Geometry g1, Geometry g2)
		{
			if (ReferenceEquals(g1, null) && ReferenceEquals(g2, null))
			{
				return true;
			}

			if (ReferenceEquals(g1, null) || ReferenceEquals(g2, null))
			{
				return false;
			}

			if (g1.GetType() != g2.GetType())
			{
				return false;
			}

			if (g1 is Point)
			{
				return (g1 as Point).Equals(g2 as Point);
			}
			else if (g1 is LineString)
			{
				return (g1 as LineString).Equals(g2 as LineString);
			}
			else if (g1 is Polygon)
			{
				return (g1 as Polygon).Equals(g2 as Polygon);
			}
			else if (g1 is MultiPoint)
			{
				return (g1 as MultiPoint).Equals(g2 as MultiPoint);
			}
			else if (g1 is MultiLineString)
			{
				return (g1 as MultiLineString).Equals(g2 as MultiLineString);
			}
			else if (g1 is MultiPolygon)
			{
				return (g1 as MultiPolygon).Equals(g2 as MultiPolygon);
			}
			else if (g1 is GeometryCollection)
			{
				if ((g1 as GeometryCollection).Collection.Count != (g2 as GeometryCollection).Collection.Count)
				{
					return false;
				}

				for (int i = 0; i < (g1 as GeometryCollection).Collection.Count; i++)
				{
					if (!Equals((g1 as GeometryCollection)[i], (g2 as GeometryCollection)[i]))
					{
						return false;
					}
				}

				return true;
			}
			else
			{
				throw new ArgumentException("The method or operation is not implemented on this geometry type.");
			}
		}

		/// <summary>
		/// Returns the distance between this geometry instance and another geometry, as
		/// measured in the spatial reference system of this instance.
		/// </summary>
		/// <param name="geom"></param>
		/// <returns></returns>
        public override double Distance(Geometry geom)
        {
			if (geom.GetType() == typeof(SharpMap.Geometries.Point3D))
			{
				Point3D p = geom as Point3D;
				return Math.Sqrt(Math.Pow(this.X - p.X, 2) + Math.Pow(this.Y - p.Y, 2) + Math.Pow(this.Z - p.Z, 2));
			}
			else
				return base.Distance(geom);
        }

        /// <summary>
        /// Converts a Geometry to &lt;Geometry Tagged Text &gt; format, then Appends it to the writer.
        /// </summary>
        /// <param name="geometry">The Geometry to process.</param>
        /// <param name="writer">The output stream to Append to.</param>
        private static void AppendGeometryTaggedText(Geometry geometry, StringWriter writer)
        {
            if (geometry == null)
                throw new NullReferenceException("Cannot write Well-Known Text: geometry was null");

            if (geometry is MapPoint)
            {
                MapPoint point = geometry as MapPoint;
                AppendPointTaggedText(point, writer);
            }
            else if (geometry is Polyline && ((Polyline)geometry).Paths.Count() == 1)
                AppendLineStringTaggedText(geometry as Polyline, writer);
            else if (geometry is Envelope)
                AppendEnvelope(geometry as Envelope, writer);
            else if (geometry is Polygon && OnlyOneExteriorRing((Polygon)geometry))
                AppendPolygonTaggedText(geometry as Polygon, writer);
            else if (geometry is MultiPoint)
                AppendMultiPointTaggedText(geometry as MultiPoint, writer);
            else if (geometry is Polyline)
                AppendMultiLineStringTaggedText(geometry as Polyline, writer);
            else if (geometry is Polygon)
                AppendMultiPolygonTaggedText(geometry as Polygon, writer);
            //else if (geometry is GeometryCollection)
            //	AppendGeometryCollectionTaggedText(geometry as List<Geometry>, writer);
            else
                throw new NotSupportedException("Unsupported Geometry implementation:" + geometry.GetType().Name);
        }

 /// <summary>
 /// Converts a Geometry to &lt;Geometry Tagged Text &gt; format, then Appends it to the writer.
 /// </summary>
 /// <param name="geometry">The Geometry to process.</param>
 /// <param name="writer">The output stream to Append to.</param>
 public void AppendGeometryTaggedText(Geometry geometry, TextWriter writer)
 {
     if (geometry is Point)
     {
         Point point = (Point) geometry;
         AppendPointTaggedText(point.getCoordinate(), writer, _precisionModel);
     }
     else if (geometry is LineString)
     {
         AppendLineStringTaggedText((LineString) geometry,  writer);
     }
     else if (geometry is Polygon)
     {
         AppendPolygonTaggedText((Polygon) geometry,  writer);
     }
     else if (geometry is MultiPoint)
     {
         AppendMultiPointTaggedText((MultiPoint) geometry,  writer);
     }
     else if (geometry is MultiLineString)
     {
         AppendMultiLineStringTaggedText((MultiLineString) geometry,  writer);
     }
     else if (geometry is MultiPolygon)
     {
         AppendMultiPolygonTaggedText((MultiPolygon) geometry,  writer);
     }
     else if (geometry is GeometryCollection)
     {
         AppendGeometryCollectionTaggedText((GeometryCollection) geometry,  writer);
     }
     else
     {
         throw new NotSupportedException("Unsupported Geometry implementation:"+ geometry.GetType().Name);
     }
 }

        private void RenderGeometry(System.Drawing.Graphics g, SharpMap.Map map, Geometry feature, SharpMap.Styles.VectorStyle style)
        {
            System.Drawing.Region gp = null;
            
            switch (feature.GetType().FullName)
            {
                case "SharpMap.Geometries.Polygon":
                    if (style.EnableOutline)
                        SharpMap.Rendering.VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, style.Outline, _ClippingEnabled, map);
                    else
                        SharpMap.Rendering.VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, null, _ClippingEnabled, map);
                    break;
                case "SharpMap.Geometries.MultiPolygon":
                    if (style.EnableOutline)
                        SharpMap.Rendering.VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, style.Outline, _ClippingEnabled, map);
                    else
                        SharpMap.Rendering.VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, null, _ClippingEnabled, map);
                    break;
                case "SharpMap.Geometries.LineString":
                    gp = InteractiveRenderer.DrawLineString(g, (LineString)feature, style.Line, map);
                    break;
                case "SharpMap.Geometries.MultiLineString":
                    SharpMap.Rendering.VectorRenderer.DrawMultiLineString(g, (MultiLineString)feature, style.Line, map);
                    break;
                case "SharpMap.Geometries.Point":
                    gp = InteractiveRenderer.DrawPoint(g, (Point)feature, style.Symbol, style.SymbolScale, style.SymbolOffset, style.SymbolRotation, map);
                    break;
                case "SharpMap.Geometries.MultiPoint":
                    SharpMap.Rendering.VectorRenderer.DrawMultiPoint(g, (MultiPoint)feature, style.Symbol, style.SymbolScale, style.SymbolOffset, style.SymbolRotation, map);
                    break;
                case "SharpMap.Geometries.GeometryCollection":
                    foreach(SharpMap.Geometries.Geometry geom in (GeometryCollection)feature)
                        RenderGeometry(g, map, geom, style);
                    break;
                default:
                    break;
            }

            if (gp != null && map is InteractiveMap && style is InteractiveStyle)
            {
                InteractiveMap imap = map as InteractiveMap;
                InteractiveStyle istyle = style as InteractiveStyle;
                ToolTipInfo info = new ToolTipInfo();
                info.Bitmap = istyle.Symbol;
                info.Description = istyle.PopUpText;
                info.Id = istyle.PopUpId;

                string layerName = istyle.PopUpCategory;
                if (string.IsNullOrEmpty(istyle.PopUpCategory))
                    layerName = LayerName;

                imap.AddObject(gp, layerName, info, g);
            }
        }