public static void ReportFeature(Feature feat, FeatureDefn def)
{
Console.WriteLine("Feature(" + def.GetName() + "): " + feat.GetFID());
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
FieldDefn fdef = def.GetFieldDefn(iField);
Console.Write(fdef.GetNameRef() + " (" +
fdef.GetFieldTypeName(fdef.GetFieldType()) + ") = ");
if (feat.IsFieldSet(iField))
{
if (fdef.GetFieldType() == FieldType.OFTStringList)
{
string[] sList = feat.GetFieldAsStringList(iField);
foreach (string s in sList)
{
Console.Write("\"" + s + "\" ");
}
Console.WriteLine();
}
else if (fdef.GetFieldType() == FieldType.OFTIntegerList)
{
int count;
int[] iList = feat.GetFieldAsIntegerList(iField, out count);
for (int i = 0; i < count; i++)
{
Console.Write(iList[i] + " ");
}
Console.WriteLine();
}
else if (fdef.GetFieldType() == FieldType.OFTRealList)
{
int count;
double[] iList = feat.GetFieldAsDoubleList(iField, out count);
for (int i = 0; i < count; i++)
{
Console.Write(iList[i].ToString() + " ");
}
Console.WriteLine();
}
else
{
Console.WriteLine(feat.GetFieldAsString(iField));
}
}
else
{
Console.WriteLine("(null)");
}
}
if (feat.GetStyleString() != null)
{
Console.WriteLine(" Style = " + feat.GetStyleString());
}
Geometry geom = feat.GetGeometryRef();
if (geom != null)
{
Console.WriteLine(" " + geom.GetGeometryName() +
"(" + geom.GetGeometryType() + ")");
Geometry sub_geom;
for (int i = 0; i < geom.GetGeometryCount(); i++)
{
sub_geom = geom.GetGeometryRef(i);
if (sub_geom != null)
{
Console.WriteLine(" subgeom" + i + ": " + sub_geom.GetGeometryName() +
"(" + sub_geom.GetGeometryType() + ")");
}
}
Envelope env = new Envelope();
geom.GetEnvelope(env);
Console.WriteLine(" ENVELOPE: " + env.MinX + "," + env.MaxX + "," +
env.MinY + "," + env.MaxY);
string geom_wkt;
geom.ExportToWkt(out geom_wkt);
Console.WriteLine(" " + geom_wkt);
}
Console.WriteLine("");
}
public static void Test2()
{
try
{
Ogr.RegisterAll();
string shapefile = @"C:\data\Links\Links.shp";
DataSource ds = Ogr.Open(shapefile, 0);
Driver driver = ds.GetDriver();
int nLayerCount = ds.GetLayerCount();//1
for (int iLayer = 0; iLayer < nLayerCount; iLayer++)
{
Layer layer = ds.GetLayerByIndex(iLayer);
string layerName = layer.GetName();
int fc = layer.GetFeatureCount(1);
Envelope env = new Envelope();
layer.GetExtent(env, 1);
//MessageBox.Show("test sr");
OSGeo.OSR.SpatialReference sr = layer.GetSpatialRef();
string sr_wkt;
sr.ExportToPrettyWkt(out sr_wkt, 1);
layer.GetName();
FeatureDefn def = layer.GetLayerDefn();
def.GetName();
for (int iField = 0; iField < def.GetFieldCount(); iField++)
{
FieldDefn fdef = def.GetFieldDefn(iField);
string fieldName = fdef.GetName(); //Id Name URL
FieldType fieldType = fdef.GetFieldType(); //OFTInteger OFTString OFTString
string fieldTypeName = fdef.GetFieldTypeName(fdef.GetFieldType()); //Integer String String
int width = fdef.GetWidth(); //6 50 254
int precision = fdef.GetPrecision(); //0 0 0
}
for (int fid = 0; fid < layer.GetFeatureCount(1); fid++)
{
Feature f = layer.GetFeature(fid);
int id = f.GetFID();
int nFiledCount = f.GetFieldCount();
Geometry geom = f.GetGeometryRef();
// retrive geometry data
//this.Geometrys.Add(geom);
string geomName = geom.GetGeometryName(); //POINT
string geomType = geom.GetGeometryType().ToString(); //wkbPoint
Envelope geom_env = new Envelope();
geom.GetEnvelope(geom_env);
// wkt
string geom_wkt;
geom.ExportToWkt(out geom_wkt);//"POINT (-63.490966216299803 46.66247022944782)"
int wkbSize = geom.WkbSize();
if (wkbSize > 0)
{
// wkb
byte[] geom_wkb = new byte[wkbSize];
geom.ExportToWkb(geom_wkb);
string str_wkb = BitConverter.ToString(geom_wkb);
// wkb--->wkt
Geometry geom2 = Geometry.CreateFromWkb(geom_wkb);
string geom2_wkt;
geom2.ExportToWkt(out geom2_wkt);
}
f.Dispose();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
return;
}
}
public static Style createRankStyle(FeatureSource featuresource, string attributename, int num, Color startcolor, Color endcolor)
{
Schema schema = featuresource.schema;
SymbolizerType sign = SymbolizerType.POINT;
switch (schema.geometryType)
{
case OSGeo.OGR.wkbGeometryType.wkbPoint:
sign = SymbolizerType.POINT;
break;
case OSGeo.OGR.wkbGeometryType.wkbLineString:
sign = SymbolizerType.LINE;
break;
case OSGeo.OGR.wkbGeometryType.wkbPolygon:
sign = SymbolizerType.POLYGON;
break;
}
FieldDefn fielddefn = null;
if (schema.fields.TryGetValue(attributename, out fielddefn) || attributename.Equals("FeatureID"))
{
FieldType type = FieldType.OFTString;
if (!attributename.Equals("FeatureID"))
{
type = fielddefn.GetFieldType();
}
if (type == FieldType.OFTInteger || type == FieldType.OFTReal || attributename.Equals("FeatureID"))
{
double maxvalue = double.MinValue;
double minvalue = double.MaxValue;
foreach (GisSmartTools.Data.Feature feature in featuresource.features.featureList)
{
double value = 0;
if (type == FieldType.OFTInteger || attributename.Equals("FeatureID"))
{
value = (int)feature.GetArrtributeByName(attributename);
}
if (type == FieldType.OFTReal)
{
value = (double)feature.GetArrtributeByName(attributename);
}
if (value > maxvalue)
{
maxvalue = value;
}
if (value < minvalue)
{
minvalue = value;
}
}
if (num == 0)
{
return(null);
}
double x = (maxvalue - minvalue) / num;
//逐个创建对应的rule
Color[] colorarray = Utils.GetLinearColorList(startcolor, endcolor, num);
double temp_minvalue = minvalue;
double temp_maxvalue = minvalue + x;
List <RenderRule> rulelist = new List <RenderRule>();
// Printer.printnode("min=" + minvalue + " max=" + maxvalue, "");
for (int i = 0; i < num; i++)
{
RenderRule rule = RenderRule.createDefaultRule(sign, colorarray[i]);
Filter_Larger larger = new Filter_Larger(attributename, temp_minvalue);
Filter_Less less = new Filter_Less(attributename, temp_maxvalue);
List <Filter.Filter> filterlist = new List <Filter.Filter>();
filterlist.Add(larger); filterlist.Add(less);
Filter_And andfilter = new Filter_And(filterlist);
rule.filter = andfilter;
rulelist.Add(rule);
// Printer.printnode("temp_" + i, "min=" + temp_minvalue + " max=" + temp_maxvalue);
temp_minvalue += x; temp_maxvalue += x;
}
Style rankstyle = new Style("RankStyle", StyleType.RANKSTYLE, RenderRule.createDefaultRule(sign, startcolor));
rankstyle.rulelist = rulelist;
Printer.printnode("rulist,count=", "" + rulelist.Count);
return(rankstyle);
}
}
return(null);
}
public void readLayerTest(string strVectorFile)
{
Gdal.AllRegister();
//为了支持中文路径，请添加下面这句代码
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
//为了使属性表字段支持中文，请添加下面这句
Gdal.SetConfigOption("SHAPE_ENCODING", "");
// 注册所有的驱动
Ogr.RegisterAll();
Gdal.SetConfigOption("GDAL_DATA", "E://lib//gdal//gdal1.9//data");
//打开数据
DataSource ds = Ogr.Open(strVectorFile, 0);
if (ds == null)
{
Console.WriteLine("打开文件【{0}】失败！", strVectorFile);
return;
}
Console.WriteLine("打开文件【{0}】成功！", strVectorFile);
// 获取该数据源中的图层个数，一般shp数据图层只有一个，如果是mdb、dxf等图层就会有多个
int iLayerCount = ds.GetLayerCount();
// 获取第一个图层
Layer oLayer = ds.GetLayerByIndex(0);
String c = "";
oLayer.GetSpatialRef().AutoIdentifyEPSG();
Console.WriteLine(oLayer.GetSpatialRef().AutoIdentifyEPSG());
OSGeo.OSR.SpatialReference spa = oLayer.GetSpatialRef();
// if (spa==null)
// {
spa = new OSGeo.OSR.SpatialReference(null);
spa.ImportFromEPSG(3395);
spa.ExportToWkt(out c);
Console.WriteLine(c);
return;
// }
// String a = "";
// spa.EPSGTreatsAsLatLong();
// Console.WriteLine(spa.ExportToWkt(out a));
// oLayer.GetSpatialRef().ExportToWkt(out a);
// Console.WriteLine(spa.GetProjParm(out a));
// Console.WriteLine(oLayer.GetSpatialRef().GetLinearUnitsName());
if (oLayer == null)
{
Console.WriteLine("获取第{0}个图层失败！\n", 0);
return;
}
// 对图层进行初始化，如果对图层进行了过滤操作，执行这句后，之前的过滤全部清空
oLayer.ResetReading();
// 通过属性表的SQL语句对图层中的要素进行筛选，这部分详细参考SQL查询章节内容
// oLayer.SetAttributeFilter("\"NAME99\"LIKE \"北京市市辖区\"");
// 通过指定的几何对象对图层中的要素进行筛选
//oLayer.SetSpatialFilter();
// 通过指定的四至范围对图层中的要素进行筛选
//oLayer.SetSpatialFilterRect();
// 获取图层中的属性表表头并输出
// Console.WriteLine("属性表结构信息：");
FeatureDefn oDefn = oLayer.GetLayerDefn();
int iFieldCount = oDefn.GetFieldCount();
for (int iAttr = 0; iAttr < iFieldCount; iAttr++)
{
FieldDefn oField = oDefn.GetFieldDefn(iAttr);
Console.WriteLine("{0}:{1} ({2}.{3})", oField.GetNameRef(),
oField.GetFieldTypeName(oField.GetFieldType()),
oField.GetWidth(), oField.GetPrecision());
}
// 输出图层中的要素个数
Console.WriteLine("要素个数 = {0}", oLayer.GetFeatureCount(0));
Feature oFeature = null;
// 下面开始遍历图层中的要素
while ((oFeature = oLayer.GetNextFeature()) != null)
{
Console.WriteLine("当前处理第{0}个: \n属性值：", oFeature.GetFID());
// 获取要素中的属性表内容
for (int iField = 0; iField < iFieldCount; iField++)
{
FieldDefn oFieldDefn = oDefn.GetFieldDefn(iField);
FieldType type = oFieldDefn.GetFieldType();
switch (type)
{
case FieldType.OFTString:
Console.WriteLine("{0}\t", oFeature.GetFieldAsString(iField));
break;
case FieldType.OFTReal:
Console.WriteLine("{0}\t", oFeature.GetFieldAsDouble(iField));
break;
case FieldType.OFTInteger:
Console.WriteLine("{0}\t", oFeature.GetFieldAsInteger(iField));
break;
default:
Console.WriteLine("{0}\t", oFeature.GetFieldAsString(iField));
break;
}
}
// 获取要素中的几何体
Geometry oGeometry = oFeature.GetGeometryRef();
// String a=oGeometry.GetGeometryName();
// String b = "";
// oGeometry.ExportToWkt(out b);
Console.WriteLine(oGeometry.GetGeometryName());
// 为了演示，只输出一个要素信息
break;
}
Console.WriteLine("数据集关闭！");
Console.ReadLine();
}
private DataTable BuildSchemaTable()
{
_schemaTable = new DataTable("SchemaTable");
_schemaTable.Locale = CultureInfo.InvariantCulture;
AddDataColumn(_schemaTable, SchemaTableColumn.ColumnName, typeof(string));
AddDataColumn(_schemaTable, SchemaTableColumn.ColumnOrdinal, typeof(int));
AddDataColumn(_schemaTable, SchemaTableColumn.ColumnSize, typeof(int), -1);
AddDataColumn(_schemaTable, SchemaTableColumn.NumericPrecision, typeof(short));
AddDataColumn(_schemaTable, SchemaTableColumn.NumericScale, typeof(short));
AddDataColumn(_schemaTable, SchemaTableColumn.DataType, typeof(Type));
AddDataColumn(_schemaTable, SchemaTableColumn.ProviderType, typeof(int));
AddDataColumn(_schemaTable, SchemaTableColumn.IsLong, typeof(bool), false);
AddDataColumn(_schemaTable, SchemaTableColumn.AllowDBNull, typeof(bool), true);
AddDataColumn(_schemaTable, SchemaTableColumn.IsUnique, typeof(bool), false);
AddDataColumn(_schemaTable, SchemaTableColumn.IsKey, typeof(bool), false);
AddDataColumn(_schemaTable, SchemaTableColumn.BaseSchemaName, typeof(string));
AddDataColumn(_schemaTable, SchemaTableColumn.BaseTableName, typeof(string), String.Empty);
AddDataColumn(_schemaTable, SchemaTableColumn.BaseColumnName, typeof(string));
AddDataRow(_schemaTable, GeometryFieldName, GeometryFieldOrdinal, 1, typeof(byte[]), true, false, false);
AddDataRow(_schemaTable, FidFieldName, FidFieldOrdinal, 1, typeof(long), false, true, true);
for (int i = 0; i < _iFieldCount; i++)
{
FieldDefn f = _ogrFeatureDefinition.GetFieldDefn(i);
AddDataRow(_schemaTable, f.GetName(), i + 2, f.GetWidth(), TranslateOgrType(f.GetFieldType()), true, false, false);
}
_schemaTable.AcceptChanges();
return(_schemaTable);
}
private void WczytajOgrLayer(Layer layer)
{
List <GeometryFeature> poligony = new List <GeometryFeature>();
List <GeometryFeature> teksty = new List <GeometryFeature>();
FeatureDefn layerDef = layer.GetLayerDefn();
Feature feat = null;
while ((feat = layer.GetNextFeature()) != null)
{
Geometry featGeom = feat.GetGeometryRef();
FeatureDefn featDef = feat.GetDefnRef();
string name = null;
string value = null;
//pierwsze pole tekstowe
for (int i = 0; i < feat.GetFieldCount(); i++)
{
FieldDefn fdef = featDef.GetFieldDefn(i);
if (feat.IsFieldSet(i))
{
if (fdef.GetFieldType() == FieldType.OFTString)
{
name = fdef.GetNameRef();
value = feat.GetFieldAsString(i);
break;
}
}
}
switch (featGeom.GetGeometryType())
{
case wkbGeometryType.wkbPolygon:
case wkbGeometryType.wkbPolygon25D:
{
GeometryFeature geomFeature = new GeometryFeature {
Geometry = featGeom.Clone(), Name = name, Value = value
};
poligony.Add(geomFeature);
}
break;
case wkbGeometryType.wkbPoint:
case wkbGeometryType.wkbPoint25D:
{
GeometryFeature geomFeature = new GeometryFeature {
Geometry = featGeom.Clone(), Name = name, Value = value
};
teksty.Add(geomFeature);
}
break;
}
feat.Dispose();
}
//przypisanie tekstów do poligonów
foreach (GeometryFeature gf in poligony)
{
//przypisz pierwszy tekst zawarty w poligonie
foreach (GeometryFeature tf in teksty)
{
if (gf.Geometry.Contains(tf.Geometry))
{
gf.Name = tf.Name;
gf.Value = tf.Value;
break;
}
}
_geometryLayer.AddFeature(gf);
}
}
/// <summary>
/// Decode the fields of an S-57 record. Always returns a string type.
/// </summary>
/// <param name="feature"></param>
/// <param name="iFieldDefn"></param>
/// <param name="iField"></param>
/// <returns></returns>
public static string DecodeField(Feature feature, FieldDefn iFieldDefn, int iField)
{
string outString;
// have to interpret each data type in order to properly get the values
outString = "";
switch (iFieldDefn.GetFieldType())
{
case FieldType.OFTStringList:
string[] sList = feature.GetFieldAsStringList(iField);
foreach (string s in sList)
{
//DebugUtil.Write(" " + s + " ");
outString += s + ",";
}
break;
case FieldType.OFTIntegerList:
{
int count;
int[] iList = feature.GetFieldAsIntegerList(iField, out count);
// change to foreach
for (int i = 0; i < count; i++)
{
//DebugUtil.Write("(" + iList[i] + ") ");
outString += iList[i].ToString() + " ";
}
break;
}
case FieldType.OFTRealList:
{
int count;
double[] iList = feature.GetFieldAsDoubleList(iField, out count);
for (int i = 0; i < count; i++)
{
//DebugUtil.Write("(" + iList[i].ToString() + ") ");
outString += iList[i].ToString() + " ";
}
break;
}
case FieldType.OFTInteger:
{
//DebugUtil.Write("(" + feature.GetFieldAsInteger(iField).ToString() + ")");
outString += feature.GetFieldAsInteger(iField).ToString();
break;
}
case FieldType.OFTString:
{
//DebugUtil.Write("(" + feature.GetFieldAsString(iField) + ")");
outString += feature.GetFieldAsString(iField);
}
break;
case FieldType.OFTReal:
{
//DebugUtil.Write("(" + feature.GetFieldAsString(iField) + ")");
outString += feature.GetFieldAsString(iField);
}
break;
default:
{
//DebugUtil.Write("Unhandled Field Type: " + iFieldDefn.GetFieldType());
outString += "Unhandled Field Type: " + iFieldDefn.GetFieldType();
}
break;
} // switch
return(outString);
}
//-----------------------------------------------------------------------------------
public void readPoint(ref Layer oLayer)
{
// 对图层进行初始化，如果对图层进行了过滤操作，执行这句后，之前的过滤全部清空
oLayer.ResetReading();
Driver oDriver = null;
DataSource oDS = null;
Layer newLayer = null;
initShp(ref oLayer, ref oDriver, ref oDS, ref newLayer, LAYER_TYPE.POINT);
// 获取图层中的属性表表头并输出
string strInfo = "属性表结构信息：\n";
FeatureDefn oDefn = oLayer.GetLayerDefn();
int iFieldCount = oDefn.GetFieldCount();
for (int iAttr = 0; iAttr < iFieldCount; iAttr++)
{
FieldDefn oField = oDefn.GetFieldDefn(iAttr);
FieldType type = oField.GetFieldType();
string fieldName = oField.GetName();
//为新图层创建属性
if (!fieldName.Equals("X坐标") && !fieldName.Equals("Y坐标"))
{
FieldDefn newField = new FieldDefn(fieldName, type);
if (type == FieldType.OFTString)
{
newField.SetWidth(oField.GetWidth());
}
newLayer.CreateField(newField, 1);
}
//获取图层属性信息
strInfo += string.Format("{0}:{1} ({2}.{3})\n", oField.GetNameRef(),
oField.GetFieldTypeName(oField.GetFieldType()),
oField.GetWidth(), oField.GetPrecision());
}
FeatureDefn newDefn = newLayer.GetLayerDefn();
// 输出图层中的要素个数
strInfo += string.Format("要素个数 = {0}\n", oLayer.GetFeatureCount(0));
Feature oFeature = null;
// 下面开始遍历图层中的要素
while ((oFeature = oLayer.GetNextFeature()) != null)
{
strInfo += string.Format("\n当前处理第{0}个: \n属性值：", oFeature.GetFID());
//为新图层创建要素
Feature oFeaturePoint = new Feature(newDefn);
double pointX = 0.0;
double pointY = 0.0;
// 获取要素中的属性表内容
for (int iField = 0; iField < iFieldCount; iField++)
{
FieldDefn oFieldDefn = oDefn.GetFieldDefn(iField);
FieldType type = oFieldDefn.GetFieldType();
string name = oFieldDefn.GetNameRef();
switch (type)
{
case FieldType.OFTString:
IntPtr pchar = OGR_F_GetFieldAsString(Feature.getCPtr(oFeature), iField);
string val = Marshal.PtrToStringAnsi(pchar);
oFeaturePoint.SetField(name, val);
break;
case FieldType.OFTReal:
if (!name.Equals("X坐标") && !name.Equals("Y坐标"))
{
oFeaturePoint.SetField(name, oFeature.GetFieldAsDouble(iField));
}
switch (name)
{
case "X":
pointX = oFeature.GetFieldAsDouble(iField);
break;
case "Y":
pointY = oFeature.GetFieldAsDouble(iField);
break;
default:
break;
}
break;
case FieldType.OFTInteger:
oFeaturePoint.SetField(iField, oFeature.GetFieldAsInteger(iField));
break;
default:
oFeaturePoint.SetField(iField, oFeature.GetFieldAsString(iField));
break;
}
}
//填充要素几何信息
Geometry oGeometry = Geometry.CreateFromWkt(string.Format("POINT({0} {1})", pointX, pointY));
oFeaturePoint.SetGeometry(oGeometry);
newLayer.CreateFeature(oFeaturePoint);
}
strInfo += "\n数据集关闭！";
oDS.Dispose();
}
public void readLine(ref Layer oLayer, string pointTableName)
{
// 对图层进行初始化，如果对图层进行了过滤操作，执行这句后，之前的过滤全部清空
oLayer.ResetReading();
//打开数据
DataSource newDs = Ogr.Open(mSrcFile, 0);
if (newDs == null)
{
Console.WriteLine(string.Format("打开文件【{0}】失败！\n", mSrcFile));
return;
}
//根据图层名称获取相应的图层
Layer matchLayer = newDs.GetLayerByName(pointTableName);
Driver oDriver = null;
DataSource oDS = null;
Layer newLayer = null;
initShp(ref oLayer, ref oDriver, ref oDS, ref newLayer, LAYER_TYPE.LINE);
// 获取图层中的属性表表头并输出
string strInfo = "属性表结构信息：\n";
FeatureDefn oDefn = oLayer.GetLayerDefn();
int iFieldCount = oDefn.GetFieldCount();
for (int iAttr = 0; iAttr < iFieldCount; iAttr++)
{
FieldDefn oField = oDefn.GetFieldDefn(iAttr);
FieldType type = oField.GetFieldType();
//为新图层创建属性
FieldDefn newField = new FieldDefn(oField.GetNameRef(), type);
if (type == FieldType.OFTString)
{
newField.SetWidth(oField.GetWidth());
}
newLayer.CreateField(newField, 1);
strInfo += string.Format("{0}:{1} ({2}.{3})\n", oField.GetNameRef(),
oField.GetFieldTypeName(oField.GetFieldType()),
oField.GetWidth(), oField.GetPrecision());
}
FeatureDefn newDefn = newLayer.GetLayerDefn();
// 输出图层中的要素个数
strInfo += string.Format("要素个数 = {0}\n", oLayer.GetFeatureCount(0));
Feature oFeature = null;
// 下面开始遍历图层中的要素
double S_X = 0.0;
double S_Y = 0.0;
double E_X = 0.0;
double E_Y = 0.0;
while ((oFeature = oLayer.GetNextFeature()) != null)
{
strInfo += string.Format("\n当前处理第{0}个: \n属性值：", oFeature.GetFID());
//为新图层创建要素
Feature oFeatureLineString = new Feature(newDefn);
string sql = string.Empty;
// 获取要素中的属性表内容
for (int iField = 0; iField < iFieldCount; iField++)
{
FieldDefn oFieldDefn = oDefn.GetFieldDefn(iField);
string name = oFieldDefn.GetNameRef();
FieldType type = oFieldDefn.GetFieldType();
switch (type)
{
case FieldType.OFTString:
IntPtr pchar = OGR_F_GetFieldAsString(Feature.getCPtr(oFeature), iField);
string val = Marshal.PtrToStringAnsi(pchar);
oFeatureLineString.SetField(iField, val);
switch (name)
{
case "S_Point":
sql = oFeature.GetFieldAsString(iField);
getCoordinate(ref matchLayer, ref sql, ref S_X, ref S_Y);
break;
case "E_Point":
sql = oFeature.GetFieldAsString(iField);
getCoordinate(ref matchLayer, ref sql, ref E_X, ref E_Y);
break;
default:
break;
}
break;
case FieldType.OFTReal:
oFeatureLineString.SetField(name, oFeature.GetFieldAsDouble(iField));
break;
case FieldType.OFTInteger:
oFeatureLineString.SetField(iField, oFeature.GetFieldAsInteger(iField));
break;
default:
oFeatureLineString.SetField(iField, oFeature.GetFieldAsString(iField));
break;
}
}
Geometry oGeometry = Geometry.CreateFromWkt(string.Format("LINESTRING({0} {1},{2} {3})", S_X, S_Y, E_X, E_Y));
oFeatureLineString.SetGeometryDirectly(oGeometry);
newLayer.CreateFeature(oFeatureLineString);
oGeometry.Dispose();
}
strInfo += "\n数据集关闭！";
oDS.Dispose();
}
public static List <string> getShapeFieldDataList(string strVectorFile, string sFileName)
{
List <string> list = new List <string>();
#region ReadShape
Gdal.AllRegister();
// 为了支持中文路径，请添加下面这句代码
OSGeo.GDAL.Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO");
// 为了使属性表字段支持中文，请添加下面这句
OSGeo.GDAL.Gdal.SetConfigOption("SHAPE_ENCODING", "");
// 注册所有的驱动
Ogr.RegisterAll();
//打开数据
DataSource ds = Ogr.Open(strVectorFile, 0);
if (ds == null)
{
MessageBox.Show("打开文件【{0}】失败！", strVectorFile);
return(list);
}
//MessageBox.Show("打开文件【{0}】成功！", strVectorFile);
// 获取该数据源中的图层个数，一般shp数据图层只有一个，如果是mdb、dxf等图层就会有多个
int iLayerCount = ds.GetLayerCount();
// 获取第一个图层
Layer oLayer = ds.GetLayerByIndex(0);
if (oLayer == null)
{
MessageBox.Show("获取第{0}个图层失败！\n", "0");
return(list);
}
// 对图层进行初始化，如果对图层进行了过滤操作，执行这句后，之前的过滤全部清空
oLayer.ResetReading();
FeatureDefn oDefn = oLayer.GetLayerDefn();
// 输出图层中的要素个数
int iFieldCount = oDefn.GetFieldCount();
Feature oFeature = null;
// 下面开始遍历图层中的要素
while ((oFeature = oLayer.GetNextFeature()) != null)
{
// 获取要素中的属性表内容
for (int iField = 0; iField < iFieldCount; iField++)
{
FieldDefn oFieldDefn = oDefn.GetFieldDefn(iField);
FieldType type = oFieldDefn.GetFieldType();
string sFieldName = oFieldDefn.GetNameRef();
switch (type)
{
case FieldType.OFTString:
//MessageBox.Show(iField+"=="+oFeature.GetFieldAsString(iField));
break;
case FieldType.OFTReal:
//MessageBox.Show(iField + "==" + oFeature.GetFieldAsDouble(iField));
break;
case FieldType.OFTInteger:
//MessageBox.Show(iField + "==" + oFeature.GetFieldAsInteger(iField));
break;
default:
//MessageBox.Show(iField + "==" + oFeature.GetFieldAsString(iField));
//list.Add(oFeature.GetFieldAsString(iField));
break;
}
if (sFieldName.Equals(sFileName))
{
list.Add(oFeature.GetFieldAsString(iField));
}
}
}
#endregion
list.Sort();
return(list);
}
public override void ProcessInput(int inputID, PipelineBuffer buffer)
{
Layer OGRLayer = this.getLayer();
FeatureDefn OGRFeatureDef = OGRLayer.GetLayerDefn();
int batchCount = 0;
OGRLayer.StartTransaction();
//initialize columnInfo object
columnInfo ci = new columnInfo();
while (buffer.NextRow())
{
try
{
//Start transaction
if (this.batchSize != 0 && batchCount % this.batchSize == 0)
{
OGRLayer.CommitTransaction();
OGRLayer.StartTransaction();
batchCount = 0;
}
Feature OGRFeature = new Feature(OGRFeatureDef);
for (int i = 0; i < this.columnInformation.Count; i++)
{
ci = this.columnInformation[i];
if (!buffer.IsNull(ci.bufferColumnIndex))
{
if (ci.geom)
{
byte[] geomBytes = new byte[buffer.GetBlobLength(ci.bufferColumnIndex)];
geomBytes = buffer.GetBlobData(ci.bufferColumnIndex, 0, geomBytes.Length);
Geometry geom = Geometry.CreateFromWkb(geomBytes);
OGRFeature.SetGeometry(geom);
}
else
{
int OGRFieldIndex = OGRFeatureDef.GetFieldIndex(ci.columnName);
FieldDefn OGRFieldDef = OGRFeatureDef.GetFieldDefn(OGRFieldIndex);
FieldType OGRFieldType = OGRFieldDef.GetFieldType();
//declare datetime variables
DateTime dt;
TimeSpan ts;
switch (OGRFieldType)
{
//case FieldType.OFTBinary:
// break;
case FieldType.OFTDate:
dt = buffer.GetDate(ci.bufferColumnIndex);
OGRFeature.SetField(OGRFieldIndex, dt.Year, dt.Month, dt.Day, 0, 0, 0, 0);
break;
case FieldType.OFTDateTime:
dt = buffer.GetDateTime(ci.bufferColumnIndex);
//get timezone?
OGRFeature.SetField(OGRFieldIndex, dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0);
break;
case FieldType.OFTInteger:
OGRFeature.SetField(OGRFieldIndex, buffer.GetInt32(ci.bufferColumnIndex));
break;
case FieldType.OFTInteger64:
OGRFeature.SetField(OGRFieldIndex, buffer.GetInt64(ci.bufferColumnIndex));
break;
case FieldType.OFTReal:
OGRFeature.SetField(OGRFieldIndex, buffer.GetDouble(ci.bufferColumnIndex));
break;
case FieldType.OFTTime:
ts = buffer.GetTime(ci.bufferColumnIndex);
OGRFeature.SetField(OGRFieldIndex, 0, 0, 0, ts.Hours, ts.Minutes, ts.Seconds, 0);
break;
case FieldType.OFTString:
default:
OGRFeature.SetField(OGRFieldIndex, buffer.GetString(ci.bufferColumnIndex));
break;
}
}
}
}
OGRLayer.CreateFeature(OGRFeature);
batchCount++;
//increment incrementPipelinePerfCounters to display correct # of rows written
ComponentMetaData.IncrementPipelinePerfCounter(103, 1);
}
catch (Exception ex)
{
//Redirect row
IDTSInputColumn100 inputColumn = ComponentMetaData.InputCollection[0].InputColumnCollection.GetInputColumnByLineageID(ci.lineageID);
IDTSOutput100 output = ComponentMetaData.OutputCollection[0];
if (ci.errorDisposition == DTSRowDisposition.RD_RedirectRow)
{
int errorCode = System.Runtime.InteropServices.Marshal.GetHRForException(ex);
buffer.DirectErrorRow(output.ID, errorCode, inputColumn.LineageID);
}
else if (ci.errorDisposition == DTSRowDisposition.RD_FailComponent || ci.errorDisposition == DTSRowDisposition.RD_NotUsed)
{
OGRLayer.RollbackTransaction();
ComponentMetaData.FireError(0, ComponentMetaData.Name, ex.Message, string.Empty, 0, out cancel);
throw new Exception(ex.Message);
}
}
}
OGRLayer.CommitTransaction();
}
public override void ReinitializeMetaData()
{
base.ReinitializeMetaData();
IDTSInput100 input = ComponentMetaData.InputCollection[0];
if (!this.validExternalMetadata && this.isConnected)
{
input.ExternalMetadataColumnCollection.RemoveAll();
input.InputColumnCollection.RemoveAll();
this.validExternalMetadata = true;
Layer OGRLayer = this.getLayer();
FeatureDefn OGRFeatureDef = OGRLayer.GetLayerDefn();
int i = 0;
while (i < OGRFeatureDef.GetFieldCount())
{
//map OGR field type to SSIS data type
FieldDefn OGRFieldDef = OGRFeatureDef.GetFieldDefn(i);
DataType BufferDataType = this.OGRTypeToBufferType(OGRFieldDef.GetFieldType());
int length = 0;
int precision = OGRFieldDef.GetWidth();
int scale = OGRFieldDef.GetPrecision();
int codepage = 1252;
switch (BufferDataType)
{
case DataType.DT_WSTR:
length = precision;
codepage = 0;
precision = 0;
scale = 0;
//check for length == 0
if (length == 0)
{
BufferDataType = DataType.DT_NTEXT;
}
break;
default:
length = 0;
precision = 0;
codepage = 0;
scale = 0;
break;
}
IDTSExternalMetadataColumn100 ecol = input.ExternalMetadataColumnCollection.New();
ecol.Name = OGRFieldDef.GetName();
ecol.DataType = BufferDataType;
ecol.Length = length;
ecol.Precision = precision;
ecol.Scale = scale;
ecol.CodePage = codepage;
i++;
}
//get geometry column
string geomtryColumn = (OGRLayer.GetGeometryColumn() != "") ? OGRLayer.GetGeometryColumn() : "GEOMETRY";
//Set OGRGeometry external metadata column
IDTSExternalMetadataColumn100 egeomCol = input.ExternalMetadataColumnCollection.New();
egeomCol.Name = geomtryColumn;
egeomCol.DataType = DataType.DT_IMAGE;
egeomCol.Precision = 0;
egeomCol.Length = 0;
egeomCol.Scale = 0;
egeomCol.CodePage = 0;
//set geometry column custom property
ComponentMetaData.CustomPropertyCollection["Geometry Column"].Value = geomtryColumn;
}
if (!ComponentMetaData.AreInputColumnsValid)
{
ComponentMetaData.RemoveInvalidInputColumns();
}
}
public VectorField(FieldDefn fieldDef, int idx)
{
FieldID = idx;
_fieldDef = fieldDef;
Type = new GDalFieldType(_fieldDef.GetFieldType());
}
private void button3_Click(object sender, EventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Title = "打开ShapeFile数据";
dlg.Filter = "ShapeFile数据(*.shp)|*.shp";
if (dlg.ShowDialog() == DialogResult.OK)
{
Ogr.RegisterAll();
string strVectorFile = dlg.FileName;
textBox1.Text = strVectorFile;
//打开数据
DataSource ds = Ogr.Open(strVectorFile, 0);
if (ds == null)
{
listBox1.Items.Add(string.Format("打开文件【{0}】失败！", strVectorFile));
return;
}
listBox1.Items.Add(string.Format("打开文件【{0}】成功！", strVectorFile));
// 获取该数据源中的图层个数，一般shp数据图层只有一个，如果是mdb、dxf等图层就会有多个
int iLayerCount = ds.GetLayerCount();
// 获取第一个图层
Layer oLayer = ds.GetLayerByIndex(0);
if (oLayer == null)
{
listBox1.Items.Add(string.Format("获取第{0}个图层失败！\n", 0));
return;
}
// 对图层进行初始化，如果对图层进行了过滤操作，执行这句后，之前的过滤全部清空
oLayer.ResetReading();
// 通过属性表的SQL语句对图层中的要素进行筛选，这部分详细参考SQL查询章节内容
//oLayer.SetAttributeFilter("\"NAME99\"LIKE \"北京市市辖区\"");
// 通过指定的几何对象对图层中的要素进行筛选
//oLayer.SetSpatialFilter();
// 通过指定的四至范围对图层中的要素进行筛选
//oLayer.SetSpatialFilterRect();
// 获取图层中的属性表表头并输出
listBox1.Items.Add("属性表结构信息：");
FeatureDefn oDefn = oLayer.GetLayerDefn();
int iFieldCount = oDefn.GetFieldCount();
for (int iAttr = 0; iAttr < iFieldCount; iAttr++)
{
FieldDefn oField = oDefn.GetFieldDefn(iAttr);
listBox1.Items.Add(string.Format("{0}:{1} ({2}.{3})", oField.GetNameRef(),
oField.GetFieldTypeName(oField.GetFieldType()),
oField.GetWidth(), oField.GetPrecision()));
}
// 输出图层中的要素个数
listBox1.Items.Add(string.Format("要素个数 = {0}", oLayer.GetFeatureCount(0)));
Feature oFeature = null;
// 下面开始遍历图层中的要素
while ((oFeature = oLayer.GetNextFeature()) != null)
{
Geometry geo = oFeature.GetGeometryRef();
wkbGeometryType wkb = geo.GetGeometryType();
listBox1.Items.Add(string.Format("当前处理第要素值：{0}", wkb.ToString()));
string strGml = geo.ExportToGML();
listBox1.Items.Add(strGml);
listBox1.Items.Add(string.Format("当前处理第{0}个: \n属性值：", oFeature.GetFID()));
// 获取要素中的属性表内容
for (int iField = 0; iField < iFieldCount; iField++)
{
FieldDefn oFieldDefn = oDefn.GetFieldDefn(iField);
FieldType type = oFieldDefn.GetFieldType();
switch (type)
{
case FieldType.OFTString:
listBox1.Items.Add(string.Format("{0}\t", oFeature.GetFieldAsString(iField)));
break;
case FieldType.OFTReal:
listBox1.Items.Add(string.Format("{0}\t", oFeature.GetFieldAsDouble(iField)));
break;
case FieldType.OFTInteger:
listBox1.Items.Add(string.Format("{0}\t", oFeature.GetFieldAsInteger(iField)));
break;
default:
listBox1.Items.Add(string.Format("{0}\t", oFeature.GetFieldAsString(iField)));
break;
}
}
// 获取要素中的几何体
Geometry oGeometry = oFeature.GetGeometryRef();
// 为了演示，只输出一个要素信息
break;
}
listBox1.Items.Add("数据集关闭！");
}
}