public IGeometry CreateGeometry(ICoordinateSequence coordinates, OgcGeometryType type)
{
switch (type)
{
case OgcGeometryType.Point:
return(CreatePoint(coordinates));
case OgcGeometryType.LineString:
return(CreateLineString(coordinates));
case OgcGeometryType.Polygon:
return(CreatePolygon(coordinates));
case OgcGeometryType.MultiPoint:
return(CreateMultiPoint(coordinates));
case OgcGeometryType.MultiPolygon:
return(CreateMultiPolygon(coordinates));
case OgcGeometryType.MultiLineString:
case OgcGeometryType.GeometryCollection:
case OgcGeometryType.Geometry:
case OgcGeometryType.Curve:
case OgcGeometryType.Surface:
case OgcGeometryType.MultiSurface:
case OgcGeometryType.MultiCurve:
default:
throw new NotSupportedException("Geometry type not supported: " + type);
}
}
public static PostGis2GeometryType ToPostGis2(this OgcGeometryType self)
{
switch (self)
{
case OgcGeometryType.Point:
case OgcGeometryType.LineString:
case OgcGeometryType.Polygon:
case OgcGeometryType.MultiPoint:
case OgcGeometryType.MultiLineString:
case OgcGeometryType.MultiPolygon:
case OgcGeometryType.GeometryCollection:
case OgcGeometryType.CircularString:
case OgcGeometryType.CompoundCurve:
case OgcGeometryType.MultiCurve:
case OgcGeometryType.MultiSurface:
return((PostGis2GeometryType)self);
case OgcGeometryType.PolyhedralSurface:
return(PostGis2GeometryType.PolyhedralSurface);
case OgcGeometryType.TIN:
return(PostGis2GeometryType.TIN);
default:
throw new InvalidOperationException();
}
}
public void TestSanD(OgcGeometryType type, int num, bool threeD)
{
var fc = new FeatureCollection();
for (int i = 0; i < num; i++)
{
fc.Add(FeatureFactory.Create(type, ("id", TypeCode.Int32),
("label", TypeCode.String), ("number1", TypeCode.Double),
("number2", TypeCode.Int64)
));
}
var options = DefaultOptions;
options.IgnoreNullValues = true;
string json = ToJsonString(fc, options);
var d = Deserialize(json, options);
Assert.That(d, Is.Not.Null);
Assert.That(d.Count, Is.EqualTo(fc.Count));
for (int i = 0; i < fc.Count; i++)
{
FeatureConverterTest.CheckEquality(fc[i], d[i]);
}
}
public PostGisProvider(IGeometryFactory geometryFactory, string connectionString,
string tableSchema, string tableName, string oidColumn, string geometryColumn,
ICoordinateTransformationFactory coordinateTransformationFactory)
: base(
new PostGisDbUtility(), geometryFactory, connectionString, tableSchema,
tableName,
oidColumn,
geometryColumn,
coordinateTransformationFactory)
{
using (NpgsqlConnection cn = (NpgsqlConnection)DbUtility.CreateConnection(connectionString))
{
try
{
cn.Open();
if (!PostGisProviderStatic.Has_X_Privilege(cn, "table", "\"public\".\"geometry_columns\"", "SELECT"))
{
throw new PostGisException(
"Insufficient rights to access table \"public\".\"geometry_columns\"!");
}
if (
!PostGisProviderStatic.Has_X_Privilege(cn, "table",
string.Format("\"{0}\".\"{1}\"", tableSchema, tableName),
"SELECT"))
{
throw new PostGisException(string.Format(
"Insufficient rights to access table \"{0}\".\"{1}\"!",
tableSchema, tableName));
}
NpgsqlCommand cmd = (NpgsqlCommand)DbUtility.CreateCommand();
cmd.Connection = cn;
cmd.CommandText =
@"SELECT x.""type""
FROM ""public"".""geometry_columns"" AS x
WHERE (x.""f_table_schema""=:p0 AND x.""f_table_name""=:p1 AND x.""f_geometry_column""=:p2);";
cmd.Parameters.Add(DbUtility.CreateParameter("p0", tableSchema, ParameterDirection.Input));
cmd.Parameters.Add(DbUtility.CreateParameter("p1", tableName, ParameterDirection.Input));
cmd.Parameters.Add(DbUtility.CreateParameter("p2", geometryColumn, ParameterDirection.Input));
NpgsqlDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
if (dr.HasRows)
{
dr.Read();
//valid geometry type
_validGeometryType = parseGeometryType(dr.GetString(0));
}
else
{
_validGeometryType = OgcGeometryType.Geometry;
}
}
catch (Exception)
{
_validGeometryType = OgcGeometryType.Unknown;
}
}
}
// [InlineData(OgcGeometryType.MultiPolygon, true)]
public async Task Should_Destructure_NetTopologySuite_Geometry(OgcGeometryType type, bool threeD)
{
var geometry = new FeatureFactory().CreateRandomGeometry(type, threeD);
using var _ = CaptureLogs(out var logs);
Logger.LogInformation("This is just a test {@Data}", geometry);
await Verify(logs.Select(z => z.RenderMessage())).UseParameters(type, threeD);
}
private string GetStyle(OgcGeometryType geometryType, string color, bool isText, Dictionary <String, String> styles)
{
string r = color.ToLower().Substring(1, 2);
string g = color.ToLower().Substring(3, 2);
string b = color.ToLower().Substring(5, 2);
color = b + g + r;
string styleId = null;
switch (geometryType)
{
case OgcGeometryType.Point:
if (isText)
{
styleId = "T" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><IconStyle><scale>0.00001</scale></IconStyle><LabelStyle><color>ff{1}</color></LabelStyle></Style>", styleId, color));
}
}
else
{
styleId = "P" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><IconStyle><color>ff{1}</color><Icon><href>http://maps.google.com/mapfiles/kml/pal4/icon57.png</href></Icon></IconStyle></Style>", styleId, color));
}
}
break;
case OgcGeometryType.LineString:
styleId = "L" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><LineStyle><color>ff{1}</color><width>2</width></LineStyle></Style>", styleId, color));
}
break;
case OgcGeometryType.Polygon:
styleId = "A" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><PolyStyle><color>80{1}</color></PolyStyle><LineStyle><color>ff{1}</color><width>2</width></LineStyle></Style>", styleId, color));
}
break;
}
return(styleId);
}
private DataTable GetShapeTable(string sql, OgcGeometryType geometryType)
{
DataTable table = null;
using (OleDbConnection connection = AppContext.GetDatabaseConnection())
{
table = new DataTable();
using (OleDbDataAdapter adapter = new OleDbDataAdapter(sql, connection))
{
adapter.Fill(table);
}
table.Columns["Shape"].ColumnName = "ShapeString";
switch (geometryType)
{
case OgcGeometryType.Point: table.Columns.Add("Shape", typeof(IPoint)); break;
case OgcGeometryType.LineString: table.Columns.Add("Shape", typeof(IMultiLineString)); break;
case OgcGeometryType.Polygon: table.Columns.Add("Shape", typeof(IMultiPolygon)); break;
}
WKTReader wktReader = new WKTReader();
foreach (DataRow row in table.Rows)
{
switch (geometryType)
{
case OgcGeometryType.Point:
row["Shape"] = (IPoint)wktReader.Read((string)row["ShapeString"]);
break;
case OgcGeometryType.LineString:
ILineString lineString = (ILineString)wktReader.Read((string)row["ShapeString"]);
IMultiLineString multiLineString = new MultiLineString(new ILineString[] { lineString });
row["Shape"] = multiLineString;
break;
case OgcGeometryType.Polygon:
IPolygon polygon = (IPolygon)wktReader.Read((string)row["ShapeString"]);
IMultiPolygon multiPolygon = new MultiPolygon(new IPolygon[] { polygon });
row["Shape"] = multiPolygon;
break;
}
}
table.Columns.Remove("ShapeString");
}
return(table);
}
private IEnumerable <Coordinate[]> WriteFeature(JsonWriter writer, JsonSerializer serializer, IFeature feature)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
if (feature == null)
{
throw new ArgumentNullException("feature");
}
Coordinate[][] arcs;
writer.WriteStartObject();
IGeometry geom = feature.Geometry;
writer.WritePropertyName("type");
writer.WriteValue(geom.GeometryType);
OgcGeometryType type = geom.OgcGeometryType;
switch (type)
{
case OgcGeometryType.Point:
WriteGeom(writer, serializer, (IPoint)geom);
arcs = null;
break;
case OgcGeometryType.LineString:
arcs = WriteGeom(writer, (ILineString)geom);
break;
case OgcGeometryType.Polygon:
arcs = WriteGeom(writer, (IPolygon)geom);
break;
default:
string err = String.Format("type unsupported: {0}", type);
throw new ArgumentOutOfRangeException(err);
}
// properties
writer.WritePropertyName("properties");
serializer.Serialize(writer, feature.Attributes);
writer.WriteEndObject();
return(arcs);
}
public PostGis_Provider(IGeometryFactory geometryFactory, string connectionString,
string tableSchema, string tableName, string oidColumn, string geometryColumn)
: base(
new PostGis_Utility(), geometryFactory, connectionString, tableSchema,
tableName,
oidColumn,
geometryColumn)
{
using (NpgsqlConnection cn = new NpgsqlConnection(connectionString))
{
cn.Open();
try
{
String selectClause = string.Format("SELECT type, srid FROM {0}.geometry_columns WHERE (f_table_name='{1}' AND f_geometry_column='{2}')",
tableSchema, tableName, geometryColumn);
NpgsqlDataReader dr = new NpgsqlCommand(selectClause, cn).ExecuteReader();
if (dr.HasRows)
{
dr.Read();
//valid geometry type
_validGeometryType = parseGeometryType(dr.GetString(0));
//Srid
Srid = dr.GetInt32(1).ToString();
if (geometryFactory.Srid == null)
{
geometryFactory.Srid = Srid;
}
else
{
//geometryFactory.SpatialReference
}
}
else
{
dr.Close();
selectClause = string.Format("SELECT ST_SRID({0}) FROM {1}.{2} LIMIT 1;", geometryColumn, tableSchema, tableName);
Srid = ((Int32) new NpgsqlCommand(selectClause, cn).ExecuteScalar()).ToString();
_validGeometryType = OgcGeometryType.Geometry;
}
}
catch (Exception)
{
_validGeometryType = OgcGeometryType.Unknown;
}
}
}
public static IGeometryCollection CreateShapes(OgcGeometryType type, Ordinates ordinates, int number = 50)
{
var empty = new bool[number];
empty[Rnd.Next(2, number / 2)] = true;
empty[Rnd.Next(number / 2, number)] = true;
var result = new IGeometry[number];
for (var i = 0; i < number; i++)
{
switch (type)
{
case OgcGeometryType.Point:
result[i] = CreatePoint(ordinates, empty[i]);
break;
case OgcGeometryType.MultiPoint:
result[i] = CreateMultiPoint(ordinates, empty[i]);
break;
case OgcGeometryType.LineString:
case OgcGeometryType.MultiLineString:
result[i] = CreateLineal(ordinates, empty[i]);
break;
case OgcGeometryType.Polygon:
case OgcGeometryType.MultiPolygon:
result[i] = CreatePolygonal(ordinates, empty[i]);
break;
}
/*
* // Ensure no empty elements
* if (result[i] == null || (result[i].IsEmpty && result[i].OgcGeometryType == OgcGeometryType.GeometryCollection))
* i--;
*/
// Ensure not null and not geometry collection
if (result[i] == null || result[i].OgcGeometryType == OgcGeometryType.GeometryCollection)
{
i--;
}
}
return(Factory.CreateGeometryCollection(result));
}
public void DrawOutline(Map map, IGraphics g, IGeometry geom, IStyle style)
{
Validate(map, g, geom, style);
VectorStyle s = (VectorStyle)style;
OgcGeometryType type = geom.OgcGeometryType;
switch (type)
{
case OgcGeometryType.LineString:
DrawLineString(g, (ILineString)geom, s.Outline, map, s.LineOffset);
break;
case OgcGeometryType.MultiLineString:
DrawMultiLineString(g, (IMultiLineString)geom, s.Outline, map, s.LineOffset);
break;
}
}
public static ShapeType ToShapeType(this OgcGeometryType ogcGeoType)
{
switch (ogcGeoType)
{
case OgcGeometryType.Point:
return(ShapeType.Point);
case OgcGeometryType.Polygon:
return(ShapeType.Polygon);
case OgcGeometryType.LineString:
return(ShapeType.Polyline);
default:
return(ShapeType.NullShape);
}
}
/// <summary>
/// Inititalizes this instance based on an <see cref="OgcGeometryType"/> and an SRID indicator
/// </summary>
/// <param name="ogcGeometryType">The OGC geometry type</param>
/// <param name="ordinates">The ordinates flag.</param>
/// <param name="hasSrid">Indicator if a SRID is supplied.</param>
public GeometryType(OgcGeometryType ogcGeometryType, Ordinates ordinates, bool hasSrid)
{
_geometrytype = (uint)ogcGeometryType;
if ((ordinates & Ordinates.Z) != 0)
{
HasWkbZ = true;
HasEwkbM = true;
}
if ((ordinates & Ordinates.M) != 0)
{
HasWkbZ = true;
HasEwkbM = true;
}
HasEwkbSrid = hasSrid;
}
internal static object ToDb2GeometryType(OgcGeometryType geometryType)
{
switch (geometryType)
{
case OgcGeometryType.Geometry:
case OgcGeometryType.Point:
case OgcGeometryType.LineString:
case OgcGeometryType.Polygon:
case OgcGeometryType.MultiLineString:
case OgcGeometryType.MultiPoint:
case OgcGeometryType.MultiPolygon:
case OgcGeometryType.GeometryCollection:
return(string.Format("ST_{0}", geometryType.ToString().ToUpper()));
default:
throw new ArgumentException(String.Format("Invalid geometry type: {0}", geometryType));
}
}
/// <summary>
/// Inititalizes this instance based on an <see cref="OgcGeometryType"/> and an SRID indicator
/// </summary>
/// <param name="ogcGeometryType">The OGC geometry type</param>
/// <param name="ordinates">The ordinates flag.</param>
/// <param name="hasSrid">Indicator if a SRID is supplied.</param>
public GeometryType(OgcGeometryType ogcGeometryType, Ordinates ordinates, bool hasSrid)
{
_geometrytype = (uint) ogcGeometryType;
if ((ordinates & Ordinates.Z) != 0)
{
HasWkbZ = true;
HasEwkbM = true;
}
if ((ordinates & Ordinates.M) != 0)
{
HasWkbZ = true;
HasEwkbM = true;
}
HasEwkbSrid = hasSrid;
}
// [InlineData(OgcGeometryType.MultiPolygon, 5, true)]
public async Task Should_Destructure_NetTopologySuite_FeatureCollection(OgcGeometryType type, int num, bool threeD)
{
var fc = new FeatureCollection();
for (var i = 0; i < num; i++)
{
fc.Add(
FeatureFactory.Create(
type, threeD, ("id", TypeCode.Int32),
("label", TypeCode.String), ("number1", TypeCode.Double),
("number2", TypeCode.Int64)
)
);
}
using var _ = CaptureLogs(out var logs);
Logger.LogInformation("This is just a test {@Data}", fc);
await Verify(logs.Select(z => z.RenderMessage())).UseParameters(type, num, threeD);
}
private static DSFeatureType ToDotSpatial(this OgcGeometryType self)
{
switch (self)
{
case OgcGeometryType.Point:
return(DSFeatureType.Point);
case OgcGeometryType.MultiPoint:
return(DSFeatureType.MultiPoint);
case OgcGeometryType.Polygon:
case OgcGeometryType.MultiPolygon:
return(DSFeatureType.Polygon);
case OgcGeometryType.LineString:
case OgcGeometryType.MultiLineString:
return(DSFeatureType.Line);
default:
return(DSFeatureType.Unspecified);
}
}
/// <summary>
/// Inititalizes this instance based on an <see cref="OgcGeometryType"/> and an SRID indicator
/// </summary>
/// <param name="ogcGeometryType">The OGC geometry type</param>
/// <param name="hasSrid">Indicator if a SRID is supplied.</param>
public GeometryType(OgcGeometryType ogcGeometryType, bool hasSrid)
: this(ogcGeometryType, Ordinates.XY, hasSrid)
{
}
public void Draw(Map map, IGraphics g, IGeometry geom, IStyle style, bool clip)
{
Validate(map, g, geom, style);
VectorStyle s = (VectorStyle)style;
OgcGeometryType type = geom.OgcGeometryType;
switch (type)
{
case OgcGeometryType.Point:
if (s.PointSymbolizer != null)
{
DrawPoint(s.PointSymbolizer, g, (IPoint)geom, map);
return;
}
if (s.Symbol != null || s.PointColor == null)
{
DrawPoint(g, (IPoint)geom, s.Symbol, s.SymbolScale, s.SymbolOffset,
s.SymbolRotation, map);
return;
}
DrawPoint(g, (IPoint)geom, s.PointColor, s.PointSize, s.SymbolOffset, map);
break;
case OgcGeometryType.MultiPoint:
if (s.PointSymbolizer != null)
{
DrawMultiPoint(s.PointSymbolizer, g, (IMultiPoint)geom, map);
}
if (s.Symbol != null || s.PointColor == null)
{
DrawMultiPoint(g, (IMultiPoint)geom, s.Symbol, s.SymbolScale, s.SymbolOffset, s.SymbolRotation, map);
}
else
{
DrawMultiPoint(g, (IMultiPoint)geom, s.PointColor, s.PointSize, s.SymbolOffset, map);
}
break;
case OgcGeometryType.LineString:
if (s.LineSymbolizer != null)
{
s.LineSymbolizer.Render(map, (ILineString)geom, g);
return;
}
DrawLineString(g, (ILineString)geom, s.Line, map, s.LineOffset);
return;
case OgcGeometryType.MultiLineString:
if (s.LineSymbolizer != null)
{
s.LineSymbolizer.Render(map, (IMultiLineString)geom, g);
return;
}
DrawMultiLineString(g, (IMultiLineString)geom, s.Line, map, s.LineOffset);
break;
case OgcGeometryType.Polygon:
if (s.EnableOutline)
{
DrawPolygon(g, (IPolygon)geom, s.Fill, s.Outline, clip, map);
}
else
{
DrawPolygon(g, (IPolygon)geom, s.Fill, null, clip, map);
}
break;
case OgcGeometryType.MultiPolygon:
if (s.EnableOutline)
{
DrawMultiPolygon(g, (IMultiPolygon)geom, s.Fill, s.Outline, clip, map);
}
else
{
DrawMultiPolygon(g, (IMultiPolygon)geom, s.Fill, null, clip, map);
}
break;
case OgcGeometryType.GeometryCollection:
IGeometryCollection coll = (IGeometryCollection)geom;
for (int i = 0; i < coll.NumGeometries; i++)
{
Draw(map, g, coll[i], s, clip);
}
break;
}
}
/// <summary>
/// Creates an OGR data source from a FeatureDataTable
/// </summary>
/// <param name="table">The name of the table</param>
/// <param name="geometryType">The geometry type</param>
/// <param name="driver">The driver</param>
/// <param name="connection">The connection string</param>
/// <param name="driverOptions">The options for the driver</param>
/// <param name="layerOptions">The options for the layer</param>
public static void CreateFromFeatureDataTable(FeatureDataTable table,
OgcGeometryType geometryType, int srid, string driver, string connection, string[] driverOptions = null, string[] layerOptions = null)
{
if (table == null)
{
throw new ArgumentNullException("table");
}
if (table.Rows.Count == 0)
{
throw new ArgumentException("The table contains no rows", "table");
}
if (geometryType < OgcGeometryType.Point || geometryType > OgcGeometryType.MultiPolygon)
{
throw new ArgumentException("Invalid geometry type", "geometryType");
}
if (string.IsNullOrWhiteSpace(driver))
{
throw new ArgumentException("No driver specified", "driver");
}
var dr = OSGeo.OGR.Ogr.GetDriverByName(driver);
if (dr == null)
{
throw new Exception(string.Format("Cannot load driver '{0}'!", driver));
}
//if (!dr.TestCapability("ODrCCreateDataSource"))
// throw new Exception(string.Format("Driver '{0}' cannot create a data source!", driver));
// Create the data source
var ds = dr.CreateDataSource(connection, driverOptions);
//if (!ds.TestCapability("ODsCCreateLayer"))
// throw new Exception(string.Format("Driver '{0}' cannot create a layer!", driver));
// Create the spatial reference
var sr = new OSGeo.OSR.SpatialReference(string.Empty);
sr.ImportFromEPSG(srid);
// Create the layer
var lyr = ds.CreateLayer(table.TableName, sr, (OgrGeometryType)geometryType, layerOptions);
sr.Dispose();
//lyr.GetSpatialRef();
foreach (System.Data.DataColumn dc in table.Columns)
{
using (var fldDef = GetFieldDefinition(dc))
lyr.CreateField(fldDef, 0);
}
using (var ld = lyr.GetLayerDefn())
{
foreach (FeatureDataRow fdr in table.Rows)
{
if ((int)fdr.Geometry.OgcGeometryType != (int)geometryType)
{
continue;
}
using (var feature = new OgrFeature(ld))
{
feature.SetGeometry(OgrGeometry.CreateFromWkb(fdr.Geometry.AsBinary()));
var idx = -1;
foreach (System.Data.DataColumn dc in table.Columns)
{
idx++;
var fd = ld.GetFieldDefn(idx);
DateTime dt;
switch (fd.GetFieldType())
{
case OgrFieldType.OFTBinary:
//Nothing
break;
case OgrFieldType.OFTDate:
dt = ((DateTime)fdr[dc]).Date;
feature.SetField(idx, dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0);
break;
case OgrFieldType.OFTDateTime:
dt = (DateTime)fdr[dc];
feature.SetField(idx, dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0);
break;
case OgrFieldType.OFTTime:
var tod = ((DateTime)fdr[dc]).TimeOfDay;
feature.SetField(idx, 0, 0, 0, tod.Hours, tod.Minutes, tod.Seconds, 0);
break;
case OgrFieldType.OFTInteger:
feature.SetField(idx, Convert.ToInt32(fdr[dc]));
break;
case OgrFieldType.OFTIntegerList:
var il = GetIntegerList(fdr[dc], dc.DataType);
feature.SetFieldIntegerList(idx, il.Length, il);
break;
case OgrFieldType.OFTReal:
feature.SetField(idx, Convert.ToDouble(fdr[dc]));
break;
case OgrFieldType.OFTRealList:
var dl = GetDoubleList(fdr[dc], dc.DataType);
feature.SetFieldDoubleList(idx, dl.Length, dl);
break;
case OgrFieldType.OFTString:
feature.SetField(idx, Convert.ToString(fdr[dc]));
break;
case OgrFieldType.OFTStringList:
var sl = (string[])fdr[dc];
feature.SetFieldStringList(idx, sl);
break;
}
fd.Dispose();
}
lyr.CreateFeature(feature);
feature.Dispose();
}
//ld.Dispose();
}
}
lyr.Dispose();
ds.Dispose();
dr.Dispose();
}
/// <summary>
/// Inititalizes this instance based on an <see cref="OgcGeometryType"/>
/// </summary>
/// <param name="ogcGeometryType">The OGC geometry type</param>
public GeometryType(OgcGeometryType ogcGeometryType)
: this(ogcGeometryType, Ordinates.XY, false)
{
}
private void DrawFeatures(Graphics graphics, string layerId, StringCollection ids, Color color, double opacity, string polygonMode, int penWidth, int dotSize)
{
if (ids.Count == 0)
{
return;
}
bool drawPolygonOutlines = polygonMode == "outline";
// get the layer
Configuration config = AppContext.GetConfiguration();
Configuration.LayerRow layerRow = config.Layer.FindByLayerID(layerId);
CommonDataFrame dataFrame = AppContext.GetDataFrame(_appState.MapTab);
CommonLayer layer = dataFrame.Layers.FirstOrDefault(lyr => String.Compare(lyr.Name, layerRow.LayerName, true) == 0);
// build the query string and select the features
CommonField field = layer.FindField(layerRow.KeyField);
string joinedIds = field.IsNumeric ? ids.Join(",") : String.Format("'{0}'", ids.Join("','"));
string query = String.Format("{0} in ({1})", field.Name, joinedIds);
string levelQuery = layerRow.GetLevelQuery(layer, _appState.Level);
if (!String.IsNullOrEmpty(levelQuery))
{
query += " and " + levelQuery;
}
CommonField keyField = layer.FindField(layerRow.KeyField);
DataTable table = layer.GetFeatureTable(String.Format("{0},{1}", layer.GeometryField.Name, keyField.Name), query);
if (table == null || table.Rows.Count == 0)
{
return;
}
OgcGeometryType geometryType = ((IGeometry)table.Rows[0][layer.GeometryField.Name]).OgcGeometryType;
// prepare the temporary image for drawing transparent highlight graphics
int width = Convert.ToInt32(graphics.VisibleClipBounds.Width);
int height = Convert.ToInt32(graphics.VisibleClipBounds.Height);
Bitmap bitMap = new Bitmap(width, height);
Graphics imageGraphics = Graphics.FromImage(bitMap);
imageGraphics.Clear(Color.Transparent);
// prepare the drawing objects
Brush brush = new SolidBrush(color);
Pen pen = new Pen(color, Convert.ToSingle(penWidth * _resolution));
pen.EndCap = System.Drawing.Drawing2D.LineCap.Square;
pen.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;
Pen bufferPen = new Pen(color, Convert.ToSingle(5 * _resolution));
bufferPen.EndCap = System.Drawing.Drawing2D.LineCap.Round;
bufferPen.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;
float dot = Convert.ToSingle(dotSize * _resolution);
// draw each shape in the table
foreach (DataRow row in table.Rows)
{
switch (geometryType)
{
case OgcGeometryType.Point:
IPoint point = (IPoint)row[layer.GeometryField.Name];
DrawPoint(imageGraphics, point, brush, dot);
break;
case OgcGeometryType.MultiPoint:
IMultiPoint multiPoint = (IMultiPoint)row[layer.GeometryField.Name];
DrawPoint(imageGraphics, (IPoint)multiPoint[0], brush, dot);
break;
case OgcGeometryType.MultiLineString:
DrawMultiLineString(imageGraphics, (IMultiLineString)row[layer.GeometryField.Name], pen);
break;
case OgcGeometryType.MultiPolygon:
if (drawPolygonOutlines)
{
DrawMultiPolygon(imageGraphics, (IMultiPolygon)row[layer.GeometryField.Name], null, null, pen);
}
else
{
DrawMultiPolygon(imageGraphics, (IMultiPolygon)row[layer.GeometryField.Name], brush, bufferPen);
}
break;
}
}
// draw the temporary image containing the highlight graphics on the output image at
// the specified opacity
float[][] matrixItems =
{
new float[] { 1, 0, 0, 0, 0 },
new float[] { 0, 1, 0, 0, 0 },
new float[] { 0, 0, 1, 0, 0 },
new float[] { 0, 0, 0, Convert.ToSingle(opacity), 0 },
new float[] { 0, 0, 0, 0, 1 }
};
ColorMatrix colorMatrix = new ColorMatrix(matrixItems);
ImageAttributes imageAtts = new ImageAttributes();
imageAtts.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
Rectangle drawRect = new Rectangle(0, 0, width, height);
graphics.DrawImage(bitMap, drawRect, 0, 0, width, height, GraphicsUnit.Pixel, imageAtts);
}
public static void CreateDataTable <TOid>(
FeatureDataTable featureDataTable,
String tableName,
String connectionString,
String geometryColumnName,
OgcGeometryType geometryType,
Double smallRasterSize, Double mediumRasterSize, Double largeRasterSize
)
{
DB2Connection conn = new DB2Connection(connectionString);
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
string srid = featureDataTable.GeometryFactory.Srid ?? DefaultSrid;
if (conn != null)
{
try
{
string createTableClause = string.Format("CREATE TABLE \"{0}\".\"{1}\" ({2});",
DefaultSpatialSchema,
tableName,
ColumnsClause(featureDataTable.Columns,
featureDataTable.Constraints));
new DB2Command(createTableClause, conn).ExecuteNonQuery();
new DB2Command(string.Format("ALTER TABLE \"{0}\".\"{1}\" ADD COLUMN \"{2}\" \"{0}\".{3};",
DefaultSpatialSchema, tableName, geometryColumnName,
ToDb2GeometryType(geometryType)), conn).ExecuteNonQuery();
Object db2crsname = new DB2Command(String.Format(
@"SELECT DISTINCT SPATIAL_REF_SYS.CS_NAME
FROM ""{0}"".""SPATIAL_REF_SYS"" AS SPATIAL_REF_SYS
WHERE SPATIAL_REF_SYS.AUTH_SRID = {1};",
DefaultSpatialSchema,
srid),
conn).ExecuteScalar();
if (db2crsname == null || db2crsname == DBNull.Value || ((String)db2crsname).Length == 0)
{
db2crsname = "DEFAULT_SRS";
}
//register spatial column
DB2Command cmd =
new DB2Command(String.Format("CALL \"{0}\".ST_REGISTER_SPATIAL_COLUMN(?,?,?,?,?,?);",
DefaultSpatialSchema),
conn);
//cmd.CommandType = CommandType.StoredProcedure;
//input parameters
//DB2Parameter par;
DB2Parameter par1 = cmd.Parameters.Add(new DB2Parameter("@P1", DB2Type.VarChar, 130));
par1.Value = "\"" + DefaultSpatialSchema + "\"";
DB2Parameter par2 = cmd.Parameters.Add(new DB2Parameter("@P2", DB2Type.VarChar, 130));
par2.Value = "\"" + tableName + "\"";
DB2Parameter par3 = cmd.Parameters.Add(new DB2Parameter("@P3", DB2Type.VarChar, 130));
par3.Value = "\"" + geometryColumnName + "\"";
DB2Parameter par4 = cmd.Parameters.Add(new DB2Parameter("@P4", DB2Type.VarChar, 130));
par4.Value = "\"" + db2crsname + "\"";
//output parameters
DB2Parameter par5 = cmd.Parameters.Add(new DB2Parameter("@P5", DB2Type.Integer, 4));
par5.Direction = ParameterDirection.Output;
DB2Parameter par6 = cmd.Parameters.Add(new DB2Parameter("@P6", DB2Type.VarChar, 1024));
par6.Direction = ParameterDirection.Output;
cmd.ExecuteNonQuery();
if (smallRasterSize != -1d)
{
//adding spatial index
new DB2Command(
String.Format(
"CREATE INDEX \"{0}\".\"idx_{1}_{2}\" ON \"{0}\".\"{1}\"(\"{2}\") EXTEND USING \"{0}\".({3}, {4}, {5});",
DefaultSpatialSchema,
tableName,
geometryColumnName,
smallRasterSize, mediumRasterSize, largeRasterSize),
conn).ExecuteNonQuery();
}
}
catch (DB2Exception ex)
{
Trace.Write(ex.Message);
//throw new DB2SpatialExtenderException(string.Format("Cannot create geometry column with type of '{0}'", geometryType.ToString()));
}
catch
{
}
}
conn.Close();
conn = null;
DB2SpatialExtenderProvider <TOid> prov = new DB2SpatialExtenderProvider <TOid>(
featureDataTable.GeometryFactory, connectionString, DefaultSpatialSchema, tableName,
featureDataTable.Columns[0].ColumnName, geometryColumnName);
prov.Insert(featureDataTable);
return;
}
public static IGeometryCollection CreateShapes(OgcGeometryType type, Ordinates ordinates, int number = 50)
{
var empty = new bool[number];
empty[Rnd.Next(2, number / 2)] = true;
empty[Rnd.Next(number / 2, number)] = true;
var result = new IGeometry[number];
for (var i = 0; i < number; i++)
{
switch (type)
{
case OgcGeometryType.Point:
result[i] = CreatePoint(ordinates, empty[i]);
break;
case OgcGeometryType.MultiPoint:
result[i] = CreateMultiPoint(ordinates, empty[i]);
break;
case OgcGeometryType.LineString:
case OgcGeometryType.MultiLineString:
result[i] = CreateLineal(ordinates, empty[i]);
break;
case OgcGeometryType.Polygon:
case OgcGeometryType.MultiPolygon:
result[i] = CreatePolygonal(ordinates, empty[i]);
break;
}
/*
// Ensure no empty elements
if (result[i] == null || (result[i].IsEmpty && result[i].OgcGeometryType == OgcGeometryType.GeometryCollection))
i--;
*/
// Ensure not null and not geometry collection
if (result[i] == null || result[i].OgcGeometryType == OgcGeometryType.GeometryCollection)
i--;
}
return Factory.CreateGeometryCollection(result);
}
private string GetStyle(OgcGeometryType geometryType, string color, bool isText, Dictionary<String, String> styles)
{
string r = color.ToLower().Substring(1, 2);
string g = color.ToLower().Substring(3, 2);
string b = color.ToLower().Substring(5, 2);
color = b + g + r;
string styleId = null;
switch (geometryType)
{
case OgcGeometryType.Point:
if (isText)
{
styleId = "T" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><IconStyle><scale>0.00001</scale></IconStyle><LabelStyle><color>ff{1}</color></LabelStyle></Style>", styleId, color));
}
}
else
{
styleId = "P" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><IconStyle><color>ff{1}</color><Icon><href>http://maps.google.com/mapfiles/kml/pal4/icon57.png</href></Icon></IconStyle></Style>", styleId, color));
}
}
break;
case OgcGeometryType.LineString:
styleId = "L" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><LineStyle><color>ff{1}</color><width>2</width></LineStyle></Style>", styleId, color));
}
break;
case OgcGeometryType.Polygon:
styleId = "A" + color;
if (!styles.ContainsKey(styleId))
{
styles.Add(styleId, String.Format("<Style id=\"{0}\"><PolyStyle><color>80{1}</color></PolyStyle><LineStyle><color>ff{1}</color><width>2</width></LineStyle></Style>", styleId, color));
}
break;
}
return styleId;
}
/// <summary>
/// Inititalizes this instance based on an <see cref="OgcGeometryType"/>
/// </summary>
/// <param name="ogcGeometryType">The OGC geometry type</param>
public GeometryType(OgcGeometryType ogcGeometryType)
: this(ogcGeometryType, Ordinates.XY, false)
{
}
/// <summary>
/// Create a new geo feature.
/// </summary>
/// <param name="_GeoCoordinates">A list of geo coordinates.</param>
/// <param name="_Type">The type of the feature.</param>
public GeoFeature(IEnumerable <Coordinate> _GeoCoordinates,
OgcGeometryType _Type = OgcGeometryType.Point)
{
GeoCoordinates = new List <Coordinate>(_GeoCoordinates);
Type = _Type;
}
public IGeometry CreateGeometry(ICoordinateSequence coordinates, OgcGeometryType type)
{
switch (type)
{
case OgcGeometryType.Point:
return CreatePoint(coordinates);
case OgcGeometryType.LineString:
return CreateLineString(coordinates);
case OgcGeometryType.Polygon:
return CreatePolygon(coordinates);
case OgcGeometryType.MultiPoint:
return CreateMultiPoint(coordinates);
case OgcGeometryType.MultiPolygon:
return CreateMultiPolygon(coordinates);
case OgcGeometryType.MultiLineString:
case OgcGeometryType.GeometryCollection:
case OgcGeometryType.Geometry:
case OgcGeometryType.Curve:
case OgcGeometryType.Surface:
case OgcGeometryType.MultiSurface:
case OgcGeometryType.MultiCurve:
default:
throw new NotSupportedException("Geometry type not supported: " + type);
}
}
private DataTable GetShapeTable(string sql, OgcGeometryType geometryType)
{
DataTable table = null;
using (OleDbConnection connection = AppContext.GetDatabaseConnection())
{
table = new DataTable();
using (OleDbDataAdapter adapter = new OleDbDataAdapter(sql, connection))
{
adapter.Fill(table);
}
table.Columns["Shape"].ColumnName = "ShapeString";
switch (geometryType)
{
case OgcGeometryType.Point: table.Columns.Add("Shape", typeof(IPoint)); break;
case OgcGeometryType.LineString: table.Columns.Add("Shape", typeof(IMultiLineString)); break;
case OgcGeometryType.Polygon: table.Columns.Add("Shape", typeof(IMultiPolygon)); break;
}
WKTReader wktReader = new WKTReader();
foreach (DataRow row in table.Rows)
{
switch (geometryType)
{
case OgcGeometryType.Point:
row["Shape"] = (IPoint)wktReader.Read((string)row["ShapeString"]);
break;
case OgcGeometryType.LineString:
ILineString lineString = (ILineString)wktReader.Read((string)row["ShapeString"]);
IMultiLineString multiLineString = new MultiLineString(new ILineString[] { lineString });
row["Shape"] = multiLineString;
break;
case OgcGeometryType.Polygon:
IPolygon polygon = (IPolygon)wktReader.Read((string)row["ShapeString"]);
IMultiPolygon multiPolygon = new MultiPolygon(new IPolygon[] { polygon });
row["Shape"] = multiPolygon;
break;
}
}
table.Columns.Remove("ShapeString");
}
return table;
}
/// <summary>
/// Inititalizes this instance based on an <see cref="OgcGeometryType"/> and an SRID indicator
/// </summary>
/// <param name="ogcGeometryType">The OGC geometry type</param>
/// <param name="hasSrid">Indicator if a SRID is supplied.</param>
public GeometryType(OgcGeometryType ogcGeometryType, bool hasSrid)
:this(ogcGeometryType, Ordinates.XY, hasSrid)
{
}
public DB2SpatialExtenderProvider(IGeometryFactory geometryFactory, string connectionString,
string tableSchema, string tableName, string oidColumn, string geometryColumn)
: base(
new DB2SpatialExtenderDbUtility(), geometryFactory, connectionString, tableSchema,
tableName,
oidColumn,
geometryColumn)
{
using (DB2Connection cn = new DB2Connection(connectionString))
{
cn.Open();
cn.CacheData = true;
try
{
String selectClause =
string.Format(
@"
SELECT SGC.TYPE_NAME, SGC.SRS_ID
FROM {0}.ST_GEOMETRY_COLUMNS AS SGC
WHERE (SGC.TABLE_SCHEMA='{1}' AND SGC.TABLE_NAME='{2}' AND SGC.COLUMN_NAME='{3}')",
DB2SpatialExtenderProviderStatic.DefaultSpatialSchema,
tableSchema,
tableName,
geometryColumn);
DB2DataReader dr = new DB2Command(selectClause, cn).ExecuteReader();
if (dr.HasRows)
{
dr.Read();
//valid geometry type
_validGeometryType = parseGeometryType(dr.GetString(0));
//SrsId
DB2SrsId = dr.GetDB2Int32(1).Value;
if (!OriginalSpatialReference.EqualParams(GeometryFactory.SpatialReference))
{
GeometryFactory.SpatialReference = OriginalSpatialReference;
}
//OriginalSrid = dr[1].ToString();
if (geometryFactory.Srid == null)
{
geometryFactory.Srid = OriginalSrid;
}
else
{
//geometryFactory.SpatialReference
}
}
else
{
dr.Close();
selectClause =
string.Format(@"
SELECT {0}.ST_SRID({1})
FROM {2} AS {3}
WHERE ({4}=MIN({4}));",
DB2SpatialExtenderProviderStatic.DefaultSpatialSchema,
QualifyColumnName(geometryColumn),
QualifyTableName(tableSchema, tableName),
tableName,
QualifyColumnName(oidColumn));
OriginalSrid = ((Int32) new DB2Command(selectClause, cn).ExecuteScalar()).ToString();
_validGeometryType = OgcGeometryType.Geometry;
}
}
catch (Exception)
{
_validGeometryType = OgcGeometryType.Unknown;
}
}
}
private IGeometry MergeShapes(DataTable table)
{
if (table.Rows.Count > 0)
{
IEnumerable <DataColumn> columns = table.Columns.Cast <DataColumn>();
DataColumn geometryColumn = columns.First(c => c.DataType.IsSubclassOf(typeof(Geometry)));
OgcGeometryType geometryType = ((IGeometry)table.Rows[0][geometryColumn]).OgcGeometryType;
switch (geometryType)
{
case OgcGeometryType.Point:
case OgcGeometryType.MultiPoint:
List <IPoint> mergeMultiPoint = new List <IPoint>();
foreach (DataRow row in table.Rows)
{
if (geometryType == OgcGeometryType.Point)
{
mergeMultiPoint.Add((IPoint)row[geometryColumn]);
}
else
{
IMultiPoint multiPoint = (IMultiPoint)row[geometryColumn];
foreach (IPoint p in multiPoint)
{
mergeMultiPoint.Add(p);
}
}
}
return(new MultiPoint(mergeMultiPoint.ToArray()));
case OgcGeometryType.MultiLineString:
List <ILineString> mergeLineString = new List <ILineString>();
foreach (DataRow row in table.Rows)
{
IMultiLineString multiLineString = (MultiLineString)row[geometryColumn];
foreach (ILineString lineString in multiLineString.Geometries.Cast <ILineString>())
{
mergeLineString.Add(lineString);
}
}
return(new MultiLineString(mergeLineString.ToArray()));
case OgcGeometryType.MultiPolygon:
List <IPolygon> mergePolygon = new List <IPolygon>();
foreach (DataRow row in table.Rows)
{
MultiPolygon multiPolygon = (MultiPolygon)row[geometryColumn];
foreach (IPolygon polygon in multiPolygon.Geometries.Cast <IPolygon>())
{
mergePolygon.Add(polygon);
}
}
return(new MultiPolygon(mergePolygon.ToArray()));
}
}
return(null);
}
/// <summary>
/// Creates an OGR data source from a FeatureDataTable
/// </summary>
/// <param name="table">The name of the table</param>
/// <param name="geometryType">The geometry type</param>
/// <param name="driver">The driver</param>
/// <param name="connection">The connection string</param>
/// <param name="driverOptions">The options for the driver</param>
/// <param name="layerOptions">The options for the layer</param>
public static void CreateFromFeatureDataTable(FeatureDataTable table,
OgcGeometryType geometryType, int srid, string driver, string connection, string[] driverOptions = null, string[] layerOptions = null)
{
if (table == null)
throw new ArgumentNullException("table");
if (table.Rows.Count == 0)
throw new ArgumentException("The table contains no rows", "table");
if (geometryType < OgcGeometryType.Point || geometryType > OgcGeometryType.MultiPolygon)
throw new ArgumentException("Invalid geometry type", "geometryType");
if (string.IsNullOrWhiteSpace(driver))
throw new ArgumentException("No driver specified", "driver");
var dr = OSGeo.OGR.Ogr.GetDriverByName(driver);
if (dr == null)
throw new Exception(string.Format("Cannot load driver '{0}'!", driver));
//if (!dr.TestCapability("ODrCCreateDataSource"))
// throw new Exception(string.Format("Driver '{0}' cannot create a data source!", driver));
// Create the data source
var ds = dr.CreateDataSource(connection, driverOptions);
//if (!ds.TestCapability("ODsCCreateLayer"))
// throw new Exception(string.Format("Driver '{0}' cannot create a layer!", driver));
// Create the spatial reference
var sr = new OSGeo.OSR.SpatialReference(string.Empty);
sr.ImportFromEPSG(srid);
// Create the layer
var lyr = ds.CreateLayer(table.TableName, sr, (OgrGeometryType)geometryType, layerOptions);
sr.Dispose();
//lyr.GetSpatialRef();
foreach (System.Data.DataColumn dc in table.Columns)
{
using (var fldDef = GetFieldDefinition(dc))
lyr.CreateField(fldDef, 0);
}
using (var ld = lyr.GetLayerDefn())
{
foreach (FeatureDataRow fdr in table.Rows)
{
if ((int)fdr.Geometry.OgcGeometryType != (int)geometryType)
continue;
using (var feature = new OgrFeature(ld))
{
feature.SetGeometry(OgrGeometry.CreateFromWkb(fdr.Geometry.AsBinary()));
var idx = -1;
foreach (System.Data.DataColumn dc in table.Columns)
{
idx++;
var fd = ld.GetFieldDefn(idx);
DateTime dt;
switch (fd.GetFieldType())
{
case OgrFieldType.OFTBinary:
//Nothing
break;
case OgrFieldType.OFTDate:
dt = ((DateTime)fdr[dc]).Date;
feature.SetField(idx, dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0);
break;
case OgrFieldType.OFTDateTime:
dt = (DateTime)fdr[dc];
feature.SetField(idx, dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0);
break;
case OgrFieldType.OFTTime:
var tod = ((DateTime)fdr[dc]).TimeOfDay;
feature.SetField(idx, 0, 0, 0, tod.Hours, tod.Minutes, tod.Seconds, 0);
break;
case OgrFieldType.OFTInteger:
feature.SetField(idx, Convert.ToInt32(fdr[dc]));
break;
case OgrFieldType.OFTIntegerList:
var il = GetIntegerList(fdr[dc], dc.DataType);
feature.SetFieldIntegerList(idx, il.Length, il);
break;
case OgrFieldType.OFTReal:
feature.SetField(idx, Convert.ToDouble(fdr[dc]));
break;
case OgrFieldType.OFTRealList:
var dl = GetDoubleList(fdr[dc], dc.DataType);
feature.SetFieldDoubleList(idx, dl.Length, dl);
break;
case OgrFieldType.OFTString:
feature.SetField(idx, Convert.ToString(fdr[dc]));
break;
case OgrFieldType.OFTStringList:
var sl = (string[])fdr[dc];
feature.SetFieldStringList(idx, sl);
break;
}
fd.Dispose();
}
lyr.CreateFeature(feature);
feature.Dispose();
}
//ld.Dispose();
}
}
lyr.Dispose();
ds.Dispose();
dr.Dispose();
}
public static IFeature Create(OgcGeometryType geometryType, in bool threeD = false, params (string, TypeCode)[] properties)
public virtual void Insert(IEnumerable <FeatureDataRow <TOid> > features)
{
OgcGeometryType geometryType = OgcGeometryType.Unknown;
using (IDbConnection conn = DbUtility.CreateConnection(ConnectionString))
{
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
using (IDbTransaction tran = conn.BeginTransaction())
{
IDbCommand cmd = DbUtility.CreateCommand();
cmd.Connection = conn;
cmd.Transaction = tran;
cmd.CommandText = string.Format(
"INSERT INTO {0} {1};", QualifiedTableName, InsertClause(cmd));
int geometryParameterIndex = cmd.Parameters.Count - 1;
foreach (FeatureDataRow <TOid> row in features)
{
if (cmd.Parameters.Count > 0)
{
for (int i = 0; i < row.FieldCount; i++)
{
((IDataParameter)cmd.Parameters[i]).Value = row.GetValue(i);
}
((IDataParameter)cmd.Parameters[geometryParameterIndex]).Value =
row.Geometry.AsBinary();
}
else
{
for (int i = 0; i < row.FieldCount; i++)
{
cmd.Parameters.Add(DbUtility.CreateParameter(string.Format("P{0}", i), row[i],
ParameterDirection.Input));
}
geometryParameterIndex = cmd.Parameters.Add(
DbUtility.CreateParameter("PGeo", row.Geometry.AsBinary(),
ParameterDirection.Input));
}
//for (int i = 0; i < cmd.Parameters.Count - 1; i++)
// ((IDataParameter)cmd.Parameters[i]).Value = row[i];
//byte[] geomBinary = row.Geometry.AsBinary();
//((IDataParameter)cmd.Parameters["@PGeo"]).Value = geomBinary;
if (geometryType == OgcGeometryType.Unknown)
{
geometryType = row.Geometry.GeometryType;
}
if (row.Geometry.GeometryType == geometryType)
{
cmd.ExecuteNonQuery();
}
}
tran.Commit();
}
}
}
public static void CreateDataTable <TOid>(
FeatureDataTable featureDataTable,
String schemaName,
String tableName,
String connectionString,
String geometryColumnName,
OgcGeometryType geometryType)
{
string srid = featureDataTable.GeometryFactory.SpatialReference != null
?
featureDataTable.GeometryFactory.SpatialReference.AuthorityCode
:
DefaultSridInt.ToString();
NpgsqlConnectionStringBuilder csb = new NpgsqlConnectionStringBuilder(connectionString);
PostGisDbUtility util = new PostGisDbUtility();
NpgsqlConnection conn = (NpgsqlConnection)util.CreateConnection(connectionString);
if (conn != null)
{
try
{
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
if (!Has_X_Privilege(conn, "database", csb.Database, "CREATE"))
{
throw new PostGisException("Insufficient rights to create table!");
}
if (!Has_X_Privilege(conn,
"function",
"addgeometrycolumn(character varying, character varying, int, character varying, int)",
"EXECUTE"))
{
throw new PostGisException("Insufficient rights to access addgeometrycolumn function!");
}
string createTableClause = string.Format(
"CREATE TABLE {0}.\"{1}\" ({2}) WITH(OIDS=FALSE);",
schemaName,
tableName,
ColumnsClause(tableName, featureDataTable.Columns,
featureDataTable.Constraints));
new NpgsqlCommand(createTableClause, conn).ExecuteNonQuery();
String addGeometryColumnClause = String.Format("('{0}', '{1}', {2}, '{3}', {4})",
tableName,
geometryColumnName,
srid,
geometryType.ToString().ToUpper(),
2);
//adding spatial column
new NpgsqlCommand(String.Format("SELECT AddGeometryColumn {0};",
addGeometryColumnClause),
conn).ExecuteNonQuery();
//adding GIST index
new NpgsqlCommand(String.Format("CREATE INDEX index_{0}_{1} ON {2}.\"{3}\" USING gist(\"{4}\");",
tableName,
geometryColumnName,
schemaName,
tableName,
geometryColumnName),
conn).ExecuteNonQuery();
}
catch (NpgsqlException ex)
{
Trace.Write(ex.Message);
throw new PostGisException(string.Format("Cannot create geometry column with type of '{0}'",
geometryType));
}
catch
{
}
}
conn.Close();
conn = null;
PostGisProvider <TOid> prov = new PostGisProvider <TOid>(
featureDataTable.GeometryFactory, connectionString, schemaName, tableName,
featureDataTable.Columns[0].ColumnName, geometryColumnName);
prov.Insert(featureDataTable);
return;
}
