public ITraceFlowSolverGEN UTIL_coreTraceSetup()
{
// get the current network's logical network
INetworkAnalysisExt nax = m_utilNetExt as INetworkAnalysisExt;
INetwork net = nax.CurrentNetwork.Network;
// create a new TraceFlowSolver object and
// set the source network for the solve
ITraceFlowSolverGEN tfs = new TraceFlowSolverClass() as ITraceFlowSolverGEN;
INetSolver netSolver = tfs as INetSolver;
netSolver.SourceNetwork = net;
// get the barriers for the network, using the element barriers and
// selection barriers that have been added using the user interface
INetworkAnalysisExtBarriers naxBarriers = m_utilNetExt as INetworkAnalysisExtBarriers;
INetElementBarriers juncElemBarriers, edgeElemBarriers;
naxBarriers.CreateElementBarriers(out juncElemBarriers, out edgeElemBarriers);
ISelectionSetBarriers selSetBarriers;
naxBarriers.CreateSelectionBarriers(out selSetBarriers);
netSolver.set_ElementBarriers(esriElementType.esriETJunction, juncElemBarriers);
netSolver.set_ElementBarriers(esriElementType.esriETEdge, edgeElemBarriers);
netSolver.SelectionSetBarriers = selSetBarriers;
// set up the disabled layers for the network solver
// for each feature layer belonging to this network, determine if it is
// enabled or disabled; if it's disabled, then notify the network solver
for (int i = 0; i < nax.FeatureLayerCount; i++)
{
IFeatureLayer featureLayer = nax.get_FeatureLayer(i);
if (naxBarriers.GetDisabledLayer(featureLayer))
{
netSolver.DisableElementClass(featureLayer.FeatureClass.FeatureClassID);
}
}
INetworkAnalysisExtWeightFilter naxWeightFilter = m_utilNetExt as INetworkAnalysisExtWeightFilter;
INetSolverWeightsGEN netSolverWeights = netSolver as INetSolverWeightsGEN;
INetSchema netSchema = net as INetSchema;
// create the junction weight filter
int juncFilterRangeCount = naxWeightFilter.get_FilterRangeCount(esriElementType.esriETJunction);
if (juncFilterRangeCount > 0)
{
INetWeight netWeight = netSchema.get_WeightByName(naxWeightFilter.JunctionWeightFilterName);
netSolverWeights.JunctionFilterWeight = netWeight;
esriWeightFilterType juncWeightFilterType;
bool juncApplyNotOperator;
naxWeightFilter.GetFilterType(esriElementType.esriETJunction,
out juncWeightFilterType, out juncApplyNotOperator);
netSolverWeights.SetFilterType(esriElementType.esriETJunction,
juncWeightFilterType, juncApplyNotOperator);
object[] juncFromValues = new object[juncFilterRangeCount];
object[] juncToValues = new object[juncFilterRangeCount];
for (int i = 0; i < juncFilterRangeCount; i++)
{
naxWeightFilter.GetFilterRange(esriElementType.esriETJunction, i,
out juncFromValues[i], out juncToValues[i]);
}
netSolverWeights.SetFilterRanges(esriElementType.esriETJunction,
ref juncFromValues, ref juncToValues);
}
// create the edge weight filters
int edgeFilterRangeCount = naxWeightFilter.get_FilterRangeCount(esriElementType.esriETEdge);
if (edgeFilterRangeCount > 0)
{
INetWeight fromToNetWeight = netSchema.get_WeightByName(naxWeightFilter.FromToEdgeWeightFilterName);
netSolverWeights.FromToEdgeFilterWeight = fromToNetWeight;
INetWeight toFromNetWeight = netSchema.get_WeightByName(naxWeightFilter.ToFromEdgeWeightFilterName);
netSolverWeights.ToFromEdgeFilterWeight = toFromNetWeight;
esriWeightFilterType edgeWeightFilterType;
bool edgeApplyNotOperator;
naxWeightFilter.GetFilterType(esriElementType.esriETEdge,
out edgeWeightFilterType, out edgeApplyNotOperator);
netSolverWeights.SetFilterType(esriElementType.esriETEdge,
edgeWeightFilterType, edgeApplyNotOperator);
object[] edgeFromValues = new object[edgeFilterRangeCount];
object[] edgeToValues = new object[edgeFilterRangeCount];
for (int i = 0; i < edgeFilterRangeCount; i++)
{
naxWeightFilter.GetFilterRange(esriElementType.esriETEdge, i,
out edgeFromValues[i], out edgeToValues[i]);
}
netSolverWeights.SetFilterRanges(esriElementType.esriETEdge,
ref edgeFromValues, ref edgeToValues);
}
INetworkAnalysisExtFlags naxFlags = m_utilNetExt as INetworkAnalysisExtFlags;
// assign the edge flags to the network solver
int edgeFlagCount = naxFlags.EdgeFlagCount;
if (edgeFlagCount > 0)
{
IEdgeFlag[] edgeFlags = new IEdgeFlag[edgeFlagCount];
for (int i = 0; i < edgeFlagCount; i++)
{
IEdgeFlagDisplay edgeFlagDisplay = naxFlags.get_EdgeFlag(i);
IFlagDisplay flagDisplay = edgeFlagDisplay as IFlagDisplay;
IEdgeFlag edgeFlag = new EdgeFlagClass();
edgeFlag.Position = Convert.ToSingle(edgeFlagDisplay.Percentage);
INetFlag netFlag = edgeFlag as INetFlag;
netFlag.UserClassID = flagDisplay.FeatureClassID;
netFlag.UserID = flagDisplay.FID;
netFlag.UserSubID = flagDisplay.SubID;
edgeFlags[i] = edgeFlag;
}
tfs.PutEdgeOrigins(ref edgeFlags);
}
// assign the junction flags to the network solver
int juncFlagCount = naxFlags.JunctionFlagCount;
if (juncFlagCount > 0)
{
IJunctionFlag[] juncFlags = new IJunctionFlag[juncFlagCount];
for (int i = 0; i < juncFlagCount; i++)
{
IJunctionFlagDisplay juncFlagDisplay = naxFlags.get_JunctionFlag(i);
IFlagDisplay flagDisplay = juncFlagDisplay as IFlagDisplay;
IJunctionFlag juncFlag = new JunctionFlagClass();
INetFlag netFlag = juncFlag as INetFlag;
netFlag.UserClassID = flagDisplay.FeatureClassID;
netFlag.UserID = flagDisplay.FID;
netFlag.UserSubID = flagDisplay.SubID;
juncFlags[i] = juncFlag;
}
tfs.PutJunctionOrigins(ref juncFlags);
}
// set the option for tracing on indeterminate flow
ITraceTasks traceTasks = m_utilNetExt as ITraceTasks;
tfs.TraceIndeterminateFlow = traceTasks.TraceIndeterminateFlow;
return(tfs);
}
//���ҷ���
private void BurstFindValves(IFlagDisplay pFlagDisplay)
{
try
{
INetwork pNetwork = pGeoNetwork.Network;
IFeatureLayer pValveFeatLayer = Utility.FindFeatLayer("Water Fixtures", this);
IFeatureLayer pWaterLineFeatLyr = Utility.FindFeatLayer("Water Lines", this);
//�õ�EdgeFlag
IEdgeFlag pEdgeFlag = new EdgeFlagClass();
INetFlag pNetFlag = pEdgeFlag as INetFlag;
pNetFlag.UserClassID = pFlagDisplay.FeatureClassID;
pNetFlag.UserID = pFlagDisplay.FID;
//��÷��ŵĹ��
IQueryFilter pQueryFilter = new QueryFilterClass();
pQueryFilter.WhereClause = "PWF_TYPE_CODE = 1";
IFeatureSelection pValveFeatSelection = pValveFeatLayer as IFeatureSelection;
pValveFeatSelection.SelectFeatures(pQueryFilter, esriSelectionResultEnum.esriSelectionResultNew, false);
//������ѡ��ķ���ΪSelectionSetBarriers
ISelectionSetBarriers pSelSetBarriers = new SelectionSetBarriersClass();
int FeatClassID = pValveFeatLayer.FeatureClass.FeatureClassID;
IEnumIDs pEnumIDs = pValveFeatSelection.SelectionSet.IDs;
pEnumIDs.Reset();
int FeatID = pEnumIDs.Next();
while (FeatID > 0)
{
pSelSetBarriers.Add(FeatClassID, FeatID);
FeatID = pEnumIDs.Next();
}
//����TraceFlowSolver
ITraceFlowSolver pTraceFlowSolver = new TraceFlowSolverClass() as ITraceFlowSolver;
INetSolver pNetSolver = pTraceFlowSolver as INetSolver;
pNetSolver.SourceNetwork = pNetwork;
pNetSolver.SelectionSetBarriers = pSelSetBarriers;
pTraceFlowSolver.PutEdgeOrigins(1, ref pEdgeFlag);
//�Ӹ��ٹ����л�ý��
IEnumNetEID pResultJenction;
IEnumNetEID pResultsEdges;
IEnumNetEID ptmpEnumNetEID = null;
pTraceFlowSolver.FindFlowEndElements(esriFlowMethod.esriFMConnected, esriFlowElements.esriFEJunctions, out pResultJenction, out ptmpEnumNetEID);
pTraceFlowSolver.FindFlowElements(esriFlowMethod.esriFMConnected, esriFlowElements.esriFEEdges, out ptmpEnumNetEID, out pResultsEdges);
int lEID;
int iUserClassID;
int iUserID;
int iUserSubID;
INetElements pNetElements = pGeoNetwork.Network as INetElements;
pResultJenction.Reset();
IFeature pFeature;
pValveFeatSelection.Clear();
for (int j = 0; j <= pResultJenction.Count - 1; j++)
{
lEID = pResultJenction.Next();
pNetElements.QueryIDs(lEID, esriElementType.esriETJunction, out iUserClassID, out iUserID, out iUserSubID);
pFeature = pValveFeatLayer.FeatureClass.GetFeature(iUserID);
pValveFeatSelection.Add(pFeature);
// MessageBox.Show(iUserClassID.ToString()+","+iUserID.ToString()+","+iUserSubID.ToString());
}
IFeatureSelection pLinesFeatSelection = pWaterLineFeatLyr as IFeatureSelection;
pLinesFeatSelection.Clear();
for (int i = 0; i <= pResultsEdges.Count - 1; i++)
{
lEID = pResultsEdges.Next();
pNetElements.QueryIDs(lEID, esriElementType.esriETEdge, out iUserClassID, out iUserID, out iUserSubID);
pFeature = pWaterLineFeatLyr.FeatureClass.GetFeature(iUserID);
pLinesFeatSelection.Add(pFeature);
}
//�����µķ���������Ⱦѡȡ�Ľ��
IMarkerSymbol pMarkerSymbol = new SimpleMarkerSymbolClass();
IRgbColor pRGBColor = new RgbColorClass();
pRGBColor.Red = 12;
pRGBColor.Green = 250;
pRGBColor.Blue = 233;
pMarkerSymbol.Size = 14;
pMarkerSymbol.Color = pRGBColor;
pValveFeatSelection.SelectionSymbol = pMarkerSymbol as ISymbol;
pValveFeatSelection.SelectionColor = pRGBColor as IColor;
pValveFeatSelection.SelectionChanged();
IRgbColor pRGBColor2 = new RgbColorClass();
pRGBColor2.Red = 230;
pRGBColor2.Green = 230;
pRGBColor2.Blue = 0;
pLinesFeatSelection.SelectionColor = pRGBColor2;
pLinesFeatSelection.SelectionChanged();
axMapControl1.ActiveView.Refresh();
ICursor pCursor = null;
pValveFeatSelection.SelectionSet.Search(null, false, out pCursor);
IFeatureCursor pFeatCursor = pCursor as IFeatureCursor;
IArray pArray = new ArrayClass();
pFeature = pFeatCursor.NextFeature();
while (pFeature != null)
{
pArray.Add(pFeature);
pFeature = pFeatCursor.NextFeature();
}
pFeature = pWaterLineFeatLyr.FeatureClass.GetFeature(pFlagDisplay.FID);
frmBurstReport frmBurstReport1 = new frmBurstReport(this, pValveFeatLayer, pWaterLineFeatLyr, pArray, pFeature);
frmBurstReport1.Show();
}
catch (Exception eX)
{
MessageBox.Show(eX.Message);
}
}
