C# IMultiPoint类代码示例

        private static void GeometryToSqlGeometry(IMultiPoint geom, SqlGeometryBuilder bldr)
        {
            bldr.BeginGeometry(OpenGisGeometryType.MultiPoint);

            for (int i = 0, c = geom.NumGeometries; i < c; i++)
                GeometryToSqlGeometry(geom.Geometries[i] as IPoint, bldr);

            bldr.EndGeometry();
        }

 /// <summary>
 /// A MultiPoint is simple if it has no repeated points.
 /// </summary>
 public bool IsSimple(IMultiPoint mp)
 {
     if (mp.IsEmpty) 
         return true;
     ISet points = new ListSet();
     for (int i = 0; i < mp.NumGeometries; i++)
     {
         IPoint pt = (IPoint) mp.GetGeometryN(i);
         ICoordinate p = pt.Coordinate;
         if (points.Contains(p))
             return false;
         points.Add(p);
     }
     return true;
 }   

 public bool IsSimple(IMultiPoint mp)
 {
     return IsSimpleMultiPoint(mp);
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="geometry"></param>
 /// <returns></returns>
 protected virtual int SetByteStream(IMultiPoint geometry)
 {
     int count = INIT_COUNT;
     count += 4;     // NumPoints
     foreach (Point geom in geometry.Geometries)
         count += SetByteStream(geom);
     return count;
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <param name="writer"></param>
 protected virtual void Write(IMultiPoint multiPoint, BinaryWriter writer)
 {
     WriteByteOrder(writer);
     writer.Write((int)WkbGeometryType.MultiPoint);
     writer.Write(multiPoint.NumGeometries);
     for (int i = 0; i < multiPoint.NumGeometries; i++)
         Write(multiPoint.Geometries[i] as Point, writer);
 }

 /// <summary>
 /// Checks validity of a MultiPoint.
 /// </summary>
 /// <param name="g"></param>
 private void CheckValid(IMultiPoint g)
 {
     CheckInvalidCoordinates(g.Coordinates);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiPoint multiPoint, BinaryWriter writer)
 {
     WriteByteOrder(writer);     // LittleIndian
     writer.Write((int) WKBGeometryTypes.WKBMultiPoint);
     writer.Write((int) multiPoint.NumGeometries);
     for (int i = 0; i < multiPoint.NumGeometries; i++)
         Write(multiPoint.Geometries[i] as IPoint, writer);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiPoint multiPoint)
 {            
     int numPoints = multiPoint.NumPoints;
     return CalculateLength(numPoints);
 }        

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiPoint multiPoint)
 {
     int count = InitValue;
     foreach (IPoint p in multiPoint.Geometries)
         count += SetByteStreamLength(p);
     return count;
 }

 /// <summary>
 /// Converts a <c>MultiPoint</c> to &lt;MultiPoint Text format, then
 /// appends it to the writer.
 /// </summary>
 /// <param name="multiPoint">The <c>MultiPoint</c> to process.</param>
 /// <param name="level"></param>
 /// <param name="writer">The output writer to append to.</param>
 private void AppendMultiPointText(IMultiPoint multiPoint, int level, TextWriter writer)
 {
     if (multiPoint.IsEmpty) 
         writer.Write(" EMPTY");
     else 
     {
         writer.Write("(");
         for (int i = 0; i < multiPoint.NumGeometries; i++) 
         {
             if (i > 0) writer.Write(",");
             AppendCoordinate(((IPoint) multiPoint.GetGeometryN(i)).Coordinate, writer, multiPoint.PrecisionModel);
         }
         writer.Write(")");
     }
 }

 /// <summary>
 /// Converts a <c>MultiPoint</c> to &lt;MultiPoint Tagged Text
 /// format, then appends it to the writer.
 /// </summary>
 /// <param name="multipoint">The <c>MultiPoint</c> to process.</param>
 /// <param name="level"></param>
 /// <param name="writer">The output writer to append to.</param>
 private void AppendMultiPointTaggedText(IMultiPoint multipoint, int level, TextWriter writer)
 {
     writer.Write("MULTIPOINT");
     AppendMultiPointText(multipoint, level, writer);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="geom"></param>
 /// <param name="parent"></param>
 /// <returns></returns>
 protected virtual IGeometry TransformMultiPoint(IMultiPoint geom, IGeometry parent) 
 {
     ArrayList transGeomList = new ArrayList();
     for (int i = 0; i < geom.NumGeometries; i++) 
     {
         IGeometry transformGeom = TransformPoint((IPoint) geom.GetGeometryN(i), geom);
         if (transformGeom == null) continue;
         if (transformGeom.IsEmpty) continue;
         transGeomList.Add(transformGeom);
     }
     return factory.BuildGeometry(transGeomList);
 }

 /// <summary>
 /// Converts the <c>ICollection</c> to an array.
 /// </summary>
 /// <param name="multiPoints">The <c>ICollection</c> of MultiPoints to convert.</param>
 /// <returns>The <c>ICollection</c> in array format.</returns>
 public static IMultiPoint[] ToMultiPointArray(ICollection multiPoints)
 {
     IMultiPoint[] list = new IMultiPoint[multiPoints.Count];
     int i = 0;
     foreach (IMultiPoint mp in multiPoints)
         list[i++] = mp;
     return list;
 }

 private static DSMultiPoint FromMultiPoint(IMultiPoint geometry, DSGeometryFactory factory, bool setUserData)
 {
     var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
     if (setUserData)
         result.UserData = geometry.UserData;
     return result;
 }

 private static GeoAPIMultiPoint FromMultiPoint(IMultiPoint geometry, GeoAPIGeometryFactory factory, bool copyUserData)
 {
     var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
     if (copyUserData)
         result.UserData = geometry.UserData;
     return result;
 }