/// <summary>
/// DotSpatial to Ogr at feature field level
/// </summary>
/// <param name="dataColumn">DataColumn of DataTable of FeatureSet</param>
/// <returns>Ogr FieldDefn</returns>
public static OSGeo.OGR.FieldDefn DS2OgrField(DataColumn dataColumn)
{
OSGeo.OGR.FieldType fieldType = new OSGeo.OGR.FieldType();
string type = dataColumn.DataType.Name.ToUpper();
switch (type)
{
case "INT":
fieldType = OSGeo.OGR.FieldType.OFTInteger;
break;
case "STRING":
fieldType = OSGeo.OGR.FieldType.OFTString;
break;
case "DATETIME":
fieldType = OSGeo.OGR.FieldType.OFTDate;
break;
case "DOUBLE":
fieldType = OSGeo.OGR.FieldType.OFTReal;
break;
default:
fieldType = OSGeo.OGR.FieldType.OFTString;
break;
}
return(new OSGeo.OGR.FieldDefn(dataColumn.Caption, fieldType));
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="attName"></param>
/// <param name="attType"></param>
/// <param name="attWidth"></param>
/// <param name="attApprox"></param>
public AttributeModel(string attName, OSGeo.OGR.FieldType attType, int attWidth, int attApprox)
{
_attributeApproxOK = attApprox;
_attributeType = attType;
_attributeWidth = attWidth;
_attributeName = attName;
}
/// <summary>
/// Ogr to DotSpatial at feature field level
/// </summary>
/// <param name="fieldDefn">Ogr FieldDefn</param>
/// <returns>DataColumn of DataTable of FeatureSet</returns>
public static DataColumn Ogr2DSField(OSGeo.OGR.FieldDefn fieldDefn)
{
DataColumn dataColumn = new DataColumn();
dataColumn.ColumnName = fieldDefn.GetName();
dataColumn.Caption = fieldDefn.GetName();//column title
OSGeo.OGR.FieldType fieldType = fieldDefn.GetFieldType();
switch (fieldType)
{
case OSGeo.OGR.FieldType.OFTInteger:
dataColumn.DataType = typeof(int);
break;
case OSGeo.OGR.FieldType.OFTString:
dataColumn.DataType = typeof(string);
break;
case OSGeo.OGR.FieldType.OFTDate:
dataColumn.DataType = typeof(DateTime);
break;
case OSGeo.OGR.FieldType.OFTReal:
dataColumn.DataType = typeof(double);
break;
default:
dataColumn.DataType = typeof(string);
break;
}
return(dataColumn);
}
public static OSGeo.OGR.FieldType ToFieldType(this FieldType fieldType)
{
if (fieldType == FieldType.Unkown)
{
throw new NotImplementedException();
}
OSGeo.OGR.FieldType destFieldType = OSGeo.OGR.FieldType.OFTString;
switch (fieldType)
{
case FieldType.Int:
destFieldType = OSGeo.OGR.FieldType.OFTInteger;
break;
case FieldType.IntList:
destFieldType = OSGeo.OGR.FieldType.OFTIntegerList;
break;
case FieldType.Double:
destFieldType = OSGeo.OGR.FieldType.OFTReal;
break;
case FieldType.DoubleList:
destFieldType = OSGeo.OGR.FieldType.OFTRealList;
break;
case FieldType.String:
destFieldType = OSGeo.OGR.FieldType.OFTString;
break;
case FieldType.StringList:
destFieldType = OSGeo.OGR.FieldType.OFTStringList;
break;
case FieldType.WideString:
destFieldType = OSGeo.OGR.FieldType.OFTWideString;
break;
case FieldType.WideStringList:
destFieldType = OSGeo.OGR.FieldType.OFTWideStringList;
break;
case FieldType.Binary:
destFieldType = OSGeo.OGR.FieldType.OFTBinary;
break;
case FieldType.DateTime:
destFieldType = OSGeo.OGR.FieldType.OFTDateTime;
break;
case FieldType.Long:
destFieldType = OSGeo.OGR.FieldType.OFTInteger64;
break;
case FieldType.LongList:
destFieldType = OSGeo.OGR.FieldType.OFTInteger64List;
break;
}
return(destFieldType);
}
public static FieldType ToFieldType(this OSGeo.OGR.FieldType fieldType)
{
FieldType destFieldType = FieldType.Unkown;
switch (fieldType)
{
case OSGeo.OGR.FieldType.OFTInteger:
destFieldType = FieldType.Int;
break;
case OSGeo.OGR.FieldType.OFTIntegerList:
destFieldType = FieldType.IntList;
break;
case OSGeo.OGR.FieldType.OFTReal:
destFieldType = FieldType.Double;
break;
case OSGeo.OGR.FieldType.OFTRealList:
destFieldType = FieldType.DoubleList;
break;
case OSGeo.OGR.FieldType.OFTString:
destFieldType = FieldType.String;
break;
case OSGeo.OGR.FieldType.OFTStringList:
destFieldType = FieldType.StringList;
break;
case OSGeo.OGR.FieldType.OFTWideString:
destFieldType = FieldType.WideString;
break;
case OSGeo.OGR.FieldType.OFTWideStringList:
destFieldType = FieldType.WideStringList;
break;
case OSGeo.OGR.FieldType.OFTBinary:
destFieldType = FieldType.Binary;
break;
case OSGeo.OGR.FieldType.OFTDateTime:
destFieldType = FieldType.DateTime;
break;
case OSGeo.OGR.FieldType.OFTInteger64:
destFieldType = FieldType.Long;
break;
case OSGeo.OGR.FieldType.OFTInteger64List:
destFieldType = FieldType.LongList;
break;
}
return(destFieldType);
}
public static string OGRFiledType2String(OSGeo.OGR.FieldType type)
{
switch (type)
{
case OSGeo.OGR.FieldType.OFTInteger:
return("int");
case OSGeo.OGR.FieldType.OFTReal:
return("float");
default:
return("varchar");
}
}
/// <summary>
/// Reads the field types from the OgrFeatureDefinition -> OgrFieldDefinition
/// </summary>
/// <param name="fdt">FeatureDatatTable</param>
/// <param name="oLayer">OgrLayer</param>
private static void ReadColumnDefinition(FeatureDataTable fdt, OgrLayer oLayer)
{
using (OgrFeatureDefn ogrFeatureDefn = oLayer.GetLayerDefn())
{
int iField;
for (iField = 0; iField < ogrFeatureDefn.GetFieldCount(); iField++)
{
using (OgrFieldDefn ogrFldDef = ogrFeatureDefn.GetFieldDefn(iField))
{
OgrFieldType type = ogrFldDef.GetFieldType();
switch (type)
{
case OgrFieldType.OFTInteger:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Int32));
break;
case OgrFieldType.OFTReal:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Double));
break;
case OgrFieldType.OFTString:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(String));
break;
case OgrFieldType.OFTWideString:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(String));
break;
case OgrFieldType.OFTDate:
case OgrFieldType.OFTTime:
case OgrFieldType.OFTDateTime:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(DateTime));
break;
default:
{
//fdt.Columns.Add(_OgrFldDef.GetName(), System.Type.GetType("System.String"));
Debug.WriteLine("Not supported type: " + type + " [" + ogrFldDef.GetName() + "]");
break;
}
}
}
}
}
}
public Boolean Evaluate(Feature feature)
{
if (this.name.Equals("FeatureID"))
{
if (feature.featureID > value)
{
return(true);
}
else
{
return(false);
}
}
OSGeo.OGR.FieldType type = feature.schema.fields[this.name].GetFieldType();
switch (type)
{
case OSGeo.OGR.FieldType.OFTInteger:
if ((int)feature.GetArrtributeByName(this.name) > this.value)
{
return(true);
}
else
{
return(false);
}
case OSGeo.OGR.FieldType.OFTReal:
if ((double)feature.GetArrtributeByName(this.name) > this.value)
{
return(true);
}
else
{
return(false);
}
default:
return(false);
}
}
public bool AppendField(String field_name, OSGeo.OGR.FieldType field_type)
{
this.schema.AppendField(new OSGeo.OGR.FieldDefn(field_name, field_type));
return(true);
}
public static void map_fields(OSGeo.OGR.Layer ogr_layer,
out System.Collections.Hashtable outFieldMap,
out ESRI.ArcGIS.Geodatabase.IFields outFields,
out ESRI.ArcGIS.Geodatabase.esriDatasetType outDatasetType,
out ESRI.ArcGIS.Geometry.esriGeometryType outGeometryType,
out int outShapeIndex,
out int outOIDFieldIndex,
out ISpatialReference outSpatialReference)
{
outSpatialReference = null;
outFields = null;
outDatasetType = ESRI.ArcGIS.Geodatabase.esriDatasetType.esriDTTable; // start assuming it is a table
outGeometryType = esriGeometryType.esriGeometryNull; //don't know what it is
outOIDFieldIndex = -1;
outShapeIndex = -1;
outFieldMap = new System.Collections.Hashtable();
System.Collections.ArrayList fieldArray = new System.Collections.ArrayList();
OSGeo.OGR.FeatureDefn featDef = ogr_layer.GetLayerDefn();
int fieldsInserted = 0;
// OIDs and Geometries can be pseudo fields in GDAL and are thus *may* not included in the OGR FieldDef
// To account for that add those first (if they exist) and keep a mapping of fields using
// fieldsInserted
//////////////////////////////
//
// handle oid field pseudo column
//
ESRI.ArcGIS.Geodatabase.IFieldEdit2 oidFieldEdit = new ESRI.ArcGIS.Geodatabase.FieldClass();
if (ogr_layer.GetFIDColumn().Length > 0)
{
oidFieldEdit.Name_2 = ogr_layer.GetFIDColumn();
oidFieldEdit.AliasName_2 = ogr_layer.GetFIDColumn();
}
else
{
oidFieldEdit.Name_2 = "FID";
oidFieldEdit.AliasName_2 = "FID";
}
oidFieldEdit.Type_2 = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeOID;
fieldArray.Add(oidFieldEdit);
outOIDFieldIndex = fieldsInserted;
fieldsInserted++;
//////////////////////////////////////
//
// handle (optional) geometry field pseudo column
//
if (!(ogr_layer.GetGeomType() == OSGeo.OGR.wkbGeometryType.wkbNone ||
ogr_layer.GetGeomType() == OSGeo.OGR.wkbGeometryType.wkbUnknown))
{
ESRI.ArcGIS.Geodatabase.IFieldEdit2 geomFieldEdit = new ESRI.ArcGIS.Geodatabase.FieldClass();
if (ogr_layer.GetGeometryColumn().Length > 0)
{
geomFieldEdit.Name_2 = ogr_layer.GetGeometryColumn();
geomFieldEdit.AliasName_2 = ogr_layer.GetGeometryColumn();
}
else
{
geomFieldEdit.Name_2 = "Shape";
geomFieldEdit.AliasName_2 = "Shape";
}
geomFieldEdit.Type_2 = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeGeometry;
// add geometry def
ESRI.ArcGIS.Geometry.esriGeometryType gdbType;
bool hasZ;
ogr_geo_type_to_esri_geo_type(ogr_layer.GetGeomType(), out gdbType, out hasZ);
ESRI.ArcGIS.Geodatabase.IGeometryDefEdit geomDef = new ESRI.ArcGIS.Geodatabase.GeometryDefClass();
geomDef.GeometryType_2 = gdbType;
geomDef.HasM_2 = false; //no M support on OGR
geomDef.HasZ_2 = hasZ;
geomDef.SpatialReference_2 = outSpatialReference = ogr_utils.get_spatialReference(ogr_layer.GetSpatialRef());
geomFieldEdit.GeometryDef_2 = geomDef;
fieldArray.Add(geomFieldEdit);
outDatasetType = ESRI.ArcGIS.Geodatabase.esriDatasetType.esriDTFeatureClass; // upgrade to featureclass
outGeometryType = gdbType;
outShapeIndex = fieldsInserted;
fieldsInserted++;
}
int fieldCount = featDef.GetFieldCount();
for (int i = 0; i < fieldCount; i++)
{
// map OGR field to ArcObjects
OSGeo.OGR.FieldDefn fieldDef = featDef.GetFieldDefn(i);
ESRI.ArcGIS.Geodatabase.IFieldEdit2 fieldEdit = new ESRI.ArcGIS.Geodatabase.FieldClass();
fieldEdit.Name_2 = fieldDef.GetName();
fieldEdit.AliasName_2 = fieldDef.GetName();
// map type
OSGeo.OGR.FieldType ogrFieldType = fieldDef.GetFieldType();
ESRI.ArcGIS.Geodatabase.esriFieldType mappedType;
switch (ogrFieldType)
{
case OSGeo.OGR.FieldType.OFTInteger:
mappedType = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeInteger;
break;
case OSGeo.OGR.FieldType.OFTReal:
mappedType = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeDouble;
break;
case OSGeo.OGR.FieldType.OFTString:
mappedType = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeString;
break;
case OSGeo.OGR.FieldType.OFTBinary:
mappedType = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeBlob;
break;
case OSGeo.OGR.FieldType.OFTDateTime:
mappedType = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeDate;
break;
default:
mappedType = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeString;
break;
}
fieldEdit.Type_2 = mappedType;
outFieldMap.Add(fieldsInserted, i);
fieldArray.Add(fieldEdit);
fieldsInserted++;
}
// Add all the fields from the array to an ESRI fields class object. The reason that we do that
// here is that we need to know the count in advance
ESRI.ArcGIS.Geodatabase.IFieldsEdit fields = new ESRI.ArcGIS.Geodatabase.FieldsClass();
fields.FieldCount_2 = fieldArray.Count;
for (int i = 0; i < fieldArray.Count; i++)
{
fields.set_Field(i, fieldArray[i] as ESRI.ArcGIS.Geodatabase.IField);
}
outFields = fields;
}
private static FeatureDataRow OgrFeatureToFeatureDataRow(FeatureDataTable table, OSGeo.OGR.Feature ogrFeature, GeoAPI.Geometries.IGeometryFactory factory)
{
FeatureDataRow fdr = table.NewRow();
Int32 fdrIndex = 0;
for (int iField = 0; iField < ogrFeature.GetFieldCount(); iField++)
{
//*** BEGIN FIX: Ensure fdrIndex is incremented if field value is not set and field is of a supported type.
bool valueAvailable = ogrFeature.IsFieldSet(iField);
OgrFieldType fieldType = ogrFeature.GetFieldType(iField);
// No need to get field value if there's no value available...
if (!valueAvailable)
{
// We need to increment the data row column index if this is a supported field type
// otherwise the next field will be written to the wrong column...
// We support all types except OFTBinary...
// Supported field types must be consistent with the code in ReadColumnDefinition and the switch case below...
if (fieldType != OgrFieldType.OFTBinary)
{
fdrIndex++;
}
continue;
}
//*** END FIX
//if (!ogrFeature.IsFieldSet(iField)) continue;
try
{
switch (ogrFeature.GetFieldType(iField))
{
case OgrFieldType.OFTString:
case OgrFieldType.OFTWideString:
{
fdr[fdrIndex++] = ogrFeature.GetFieldAsString(iField);
break;
}
case OgrFieldType.OFTStringList:
case OgrFieldType.OFTWideStringList:
{
fdr[fdrIndex++] = ogrFeature.GetFieldAsStringList(iField);
break;
}
case OgrFieldType.OFTInteger:
{
fdr[fdrIndex++] = ogrFeature.GetFieldAsInteger(iField);
break;
}
case OgrFieldType.OFTIntegerList:
{
int count = 0;
fdr[fdrIndex++] = ogrFeature.GetFieldAsIntegerList(iField, out count);
break;
}
case OgrFieldType.OFTReal:
{
fdr[fdrIndex++] = ogrFeature.GetFieldAsDouble(iField);
break;
}
case OgrFieldType.OFTRealList:
{
int count = 0;
fdr[fdrIndex++] = ogrFeature.GetFieldAsDoubleList(iField, out count);
break;
}
case OgrFieldType.OFTDate:
case OgrFieldType.OFTDateTime:
case OgrFieldType.OFTTime:
Int32 y, m, d, h, mi, s, tz;
ogrFeature.GetFieldAsDateTime(iField, out y, out m, out d, out h, out mi, out s, out tz);
try
{
if (y == 0 && m == 0 && d == 0)
{
fdr[fdrIndex++] = DateTime.MinValue.AddMinutes(h * 60 + mi);
}
else
{
fdr[fdrIndex++] = new DateTime(y, m, d, h, mi, s);
}
}
catch
{
throw;
}
break;
default:
Debug.WriteLine(string.Format("Cannot handle Ogr DataType '{0}', '{1}'", ogrFeature.GetFieldType(iField), iField));
break;
}
}
catch { }
}
using (var gr = ogrFeature.GetGeometryRef())
{
fdr.Geometry = ParseOgrGeometry(gr, factory);
gr.Dispose();
}
return(fdr);
}
