/// <summary>
/// Converts an SharpMap Geometry to a FDO geometry
/// </summary>
/// <param name="geom">The SharpMap geometry</param>
/// <returns></returns>
public static FdoGeometry ToFdoGeometry(Sm.Geometry geom)
{
//Get the WKB form of the geometry
byte[] wkb = GeometryToWKB.Write(geom);
Fdo.IGeometry fg = FdoGeometryFactory.Instance.CreateGeometryFromWkb(wkb);
return(new FdoGeometry(fg));
}
/// <summary>
/// Creates the polygon from an envelope.
/// </summary>
/// <param name="env">The envelope.</param>
/// <returns></returns>
public static Fdo.IPolygon CreatePolygonFromEnvelope(Fdo.IEnvelope env)
{
FdoGeometryFactory fact = FdoGeometryFactory.Instance;
Fdo.IGeometry geom = fact.CreateGeometry(env);
return((Fdo.IPolygon)geom);
}
public static GeoAPI.Geometries.IGeometry ConvertTo(OSGeo.FDO.Geometry.IGeometry geometry)
{
//GisSharpBlog.NetTopologySuite.IO.WKTReader wktReader = new GisSharpBlog.NetTopologySuite.IO.WKTReader();
//GeoAPI.Geometries.IGeometry ntsGeometry = wktReader.Read( geometry.Text );
//return ntsGeometry;
GisSharpBlog.NetTopologySuite.IO.WKBReader wkbReader = new GisSharpBlog.NetTopologySuite.IO.WKBReader();
FgfGeometryFactory geometryFactory = new FgfGeometryFactory();
GeoAPI.Geometries.IGeometry ntsGeometry = wkbReader.Read(geometryFactory.GetWkb(geometry));
return(ntsGeometry);
}
public SharpMap.Geometries.BoundingBox GetExtents()
{
SharpMap.Geometries.BoundingBox bbox = null;
if (_data == null || _data.Rows.Count == 0 || string.IsNullOrEmpty(_data.GeometryColumn))
{
return(new SharpMap.Geometries.BoundingBox(0.0, 0.0, 0.0, 0.0));
}
foreach (FdoFeature feat in _data.Rows)
{
if (feat[_data.GeometryColumn] != null && feat[_data.GeometryColumn] != DBNull.Value)
{
try
{
OSGeo.FDO.Geometry.IGeometry geom = (OSGeo.FDO.Geometry.IGeometry)feat[_data.GeometryColumn];
if (bbox != null)
{
if (geom.Envelope.MaxX > bbox.Max.X)
{
bbox.Max.X = geom.Envelope.MaxX;
}
if (geom.Envelope.MaxY > bbox.Max.Y)
{
bbox.Max.Y = geom.Envelope.MaxY;
}
if (geom.Envelope.MinX < bbox.Min.X)
{
bbox.Min.X = geom.Envelope.MinX;
}
if (geom.Envelope.MinY < bbox.Min.Y)
{
bbox.Min.Y = geom.Envelope.MinY;
}
}
else
{
bbox = new SharpMap.Geometries.BoundingBox(geom.Envelope.MinX, geom.Envelope.MinY, geom.Envelope.MaxX, geom.Envelope.MaxY);
}
}
catch { }
}
}
if (bbox != null)
{
return(bbox);
}
else
{
return(new SharpMap.Geometries.BoundingBox(0.0, 0.0, 0.0, 0.0));
}
}
private static void _PopulateSimpleType(IGeometrySink sink, FGeometry.IGeometry geometry)
{
sink.BeginGeometry(GeometryTypeUtils.Convert(geometry.DerivedType));
switch (geometry.DerivedType)
{
case FCommon.GeometryType.GeometryType_LineString:
using (FGeometry.DirectPositionCollection positions = ((FGeometry.ILineString)geometry).Positions)
CreateFigure(sink, positions);
break;
case FCommon.GeometryType.GeometryType_Point:
using (FGeometry.DirectPositionCollection positions = new FGeometry.DirectPositionCollection())
using (FGeometry.IDirectPosition dp = ((FGeometry.IPoint)geometry).Position)
{
positions.Add(dp);
CreateFigure(sink, positions);
}
break;
case FCommon.GeometryType.GeometryType_Polygon:
{
var polygon = (FGeometry.IPolygon)geometry;
using (FGeometry.ILinearRing exterior = polygon.ExteriorRing)
using (FGeometry.DirectPositionCollection positions = exterior.Positions)
CreateFigure(sink, positions);
for (int i = 0; i < polygon.InteriorRingCount; ++i)
{
using (FGeometry.ILinearRing interior = polygon.GetInteriorRing(i))
using (FGeometry.DirectPositionCollection positions = interior.Positions)
CreateFigure(sink, positions);
}
}
break;
default:
throw new NotSupportedException(
string.Format(
CultureInfo.CurrentCulture,
SR.UnsupportedGeometryTypeException,
geometry.DerivedType
)
);
}
sink.EndGeometry();
}
/// <summary>Creates a new instance of the <see cref="FdoGeometry" /> class that encapsulates
/// a copy of the specified FDO geometry, in the specified coordinate system.</summary>
/// <param name="geometry">The FDO geometry for which a copy will be encapsulated.</param>
/// <param name="coordinateSystem">The coordinate system of the encapsulated FDO geometry.</param>
/// <remarks>
/// <para>This instance encapsulates a copy of the specified <paramref name="geometry" />. It is thus
/// the responsibility of the caller to <see cref="IDisposable.Dispose()" /> the specified <paramref name="geometry" />.</para>
/// </remarks>
public FdoGeometry(FGeometry.IGeometry geometry, ICoordinateSystem coordinateSystem)
{
Debug.Assert(geometry != null);
if (geometry == null)
{
throw new ArgumentNullException("geometry");
}
Debug.Assert(coordinateSystem != null);
if (coordinateSystem == null)
{
throw new ArgumentNullException("coordinateSystem");
}
_Geometry = FdoGeometryBuilder.Factory.CreateGeometry(geometry);
_CoordinateSystem = coordinateSystem;
}
/// <summary>
/// Converts an FDO Geometry to a SharpMap geometry
/// </summary>
/// <param name="geom">The FDO geometry</param>
/// <returns></returns>
public static Sm.Geometry FromFdoGeometry(FdoGeometry geom, OSGeo.FDO.Geometry.FgfGeometryFactory geomFactory)
{
if (FdoGeometryUtil.Is2D(geom.InternalInstance))
{
//Get the WKB form of the geometry
byte[] wkb = FdoGeometryFactory.Instance.GetWkb(geom.InternalInstance);
return(GeometryFromWKB.Parse(wkb));
}
else
{
using (OSGeo.FDO.Geometry.IGeometry flattened = FdoGeometryUtil.Flatten(geom.InternalInstance, geomFactory))
{
//Get the WKB form of the geometry
byte[] wkb = FdoGeometryFactory.Instance.GetWkb(flattened);
return(GeometryFromWKB.Parse(wkb));
}
}
}
/// <summary>Applies a geometry type call sequence to the specified <paramref name="sink" />.</summary>
/// <param name="sink">The sink to populate.</param>
/// <remarks>
/// <para>The call sequence is a set of figures, lines, and points for geometry types.</para>
/// </remarks>
public void Populate(IGeometrySink sink)
{
sink.SetCoordinateSystem(CoordinateSystem);
switch (_Geometry.DerivedType)
{
case FCommon.GeometryType.GeometryType_LineString:
case FCommon.GeometryType.GeometryType_Point:
case FCommon.GeometryType.GeometryType_Polygon:
_PopulateSimpleType(sink, _Geometry);
break;
case FCommon.GeometryType.GeometryType_MultiLineString:
sink.BeginGeometry(GeometryTypeUtils.Convert(_Geometry.DerivedType));
{
var multiLineString = (FGeometry.IMultiLineString)_Geometry;
for (int i = 0; i < multiLineString.Count; ++i)
{
using (FGeometry.ILineString lineString = multiLineString[i])
_PopulateSimpleType(sink, lineString);
}
}
sink.EndGeometry();
break;
case FCommon.GeometryType.GeometryType_MultiPoint:
sink.BeginGeometry(GeometryTypeUtils.Convert(_Geometry.DerivedType));
{
var multiPoint = (FGeometry.IMultiPoint)_Geometry;
using (FGeometry.DirectPositionCollection positions = new FGeometry.DirectPositionCollection())
for (int i = 0; i < multiPoint.Count; ++i)
{
using (FGeometry.IPoint point = multiPoint[i])
_PopulateSimpleType(sink, point);
}
}
sink.EndGeometry();
break;
case FCommon.GeometryType.GeometryType_MultiPolygon:
sink.BeginGeometry(GeometryTypeUtils.Convert(_Geometry.DerivedType));
{
var multiPolygon = (FGeometry.IMultiPolygon)_Geometry;
for (int i = 0; i < multiPolygon.Count; ++i)
{
using (FGeometry.IPolygon polygon = multiPolygon[i])
_PopulateSimpleType(sink, polygon);
}
}
sink.EndGeometry();
break;
case FCommon.GeometryType.GeometryType_MultiGeometry:
sink.BeginGeometry(GeometryTypeUtils.Convert(_Geometry.DerivedType));
{
var multiGeometry = (FGeometry.IMultiGeometry)_Geometry;
for (int i = 0; i < multiGeometry.Count; ++i)
{
using (FGeometry.IGeometry geometry = multiGeometry[i])
_PopulateSimpleType(sink, geometry);
}
}
sink.EndGeometry();
break;
default:
throw new NotSupportedException(
string.Format(
CultureInfo.CurrentCulture,
SR.UnsupportedGeometryTypeException,
_Geometry.DerivedType
)
);
}
}
