public async Task ApplyNoc(BillingNOC noc, Models.ExponentPortalEntities db)
{
String _CField = CalculateField.Replace("NOC_Details.", "#NOC_Details.");
String SQL =
$@"SELECT {_CField} * {CostMultipliedBy} / {_CostDividedBy} FROM #NOC_Details";
if (!String.IsNullOrWhiteSpace(ApplyCondition))
{
String _ACondition = ApplyCondition.Replace("NOC_Details.", "#NOC_Details.");
SQL += $" WHERE ({_ACondition})";
}
using (var cmd = db.Database.Connection.CreateCommand()) {
cmd.CommandText = SQL;
var Result = await cmd.ExecuteScalarAsync();
if (Result == null)
{
_CalculatedCost = 0;
}
else
{
Decimal.TryParse(Result.ToString(), out _CalculatedCost);
}
}//using ctx.Database.Connection.CreateCommand
}
public static void CalculateField(object table, string fldName, object expression)
{
var geoprocessor = new Geoprocessor()
{
OverwriteOutput = true,
AddOutputsToMap = false
};
try
{
CalculateField fieldCalc = new CalculateField(table, fldName, expression)
{
expression_type = "PYTHON_9.3"
};
geoprocessor.Execute(fieldCalc, null);
}
catch (Exception)
{
if (geoprocessor.MessageCount > 0)
{
string excMessage = null;
for (int Count = 0; Count <= geoprocessor.MessageCount - 1; Count++)
{
excMessage += geoprocessor.GetMessage(Count) + Environment.NewLine;
}
throw new Exception(excMessage);
}
}
}
//执行计算，输出计算结果信息字符串
private string FieldCal(IFeatureLayer pFtLayer, string strExpression)
{
txtMessage.Text = "正在计算请稍后……\r\n";
try
{
Geoprocessor Gp = new Geoprocessor();
Gp.OverwriteOutput = true;
CalculateField calField = new CalculateField();
calField.expression = strExpression;
Gp.Execute(calField, null);
for (int i = 0; i < Gp.MessageCount; i++)
{
txtMessage.Text += Gp.GetMessage(i).ToString() + "\r\n";
}
return("计算成功");
}
catch (Exception e)
{
txtMessage.Text += e.Message;
return("计算失败" + e.Message);
}
}
//执行计算，输出计算结果信息字符串
private string FieldCal(IFeatureLayer pFtLayer, string strExpression)
{
txtMessage.Text = "正在计算请稍后……\r\n";
try
{
Geoprocessor Gp = new Geoprocessor();
Gp.OverwriteOutput = true;
CalculateField calField = new CalculateField();
calField.expression = strExpression;
Gp.Execute(calField, null);
for (int i = 0; i < Gp.MessageCount; i++)
{
txtMessage.Text += Gp.GetMessage(i).ToString() + "\r\n";
}
return "计算成功";
}
catch (Exception e)
{
txtMessage.Text += e.Message;
return "计算失败" + e.Message;
}
}
public static void calculate_field(Geoprocessor gp, string in_table, string field_name, string expression, string ex_type)
{
CalculateField calculateField = new CalculateField();
calculateField.in_table = in_table;
calculateField.field = field_name;
calculateField.expression = expression;
calculateField.expression_type = ex_type;
gp.Execute(calculateField, null);
}
//调用字段计算器窗口
private void button5_Click(object sender, EventArgs e)
{
int indexNum = dataGridView1.CurrentCell.ColumnIndex;
string strField = dataGridView1.Columns[indexNum].HeaderText.ToString();
ILayer pLayer = currentLayer;
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
CalculateField calculate = new CalculateField(pFeatureLayer, dataGridView1, strField);
calculate.Show();
}
private void 计算ToolStripMenuItem_Click(object sender, EventArgs e)
{
int indexNum = dataGridView1.CurrentCell.ColumnIndex;
string strField = dataGridView1.Columns[indexNum].HeaderText.ToString();
ILayer pLayer = currentLayer;
IFeatureLayer pFLayer = pLayer as IFeatureLayer;
CalculateField formcalfield = new CalculateField(pFLayer, dataGridView1, strField);
formcalfield.Show();
}
/// <summary>
/// Calculates the values of a field for a feature class.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="fieldName">The field that will be updated with the new calculation.</param>
/// <param name="expression">The simple calculation expression used to create a value that will populate the selected rows.</param>
/// <param name="python">A block of Python code for complex expresssions.</param>
/// <param name="trackCancel">The track cancel.</param>
/// <param name="eventHandler">The events.</param>
public static void Calculate(this ITable source, string fieldName, string expression, string python, ITrackCancel trackCancel, IGeoProcessorEvents eventHandler)
{
CalculateField gp = new CalculateField();
gp.in_table = source;
gp.field = fieldName;
gp.expression = expression;
gp.code_block = python;
gp.expression_type = "PYTHON_9.3";
gp.Run(trackCancel, eventHandler);
}
static Dictionary <int, int> GetFeatureVertexCount(string fcPath)
{
Dictionary <int, int> pntCntDict = new Dictionary <int, int>();
Geoprocessor gp = new Geoprocessor {
OverwriteOutput = true
};
try
{
AddField addField = new AddField {
in_table = fcPath, field_name = "PointCount", field_type = "LONG"
};
gp.Execute(addField, null);
CalculateField calcField = new CalculateField
{
in_table = fcPath,
field = "PointCount",
expression = "!Shape!.pointcount",
expression_type = "PYTHON"
};
gp.Execute(calcField, null);
}
catch (COMException)
{
object sev = 2;
Console.WriteLine(gp.GetMessages(ref sev));
}
IGPUtilities gpUtilities = new GPUtilitiesClass();
IFeatureClass featClass = gpUtilities.OpenFeatureClassFromString(fcPath);
int fieldIndex = featClass.FindField("PointCount");
IQueryFilter qf = new QueryFilterClass {
SubFields = "PointCount"
};
ICursor cursor = featClass.Search(qf, true) as Cursor;
IRow row;
while ((row = cursor.NextRow()) != null)
{
pntCntDict.Add(row.OID, (int)row.Value[fieldIndex]);
}
return(pntCntDict);
}
private string FieldCal(IFeatureLayer pFtLayer, string strField, string strExpression)
{
try
{
Geoprocessor Gp = new Geoprocessor();
Gp.OverwriteOutput = true;
CalculateField calField = new CalculateField();
calField.in_table = pFtLayer as ITable;
calField.field = strField;
calField.expression = strExpression;
calField.expression_type = "PYTHON";
Gp.Execute(calField, null);
return("计算成功");
}
catch (Exception e)
{
return("计算失败" + e.Message);
}
}
private void CreateAndPopulateLTRField(string outputFileGdbPath, string ltrTablePath,
string newFieldName, string queryExpression,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
// Add a new field to the Streets feature class
AddField addFieldTool = new AddField();
addFieldTool.in_table = outputFileGdbPath + "\\" + StreetsFCName;
addFieldTool.field_name = newFieldName;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
gp.Execute(addFieldTool, trackcancel);
// Extract the information needed for this field from the LTR table
string extractTablePath = outputFileGdbPath + "\\ltrExtract";
AddMessage("Extracting information for the " + newFieldName + " field...", messages, trackcancel);
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = ltrTablePath;
tableSelectTool.out_table = extractTablePath;
tableSelectTool.where_clause = queryExpression;
gp.Execute(tableSelectTool, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
addIndexTool.in_table = extractTablePath;
gp.Execute(addIndexTool, trackcancel);
// Calculate the truck route/restriction field
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = extractTablePath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Writing the information to the " + newFieldName + " field...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + "." + newFieldName;
calcFieldTool.expression = "\"Y\"";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "ltrExtract";
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = extractTablePath;
gp.Execute(deleteTool, trackcancel);
}
private void CreateAndPopulateTurnFeatureClass(string outputFileGdbPath, string fdsName,
string ProhibMPTableName, string tempStatsTableName,
IGPMessages messages, ITrackCancel trackcancel)
{
// Determine the number of AltID fields we need (the same as the MAX_SEQNR value).
Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory");
var wsf = Activator.CreateInstance(factoryType) as IWorkspaceFactory;
var fws = wsf.OpenFromFile(outputFileGdbPath, 0) as IFeatureWorkspace;
ITable tempStatsTable = fws.OpenTable(tempStatsTableName);
short numAltIDFields = 2;
if (tempStatsTable.RowCount(null) == 1)
numAltIDFields = (short)((double)(tempStatsTable.GetRow(1).get_Value(tempStatsTable.FindField("MAX_SEQNR"))));
// Open the MP table and find the fields we need
ITable mpTable = fws.OpenTable(ProhibMPTableName);
int seqNrField = mpTable.FindField("SEQNR");
int trpElIDField = mpTable.FindField("TRPELID");
int idFieldOnMP = mpTable.FindField("ID");
int mpJnctIDField = mpTable.FindField("JNCTID");
// Create a temporary template feature class
var fcd = new FeatureClassDescriptionClass() as IFeatureClassDescription;
var ocd = fcd as IObjectClassDescription;
var fieldsEdit = ocd.RequiredFields as IFieldsEdit;
IField fieldOnMPTable = mpTable.Fields.get_Field(idFieldOnMP); // use the ID field as a template for the AltID fields
for (short i = 1; i <= numAltIDFields; i++)
{
IFieldEdit newField = new FieldClass();
newField.Name_2 = "AltID" + i;
newField.Precision_2 = fieldOnMPTable.Precision;
newField.Scale_2 = fieldOnMPTable.Scale;
newField.Type_2 = fieldOnMPTable.Type;
fieldsEdit.AddField(newField as IField);
}
fieldsEdit.AddField(fieldOnMPTable);
fieldOnMPTable = mpTable.Fields.get_Field(mpJnctIDField);
fieldsEdit.AddField(fieldOnMPTable);
var fieldChk = new FieldCheckerClass() as IFieldChecker;
IEnumFieldError enumFieldErr = null;
IFields validatedFields = null;
fieldChk.ValidateWorkspace = fws as IWorkspace;
fieldChk.Validate(fieldsEdit as IFields, out enumFieldErr, out validatedFields);
var tempFC = fws.CreateFeatureClass("TheTemplate", validatedFields, ocd.InstanceCLSID, ocd.ClassExtensionCLSID,
esriFeatureType.esriFTSimple, fcd.ShapeFieldName, "") as IDataset;
// Create the turn feature class from the template, then delete the template
Geoprocessor gp = new Geoprocessor();
CreateTurnFeatureClass createTurnFCTool = new CreateTurnFeatureClass();
string pathToFds = outputFileGdbPath + "\\" + fdsName;
createTurnFCTool.out_location = pathToFds;
createTurnFCTool.out_feature_class_name = TurnFCName;
createTurnFCTool.maximum_edges = numAltIDFields;
createTurnFCTool.in_template_feature_class = outputFileGdbPath + "\\TheTemplate";
gp.Execute(createTurnFCTool, trackcancel);
tempFC.Delete();
// Open the new turn feature class and find all the fields on it
IFeatureClass turnFC = fws.OpenFeatureClass(TurnFCName);
int[] altIDFields = new int[numAltIDFields];
int[] edgeFCIDFields = new int[numAltIDFields];
int[] edgeFIDFields = new int[numAltIDFields];
int[] edgePosFields = new int[numAltIDFields];
for (short i = 0; i < numAltIDFields; i++)
{
altIDFields[i] = turnFC.FindField("AltID" + (i + 1));
edgeFCIDFields[i] = turnFC.FindField("Edge" + (i + 1) + "FCID");
edgeFIDFields[i] = turnFC.FindField("Edge" + (i + 1) + "FID");
edgePosFields[i] = turnFC.FindField("Edge" + (i + 1) + "Pos");
}
int edge1endField = turnFC.FindField("Edge1End");
int idFieldOnTurnFC = turnFC.FindField("ID");
int turnFCJnctIDField = turnFC.FindField("JNCTID");
// Look up the FCID of the Streets feature class
IFeatureClass streetsFC = fws.OpenFeatureClass(StreetsFCName);
int streetsFCID = streetsFC.FeatureClassID;
// Set up queries
var ts = new TableSortClass() as ITableSort;
ts.Fields = "ID, SEQNR";
ts.set_Ascending("ID", true);
ts.set_Ascending("SEQNR", true);
ts.QueryFilter = new QueryFilterClass();
ts.Table = mpTable;
ts.Sort(null);
ICursor mpCursor = ts.Rows;
IFeatureCursor turnFCCursor = turnFC.Insert(true);
IFeatureBuffer turnBuffer = turnFC.CreateFeatureBuffer();
// Write the field values to the turn feature class accordingly
turnBuffer.set_Value(edge1endField, "?"); // dummy value; will be updated in a later calculation
int numFeatures = 0;
IRow mpRow = mpCursor.NextRow();
while (mpRow != null)
{
// Transfer the non-edge identifying field values to the buffer
turnBuffer.set_Value(idFieldOnTurnFC, mpRow.get_Value(idFieldOnMP));
turnBuffer.set_Value(turnFCJnctIDField, mpRow.get_Value(mpJnctIDField));
// Write the AltID values to the buffer
int seq = (int)(mpRow.get_Value(seqNrField));
int lastEntry;
do
{
lastEntry = seq;
turnBuffer.set_Value(altIDFields[lastEntry - 1], mpRow.get_Value(trpElIDField));
mpRow = mpCursor.NextRow();
if (mpRow == null) break;
seq = (int)(mpRow.get_Value(seqNrField));
} while (seq != 1);
// Zero-out the unused fields
for (int i = lastEntry; i < numAltIDFields; i++)
turnBuffer.set_Value(altIDFields[i], 0);
// Write the FCID and Pos field values to the buffer
for (short i = 0; i < numAltIDFields; i++)
{
double altID = (double)(turnBuffer.get_Value(altIDFields[i]));
if (altID != 0)
{
turnBuffer.set_Value(edgeFCIDFields[i], streetsFCID);
turnBuffer.set_Value(edgeFIDFields[i], 1);
turnBuffer.set_Value(edgePosFields[i], 0.5);
}
else
{
turnBuffer.set_Value(edgeFCIDFields[i], 0);
turnBuffer.set_Value(edgeFIDFields[i], 0);
turnBuffer.set_Value(edgePosFields[i], 0);
}
}
// Create the turn feature
turnFCCursor.InsertFeature(turnBuffer);
numFeatures++;
if ((numFeatures % 100) == 0)
{
// check for user cancel
if (trackcancel != null && !trackcancel.Continue())
throw (new COMException("Function cancelled."));
}
}
// Flush any outstanding writes to the turn feature class
turnFCCursor.Flush();
// Update the Edge1End values
AddMessage("Updating the Edge1End values...", messages, trackcancel);
MakeFeatureLayer makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = pathToFds + "\\" + TurnFCName;
makeFeatureLayerTool.out_layer = "Turn_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Turn_Layer";
addJoinTool.in_field = "AltID1";
addJoinTool.join_table = pathToFds + "\\" + StreetsFCName;
addJoinTool.join_field = "ID";
gp.Execute(addJoinTool, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Turn_Layer";
calcFieldTool.field = TurnFCName + ".Edge1End";
calcFieldTool.expression = "x";
calcFieldTool.code_block = "Select Case [" + TurnFCName + ".JNCTID]\n Case [" + StreetsFCName + ".F_JNCTID]: x = \"N\"\n Case [" + StreetsFCName + ".T_JNCTID]: x = \"Y\"\n Case Else: x = \"?\"\nEnd Select";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Turn_Layer";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = "Turn_Layer";
gp.Execute(deleteTool, trackcancel);
AddMessage("Updating the EdgeFID values...", messages, trackcancel);
// Create a temporary network dataset for updating the EdgeFID values
IDENetworkDataset dends = new DENetworkDatasetClass();
dends.SupportsTurns = true;
dends.Buildable = true;
(dends as IDataElement).Name = StreetsFCName;
(dends as IDEGeoDataset).SpatialReference = (streetsFC as IGeoDataset).SpatialReference;
IArray sourceArray = new ArrayClass();
var efs = new EdgeFeatureSourceClass() as IEdgeFeatureSource;
(efs as INetworkSource).Name = StreetsFCName;
efs.UsesSubtypes = false;
efs.ClassConnectivityGroup = 1;
efs.ClassConnectivityPolicy = esriNetworkEdgeConnectivityPolicy.esriNECPEndVertex;
sourceArray.Add(efs);
var tfs = new TurnFeatureSourceClass() as INetworkSource;
tfs.Name = TurnFCName;
sourceArray.Add(tfs);
dends.Sources = sourceArray;
var fdxc = fws.OpenFeatureDataset(fdsName) as IFeatureDatasetExtensionContainer;
var dsCont = fdxc.FindExtension(esriDatasetType.esriDTNetworkDataset) as IDatasetContainer2;
var tempNDS = dsCont.CreateDataset(dends as IDEDataset) as IDataset;
// Set the EdgeFID field values by running UpdateByAlternateIDFields
UpdateByAlternateIDFields updateByAltIDTool = new UpdateByAlternateIDFields();
updateByAltIDTool.in_network_dataset = pathToFds + "\\" + StreetsFCName;
updateByAltIDTool.alternate_ID_field_name = "ID";
gp.Execute(updateByAltIDTool, trackcancel);
// Delete the temporary network dataset
tempNDS.Delete();
// Write the turn geometries
TurnGeometryUtilities.WriteTurnGeometry(outputFileGdbPath, StreetsFCName, TurnFCName,
numAltIDFields, 0.3, messages, trackcancel);
// Index the turn geometries
AddMessage("Creating spatial index on the turn feature class...", messages, trackcancel);
AddSpatialIndex addSpatialIndexTool = new AddSpatialIndex();
addSpatialIndexTool.in_features = pathToFds + "\\" + TurnFCName;
gp.Execute(addSpatialIndexTool, trackcancel);
return;
}
private void CreateAndPopulateRSField(string outputFileGdbPath, bool onTurnFC, string newFieldName, string queryExpression,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
string fcName = StreetsFCName;
string layerName = "Streets_Layer";
if (onTurnFC)
{
fcName = TurnFCName;
layerName = "RestrictedTurns_Layer";
}
// Add a new field to the feature class
AddField addFieldTool = new AddField();
addFieldTool.in_table = outputFileGdbPath + "\\" + fcName;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
addFieldTool.field_name = newFieldName;
gp.Execute(addFieldTool, trackcancel);
// Extract the information needed for this field from the RS table
string extractTablePath = outputFileGdbPath + "\\rsExtract";
AddMessage("Extracting information for the " + newFieldName + " field...", messages, trackcancel);
string rsTablePath = outputFileGdbPath + "\\rs";
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = rsTablePath;
tableSelectTool.out_table = extractTablePath;
tableSelectTool.where_clause = queryExpression;
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Indexing the ID field...", messages, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
addIndexTool.in_table = extractTablePath;
gp.Execute(addIndexTool, trackcancel);
// Calculate the turn restriction field
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = layerName;
addJoinTool.in_field = "ID";
addJoinTool.join_table = extractTablePath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the " + newFieldName + " field...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = layerName;
calcFieldTool.field = fcName + "." + newFieldName;
calcFieldTool.expression = "\"Y\"";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = layerName;
removeJoinTool.join_name = "rsExtract";
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = extractTablePath;
gp.Execute(deleteTool, trackcancel);
}
public void Execute(IArray paramvalues, ITrackCancel trackcancel,
IGPEnvironmentManager envMgr, IGPMessages messages)
{
// Remember the original GP environment settings and temporarily override these settings
var gpSettings = envMgr as IGeoProcessorSettings;
bool origAddOutputsToMapSetting = gpSettings.AddOutputsToMap;
bool origLogHistorySetting = gpSettings.LogHistory;
gpSettings.AddOutputsToMap = false;
gpSettings.LogHistory = false;
// Create the Geoprocessor
Geoprocessor gp = new Geoprocessor();
try
{
// Validate our values
IGPMessages validateMessages = ((IGPFunction2)this).Validate(paramvalues, false, envMgr);
if ((validateMessages as IGPMessage).IsError())
{
messages.AddError(1, "Validate failed");
return;
}
// Unpack values
IGPParameter gpParam = paramvalues.get_Element(InputAETable) as IGPParameter;
IGPValue inputAETableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputAdminAreaFeatureClasses) as IGPParameter;
var inputAdminAreaFeatureClassesMultiValue = m_gpUtils.UnpackGPValue(gpParam) as IGPMultiValue;
gpParam = paramvalues.get_Element(OutputFileGDB) as IGPParameter;
IGPValue outputFileGDBValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTATable) as IGPParameter;
IGPValue inputTATableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputNWFeatureClass) as IGPParameter;
IGPValue inputNWFeatureClassValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTimeZoneIDBaseFieldName) as IGPParameter;
IGPValue inputTimeZoneIDBaseFieldNameValue = m_gpUtils.UnpackGPValue(gpParam);
if (inputTATableValue.IsEmpty() ^ inputNWFeatureClassValue.IsEmpty())
{
messages.AddError(1, "The TA table and NW feature class must be specified together.");
return;
}
bool processStreetsFC = (!(inputNWFeatureClassValue.IsEmpty()));
string timeZoneIDBaseFieldName = "";
if (!(inputTimeZoneIDBaseFieldNameValue.IsEmpty()))
timeZoneIDBaseFieldName = inputTimeZoneIDBaseFieldNameValue.GetAsText();
// Get the path to the output file GDB
string outputFileGdbPath = outputFileGDBValue.GetAsText();
// Create the new file geodatabase
AddMessage("Creating the file geodatabase...", messages, trackcancel);
int lastBackslash = outputFileGdbPath.LastIndexOf("\\");
CreateFileGDB createFGDBTool = new CreateFileGDB();
createFGDBTool.out_folder_path = outputFileGdbPath.Remove(lastBackslash);
createFGDBTool.out_name = outputFileGdbPath.Substring(lastBackslash + 1);
gp.Execute(createFGDBTool, trackcancel);
// Copy the admin area feature classes
int numAdminAreaFCs = inputAdminAreaFeatureClassesMultiValue.Count;
string mergeToolInputs = "";
for (int i = 0; i < numAdminAreaFCs; i++)
{
AddMessage("Copying the Administrative Area feature classes (" + Convert.ToString(i+1) + " of " + Convert.ToString(numAdminAreaFCs) + ")...", messages, trackcancel);
string origAdminFCPath = inputAdminAreaFeatureClassesMultiValue.get_Value(i).GetAsText();
FeatureClassToFeatureClass importFCTool = new FeatureClassToFeatureClass();
importFCTool.in_features = origAdminFCPath;
importFCTool.out_path = outputFileGdbPath;
importFCTool.out_name = "Admin" + Convert.ToString(i, System.Globalization.CultureInfo.InvariantCulture);
importFCTool.field_mapping = "ID \"ID\" true true false 8 Double 0 0 ,First,#," + origAdminFCPath + ",ID,-1,-1;" +
"FEATTYP \"FEATTYP\" true true false 2 Short 0 0 ,First,#," + origAdminFCPath + ",FEATTYP,-1,-1;" +
"ORDER00 \"ORDER00\" true true false 3 Text 0 0 ,First,#," + origAdminFCPath + ",ORDER00,-1,-1;" +
"NAME \"NAME\" true true false 100 Text 0 0 ,First,#," + origAdminFCPath + ",NAME,-1,-1;" +
"NAMELC \"NAMELC\" true true false 3 Text 0 0 ,First,#," + origAdminFCPath + ",NAMELC,-1,-1";
gp.Execute(importFCTool, trackcancel);
mergeToolInputs = mergeToolInputs + outputFileGdbPath + "\\Admin" + Convert.ToString(i, System.Globalization.CultureInfo.InvariantCulture) + ";";
}
mergeToolInputs = mergeToolInputs.Remove(mergeToolInputs.Length - 1);
// Merge the admin area feature classes together into one feature class
AddMessage("Merging the Administrative Area feature classes...", messages, trackcancel);
string adminFCPath = outputFileGdbPath + "\\AdminFC";
Merge mergeTool = new Merge();
mergeTool.inputs = mergeToolInputs;
mergeTool.output = adminFCPath;
gp.Execute(mergeTool, trackcancel);
Delete deleteTool = null;
for (int i = 0; i < numAdminAreaFCs; i++)
{
deleteTool = new Delete();
deleteTool.in_data = outputFileGdbPath + "\\Admin" + Convert.ToString(i, System.Globalization.CultureInfo.InvariantCulture);
gp.Execute(deleteTool, trackcancel);
}
// Extract the time zone information and index it
AddMessage("Extracting the time zone information...", messages, trackcancel);
string tzTablePath = outputFileGdbPath + "\\TZ";
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputAETableValue.GetAsText();
tableSelectTool.out_table = tzTablePath;
tableSelectTool.where_clause = "ATTTYP = 'TZ'";
gp.Execute(tableSelectTool, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.in_table = tzTablePath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
// Add the UTCOffset field and calculate it
AddField addFieldTool = new AddField();
addFieldTool.in_table = adminFCPath;
addFieldTool.field_name = "UTCOffset";
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
MakeFeatureLayer makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = adminFCPath;
makeFeatureLayerTool.out_layer = "AdminFC_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "AdminFC_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = tzTablePath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the UTCOffset information on the Administrative Area feature class...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "AdminFC_Layer";
calcFieldTool.field = "AdminFC.UTCOffset";
calcFieldTool.code_block = "u = Null\ns = Trim([TZ.ATTVALUE])\nIf Not IsNull(s) Then\n" +
" sign = 1\n If Left(s, 1) = \"-\" Then sign = -1\n" +
" u = sign * ( (60 * Abs(CInt(Mid(s, 1, Len(s) - 3)))) + CInt(Right(s, 2)) )\n" +
"End If";
calcFieldTool.expression = "u";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "AdminFC_Layer";
removeJoinTool.join_name = "TZ";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "AdminFC_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = tzTablePath;
gp.Execute(deleteTool, trackcancel);
// Extract out only the admin areas that have time zone information
AddMessage("Extracting Administrative Areas with time zone information...", messages, trackcancel);
string adminTZFCPath = outputFileGdbPath + "\\AdminFCwTZ";
Select selectTool = new Select();
selectTool.in_features = adminFCPath;
selectTool.out_feature_class = adminTZFCPath;
selectTool.where_clause = "NOT UTCOffset IS NULL";
gp.Execute(selectTool, trackcancel);
// Extract the daylight saving time information and index it
AddMessage("Extracting the daylight saving time information...", messages, trackcancel);
string suTablePath = outputFileGdbPath + "\\SU";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputAETableValue.GetAsText();
tableSelectTool.out_table = suTablePath;
tableSelectTool.where_clause = "ATTTYP = 'SU'";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = suTablePath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
// Add the daylight saving field and calculate it
addFieldTool = new AddField();
addFieldTool.in_table = adminTZFCPath;
addFieldTool.field_name = "DST";
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = adminTZFCPath;
makeFeatureLayerTool.out_layer = "AdminFCwTZ_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "AdminFCwTZ_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = suTablePath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_ALL";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying the DST information to the Administrative Area feature class...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "AdminFCwTZ_Layer";
calcFieldTool.field = "AdminFCwTZ.DST";
calcFieldTool.code_block = "s = 0\nIf Not IsNull( [SU.ATTVALUE] ) Then s = CInt( [SU.ATTVALUE] )";
calcFieldTool.expression = "s";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "AdminFCwTZ_Layer";
removeJoinTool.join_name = "SU";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "AdminFCwTZ_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = suTablePath;
gp.Execute(deleteTool, trackcancel);
// Create and calculate the sortable MSTIMEZONE field
addFieldTool = new AddField();
addFieldTool.in_table = adminTZFCPath;
addFieldTool.field_name = "SortableMSTIMEZONE";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 60;
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the time zones...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = adminTZFCPath;
calcFieldTool.field = "SortableMSTIMEZONE";
calcFieldTool.code_block = TimeZoneUtilities.MakeSortableMSTIMEZONECode("ORDER00");
calcFieldTool.expression = "z";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
Rename renameTool = new Rename();
renameTool.in_data = adminTZFCPath;
renameTool.out_data = adminTZFCPath + "wNulls";
gp.Execute(renameTool, trackcancel);
selectTool = new Select();
selectTool.in_features = adminTZFCPath + "wNulls";
selectTool.out_feature_class = adminTZFCPath;
selectTool.where_clause = "NOT SortableMSTIMEZONE IS NULL";
gp.Execute(selectTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = adminTZFCPath + "wNulls";
gp.Execute(deleteTool, trackcancel);
// Dissolve the time zone polygons together
AddMessage("Dissolving the time zones...", messages, trackcancel);
string timeZoneFCPath = outputFileGdbPath + "\\" + TimeZoneFCName;
Dissolve dissolveTool = new Dissolve();
dissolveTool.in_features = adminTZFCPath;
dissolveTool.out_feature_class = timeZoneFCPath;
dissolveTool.dissolve_field = "SortableMSTIMEZONE";
dissolveTool.multi_part = "MULTI_PART";
gp.Execute(dissolveTool, trackcancel);
// Create and calculate the MSTIMEZONE field
addFieldTool = new AddField();
addFieldTool.in_table = timeZoneFCPath;
addFieldTool.field_name = "MSTIMEZONE";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 50;
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the time zones...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = timeZoneFCPath;
calcFieldTool.field = "MSTIMEZONE";
calcFieldTool.expression = "Mid([SortableMSTIMEZONE], 7)";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Delete the old sortable MSTIMEZONE field
DeleteField deleteFieldTool = new DeleteField();
deleteFieldTool.in_table = timeZoneFCPath;
deleteFieldTool.drop_field = "SortableMSTIMEZONE";
gp.Execute(deleteFieldTool, trackcancel);
if (processStreetsFC)
{
// Create the network dataset time zone table
AddMessage("Creating the time zones table...", messages, trackcancel);
TableToTable importTableTool = new TableToTable();
importTableTool.in_rows = timeZoneFCPath;
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = TimeZonesTableName;
importTableTool.field_mapping = "MSTIMEZONE \"MSTIMEZONE\" true true false 50 Text 0 0 ,First,#," +
timeZoneFCPath + ",MSTIMEZONE,-1,-1";
gp.Execute(importTableTool, trackcancel);
// Import the NW feature class to the file geodatabase
AddMessage("Copying the NW feature class to the geodatabase...", messages, trackcancel);
FeatureClassToFeatureClass importFCTool = new FeatureClassToFeatureClass();
importFCTool.in_features = inputNWFeatureClassValue.GetAsText();
importFCTool.out_path = outputFileGdbPath;
importFCTool.out_name = "nw";
gp.Execute(importFCTool, trackcancel);
string pathToLocalNW = outputFileGdbPath + "\\nw";
// Create Join polygon feature class
AddMessage("Creating the join polygon feature class...", messages, trackcancel);
string joinPolygonFCPath = outputFileGdbPath + "\\JoinPolygonFC";
MultipartToSinglepart multipartToSinglepartTool = new MultipartToSinglepart();
multipartToSinglepartTool.in_features = timeZoneFCPath;
multipartToSinglepartTool.out_feature_class = joinPolygonFCPath;
gp.Execute(multipartToSinglepartTool, trackcancel);
// Add and calculate the time zone ID fields to the join polygons
addFieldTool = new AddField();
addFieldTool.in_table = joinPolygonFCPath;
addFieldTool.field_type = "SHORT";
addFieldTool.field_name = "FT_" + timeZoneIDBaseFieldName;
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_" + timeZoneIDBaseFieldName;
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the FT_" + timeZoneIDBaseFieldName + " field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = joinPolygonFCPath;
calcFieldTool.field = "FT_" + timeZoneIDBaseFieldName;
calcFieldTool.expression = "[ORIG_FID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF_" + timeZoneIDBaseFieldName + " field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = joinPolygonFCPath;
calcFieldTool.field = "TF_" + timeZoneIDBaseFieldName;
calcFieldTool.expression = "[ORIG_FID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Delete the MSTIMEZONE and ORIG_FID fields from the join polygon FC
deleteFieldTool = new DeleteField();
deleteFieldTool.in_table = joinPolygonFCPath;
deleteFieldTool.drop_field = "MSTIMEZONE;ORIG_FID";
gp.Execute(deleteFieldTool, trackcancel);
// Perform a spatial join between the Streets and the join polygons
AddMessage("Creating Streets feature class with time zone ID fields...", messages, trackcancel);
string outputStreetsFCPath = outputFileGdbPath + "\\" + StreetsFCName;
SpatialJoin spatialJoinTool = new SpatialJoin();
spatialJoinTool.target_features = pathToLocalNW;
spatialJoinTool.join_features = joinPolygonFCPath;
spatialJoinTool.out_feature_class = outputStreetsFCPath;
spatialJoinTool.match_option = "IS_WITHIN";
gp.Execute(spatialJoinTool, trackcancel);
// Delete the extraneous fields
deleteFieldTool = new DeleteField();
deleteFieldTool.in_table = outputStreetsFCPath;
deleteFieldTool.drop_field = "Join_Count;TARGET_FID;Shape_Length_1";
gp.Execute(deleteFieldTool, trackcancel);
// Delete the temporary NW and Join feature classes
deleteTool = new Delete();
deleteTool.in_data = pathToLocalNW;
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = joinPolygonFCPath;
gp.Execute(deleteTool, trackcancel);
// Extract the drive side information and index it
AddMessage("Extracting the drive side information...", messages, trackcancel);
string driveSideTablePath = outputFileGdbPath + "\\DriveSide";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputAETableValue.GetAsText();
tableSelectTool.out_table = driveSideTablePath;
tableSelectTool.where_clause = "ATTTYP = '3D'";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = driveSideTablePath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
// Add the DriveSide field and calculate it
addFieldTool = new AddField();
addFieldTool.in_table = adminFCPath;
addFieldTool.field_name = "DriveSide";
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = adminFCPath;
makeFeatureLayerTool.out_layer = "AdminFC_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "AdminFC_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = driveSideTablePath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying the drive side information to the Administrative Area feature class...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "AdminFC_Layer";
calcFieldTool.field = "AdminFC.DriveSide";
calcFieldTool.expression = "CInt( [DriveSide.ATTVALUE] )";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "AdminFC_Layer";
removeJoinTool.join_name = "DriveSide";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "AdminFC_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = driveSideTablePath;
gp.Execute(deleteTool, trackcancel);
// Extract out only the admin areas that have drive side information and index the ORDER00 field
AddMessage("Extracting Administrative Areas with drive side information...", messages, trackcancel);
string adminFCwDriveSidePath = outputFileGdbPath + "\\AdminFCwDriveSide";
selectTool = new Select();
selectTool.in_features = adminFCPath;
selectTool.out_feature_class = adminFCwDriveSidePath;
selectTool.where_clause = "NOT DriveSide IS NULL";
gp.Execute(selectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = adminFCwDriveSidePath;
addIndexTool.fields = "ORDER00";
addIndexTool.index_name = "ORDER00";
gp.Execute(addIndexTool, trackcancel);
// Add the DriveSide field to the AdminFCwTZ feature class and calculate it.
addFieldTool = new AddField();
addFieldTool.in_table = adminTZFCPath;
addFieldTool.field_name = "DriveSide";
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = adminTZFCPath;
makeFeatureLayerTool.out_layer = "AdminFCwTZ_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "AdminFCwTZ_Layer";
addJoinTool.in_field = "ORDER00";
addJoinTool.join_table = adminFCwDriveSidePath;
addJoinTool.join_field = "ORDER00";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the DriveSide field on the AdminFCwTZ feature class...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "AdminFCwTZ_Layer";
calcFieldTool.field = "AdminFCwTZ.DriveSide";
calcFieldTool.expression = "[AdminFCwDriveSide.DriveSide]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "AdminFCwTZ_Layer";
removeJoinTool.join_name = "AdminFCwDriveSide";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "AdminFCwTZ_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = adminFCwDriveSidePath;
gp.Execute(deleteTool, trackcancel);
// Extract the information for boundary roads
AddMessage("Extracting the information for boundary roads...", messages, trackcancel);
string taTablePath = outputFileGdbPath + "\\TA";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputTATableValue.GetAsText();
tableSelectTool.out_table = taTablePath;
tableSelectTool.where_clause = "ARETYP <= 1120 AND SOL > 0";
gp.Execute(tableSelectTool, trackcancel);
// Join the boundary road information with the AdminFCwTZ feature class to
// create the FT_BoundaryTimeZones and TF_BoundaryTimeZones join tables
addIndexTool = new AddIndex();
addIndexTool.in_table = adminTZFCPath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
MakeTableView makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = taTablePath;
makeTableViewTool.out_view = "TA_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "TA_View";
addJoinTool.in_field = "AREID";
addJoinTool.join_table = adminTZFCPath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Extracting the boundary FT time zones...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = "TA_View";
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "FT_BoundaryTimeZones";
importTableTool.where_clause = "TA.SOL = AdminFCwTZ.DriveSide";
importTableTool.field_mapping = "ID \"ID\" true true false 8 Double 0 0 ,First,#," + taTablePath + ",TA.ID,-1,-1;" +
"SortableMSTIMEZONE \"SortableMSTIMEZONE\" true true false 60 Text 0 0 ,First,#," +
adminTZFCPath + ",AdminFCwTZ.SortableMSTIMEZONE,-1,-1";
gp.Execute(importTableTool, trackcancel);
string ftBoundaryTimeZonesPath = outputFileGdbPath + "\\FT_BoundaryTimeZones";
addIndexTool = new AddIndex();
addIndexTool.in_table = ftBoundaryTimeZonesPath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
AddMessage("Extracting the boundary TF time zones...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = "TA_View";
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "TF_BoundaryTimeZones";
importTableTool.where_clause = "TA.SOL <> AdminFCwTZ.DriveSide";
importTableTool.field_mapping = "ID \"ID\" true true false 8 Double 0 0 ,First,#," + taTablePath + ",TA.ID,-1,-1;" +
"SortableMSTIMEZONE \"SortableMSTIMEZONE\" true true false 60 Text 0 0 ,First,#," +
adminTZFCPath + ",AdminFCwTZ.SortableMSTIMEZONE,-1,-1";
gp.Execute(importTableTool, trackcancel);
string tfBoundaryTimeZonesPath = outputFileGdbPath + "\\TF_BoundaryTimeZones";
addIndexTool = new AddIndex();
addIndexTool.in_table = tfBoundaryTimeZonesPath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "TA_View";
removeJoinTool.join_name = "AdminFCwTZ";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "TA_View";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = taTablePath;
gp.Execute(deleteTool, trackcancel);
// Calculate the boundary time zone ID values
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = outputStreetsFCPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = ftBoundaryTimeZonesPath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the boundary FT time zones...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".FT_" + timeZoneIDBaseFieldName;
calcFieldTool.code_block = TimeZoneUtilities.MakeTimeZoneIDCode(outputFileGdbPath, TimeZonesTableName, "FT_BoundaryTimeZones.SortableMSTIMEZONE");
calcFieldTool.expression = "tzID";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "FT_BoundaryTimeZones";
gp.Execute(removeJoinTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = tfBoundaryTimeZonesPath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the boundary TF time zones...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".TF_" + timeZoneIDBaseFieldName;
calcFieldTool.code_block = TimeZoneUtilities.MakeTimeZoneIDCode(outputFileGdbPath, TimeZonesTableName, "TF_BoundaryTimeZones.SortableMSTIMEZONE");
calcFieldTool.expression = "tzID";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "TF_BoundaryTimeZones";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = ftBoundaryTimeZonesPath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = tfBoundaryTimeZonesPath;
gp.Execute(deleteTool, trackcancel);
}
else
{
// Create a dummy TimeZones table and a dummy Streets feature class
CreateTable createTableTool = new CreateTable();
createTableTool.out_path = outputFileGdbPath;
createTableTool.out_name = TimeZonesTableName;
gp.Execute(createTableTool, trackcancel);
CreateFeatureclass createFCTool = new CreateFeatureclass();
createFCTool.out_path = outputFileGdbPath;
createFCTool.out_name = StreetsFCName;
createFCTool.geometry_type = "POLYLINE";
gp.Execute(createFCTool, trackcancel);
}
deleteTool = new Delete();
deleteTool.in_data = adminFCPath;
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = adminTZFCPath;
gp.Execute(deleteTool, trackcancel);
// Compact the output file geodatabase
AddMessage("Compacting the output file geodatabase...", messages, trackcancel);
Compact compactTool = new Compact();
compactTool.in_workspace = outputFileGdbPath;
gp.Execute(compactTool, trackcancel);
}
catch (Exception e)
{
if (gp.MaxSeverity == 2)
{
object missing = System.Type.Missing;
messages.AddError(1, gp.GetMessages(ref missing));
}
messages.AddError(1, e.Message);
messages.AddError(1, e.StackTrace);
}
finally
{
// Restore the original GP environment settings
gpSettings.AddOutputsToMap = origAddOutputsToMapSetting;
gpSettings.LogHistory = origLogHistorySetting;
}
GC.Collect();
return;
}
public void Execute(IArray paramvalues, ITrackCancel trackcancel,
IGPEnvironmentManager envMgr, IGPMessages messages)
{
// Remember the original GP environment settings and temporarily override these settings
var gpSettings = envMgr as IGeoProcessorSettings;
bool origAddOutputsToMapSetting = gpSettings.AddOutputsToMap;
bool origLogHistorySetting = gpSettings.LogHistory;
gpSettings.AddOutputsToMap = false;
gpSettings.LogHistory = false;
// Create the Geoprocessor
Geoprocessor gp = new Geoprocessor();
try
{
// Validate our values
IGPMessages validateMessages = ((IGPFunction2)this).Validate(paramvalues, false, envMgr);
if ((validateMessages as IGPMessage).IsError())
{
messages.AddError(1, "Validate failed");
return;
}
// Unpack values
IGPParameter gpParam = paramvalues.get_Element(InputNWFeatureClass) as IGPParameter;
IGPValue inputNWFeatureClassValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputMNFeatureClass) as IGPParameter;
IGPValue inputMNFeatureClassValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputMPTable) as IGPParameter;
IGPValue inputMPTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputSITable) as IGPParameter;
IGPValue inputSITableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputSPTable) as IGPParameter;
IGPValue inputSPTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(OutputFileGDB) as IGPParameter;
IGPValue outputFileGDBValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(OutputFileGDBVersion) as IGPParameter;
IGPValue outputFileGDBVersionValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputFeatureDatasetName) as IGPParameter;
IGPValue inputFeatureDatasetNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputNetworkDatasetName) as IGPParameter;
IGPValue inputNetworkDatasetNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputCreateNetworkAttributesInMetric) as IGPParameter;
IGPValue inputCreateNetworkAttributeInMetricValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputCreateTwoDistanceAttributes) as IGPParameter;
IGPValue inputCreateTwoDistanceAttributesValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputRSTable) as IGPParameter;
IGPValue inputRSTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTimeZoneIDBaseFieldName) as IGPParameter;
IGPValue inputTimeZoneIDBaseFieldNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTimeZoneTable) as IGPParameter;
IGPValue inputTimeZoneTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputCommonTimeZoneForTheEntireDataset) as IGPParameter;
IGPValue inputCommonTimeZoneForTheEntireDatasetValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputHSNPTable) as IGPParameter;
IGPValue inputHSNPTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputHSPRTable) as IGPParameter;
IGPValue inputHSPRTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputRDTable) as IGPParameter;
IGPValue inputRDTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedFolder) as IGPParameter;
IGPValue inputLiveTrafficFeedFolderValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedArcGISServerConnection) as IGPParameter;
IGPValue inputLiveTrafficFeedArcGISServerConnectionValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedGeoprocessingServiceName) as IGPParameter;
IGPValue inputLiveTrafficFeedGeoprocessingServiceNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedGeoprocessingTaskName) as IGPParameter;
IGPValue inputLiveTrafficFeedGeoprocessingTaskNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLTRTable) as IGPParameter;
IGPValue inputLTRTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLRSTable) as IGPParameter;
IGPValue inputLRSTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLVCTable) as IGPParameter;
IGPValue inputLVCTableValue = m_gpUtils.UnpackGPValue(gpParam);
double fgdbVersion = 0.0;
if (!(outputFileGDBVersionValue.IsEmpty()))
fgdbVersion = Convert.ToDouble(outputFileGDBVersionValue.GetAsText(), System.Globalization.CultureInfo.InvariantCulture);
bool createNetworkAttributesInMetric = false;
if (!(inputCreateNetworkAttributeInMetricValue.IsEmpty()))
createNetworkAttributesInMetric = ((inputCreateNetworkAttributeInMetricValue.GetAsText()).ToUpper() == "TRUE");
bool createTwoDistanceAttributes = false;
if (!(inputCreateTwoDistanceAttributesValue.IsEmpty()))
createTwoDistanceAttributes = ((inputCreateTwoDistanceAttributesValue.GetAsText()).ToUpper() == "TRUE");
if (inputTimeZoneIDBaseFieldNameValue.IsEmpty() ^ inputTimeZoneTableValue.IsEmpty())
{
messages.AddError(1, "The Time Zone ID Base Field Name and the Time Zone Table must be specified together.");
return;
}
string timeZoneIDBaseFieldName = "";
bool directedTimeZoneIDFields = false;
if (!(inputTimeZoneIDBaseFieldNameValue.IsEmpty()))
{
timeZoneIDBaseFieldName = inputTimeZoneIDBaseFieldNameValue.GetAsText();
IDETable inputTable = m_gpUtils.DecodeDETable(inputNWFeatureClassValue);
if (inputTable.Fields.FindField(timeZoneIDBaseFieldName) == -1)
{
directedTimeZoneIDFields = true;
if (((inputTable.Fields.FindField("FT_" + timeZoneIDBaseFieldName) == -1) || (inputTable.Fields.FindField("TF_" + timeZoneIDBaseFieldName) == -1)))
{
messages.AddError(1, "Field named " + timeZoneIDBaseFieldName + " does not exist, nor the pair of fields with FT_ and TF_ prefixing " + timeZoneIDBaseFieldName + " does not exist.");
return;
}
}
}
string commonTimeZone = "";
if (!(inputCommonTimeZoneForTheEntireDatasetValue.IsEmpty()))
commonTimeZone = inputCommonTimeZoneForTheEntireDatasetValue.GetAsText();
if (inputHSNPTableValue.IsEmpty() ^ inputHSPRTableValue.IsEmpty())
{
messages.AddError(1, "The HSNP and HSPR tables must be specified together.");
return;
}
bool agsConnectionIsEmpty = inputLiveTrafficFeedArcGISServerConnectionValue.IsEmpty();
bool gpServiceNameIsEmpty = inputLiveTrafficFeedGeoprocessingServiceNameValue.IsEmpty();
bool gpTaskNameIsEmpty = inputLiveTrafficFeedGeoprocessingTaskNameValue.IsEmpty();
if ((agsConnectionIsEmpty | gpServiceNameIsEmpty | gpTaskNameIsEmpty) ^
(agsConnectionIsEmpty & gpServiceNameIsEmpty & gpTaskNameIsEmpty))
{
messages.AddError(1, "The ArcGIS Server Connection, Geoprocessing Service Name, and Geoprocessing Task Name must all be specified together.");
return;
}
bool feedFolderIsEmpty = inputLiveTrafficFeedFolderValue.IsEmpty();
if (!(feedFolderIsEmpty | agsConnectionIsEmpty))
{
messages.AddError(1, "The live traffic feed folder and live traffic feed connection cannot be specified together.");
return;
}
bool usesLiveTraffic = !(inputRDTableValue.IsEmpty());
if (!usesLiveTraffic ^ (feedFolderIsEmpty & agsConnectionIsEmpty))
{
messages.AddError(1, "The RD table and live traffic feed folder or connection must be specified together.");
return;
}
ITrafficFeedLocation trafficFeedLocation = null;
if (usesLiveTraffic)
{
if (feedFolderIsEmpty)
{
// We're using an ArcGIS Server Connection and Geoprocessing Service/Task
ITrafficFeedGPService tfgps = new TrafficFeedGPServiceClass();
IName trafficFeedGPServiceName = m_gpUtils.GetNameObject(inputLiveTrafficFeedArcGISServerConnectionValue as IDataElement);
tfgps.ConnectionProperties = ((IAGSServerConnectionName)trafficFeedGPServiceName).ConnectionProperties;
tfgps.ServiceName = inputLiveTrafficFeedGeoprocessingServiceNameValue.GetAsText();
tfgps.TaskName = inputLiveTrafficFeedGeoprocessingTaskNameValue.GetAsText();
trafficFeedLocation = tfgps as ITrafficFeedLocation;
}
else
{
// We're using a Traffic Feed Folder
ITrafficFeedDirectory tfd = new TrafficFeedDirectoryClass();
tfd.TrafficDirectory = inputLiveTrafficFeedFolderValue.GetAsText();
trafficFeedLocation = tfd as ITrafficFeedLocation;
}
}
if (inputLRSTableValue.IsEmpty() ^ inputLVCTableValue.IsEmpty())
{
messages.AddError(1, "The LRS and LVC tables must be specified together.");
return;
}
// Get the path to the output file GDB, and feature dataset and network dataset names
string outputFileGdbPath = outputFileGDBValue.GetAsText();
string fdsName = inputFeatureDatasetNameValue.GetAsText();
string ndsName = inputNetworkDatasetNameValue.GetAsText();
// Create the new file geodatabase and feature dataset
AddMessage("Creating the file geodatabase and feature dataset...", messages, trackcancel);
int lastBackslash = outputFileGdbPath.LastIndexOf("\\");
CreateFileGDB createFGDBTool = new CreateFileGDB();
createFGDBTool.out_folder_path = outputFileGdbPath.Remove(lastBackslash);
createFGDBTool.out_name = outputFileGdbPath.Substring(lastBackslash + 1);
createFGDBTool.out_version = "9.3";
gp.Execute(createFGDBTool, trackcancel);
CreateFeatureDataset createFDSTool = new CreateFeatureDataset();
createFDSTool.out_dataset_path = outputFileGdbPath;
createFDSTool.out_name = fdsName;
createFDSTool.spatial_reference = inputNWFeatureClassValue.GetAsText();
gp.Execute(createFDSTool, trackcancel);
// Import the NW feature class to the file geodatabase
// If we're using ArcInfo, also sort the feature class
MakeFeatureLayer makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = inputNWFeatureClassValue.GetAsText();
makeFeatureLayerTool.out_layer = "nw_Layer";
makeFeatureLayerTool.where_clause = "FEATTYP <> 4165";
gp.Execute(makeFeatureLayerTool, trackcancel);
string pathToFds = outputFileGdbPath + "\\" + fdsName;
string streetsFeatureClassPath = pathToFds + "\\" + StreetsFCName;
FeatureClassToFeatureClass importFCTool = null;
IAoInitialize aoi = new AoInitializeClass();
if (aoi.InitializedProduct() == esriLicenseProductCode.esriLicenseProductCodeAdvanced)
{
AddMessage("Importing and spatially sorting the Streets feature class...", messages, trackcancel);
Sort sortTool = new Sort();
sortTool.in_dataset = "nw_Layer";
sortTool.out_dataset = streetsFeatureClassPath;
sortTool.sort_field = "Shape";
sortTool.spatial_sort_method = "PEANO";
gp.Execute(sortTool, trackcancel);
}
else
{
AddMessage("Importing the Streets feature class...", messages, trackcancel);
importFCTool = new FeatureClassToFeatureClass();
importFCTool.in_features = "nw_Layer";
importFCTool.out_path = pathToFds;
importFCTool.out_name = StreetsFCName;
gp.Execute(importFCTool, trackcancel);
}
Delete deleteTool = new Delete();
deleteTool.in_data = "nw_Layer";
gp.Execute(deleteTool, trackcancel);
// Add an index to the Streets feature class's ID field
AddMessage("Indexing the ID field...", messages, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.in_table = streetsFeatureClassPath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
// Copy the time zones table to the file geodatabase
TableToTable importTableTool = null;
if (timeZoneIDBaseFieldName != "")
{
AddMessage("Copying the TimeZones table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputTimeZoneTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "TimeZones";
gp.Execute(importTableTool, trackcancel);
}
// Initialize common variables that will be used for both
// processing historical traffic and maneuvers
AddField addFieldTool = null;
AddJoin addJoinTool = null;
RemoveJoin removeJoinTool = null;
CalculateField calcFieldTool = null;
TableSelect tableSelectTool = null;
MakeTableView makeTableViewTool = null;
#region Process Historical Traffic Tables
bool usesHistoricalTraffic = false;
if (!(inputHSNPTableValue.IsEmpty()))
{
usesHistoricalTraffic = true;
// Add fields for the weekday/weekend/all-week averages to the Streets feature class
AddMessage("Creating fields for the weekday/weekend/all-week averages...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "SHORT";
addFieldTool.field_name = "FT_Weekday";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_Weekday";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "FT_Weekend";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_Weekend";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "FT_AllWeek";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_AllWeek";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "FT_WeekdayMinutes";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_WeekdayMinutes";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "FT_WeekendMinutes";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_WeekendMinutes";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "FT_AllWeekMinutes";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_AllWeekMinutes";
gp.Execute(addFieldTool, trackcancel);
// Separate out the FT and TF speeds into separate tables and index the NETWORK_ID fields
AddMessage("Extracting speed information...", messages, trackcancel);
string FTSpeedsTablePath = outputFileGdbPath + "\\FT_Speeds";
string TFSpeedsTablePath = outputFileGdbPath + "\\TF_Speeds";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputHSNPTableValue.GetAsText();
tableSelectTool.out_table = FTSpeedsTablePath;
tableSelectTool.where_clause = "VAL_DIR = 2";
gp.Execute(tableSelectTool, trackcancel);
tableSelectTool.out_table = TFSpeedsTablePath;
tableSelectTool.where_clause = "VAL_DIR = 3";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = FTSpeedsTablePath;
addIndexTool.fields = "NETWORK_ID";
addIndexTool.index_name = "NETWORK_ID";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.in_table = TFSpeedsTablePath;
gp.Execute(addIndexTool, trackcancel);
// Calculate the speeds fields
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = FTSpeedsTablePath;
addJoinTool.join_field = "NETWORK_ID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying over the FT weekday speeds...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".FT_Weekday";
calcFieldTool.expression = "[FT_Speeds.SPWEEKDAY]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the FT weekend speeds...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".FT_Weekend";
calcFieldTool.expression = "[FT_Speeds.SPWEEKEND]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the FT all-week speeds...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".FT_AllWeek";
calcFieldTool.expression = "[FT_Speeds.SPWEEK]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "FT_Speeds";
gp.Execute(removeJoinTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = TFSpeedsTablePath;
addJoinTool.join_field = "NETWORK_ID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying over the TF weekday speeds...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".TF_Weekday";
calcFieldTool.expression = "[TF_Speeds.SPWEEKDAY]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the TF weekend speeds...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".TF_Weekend";
calcFieldTool.expression = "[TF_Speeds.SPWEEKEND]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the TF all-week speeds...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".TF_AllWeek";
calcFieldTool.expression = "[TF_Speeds.SPWEEK]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "TF_Speeds";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = FTSpeedsTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = TFSpeedsTablePath;
gp.Execute(deleteTool, trackcancel);
// Calculate the travel time fields
AddMessage("Calculating the FT weekday travel times...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = streetsFeatureClassPath;
calcFieldTool.field = "FT_WeekdayMinutes";
calcFieldTool.expression = "[METERS] * 0.06 / s";
calcFieldTool.code_block = "s = [FT_Weekday]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the FT weekend travel times...", messages, trackcancel);
calcFieldTool.field = "FT_WeekendMinutes";
calcFieldTool.expression = "[METERS] * 0.06 / s";
calcFieldTool.code_block = "s = [FT_Weekend]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the FT all-week travel times...", messages, trackcancel);
calcFieldTool.field = "FT_AllWeekMinutes";
calcFieldTool.expression = "[METERS] * 0.06 / s";
calcFieldTool.code_block = "s = [FT_AllWeek]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF weekday travel times...", messages, trackcancel);
calcFieldTool.field = "TF_WeekdayMinutes";
calcFieldTool.expression = "[METERS] * 0.06 / s";
calcFieldTool.code_block = "s = [TF_Weekday]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF weekend travel times...", messages, trackcancel);
calcFieldTool.field = "TF_WeekendMinutes";
calcFieldTool.expression = "[METERS] * 0.06 / s";
calcFieldTool.code_block = "s = [TF_Weekend]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF all-week travel times...", messages, trackcancel);
calcFieldTool.field = "TF_AllWeekMinutes";
calcFieldTool.expression = "[METERS] * 0.06 / s";
calcFieldTool.code_block = "s = [TF_AllWeek]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Create the DailyProfiles table
AddMessage("Creating the profiles table...", messages, trackcancel);
CreateDailyProfilesTable(m_gpUtils.OpenDataset(inputHSPRTableValue) as ITable, outputFileGdbPath, fgdbVersion);
// Copy over the historical traffic records of the HSNP table to the file geodatabase
AddMessage("Copying HSNP table to the file geodatabase...", messages, trackcancel);
string histTrafficJoinTablePath = outputFileGdbPath + "\\" + HistTrafficJoinTableName;
tableSelectTool.out_table = histTrafficJoinTablePath;
tableSelectTool.where_clause = "SPFREEFLOW > 0";
gp.Execute(tableSelectTool, trackcancel);
// Add FCID, FID, and position fields to the Streets_DailyProfiles table
AddMessage("Creating fields on the historical traffic join table...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = histTrafficJoinTablePath;
addFieldTool.field_type = "LONG";
addFieldTool.field_name = "EdgeFCID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeFID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "EdgeFrmPos";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeToPos";
gp.Execute(addFieldTool, trackcancel);
// If we're creating 10.0, then also create the FreeflowMinutes field
if (fgdbVersion == 10.0)
{
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "FreeflowMinutes";
gp.Execute(addFieldTool, trackcancel);
}
// Calculate the fields
AddMessage("Calculating the EdgeFrmPos field for historical traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = "EdgeFrmPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = "Select Case [VAL_DIR]\n Case 2: x = 0\n Case 3: x = 1\nEnd Select";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeToPos field for historical traffic...", messages, trackcancel);
calcFieldTool.field = "EdgeToPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = "Select Case [VAL_DIR]\n Case 2: x = 1\n Case 3: x = 0\nEnd Select";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFCID field for historical traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = "EdgeFCID";
calcFieldTool.expression = "1";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFID field for historical traffic...", messages, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = histTrafficJoinTablePath;
makeTableViewTool.out_view = "Streets_DailyProfiles_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_DailyProfiles_View";
addJoinTool.in_field = "NETWORK_ID";
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "ID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_DailyProfiles_View";
calcFieldTool.field = HistTrafficJoinTableName + ".EdgeFID";
calcFieldTool.expression = "[" + StreetsFCName + ".OBJECTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
if (fgdbVersion == 10.0)
{
AddMessage("Calculating the FreeflowMinutes field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_DailyProfiles_View";
calcFieldTool.field = HistTrafficJoinTableName + ".FreeflowMinutes";
calcFieldTool.expression = "[" + StreetsFCName + ".METERS] * 0.06 / [" + HistTrafficJoinTableName + ".SPFREEFLOW]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_DailyProfiles_View";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_DailyProfiles_View";
gp.Execute(deleteTool, trackcancel);
// Add an index to the Streets feature class's NET2CLASS field
AddMessage("Indexing the NET2CLASS field...", messages, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = streetsFeatureClassPath;
addIndexTool.fields = "NET2CLASS";
addIndexTool.index_name = "NET2CLASS";
gp.Execute(addIndexTool, trackcancel);
}
#endregion
#region Process Live Traffic Table
if (usesLiveTraffic)
{
// Copy the RD table to the file geodatabase
AddMessage("Creating the live traffic join table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputRDTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = TMCJoinTableName;
gp.Execute(importTableTool, trackcancel);
string TMCJoinTablePath = outputFileGdbPath + "\\" + TMCJoinTableName;
// Add FCID, FID, position, and TMC fields to the Streets_TMC table
AddMessage("Creating fields on the live traffic join table...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = TMCJoinTablePath;
addFieldTool.field_type = "LONG";
addFieldTool.field_name = "EdgeFCID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeFID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "EdgeFrmPos";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeToPos";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 9;
addFieldTool.field_name = "TMC";
gp.Execute(addFieldTool, trackcancel);
// Calculate the fields
AddMessage("Calculating the TMC field for live traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = TMCJoinTablePath;
calcFieldTool.field = "TMC";
calcFieldTool.expression = "Right([RDSTMC], 9)";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFrmPos field for live traffic...", messages, trackcancel);
calcFieldTool.field = "EdgeFrmPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = "Select Case Left([RDSTMC], 1)\n Case \"+\": x = 0\n Case \"-\": x = 1\nEnd Select";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeToPos field for live traffic...", messages, trackcancel);
calcFieldTool.field = "EdgeToPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = "Select Case Left([RDSTMC], 1)\n Case \"-\": x = 0\n Case \"+\": x = 1\nEnd Select";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFCID field for live traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = TMCJoinTablePath;
calcFieldTool.field = "EdgeFCID";
calcFieldTool.expression = "1";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFID field for live traffic...", messages, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = TMCJoinTablePath;
makeTableViewTool.out_view = "Streets_TMC_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_TMC_View";
addJoinTool.in_field = "ID";
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "ID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_TMC_View";
calcFieldTool.field = TMCJoinTableName + ".EdgeFID";
calcFieldTool.expression = "[" + StreetsFCName + ".OBJECTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_TMC_View";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_TMC_View";
gp.Execute(deleteTool, trackcancel);
// If Historical Traffic is not being used, then we need to create placeholder historical traffic tables
if (!usesHistoricalTraffic)
{
// Create the Streets_DailyProfiles table by starting with a copy of the Streets_TMC table
AddMessage("Creating the historical traffic join table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = TMCJoinTablePath;
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = HistTrafficJoinTableName;
gp.Execute(importTableTool, trackcancel);
string histTrafficJoinTablePath = outputFileGdbPath + "\\" + HistTrafficJoinTableName;
AddMessage("Creating and calculating the KPH field on the historical traffic join table...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = histTrafficJoinTablePath;
addFieldTool.field_type = "SHORT";
addFieldTool.field_name = "KPH";
gp.Execute(addFieldTool, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = histTrafficJoinTablePath;
makeTableViewTool.out_view = "Streets_DailyProfiles_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_DailyProfiles_View";
addJoinTool.in_field = "EdgeFID";
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "OBJECTID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_DailyProfiles_View";
calcFieldTool.field = HistTrafficJoinTableName + ".KPH";
calcFieldTool.expression = "[" + StreetsFCName + ".KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_DailyProfiles_View";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_DailyProfiles_View";
gp.Execute(deleteTool, trackcancel);
AddMessage("Creating and calculating the PROFILE fields on the historical traffic join table...", messages, trackcancel);
for (int i = 1; i <= 7; i++)
{
string fieldName = "PROFILE_" + Convert.ToString(i, System.Globalization.CultureInfo.InvariantCulture);
addFieldTool = new AddField();
addFieldTool.in_table = histTrafficJoinTablePath;
addFieldTool.field_type = "SHORT";
addFieldTool.field_name = fieldName;
gp.Execute(addFieldTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = fieldName;
calcFieldTool.expression = "1";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
// Create the Profiles table
CreateNonHistoricalDailyProfilesTable(outputFileGdbPath);
}
}
#endregion
// Copy the MN feature class to the file geodatabase
AddMessage("Copying the Maneuvers feature class and indexing...", messages, trackcancel);
importFCTool = new FeatureClassToFeatureClass();
importFCTool.in_features = inputMNFeatureClassValue.GetAsText();
importFCTool.out_path = outputFileGdbPath;
importFCTool.out_name = "mn";
gp.Execute(importFCTool, trackcancel);
string mnFeatureClassPath = outputFileGdbPath + "\\mn";
addIndexTool = new AddIndex();
addIndexTool.in_table = mnFeatureClassPath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
// Copy the MP table to the file geodatabase
AddMessage("Copying the Maneuver Path table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputMPTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "mp";
gp.Execute(importTableTool, trackcancel);
string mpTablePath = outputFileGdbPath + "\\mp";
// Add and calculate the at junction and feature type fields to the MP table
AddMessage("Creating and calculating fields for the maneuver types and at junctions...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = mpTablePath;
addFieldTool.field_name = "JNCTID";
addFieldTool.field_type = "DOUBLE";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "FEATTYP";
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = mpTablePath;
makeTableViewTool.out_view = "mp_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "mp_View";
addJoinTool.in_field = "ID";
addJoinTool.join_table = mnFeatureClassPath;
addJoinTool.join_field = "ID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "mp_View";
calcFieldTool.field = "mp.JNCTID";
calcFieldTool.expression = "[mn.JNCTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
calcFieldTool.field = "mp.FEATTYP";
calcFieldTool.expression = "[mn.FEATTYP]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "mp_View";
removeJoinTool.join_name = "mn";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "mp_View";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = mnFeatureClassPath;
gp.Execute(deleteTool, trackcancel);
// Extract only the prohibited maneuvers (feature types 2103 and 2101)
AddMessage("Extracting prohibited maneuvers...", messages, trackcancel);
string prohibMPwJnctIDTablePath = outputFileGdbPath + "\\ProhibMPwJnctID";
string tempTablePath = outputFileGdbPath + "\\TempTable";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = mpTablePath;
tableSelectTool.out_table = prohibMPwJnctIDTablePath;
tableSelectTool.where_clause = "FEATTYP = 2103";
gp.Execute(tableSelectTool, trackcancel);
tableSelectTool.out_table = tempTablePath;
tableSelectTool.where_clause = "FEATTYP = 2101";
gp.Execute(tableSelectTool, trackcancel);
Append appendTool = new Append();
appendTool.inputs = tempTablePath;
appendTool.target = prohibMPwJnctIDTablePath;
appendTool.schema_type = "TEST";
gp.Execute(appendTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = tempTablePath;
gp.Execute(deleteTool, trackcancel);
AddMessage("Creating turn feature class...", messages, trackcancel);
// Create the turn feature class
string tempStatsTablePath = outputFileGdbPath + "\\tempStatsTable";
Statistics statsTool = new Statistics();
statsTool.in_table = prohibMPwJnctIDTablePath;
statsTool.out_table = tempStatsTablePath;
statsTool.statistics_fields = "SEQNR MAX";
gp.Execute(statsTool, null);
CreateAndPopulateTurnFeatureClass(outputFileGdbPath, fdsName, "ProhibMPwJnctID", "tempStatsTable",
messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = tempStatsTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = prohibMPwJnctIDTablePath;
gp.Execute(deleteTool, trackcancel);
GC.Collect();
// Extract the bifurcations (feature type 9401)
AddMessage("Extracting bifurcations...", messages, trackcancel);
string bifurcationMPwJnctIDTablePath = outputFileGdbPath + "\\BifurcationMPwJnctID";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = mpTablePath;
tableSelectTool.out_table = bifurcationMPwJnctIDTablePath;
tableSelectTool.where_clause = "FEATTYP = 9401";
gp.Execute(tableSelectTool, trackcancel);
deleteTool.in_data = mpTablePath;
gp.Execute(deleteTool, trackcancel);
// Add and calculate the StreetsOID and the from-/to-junction ID fields to the MP table
AddMessage("Creating and calculating fields for the StreetsOID and the from-/to-junction IDs...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = bifurcationMPwJnctIDTablePath;
addFieldTool.field_type = "LONG";
addFieldTool.field_name = "StreetsOID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "F_JNCTID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "T_JNCTID";
gp.Execute(addFieldTool, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = bifurcationMPwJnctIDTablePath;
makeTableViewTool.out_view = "bifurcationMP_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "bifurcationMP_View";
addJoinTool.in_field = "TRPELID";
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "ID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "bifurcationMP_View";
calcFieldTool.field = "BifurcationMPwJnctID.StreetsOID";
calcFieldTool.expression = "[Streets.OBJECTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
calcFieldTool.field = "BifurcationMPwJnctID.F_JNCTID";
calcFieldTool.expression = "[Streets.F_JNCTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
calcFieldTool.field = "BifurcationMPwJnctID.T_JNCTID";
calcFieldTool.expression = "[Streets.T_JNCTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "bifurcationMP_View";
removeJoinTool.join_name = "Streets";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "bifurcationMP_View";
gp.Execute(deleteTool, trackcancel);
AddMessage("Creating RoadSplits table...", messages, trackcancel);
// Create the RoadSplits table
CreateAndPopulateRoadSplitsTable(outputFileGdbPath, "BifurcationMPwJnctID", messages, trackcancel);
deleteTool.in_data = bifurcationMPwJnctIDTablePath;
gp.Execute(deleteTool, trackcancel);
GC.Collect();
#region Process Restrictions Table
bool usesRSTable = false;
if (!(inputRSTableValue.IsEmpty()))
{
usesRSTable = true;
// Extract the information from the Restrictions table
AddMessage("Extracting information from the Restrictions table...", messages, trackcancel);
string rsTablePath = outputFileGdbPath + "\\rs";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputRSTableValue.GetAsText();
tableSelectTool.out_table = rsTablePath;
tableSelectTool.where_clause = "RESTRTYP = 'DF' OR FEATTYP IN (2101, 2103)";
gp.Execute(tableSelectTool, trackcancel);
// Create and populate fields for the Streets
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "FT_AllVehicles_Restricted",
"DIR_POS IN (1, 2) AND VT = 0", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "TF_AllVehicles_Restricted",
"DIR_POS IN (1, 3) AND VT = 0", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "FT_PassengerCars_Restricted",
"DIR_POS IN (1, 2) AND VT = 11", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "TF_PassengerCars_Restricted",
"DIR_POS IN (1, 3) AND VT = 11", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "FT_ResidentialVehicles_Restricted",
"DIR_POS IN (1, 2) AND VT = 12", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "TF_ResidentialVehicles_Restricted",
"DIR_POS IN (1, 3) AND VT = 12", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "FT_Taxis_Restricted",
"DIR_POS IN (1, 2) AND VT = 16", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "TF_Taxis_Restricted",
"DIR_POS IN (1, 3) AND VT = 16", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "FT_PublicBuses_Restricted",
"DIR_POS IN (1, 2) AND VT = 17", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, false, "TF_PublicBuses_Restricted",
"DIR_POS IN (1, 3) AND VT = 17", gp, messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
// Create and populate fields for the RestrictedTurns
string pathToTurnFC = pathToFds + "\\" + TurnFCName;
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = pathToTurnFC;
makeFeatureLayerTool.out_layer = "RestrictedTurns_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, true, "AllVehicles_Restricted", "VT = 0 OR RESTRTYP = '8I'", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, true, "PassengerCars_Restricted", "VT = 11", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, true, "ResidentialVehicles_Restricted", "VT = 12", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, true, "Taxis_Restricted", "VT = 16", gp, messages, trackcancel);
CreateAndPopulateRSField(outputFileGdbPath, true, "PublicBuses_Restricted", "VT = 17", gp, messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "RestrictedTurns_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = rsTablePath;
gp.Execute(deleteTool, trackcancel);
}
#endregion
#region Process Logistics Truck Routes Table
bool usesLTRTable = false;
if (!(inputLTRTableValue.IsEmpty()))
{
usesLTRTable = true;
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
if (fgdbVersion >= 10.1)
{
CreateAndPopulateLTRField(outputFileGdbPath, inputLTRTableValue.GetAsText(),
"NationalSTAARoute", "PREFERRED = 1", gp, messages, trackcancel);
CreateAndPopulateLTRField(outputFileGdbPath, inputLTRTableValue.GetAsText(),
"NationalRouteAccess", "PREFERRED = 2", gp, messages, trackcancel);
CreateAndPopulateLTRField(outputFileGdbPath, inputLTRTableValue.GetAsText(),
"DesignatedTruckRoute", "PREFERRED = 3", gp, messages, trackcancel);
CreateAndPopulateLTRField(outputFileGdbPath, inputLTRTableValue.GetAsText(),
"TruckBypassRoad", "PREFERRED = 4", gp, messages, trackcancel);
}
CreateAndPopulateLTRField(outputFileGdbPath, inputLTRTableValue.GetAsText(),
"NoCommercialVehicles", "RESTRICTED = 1", gp, messages, trackcancel);
CreateAndPopulateLTRField(outputFileGdbPath, inputLTRTableValue.GetAsText(),
"ImmediateAccessOnly", "RESTRICTED = 2", gp, messages, trackcancel);
CreateAndPopulateLTRField(outputFileGdbPath, inputLTRTableValue.GetAsText(),
"TrucksRestricted", "RESTRICTED = 3", gp, messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
}
#endregion
#region Process Logistics Restrictions Table
bool usesLRSTable = false;
string lrsStatsTablePath = outputFileGdbPath + "\\lrs_Stats";
if (!(inputLRSTableValue.IsEmpty()))
{
usesLRSTable = true;
// Copy the LRS table to the file geodatabase
AddMessage("Copying the Logistics Restrictions (LRS) table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputLRSTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "lrs";
gp.Execute(importTableTool, trackcancel);
string lrsTablePath = outputFileGdbPath + "\\lrs";
// Copy the SUBSEQNR 1 rows of the LVC table to the file geodatabase
AddMessage("Copying the Logistics Vehicle Characteristics (LVC) table...", messages, trackcancel);
string lvcTablePath = outputFileGdbPath + "\\lvc";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputLVCTableValue.GetAsText();
tableSelectTool.out_table = lvcTablePath;
tableSelectTool.where_clause = "SUBSEQNR = 1";
gp.Execute(tableSelectTool, trackcancel);
// Add and calculate join fields on the LRS and LVC tables
addFieldTool = new AddField();
addFieldTool.field_name = "ID_SEQNR";
addFieldTool.field_length = 19;
addFieldTool.field_type = "TEXT";
addFieldTool.in_table = lrsTablePath;
gp.Execute(addFieldTool, trackcancel);
addFieldTool.in_table = lvcTablePath;
gp.Execute(addFieldTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.field = "ID_SEQNR";
calcFieldTool.expression = "[ID] & \".\" & [SEQNR]";
calcFieldTool.expression_type = "VB";
AddMessage("Calculating the join field on the LRS table...", messages, trackcancel);
calcFieldTool.in_table = lrsTablePath;
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the join field on the LVC table...", messages, trackcancel);
calcFieldTool.in_table = lvcTablePath;
gp.Execute(calcFieldTool, trackcancel);
// Index the join field on the LVC table
AddMessage("Indexing the join field...", messages, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = lvcTablePath;
addIndexTool.fields = "ID_SEQNR";
addIndexTool.index_name = "ID_SEQNR";
gp.Execute(addIndexTool, trackcancel);
// Join the LRS and LVC tables together, and only extract those rows from
// the LRS table that do not have an accompanying row in the LVC table
AddMessage("Simplifying the LRS table...", messages, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = lrsTablePath;
makeTableViewTool.out_view = "lrs_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "lrs_View";
addJoinTool.in_field = "ID_SEQNR";
addJoinTool.join_table = lvcTablePath;
addJoinTool.join_field = "ID_SEQNR";
gp.Execute(addJoinTool, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = "lrs_View";
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "lrs_simplified";
importTableTool.where_clause = "lvc.OBJECTID IS NULL";
importTableTool.field_mapping = "ID \"ID\" true true false 8 Double 0 0 ,First,#," + lrsTablePath + ",lrs.ID,-1,-1;" +
"SEQNR \"SEQNR\" true true false 2 Short 0 0 ,First,#," + lrsTablePath + ",lrs.SEQNR,-1,-1;" +
"FEATTYP \"FEATTYP\" true true false 2 Short 0 0 ,First,#," + lrsTablePath + ",lrs.FEATTYP,-1,-1;" +
"RESTRTYP \"RESTRTYP\" true true false 2 Text 0 0 ,First,#," + lrsTablePath + ",lrs.RESTRTYP,-1,-1;" +
"VT \"VT\" true true false 2 Short 0 0 ,First,#," + lrsTablePath + ",lrs.VT,-1,-1;" +
"RESTRVAL \"RESTRVAL\" true true false 2 Short 0 0 ,First,#," + lrsTablePath + ",lrs.RESTRVAL,-1,-1;" +
"LIMIT \"LIMIT\" true true false 8 Double 0 0 ,First,#," + lrsTablePath + ",lrs.LIMIT,-1,-1;" +
"UNIT_MEAS \"UNIT_MEAS\" true true false 2 Short 0 0 ,First,#," + lrsTablePath + ",lrs.UNIT_MEAS,-1,-1;" +
"LANE_VALID \"LANE_VALID\" true true false 20 Text 0 0 ,First,#," + lrsTablePath + ",lrs.LANE_VALID,-1,-1;" +
"VALDIRPOS \"VALDIRPOS\" true true false 2 Short 0 0 ,First,#," + lrsTablePath + ",lrs.VALDIRPOS,-1,-1;" +
"VERIFIED \"VERIFIED\" true true false 2 Short 0 0 ,First,#," + lrsTablePath + ",lrs.VERIFIED,-1,-1";
gp.Execute(importTableTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "lrs_View";
removeJoinTool.join_name = "lvc";
gp.Execute(removeJoinTool, trackcancel);
string lrsSimplifiedTablePath = outputFileGdbPath + "\\lrs_simplified";
deleteTool = new Delete();
deleteTool.in_data = "lrs_View";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = lrsTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = lvcTablePath;
gp.Execute(deleteTool, trackcancel);
// Get statistics on the simplified LRS table
AddMessage("Analyzing the LRS table...", messages, trackcancel);
statsTool = new Statistics();
statsTool.in_table = lrsSimplifiedTablePath;
statsTool.out_table = lrsStatsTablePath;
statsTool.statistics_fields = "ID COUNT";
statsTool.case_field = "RESTRTYP;VT;RESTRVAL";
gp.Execute(statsTool, trackcancel);
// Create and populate the logistics restriction fields
CreateAndPopulateLogisticsRestrictionFields(outputFileGdbPath, "lrs_Stats", lrsSimplifiedTablePath, gp, messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = lrsSimplifiedTablePath;
gp.Execute(deleteTool, trackcancel);
}
#endregion
GC.Collect();
// Create Signpost feature class and table
AddMessage("Creating signpost feature class and table...", messages, trackcancel);
CreateSignposts(inputSITableValue.GetAsText(), inputSPTableValue.GetAsText(), outputFileGdbPath,
messages, trackcancel);
AddSpatialIndex addSpatialIndexTool = new AddSpatialIndex();
addSpatialIndexTool.in_features = pathToFds + "\\" + SignpostFCName;
gp.Execute(addSpatialIndexTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = outputFileGdbPath + "\\" + SignpostJoinTableName;
addIndexTool.fields = "SignpostID";
addIndexTool.index_name = "SignpostID";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.fields = "Sequence";
addIndexTool.index_name = "Sequence";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.fields = "EdgeFCID";
addIndexTool.index_name = "EdgeFCID";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.fields = "EdgeFID";
addIndexTool.index_name = "EdgeFID";
gp.Execute(addIndexTool, trackcancel);
GC.Collect();
// Upgrade the geodatabase (if not 9.3)
if (fgdbVersion > 9.3)
{
UpgradeGDB upgradeGdbTool = new UpgradeGDB();
upgradeGdbTool.input_workspace = outputFileGdbPath;
gp.Execute(upgradeGdbTool, trackcancel);
}
// Create and build the network dataset, then pack it in a GPValue
AddMessage("Creating and building the network dataset...", messages, trackcancel);
CreateAndBuildNetworkDataset(outputFileGdbPath, fgdbVersion, fdsName, ndsName, createNetworkAttributesInMetric,
createTwoDistanceAttributes, timeZoneIDBaseFieldName, directedTimeZoneIDFields, commonTimeZone,
usesHistoricalTraffic, trafficFeedLocation, usesRSTable, usesLTRTable, usesLRSTable, "lrs_Stats");
// Once the network dataset is built, we can delete the stats table
if (usesLRSTable)
{
deleteTool = new Delete();
deleteTool.in_data = lrsStatsTablePath;
gp.Execute(deleteTool, trackcancel);
}
// Write the build errors to the turn feature class
TurnGeometryUtilities.WriteBuildErrorsToTurnFC(outputFileGdbPath, fdsName, TurnFCName, messages, trackcancel);
// Compact the output file geodatabase
AddMessage("Compacting the output file geodatabase...", messages, trackcancel);
Compact compactTool = new Compact();
compactTool.in_workspace = outputFileGdbPath;
gp.Execute(compactTool, trackcancel);
}
catch (Exception e)
{
if (gp.MaxSeverity == 2)
{
object missing = System.Type.Missing;
messages.AddError(1, gp.GetMessages(ref missing));
}
messages.AddError(1, e.Message);
messages.AddError(1, e.StackTrace);
}
finally
{
// Restore the original GP environment settings
gpSettings.AddOutputsToMap = origAddOutputsToMapSetting;
gpSettings.LogHistory = origLogHistorySetting;
}
GC.Collect();
return;
}
private void CreateAndPopulateDirectionalVehicleAccessFields(string baseFieldName, string streetsFeatureClassPath,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
AddMessage("Creating the FT_" + baseFieldName + " and TF_" + baseFieldName + " fields...", messages, trackcancel);
AddField addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
addFieldTool.field_name = "FT_" + baseFieldName;
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_" + baseFieldName;
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the FT_" + baseFieldName + " field...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = streetsFeatureClassPath;
calcFieldTool.field = "FT_" + baseFieldName;
calcFieldTool.code_block = "x = \"Y\"\nIf [DIR_TRAVEL] = \"T\" Or [" + baseFieldName + "] = \"N\" Then x = \"N\"";
calcFieldTool.expression = "x";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF_" + baseFieldName + " field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = streetsFeatureClassPath;
calcFieldTool.field = "TF_" + baseFieldName;
calcFieldTool.code_block = "x = \"Y\"\nIf [DIR_TRAVEL] = \"F\" Or [" + baseFieldName + "] = \"N\" Then x = \"N\"";
calcFieldTool.expression = "x";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
return;
}
//生成乡镇数据
private void mnuMakeXZQTown_Click(object sender, EventArgs e)
{
if (m_xzqLayer == null)
{
MessageBox.Show("请先加载XZQ数据。");
return;
}
string strXZQTownListPath = Application.StartupPath + "\\tempResult";
string strXZQTownListName = "XZQTownList.txt";
string filepath = strXZQTownListPath + "\\" + strXZQTownListName;
if (!File.Exists(filepath))
{
MessageBox.Show("乡镇对照文件不存在！");
return;
}
//先把XZQ数据拷贝到tempResult
string strOutputPath = Application.StartupPath + "\\tempResult";
string strOutputName = "xzqtown.shp";
IFeatureLayer pFeatLyr = m_xzqLayer as IFeatureLayer;
IFeatureClass pFeatCls = pFeatLyr.FeatureClass;
bool bSuccess = Function.saveFeatureClass(pFeatCls, strOutputPath);
if (!bSuccess)
{
MessageBox.Show("拷贝XZQ数据出错！");
return;
}
else
{
string shpSrcPath = strOutputPath + "\\" + "GPL0.shp";
Function.reNameShpFile(shpSrcPath, strOutputPath + "\\" + strOutputName);
}
//打开XZQTown.shp，增加字段XZQTDM，并填值
string strAddFieldName = "XZQTDM";
IFeatureClass fc_XZQTown = Function.OpenShpFile(strOutputPath, "xzqtown");
Function.AddFiled2Layer(ref fc_XZQTown, "XZQTMC", esriFieldType.esriFieldTypeString, 15);
bSuccess = Function.AddFiled2Layer(ref fc_XZQTown, strAddFieldName, esriFieldType.esriFieldTypeString, 9);
if (!bSuccess)
{
MessageBox.Show("添加XZQTDM字段出错！");
return;
}
//向下的代码没调通
CalculateField fieldcalc = new CalculateField();
fieldcalc.expression = "Left([XZQDM],9)";//可能这个写法不对
//fieldcalc.expression = "Left([XZQDM]";
fieldcalc.expression_type = "VBScript";
IField field = fc_XZQTown.Fields.get_Field(fc_XZQTown.Fields.FindField(strAddFieldName));
fieldcalc.field = field;
fieldcalc.in_table = fc_XZQTown;
Geoprocessor gp = new Geoprocessor();
gp.OverwriteOutput = true; //允许运算结果覆盖现有文件
gp.Execute(fieldcalc, null); //执行
//调用Dissolve工具，合并，数据生成到baseData文件夹
Dissolve dissolve = new Dissolve();
dissolve.in_features = fc_XZQTown;
dissolve.dissolve_field = field;
string shpPath = m_prjMan.m_projectPath + "\\" + m_prjMan.m_projectName + "\\" + ProjectManage.m_baseData;
dissolve.out_feature_class = shpPath + "\\xzqtown.shp";
dissolve.statistics_fields = "SUM([KZMJ],SUM[JSMJ],FIRST[XZQTMC]";
gp.Execute(dissolve, null);
MessageBox.Show("乡镇图层生成成功！");
}
public void Execute(IArray paramvalues, ITrackCancel trackcancel,
IGPEnvironmentManager envMgr, IGPMessages messages)
{
// Remember the original GP environment settings and temporarily override these settings
var gpSettings = envMgr as IGeoProcessorSettings;
bool origAddOutputsToMapSetting = gpSettings.AddOutputsToMap;
bool origLogHistorySetting = gpSettings.LogHistory;
gpSettings.AddOutputsToMap = false;
gpSettings.LogHistory = false;
// Create the Geoprocessor
Geoprocessor gp = new Geoprocessor();
try
{
// Validate our values
IGPMessages validateMessages = ((IGPFunction2)this).Validate(paramvalues, false, envMgr);
if ((validateMessages as IGPMessage).IsError())
{
messages.AddError(1, "Validate failed");
return;
}
// Unpack values
IGPParameter gpParam = paramvalues.get_Element(InputStreetsFeatureClass) as IGPParameter;
IGPValue inputStreetsFeatureClassValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputAltStreetsFeatureClass) as IGPParameter;
IGPValue inputAltStreetsFeatureClassValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputZLevelsFeatureClass) as IGPParameter;
IGPValue inputZLevelsFeatureClassValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputCdmsTable) as IGPParameter;
IGPValue inputCdmsTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputRdmsTable) as IGPParameter;
IGPValue inputRdmsTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputSignsTable) as IGPParameter;
IGPValue inputSignsTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(OutputFileGDB) as IGPParameter;
IGPValue outputFileGDBValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(OutputFileGDBVersion) as IGPParameter;
IGPValue outputFileGDBVersionValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputFeatureDatasetName) as IGPParameter;
IGPValue inputFeatureDatasetNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputNetworkDatasetName) as IGPParameter;
IGPValue inputNetworkDatasetNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputCreateNetworkAttributesInMetric) as IGPParameter;
IGPValue inputCreateNetworkAttributeInMetricValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputCreateArcGISOnlineNetworkAttributes) as IGPParameter;
IGPValue inputCreateArcGISOnlineNetworkAttributesValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTimeZoneIDBaseFieldName) as IGPParameter;
IGPValue inputTimeZoneIDBaseFieldNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTimeZoneTable) as IGPParameter;
IGPValue inputTimeZoneTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputCommonTimeZoneForTheEntireDataset) as IGPParameter;
IGPValue inputCommonTimeZoneForTheEntireDatasetValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTrafficTable) as IGPParameter;
IGPValue inputTrafficTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLinkReferenceFileFC14) as IGPParameter;
IGPValue inputLinkReferenceFileFC14Value = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLinkReferenceFileFC5) as IGPParameter;
IGPValue inputLinkReferenceFileFC5Value = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTMCReferenceFile) as IGPParameter;
IGPValue inputTMCReferenceFileValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputSPDFile) as IGPParameter;
IGPValue inputSPDFileValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedFolder) as IGPParameter;
IGPValue inputLiveTrafficFeedFolderValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedArcGISServerConnection) as IGPParameter;
IGPValue inputLiveTrafficFeedArcGISServerConnectionValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedGeoprocessingServiceName) as IGPParameter;
IGPValue inputLiveTrafficFeedGeoprocessingServiceNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputLiveTrafficFeedGeoprocessingTaskName) as IGPParameter;
IGPValue inputLiveTrafficFeedGeoprocessingTaskNameValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputUSCndModTable) as IGPParameter;
IGPValue inputUSCndModTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputNonUSCndModTable) as IGPParameter;
IGPValue inputNonUSCndModTableValue = m_gpUtils.UnpackGPValue(gpParam);
double fgdbVersion = 0.0;
if (!(outputFileGDBVersionValue.IsEmpty()))
fgdbVersion = Convert.ToDouble(outputFileGDBVersionValue.GetAsText(), System.Globalization.CultureInfo.InvariantCulture);
bool createNetworkAttributesInMetric = false;
if (!(inputCreateNetworkAttributeInMetricValue.IsEmpty()))
createNetworkAttributesInMetric = ((inputCreateNetworkAttributeInMetricValue.GetAsText()).ToUpper() == "TRUE");
bool createArcGISOnlineNetworkAttributes = false;
if (!(inputCreateArcGISOnlineNetworkAttributesValue.IsEmpty()))
createArcGISOnlineNetworkAttributes = ((inputCreateArcGISOnlineNetworkAttributesValue.GetAsText()).ToUpper() == "TRUE");
if (inputTimeZoneIDBaseFieldNameValue.IsEmpty() ^ inputTimeZoneTableValue.IsEmpty())
{
messages.AddError(1, "The Time Zone ID Base Field Name and the Time Zone Table must be specified together.");
return;
}
string timeZoneIDBaseFieldName = "";
bool directedTimeZoneIDFields = false;
if (!(inputTimeZoneIDBaseFieldNameValue.IsEmpty()))
{
timeZoneIDBaseFieldName = inputTimeZoneIDBaseFieldNameValue.GetAsText();
IDETable inputTable = m_gpUtils.DecodeDETable(inputStreetsFeatureClassValue);
if (inputTable.Fields.FindField(timeZoneIDBaseFieldName) == -1)
{
directedTimeZoneIDFields = true;
if (((inputTable.Fields.FindField("FT_" + timeZoneIDBaseFieldName) == -1) || (inputTable.Fields.FindField("TF_" + timeZoneIDBaseFieldName) == -1)))
{
messages.AddError(1, "Field named " + timeZoneIDBaseFieldName + " does not exist, nor the pair of fields with FT_ and TF_ prefixing " + timeZoneIDBaseFieldName + " does not exist.");
return;
}
}
}
string commonTimeZone = "";
if (!(inputCommonTimeZoneForTheEntireDatasetValue.IsEmpty()))
commonTimeZone = inputCommonTimeZoneForTheEntireDatasetValue.GetAsText();
if (inputLinkReferenceFileFC14Value.IsEmpty() ^ inputLinkReferenceFileFC5Value.IsEmpty())
{
messages.AddError(1, "Both Traffic Patterns Link Reference .csv files must be specified together.");
return;
}
bool usesHistoricalTraffic = !(inputSPDFileValue.IsEmpty());
bool usesNTPFullCoverage = !(inputLinkReferenceFileFC5Value.IsEmpty());
if ((inputTMCReferenceFileValue.IsEmpty() & !usesNTPFullCoverage) ^ inputSPDFileValue.IsEmpty())
{
messages.AddError(1, "The Traffic Patterns SPD .csv file must be specified with the Traffic Patterns Link/TMC Reference .csv file(s).");
return;
}
if (inputTrafficTableValue.IsEmpty() & !inputTMCReferenceFileValue.IsEmpty())
{
messages.AddError(1, "If the TMC Reference .csv file is specified, then the Traffic table must also be specified.");
return;
}
bool agsConnectionIsEmpty = inputLiveTrafficFeedArcGISServerConnectionValue.IsEmpty();
bool gpServiceNameIsEmpty = inputLiveTrafficFeedGeoprocessingServiceNameValue.IsEmpty();
bool gpTaskNameIsEmpty = inputLiveTrafficFeedGeoprocessingTaskNameValue.IsEmpty();
if ((agsConnectionIsEmpty | gpServiceNameIsEmpty | gpTaskNameIsEmpty) ^
(agsConnectionIsEmpty & gpServiceNameIsEmpty & gpTaskNameIsEmpty))
{
messages.AddError(1, "The ArcGIS Server Connection, Geoprocessing Service Name, and Geoprocessing Task Name must all be specified together.");
return;
}
bool feedFolderIsEmpty = inputLiveTrafficFeedFolderValue.IsEmpty();
if (!(feedFolderIsEmpty | agsConnectionIsEmpty))
{
messages.AddError(1, "The live traffic feed folder and live traffic feed connection cannot be specified together.");
return;
}
if (inputTrafficTableValue.IsEmpty() & !(feedFolderIsEmpty & agsConnectionIsEmpty))
{
messages.AddError(1, "The Traffic table must be specified to use Live Traffic.");
return;
}
bool usesTransport = true;
if (inputUSCndModTableValue.IsEmpty() && inputNonUSCndModTableValue.IsEmpty())
usesTransport = false;
ITrafficFeedLocation trafficFeedLocation = null;
if (!agsConnectionIsEmpty)
{
// We're using an ArcGIS Server Connection and Geoprocessing Service/Task
ITrafficFeedGPService tfgps = new TrafficFeedGPServiceClass();
IName trafficFeedGPServiceName = m_gpUtils.GetNameObject(inputLiveTrafficFeedArcGISServerConnectionValue as IDataElement);
tfgps.ConnectionProperties = ((IAGSServerConnectionName)trafficFeedGPServiceName).ConnectionProperties;
tfgps.ServiceName = inputLiveTrafficFeedGeoprocessingServiceNameValue.GetAsText();
tfgps.TaskName = inputLiveTrafficFeedGeoprocessingTaskNameValue.GetAsText();
trafficFeedLocation = tfgps as ITrafficFeedLocation;
}
else if (!feedFolderIsEmpty)
{
// We're using a Traffic Feed Folder
ITrafficFeedDirectory tfd = new TrafficFeedDirectoryClass();
tfd.TrafficDirectory = inputLiveTrafficFeedFolderValue.GetAsText();
trafficFeedLocation = tfd as ITrafficFeedLocation;
}
// Get the path to the output file GDB, and feature dataset and network dataset names
string outputFileGdbPath = outputFileGDBValue.GetAsText();
string fdsName = inputFeatureDatasetNameValue.GetAsText();
string ndsName = inputNetworkDatasetNameValue.GetAsText();
// Create the new file geodatabase and feature dataset
AddMessage("Creating the file geodatabase and feature dataset...", messages, trackcancel);
int lastBackslash = outputFileGdbPath.LastIndexOf("\\");
CreateFileGDB createFGDBTool = new CreateFileGDB();
createFGDBTool.out_folder_path = outputFileGdbPath.Remove(lastBackslash);
createFGDBTool.out_name = outputFileGdbPath.Substring(lastBackslash + 1);
createFGDBTool.out_version = "9.3";
gp.Execute(createFGDBTool, trackcancel);
CreateFeatureDataset createFDSTool = new CreateFeatureDataset();
createFDSTool.out_dataset_path = outputFileGdbPath;
createFDSTool.out_name = fdsName;
createFDSTool.spatial_reference = inputStreetsFeatureClassValue.GetAsText();
gp.Execute(createFDSTool, trackcancel);
// Import the Streets feature class to the file geodatabase
// If we're using ArcInfo, also sort the feature class
string pathToFds = outputFileGdbPath + "\\" + fdsName;
string streetsFeatureClassPath = pathToFds + "\\" + StreetsFCName;
IAoInitialize aoi = new AoInitializeClass();
if (aoi.InitializedProduct() == esriLicenseProductCode.esriLicenseProductCodeAdvanced)
{
AddMessage("Importing and spatially sorting the Streets feature class...", messages, trackcancel);
Sort sortTool = new Sort();
sortTool.in_dataset = inputStreetsFeatureClassValue.GetAsText();
sortTool.out_dataset = streetsFeatureClassPath;
sortTool.sort_field = "Shape";
sortTool.spatial_sort_method = "PEANO";
gp.Execute(sortTool, trackcancel);
}
else
{
AddMessage("Importing the Streets feature class...", messages, trackcancel);
FeatureClassToFeatureClass importFCTool = new FeatureClassToFeatureClass();
importFCTool.in_features = inputStreetsFeatureClassValue.GetAsText();
importFCTool.out_path = pathToFds;
importFCTool.out_name = StreetsFCName;
gp.Execute(importFCTool, trackcancel);
}
// Add an index to the Streets feature class's LINK_ID field
AddMessage("Indexing the LINK_ID field...", messages, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.in_table = streetsFeatureClassPath;
addIndexTool.fields = "LINK_ID";
addIndexTool.index_name = "LINK_ID";
gp.Execute(addIndexTool, trackcancel);
// Add the alternate street name fields to the Streets feature class
AddMessage("Creating fields on the Streets feature class for the alternate street names...", messages, trackcancel);
AddField addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 240;
addFieldTool.field_name = "ST_NAME_Alt";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_length = 3;
addFieldTool.field_name = "ST_LANGCD_Alt";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_length = 6;
addFieldTool.field_name = "ST_NM_PREF_Alt";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_length = 90;
addFieldTool.field_name = "ST_TYP_BEF_Alt";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_length = 105;
addFieldTool.field_name = "ST_NM_BASE_Alt";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_length = 6;
addFieldTool.field_name = "ST_NM_SUFF_Alt";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_length = 90;
addFieldTool.field_name = "ST_TYP_AFT_Alt";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_length = 1;
addFieldTool.field_name = "DIRONSIGN_Alt";
gp.Execute(addFieldTool, trackcancel);
// Extract the explicatable street names
string ExplicatblTablePath = outputFileGdbPath + "\\Explicatbl";
AddMessage("Extracting the explicatable street names...", messages, trackcancel);
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputAltStreetsFeatureClassValue.GetAsText();
tableSelectTool.out_table = ExplicatblTablePath;
tableSelectTool.where_clause = "EXPLICATBL = 'Y'";
gp.Execute(tableSelectTool, trackcancel);
// Determine which explicatable names are alternate names and extract them
MakeTableView makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = ExplicatblTablePath;
makeTableViewTool.out_view = "Explicatbl_View";
gp.Execute(makeTableViewTool, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Explicatbl_View";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "LINK_ID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Extracting the alternate street names...", messages, trackcancel);
TableToTable importTableTool = new TableToTable();
importTableTool.in_rows = "Explicatbl_View";
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "AltNames";
importTableTool.where_clause = "Explicatbl.ST_TYP_BEF <> " + StreetsFCName + ".ST_TYP_BEF OR " +
"Explicatbl.ST_NM_BASE <> " + StreetsFCName + ".ST_NM_BASE OR " +
"Explicatbl.ST_TYP_AFT <> " + StreetsFCName + ".ST_TYP_AFT";
importTableTool.field_mapping = "LINK_ID \"LINK_ID\" true true false 4 Long 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.LINK_ID,-1,-1;" +
"ST_NAME \"ST_NAME\" true true false 240 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.ST_NAME,-1,-1;" +
"ST_LANGCD \"ST_LANGCD\" true true false 3 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.ST_LANGCD,-1,-1;" +
"ST_NM_PREF \"ST_NM_PREF\" true true false 6 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.ST_NM_PREF,-1,-1;" +
"ST_TYP_BEF \"ST_TYP_BEF\" true true false 90 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.ST_TYP_BEF,-1,-1;" +
"ST_NM_BASE \"ST_NM_BASE\" true true false 105 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.ST_NM_BASE,-1,-1;" +
"ST_NM_SUFF \"ST_NM_SUFF\" true true false 6 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.ST_NM_SUFF,-1,-1;" +
"ST_TYP_AFT \"ST_TYP_AFT\" true true false 90 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.ST_TYP_AFT,-1,-1;" +
"DIRONSIGN \"DIRONSIGN\" true true false 1 Text 0 0 ,First,#," + ExplicatblTablePath + ",Explicatbl.DIRONSIGN,-1,-1";
gp.Execute(importTableTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Explicatbl_View";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = "Explicatbl_View";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = ExplicatblTablePath;
gp.Execute(deleteTool, trackcancel);
string AltNamesTablePath = outputFileGdbPath + "\\AltNames";
addIndexTool = new AddIndex();
addIndexTool.in_table = AltNamesTablePath;
addIndexTool.fields = "LINK_ID";
addIndexTool.index_name = "LINK_ID";
gp.Execute(addIndexTool, trackcancel);
// Calculate the alternate street name fields
MakeFeatureLayer makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = AltNamesTablePath;
addJoinTool.join_field = "LINK_ID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying over the alternate ST_NAME values...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.expression_type = "VB";
calcFieldTool.field = StreetsFCName + ".ST_NAME_Alt";
calcFieldTool.expression = "[AltNames.ST_NAME]";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the alternate ST_LANGCD values...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".ST_LANGCD_Alt";
calcFieldTool.expression = "[AltNames.ST_LANGCD]";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the alternate ST_NM_PREF values...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".ST_NM_PREF_Alt";
calcFieldTool.expression = "[AltNames.ST_NM_PREF]";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the alternate ST_TYP_BEF values...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".ST_TYP_BEF_Alt";
calcFieldTool.expression = "[AltNames.ST_TYP_BEF]";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the alternate ST_NM_BASE values...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".ST_NM_BASE_Alt";
calcFieldTool.expression = "[AltNames.ST_NM_BASE]";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the alternate ST_NM_SUFF values...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".ST_NM_SUFF_Alt";
calcFieldTool.expression = "[AltNames.ST_NM_SUFF]";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the alternate ST_TYP_AFT values...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".ST_TYP_AFT_Alt";
calcFieldTool.expression = "[AltNames.ST_TYP_AFT]";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Copying over the alternate DIRONSIGN values...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".DIRONSIGN_Alt";
calcFieldTool.expression = "[AltNames.DIRONSIGN]";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "AltNames";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = AltNamesTablePath;
gp.Execute(deleteTool, trackcancel);
// Add fields for the Z-Level values to the Streets feature class
AddMessage("Creating fields on the Streets feature class for the Z-Level values...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "SHORT";
addFieldTool.field_name = "F_ZLEV";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "T_ZLEV";
gp.Execute(addFieldTool, trackcancel);
// Separate out the From and To Z-Level values into separate tables and index the LINK_ID fields
string FromZsTablePath = outputFileGdbPath + "\\FromZs";
string ToZsTablePath = outputFileGdbPath + "\\ToZs";
AddMessage("Extracting the From Z-Level information...", messages, trackcancel);
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputZLevelsFeatureClassValue.GetAsText();
tableSelectTool.out_table = FromZsTablePath;
tableSelectTool.where_clause = "INTRSECT = 'Y' AND POINT_NUM = 1";
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Extracting the To Z-Level information...", messages, trackcancel);
tableSelectTool.out_table = ToZsTablePath;
tableSelectTool.where_clause = "INTRSECT = 'Y' AND POINT_NUM > 1";
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Analyzing the Z-Level information...", messages, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = FromZsTablePath;
addIndexTool.fields = "LINK_ID";
addIndexTool.index_name = "LINK_ID";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.in_table = ToZsTablePath;
gp.Execute(addIndexTool, trackcancel);
// Calculate the Z-Level fields
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = FromZsTablePath;
addJoinTool.join_field = "LINK_ID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying over the F_ZLEV values...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".F_ZLEV";
calcFieldTool.expression = "[FromZs.Z_LEVEL]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "FromZs";
gp.Execute(removeJoinTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = ToZsTablePath;
addJoinTool.join_field = "LINK_ID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying over the T_ZLEV values...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".T_ZLEV";
calcFieldTool.expression = "[ToZs.Z_LEVEL]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "ToZs";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = FromZsTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = ToZsTablePath;
gp.Execute(deleteTool, trackcancel);
// Add fields for the distance (Meters), language, and speed (KPH) values to the Streets feature class
AddMessage("Creating fields on the Streets feature class for distance, speed, and language...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "Meters";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "KPH";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "TEXT";
addFieldTool.field_name = "Language";
addFieldTool.field_length = 2;
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "TEXT";
addFieldTool.field_name = "Language_Alt";
addFieldTool.field_length = 2;
gp.Execute(addFieldTool, trackcancel);
// Calculate the distance (Meters), language, and speed (KPH) fields
AddMessage("Calculating the distance, speed, and language fields...", messages, trackcancel);
CalculateMetersKPHAndLanguageFields(outputFileGdbPath);
if (createArcGISOnlineNetworkAttributes)
{
CreateAndPopulateDirectionalVehicleAccessFields("AR_AUTO", streetsFeatureClassPath, gp, messages, trackcancel);
CreateAndPopulateDirectionalVehicleAccessFields("AR_BUS", streetsFeatureClassPath, gp, messages, trackcancel);
CreateAndPopulateDirectionalVehicleAccessFields("AR_TAXIS", streetsFeatureClassPath, gp, messages, trackcancel);
CreateAndPopulateDirectionalVehicleAccessFields("AR_TRUCKS", streetsFeatureClassPath, gp, messages, trackcancel);
CreateAndPopulateDirectionalVehicleAccessFields("AR_DELIV", streetsFeatureClassPath, gp, messages, trackcancel);
CreateAndPopulateDirectionalVehicleAccessFields("AR_EMERVEH", streetsFeatureClassPath, gp, messages, trackcancel);
CreateAndPopulateDirectionalVehicleAccessFields("AR_MOTOR", streetsFeatureClassPath, gp, messages, trackcancel);
}
// Add a field to the Streets feature class indicating roads closed for construction
AddMessage("Creating the ClosedForConstruction field on the Streets feature class...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "TEXT";
addFieldTool.field_name = "ClosedForConstruction";
addFieldTool.field_length = 1;
gp.Execute(addFieldTool, trackcancel);
// Create a table for looking up roads closed for construction
AddMessage("Creating and indexing the table containing roads closed for construction...", messages, trackcancel);
string closedForConstructionTablePath = outputFileGdbPath + "\\ClosedForConstruction";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputCdmsTableValue.GetAsText();
tableSelectTool.out_table = closedForConstructionTablePath;
tableSelectTool.where_clause = "COND_TYPE = 3";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = closedForConstructionTablePath;
addIndexTool.fields = "LINK_ID";
addIndexTool.index_name = "LINK_ID";
gp.Execute(addIndexTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = closedForConstructionTablePath;
addJoinTool.join_field = "LINK_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the ClosedForConstruction field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = "Streets.ClosedForConstruction";
calcFieldTool.expression = "\"Y\"";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "ClosedForConstruction";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = closedForConstructionTablePath;
gp.Execute(deleteTool, trackcancel);
// Add fields to the Streets feature class indicating roads with usage fees
string[] arFieldSuffixes = new string[] { "AUTO", "BUS", "TAXIS", "CARPOOL", "PEDSTRN",
"TRUCKS", "THRUTR", "DELIVER", "EMERVEH", "MOTOR" };
AddMessage("Creating the UFR fields on the Streets feature class...", messages, trackcancel);
foreach (string arFieldSuffix in arFieldSuffixes)
{
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_name = "UFR_" + arFieldSuffix;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
gp.Execute(addFieldTool, trackcancel);
}
// Create a table for looking up roads with usage fees
AddMessage("Creating and indexing the table containing roads with usage fees...", messages, trackcancel);
string usageFeeRequiredTablePath = outputFileGdbPath + "\\UsageFeeRequired";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputCdmsTableValue.GetAsText();
tableSelectTool.out_table = usageFeeRequiredTablePath;
tableSelectTool.where_clause = "COND_TYPE = 12";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = usageFeeRequiredTablePath;
addIndexTool.fields = "LINK_ID";
addIndexTool.index_name = "LINK_ID";
gp.Execute(addIndexTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = usageFeeRequiredTablePath;
addJoinTool.join_field = "LINK_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the ClosedForConstruction field...", messages, trackcancel);
foreach (string arFieldSuffix in arFieldSuffixes)
{
AddMessage("Calculating the UFR_" + arFieldSuffix + " field on the Streets feature class...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = "Streets.UFR_" + arFieldSuffix;
calcFieldTool.expression = "[UsageFeeRequired.AR_" + arFieldSuffix + "]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "UsageFeeRequired";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = usageFeeRequiredTablePath;
gp.Execute(deleteTool, trackcancel);
// Copy the time zones table to the file geodatabase
if (timeZoneIDBaseFieldName != "")
{
AddMessage("Copying the TimeZones table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputTimeZoneTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "TimeZones";
gp.Execute(importTableTool, trackcancel);
}
#region Process Historical Traffic Tables
if (usesHistoricalTraffic)
{
// Create the Patterns table and index its PatternID field
AddMessage("Creating the Patterns table...", messages, trackcancel);
string listOfConstantPatterns = CreatePatternsTable(inputSPDFileValue.GetAsText(), outputFileGdbPath, fgdbVersion);
string patternsTablePath = outputFileGdbPath + "\\" + ProfilesTableName;
addIndexTool = new AddIndex();
addIndexTool.in_table = patternsTablePath;
addIndexTool.fields = "PatternID";
addIndexTool.index_name = "PatternID";
gp.Execute(addIndexTool, trackcancel);
string histTrafficJoinTablePath = outputFileGdbPath + "\\" + HistTrafficJoinTableName;
// Add fields for the average speeds to the Streets feature class
AddMessage("Creating fields for the average speeds and travel times...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "FT_AverageSpeed";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_AverageSpeed";
gp.Execute(addFieldTool, trackcancel);
if (usesNTPFullCoverage)
{
// Convert the Link Reference files to a FileGDB table
AddMessage("Converting the Link Reference files to a table...", messages, trackcancel);
ConvertLinkReferenceFilesToFGDBTable(inputLinkReferenceFileFC14Value.GetAsText(),
inputLinkReferenceFileFC5Value.GetAsText(),
outputFileGdbPath);
string referenceTablePath = outputFileGdbPath + "\\TempRefTable";
// Extract out the rows we want in our historical traffic table
AddMessage("Creating the historical traffic join table...", messages, trackcancel);
if (listOfConstantPatterns == "")
{
Rename renameTool = new Rename();
renameTool.in_data = referenceTablePath;
renameTool.out_data = histTrafficJoinTablePath;
gp.Execute(renameTool, trackcancel);
}
else
{
tableSelectTool = new TableSelect();
tableSelectTool.in_table = referenceTablePath;
tableSelectTool.out_table = histTrafficJoinTablePath;
tableSelectTool.where_clause = "NOT ( IS_FC5 = 'Y' AND U IN (" + listOfConstantPatterns +
") AND U = M AND M = T AND T = W AND W = R AND R = F AND F = S )";
gp.Execute(tableSelectTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = referenceTablePath;
gp.Execute(deleteTool, trackcancel);
}
}
else
{
// Convert the TMC Reference file to a FileGDB table and index its TMC field
AddMessage("Converting the TMC Reference file to a table...", messages, trackcancel);
ConvertTMCReferenceFileToFGDBTable(inputTMCReferenceFileValue.GetAsText(), outputFileGdbPath);
string referenceTablePath = outputFileGdbPath + "\\TempRefTable";
addIndexTool = new AddIndex();
addIndexTool.in_table = referenceTablePath;
addIndexTool.fields = "TMC";
addIndexTool.index_name = "TMC";
gp.Execute(addIndexTool, trackcancel);
// Copy over the Traffic table to the file geodatabase
AddMessage("Copying Traffic table to the file geodatabase...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputTrafficTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "Street";
gp.Execute(importTableTool, trackcancel);
string trafficTablePath = outputFileGdbPath + "\\Street";
// Add the TMC field and calculate it
AddMessage("Calculating TMC values for historical traffic...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = trafficTablePath;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 9;
addFieldTool.field_name = "TMC";
gp.Execute(addFieldTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = trafficTablePath;
calcFieldTool.field = "TMC";
calcFieldTool.expression = "Replace(Replace(Right([TRAFFIC_CD], 9), \"+\", \"P\"), \"-\", \"N\")";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Creating the historical traffic join table...", messages, trackcancel);
// Join the Traffic table to the Reference table...
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = trafficTablePath;
makeTableViewTool.out_view = "Traffic_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Traffic_View";
addJoinTool.in_field = "TMC";
addJoinTool.join_table = referenceTablePath;
addJoinTool.join_field = "TMC";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
// ...then create the Streets_Patterns table by copying out the joined rows
importTableTool = new TableToTable();
importTableTool.in_rows = "Traffic_View";
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = HistTrafficJoinTableName;
importTableTool.field_mapping = "LINK_ID \"LINK_ID\" true true false 4 Long 0 0 ,First,#," + trafficTablePath + ",Street.LINK_ID,-1,-1;" +
"TRAFFIC_CD \"TRAFFIC_CD\" true true false 10 Text 0 0 ,First,#," + trafficTablePath + ",Street.TRAFFIC_CD,-1,-1;" +
"TMC \"TMC\" true true false 9 Text 0 0 ,First,#," + trafficTablePath + ",Street.TMC,-1,-1;" +
"U \"U\" true true false 2 Short 0 0 ,First,#," + trafficTablePath + ",TempRefTable.U,-1,-1;" +
"M \"M\" true true false 2 Short 0 0 ,First,#," + trafficTablePath + ",TempRefTable.M,-1,-1;" +
"T \"T\" true true false 2 Short 0 0 ,First,#," + trafficTablePath + ",TempRefTable.T,-1,-1;" +
"W \"W\" true true false 2 Short 0 0 ,First,#," + trafficTablePath + ",TempRefTable.W,-1,-1;" +
"R \"R\" true true false 2 Short 0 0 ,First,#," + trafficTablePath + ",TempRefTable.R,-1,-1;" +
"F \"F\" true true false 2 Short 0 0 ,First,#," + trafficTablePath + ",TempRefTable.F,-1,-1;" +
"S \"S\" true true false 2 Short 0 0 ,First,#," + trafficTablePath + ",TempRefTable.S,-1,-1";
gp.Execute(importTableTool, trackcancel);
// Delete the join, view, and temporary tables
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Traffic_View";
removeJoinTool.join_name = "TempRefTable";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Traffic_View";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = referenceTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = trafficTablePath;
gp.Execute(deleteTool, trackcancel);
}
AddMessage("Creating fields on the historical traffic join table...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = histTrafficJoinTablePath;
// Add FCID, FID, position, AverageSpeed[_X], and BaseSpeed[_X] fields to the Streets_Patterns table
addFieldTool.field_type = "LONG";
addFieldTool.field_name = "EdgeFCID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeFID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "EdgeFrmPos";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeToPos";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "AverageSpeed";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "AverageSpeed_U";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "AverageSpeed_M";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "AverageSpeed_T";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "AverageSpeed_W";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "AverageSpeed_R";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "AverageSpeed_F";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "AverageSpeed_S";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "BaseSpeed";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "BaseSpeed_U";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "BaseSpeed_M";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "BaseSpeed_T";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "BaseSpeed_W";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "BaseSpeed_R";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "BaseSpeed_F";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "BaseSpeed_S";
gp.Execute(addFieldTool, trackcancel);
// If we're creating 10.0, then we also need to create the BaseMinutes field
if (fgdbVersion == 10.0)
{
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "BaseMinutes";
gp.Execute(addFieldTool, trackcancel);
}
// Populate the AverageSpeed_X and BaseSpeed_X fields
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = histTrafficJoinTablePath;
makeTableViewTool.out_view = "Streets_Patterns_View";
gp.Execute(makeTableViewTool, trackcancel);
PopulateAverageSpeedAndBaseSpeedFields(patternsTablePath, "U", gp, messages, trackcancel);
PopulateAverageSpeedAndBaseSpeedFields(patternsTablePath, "M", gp, messages, trackcancel);
PopulateAverageSpeedAndBaseSpeedFields(patternsTablePath, "T", gp, messages, trackcancel);
PopulateAverageSpeedAndBaseSpeedFields(patternsTablePath, "W", gp, messages, trackcancel);
PopulateAverageSpeedAndBaseSpeedFields(patternsTablePath, "R", gp, messages, trackcancel);
PopulateAverageSpeedAndBaseSpeedFields(patternsTablePath, "F", gp, messages, trackcancel);
PopulateAverageSpeedAndBaseSpeedFields(patternsTablePath, "S", gp, messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Patterns_View";
gp.Execute(deleteTool, trackcancel);
// Calculate the AverageSpeed and BaseSpeed fields
AddMessage("Calculating the AverageSpeed field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = "AverageSpeed";
calcFieldTool.expression = "( (1/[AverageSpeed_U]) + (1/[AverageSpeed_M]) + (1/[AverageSpeed_T]) + (1/[AverageSpeed_W]) + (1/[AverageSpeed_R]) + (1/[AverageSpeed_F]) + (1/[AverageSpeed_S]) ) / " +
"( (1/[AverageSpeed_U]/[AverageSpeed_U]) + (1/[AverageSpeed_M]/[AverageSpeed_M]) + (1/[AverageSpeed_T]/[AverageSpeed_T]) + (1/[AverageSpeed_W]/[AverageSpeed_W]) + (1/[AverageSpeed_R]/[AverageSpeed_R]) + (1/[AverageSpeed_F]/[AverageSpeed_F]) + (1/[AverageSpeed_S]/[AverageSpeed_S]) )";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the BaseSpeed field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = "BaseSpeed";
calcFieldTool.expression = "( (1/[BaseSpeed_U]) + (1/[BaseSpeed_M]) + (1/[BaseSpeed_T]) + (1/[BaseSpeed_W]) + (1/[BaseSpeed_R]) + (1/[BaseSpeed_F]) + (1/[BaseSpeed_S]) ) / " +
"( (1/[BaseSpeed_U]/[BaseSpeed_U]) + (1/[BaseSpeed_M]/[BaseSpeed_M]) + (1/[BaseSpeed_T]/[BaseSpeed_T]) + (1/[BaseSpeed_W]/[BaseSpeed_W]) + (1/[BaseSpeed_R]/[BaseSpeed_R]) + (1/[BaseSpeed_F]/[BaseSpeed_F]) + (1/[BaseSpeed_S]/[BaseSpeed_S]) )";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
DeleteField deleteFieldTool = new DeleteField();
deleteFieldTool.in_table = histTrafficJoinTablePath;
deleteFieldTool.drop_field = "AverageSpeed_U;AverageSpeed_M;AverageSpeed_T;AverageSpeed_W;AverageSpeed_R;AverageSpeed_F;AverageSpeed_S;BaseSpeed_U;BaseSpeed_M;BaseSpeed_T;BaseSpeed_W;BaseSpeed_R;BaseSpeed_F;BaseSpeed_S";
gp.Execute(deleteFieldTool, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = histTrafficJoinTablePath;
makeTableViewTool.out_view = "Streets_Patterns_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Patterns_View";
addJoinTool.in_field = (usesNTPFullCoverage ? "LINK_PVID" : "LINK_ID");
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "LINK_ID";
gp.Execute(addJoinTool, trackcancel);
// Calculate the BaseMinutes field (if 10.0)
if (fgdbVersion == 10.0)
{
AddMessage("Calculating the BaseMinutes field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Patterns_View";
calcFieldTool.field = HistTrafficJoinTableName + ".BaseMinutes";
calcFieldTool.expression = "[" + StreetsFCName + ".Meters] * 0.06 / [" + HistTrafficJoinTableName + ".BaseSpeed]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
// Calculate the FCID, FID, and position fields
AddMessage("Calculating the EdgeFID field for historical traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Patterns_View";
calcFieldTool.field = HistTrafficJoinTableName + ".EdgeFID";
calcFieldTool.expression = "[" + StreetsFCName + ".OBJECTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Patterns_View";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Patterns_View";
gp.Execute(deleteTool, trackcancel);
AddMessage("Calculating the EdgeFCID field for historical traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = "EdgeFCID";
calcFieldTool.expression = "1";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFrmPos field for historical traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = "EdgeFrmPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = (usesNTPFullCoverage ? "Select Case [TRAVEL_DIRECTION]\n Case \"F\": x = 0\n Case \"T\": x = 1\nEnd Select" :
"Select Case Left([TRAFFIC_CD], 1)\n Case \"+\": x = 0\n Case \"-\": x = 1\nEnd Select");
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeToPos field for historical traffic...", messages, trackcancel);
calcFieldTool.field = "EdgeToPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = (usesNTPFullCoverage ? "Select Case [TRAVEL_DIRECTION]\n Case \"T\": x = 0\n Case \"F\": x = 1\nEnd Select" :
"Select Case Left([TRAFFIC_CD], 1)\n Case \"-\": x = 0\n Case \"+\": x = 1\nEnd Select");
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Write the average speeds to the streets feature class
WriteAverageSpeedsToStreets(outputFileGdbPath, streetsFeatureClassPath, usesNTPFullCoverage, gp, messages, trackcancel);
// Add fields for the average travel times to the Streets feature class
AddMessage("Creating fields for the average travel times...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "FT_Minutes";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_Minutes";
gp.Execute(addFieldTool, trackcancel);
// Calculate the average travel time fields
AddMessage("Calculating the FT travel times...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = streetsFeatureClassPath;
calcFieldTool.field = "FT_Minutes";
calcFieldTool.expression = "[Meters] * 0.06 / s";
calcFieldTool.code_block = "s = [FT_AverageSpeed]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF travel times...", messages, trackcancel);
calcFieldTool.field = "TF_Minutes";
calcFieldTool.expression = "[Meters] * 0.06 / s";
calcFieldTool.code_block = "s = [TF_AverageSpeed]\nIf IsNull(s) Then s = [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Offset the daily pattern fields (U,M,T,W,R,F,S) on the historical traffic join table
OffsetDailyPatternFields(histTrafficJoinTablePath, patternsTablePath);
// Add an index to the Streets feature class's FUNC_CLASS field
AddMessage("Indexing the FUNC_CLASS field...", messages, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = streetsFeatureClassPath;
addIndexTool.fields = "FUNC_CLASS";
addIndexTool.index_name = "FUNC_CLASS";
gp.Execute(addIndexTool, trackcancel);
}
else
{
// Create and calculate the generic Minutes field from speed categories
addFieldTool = new AddField();
addFieldTool.in_table = streetsFeatureClassPath;
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "Minutes";
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the Minutes field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = streetsFeatureClassPath;
calcFieldTool.field = "Minutes";
calcFieldTool.expression = "[Meters] * 0.06 / [KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
#endregion
#region Process Live Traffic Table
// Create the live traffic table (for 10.1 or later)
if (fgdbVersion >= 10.1 && !inputTrafficTableValue.IsEmpty())
{
// Copy over the Traffic table to the file geodatabase
AddMessage("Copying Traffic table to the file geodatabase...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputTrafficTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = TMCJoinTableName;
gp.Execute(importTableTool, trackcancel);
string TMCJoinTablePath = outputFileGdbPath + "\\" + TMCJoinTableName;
// Add the TMC field and calculate it
AddMessage("Calculating TMC values for live traffic...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = TMCJoinTablePath;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 9;
addFieldTool.field_name = "TMC";
gp.Execute(addFieldTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = TMCJoinTablePath;
calcFieldTool.field = "TMC";
calcFieldTool.expression = "Right([TRAFFIC_CD], 9)";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Creating the live traffic join table...", messages, trackcancel);
// Add FCID, FID, and position fields to the Streets_TMC table
AddMessage("Creating fields on the live traffic join table...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = TMCJoinTablePath;
addFieldTool.field_type = "LONG";
addFieldTool.field_name = "EdgeFCID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeFID";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "EdgeFrmPos";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "EdgeToPos";
gp.Execute(addFieldTool, trackcancel);
// Calculate the fields
AddMessage("Calculating the EdgeFrmPos field for live traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = TMCJoinTablePath;
calcFieldTool.field = "EdgeFrmPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = "Select Case Left([TRAFFIC_CD], 1)\n Case \"+\": x = 0\n Case \"-\": x = 1\nEnd Select";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeToPos field for live traffic...", messages, trackcancel);
calcFieldTool.field = "EdgeToPos";
calcFieldTool.expression = "x";
calcFieldTool.code_block = "Select Case Left([TRAFFIC_CD], 1)\n Case \"-\": x = 0\n Case \"+\": x = 1\nEnd Select";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFCID field for live traffic...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = TMCJoinTablePath;
calcFieldTool.field = "EdgeFCID";
calcFieldTool.expression = "1";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the EdgeFID field for live traffic...", messages, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = TMCJoinTablePath;
makeTableViewTool.out_view = "Streets_TMC_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_TMC_View";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "LINK_ID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_TMC_View";
calcFieldTool.field = TMCJoinTableName + ".EdgeFID";
calcFieldTool.expression = "[" + StreetsFCName + ".OBJECTID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_TMC_View";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_TMC_View";
gp.Execute(deleteTool, trackcancel);
// If Historical Traffic is not being used, then we need to create placeholder historical traffic tables
if (!usesHistoricalTraffic)
{
// Create the Streets_Patterns table by starting with a copy of the Streets_TMC table
AddMessage("Creating the historical traffic join table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = TMCJoinTablePath;
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = HistTrafficJoinTableName;
gp.Execute(importTableTool, trackcancel);
string histTrafficJoinTablePath = outputFileGdbPath + "\\" + HistTrafficJoinTableName;
AddMessage("Creating and calculating the KPH field on the historical traffic join table...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = histTrafficJoinTablePath;
addFieldTool.field_type = "FLOAT";
addFieldTool.field_name = "KPH";
gp.Execute(addFieldTool, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = histTrafficJoinTablePath;
makeTableViewTool.out_view = "Streets_Patterns_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Patterns_View";
addJoinTool.in_field = "EdgeFID";
addJoinTool.join_table = streetsFeatureClassPath;
addJoinTool.join_field = "OBJECTID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Patterns_View";
calcFieldTool.field = HistTrafficJoinTableName + ".KPH";
calcFieldTool.expression = "[" + StreetsFCName + ".KPH]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Patterns_View";
removeJoinTool.join_name = StreetsFCName;
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Patterns_View";
gp.Execute(deleteTool, trackcancel);
AddMessage("Creating and calculating the daily patterns fields on the historical traffic join table...", messages, trackcancel);
string[] fieldNames = new string[] { "S", "M", "T", "W", "R", "F", "S" };
foreach (string f in fieldNames)
{
addFieldTool = new AddField();
addFieldTool.in_table = histTrafficJoinTablePath;
addFieldTool.field_type = "SHORT";
addFieldTool.field_name = f;
gp.Execute(addFieldTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = histTrafficJoinTablePath;
calcFieldTool.field = f;
calcFieldTool.expression = "1";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
// Create the Patterns table
CreateNonHistoricalPatternsTable(outputFileGdbPath);
}
}
#endregion
// Copy the Cdms table to the file geodatabase
AddMessage("Copying the Condition/Driving Manoeuvres (CDMS) table and indexing...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputCdmsTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "Cdms";
gp.Execute(importTableTool, trackcancel);
string cdmsTablePath = outputFileGdbPath + "\\Cdms";
addIndexTool = new AddIndex();
addIndexTool.in_table = cdmsTablePath;
addIndexTool.fields = "COND_ID";
addIndexTool.index_name = "COND_ID";
gp.Execute(addIndexTool, trackcancel);
// Copy the Rdms table to the file geodatabase
AddMessage("Copying the Restricted Driving Manoeuvres (RDMS) table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputRdmsTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "Rdms";
gp.Execute(importTableTool, trackcancel);
string rdmsTablePath = outputFileGdbPath + "\\Rdms";
// Add and calculate the end of link and condition type fields to the Rdms table
AddMessage("Creating and calculating fields for the manoeuvre types and ends of link...", messages, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = rdmsTablePath;
addFieldTool.field_name = "COND_TYPE";
addFieldTool.field_type = "LONG";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "END_OF_LK";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
gp.Execute(addFieldTool, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = rdmsTablePath;
makeTableViewTool.out_view = "Rdms_View";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Rdms_View";
addJoinTool.in_field = "COND_ID";
addJoinTool.join_table = cdmsTablePath;
addJoinTool.join_field = "COND_ID";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Rdms_View";
calcFieldTool.field = "Rdms.COND_TYPE";
calcFieldTool.expression = "[Cdms.COND_TYPE]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
calcFieldTool.field = "Rdms.END_OF_LK";
calcFieldTool.expression = "[Cdms.END_OF_LK]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Rdms_View";
removeJoinTool.join_name = "Cdms";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Rdms_View";
gp.Execute(deleteTool, trackcancel);
// Extract only the gates (condition type 4) and prohibitied manoeuvres (condition type 7)
// If using Transport, also extract the Transport manoeuvres (condition type 26)
AddMessage("Extracting restricted driving manoeuvres...", messages, trackcancel);
string prohibRdmsWEndOfLkTablePath = outputFileGdbPath + "\\ProhibRdmsWEndOfLk";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = rdmsTablePath;
tableSelectTool.out_table = prohibRdmsWEndOfLkTablePath;
if (usesTransport)
tableSelectTool.where_clause = "COND_TYPE IN (4, 7, 26)";
else
tableSelectTool.where_clause = "COND_TYPE IN (4, 7)";
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Creating turn feature class...", messages, trackcancel);
// Create the turn feature class
string tempStatsTablePath = outputFileGdbPath + "\\tempStatsTable";
Statistics statsTool = new Statistics();
statsTool.in_table = prohibRdmsWEndOfLkTablePath;
statsTool.out_table = tempStatsTablePath;
statsTool.statistics_fields = "SEQ_NUMBER MAX";
gp.Execute(statsTool, null);
CreateAndPopulateTurnFeatureClass(outputFileGdbPath, fdsName, "ProhibRdmsWEndOfLk", "tempStatsTable",
messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = tempStatsTablePath;
gp.Execute(deleteTool, trackcancel);
string pathToTurnFC = pathToFds + "\\" + TurnFCName;
// Create and calculate condition type and access restriction fields on the turn feature class
addFieldTool = new AddField();
addFieldTool.in_table = pathToTurnFC;
addFieldTool.field_name = "COND_TYPE";
addFieldTool.field_type = "LONG";
gp.Execute(addFieldTool, trackcancel);
AddMessage("Creating access restriction fields on the turn feature class...", messages, trackcancel);
foreach (string arFieldSuffix in arFieldSuffixes)
{
addFieldTool = new AddField();
addFieldTool.in_table = pathToTurnFC;
addFieldTool.field_name = "AR_" + arFieldSuffix;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
gp.Execute(addFieldTool, trackcancel);
}
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = pathToTurnFC;
makeFeatureLayerTool.out_layer = "Turn_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Turn_Layer";
addJoinTool.in_field = "COND_ID";
addJoinTool.join_table = cdmsTablePath;
addJoinTool.join_field = "COND_ID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the COND_TYPE field on the turn feature class...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Turn_Layer";
calcFieldTool.field = TurnFCName + ".COND_TYPE";
calcFieldTool.expression = "[Cdms.COND_TYPE]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
foreach (string arFieldSuffix in arFieldSuffixes)
{
AddMessage("Calculating the AR_" + arFieldSuffix + " field on the turn feature class...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Turn_Layer";
calcFieldTool.field = TurnFCName + ".AR_" + arFieldSuffix;
calcFieldTool.expression = "[Cdms.AR_" + arFieldSuffix + "]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Turn_Layer";
removeJoinTool.join_name = "Cdms";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Turn_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = cdmsTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = prohibRdmsWEndOfLkTablePath;
gp.Execute(deleteTool, trackcancel);
GC.Collect();
#region Process Transport Tables
if (usesTransport)
{
string nonDimensionalCndModTablePath = outputFileGdbPath + "\\nonDimensionalCndMod";
string dimensionalCndModTablePath = outputFileGdbPath + "\\dimensionalCndMod";
if (!(inputUSCndModTableValue.IsEmpty()))
{
// Extract the Transport information for the US
AddMessage("Extracting the US non-dimensional conditions...", messages, trackcancel);
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputUSCndModTableValue.GetAsText();
tableSelectTool.out_table = nonDimensionalCndModTablePath;
tableSelectTool.where_clause = "MOD_TYPE IN (38, 39, 46, 49, 60, 75)";
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Extracting the US dimensional conditions...", messages, trackcancel);
tableSelectTool.out_table = dimensionalCndModTablePath;
tableSelectTool.where_clause = "MOD_TYPE IN (41, 42, 43, 44, 45, 48, 81)";
gp.Execute(tableSelectTool, trackcancel);
// Create a new field to hold the dimension in a common unit (m or kg or KPH)
addFieldTool = new AddField();
addFieldTool.in_table = dimensionalCndModTablePath;
addFieldTool.field_name = "MetersOrKilogramsOrKPH";
addFieldTool.field_type = "DOUBLE";
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating common units of measure...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = dimensionalCndModTablePath;
calcFieldTool.field = "MetersOrKilogramsOrKPH";
calcFieldTool.code_block = "x = CLng([MOD_VAL])\nSelect Case [MOD_TYPE]\n" +
" Case 41, 44, 45, 81: x = x * 0.0254\n" +
" Case 42, 43: x = x * 0.45359237\n" +
" Case 48: x = x * 1.609344\nEnd Select";
calcFieldTool.expression = "x";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
if (!(inputNonUSCndModTableValue.IsEmpty()))
{
string tempNonDimensionalCndModTablePath = outputFileGdbPath + "\\tempNonDimensionalCndMod";
string tempDimensionalCndModTablePath = outputFileGdbPath + "\\tempDimensionalCndMod";
// Extract the Transport information for outside the US to temporary tables
AddMessage("Extracting the non-US non-dimensional conditions...", messages, trackcancel);
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputNonUSCndModTableValue.GetAsText();
tableSelectTool.out_table = tempNonDimensionalCndModTablePath;
tableSelectTool.where_clause = "MOD_TYPE IN (38, 39, 46, 49, 60, 75)";
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Extracting the non-US dimensional conditions...", messages, trackcancel);
tableSelectTool.out_table = tempDimensionalCndModTablePath;
tableSelectTool.where_clause = "MOD_TYPE IN (41, 42, 43, 44, 45, 48, 81)";
gp.Execute(tableSelectTool, trackcancel);
// Create a new field to hold the dimension in a common unit (m or kg)
addFieldTool = new AddField();
addFieldTool.in_table = tempDimensionalCndModTablePath;
addFieldTool.field_name = "MetersOrKilogramsOrKPH";
addFieldTool.field_type = "DOUBLE";
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating common units of measure...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = dimensionalCndModTablePath;
calcFieldTool.field = "MetersOrKilogramsOrKPH";
calcFieldTool.code_block = "x = CLng([MOD_VAL])\nSelect Case [MOD_TYPE]\n" +
" Case 41, 44, 45, 81: x = x * 0.01\nEnd Select";
calcFieldTool.expression = "x";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Append the temporary tables to the main table containing US attributes
Append appendTool = new Append();
appendTool.inputs = tempNonDimensionalCndModTablePath;
appendTool.target = nonDimensionalCndModTablePath;
gp.Execute(appendTool, trackcancel);
appendTool.inputs = tempDimensionalCndModTablePath;
appendTool.target = dimensionalCndModTablePath;
gp.Execute(appendTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = tempNonDimensionalCndModTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = tempDimensionalCndModTablePath;
gp.Execute(deleteTool, trackcancel);
}
}
else
{
// Extract the Transport information for outside the US
AddMessage("Extracting the non-US non-dimensional conditions...", messages, trackcancel);
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputNonUSCndModTableValue.GetAsText();
tableSelectTool.out_table = nonDimensionalCndModTablePath;
tableSelectTool.where_clause = "MOD_TYPE IN (38, 39, 46, 49, 60, 75)";
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Extracting the non-US dimensional conditions...", messages, trackcancel);
tableSelectTool.out_table = dimensionalCndModTablePath;
tableSelectTool.where_clause = "MOD_TYPE IN (41, 42, 43, 44, 45, 48, 81)";
gp.Execute(tableSelectTool, trackcancel);
// Create a new field to hold the dimension in a common unit (m or kg)
addFieldTool = new AddField();
addFieldTool.in_table = dimensionalCndModTablePath;
addFieldTool.field_name = "MetersOrKilogramsOrKPH";
addFieldTool.field_type = "DOUBLE";
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating common units of measure...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = dimensionalCndModTablePath;
calcFieldTool.field = "MetersOrKilogramsOrKPH";
calcFieldTool.code_block = "x = CLng([MOD_VAL])\nSelect Case [MOD_TYPE]\n" +
" Case 41, 44, 45, 81: x = x * 0.01\nEnd Select";
calcFieldTool.expression = "x";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
}
// Create a table for looking up LINK_IDs from COND_IDs
AddMessage("Creating and indexing LINK_ID/COND_ID look-up table for preferred roads...", messages, trackcancel);
string preferredLinkIDLookupTablePath = outputFileGdbPath + "\\preferredLinkIDLookupTable";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputCdmsTableValue.GetAsText();
tableSelectTool.out_table = preferredLinkIDLookupTablePath;
tableSelectTool.where_clause = "COND_TYPE = 27";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = preferredLinkIDLookupTablePath;
addIndexTool.fields = "COND_ID";
addIndexTool.index_name = "COND_ID";
gp.Execute(addIndexTool, trackcancel);
// Create a table for looking up the condition's direction
AddMessage("Creating and indexing direction look-up table for preferred roads...", messages, trackcancel);
string preferredDirectionLookupTablePath = outputFileGdbPath + "\\preferredDirectionLookupTable";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = nonDimensionalCndModTablePath;
tableSelectTool.out_table = preferredDirectionLookupTablePath;
tableSelectTool.where_clause = "MOD_TYPE = 60";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = preferredDirectionLookupTablePath;
addIndexTool.fields = "COND_ID";
addIndexTool.index_name = "COND_ID";
gp.Execute(addIndexTool, trackcancel);
// Create a table for looking up LINK_IDs from COND_IDs
AddMessage("Creating and indexing LINK_ID/COND_ID look-up table for restrictions...", messages, trackcancel);
string restrictionLinkIDLookupTablePath = outputFileGdbPath + "\\restrictionLinkIDLookupTable";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = inputCdmsTableValue.GetAsText();
tableSelectTool.out_table = restrictionLinkIDLookupTablePath;
tableSelectTool.where_clause = "COND_TYPE = 23";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = restrictionLinkIDLookupTablePath;
addIndexTool.fields = "COND_ID";
addIndexTool.index_name = "COND_ID";
gp.Execute(addIndexTool, trackcancel);
// Create a table for looking up the condition's direction
AddMessage("Creating and indexing direction look-up table for restrictions...", messages, trackcancel);
string restrictionDirectionLookupTablePath = outputFileGdbPath + "\\restrictionDirectionLookupTable";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = nonDimensionalCndModTablePath;
tableSelectTool.out_table = restrictionDirectionLookupTablePath;
tableSelectTool.where_clause = "MOD_TYPE = 38";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = restrictionDirectionLookupTablePath;
addIndexTool.fields = "COND_ID";
addIndexTool.index_name = "COND_ID";
gp.Execute(addIndexTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
CreateAndPopulateTruckFCOverrideField(outputFileGdbPath, gp, messages, trackcancel);
if (fgdbVersion >= 10.1)
{
// Create and calculate the preferred fields for Streets
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "STAAPreferred",
"MOD_TYPE = 49 AND MOD_VAL = '1'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "TruckDesignatedPreferred",
"MOD_TYPE = 49 AND MOD_VAL = '2'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "NRHMPreferred",
"MOD_TYPE = 49 AND MOD_VAL = '3'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "ExplosivesPreferred",
"MOD_TYPE = 49 AND MOD_VAL = '4'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "PIHPreferred",
"MOD_TYPE = 49 AND MOD_VAL = '5'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "MedicalWastePreferred",
"MOD_TYPE = 49 AND MOD_VAL = '6'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "RadioactivePreferred",
"MOD_TYPE = 49 AND MOD_VAL = '7'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "HazmatPreferred",
"MOD_TYPE = 49 AND MOD_VAL = '8'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, true, "LocallyPreferred",
"MOD_TYPE = 49 AND MOD_VAL = '9'", gp, messages, trackcancel);
if (createArcGISOnlineNetworkAttributes)
{
CreateAndPopulateAGOLTextTransportFieldsOnStreets(outputFileGdbPath, "PreferredTruckRoute",
new string[] { "STAAPreferred", "TruckDesignatedPreferred", "LocallyPreferred" },
gp, messages, trackcancel);
CreateAndPopulateAGOLTextTransportFieldsOnStreets(outputFileGdbPath, "PreferredHazmatRoute",
new string[] { "NRHMPreferred", "ExplosivesPreferred", "PIHPreferred", "MedicalWastePreferred", "RadioactivePreferred", "HazmatPreferred" },
gp, messages, trackcancel);
}
}
// Create and calculate the HazMat restriction fields for Streets
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "ExplosivesProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '1'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "GasProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '2'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "FlammableProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '3'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "CombustibleProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '4'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "OrganicProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '5'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "PoisonProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '6'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "RadioactiveProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '7'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "CorrosiveProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '8'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "OtherHazmatProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '9'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "AnyHazmatProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '20'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "PIHProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '21'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "HarmfulToWaterProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '22'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "ExplosiveAndFlammableProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '23'", gp, messages, trackcancel);
if (createArcGISOnlineNetworkAttributes)
{
CreateAndPopulateAGOLTextTransportFieldsOnStreets(outputFileGdbPath, "AGOL_AnyHazmatProhibited",
new string[] { "ExplosivesProhibited", "GasProhibited", "FlammableProhibited", "CombustibleProhibited", "OrganicProhibited", "PoisonProhibited", "RadioactiveProhibited", "CorrosiveProhibited",
"OtherHazmatProhibited", "AnyHazmatProhibited", "PIHProhibited", "HarmfulToWaterProhibited", "ExplosiveAndFlammableProhibited" },
gp, messages, trackcancel);
}
// Create and calculate the other restriction fields for Streets
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, true, false, false, "HeightLimit_Meters",
"MOD_TYPE = 41", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, true, false, false, "WeightLimit_Kilograms",
"MOD_TYPE = 42", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, true, false, false, "WeightLimitPerAxle_Kilograms",
"MOD_TYPE = 43", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, true, false, false, "LengthLimit_Meters",
"MOD_TYPE = 44", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, true, false, false, "WidthLimit_Meters",
"MOD_TYPE = 45", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, true, false, "MaxTrailersAllowedOnTruck",
"MOD_TYPE = 46 AND MOD_VAL IN ('1', '2', '3')", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "SemiOrTractorWOneOrMoreTrailersProhibited",
"MOD_TYPE = 46 AND MOD_VAL = '4'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, true, false, "MaxAxlesAllowed",
"MOD_TYPE = 75 AND MOD_VAL IN ('1', '2', '3', '4', '5')", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "SingleAxleProhibited",
"MOD_TYPE = 75 AND MOD_VAL = '6'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, false, false, false, "TandemAxleProhibited",
"MOD_TYPE = 75 AND MOD_VAL = '7'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, true, false, false, "KingpinToRearAxleLengthLimit_Meters",
"MOD_TYPE = 81", gp, messages, trackcancel);
// Create and calculate the truck speed fields for Streets
CreateAndPopulateTransportFieldsOnStreets(outputFileGdbPath, true, false, true, "TruckKPH",
"MOD_TYPE = 48", gp, messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = preferredLinkIDLookupTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = preferredDirectionLookupTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = restrictionLinkIDLookupTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = restrictionDirectionLookupTablePath;
gp.Execute(deleteTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = pathToTurnFC;
makeFeatureLayerTool.out_layer = "RestrictedTurns_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
// Create and calculate the HazMat restriction fields for RestrictedTurns
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "ExplosivesProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '1'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "GasProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '2'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "FlammableProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '3'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "CombustibleProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '4'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "OrganicProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '5'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "PoisonProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '6'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "RadioactiveProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '7'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "CorrosiveProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '8'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "OtherHazmatProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '9'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "AnyHazmatProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '20'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "PIHProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '21'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "HarmfulToWaterProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '22'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "ExplosiveAndFlammableProhibited",
"MOD_TYPE = 39 AND MOD_VAL = '23'", gp, messages, trackcancel);
if (createArcGISOnlineNetworkAttributes)
{
CreateAndPopulateAGOLTextTransportFieldOnTurns(outputFileGdbPath, "AGOL_AnyHazmatProhibited",
new string[] { "ExplosivesProhibited", "GasProhibited", "FlammableProhibited", "CombustibleProhibited", "OrganicProhibited", "PoisonProhibited", "RadioactiveProhibited", "CorrosiveProhibited",
"OtherHazmatProhibited", "AnyHazmatProhibited", "PIHProhibited", "HarmfulToWaterProhibited", "ExplosiveAndFlammableProhibited" },
gp, messages, trackcancel);
}
// Create and calculate the other restriction fields for RestrictedTurns
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, true, false, "HeightLimit_Meters",
"MOD_TYPE = 41", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, true, false, "WeightLimit_Kilograms",
"MOD_TYPE = 42", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, true, false, "WeightLimitPerAxle_Kilograms",
"MOD_TYPE = 43", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, true, false, "LengthLimit_Meters",
"MOD_TYPE = 44", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, true, false, "WidthLimit_Meters",
"MOD_TYPE = 45", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, true, "MaxTrailersAllowedOnTruck",
"MOD_TYPE = 46 AND MOD_VAL IN ('1', '2', '3')", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "SemiOrTractorWOneOrMoreTrailersProhibited",
"MOD_TYPE = 46 AND MOD_VAL = '4'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, true, "MaxAxlesAllowed",
"MOD_TYPE = 75 AND MOD_VAL IN ('1', '2', '3', '4', '5')", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "SingleAxleProhibited",
"MOD_TYPE = 75 AND MOD_VAL = '6'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, false, false, "TandemAxleProhibited",
"MOD_TYPE = 75 AND MOD_VAL = '7'", gp, messages, trackcancel);
CreateAndPopulateTransportFieldOnTurns(outputFileGdbPath, true, false, "KingpinToRearAxleLengthLimit_Meters",
"MOD_TYPE = 81", gp, messages, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "RestrictedTurns_Layer";
gp.Execute(deleteTool, trackcancel);
// Create and calculate the AllTransportProhibited field
addFieldTool = new AddField();
addFieldTool.in_table = pathToTurnFC;
addFieldTool.field_name = "AllTransportProhibited";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
gp.Execute(addFieldTool, trackcancel);
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = pathToTurnFC;
makeFeatureLayerTool.out_layer = "RestrictedTurns_Layer";
makeFeatureLayerTool.where_clause = "COND_TYPE = 26 AND ExplosivesProhibited IS NULL AND GasProhibited IS NULL AND " +
"FlammableProhibited IS NULL AND CombustibleProhibited IS NULL AND OrganicProhibited IS NULL AND " +
"PoisonProhibited IS NULL AND RadioactiveProhibited IS NULL AND CorrosiveProhibited IS NULL AND " +
"OtherHazmatProhibited IS NULL AND AnyHazmatProhibited IS NULL AND PIHProhibited IS NULL AND " +
"HarmfulToWaterProhibited IS NULL AND ExplosiveAndFlammableProhibited IS NULL AND " +
"HeightLimit_Meters IS NULL AND WeightLimit_Kilograms IS NULL AND WeightLimitPerAxle_Kilograms IS NULL AND " +
"LengthLimit_Meters IS NULL AND WidthLimit_Meters IS NULL AND MaxTrailersAllowedOnTruck IS NULL AND " +
"SemiOrTractorWOneOrMoreTrailersProhibited IS NULL AND MaxAxlesAllowed IS NULL AND " +
"SingleAxleProhibited IS NULL AND TandemAxleProhibited IS NULL AND KingpinToRearAxleLengthLimit_Meters IS NULL";
gp.Execute(makeFeatureLayerTool, trackcancel);
AddMessage("Calculating the AllTransportProhibited field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "RestrictedTurns_Layer";
calcFieldTool.field = "AllTransportProhibited";
calcFieldTool.expression = "\"Y\"";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "RestrictedTurns_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = nonDimensionalCndModTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = dimensionalCndModTablePath;
gp.Execute(deleteTool, trackcancel);
GC.Collect();
}
#endregion
// Extract the special explications (condition type 9) from the Rdms Table and create RoadSplits table
AddMessage("Creating RoadSplits table...", messages, trackcancel);
string specialExplicationRdmsWEndOfLkTablePath = outputFileGdbPath + "\\SpecialExplicationRdmsWEndOfLk";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = rdmsTablePath;
tableSelectTool.out_table = specialExplicationRdmsWEndOfLkTablePath;
tableSelectTool.where_clause = "COND_TYPE = 9";
gp.Execute(tableSelectTool, trackcancel);
deleteTool.in_data = rdmsTablePath;
gp.Execute(deleteTool, trackcancel);
CreateRoadSplitsTable("SpecialExplicationRdmsWEndOfLk", outputFileGdbPath, messages, trackcancel);
deleteTool.in_data = specialExplicationRdmsWEndOfLkTablePath;
gp.Execute(deleteTool, trackcancel);
// Create Signpost feature class and table
AddMessage("Creating signpost feature class and table...", messages, trackcancel);
CreateSignposts(inputSignsTableValue.GetAsText(), outputFileGdbPath, messages, trackcancel);
AddSpatialIndex addSpatialIndexTool = new AddSpatialIndex();
addSpatialIndexTool.in_features = pathToFds + "\\" + SignpostFCName;
gp.Execute(addSpatialIndexTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = outputFileGdbPath + "\\" + SignpostJoinTableName;
addIndexTool.fields = "SignpostID";
addIndexTool.index_name = "SignpostID";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.fields = "Sequence";
addIndexTool.index_name = "Sequence";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.fields = "EdgeFCID";
addIndexTool.index_name = "EdgeFCID";
gp.Execute(addIndexTool, trackcancel);
addIndexTool.fields = "EdgeFID";
addIndexTool.index_name = "EdgeFID";
gp.Execute(addIndexTool, trackcancel);
GC.Collect();
// Upgrade the geodatabase (if not 9.3)
if (fgdbVersion > 9.3)
{
UpgradeGDB upgradeGdbTool = new UpgradeGDB();
upgradeGdbTool.input_workspace = outputFileGdbPath;
gp.Execute(upgradeGdbTool, trackcancel);
}
// Create and build the network dataset, then pack it in a GPValue
AddMessage("Creating and building the network dataset...", messages, trackcancel);
CreateAndBuildNetworkDataset(outputFileGdbPath, fgdbVersion, fdsName, ndsName, createNetworkAttributesInMetric,
createArcGISOnlineNetworkAttributes, timeZoneIDBaseFieldName, directedTimeZoneIDFields, commonTimeZone,
usesHistoricalTraffic, trafficFeedLocation, usesTransport);
// Write the build errors to the turn feature class
TurnGeometryUtilities.WriteBuildErrorsToTurnFC(outputFileGdbPath, fdsName, TurnFCName, messages, trackcancel);
// Compact the output file geodatabase
AddMessage("Compacting the output file geodatabase...", messages, trackcancel);
Compact compactTool = new Compact();
compactTool.in_workspace = outputFileGdbPath;
gp.Execute(compactTool, trackcancel);
}
catch (Exception e)
{
if (gp.MaxSeverity == 2)
{
object missing = System.Type.Missing;
messages.AddError(1, gp.GetMessages(ref missing));
}
messages.AddError(1, e.Message);
messages.AddError(1, e.StackTrace);
}
finally
{
// Restore the original GP environment settings
gpSettings.AddOutputsToMap = origAddOutputsToMapSetting;
gpSettings.LogHistory = origLogHistorySetting;
}
GC.Collect();
return;
}
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 void PopulateAverageSpeedAndBaseSpeedFields(string patternsTablePath, string day,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Patterns_View";
addJoinTool.in_field = day;
addJoinTool.join_table = patternsTablePath;
addJoinTool.join_field = "PatternID";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the AverageSpeed_" + day + " field...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Patterns_View";
calcFieldTool.field = HistTrafficJoinTableName + ".AverageSpeed_" + day;
calcFieldTool.expression = "[" + ProfilesTableName + ".AverageSpeed]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the BaseSpeed_" + day + " field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Patterns_View";
calcFieldTool.field = HistTrafficJoinTableName + ".BaseSpeed_" + day;
calcFieldTool.expression = "[" + ProfilesTableName + ".BaseSpeed]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Patterns_View";
removeJoinTool.join_name = ProfilesTableName;
gp.Execute(removeJoinTool, trackcancel);
return;
}
private void WriteAverageSpeedsToStreets(string outputFileGdbPath, string streetsFeatureClassPath, bool usesNTPFullCoverage,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
string joinFieldName = (usesNTPFullCoverage ? "LINK_PVID" : "LINK_ID");
string refTablePath = outputFileGdbPath + "\\" + HistTrafficJoinTableName;
// Separate out the FT and TF speeds into separate tables and index the ID fields
string FTSpeedsTablePath = outputFileGdbPath + "\\FT_Speeds";
string TFSpeedsTablePath = outputFileGdbPath + "\\TF_Speeds";
AddMessage("Extracting FT average speeds...", messages, trackcancel);
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = refTablePath;
tableSelectTool.out_table = FTSpeedsTablePath;
tableSelectTool.where_clause = (usesNTPFullCoverage ? "\"TRAVEL_DIRECTION\" = 'F'" : "\"TRAFFIC_CD\" LIKE '+%'");
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Extracting TF average speeds...", messages, trackcancel);
tableSelectTool.out_table = TFSpeedsTablePath;
tableSelectTool.where_clause = (usesNTPFullCoverage ? "\"TRAVEL_DIRECTION\" = 'T'" : "\"TRAFFIC_CD\" LIKE '-%'");
gp.Execute(tableSelectTool, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.in_table = FTSpeedsTablePath;
addIndexTool.fields = joinFieldName;
addIndexTool.index_name = joinFieldName;
gp.Execute(addIndexTool, trackcancel);
addIndexTool.in_table = TFSpeedsTablePath;
gp.Execute(addIndexTool, trackcancel);
// Calculate the average speed fields on the Streets feature class
string FTCodeBlock = "x = [" + StreetsFCName + ".FT_AverageSpeed]\na = [FT_Speeds.AverageSpeed]\nIf Not IsNull(a) Then x = a";
string TFCodeBlock = "x = [" + StreetsFCName + ".TF_AverageSpeed]\na = [TF_Speeds.AverageSpeed]\nIf Not IsNull(a) Then x = a";
string FTExpression = "x";
string TFExpression = "x";
MakeFeatureLayer makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = streetsFeatureClassPath;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = FTSpeedsTablePath;
addJoinTool.join_field = joinFieldName;
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying over the FT average speeds...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".FT_AverageSpeed";
calcFieldTool.code_block = FTCodeBlock;
calcFieldTool.expression = FTExpression;
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "FT_Speeds";
gp.Execute(removeJoinTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = TFSpeedsTablePath;
addJoinTool.join_field = joinFieldName;
gp.Execute(addJoinTool, trackcancel);
AddMessage("Copying over the TF average speeds...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".TF_AverageSpeed";
calcFieldTool.code_block = TFCodeBlock;
calcFieldTool.expression = TFExpression;
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "TF_Speeds";
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = FTSpeedsTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = TFSpeedsTablePath;
gp.Execute(deleteTool, trackcancel);
return;
}
private void CreateAndPopulateLogisticsRestrictionFields(string outputFileGdbPath, string lrsStatsTableName, string lrsTablePath,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
// Make a feature layer for the Streets feature class
MakeFeatureLayer makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = outputFileGdbPath + "\\" + StreetsFCName;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
// Create fields for the maximum and recommended speeds for all trucks
AddField addFieldTool = new AddField();
addFieldTool.in_table = "Streets_Layer";
addFieldTool.field_type = "DOUBLE";
addFieldTool.field_name = "MaximumSpeed_KPH_AllTrucks";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "RecommendedSpeed_KPH_AllTrucks";
gp.Execute(addFieldTool, trackcancel);
// Initialize the Delete tool for use later
Delete deleteTool = new Delete();
// Open the lrsStatsTable and find the fields we need
Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory");
var wsf = Activator.CreateInstance(factoryType) as IWorkspaceFactory;
var fws = wsf.OpenFromFile(outputFileGdbPath, 0) as IFeatureWorkspace;
ITable lrsStatsTable = fws.OpenTable(lrsStatsTableName);
int restrTypField = lrsStatsTable.FindField("RESTRTYP");
int vtField = lrsStatsTable.FindField("VT");
int restrValField = lrsStatsTable.FindField("RESTRVAL");
// Loop through the lrsStatsTable
ICursor cur = lrsStatsTable.Search(null, true);
IRow statsTableRow = null;
while ((statsTableRow = cur.NextRow()) != null)
{
// Get the RESTRTYP, VT, and RESTRVAL field values and determine the field name
string restrTyp = (string)(statsTableRow.get_Value(restrTypField));
short vt = (short)(statsTableRow.get_Value(vtField));
short restrVal = (short)(statsTableRow.get_Value(restrValField));
string fieldName = "";
// Create a new field for this restriction
// (note for speed restrictions, fields were already created earlier)
if (restrTyp == null || restrTyp.Trim().Length == 0)
continue;
else if (restrTyp != "SP")
{
fieldName = MakeLogisticsFieldName(restrTyp, vt, restrVal);
addFieldTool = new AddField();
addFieldTool.in_table = "Streets_Layer";
addFieldTool.field_name = fieldName;
switch (restrTyp.Remove(1))
{
case "!":
addFieldTool.field_type = "DOUBLE";
break;
case "@":
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
break;
default:
continue; // Only process dimensional (!_) and load (@_) restrictions
}
gp.Execute(addFieldTool, trackcancel);
}
else
{
// for speed restrictions, only process for All Trucks (vt 50)
if (vt != 50)
continue;
else
{
// only process for Maximum Speeds (restrVal 1) and Recommended Speeds (restrVal 2)
switch (restrVal)
{
case 1:
fieldName = "MaximumSpeed_KPH_AllTrucks";
break;
case 2:
fieldName = "RecommendedSpeed_KPH_AllTrucks";
break;
default:
continue;
}
}
}
// Extract the LRS table rows for this restriction
AddMessage("Extracting information for the " + fieldName + " field...", messages, trackcancel);
string outputTablePath = outputFileGdbPath + "\\" + fieldName;
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = lrsTablePath;
tableSelectTool.out_table = outputTablePath;
tableSelectTool.where_clause = "RESTRTYP = '" + restrTyp + "' AND VT = " + vt + " AND RESTRVAL = " + restrVal;
gp.Execute(tableSelectTool, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.in_table = outputTablePath;
addIndexTool.fields = "ID";
addIndexTool.index_name = "ID";
gp.Execute(addIndexTool, trackcancel);
// Calculate the field for this restriction
AddMessage("Calculating the " + fieldName + " field...", messages, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "ID";
addJoinTool.join_table = outputTablePath;
addJoinTool.join_field = "ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + "." + fieldName;
switch (restrTyp)
{
case "SP":
// Speed restriction -- numeric field must be in km/h
calcFieldTool.code_block = "sp = [" + fieldName + ".LIMIT]\nIf [" + fieldName + ".UNIT_MEAS] = 2 Then\n sp = sp * 1.609344\nEnd If";
calcFieldTool.expression = "sp";
break;
case "!A":
case "!B":
case "!C":
case "!D":
case "!E":
case "!F":
// Weight limits -- numeric field must be in tons
calcFieldTool.code_block = "wt = [" + fieldName + ".LIMIT]\nIf [" + fieldName + ".UNIT_MEAS] = 3 Then\n wt = wt / 0.90718474\nEnd If";
calcFieldTool.expression = "wt";
break;
case "!G":
case "!H":
case "!I":
case "!J":
case "!K":
case "!L":
case "!M":
case "!N":
case "!O":
case "!P":
// Length/Width/Height limits -- numeric field must be in feet
calcFieldTool.code_block = "d = [" + fieldName + ".LIMIT]\nSelect Case [" + fieldName + ".UNIT_MEAS]\n" +
" Case 4: d = d / 30.48\n Case 5: d = d / 0.3048\n Case 8: d = d / 12\nEnd Select";
calcFieldTool.expression = "d";
break;
default:
// Load restrictions -- string field is the letter "Y"
calcFieldTool.expression = "\"Y\"";
break;
}
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = fieldName;
gp.Execute(removeJoinTool, trackcancel);
// Clean up the extracted data before moving on to the next row
deleteTool.in_data = outputTablePath;
gp.Execute(deleteTool, trackcancel);
}
// Remove the streets layer before exiting
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
}
private void CreateAndPopulateTransportFieldsOnStreets(string outputFileGdbPath, bool isDimensional, bool isQuantitative,
bool isPreferred, string newFieldNameBase, string queryExpression,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
string cndModTableName = isDimensional ? "dimensionalCndMod" : "nonDimensionalCndMod";
string linkIDLookupTableName = isPreferred ? "preferredLinkIDLookupTable" : "restrictionLinkIDLookupTable";
string directionLookupTableName = isPreferred ? "preferredDirectionLookupTable" : "restrictionDirectionLookupTable";
// Add new fields to the Streets feature class
AddField addFieldTool = new AddField();
addFieldTool.in_table = outputFileGdbPath + "\\" + StreetsFCName;
if (isDimensional)
{
addFieldTool.field_type = "DOUBLE";
}
else if (isQuantitative)
{
addFieldTool.field_type = "SHORT";
}
else
{
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
}
addFieldTool.field_name = "FT_" + newFieldNameBase;
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_" + newFieldNameBase;
gp.Execute(addFieldTool, trackcancel);
// Extract the information needed for this field from the CndMod table
string extractTablePath = outputFileGdbPath + "\\cndModExtract";
AddMessage("Extracting information for the " + newFieldNameBase + " fields...", messages, trackcancel);
string cndModTablePath = outputFileGdbPath + "\\" + cndModTableName;
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = cndModTablePath;
tableSelectTool.out_table = extractTablePath;
tableSelectTool.where_clause = queryExpression;
gp.Execute(tableSelectTool, trackcancel);
// Create LINK_ID and Direction fields on the extract table
addFieldTool = new AddField();
addFieldTool.in_table = extractTablePath;
addFieldTool.field_name = "LINK_ID";
addFieldTool.field_type = "LONG";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "Direction";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 2;
gp.Execute(addFieldTool, trackcancel);
// Copy over the LINK_ID values to the extract table
MakeTableView makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = extractTablePath;
makeTableViewTool.out_view = "cndModExtract_View";
gp.Execute(makeTableViewTool, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "cndModExtract_View";
addJoinTool.in_field = "COND_ID";
addJoinTool.join_table = outputFileGdbPath + "\\" + linkIDLookupTableName;
addJoinTool.join_field = "COND_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Looking up LINK_ID values for the " + newFieldNameBase + " fields...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "cndModExtract_View";
calcFieldTool.field = "cndModExtract.LINK_ID";
calcFieldTool.expression = "[" + linkIDLookupTableName + ".LINK_ID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "cndModExtract_View";
removeJoinTool.join_name = linkIDLookupTableName;
gp.Execute(removeJoinTool, trackcancel);
// Calculate the Direction values in the extract table
addJoinTool.in_layer_or_view = "cndModExtract_View";
addJoinTool.in_field = "COND_ID";
addJoinTool.join_table = outputFileGdbPath + "\\" + directionLookupTableName;
addJoinTool.join_field = "COND_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Looking up direction values for the " + newFieldNameBase + " fields...", messages, trackcancel);
calcFieldTool.in_table = "cndModExtract_View";
calcFieldTool.field = "cndModExtract.Direction";
if (isPreferred)
calcFieldTool.code_block = "dir = \"\"\nSelect Case [" + directionLookupTableName + ".MOD_VAL]\n" +
" Case \"1\": dir = \"FT\"\n Case \"2\": dir = \"TF\"\n Case \"3\": dir = \"B\"\nEnd Select";
else
calcFieldTool.code_block = "dir = \"\"\nSelect Case [" + directionLookupTableName + ".MOD_VAL]\n" +
" Case \"1\": dir = \"B\"\n Case \"2\": dir = \"FT\"\n Case \"3\": dir = \"TF\"\nEnd Select";
calcFieldTool.expression = "dir";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool.in_layer_or_view = "cndModExtract_View";
removeJoinTool.join_name = directionLookupTableName;
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = "cndModExtract_View";
gp.Execute(deleteTool, trackcancel);
AddMessage("Indexing the LINK_ID lookup values...", messages, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.fields = "LINK_ID";
addIndexTool.index_name = "LINK_ID";
addIndexTool.in_table = extractTablePath;
gp.Execute(addIndexTool, trackcancel);
// Calculate the preferred route/restriction fields
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = extractTablePath;
addJoinTool.join_field = "LINK_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.expression_type = "VB";
string fieldVal = isDimensional ? "[cndModExtract.MetersOrKilogramsOrKPH]" : (isQuantitative ? "CInt( [cndModExtract.MOD_VAL] )" : "\"Y\"");
AddMessage("Calculating the FT_" + newFieldNameBase + " field...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".FT_" + newFieldNameBase;
calcFieldTool.code_block = "Select Case [cndModExtract.Direction]\n" +
" Case \"FT\", \"B\": val = " + fieldVal + "\n Case Else: val = Null\nEnd Select";
calcFieldTool.expression = "val";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF_" + newFieldNameBase + " field...", messages, trackcancel);
calcFieldTool.field = StreetsFCName + ".TF_" + newFieldNameBase;
calcFieldTool.code_block = "Select Case [cndModExtract.Direction]\n" +
" Case \"TF\", \"B\": val = " + fieldVal + "\n Case Else: val = Null\nEnd Select";
calcFieldTool.expression = "val";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "cndModExtract";
gp.Execute(removeJoinTool, trackcancel);
deleteTool.in_data = extractTablePath;
gp.Execute(deleteTool, trackcancel);
}
private void CreateAndPopulateTransportFieldOnTurns(string outputFileGdbPath, bool isDimensional, bool isQuantitative,
string newFieldName, string queryExpression,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
string cndModTableName = isDimensional ? "dimensionalCndMod" : "nonDimensionalCndMod";
// Add a new field to the Turns feature class
AddField addFieldTool = new AddField();
addFieldTool.in_table = outputFileGdbPath + "\\" + TurnFCName;
if (isDimensional)
{
addFieldTool.field_type = "DOUBLE";
}
else if (isQuantitative)
{
addFieldTool.field_type = "SHORT";
}
else
{
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
}
addFieldTool.field_name = newFieldName;
gp.Execute(addFieldTool, trackcancel);
// Extract the information needed for this field from the CndMod table
string extractTablePath = outputFileGdbPath + "\\cndModExtract";
AddMessage("Extracting information for the " + newFieldName + " field on " + TurnFCName + "...", messages, trackcancel);
string cndModTablePath = outputFileGdbPath + "\\" + cndModTableName;
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = cndModTablePath;
tableSelectTool.out_table = extractTablePath;
tableSelectTool.where_clause = queryExpression;
gp.Execute(tableSelectTool, trackcancel);
AddMessage("Indexing the COND_ID field...", messages, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.fields = "COND_ID";
addIndexTool.index_name = "COND_ID";
addIndexTool.in_table = extractTablePath;
gp.Execute(addIndexTool, trackcancel);
// Calculate the turn restriction field
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "RestrictedTurns_Layer";
addJoinTool.in_field = "COND_ID";
addJoinTool.join_table = extractTablePath;
addJoinTool.join_field = "COND_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the " + newFieldName + " field on " + TurnFCName + "...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "RestrictedTurns_Layer";
calcFieldTool.field = TurnFCName + "." + newFieldName;
calcFieldTool.expression = isDimensional ? "[cndModExtract.MetersOrKilogramsOrKPH]" : (isQuantitative ? "CInt( [cndModExtract.MOD_VAL] )" : "\"Y\"");
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "RestrictedTurns_Layer";
removeJoinTool.join_name = "cndModExtract";
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = extractTablePath;
gp.Execute(deleteTool, trackcancel);
}
public void Execute(IArray paramvalues, ITrackCancel trackcancel,
IGPEnvironmentManager envMgr, IGPMessages messages)
{
// Remember the original GP environment settings and temporarily override these settings
var gpSettings = envMgr as IGeoProcessorSettings;
bool origAddOutputsToMapSetting = gpSettings.AddOutputsToMap;
bool origLogHistorySetting = gpSettings.LogHistory;
gpSettings.AddOutputsToMap = false;
gpSettings.LogHistory = false;
// Create the Geoprocessor
Geoprocessor gp = new Geoprocessor();
try
{
// Validate our values
IGPMessages validateMessages = ((IGPFunction2)this).Validate(paramvalues, false, envMgr);
if ((validateMessages as IGPMessage).IsError())
{
messages.AddError(1, "Validate failed");
return;
}
// Unpack values
IGPParameter gpParam = paramvalues.get_Element(InputMtdDSTTable) as IGPParameter;
IGPValue inputMtdDSTTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputMtdCntryRefTable) as IGPParameter;
IGPValue inputMtdCntryRefTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputMtdAreaTable) as IGPParameter;
IGPValue inputMtdAreaTableValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputAdminBndyFeatureClasses) as IGPParameter;
var inputAdminBndyFeatureClassesMultiValue = m_gpUtils.UnpackGPValue(gpParam) as IGPMultiValue;
gpParam = paramvalues.get_Element(OutputFileGDB) as IGPParameter;
IGPValue outputFileGDBValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputStreetsFeatureClass) as IGPParameter;
IGPValue inputStreetsFeatureClassValue = m_gpUtils.UnpackGPValue(gpParam);
gpParam = paramvalues.get_Element(InputTimeZoneIDBaseFieldName) as IGPParameter;
IGPValue inputTimeZoneIDBaseFieldNameValue = m_gpUtils.UnpackGPValue(gpParam);
bool processStreetsFC = (!(inputStreetsFeatureClassValue.IsEmpty()));
string timeZoneIDBaseFieldName = "";
if (!(inputTimeZoneIDBaseFieldNameValue.IsEmpty()))
timeZoneIDBaseFieldName = inputTimeZoneIDBaseFieldNameValue.GetAsText();
// Get the path to the output file GDB
string outputFileGdbPath = outputFileGDBValue.GetAsText();
// Create the new file geodatabase
AddMessage("Creating the file geodatabase...", messages, trackcancel);
int lastBackslash = outputFileGdbPath.LastIndexOf("\\");
CreateFileGDB createFGDBTool = new CreateFileGDB();
createFGDBTool.out_folder_path = outputFileGdbPath.Remove(lastBackslash);
createFGDBTool.out_name = outputFileGdbPath.Substring(lastBackslash + 1);
gp.Execute(createFGDBTool, trackcancel);
// Copy the MtdDST table to the file geodatabase and add the ADMIN_LVL and AREACODE fields to it
AddMessage("Copying the MtdDST table to the file geodatabase...", messages, trackcancel);
TableToTable importTableTool = new TableToTable();
string inputMtdDSTTablePath = inputMtdDSTTableValue.GetAsText();
importTableTool.in_rows = inputMtdDSTTablePath;
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "MtdDST";
importTableTool.field_mapping = "AREA_ID \"AREA_ID\" true true false 4 Long 0 0 ,First,#," + inputMtdDSTTablePath + ",AREA_ID,-1,-1;" +
"TIME_ZONE \"TIME_ZONE\" true true false 4 Text 0 0 ,First,#," + inputMtdDSTTablePath + ",TIME_ZONE,-1,-1;" +
"DST_EXIST \"DST_EXIST\" true true false 1 Text 0 0 ,First,#," + inputMtdDSTTablePath + ",DST_EXIST,-1,-1";
gp.Execute(importTableTool, trackcancel);
string mtdDSTTablePath = outputFileGdbPath + "\\MtdDST";
AddField addFieldTool = new AddField();
addFieldTool.in_table = mtdDSTTablePath;
addFieldTool.field_name = "ADMIN_LVL";
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = mtdDSTTablePath;
addFieldTool.field_name = "AREACODE";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 76;
gp.Execute(addFieldTool, trackcancel);
// Copy the MtdArea table to the file geodatabase and index the AREA_ID field
AddMessage("Copying the MtdArea table to the file geodatabase...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = inputMtdAreaTableValue.GetAsText();
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = "MtdArea";
gp.Execute(importTableTool, trackcancel);
string mtdAreaTablePath = outputFileGdbPath + "\\MtdArea";
AddIndex addIndexTool = new AddIndex();
addIndexTool.in_table = mtdAreaTablePath;
addIndexTool.fields = "AREA_ID";
addIndexTool.index_name = "AREA_ID";
gp.Execute(addIndexTool, trackcancel);
// Calculate the ADMIN_LVL and AREACODE fields on the MtdDST table
MakeTableView makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = mtdDSTTablePath;
makeTableViewTool.out_view = "MtdDST_Layer";
gp.Execute(makeTableViewTool, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "MtdDST_Layer";
addJoinTool.in_field = "AREA_ID";
addJoinTool.join_table = mtdAreaTablePath;
addJoinTool.join_field = "AREA_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the ADMIN_LVL field...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "MtdDST_Layer";
calcFieldTool.field = "MtdDST.ADMIN_LVL";
calcFieldTool.expression = "[MtdArea.ADMIN_LVL]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the AREACODE field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "MtdDST_Layer";
calcFieldTool.field = "MtdDST.AREACODE";
calcFieldTool.code_block = "lvl = [MtdArea.ADMIN_LVL]\n" +
"s = CStr([MtdArea.AREACODE_1])\n" +
"If lvl >= 2 Then s = s & \".\" & CStr([MtdArea.AREACODE_2])\n" +
"If lvl >= 3 Then s = s & \".\" & CStr([MtdArea.AREACODE_3])\n" +
"If lvl >= 4 Then s = s & \".\" & CStr([MtdArea.AREACODE_4])\n" +
"If lvl >= 5 Then s = s & \".\" & CStr([MtdArea.AREACODE_5])\n" +
"If lvl >= 6 Then s = s & \".\" & CStr([MtdArea.AREACODE_6])\n" +
"If lvl >= 7 Then s = s & \".\" & CStr([MtdArea.AREACODE_7])";
calcFieldTool.expression = "s";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "MtdDST_Layer";
removeJoinTool.join_name = "MtdArea";
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = "MtdDST_Layer";
gp.Execute(deleteTool, trackcancel);
// Create the MtdDST# tables by admin levels and index the AREACODE field
TableSelect tableSelectTool = null;
for (int i = 1; i <= 7; i++)
{
string iAsString = Convert.ToString(i, System.Globalization.CultureInfo.InvariantCulture);
AddMessage("Extracting level " + iAsString + " MtdDST rows...", messages, trackcancel);
tableSelectTool = new TableSelect();
tableSelectTool.in_table = mtdDSTTablePath;
tableSelectTool.out_table = mtdDSTTablePath + iAsString;
tableSelectTool.where_clause = "ADMIN_LVL = " + iAsString;
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = mtdDSTTablePath + iAsString;
addIndexTool.fields = "AREACODE";
addIndexTool.index_name = "AREACODE";
gp.Execute(addIndexTool, trackcancel);
}
deleteTool = new Delete();
deleteTool.in_data = mtdDSTTablePath;
gp.Execute(deleteTool, trackcancel);
// Copy the MtdCntryRef table to the file geodatabase (use Statistics tool to remove duplicate rows)
AddMessage("Copying the MtdCntryRef table to the file geodatabase...", messages, trackcancel);
string inputMtdCntryRefTablePath = inputMtdCntryRefTableValue.GetAsText();
string mtdCntryRefTablePath = outputFileGdbPath + "\\MtdCntryRef";
Statistics statsTool = new Statistics();
statsTool.in_table = inputMtdCntryRefTablePath;
statsTool.out_table = mtdCntryRefTablePath;
statsTool.statistics_fields = "ISO_CODE COUNT";
statsTool.case_field = "GOVT_CODE;ISO_CODE;DRIVING_SD;ADMINLEVEL";
gp.Execute(statsTool, trackcancel);
DeleteField deleteFieldTool = new DeleteField();
deleteFieldTool.in_table = mtdCntryRefTablePath;
deleteFieldTool.drop_field = "FREQUENCY;COUNT_ISO_CODE";
gp.Execute(deleteFieldTool, trackcancel);
// Index the GOVT_CODE field
addIndexTool = new AddIndex();
addIndexTool.in_table = mtdCntryRefTablePath;
addIndexTool.fields = "GOVT_CODE";
addIndexTool.index_name = "GOVT_CODE";
gp.Execute(addIndexTool, trackcancel);
// Extract the top level (country) records from the MtdArea table and index the AREACODE_1 field
AddMessage("Extracting the top-level rows from the MtdArea table...", messages, trackcancel);
string mtdTopAreaTablePath = outputFileGdbPath + "\\TopArea";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = mtdAreaTablePath;
tableSelectTool.out_table = mtdTopAreaTablePath;
tableSelectTool.where_clause = "AREACODE_2 = 0 AND AREA_TYPE = 'B'";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = mtdTopAreaTablePath;
addIndexTool.fields = "AREACODE_1";
addIndexTool.index_name = "AREACODE_1";
gp.Execute(addIndexTool, trackcancel);
// Create and calculate the TOP_GOVT_CODE field on the MtdArea table
addFieldTool = new AddField();
addFieldTool.in_table = mtdAreaTablePath;
addFieldTool.field_name = "TOP_GOVT_CODE";
addFieldTool.field_type = "LONG";
gp.Execute(addFieldTool, trackcancel);
makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = mtdAreaTablePath;
makeTableViewTool.out_view = "MtdArea_Layer";
gp.Execute(makeTableViewTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "MtdArea_Layer";
addJoinTool.in_field = "AREACODE_1";
addJoinTool.join_table = mtdTopAreaTablePath;
addJoinTool.join_field = "AREACODE_1";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the TOP_GOVT_CODE field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "MtdArea_Layer";
calcFieldTool.field = "MtdArea.TOP_GOVT_CODE";
calcFieldTool.expression = "[TopArea.GOVT_CODE]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "MtdArea_Layer";
removeJoinTool.join_name = "TopArea";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = mtdTopAreaTablePath;
gp.Execute(deleteTool, trackcancel);
// Create and calculate the ISO_CODE and DRIVING_SD string fields
addFieldTool = new AddField();
addFieldTool.in_table = mtdAreaTablePath;
addFieldTool.field_name = "ISO_CODE";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 3;
gp.Execute(addFieldTool, trackcancel);
addFieldTool = new AddField();
addFieldTool.in_table = mtdAreaTablePath;
addFieldTool.field_name = "DRIVING_SD";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
gp.Execute(addFieldTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "MtdArea_Layer";
addJoinTool.in_field = "TOP_GOVT_CODE";
addJoinTool.join_table = mtdCntryRefTablePath;
addJoinTool.join_field = "GOVT_CODE";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the ISO_CODE field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "MtdArea_Layer";
calcFieldTool.field = "MtdArea.ISO_CODE";
calcFieldTool.expression = "[MtdCntryRef.ISO_CODE]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the DRIVING_SD field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "MtdArea_Layer";
calcFieldTool.field = "MtdArea.DRIVING_SD";
calcFieldTool.expression = "[MtdCntryRef.DRIVING_SD]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "MtdArea_Layer";
removeJoinTool.join_name = "MtdCntryRef";
gp.Execute(removeJoinTool, trackcancel);
// Create and calculate the FullAREACODE# string fields and the UTCOffset and DST fields
addFieldTool = new AddField();
addFieldTool.in_table = mtdAreaTablePath;
addFieldTool.field_type = "SHORT";
addFieldTool.field_name = "UTCOffset";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "DST";
gp.Execute(addFieldTool, trackcancel);
string codeBlock = "lvl = [ADMIN_LVL]\ns = CStr([AREACODE_1])";
for (int i = 1; i <= 7; i++)
{
string iAsString = Convert.ToString(i, System.Globalization.CultureInfo.InvariantCulture);
string iPlusOne = Convert.ToString(i+1, System.Globalization.CultureInfo.InvariantCulture);
string fullAreaCodeFieldName = "FullAREACODE" + iAsString;
addFieldTool = new AddField();
addFieldTool.in_table = mtdAreaTablePath;
addFieldTool.field_name = fullAreaCodeFieldName;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 76;
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the FullAREACODE" + iAsString + " field...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = mtdAreaTablePath;
calcFieldTool.field = fullAreaCodeFieldName;
calcFieldTool.code_block = codeBlock;
calcFieldTool.expression = "s";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
codeBlock = codeBlock + "\nIf lvl >= " + iPlusOne + " Then s = s & \".\" & CStr([AREACODE_" + iPlusOne + "])";
string dstJoinTableName = "MtdDST" + iAsString;
string dstJoinTablePath = outputFileGdbPath + "\\" + dstJoinTableName;
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "MtdArea_Layer";
addJoinTool.in_field = fullAreaCodeFieldName;
addJoinTool.join_table = dstJoinTablePath;
addJoinTool.join_field = "AREACODE";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the UTCOffset field (" + iAsString + " of 7)...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "MtdArea_Layer";
calcFieldTool.field = "MtdArea.UTCOffset";
calcFieldTool.code_block = "s = [MtdArea.UTCOffset]\n" +
"joinValue = [" + dstJoinTableName + ".TIME_ZONE]\n" +
"If Not IsNull(joinValue) Then\n" +
" If Trim(joinValue) <> \"\" Then s = CInt(joinValue) * 6\n" +
"End If";
calcFieldTool.expression = "s";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the DST field (" + iAsString + " of 7)...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "MtdArea_Layer";
calcFieldTool.field = "MtdArea.DST";
calcFieldTool.code_block = "s = [MtdArea.DST]\n" +
"joinValue = [" + dstJoinTableName + ".DST_EXIST]\n" +
"If Not IsNull(joinValue) Then\n" +
" Select Case Trim(joinValue)\n" +
" Case \"Y\": s = 1\n Case \"N\": s = 0\n" +
" End Select\n" +
"End If";
calcFieldTool.expression = "s";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "MtdArea_Layer";
removeJoinTool.join_name = dstJoinTableName;
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = dstJoinTablePath;
gp.Execute(deleteTool, trackcancel);
}
deleteTool = new Delete();
deleteTool.in_data = "MtdArea_Layer";
gp.Execute(deleteTool, trackcancel);
// Create and calculate the sortable MSTIMEZONE field on the MtdArea table
addFieldTool = new AddField();
addFieldTool.in_table = mtdAreaTablePath;
addFieldTool.field_name = "SortableMSTIMEZONE";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 60;
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the time zones...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = mtdAreaTablePath;
calcFieldTool.field = "SortableMSTIMEZONE";
calcFieldTool.code_block = TimeZoneUtilities.MakeSortableMSTIMEZONECode("ISO_CODE");
calcFieldTool.expression = "z";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Extract the MtdArea rows to be used for generating the time zone polygons and index the AREA_ID field
string mtdAreaForTZPolysTablePath = outputFileGdbPath + "\\MtdAreaForTZPolys";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = mtdAreaTablePath;
tableSelectTool.out_table = mtdAreaForTZPolysTablePath;
tableSelectTool.where_clause = CreateWhereClauseForAdminLvlByCountry(outputFileGdbPath, "MtdCntryRef");
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = mtdAreaForTZPolysTablePath;
addIndexTool.fields = "AREA_ID";
addIndexTool.index_name = "AREA_ID";
gp.Execute(addIndexTool, trackcancel);
// We no longer need the MtdCntryRef table anymore
deleteTool = new Delete();
deleteTool.in_data = mtdCntryRefTablePath;
gp.Execute(deleteTool, trackcancel);
// Merge the AdminBndy feature classes together into one feature class
int numAdminBndyFCs = inputAdminBndyFeatureClassesMultiValue.Count;
string mergeToolInputs = "";
for (int i = 0; i < numAdminBndyFCs; i++)
{
mergeToolInputs = mergeToolInputs + inputAdminBndyFeatureClassesMultiValue.get_Value(i).GetAsText() + ";";
}
mergeToolInputs = mergeToolInputs.Remove(mergeToolInputs.Length - 1);
string adminBndyFCPath = outputFileGdbPath + "\\AdminBndy";
AddMessage("Merging the Administrative Boundary feature classes...", messages, trackcancel);
Merge mergeTool = new Merge();
mergeTool.inputs = mergeToolInputs;
mergeTool.output = adminBndyFCPath;
gp.Execute(mergeTool, trackcancel);
// Join the AdminBndy polygons to the MtdArea rows to be used for generating the time zone polygons
MakeFeatureLayer makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = adminBndyFCPath;
makeFeatureLayerTool.out_layer = "AdminBndy_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "AdminBndy_Layer";
addJoinTool.in_field = "AREA_ID";
addJoinTool.join_table = mtdAreaForTZPolysTablePath;
addJoinTool.join_field = "AREA_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
FeatureClassToFeatureClass importFCTool = new FeatureClassToFeatureClass();
importFCTool.in_features = "AdminBndy_Layer";
importFCTool.out_path = outputFileGdbPath;
importFCTool.out_name = "UndissolvedTZPolys";
importFCTool.field_mapping = "SortableMSTIMEZONE \"SortableMSTIMEZONE\" true true false 60 Text 0 0 ,First,#," +
mtdAreaForTZPolysTablePath + ",MtdAreaForTZPolys.SortableMSTIMEZONE,-1,-1";
gp.Execute(importFCTool, trackcancel);
string undissolvedTZPolysFCPath = outputFileGdbPath + "\\UndissolvedTZPolys";
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "AdminBndy_Layer";
removeJoinTool.join_name = "MtdAreaForTZPolys";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "AdminBndy_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = adminBndyFCPath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = mtdAreaForTZPolysTablePath;
gp.Execute(deleteTool, trackcancel);
// Dissolve the time zone polygons together
AddMessage("Dissolving the time zones...", messages, trackcancel);
string timeZoneFCPath = outputFileGdbPath + "\\" + TimeZoneFCName;
Dissolve dissolveTool = new Dissolve();
dissolveTool.in_features = undissolvedTZPolysFCPath;
dissolveTool.out_feature_class = timeZoneFCPath;
dissolveTool.dissolve_field = "SortableMSTIMEZONE";
dissolveTool.multi_part = "MULTI_PART";
gp.Execute(dissolveTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = undissolvedTZPolysFCPath;
gp.Execute(deleteTool, trackcancel);
// Create and calculate the MSTIMEZONE field
addFieldTool = new AddField();
addFieldTool.in_table = timeZoneFCPath;
addFieldTool.field_name = "MSTIMEZONE";
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 50;
gp.Execute(addFieldTool, trackcancel);
AddMessage("Calculating the time zones...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = timeZoneFCPath;
calcFieldTool.field = "MSTIMEZONE";
calcFieldTool.expression = "Mid([SortableMSTIMEZONE], 7)";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
// Delete the old sortable MSTIMEZONE field
deleteFieldTool = new DeleteField();
deleteFieldTool.in_table = timeZoneFCPath;
deleteFieldTool.drop_field = "SortableMSTIMEZONE";
gp.Execute(deleteFieldTool, trackcancel);
if (processStreetsFC)
{
// Create the network dataset time zone table
AddMessage("Creating the time zones table...", messages, trackcancel);
importTableTool = new TableToTable();
importTableTool.in_rows = timeZoneFCPath;
importTableTool.out_path = outputFileGdbPath;
importTableTool.out_name = TimeZonesTableName;
importTableTool.field_mapping = "MSTIMEZONE \"MSTIMEZONE\" true true false 50 Text 0 0 ,First,#," +
timeZoneFCPath + ",MSTIMEZONE,-1,-1";
gp.Execute(importTableTool, trackcancel);
// Separate the MtdArea table by driving side and index the AREA_ID field on each
AddMessage("Extracting rows for the left-side driving areas...", messages, trackcancel);
string drivingLTablePath = mtdAreaTablePath + "DrivingL";
string drivingRTablePath = mtdAreaTablePath + "DrivingR";
tableSelectTool = new TableSelect();
tableSelectTool.in_table = mtdAreaTablePath;
tableSelectTool.out_table = drivingLTablePath;
tableSelectTool.where_clause = "DRIVING_SD = 'L'";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = drivingLTablePath;
addIndexTool.fields = "AREA_ID";
addIndexTool.index_name = "AREA_ID";
gp.Execute(addIndexTool, trackcancel);
AddMessage("Extracting rows for the right-side driving areas...", messages, trackcancel);
tableSelectTool = new TableSelect();
tableSelectTool.in_table = mtdAreaTablePath;
tableSelectTool.out_table = drivingRTablePath;
tableSelectTool.where_clause = "DRIVING_SD = 'R'";
gp.Execute(tableSelectTool, trackcancel);
addIndexTool = new AddIndex();
addIndexTool.in_table = drivingRTablePath;
addIndexTool.fields = "AREA_ID";
addIndexTool.index_name = "AREA_ID";
gp.Execute(addIndexTool, trackcancel);
// Import the Streets feature class to the file geodatabase and
// add the FT_TimeZoneID and TF_TimeZoneID fields
AddMessage("Copying the Streets feature class to the geodatabase...", messages, trackcancel);
importFCTool = new FeatureClassToFeatureClass();
importFCTool.in_features = inputStreetsFeatureClassValue.GetAsText();
importFCTool.out_path = outputFileGdbPath;
importFCTool.out_name = StreetsFCName;
gp.Execute(importFCTool, trackcancel);
string pathToStreetsFC = outputFileGdbPath + "\\" + StreetsFCName;
addFieldTool = new AddField();
addFieldTool.in_table = pathToStreetsFC;
addFieldTool.field_name = "FT_" + timeZoneIDBaseFieldName;
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_" + timeZoneIDBaseFieldName;
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
// Calculate the TimeZoneID fields
makeFeatureLayerTool = new MakeFeatureLayer();
makeFeatureLayerTool.in_features = pathToStreetsFC;
makeFeatureLayerTool.out_layer = "Streets_Layer";
gp.Execute(makeFeatureLayerTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "R_AREA_ID";
addJoinTool.join_table = drivingLTablePath;
addJoinTool.join_field = "AREA_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the FT_" + timeZoneIDBaseFieldName + " field for left driving side roads...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".FT_" + timeZoneIDBaseFieldName;
calcFieldTool.code_block = TimeZoneUtilities.MakeTimeZoneIDCode(outputFileGdbPath, TimeZonesTableName, "MtdAreaDrivingL.SortableMSTIMEZONE");
calcFieldTool.expression = "tzID";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "MtdAreaDrivingL";
gp.Execute(removeJoinTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "L_AREA_ID";
addJoinTool.join_table = drivingRTablePath;
addJoinTool.join_field = "AREA_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the FT_" + timeZoneIDBaseFieldName + " field for right driving side roads...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".FT_" + timeZoneIDBaseFieldName;
calcFieldTool.code_block = TimeZoneUtilities.MakeTimeZoneIDCode(outputFileGdbPath, TimeZonesTableName, "MtdAreaDrivingR.SortableMSTIMEZONE");
calcFieldTool.expression = "tzID";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "MtdAreaDrivingR";
gp.Execute(removeJoinTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "L_AREA_ID";
addJoinTool.join_table = drivingLTablePath;
addJoinTool.join_field = "AREA_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the TF_" + timeZoneIDBaseFieldName + " field for left driving side roads...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".TF_" + timeZoneIDBaseFieldName;
calcFieldTool.code_block = TimeZoneUtilities.MakeTimeZoneIDCode(outputFileGdbPath, TimeZonesTableName, "MtdAreaDrivingL.SortableMSTIMEZONE");
calcFieldTool.expression = "tzID";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "MtdAreaDrivingL";
gp.Execute(removeJoinTool, trackcancel);
addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "R_AREA_ID";
addJoinTool.join_table = drivingRTablePath;
addJoinTool.join_field = "AREA_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Calculating the TF_" + timeZoneIDBaseFieldName + " field for right driving side roads...", messages, trackcancel);
calcFieldTool = new CalculateField();
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".TF_" + timeZoneIDBaseFieldName;
calcFieldTool.code_block = TimeZoneUtilities.MakeTimeZoneIDCode(outputFileGdbPath, TimeZonesTableName, "MtdAreaDrivingR.SortableMSTIMEZONE");
calcFieldTool.expression = "tzID";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "MtdAreaDrivingR";
gp.Execute(removeJoinTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = "Streets_Layer";
gp.Execute(deleteTool, trackcancel);
deleteTool = new Delete();
deleteTool.in_data = drivingLTablePath;
gp.Execute(deleteTool, trackcancel);
deleteTool.in_data = drivingRTablePath;
gp.Execute(deleteTool, trackcancel);
}
else
{
// Create a dummy TimeZones table and a dummy Streets feature class
CreateTable createTableTool = new CreateTable();
createTableTool.out_path = outputFileGdbPath;
createTableTool.out_name = TimeZonesTableName;
gp.Execute(createTableTool, trackcancel);
CreateFeatureclass createFCTool = new CreateFeatureclass();
createFCTool.out_path = outputFileGdbPath;
createFCTool.out_name = StreetsFCName;
createFCTool.geometry_type = "POLYLINE";
gp.Execute(createFCTool, trackcancel);
}
deleteTool = new Delete();
deleteTool.in_data = mtdAreaTablePath;
gp.Execute(deleteTool, trackcancel);
// Compact the output file geodatabase
AddMessage("Compacting the output file geodatabase...", messages, trackcancel);
Compact compactTool = new Compact();
compactTool.in_workspace = outputFileGdbPath;
gp.Execute(compactTool, trackcancel);
}
catch (Exception e)
{
if (gp.MaxSeverity == 2)
{
object missing = System.Type.Missing;
messages.AddError(1, gp.GetMessages(ref missing));
}
messages.AddError(1, e.Message);
messages.AddError(1, e.StackTrace);
}
finally
{
// Restore the original GP environment settings
gpSettings.AddOutputsToMap = origAddOutputsToMapSetting;
gpSettings.LogHistory = origLogHistorySetting;
}
GC.Collect();
return;
}
private void button6_Click(object sender, EventArgs e)
{
Geoprocessor gp = new Geoprocessor();
gp.AddOutputsToMap = true;
gp.OverwriteOutput = true;
CreateThiessenPolygons ct = new CreateThiessenPolygons();
ILayer points = GetLayerByName(map, "public_library_shp");
IFeatureClass fc = (points as IFeatureLayer2).FeatureClass;
ct.in_features = fc;
ct.out_feature_class = output;
ILayer bounds = GetLayerByName(map, "cty00_shp");
IEnvelope envelope = bounds.AreaOfInterest.Envelope;
string envelopestr = string.Format("{0} {1} {2} {3}",
envelope.XMin, envelope.YMax, envelope.XMax, envelope.YMin);
gp.SetEnvironmentValue("Extent", envelopestr);
gp.Execute(ct, null);
AddJoin joined = new AddJoin();
joined.join_table = population;
joined.in_layer_or_view = "trt00_shp";
joined.in_field = "STFID2";
joined.join_field = "GEO_ID";
joined.out_layer_or_view = output + @"\joinedoutput";
gp.Execute(joined, null);
Intersect intersect = new Intersect();
intersect.in_features = "marketshare" + ";" + tracts;
intersect.join_attributes = "ALL";
intersect.out_feature_class = output + @"\intersect";
gp.Execute(intersect, null);
AddField addedfield = new AddField();
addedfield.in_table = "intersect";
addedfield.field_name = "field";
addedfield.field_type = "FLOAT";
gp.Execute(addedfield, null);
AddJoin joined2 = new AddJoin();
joined2.join_table = population;
joined2.in_layer_or_view = "intersect";
joined2.in_field = "STFID2";
joined2.join_field = "GEO_ID";
joined2.out_layer_or_view = output + @"\joinedoutput";
gp.Execute(joined2, null);
CalculateField calc = new CalculateField();
calc.in_table = "intersect";
calc.field = "field";
calc.expression = "!population.P001001!*!intersect.Shape_Area!/!intersect_Area!";
gp.Execute(calc, null);
Dissolve dissolved = new Dissolve();
dissolved.in_features = intersect;
dissolved.statistics_fields = "field";
dissolved.out_feature_class = output + @"\dissolve";
gp.Execute(dissolved, null);
}
private void CreateAndPopulateTruckFCOverrideField(string outputFileGdbPath, Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
// Add the TruckFCOverride field to the Streets feature class
AddField addFieldTool = new AddField();
addFieldTool.in_table = outputFileGdbPath + "\\" + StreetsFCName;
addFieldTool.field_name = "TruckFCOverride";
addFieldTool.field_type = "SHORT";
gp.Execute(addFieldTool, trackcancel);
string extractTablePath = outputFileGdbPath + "\\cndModExtract";
string cndModTablePath = outputFileGdbPath + "\\nonDimensionalCndMod";
for (short fc = 2; fc >= 1; fc--)
{
string fcAsString = Convert.ToString(fc, System.Globalization.CultureInfo.InvariantCulture);
// Extract the FC Override information from the CndMod table
AddMessage("Extracting the FC " + fcAsString + " Override information...", messages, trackcancel);
TableSelect tableSelectTool = new TableSelect();
tableSelectTool.in_table = cndModTablePath;
tableSelectTool.out_table = extractTablePath;
tableSelectTool.where_clause = "MOD_TYPE = 49 AND MOD_VAL = '" + Convert.ToString(fc + 14, System.Globalization.CultureInfo.InvariantCulture) + "'";
gp.Execute(tableSelectTool, trackcancel);
// Create the LINK_ID field on the extract table
addFieldTool = new AddField();
addFieldTool.in_table = extractTablePath;
addFieldTool.field_name = "LINK_ID";
addFieldTool.field_type = "LONG";
gp.Execute(addFieldTool, trackcancel);
// Copy over the LINK_ID values to the extract table
MakeTableView makeTableViewTool = new MakeTableView();
makeTableViewTool.in_table = extractTablePath;
makeTableViewTool.out_view = "cndModExtract_View";
gp.Execute(makeTableViewTool, trackcancel);
AddJoin addJoinTool = new AddJoin();
addJoinTool.in_layer_or_view = "cndModExtract_View";
addJoinTool.in_field = "COND_ID";
addJoinTool.join_table = outputFileGdbPath + "\\preferredLinkIDLookupTable";
addJoinTool.join_field = "COND_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Looking up LINK_ID values for the FC " + fcAsString + " Override values...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = "cndModExtract_View";
calcFieldTool.field = "cndModExtract.LINK_ID";
calcFieldTool.expression = "[preferredLinkIDLookupTable.LINK_ID]";
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
RemoveJoin removeJoinTool = new RemoveJoin();
removeJoinTool.in_layer_or_view = "cndModExtract_View";
removeJoinTool.join_name = "preferredLinkIDLookupTable";
gp.Execute(removeJoinTool, trackcancel);
Delete deleteTool = new Delete();
deleteTool.in_data = "cndModExtract_View";
gp.Execute(deleteTool, trackcancel);
AddMessage("Indexing the LINK_ID lookup values...", messages, trackcancel);
AddIndex addIndexTool = new AddIndex();
addIndexTool.fields = "LINK_ID";
addIndexTool.index_name = "LINK_ID";
addIndexTool.in_table = extractTablePath;
gp.Execute(addIndexTool, trackcancel);
// Populate the TruckFCOverride field with the FC Override values
addJoinTool.in_layer_or_view = "Streets_Layer";
addJoinTool.in_field = "LINK_ID";
addJoinTool.join_table = extractTablePath;
addJoinTool.join_field = "LINK_ID";
addJoinTool.join_type = "KEEP_COMMON";
gp.Execute(addJoinTool, trackcancel);
AddMessage("Populating the TruckFCOverride field with FC " + fcAsString + " Override values...", messages, trackcancel);
calcFieldTool.in_table = "Streets_Layer";
calcFieldTool.field = StreetsFCName + ".TruckFCOverride";
calcFieldTool.expression = fcAsString;
calcFieldTool.expression_type = "VB";
gp.Execute(calcFieldTool, trackcancel);
removeJoinTool.in_layer_or_view = "Streets_Layer";
removeJoinTool.join_name = "cndModExtract";
gp.Execute(removeJoinTool, trackcancel);
deleteTool.in_data = extractTablePath;
gp.Execute(deleteTool, trackcancel);
}
}
private void CreateAndPopulateAGOLTextTransportFieldsOnStreets(string outputFileGdbPath, string newFieldNameBase, string[] arrayOfFieldNameBase,
Geoprocessor gp, IGPMessages messages, ITrackCancel trackcancel)
{
// Add new fields to the Streets feature class
AddField addFieldTool = new AddField();
addFieldTool.in_table = outputFileGdbPath + "\\" + StreetsFCName;
addFieldTool.field_type = "TEXT";
addFieldTool.field_length = 1;
addFieldTool.field_name = "FT_" + newFieldNameBase;
gp.Execute(addFieldTool, trackcancel);
addFieldTool.field_name = "TF_" + newFieldNameBase;
gp.Execute(addFieldTool, trackcancel);
string ftCodeBlock = "val = Null";
string tfCodeBlock = "val = Null";
foreach (string fieldNameBase in arrayOfFieldNameBase)
{
ftCodeBlock += "\nIf [FT_" + fieldNameBase + "] = \"Y\" Then val = \"Y\"";
tfCodeBlock += "\nIf [TF_" + fieldNameBase + "] = \"Y\" Then val = \"Y\"";
}
AddMessage("Calculating the FT_" + newFieldNameBase + " field...", messages, trackcancel);
CalculateField calcFieldTool = new CalculateField();
calcFieldTool.in_table = outputFileGdbPath + "\\" + StreetsFCName;
calcFieldTool.field = "FT_" + newFieldNameBase;
calcFieldTool.code_block = ftCodeBlock;
calcFieldTool.expression = "val";
gp.Execute(calcFieldTool, trackcancel);
AddMessage("Calculating the TF_" + newFieldNameBase + " field...", messages, trackcancel);
calcFieldTool.field = "TF_" + newFieldNameBase;
calcFieldTool.code_block = tfCodeBlock;
calcFieldTool.expression = "val";
gp.Execute(calcFieldTool, trackcancel);
}