private NetworkRenderer(bool init)
{
_renderers = new RendererGroup();
if (init == true)
{
_renderers.Add(PlugInManager.Create(KnownObjects.Carto_SimpleRenderer) as IFeatureRenderer); // Edges
_renderers.Add(PlugInManager.Create(KnownObjects.Carto_SimpleRenderer) as IFeatureRenderer); // Simple Nodes
_renderers.Add(PlugInManager.Create(KnownObjects.Carto_SimpleRenderer) as IFeatureRenderer); // Switches On
_renderers.Add(PlugInManager.Create(KnownObjects.Carto_SimpleRenderer) as IFeatureRenderer); // Switches Off
foreach (IFeatureRenderer renderer in _renderers)
{
geometryType geomType = geometryType.Polyline;
if (_renderers.IndexOf(renderer) > 0)
{
geomType = geometryType.Point;
}
if (renderer is ISymbolCreator && renderer is IFeatureRenderer2)
{
((IFeatureRenderer2)renderer).Symbol = ((ISymbolCreator)renderer).CreateStandardSymbol(geomType);
}
}
}
}
static public ISymbol CreateStandardSelectionSymbol(geometryType type)
{
ISymbol symbol = null;
switch (type)
{
case geometryType.Envelope:
case geometryType.Polygon:
symbol = new SimpleFillSymbol();
((SimpleFillSymbol)symbol).Color = ArgbColor.Transparent;
((SimpleFillSymbol)symbol).OutlineSymbol = new SimpleLineSymbol();
((SimpleLineSymbol)((SimpleFillSymbol)symbol).OutlineSymbol).Color = ArgbColor.Cyan;
((SimpleLineSymbol)((SimpleFillSymbol)symbol).OutlineSymbol).Width = 3;
break;
case geometryType.Polyline:
symbol = new SimpleLineSymbol();
((SimpleLineSymbol)symbol).Color = ArgbColor.Cyan;
((SimpleLineSymbol)symbol).Width = 3;
break;
case geometryType.Point:
symbol = new SimplePointSymbol();
((SimplePointSymbol)symbol).Color = ArgbColor.Cyan;
((SimplePointSymbol)symbol).Size = 5;
break;
}
return(symbol);
}
static public ISymbol CreateStandardSymbol(geometryType type)
{
ISymbol symbol = null;
switch (type)
{
case geometryType.Envelope:
case geometryType.Polygon:
symbol = new SimpleFillSymbol();
((SimpleFillSymbol)symbol).OutlineSymbol = new SimpleLineSymbol();
((SimpleFillSymbol)symbol).Color = RandomColor;
((SimpleLineSymbol)((SimpleFillSymbol)symbol).OutlineSymbol).Color = RandomColor;
break;
case geometryType.Polyline:
symbol = new SimpleLineSymbol();
((SimpleLineSymbol)symbol).Color = RandomColor;
break;
case geometryType.Multipoint:
case geometryType.Point:
symbol = new SimplePointSymbol();
((SimplePointSymbol)symbol).Color = RandomColor;
break;
}
return(symbol);
}
static public ISymbol CreateStandardHighlightSymbol(geometryType type)
{
ISymbol symbol = null;
switch (type)
{
case geometryType.Envelope:
case geometryType.Polygon:
symbol = new SimpleFillSymbol();
((SimpleFillSymbol)symbol).Color = ArgbColor.FromArgb(100, 255, 255, 0);
((SimpleFillSymbol)symbol).OutlineSymbol = new SimpleLineSymbol();
((SimpleLineSymbol)((SimpleFillSymbol)symbol).OutlineSymbol).Color = ArgbColor.Yellow;
((SimpleLineSymbol)((SimpleFillSymbol)symbol).OutlineSymbol).Width = 5;
break;
case geometryType.Polyline:
symbol = new SimpleLineSymbol();
((SimpleLineSymbol)symbol).Color = ArgbColor.Yellow;
((SimpleLineSymbol)symbol).Width = 5;
break;
case geometryType.Point:
symbol = new SimplePointSymbol();
((SimplePointSymbol)symbol).Color = ArgbColor.Yellow;
((SimplePointSymbol)symbol).Size = 10;
break;
}
return(symbol);
}
public void AXLaddHighlightSymbol(geometryType type, string color, double trans)
{
if (type == geometryType.Unknown)
{
return;
}
m_xWriter.WriteStartElement("SIMPLERENDERER");
switch (type)
{
case geometryType.Polygon:
m_xWriter.WriteStartElement("SIMPLEPOLYGONSYMBOL");
m_xWriter.WriteAttributeString("transparency", trans.ToString());
m_xWriter.WriteAttributeString("fillcolor", color);
m_xWriter.WriteEndElement(); // SIMPLEPOLYGONSYMBOL
break;
case geometryType.Polyline:
m_xWriter.WriteStartElement("SIMPLELINESYMBOL");
m_xWriter.WriteAttributeString("transparency", trans.ToString());
m_xWriter.WriteAttributeString("color", color);
m_xWriter.WriteAttributeString("width", "10");
m_xWriter.WriteEndElement(); // SIMPLELINESYMBOL
break;
default: // point
m_xWriter.WriteStartElement("SIMPLEMARKERSYMBOL");
m_xWriter.WriteAttributeString("transparency", trans.ToString());
m_xWriter.WriteAttributeString("color", color);
m_xWriter.WriteAttributeString("width", "20");
m_xWriter.WriteEndElement(); // SIMPLEMARKERSYMBOL
break;
}
m_xWriter.WriteEndElement();
}
static public EsriGeometryType ToGeometryType(geometryType type)
{
switch (type)
{
case geometryType.Point:
return(EsriGeometryType.esriGeometryPoint);
case geometryType.Multipoint:
return(EsriGeometryType.esriGeometryMultipoint);
case geometryType.Polyline:
return(EsriGeometryType.esriGeometryPolyline);
case geometryType.Polygon:
return(EsriGeometryType.esriGeometryPolygon);
case geometryType.Aggregate:
return(EsriGeometryType.esriGeometryBag);
case geometryType.Envelope:
return(EsriGeometryType.esriGeometryEnvelope);
case geometryType.Unknown:
case geometryType.Network:
default:
return(EsriGeometryType.esriGeometryNull);
}
}
public ISymbol this[geometryType type]
{
get
{
switch (type)
{
case geometryType.Point:
return(_pointSymbol);
case geometryType.Polyline:
return(_lineSymbol);
case geometryType.Polygon:
return(_polygonSymbol);
}
return(null);
}
set
{
if (value == null)
{
return;
}
switch (type)
{
case geometryType.Point:
if (value != _pointSymbol)
{
_pointSymbol.Release();
_pointSymbol = value;
}
break;
case geometryType.Polyline:
if (value != _lineSymbol)
{
_lineSymbol.Release();
_lineSymbol = value;
}
break;
case geometryType.Polygon:
if (value != _polygonSymbol)
{
_polygonSymbol.Release();
_polygonSymbol = value;
}
break;
}
}
}
//private void SetFeatureClassAndFeature(IFeatureClass fc, IFeature feature)
//{
// if (_fc == fc && _feature == feature) return;
// _fc = fc;
// _feature = feature;
// if (_feature == null || feature.Shape == null)
// Sketch = null;
// else
// Sketch = new EditSketch(feature.Shape);
// if (OnChangeSelectedFeature != null)
// OnChangeSelectedFeature(this, fc, feature);
//}
internal void CreateStandardFeature()
{
if (_fc == null)
{
return;
}
Feature feature = new Feature();
geometryType gType = _fc.GeometryType;
if (gType == geometryType.Unknown)
{
FormChooseGeometry dlg = new FormChooseGeometry();
if (dlg.ShowDialog() != DialogResult.OK)
{
this.Sketch = null;
return;
}
gType = dlg.GeometryType;
}
switch (gType)
{
case geometryType.Point:
feature.Shape = new gView.Framework.Geometry.Point();
break;
case geometryType.Multipoint:
feature.Shape = new MultiPoint();
break;
case geometryType.Polyline:
feature.Shape = new Polyline();
break;
case geometryType.Polygon:
feature.Shape = new Polygon();
break;
default:
return;
}
_feature = feature;
if (OnCreateStandardFeature != null)
{
OnCreateStandardFeature(this, _feature);
}
Sketch = new EditSketch(_feature.Shape);
}
public bool SupportsGeometryType(geometryType geomType)
{
foreach (SymbolCollectionItem sSym in _symbols)
{
if (sSym?.Symbol != null)
{
if (sSym.Symbol.SupportsGeometryType(geomType) == false)
{
return(false);
}
}
}
return(true);
}
public static string DefaultLabelPlacement(geometryType type)
{
switch (type)
{
case geometryType.Point:
return("esriServerPointLabelPlacementAboveRight");
case geometryType.Polyline:
return("esriServerLinePlacementAboveAlong");
case geometryType.Polygon:
return("esriServerPolygonPlacementAlwaysHorizontal");
}
return(String.Empty);
}
private void btnAdd_Click(object sender, EventArgs e)
{
geometryType geomType = geometryType.Unknown;
if (_layer != null && _layer.FeatureClass != null)
{
geomType = _layer.FeatureClass.GeometryType;
}
if (geomType == geometryType.Unknown)
{
FormGeometrySelector geomSel = new FormGeometrySelector();
if (geomSel.ShowDialog() != DialogResult.OK ||
geomSel.GeometryType == geometryType.Unknown)
{
return;
}
geomType = geomSel.GeometryType;
}
ISymbol symbol = null;
switch (geomType)
{
case geometryType.Point:
symbol = new SimplePointSymbol();
break;
case geometryType.Polyline:
symbol = new SimpleLineSymbol();
break;
case geometryType.Polygon:
symbol = new SimpleFillSymbol();
break;
}
FormNewSLDRule newRule = new FormNewSLDRule(_layer,
new SLDRenderer.Rule(new gView.Framework.OGC.WFS.Filter(GmlVersion.v1), symbol));
if (newRule.ShowDialog() == DialogResult.OK)
{
_renderer.Rules.Add(newRule.Rule);
RendererBox.Items.Add(new RuleItem(newRule.Rule));
}
}
public Task <IEnumerable <IFeature> > GetFeatures(geometryType geometryType)
{
switch (geometryType)
{
case geometryType.Point:
return(GetFeatures <IPoint>());
case geometryType.Polyline:
return(GetFeatures <IPolyline>());
case geometryType.Polygon:
return(GetFeatures <IPolygon>());
default:
throw new Exception($"geometry type { geometryType } not implemented with GeoJsonSource");
}
}
internal DocumentCollection GetFeatureCollection(geometryType geomType)
{
switch (geomType)
{
case geometryType.Point:
case geometryType.Multipoint:
return(_featureCollection_points);
case geometryType.Polyline:
return(_featureCollection_lines);
case geometryType.Polygon:
return(_featureCollection_polygons);
default:
throw new Exception($"There is no collection for geometry-type '{geomType.ToString()}'");
}
}
public bool SupportsGeometryType(geometryType geomType) => geomType == geometryType.Polygon;
public FeatureClass(Dataset dataset, OSGeo.OGR.Layer layer)
{
_dataset = dataset;
_ogrLayer = layer;
OSGeo.OGR.FeatureDefn defn = layer.GetLayerDefn();
_name = defn.GetName();
if (dataset.ConnectionString.ToLower().EndsWith(".dxf"))
{
try
{
System.IO.FileInfo fi = new System.IO.FileInfo(dataset.ConnectionString);
_name = fi.Name;
}
catch { }
}
_fields = new Fields();
for (int i = 0; i < defn.GetFieldCount(); i++)
{
OSGeo.OGR.FieldDefn fdefn = defn.GetFieldDefn(i);
Field field = new Field(fdefn.GetName());
switch (fdefn.GetFieldTypeName(fdefn.GetFieldType()).ToLower())
{
case "integer":
if (_idFieldName == String.Empty)
{
_idFieldName = field.name;
}
field.type = FieldType.integer;
break;
case "real":
field.type = FieldType.Double;
break;
case "string":
field.type = FieldType.String;
field.size = fdefn.GetWidth();
break;
}
_fields.Add(field);
}
_countFeatures = layer.GetFeatureCount(1);
OSGeo.OGR.Envelope env = new OSGeo.OGR.Envelope();
layer.GetExtent(env, 1);
_envelope = new Envelope(env.MinX, env.MinY, env.MaxX, env.MaxY);
switch (defn.GetGeomType())
{
case OSGeo.OGR.wkbGeometryType.wkbPoint:
_geomType = geometryType.Point;
break;
case OSGeo.OGR.wkbGeometryType.wkbLineString:
case OSGeo.OGR.wkbGeometryType.wkbMultiLineString:
_geomType = geometryType.Polyline;
break;
case OSGeo.OGR.wkbGeometryType.wkbPolygon:
case OSGeo.OGR.wkbGeometryType.wkbMultiPolygon:
_geomType = geometryType.Polygon;
break;
}
}
public Fields ElementFields(string elementName, out string shapeFieldname, out geometryType geomType)
{
shapeFieldname = "";
geomType = geometryType.Unknown;
if (_schema == null)
{
return(null);
}
XmlNode elementNode = _schema.SelectSingleNode("W3:schema/W3:element[@name='" + elementName + "']", _ns);
if (elementNode == null || elementNode.Attributes["type"] == null)
{
elementNode = _schema.SelectSingleNode("W3:schema/W3:element[@name='" + TypeWithoutPrefix(elementName) + "']", _ns);
if (elementNode == null || elementNode.Attributes["type"] == null)
{
return(null);
}
}
string type = TypeWithoutPrefix(elementNode.Attributes["type"].Value);
XmlNode complexTypeNode = _schema.SelectSingleNode("W3:schema/W3:complexType[@name='" + type + "']", _ns);
if (complexTypeNode == null)
{
return(null);
}
Fields fields = new Fields();
foreach (XmlNode eNode in complexTypeNode.SelectNodes("W3:complexContent/W3:extension/W3:sequence/W3:element", _ns))
{
string name = String.Empty;
if (eNode.Attributes["name"] != null)
{
name = eNode.Attributes["name"].Value;
}
FieldType fType = FieldType.String;
int size = 8;
XmlNode restrictionNode = eNode.SelectSingleNode("W3:simpleType/W3:restriction[@base]", _ns);
if (restrictionNode != null)
{
switch (restrictionNode.Attributes["base"].Value.ToLower())
{
case "string":
fType = FieldType.String;
XmlNode maxLengthNode = restrictionNode.SelectSingleNode("W3:maxLength[@value]", _ns);
if (maxLengthNode != null)
{
size = int.Parse(maxLengthNode.Attributes["value"].Value);
}
break;
case "decimal":
fType = FieldType.Double;
break;
case "integer":
fType = FieldType.integer;
break;
}
}
else if (eNode.Attributes["type"] != null)
{
switch (TypeWithoutPrefix(eNode.Attributes["type"].Value.ToLower()))
{
case "string":
fType = FieldType.String;
break;
case "int":
case "integer":
fType = FieldType.integer;
break;
case "decimal":
case "double":
fType = FieldType.Double;
break;
case "geometrypropertytype":
shapeFieldname = name;
continue;
case "polygonproperty":
case "polygonpropertytype":
case "multipolygonproperty":
case "multipolygonpropertytype":
shapeFieldname = name;
geomType = geometryType.Polygon;
continue;
case "linestringproperty":
case "linestringpropertytype":
case "multilinestringproperty":
case "multilinestringpropertytype":
shapeFieldname = name;
geomType = geometryType.Polyline;
continue;
case "pointproperty":
case "pointpropertytype":
shapeFieldname = name;
geomType = geometryType.Point;
continue;
case "multipointproperty":
case "multipointpropertytype":
shapeFieldname = name;
geomType = geometryType.Multipoint;
continue;
case "featureidtype":
case "gmlobjectidtype":
fType = FieldType.ID;
break;
case "datetime":
fType = FieldType.Date;
break;
case "long":
fType = FieldType.biginteger;
break;
case "short":
fType = FieldType.smallinteger;
break;
default:
break;
}
}
else if (eNode.Attributes["ref"] != null)
{
switch (TypeWithoutPrefix(eNode.Attributes["ref"].Value.ToLower()))
{
case "polygonproperty":
case "polygonpropertytype":
case "multipolygonproperty":
case "multipolygonpropertytype":
shapeFieldname = name;
geomType = geometryType.Polygon;
continue;
case "linestringproperty":
case "linestringpropertytype":
case "multilinestringproperty":
case "multilinestringpropertytype":
shapeFieldname = name;
geomType = geometryType.Polyline;
continue;
case "pointproperty":
case "pointpropertytype":
shapeFieldname = name;
geomType = geometryType.Point;
continue;
case "multipointproperty":
case "multipointpropertytype":
shapeFieldname = name;
geomType = geometryType.Multipoint;
continue;
}
}
if (name != String.Empty)
{
fields.Add(new Field(name, fType, size));
}
}
return(fields);
}
public NullSymbol(geometryType geomType)
{
_geomType = geomType;
}
public bool SupportsGeometryType(geometryType geomType) => geomType == geometryType.Polygon || geomType == geometryType.Aggregate;
public SdeFeatureClass(SdeDataset dataset, SE_CONNECTION connection, SE_LAYERINFO layerInfo)
{
_dataset = dataset;
byte[] tableName = new byte[CONST.SE_QUALIFIED_TABLE_NAME];
byte[] columnName = new byte[CONST.SE_MAX_COLUMN_LEN];
byte[] shapeColumnName = new byte[CONST.SE_MAX_COLUMN_LEN];
System.Int32 status = Wrapper92.SE_layerinfo_get_spatial_column(layerInfo, tableName, shapeColumnName);
if (status != 0)
{
return;
}
_name = Functions.GetASCIIString(tableName);
//_shapeFildName mit den Felder abfragen, weils sonst oft Probleme mit Groß/Kleinschreibung der Felder gibt...
//_shapeFieldName = Functions.GetASCIIString(shapeColumnName);
SE_ENVELOPE sdeEnvelope = new SE_ENVELOPE();
status = Wrapper92.SE_layerinfo_get_envelope(layerInfo, ref sdeEnvelope);
if (status == 0)
{
_envelope = new Envelope(sdeEnvelope.minx, sdeEnvelope.miny, sdeEnvelope.maxx, sdeEnvelope.maxy);
}
System.Int32 shape_types = 0;
status = Wrapper92.SE_layerinfo_get_shape_types(layerInfo, ref shape_types);
if (status == 0)
{
if ((shape_types & CONST.SE_NIL_TYPE_MASK) != 0)
{
_geomType = geometryType.Unknown;
}
if ((shape_types & CONST.SE_POINT_TYPE_MASK) != 0)
{
_geomType = geometryType.Point;
}
if ((shape_types & CONST.SE_LINE_TYPE_MASK) != 0)
{
_geomType = geometryType.Polyline;
}
if ((shape_types & CONST.SE_SIMPLE_LINE_TYPE_MASK) != 0)
{
_geomType = geometryType.Polyline;
}
if ((shape_types & CONST.SE_AREA_TYPE_MASK) != 0)
{
_geomType = geometryType.Polygon;
}
//if ((shape_types & CONST.SE_UNVERIFIED_SHAPE_MASK) != 0)
//{
// _geomType = geometryType.Unknown;
//}
//if ((shape_types & CONST.SE_MULTIPART_TYPE_MASK) != 0)
//{
// _geomType = geometryType.Aggregate;
//}
}
// IDField
IntPtr regInfo = new IntPtr(0);
status = Wrapper92.SE_reginfo_create(ref regInfo);
if (status == 0)
{
try
{
if (Wrapper92.SE_registration_get_info(connection, _name, regInfo) == 0)
{
byte[] buffer = new byte[CONST.SE_MAX_COLUMN_LEN];
System.Int32 idColType = 0;
if (Wrapper92.SE_reginfo_get_rowid_column(regInfo, buffer, ref idColType) == 0)
{
_idFieldName = Functions.GetASCIIString(buffer);
}
}
}
catch { }
Wrapper92.SE_reginfo_free(regInfo);
}
// Felder auslesen
_fields = new Fields();
IntPtr ptr = new IntPtr(0);
System.Int16 numFields = 0;
status = Wrapper92.SE_table_describe(connection, _name, ref numFields, ref ptr);
if (status == 0)
{
try
{
unsafe
{
byte *columnDefs = (byte *)ptr;
for (int i = 0; i < numFields; i++)
{
SE_COLUMN_DEF colDef = (SE_COLUMN_DEF)Marshal.PtrToStructure((IntPtr)columnDefs, typeof(SE_COLUMN_DEF));
string colName = Functions.GetASCIIString(colDef.column_name);
FieldType colType = FieldType.unknown;
switch (colDef.sde_type)
{
case CONST.SE_SMALLINT_TYPE:
colType = FieldType.smallinteger;
break;
case CONST.SE_INTEGER_TYPE:
colType = FieldType.integer;
break;
case CONST.SE_FLOAT_TYPE:
colType = FieldType.Float;
break;
case CONST.SE_DOUBLE_TYPE:
colType = FieldType.Double;
break;
case CONST.SE_STRING_TYPE:
colType = FieldType.String;
break;
case CONST.SE_NSTRING_TYPE:
colType = FieldType.NString;
break;
case CONST.SE_BLOB_TYPE:
colType = FieldType.binary;
break;
case CONST.SE_DATE_TYPE:
colType = FieldType.Date;
break;
case CONST.SE_SHAPE_TYPE:
colType = FieldType.Shape;
if (String.IsNullOrEmpty(_shapeFieldName))
{
_shapeFieldName = colName;
}
break;
case CONST.SE_RASTER_TYPE:
break;
default:
colType = FieldType.unknown;
break;
}
if (colName == _idFieldName)
{
colType = FieldType.ID;
}
_fields.Add(new Field(colName, colType, (int)colDef.size, (int)colDef.decimal_digits));
columnDefs += Marshal.SizeOf(colDef);
}
}
}
catch (Exception ex)
{
_errMsg = ex.Message;
}
if (String.IsNullOrEmpty(_shapeFieldName)) // nur wenn bei den Felder nix gefunden wurde...
{
_shapeFieldName = Functions.GetASCIIString(shapeColumnName);
}
Wrapper92.SE_table_free_descriptions(ptr);
}
}
public bool SupportsGeometryType(geometryType geomType) => geomType == geometryType.Point || geomType == geometryType.Multipoint;
static public IGeometry MakeValid(this IGeometry geometry, geometryType geometryType = geometryType.Unknown, bool closeRings = false)
{
if (geometry == null)
{
throw new InvalidGeometryException("geometry is null");
}
#region Check geometry type
switch (geometryType)
{
case geometryType.Point:
if (!(geometry is IPoint))
{
throw new InvalidGeometryException("Invalid point type: " + geometry.GetType().ToString());
}
break;
case geometryType.Multipoint:
if (!(geometry is IMultiPoint))
{
throw new InvalidGeometryException("Invalid multipoint type: " + geometry.GetType().ToString());
}
break;
case geometryType.Polyline:
if (!(geometry is IPolyline))
{
throw new InvalidGeometryException("Invalid polyline type: " + geometry.GetType().ToString());
}
break;
case geometryType.Polygon:
if (!(geometry is IPolygon))
{
throw new InvalidGeometryException("Invalid polygon type: " + geometry.GetType().ToString());
}
break;
case geometryType.Aggregate:
if (!(geometry is IAggregateGeometry))
{
throw new InvalidGeometryException("Invalid aggregate geometry type: " + geometry.GetType().ToString());
}
break;
}
#endregion
if (geometry is IPolyline)
{
var polyline = (IPolyline)geometry;
#region Remove Zero Length Paths
int removePath;
do
{
removePath = -1;
for (int p = 0, to = polyline.PathCount; p < to; p++)
{
if (polyline[p] == null || polyline[p].Length == 0.0)
{
removePath = p;
break;
}
}
if (removePath >= 0)
{
polyline.RemovePath(removePath);
}
}while (removePath >= 0);
#endregion
}
if (geometry is IPolygon)
{
var polygon = (IPolygon)geometry;
#region Remove Zero Area Rings
int removeRing;
do
{
removeRing = -1;
for (int p = 0, to = polygon.RingCount; p < to; p++)
{
if (polygon[p] == null || polygon[p].Area == 0.0)
{
removeRing = p;
break;
}
}
if (removeRing >= 0)
{
polygon.RemoveRing(removeRing);
}
}while (removeRing >= 0);
#endregion
#region Check rings
for (int p = 0, to = polygon.RingCount; p < to; p++)
{
var ring = polygon[p];
if (Algorithm.IsSelfIntersecting(ring))
{
throw new InvalidGeometryException("Selfintersecting polygon rings are not allowed");
}
if (closeRings)
{
ring.Close();
}
}
#endregion
}
return(geometry);
}
public ShapeFileIcon(geometryType geoType)
{
_geoType = geoType;
}
public OpenFeatureLayerFilter(geometryType geomType)
: this()
{
_geomType = geomType;
}
public ISymbol this[geometryType type]
{
get { return(_symbol[type]); }
set { _symbol[type] = value; }
}
async public static Task <GeoJsonServiceFeatureClass> CreateInstance(GeoJsonServiceDataset dataset, geometryType geometryType)
{
var instance = new GeoJsonServiceFeatureClass(dataset);
instance.SpatialReference = await dataset.GetSpatialReference();
instance.GeometryType = geometryType;
instance.Name = $"{ dataset.DatasetName }-{ geometryType.ToString().ToLower() }";
#region Loop all features for Fields
var fields = new Fields();
if (dataset.Source != null)
{
bool idIsInterger = false;
var features = await dataset.Source.GetFeatures(geometryType);
// mayby later...
//if (features != null && features.Count() > 0)
//{
// idIsInterger = features.Where(f => f != null && int.TryParse(f["id"]?.ToString(), out int intId))
// .Count() == features.Count();
//}
foreach (var feature in features)
{
foreach (var fieldValue in feature.Fields)
{
if (fields.FindField(fieldValue.Name) == null)
{
var val = fieldValue.Value;
if (fieldValue.Name == "id" && idIsInterger)
{
fields.Add(new Field(fieldValue.Name, FieldType.ID));
}
else if (val?.GetType() == typeof(int))
{
fields.Add(new Field(fieldValue.Name, FieldType.integer));
}
else if (val?.GetType() == typeof(double))
{
fields.Add(new Field(fieldValue.Name, FieldType.Double));
}
else
{
// ToDo: Check for Date?
fields.Add(new Field(fieldValue.Name, FieldType.String));
}
}
}
}
}
instance.Fields = fields;
#endregion
return(instance);
}
public ISymbol CreateStandardHighlightSymbol(geometryType type)
{
return(RendererFunctions.CreateStandardHighlightSymbol(type));
}
public bool SupportsGeometryType(geometryType geomType) => true;
public OgcSpatialFeatureclass(OgcSpatialDataset dataset, DataRow geometry_columns_row)
{
_dataset = dataset;
if (_dataset == null || geometry_columns_row == null)
{
return;
}
try
{
_lastException = null;
string schema = String.Empty;
try
{
if (!String.IsNullOrEmpty(_dataset.OgcDictionary("geometry_columns.f_table_schema")))
{
schema = geometry_columns_row[_dataset.OgcDictionary("geometry_columns.f_table_schema")].ToString();
}
if (!String.IsNullOrEmpty(schema))
{
schema += ".";
}
}
catch { schema = ""; }
_name = schema + geometry_columns_row[_dataset.OgcDictionary("geometry_columns.f_table_name")].ToString();
_shapefield = geometry_columns_row[_dataset.OgcDictionary("geometry_columns.f_geometry_column")].ToString();
_idfield = _dataset.OgcDictionary("gid");
// Read Primary Key -> PostGIS id is not always "gid";
string pKey = GetPKey();
if (!String.IsNullOrWhiteSpace(pKey) && !pKey.Equals(_idfield))
{
_idfield = pKey;
}
_geometry_columns_type = geometry_columns_row[_dataset.OgcDictionary("geometry_columns.type")].ToString().ToUpper();
switch (_geometry_columns_type)
{
case "MULTIPOLYGON":
case "POLYGON":
case "MULTIPOLYGONM":
case "POLYGONM":
_geomType = geometryType.Polygon;
break;
case "MULTILINESTRING":
case "LINESTRING":
case "MULTILINESTRINGM":
case "LINESTRINGM":
_geomType = geometryType.Polyline;
break;
case "POINT":
case "POINTM":
case "MULTIPOINT":
case "MULTIPOINTM":
_geomType = geometryType.Point;
break;
default:
_geomType = geometryType.Unknown;
break;
}
_hasZ = (int)geometry_columns_row[_dataset.OgcDictionary("geometry_columns.coord_dimension")] == 3;
try
{
int srid = int.Parse(geometry_columns_row[_dataset.OgcDictionary("geometry_columns.srid")].ToString());
if (srid > 0)
{
_sRef = gView.Framework.Geometry.SpatialReference.FromID("epsg:" + srid.ToString());
}
else
{
_sRef = TrySelectSpatialReference(dataset, this);
}
}
catch { }
ReadSchema();
}
catch (Exception ex)
{
_lastException = ex;
string msg = ex.Message;
}
}
public void Load(IPersistStream stream)
{
_geomType = (geometryType)stream.Load("geomtype", (int)geometryType.Unknown);
}
public SdeFeatureClass(SdeDataset dataset, SE_CONNECTION connection, SE_LAYERINFO layerInfo)
{
_dataset = dataset;
byte[] tableName = new byte[CONST.SE_QUALIFIED_TABLE_NAME];
byte[] columnName = new byte[CONST.SE_MAX_COLUMN_LEN];
byte[] shapeColumnName = new byte[CONST.SE_MAX_COLUMN_LEN];
System.Int32 status = Wrapper10.SE_layerinfo_get_spatial_column(layerInfo, tableName, shapeColumnName);
if (status != 0)
{
return;
}
_name = Functions.GetASCIIString(tableName);
//_shapeFildName mit den Felder abfragen, weils sonst oft Probleme mit Groß/Kleinschreibung der Felder gibt...
//_shapeFieldName = Functions.GetASCIIString(shapeColumnName);
SE_ENVELOPE sdeEnvelope = new SE_ENVELOPE();
status = Wrapper10.SE_layerinfo_get_envelope(layerInfo, ref sdeEnvelope);
if (status == 0)
{
_envelope = new Envelope(sdeEnvelope.minx, sdeEnvelope.miny, sdeEnvelope.maxx, sdeEnvelope.maxy);
}
System.Int32 shape_types = 0;
status = Wrapper10.SE_layerinfo_get_shape_types(layerInfo, ref shape_types);
if (status == 0)
{
if ((shape_types & CONST.SE_NIL_TYPE_MASK) != 0)
{
_geomType = geometryType.Unknown;
}
if ((shape_types & CONST.SE_POINT_TYPE_MASK) != 0)
{
_geomType = geometryType.Point;
}
if ((shape_types & CONST.SE_LINE_TYPE_MASK) != 0)
{
_geomType = geometryType.Polyline;
}
if ((shape_types & CONST.SE_SIMPLE_LINE_TYPE_MASK) != 0)
{
_geomType = geometryType.Polyline;
}
if ((shape_types & CONST.SE_AREA_TYPE_MASK) != 0)
{
_geomType = geometryType.Polygon;
}
//if ((shape_types & CONST.SE_UNVERIFIED_SHAPE_MASK) != 0)
//{
// _geomType = geometryType.Unknown;
//}
//if ((shape_types & CONST.SE_MULTIPART_TYPE_MASK) != 0)
//{
// _geomType = geometryType.Aggregate;
//}
}
// IDField
IntPtr regInfo = new IntPtr(0);
status = Wrapper10.SE_reginfo_create(ref regInfo);
if (status == 0)
{
try
{
if (Wrapper10.SE_registration_get_info(connection, _name, regInfo) == 0)
{
byte[] buffer = new byte[CONST.SE_MAX_COLUMN_LEN];
System.Int32 idColType = 0;
if (Wrapper10.SE_reginfo_get_rowid_column(regInfo, buffer, ref idColType) == 0)
{
_idFieldName = Functions.GetASCIIString(buffer);
}
}
}
catch { }
Wrapper10.SE_reginfo_free(regInfo);
}
// Felder auslesen
_fields = new Fields();
IntPtr ptr = new IntPtr(0);
System.Int16 numFields = 0;
status = Wrapper10.SE_table_describe(connection, _name, ref numFields, ref ptr);
if (status == 0)
{
try
{
unsafe
{
byte *columnDefs = (byte *)ptr;
for (int i = 0; i < numFields; i++)
{
SE_COLUMN_DEF colDef = (SE_COLUMN_DEF)Marshal.PtrToStructure((IntPtr)columnDefs, typeof(SE_COLUMN_DEF));
string colName = Functions.GetASCIIString(colDef.column_name);
FieldType colType = FieldType.unknown;
switch (colDef.sde_type)
{
case CONST.SE_SMALLINT_TYPE:
colType = FieldType.smallinteger;
break;
case CONST.SE_INTEGER_TYPE:
colType = FieldType.integer;
break;
case CONST.SE_FLOAT_TYPE:
colType = FieldType.Float;
break;
case CONST.SE_DOUBLE_TYPE:
colType = FieldType.Double;
break;
case CONST.SE_STRING_TYPE:
colType = FieldType.String;
break;
case CONST.SE_NSTRING_TYPE:
colType = FieldType.NString;
break;
case CONST.SE_BLOB_TYPE:
colType = FieldType.binary;
break;
case CONST.SE_DATE_TYPE:
colType = FieldType.Date;
break;
case CONST.SE_SHAPE_TYPE:
colType = FieldType.Shape;
if (String.IsNullOrEmpty(_shapeFieldName))
{
_shapeFieldName = colName;
}
break;
case CONST.SE_RASTER_TYPE:
break;
default:
colType = FieldType.unknown;
break;
}
if (colName.ToLower() == _idFieldName.ToLower())
{
colType = FieldType.ID;
colName = _idFieldName;
}
_fields.Add(new Field(colName, colType, (int)colDef.size, (int)colDef.decimal_digits));
columnDefs += Marshal.SizeOf(colDef);
}
}
// Not so good -> no datum transformation
// Better set it NULL and transform layer automatically if nessessary by the Map.LayerDefaultSpatialReference (this is used for all layers with SRef==NULL
//this.SpatialReference = _dataset.GetLayerSpatialReference(connection, this.Name, this.ShapeFieldName);
}
catch (Exception ex)
{
_errMsg = ex.Message;
}
if (String.IsNullOrEmpty(_shapeFieldName)) // nur wenn bei den Felder nix gefunden wurde...
{
_shapeFieldName = Functions.GetASCIIString(shapeColumnName);
}
if (String.IsNullOrWhiteSpace(_idFieldName))
{
// If there is no ID (Views), try to find a UNIQUE integer field
foreach (var field in _fields)
{
if (field.type == FieldType.integer)
{
QueryFilter qFilter = new QueryFilter();
qFilter.SubFields = field.name;
List <int> ids = new List <int>();
using (IFeatureCursor cursor = this.GetFeatures(qFilter))
{
IFeature feature;
while ((feature = cursor.NextFeature) != null)
{
int id = Convert.ToInt32(feature[field.name]);
ids.Add(id);
}
}
if (ids.Count > 0 && ids.Count == ids.Distinct().Count()) // Check if Unique
{
_idFieldName = field.name;
((Field)field).type = FieldType.ID;
break;
}
}
}
}
Wrapper10.SE_table_free_descriptions(ptr);
}
}