private void comboBox2_SelectedIndexChanged(object sender, EventArgs e)
{
comboBox3.Items.Clear();
comboBox3.Items.Add("-Select-");
IEnumLayer pEnumLayer = pMap.Layers;
ILayer pLayer;
for (int i = 0; i < pMap.LayerCount; i++)
{
pLayer = pEnumLayer.Next();
if (pLayer.Name.Equals(comboBox2.Text))
{
IFeatureLayer2 pFeatureLayer2 = (IFeatureLayer2)pLayer;
IFeatureClass pFeatureClass = pFeatureLayer2.FeatureClass;
IFields pFields = pFeatureClass.Fields;
for (int j = 0; j < pFields.FieldCount; j++)
{
IField pField = pFields.get_Field(j);
comboBox3.Items.Add(pField.Name);
}
}
}
comboBox3.SelectedIndex = 0;
}
/// <summary>
/// If the optional <see cref="MCDA.Model.ClassBreaksRendererContainer" /> is set and includes all properties the
/// method
/// creates a new class breaks renderer and performs a partial refresh.
/// </summary>
/// <param name="renderContainer"></param>
/// <param name="featureLayer"></param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public void Render(RendererContainer renderContainer, IFeatureLayer2 featureLayer)
{
var geoFeatureLayer = featureLayer as IGeoFeatureLayer;
switch (renderContainer.Renderer)
{
case Renderer.ClassBreaksRenderer:
geoFeatureLayer.Renderer = RendererFactory.NewClassBreaksRenderer(renderContainer);
break;
case Renderer.BiPolarRenderer:
geoFeatureLayer.Renderer = RendererFactory.NewUniqueValueRenderer(renderContainer);
break;
case Renderer.None:
geoFeatureLayer.Renderer = RendererFactory.NewSimpleRenderer();
break;
}
switch (ConfigSingleton.Instance.SelectedRenderoption)
{
case RenderOption.AfterSliderDrag:
PartialRefresh(renderContainer, featureLayer);
break;
case RenderOption.AnimationLike:
case RenderOption.Realtime:
default:
PartialRefresh(renderContainer, featureLayer, false);
break;
}
}
/// <summary>
/// Performs a partial refresh on the feature feature in the in memory workspace.
/// </summary>
/// <param name="renderContainer"></param>
/// <param name="featureLayer"></param>
/// <param name="updateTOC"></param>
private static void PartialRefresh(RendererContainer renderContainer, IFeatureLayer2 featureLayer, bool updateTOC = true)
{
var activeView = (IActiveView)ArcMap.Document.FocusMap;
if (updateTOC)
{
activeView.ContentsChanged();
ArcMap.Document.UpdateContents();
}
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeography, featureLayer, null);
}
public void Refresh()
{
TableList.Clear();
RelationLookup.Clear();
IMap aMap = ArcMap.Document.FocusMap as IMap;
IMapLayers2 layers = ArcMap.Document.FocusMap as IMapLayers2;
IEnumLayer someLayers = layers.Layers;
ILayer aLayer = null;
while ((aLayer = someLayers.Next()) != null)
{
IFeatureLayer2 someFeatlayer = aLayer as IFeatureLayer2;
if (someFeatlayer != null)
{
IFeatureClass featClass = someFeatlayer.FeatureClass as IFeatureClass;
if (featClass != null)
{
IEnumRelationshipClass someRelationships = featClass.RelationshipClasses[esriRelRole.esriRelRoleAny] as IEnumRelationshipClass;
if (someRelationships != null)
{
IRelationshipClass aRelationship = someRelationships.Next();
while (aRelationship != null)
{
Debug.WriteLine(aRelationship.OriginClass.AliasName + " <--> " + aRelationship.DestinationClass.AliasName);
IDataset aDataset = aRelationship.OriginClass as IDataset;
IDataset anotherDataset = aRelationship.DestinationClass as IDataset;
AddDataset(new IDataset[] { aDataset, anotherDataset });
IDataset aDS = featClass as IDataset;
if (aDS != null)
{
Debug.WriteLine(aDS.Name + "," + aDataset.Name + "," + anotherDataset.Name);
string name = aDS.Name.Equals(aDataset.Name, StringComparison.InvariantCultureIgnoreCase) ? anotherDataset.Name : aDataset.Name;
if (RelationLookup.ContainsKey(name))
{
RelationLookup[name].Add(aRelationship);
}
else
{
RelationLookup.Add(name, new List <IRelationshipClass>()
{
aRelationship
});
}
}
aRelationship = someRelationships.Next();
}
}
}
}
}
TableList.Sort((a, b) => a.TableName.CompareTo(b.TableName));
}
/// <summary>
///
/// </summary>
/// <remarks>
/// The <see cref="IFeatureLayer.FeatureClass"/> attribute is set to the given <see cref="IFeatureLayer2"/>.
/// </remarks>
/// <param name="featureClass"></param>
/// <param name="featureLayer"></param>
public Feature(IFeatureClass featureClass, IFeatureLayer2 featureLayer)
{
featureLayer.FeatureClass = featureClass;
this._featureClass = featureClass;
this._featureLayer = featureLayer;
_isFeatureLayer = true;
this._esriLayer = featureLayer as ILayer2;
_featureName = this._esriLayer.Name;
_fields = new ObservableCollection <Field>(GetFields().OrderByDescending(f => f.IsSuitableForMCDA).ThenBy(l => l.FieldName));
}
/// <summary>
/// Creates a Temporal Layer using the specified feature class and add it to the map.
/// </summary>
/// <param name="featureClass">The feature class to use for the temporal layer.</param>
/// <param name="eventFieldName">Indicates the feature class column that identifies or groups temporal observations with time series.</param>
/// <param name="temporalFieldName">Identifies the temporal field, which must be a field type whose data can be converted to a date value.</param>
private void AddTemporalLayer(IFeatureClass featureClass, string eventFieldName, string temporalFieldName)
{
ITemporalLayer temporalFeatureLayer = new TemporalFeatureLayerClass();
IFeatureLayer2 featureLayer = temporalFeatureLayer as IFeatureLayer2;
ILayer layer = temporalFeatureLayer as ILayer;
ITemporalRenderer temporalRenderer = new CoTrackSymbologyRendererClass();
ITemporalRenderer2 temporalRenderer2 = (ITemporalRenderer2)temporalRenderer;
IFeatureRenderer featureRenderer = temporalRenderer as IFeatureRenderer;
ITrackSymbologyRenderer trackRenderer = temporalRenderer as ITrackSymbologyRenderer;
if (featureLayer != null)
{
featureLayer.FeatureClass = featureClass;
}
if (featureRenderer != null)
{
temporalRenderer.TemporalObjectColumnName = eventFieldName;
temporalRenderer.TemporalFieldName = temporalFieldName;
temporalFeatureLayer.Renderer = featureRenderer;
}
if (trackRenderer != null)
{
//Create green color value
IRgbColor rgbColor = new RgbColorClass();
rgbColor.RGB = 0x00FF00;
//Create simple thin green line
ISimpleLineSymbol simpleLineSymbol = new SimpleLineSymbolClass();
simpleLineSymbol.Color = (IColor)rgbColor;
simpleLineSymbol.Width = 1.0;
//Create simple renderer using line symbol
ISimpleRenderer simpleRenderer = new SimpleRendererClass();
simpleRenderer.Symbol = (ISymbol)simpleLineSymbol;
//Apply line renderer as track symbol and enable track rendering
trackRenderer.TrackSymbologyRenderer = (IFeatureRenderer)simpleRenderer;
trackRenderer.ShowTrackSymbologyLegendGroup = true;
temporalRenderer2.TrackRendererEnabled = true;
}
if (layer != null)
{
ArcMap.Document.FocusMap.AddLayer(layer);
}
}
/// <summary> The polygon feature layers in current map </summary>
/// <returns> Function to retrieve a list of polygon feature layers in current map </returns>
public ArrayList PolygonLayers()
{
ArrayList pList = new ArrayList();
if (FocusMap == null)
{
return(pList);
}
if (FocusMap.LayerCount == 0)
{
return(pList);
}
try
{
UID pID = new UIDClass();
pID.Value = "{E156D7E5-22AF-11D3-9F99-00C04F6BC78E}"; //GeoFeatureLayer
IEnumLayer pEnumLayer = FocusMap.get_Layers(pID, true);
pEnumLayer.Reset();
ILayer pLayer = pEnumLayer.Next();
while (!(pLayer == null))
{
IFeatureLayer2 pFLayer = (IFeatureLayer2)pLayer;
if (pFLayer.ShapeType == esriGeometryType.esriGeometryPolygon)
{
if (pFLayer.FeatureClass != null)
{
pList.Add(pLayer.Name);
}
}
pLayer = pEnumLayer.Next();
}
return(pList);
}
catch (Exception ex)
{
if (SupressMessaging == false)
{
MessageBox.Show(ex.Message, "Polygon Layers", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
return(pList);
}
public Feature(ESRI.ArcGIS.Carto.ILayer2 layer)
{
this._esriLayer = layer;
_featureName = layer.Name;
var featureLayer = layer as ESRI.ArcGIS.Carto.IFeatureLayer2;
if (featureLayer == null)
{
_isFeatureLayer = false;
_fields = new ObservableCollection <Field>();
}
else
{
_isFeatureLayer = true;
this._featureLayer = featureLayer;
_fields = new ObservableCollection <Field>(GetFields().OrderByDescending(f => f.IsSuitableForMCDA).ThenBy(l => l.FieldName));
}
}
public ILayer GetLayerFromFeature(IFeature feat)
{
IFeatureClass fc = feat.Class as IFeatureClass;
IMap aMap = ArcMap.Document.FocusMap as IMap;
IMapLayers2 layers = ArcMap.Document.FocusMap as IMapLayers2;
IEnumLayer someLayers = layers.Layers;
ILayer aLayer = null;
while ((aLayer = someLayers.Next()) != null)
{
IFeatureLayer2 someFeatlayer = aLayer as IFeatureLayer2;
if (someFeatlayer != null)
{
IDataset newDS = someFeatlayer.FeatureClass as IDataset;
IDataset ds = feat.Class as IDataset;
Debug.WriteLine($"{newDS.Name},{ds.Name}");
if (newDS.Name.Equals(ds.Name, StringComparison.InvariantCultureIgnoreCase))
{
return(aLayer);
}
}
}
return(null);
}
public static void MakeDistanceArray(IFeature InputFeature, int GruopID)
{
List <DistanceFeatureClass> DistFeatureList = new List <DistanceFeatureClass>();
IEnumLayer pEnumLayer = Form1.pMap.Layers;
ILayer pLayer;
for (int i = 0; i < Form1.pMap.LayerCount; i++)
{
pLayer = pEnumLayer.Next();
if (pLayer.Name.Equals(Form1.OperationLayer))
{
IFeatureLayer2 pFeatureLayer = (IFeatureLayer2)pLayer;
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IQueryFilter pQueryFilter = new QueryFilter();
pQueryFilter.WhereClause = "SpltGropus = 0";
IFeatureCursor pFeatureCursor = pFeatureClass.Search(pQueryFilter, false);
IFeature CheckFeature = pFeatureCursor.NextFeature();
while (CheckFeature != null)
{
IProximityOperator pProxOper = (IProximityOperator)CheckFeature.Shape;
double distance = pProxOper.ReturnDistance(InputFeature.Shape);
CheckFeature.set_Value(CheckFeature.Fields.FindField("Distance"), distance);
CheckFeature.Store();
DistanceFeatureClass DistFeature = new DistanceFeatureClass(distance, CheckFeature);
DistFeatureList.Add(DistFeature);
CheckFeature = pFeatureCursor.NextFeature();
}
DistFeatureList = DistFeatureList.OrderBy(a => a.getDistance()).ToList();
double formarValue = 0;
double addValue = 0;
for (int j = 0; j < DistFeatureList.Count; j++)
{
//MessageBox.Show("..." + Form1.Group.getCalculatedSplitValue() + "..." + Form1.EqualPartValue, "hi");
if (Form1.GroupIDTotalList[GruopID - 1].getCalculatedSplitValue() < Form1.EqualPartValue)
{
formarValue = Form1.GroupIDTotalList[GruopID - 1].getCalculatedSplitValue();
addValue = Convert.ToDouble(DistFeatureList[j].getFeature().get_Value(DistFeatureList[j].getFeature().Fields.FindField(Form1.OperationAttribute)));
DistFeatureList[j].getFeature().set_Value(DistFeatureList[j].getFeature().Fields.FindField("SpltGropus"), GruopID);
DistFeatureList[j].getFeature().Store();
Form1.GroupIDTotalList[GruopID - 1].setCalculatedSplitValue(formarValue + addValue);
}
//Form1.Group.setCalculatedSplitValue(DistFeatureList[j].getFeature().get_Value(DistFeatureList[j].getFeature().Fields.FindField("SpltGropus")));
//DistFeatureList[j].set_Value(FeatureList[j].Fields.FindField("SpltGropus"), 10);
//FeatureList[j].Store();
//MessageBox.Show("..." + DistFeatureList[j].getDistance(), "hi");
}
Form1.RegionFormed = Form1.RegionFormed + 1;
//MessageBox.Show("..." + ((Form1.NoOfSplit - 1) == Form1.RegionFormed), "hi");
if ((Form1.NoOfSplit - 1) == Form1.RegionFormed)
{
IGeoFeatureLayer pGeoFetLayer = (IGeoFeatureLayer)pLayer;
Symbology.DefineUniqueValueRenderer(pGeoFetLayer, "SpltGropus");
}
//Creating convexhull of the generated region ??? if does not work you have to make the concave hull??
IQueryFilter RegionQueryFilter = new QueryFilter();
RegionQueryFilter.WhereClause = "SpltGropus = " + GruopID;
IFeatureCursor RegionFeatureCursor = pFeatureClass.Search(RegionQueryFilter, false);
Form1.RegionGeomtry = StaticMethodsClass.CreateConvexHull(RegionFeatureCursor);
//IFeature dd = pFeatureClass.CreateFeature();
//dd.Shape = pPol;
//dd.set_Value(dd.Fields.FindField("SpltGropus"), GruopID);
//dd.Store();
//IActiveView activeView = Form1.pMap as IActiveView;
//activeView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, null);
//MessageBox.Show("...", "hi");
//
//MessageBox.Show("..." , "hi");
}
}
}
public void UpdateFeature(IMap pMap, ILayer pCurrentLayer, IPoint pPoint)
{
//处理具体数据
if (pMap == null || pPoint == null)
{
return;
}
m_pMap = pMap;
//如果没有地图图层 ，则不处理
long nLayerCount = pMap.LayerCount;
if (nLayerCount == 0)
{
return;
}
//删除树结点
FtTreeView.Nodes.Clear();
this.FTtreeList.Nodes.Clear();
//开始选择
IGeometry geom = pPoint;
ISpatialReference spatialReference = m_pMap.SpatialReference;
geom.SpatialReference = spatialReference;
//Refresh the active view
IActiveView activeView = (IActiveView)m_pMap;
ISelectionEnvironment selEnv = new SelectionEnvironment();
selEnv.PointSelectionMethod = esriSpatialRelEnum.esriSpatialRelWithin;
m_pMap.SelectByShape(geom, selEnv, false);
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, activeView.Extent);
//如果没有设置 当前图层pCurrentLayer ，则不处理
ESRI.ArcGIS.esriSystem.IPersist pPersist = new FeatureLayer() as ESRI.ArcGIS.esriSystem.IPersist;
UID uid = pPersist as UID;
IEnumLayer pEnumlayer = pMap.get_Layers(uid, true);
pEnumlayer.Reset();
ILayer pLayer = pEnumlayer.Next();
while (pLayer != null)
{
if (pLayer.Visible == false)
{
pLayer = pEnumlayer.Next();
continue;
}
IFeatureLayer2 pFtLayer = (IFeatureLayer2)pLayer;
IFeatureSelection pFtSelect = (IFeatureSelection)pFtLayer;
ISelectionSet pSelectset = (ISelectionSet)pFtSelect.SelectionSet;
InitTreeView(pSelectset, pLayer);
pLayer = pEnumlayer.Next();
}
}
/// <summary>
/// 更新显示属性信息
/// </summary>
/// <param name="pMap"></param>
/// <param name="pGeo"></param>
public void UpdateFeature(IMap pMap, IGeometry pGeo)
{
//处理具体数据
if (pMap == null || pGeo == null)
{
return;
}
m_pMap = pMap;
//删除树结点
FTAttrTreeList.Nodes.Clear();
FTtreeList.Nodes.Clear();
//如果没有设置 当前图层pCurrentLayer ，则不处理
ESRI.ArcGIS.esriSystem.IPersist pPersist = new FeatureLayer() as ESRI.ArcGIS.esriSystem.IPersist;
UID uid = pPersist as UID;
IEnumLayer pEnumlayer = pMap.get_Layers(uid, true);
pEnumlayer.Reset();
ILayer pLayer = pEnumlayer.Next();
while (pLayer != null)
{
if (pLayer.Visible == false)
{
pLayer = pEnumlayer.Next();
continue;
}
try
{
if (pLayer.SupportedDrawPhases == 5) //如果图层为拓扑图层
{
pLayer = pEnumlayer.Next();
continue;
}
}
catch (Exception ex)
{
//GT_CONST.LogAPI.CheckLog.AppendErrLogs(ex.ToString());
pLayer = pEnumlayer.Next();
continue;
}
if (pLayer is ICompositeLayer)
{
pLayer = pEnumlayer.Next();
continue;
}
IFeatureLayer2 pFtLayer2 = (IFeatureLayer2)pLayer;
IFeatureSelection pFtSelect = (IFeatureSelection)pFtLayer2;
ISelectionSet pSelectset = (ISelectionSet)pFtSelect.SelectionSet;
InitTreeView(pSelectset, pLayer);
pLayer = pEnumlayer.Next();
}
FTtreeList.ExpandAll();
#region 在右侧面板显示第一个结点的详细信息
TreeListNode treelistNode = FTtreeList.Nodes.FirstNode;
if (treelistNode == null)
{
return;
}
TreeListNode nodeChild = treelistNode.FirstNode;
if (nodeChild.ParentNode == null)
{
return;
}
TreeListNode parentNode = nodeChild.ParentNode;
try
{
object st = treelistNode[0];
string strLayerName1 = nodeChild.ParentNode.GetDisplayText("FtName").ToString();
}
catch (Exception ex)
{
//GT_CONST.LogAPI.CheckLog.AppendErrLogs(ex.ToString());
string s = ex.Message;
}
string strLayerName = nodeChild.ParentNode.GetDisplayText("FtName").ToString();
ILayer pLayer1 = Hy.Common.Utility.Esri.MapOperAPI.GetLayerFromMapByName(m_pMap, strLayerName);
if (pLayer1 == null)
{
return;
}
IFeatureLayer pFtLayer = (IFeatureLayer)pLayer1;
IFeatureClass pFtCls = pFtLayer.FeatureClass;
//IQueryFilter pFilter = new QueryFilterClass();
IFields pFields = pFtCls.Fields;
int nIndex = pFields.FindField("BSM");
if (nIndex == -1)
{
return;
}
IQueryFilter pQueryFilter = new QueryFilterClass();
IField pField = pFields.get_Field(nIndex);
bool bTest = GetTypeByEsriField(pField.Type);
if (bTest == false) //整形
{
pQueryFilter.WhereClause = "BSM = " + nodeChild.GetDisplayText("FtName").ToString();
//pQueryFilter.WhereClause = "BSM = " + treenodeChild.Text;
}
else
{
pQueryFilter.WhereClause = "BSM = " + nodeChild.GetDisplayText("FtName").ToString();
//pQueryFilter.WhereClause = "BSM = '" + treenodeChild.Text + "'";
}
//string strOIDField = pFtCls.OIDFieldName;
//pFilter.WhereClause = "BSM =" + treenodeChild.Text;
IFeatureCursor pFtCursor = pFtCls.Search(pQueryFilter, true);
IFeature pFt = pFtCursor.NextFeature();
while (pFt != null)
{
int nOID = pFt.OID;
IGeometry geom = pFt.Shape;
InitAttrTreeList(pFtCls, pFt);
//InitAttrListView(pFtCls, pFt);
//ArcGISAPI.ZoomToFeature(m_pActiveView, pFtLayer, nOID);
//m_pMap.SelectByShape(geom, null, false);
pFt = pFtCursor.NextFeature();
}
//m_pActiveView.Refresh();
#endregion
}
/// <summary>
/// Occurs when this command is clicked
/// </summary>
public override void OnClick()
{
// TODO: Add ClsAsortVertex.OnClick implementation
IToolbarControl2 pToolbarControl;
if (m_hookHelper.Hook is IToolbarControl)
{
pToolbarControl = (m_hookHelper.Hook) as IToolbarControl2;
m_MapControl = (pToolbarControl.Buddy) as IMapControl4;
}
else if (m_hookHelper.Hook is IMapControl4)
{
m_MapControl = (IMapControl4)(m_hookHelper.Hook);
}
IMap pMap = m_MapControl.ActiveView.FocusMap as IMap;
ILayer2 pLayer = null;
//m_MapControl.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint();
for (int i = 0; i < pMap.LayerCount; i++)
{
pLayer = pMap.get_Layer(i) as ILayer2;
if (pLayer is IFeatureLayer2)
{
IFeatureLayer2 pFeatLyr = pLayer as IFeatureLayer2;
IFeatureSelection pFeatSel = pFeatLyr as IFeatureSelection;
ISelectionSet2 pSelSet = pFeatSel.SelectionSet as ISelectionSet2;
if (pSelSet.Count <= 0)
{
return;
}
else
{
ICursor pCursor = null;
pSelSet.Search(null, false, out pCursor);
IFeatureCursor pFeatCursor = pCursor as IFeatureCursor;
IFeature pFeat = pFeatCursor.NextFeature();
while (pFeat != null)
{
IGeometry5 pGeometry = pFeat.Shape as IGeometry5;
IPointCollection pPointCol = new Multipoint();
pPointCol = pGeometry as IPointCollection;
double[] arrayX = new double[200];
double[] arrayY = new double[200];
IPointArray pPtArray = new PointArrayClass();
pPtArray = AsortVertex(pPointCol, arrayX, arrayY);
for (int k = 0; k < pPointCol.PointCount; k++)
{
IPoint pPoint = new PointClass();
pPoint = pPointCol.get_Point(k);
MessageBox.Show(pPointCol.get_Point(k).ID.ToString());
for (int l = 0; l < pPtArray.Count; l++)
{
if (pPoint.X == pPtArray.get_Element(l).X)
{
int ID = pPtArray.get_Element(l).ID;
pPointCol.get_Point(k).ID = ID;
MessageBox.Show(pPointCol.get_Point(k).ID.ToString());
break;
}
}
}
pFeat = pFeatCursor.NextFeature();
}
}
}
}
m_MapControl.ActiveView.Refresh();
}
private void button2_Click(object sender, EventArgs e)
{
if (pMap.SelectionCount > 1)
{
MessageBox.Show("Please select only one feature (starting point)", "Selection error...");
return;
}
OperationLayer = comboBox2.Text;
OperationAttribute = comboBox3.Text;
Tolerance = Convert.ToDouble(textBox2.Text);
NoOfSplit = Convert.ToInt16(textBox1.Text);
IEnumLayer pEnumLayer = pMap.Layers;
ILayer pLayer;
for (int i = 0; i < pMap.LayerCount; i++)
{
pLayer = pEnumLayer.Next();
if (pLayer.Name.Equals(OperationLayer))
{
IDataset pDataSet = (IDataset)(pLayer);
Geoprocessor GP = new Geoprocessor();
GP.OverwriteOutput = true;
AddField SplitGroup = new AddField();
SplitGroup.in_table = pDataSet.Workspace.PathName + System.IO.Path.DirectorySeparatorChar + pDataSet.Name + ".shp";
//........
workSpacePath = pDataSet.Workspace.PathName;
//........
SplitGroup.field_name = "SpltGropus";
SplitGroup.field_type = "SHORT";
GP.Execute(SplitGroup, null);
CalculateField CalculateField = new CalculateField();
CalculateField.in_table = pDataSet.Workspace.PathName + System.IO.Path.DirectorySeparatorChar + pDataSet.Name + ".shp";
CalculateField.field = "SpltGropus";
CalculateField.expression = "0";
GP.Execute(CalculateField, null);
AddField TempGroup = new AddField();
TempGroup.in_table = pDataSet.Workspace.PathName + System.IO.Path.DirectorySeparatorChar + pDataSet.Name + ".shp";
TempGroup.field_name = "Distance";
TempGroup.field_type = "DOUBLE";
GP.Execute(TempGroup, null);
AggregatePolygons ConcaveHull = new AggregatePolygons();
ConcaveHull.aggregation_distance = Tolerance;
ConcaveHull.in_features = pDataSet.Workspace.PathName + System.IO.Path.DirectorySeparatorChar + pDataSet.Name + ".shp";
ConcaveHull.out_feature_class = System.IO.Path.GetTempPath() + System.IO.Path.DirectorySeparatorChar + "Temp_ConcaveHull.shp";
GP.AddOutputsToMap = false;
GP.Execute(ConcaveHull, null);
//IFeatureLayer2 pFeatureLayer21 = (IFeatureLayer2)pLayer;
//IFeatureClass pFeatureClass1 = pFeatureLayer21.FeatureClass;
//IField spltgrp = new FieldClass();
//IFieldEdit spltgrp1 = (IFieldEdit)spltgrp;
//spltgrp1.Name_2 = "SpltGropus";
//spltgrp1.Type_2 = esriFieldType.esriFieldTypeSmallInteger;
//spltgrp = spltgrp1;
//IField tmpgrp = new FieldClass();
//IFieldEdit tmpgrp1 = (IFieldEdit)tmpgrp;
//tmpgrp1.Name_2 = "TempGroups";
//tmpgrp1.Type_2 = esriFieldType.esriFieldTypeSmallInteger;
//tmpgrp = tmpgrp1;
//pFeatureClass1.AddField(spltgrp);
//pFeatureClass1.AddField(tmpgrp);
IFeatureLayer pFeatureLayer = (IFeatureLayer)pLayer;
IFeatureSelection pFeatureSelection = (IFeatureSelection)pFeatureLayer;
ISelectionSet pSelectionSet = pFeatureSelection.SelectionSet;
ICursor pCursor;
pSelectionSet.Search(null, false, out pCursor);
IFeatureCursor pFeatureCursor = (IFeatureCursor)pCursor;
IFeature pFeature = pFeatureCursor.NextFeature();
GroupIDTotal Group = new GroupIDTotal();
Group.setID(1);
Group.setCalculatedSplitValue(Convert.ToDouble(pFeature.get_Value(pFeature.Fields.FindField(OperationAttribute))));
pFeature.set_Value(pFeature.Fields.FindField("SpltGropus"), 1);
pFeature.Store();
GroupIDTotalList.Add(Group);
//Group = new GroupIDTotal (1,(double)pFeature.get_Value(pFeature.Fields.FindField(OperationAttribute)));
IFeatureLayer2 pFeatureLayer2 = (IFeatureLayer2)pLayer;
IFeatureClass pFeatureClass = pFeatureLayer2.FeatureClass;
IQueryFilter pQueryFilter = new QueryFilter();
pQueryFilter.WhereClause = null;
IFeatureCursor pFeatureCursor1 = pFeatureClass.Search(pQueryFilter, false);
IFeature pFeature1;
for (int j = 0; j < pFeatureClass.FeatureCount(pQueryFilter); j++)
{
pFeature1 = pFeatureCursor1.NextFeature();
FieldTotal = FieldTotal + Convert.ToDouble(pFeature1.get_Value(pFeature1.Fields.FindField(OperationAttribute)));
}
EqualPartValue = FieldTotal / Convert.ToInt16(textBox1.Text);
F2FDistance.MakeDistanceArray(pFeature, GroupIDTotalList[0].getID());
int k = 2;
while ((NoOfSplit - 1) != RegionFormed)
{
IFeature NextStartingFeature = StaticMethodsClass.FindNextStartingFeature(RegionGeomtry);
//MessageBox.Show("..." + NextStartingFeature.OID, "hi");
GroupIDTotal NextGroup = new GroupIDTotal();
NextGroup.setID((short)k);
NextGroup.setCalculatedSplitValue(Convert.ToDouble(NextStartingFeature.get_Value(NextStartingFeature.Fields.FindField(OperationAttribute))));
NextStartingFeature.set_Value(NextStartingFeature.Fields.FindField("SpltGropus"), k);
NextStartingFeature.Store();
GroupIDTotalList.Add(NextGroup);
F2FDistance.MakeDistanceArray(NextStartingFeature, GroupIDTotalList[k - 1].getID());
k = k + 1;
}
//
//IGeometry pPol = CreateConvexHull.Create(pFeatureCursor1);
//IFeature dd = pFeatureClass.CreateFeature();
//dd.Shape = pPol;
//dd.Store();
//IActiveView activeView = pMap as IActiveView;
//activeView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, null);
//MessageBox.Show("...", "hi");
//
}
}
MessageBox.Show("..." + FieldTotal + "..." + EqualPartValue, "hi");
//MessageBox.Show("..." + pFeature1.OID, "hi");
}
private static void MapUsingClassbreaksRenderer()
{
string layerName = CboLayers.GetSelectedLayer();
ILayer layer = GetLayerByName(layerName);
IFeatureLayer2 fLayer = layer as IFeatureLayer2;
string fieldName = CboFields.GetSelectedField();
// Get the number of classes
string selectedClass = CboClasses.GetSelectedClass();
int numberOfClasses = Convert.ToInt32(selectedClass);
ITableHistogram tableHistogram = new TableHistogramClass();
tableHistogram.Table = fLayer.FeatureClass as ITable;
tableHistogram.Field = fieldName;
IHistogram histo = tableHistogram as IHistogram;
object datavalues, datafrequencies;
histo.GetHistogram(out datavalues, out datafrequencies);
IClassify classify = new QuantileClass();
classify.SetHistogramData(datavalues, datafrequencies);
classify.Classify(ref numberOfClasses);
if (numberOfClasses <= 1)
{
return;
}
double[] classBreaks = (double[])classify.ClassBreaks;
IClassBreaksRenderer render = new ClassBreaksRenderer();
render.Field = fieldName;
render.BreakCount = numberOfClasses;
render.MinimumBreak = classBreaks[0];
// Get the colors
ICmykColor[] colors = ColorbrewerExtension.GetCmykColors();
IFillSymbol fill = null;
// Iterate through the colors
for (int i = 0; i < numberOfClasses; i++)
{
fill = new SimpleFillSymbol();
fill.Color = colors[i];
fill.Outline.Width = 0.5;
render.Symbol[i] = fill as ISymbol;
render.Break[i] = classBreaks[i + 1];
render.Label[i] = string.Format("{0} to {1}", classBreaks[i]
, classBreaks[i + 1]);
}
IGeoFeatureLayer gFLayer = layer as IGeoFeatureLayer;
gFLayer.Renderer = render as IFeatureRenderer;
IMxDocument mxDoc = ArcMap.Application.Document as IMxDocument;
mxDoc.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, gFLayer
, mxDoc.ActiveView.Extent);
mxDoc.UpdateContents();
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
// find feature class inside the given feature dataset
IGPParameter osmFeatureDatasetParameter = paramvalues.get_Element(in_osmFeatureDatasetNumber) as IGPParameter;
IDEFeatureDataset osmFeatureDataset = gpUtilities3.UnpackGPValue(osmFeatureDatasetParameter) as IDEFeatureDataset;
string osmPointFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_pt";
string osmLineFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ln";
string osmPolygonFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ply";
IFeatureClass osmPointFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPointFeatureClassString);
IFeatureClass osmLineFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmLineFeatureClassString);
IFeatureClass osmPoylgonFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPolygonFeatureClassString);
// open the specified layers holding the symbology and editing templates
IGPParameter osmPointSymbolTemplateParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter;
IGPValue osmGPPointLayerValue = gpUtilities3.UnpackGPValue(osmPointSymbolTemplateParameter);
IGPParameter outputPointGPParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter;
IGPValue outputPointLayerGPValue = gpUtilities3.UnpackGPValue(outputPointGPParameter);
bool isLayerOnDisk = false;
// create a clone of the source layer
// we will then go ahead and adjust the data source (dataset) of the cloned layer
IObjectCopy objectCopy = new ObjectCopyClass();
ICompositeLayer adjustedPointTemplateLayer = objectCopy.Copy(osmGPPointLayerValue) as ICompositeLayer;
IGPGroupLayer osmPointGroupTemplateLayer = adjustedPointTemplateLayer as IGPGroupLayer;
ICompositeLayer compositeLayer = gpUtilities3.Open((IGPValue)osmPointGroupTemplateLayer) as ICompositeLayer;
//ICompositeLayer adjustedPointTemplateLayer = osmGPPointLayerValue as ICompositeLayer;
//IGPGroupLayer osmPointGroupTemplateLayer = osmGPPointLayerValue as IGPGroupLayer;
//IClone cloneSource = osmPointGroupTemplateLayer as IClone;
//ICompositeLayer compositeLayer = m_gpUtilities3.Open((IGPValue)cloneSource.Clone()) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPointLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
IFeatureLayerDefinition2 featureLayerDefinition2 = null;
ISQLSyntax sqlSyntax = null;
IGPLayer adjustedPointGPLayer = null;
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer != null)
{
if (geoFeatureLayer.ShapeType == osmPointFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPointFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPointFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPointFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
}
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile pointLayerFile = new LayerFileClass();
if (pointLayerFile.get_IsPresent(outputPointLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPointLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120041, ex.Message);
return;
}
}
pointLayerFile.New(outputPointLayerGPValue.GetAsText());
pointLayerFile.ReplaceContents((ILayer)compositeLayer);
pointLayerFile.Save();
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)pointLayerFile.Layer);
}
// IGPLayer adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPointGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPointGPLayer, outputPointGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmLineSymbolTemplateParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter;
IGPValue osmGPLineLayerValue = gpUtilities3.UnpackGPValue(osmLineSymbolTemplateParameter) as IGPValue;
IGPParameter outputLineGPParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter;
IGPValue outputLineLayerGPValue = gpUtilities3.UnpackGPValue(outputLineGPParameter);
IGPValue adjustedLineTemplateLayer = objectCopy.Copy(osmGPLineLayerValue) as IGPValue;
IGPGroupLayer osmLineGroupTemplateLayer = adjustedLineTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmLineGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPLineLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmLineFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmLineFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmLineFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmLineFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (string.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile lineLayerFile = new LayerFileClass();
if (lineLayerFile.get_IsPresent(outputLineLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputLineLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120042, ex.Message);
return;
}
}
lineLayerFile.New(outputLineLayerGPValue.GetAsText());
lineLayerFile.ReplaceContents((ILayer)compositeLayer);
lineLayerFile.Save();
}
IGPLayer adjustLineGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustLineGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustLineGPLayer, outputLineGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmPolygonSymbolTemplateParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter;
IGPValue osmGPPolygonLayerValue = gpUtilities3.UnpackGPValue(osmPolygonSymbolTemplateParameter);
IGPParameter outputPolygonGPParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter;
IGPValue outputPolygonLayerGPValue = gpUtilities3.UnpackGPValue(outputPolygonGPParameter);
IGPValue adjustedPolygonTemplateLayer = objectCopy.Copy(osmGPPolygonLayerValue) as IGPValue;
IGPGroupLayer osmPolygonGroupTemplateLayer = adjustedPolygonTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmPolygonGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPolygonLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmPoylgonFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPoylgonFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPoylgonFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPoylgonFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile polygonLayerFile = new LayerFileClass();
if (polygonLayerFile.get_IsPresent(outputPolygonLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPolygonLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120043, ex.Message);
return;
}
}
polygonLayerFile.New(outputPolygonLayerGPValue.GetAsText());
polygonLayerFile.ReplaceContents((ILayer)compositeLayer);
polygonLayerFile.Save();
}
IGPLayer adjustedPolygonGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPolygonGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPolygonGPLayer, outputPolygonGPParameter);
}
}
catch (Exception ex)
{
message.AddError(-10, ex.Message);
}
}
// ArcGIS Snippet Title:
// Loop Through Layers of Specific UID
//
// Long Description:
// Stub code to loop through layers in a map where a specific UID is supplied.
//
///<summary>Stub code to loop through layers in a map where a specific UID is supplied.</summary>
///
///<param name="map">An IMap interface in which the layers reside.</param>
///<param name="layerCLSID">A System.String that is the layer GUID type. For example: "{E156D7E5-22AF-11D3-9F99-00C04F6BC78E}" is the IGeoFeatureLayer.</param>
///
///<remarks>In order of the code to be useful the user needs to write their own code to use the layer in the TODO section.
///
/// The different layer GUID's and Interface's are:
/// "{AD88322D-533D-4E36-A5C9-1B109AF7A346}" = IACFeatureLayer
/// "{74E45211-DFE6-11D3-9FF7-00C04F6BC6A5}" = IACLayer
/// "{495C0E2C-D51D-4ED4-9FC1-FA04AB93568D}" = IACImageLayer
/// "{65BD02AC-1CAD-462A-A524-3F17E9D85432}" = IACAcetateLayer
/// "{4AEDC069-B599-424B-A374-49602ABAD308}" = IAnnotationLayer
/// "{DBCA59AC-6771-4408-8F48-C7D53389440C}" = IAnnotationSublayer
/// "{E299ADBC-A5C3-11D2-9B10-00C04FA33299}" = ICadLayer
/// "{7F1AB670-5CA9-44D1-B42D-12AA868FC757}" = ICadastralFabricLayer
/// "{BA119BC4-939A-11D2-A2F4-080009B6F22B}" = ICompositeLayer
/// "{9646BB82-9512-11D2-A2F6-080009B6F22B}" = ICompositeGraphicsLayer
/// "{0C22A4C7-DAFD-11D2-9F46-00C04F6BC78E}" = ICoverageAnnotationLayer
/// "{6CA416B1-E160-11D2-9F4E-00C04F6BC78E}" = IDataLayer
/// "{0737082E-958E-11D4-80ED-00C04F601565}" = IDimensionLayer
/// "{48E56B3F-EC3A-11D2-9F5C-00C04F6BC6A5}" = IFDOGraphicsLayer
/// "{40A9E885-5533-11D0-98BE-00805F7CED21}" = IFeatureLayer
/// "{605BC37A-15E9-40A0-90FB-DE4CC376838C}" = IGdbRasterCatalogLayer
/// "{E156D7E5-22AF-11D3-9F99-00C04F6BC78E}" = IGeoFeatureLayer
/// "{34B2EF81-F4AC-11D1-A245-080009B6F22B}" = IGraphicsLayer
/// "{EDAD6644-1810-11D1-86AE-0000F8751720}" = IGroupLayer
/// "{D090AA89-C2F1-11D3-9FEF-00C04F6BC6A5}" = IIMSSubLayer
/// "{DC8505FF-D521-11D3-9FF4-00C04F6BC6A5}" = IIMAMapLayer
/// "{34C20002-4D3C-11D0-92D8-00805F7C28B0}" = ILayer
/// "{E9B56157-7EB7-4DB3-9958-AFBF3B5E1470}" = IMapServerLayer
/// "{B059B902-5C7A-4287-982E-EF0BC77C6AAB}" = IMapServerSublayer
/// "{82870538-E09E-42C0-9228-CBCB244B91BA}" = INetworkLayer
/// "{D02371C7-35F7-11D2-B1F2-00C04F8EDEFF}" = IRasterLayer
/// "{AF9930F0-F61E-11D3-8D6C-00C04F5B87B2}" = IRasterCatalogLayer
/// "{FCEFF094-8E6A-4972-9BB4-429C71B07289}" = ITemporaryLayer
/// "{5A0F220D-614F-4C72-AFF2-7EA0BE2C8513}" = ITerrainLayer
/// "{FE308F36-BDCA-11D1-A523-0000F8774F0F}" = ITinLayer
/// "{FB6337E3-610A-4BC2-9142-760D954C22EB}" = ITopologyLayer
/// "{005F592A-327B-44A4-AEEB-409D2F866F47}" = IWMSLayer
/// "{D43D9A73-FF6C-4A19-B36A-D7ECBE61962A}" = IWMSGroupLayer
/// "{8C19B114-1168-41A3-9E14-FC30CA5A4E9D}" = IWMSMapLayer
///</remarks>
public ILayer LoopThroughLayersOfSpecificUID(IMap map, String layerCLSID, string LayerName)
{
ILayer myLayer;
myLayer = null;
ESRI.ArcGIS.esriSystem.UID uid = new UIDClass();
//ESRI.ArcGIS.esriIUID uid = new ESRI.ArcGIS.esriUIDClass();
uid.Value = layerCLSID; // Example: "{E156D7E5-22AF-11D3-9F99-00C04F6BC78E}" = IGeoFeatureLayer
try
{
IEnumLayer enumLayer = map.get_Layers(((ESRI.ArcGIS.esriSystem.UID)(uid)), true); // Explicit Cast
enumLayer.Reset();
ILayer layer;
while ((layer = enumLayer.Next()) != null)
{
IFeatureLayer2 pFL = layer as IFeatureLayer2;
IDataset pDS = pFL.FeatureClass as IDataset;
if (pDS != null)
{
if (pDS.Name == LayerName)
{
myLayer = layer;
break;
}
}
////if (pFL != null)
////{
//// IQueryFilter pQF = new QueryFilter();
//// pQF.WhereClause = "CIP_ID =" + txtCipNumber.Text;
//// //IFeatureCursor pFCur = pFL.Search(pQF,true);
//// IDataset pDS = pFL.FeatureClass as IDataset;
//// ISelectionSet pSS = pFL.FeatureClass.Select (pQF,esriSelectionType.esriSelectionTypeHybrid,esriSelectionOption.esriSelectionOptionNormal, pDS.Workspace);
//// IMxDocument pMxDoc = ArcMap.Document;
//// IMap pMap = pMxDoc.FocusMap;
//// if (pDS != null)
//// {
//// IEnumDataset pEnumDS = pDS.Workspace.get_Datasets(esriDatasetType.esriDTFeatureClass);
//// IFeatureClass pDS2 = pEnumDS.Next() as IFeatureClass;
//// while (pDS2 != null)
//// {
//// if (pDS2.AliasName == "SANGIS.CIP_LINE" || pDS2.AliasName == "SANGIS.CIP_POINT" || pDS2.AliasName == "SANGIS.CIP_POLY")
//// {
//// IQueryFilter pQF = new QueryFilter();
//// pQF.WhereClause = "CIP_ID =" + txtCipNumber.Text;
//// IFeatureCursor pFCur = pDS2.Search(pQF,true);
//// IFeature pFeat = pFCur.NextFeature();
//// }
//// }
//// }
//}
//if (myLayer.Fe == typeof(IFeatureClass))
//{
// IFeatureClass pFC =(IFeatureClass) myLayer;
// if (pFC.FeatureDataset.Workspace.WorkspaceFactory.WorkspaceType == esriWorkspaceType.esriRemoteDatabaseWorkspace)
// {
// IRemoteDatabaseWorkspaceFactory pRDWF = (IRemoteDatabaseWorkspaceFactory) pFC.FeatureDataset.Workspace.WorkspaceFactory;
// }
}
return(myLayer);
}
catch (Exception ex)
{
//Windows.Forms.MessageBox.Show("No layers of type: " + uid.Value.ToString);
return(myLayer);
}
finally
{
}
}
