public IFeatureClass CreateEmptyFeatureClass(string inFileName, string featureType)
{
IFeatureClass fc = null;
try
{
mLog.Debug("inside CreateEmptyFeatureClass the file to make is " + inFileName);
mLog.Debug("it will be a " + featureType);
string path;
string fileName;
this.GetPathAndFileName(inFileName, out path, out fileName);
CreateFeatureclass cf = new CreateFeatureclass();
cf.out_path = path;
cf.out_name = fileName;
cf.geometry_type = featureType.ToUpper();
fc = this.RunProcessGetFeatureClass(cf, null);
}
catch (System.Runtime.InteropServices.COMException ex)
{
//System.Windows.Forms.MessageBox.Show(ex.Message);
eLog.Debug(ex);
}
mLog.Debug("Leaving CreateEmptyFeatureClass");
return(fc);
}
public static void create_fc(Geoprocessor gp, string ws, string name, string geometry_type, string spatial_reference)
{
CreateFeatureclass cfc = new CreateFeatureclass();
cfc.out_path = ws;
cfc.out_name = name;
cfc.geometry_type = geometry_type;
cfc.spatial_reference = spatial_reference;
gp.Execute(cfc, null);
}
/// <summary>
/// This sample console app demonstrates listening to GP events as they happen
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
GPMessageEventHandler gpEventHandler = new GPMessageEventHandler();
//get an instance of the geoprocessor
Geoprocessor GP = new Geoprocessor();
//register the event helper in order to be able to listen to GP events
GP.RegisterGeoProcessorEvents(gpEventHandler);
//wire the GP events
gpEventHandler.GPMessage += new MessageEventHandler(OnGPMessage);
gpEventHandler.GPPreToolExecute += new PreToolExecuteEventHandler(OnGPPreToolExecute);
gpEventHandler.GPToolboxChanged += new ToolboxChangedEventHandler(OnGPToolboxChanged);
gpEventHandler.GPPostToolExecute += new PostToolExecuteEventHandler(OnGPPostToolExecute);
//instruct the geoprocessing engine to overwrite existing datasets
GP.OverwriteOutput = true;
//create instance of the 'create random points' tool. Write the output to the machine's temp directory
CreateFeatureclass createFeatureClass = new CreateFeatureclass(System.IO.Path.GetTempPath(), "RandomPoints.shp");
//execute the tool
GP.Execute(createFeatureClass, null);
//unwire the GP events
gpEventHandler.GPMessage -= new MessageEventHandler(OnGPMessage);
gpEventHandler.GPPreToolExecute -= new PreToolExecuteEventHandler(OnGPPreToolExecute);
gpEventHandler.GPToolboxChanged -= new ToolboxChangedEventHandler(OnGPToolboxChanged);
gpEventHandler.GPPostToolExecute -= new PostToolExecuteEventHandler(OnGPPostToolExecute);
//unregister the event helper
GP.UnRegisterGeoProcessorEvents(gpEventHandler);
System.Diagnostics.Trace.WriteLine("Done");
}
/// <summary>
/// This sample console app demonstrates listening to GP events as they happen
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
GPMessageEventHandler gpEventHandler = new GPMessageEventHandler();
//get an instance of the geoprocessor
Geoprocessor GP = new Geoprocessor();
//register the event helper in order to be able to listen to GP events
GP.RegisterGeoProcessorEvents(gpEventHandler);
//wire the GP events
gpEventHandler.GPMessage += new MessageEventHandler(OnGPMessage);
gpEventHandler.GPPreToolExecute += new PreToolExecuteEventHandler(OnGPPreToolExecute);
gpEventHandler.GPToolboxChanged += new ToolboxChangedEventHandler(OnGPToolboxChanged);
gpEventHandler.GPPostToolExecute += new PostToolExecuteEventHandler(OnGPPostToolExecute);
//instruct the geoprocessing engine to overwrite existing datasets
GP.OverwriteOutput = true;
//create instance of the 'create random points' tool. Write the output to the machine's temp directory
CreateFeatureclass createFeatureClass = new CreateFeatureclass(System.IO.Path.GetTempPath(), "RandomPoints.shp");
//execute the tool
GP.Execute(createFeatureClass, null);
//unwire the GP events
gpEventHandler.GPMessage -= new MessageEventHandler(OnGPMessage);
gpEventHandler.GPPreToolExecute -= new PreToolExecuteEventHandler(OnGPPreToolExecute);
gpEventHandler.GPToolboxChanged -= new ToolboxChangedEventHandler(OnGPToolboxChanged);
gpEventHandler.GPPostToolExecute -= new PostToolExecuteEventHandler(OnGPPostToolExecute);
//unregister the event helper
GP.UnRegisterGeoProcessorEvents(gpEventHandler);
System.Diagnostics.Trace.WriteLine("Done");
}
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 List<IFeatureClass> createFeatureClass(List<List<IFeature>> features)
{
List<IFeatureClass> feaclsList = new List<IFeatureClass>();
foreach (List<IFeature> feas in features)
{
foreach (IFeature fea in feas)
{
}
m_GP.SetEnvironmentValue("workspace", m_OutputTemp_Aggregation);
CreateFeatureclass createFeaClsTool = new CreateFeatureclass();
}
return feaclsList;
}
public override void OnClick()
{
CreateFeatureclass gpCreate = new CreateFeatureclass();
}
public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message)
{
// Get Parameters
IGPParameter3 inputParameter = (IGPParameter3)paramvalues.get_Element(0);
IGPParameter3 polygonParameter = (IGPParameter3)paramvalues.get_Element(1);
IGPParameter3 outputParameter = (IGPParameter3)paramvalues.get_Element(2);
IGPParameter3 fieldParameter = (IGPParameter3)paramvalues.get_Element(3);
// UnPackGPValue. This ensures you get the value from either the dataelement or GpVariable (ModelBuilder)
IGPValue inputParameterValue = m_GPUtilities.UnpackGPValue(inputParameter);
IGPValue polygonParameterValue = m_GPUtilities.UnpackGPValue(polygonParameter);
IGPValue outputParameterValue = m_GPUtilities.UnpackGPValue(outputParameter);
IGPValue fieldParameterValue = m_GPUtilities.UnpackGPValue(fieldParameter);
// Decode Input Feature Layers
IFeatureClass inputFeatureClass;
IFeatureClass polygonFeatureClass;
IQueryFilter inputFeatureClassQF;
IQueryFilter polygonFeatureClassQF;
m_GPUtilities.DecodeFeatureLayer(inputParameterValue, out inputFeatureClass, out inputFeatureClassQF);
m_GPUtilities.DecodeFeatureLayer(polygonParameterValue, out polygonFeatureClass, out polygonFeatureClassQF);
if (inputFeatureClass == null)
{
message.AddError(2, "Could not open input dataset.");
return;
}
if (polygonFeatureClass == null)
{
message.AddError(2, "Could not open clipping polygon dataset.");
return;
}
if (polygonFeatureClass.FeatureCount(null) > 1)
{
message.AddWarning("Clipping polygon feature class contains more than one feature.");
}
// Create the Geoprocessor
Geoprocessor gp = new Geoprocessor();
// Create Output Polygon Feature Class
CreateFeatureclass cfc = new CreateFeatureclass();
IName name = m_GPUtilities.CreateFeatureClassName(outputParameterValue.GetAsText());
IDatasetName dsName = name as IDatasetName;
IFeatureClassName fcName = dsName as IFeatureClassName;
IFeatureDatasetName fdsName = fcName.FeatureDatasetName as IFeatureDatasetName;
// Check if output is in a FeatureDataset or not. Set the output path parameter for CreateFeatureClass tool.
if (fdsName != null)
{
cfc.out_path = fdsName;
}
else
{
cfc.out_path = dsName.WorkspaceName.PathName;
}
// Set the output Coordinate System for CreateFeatureClass tool.
// ISpatialReference3 sr = null;
IGPEnvironment env = envMgr.FindEnvironment("outputCoordinateSystem");
// Same as Input
if (env.Value.IsEmpty())
{
IGeoDataset ds = inputFeatureClass as IGeoDataset;
cfc.spatial_reference = ds.SpatialReference as ISpatialReference3;
}
// Use the environment setting
else
{
IGPCoordinateSystem cs = env.Value as IGPCoordinateSystem;
cfc.spatial_reference = cs.SpatialReference as ISpatialReference3;
}
// Remaining properties for Create Feature Class Tool
cfc.out_name = dsName.Name;
cfc.geometry_type = "POLYGON";
// Execute Geoprocessor
gp.Execute(cfc, null);
// Get Unique Field
int iField = inputFeatureClass.FindField(fieldParameterValue.GetAsText());
IField uniqueField = inputFeatureClass.Fields.get_Field(iField);
// Extract Clipping Polygon Geometry
IFeature polygonFeature = polygonFeatureClass.GetFeature(0);
IPolygon clippingPolygon = (IPolygon)polygonFeature.Shape;
// Spatial Filter
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = polygonFeature.ShapeCopy;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
// Debug Message
message.AddMessage("Generating TIN...");
// Create TIN
ITinEdit tinEdit = new TinClass();
// Advanced TIN Functions
ITinAdvanced2 tinAdv = (ITinAdvanced2)tinEdit;
try
{
// Initialize New TIN
IGeoDataset gds = inputFeatureClass as IGeoDataset;
tinEdit.InitNew(gds.Extent);
// Add Mass Points to TIN
tinEdit.StartEditing();
tinEdit.AddFromFeatureClass(inputFeatureClass, spatialFilter, uniqueField, uniqueField, esriTinSurfaceType.esriTinMassPoint);
tinEdit.Refresh();
// Get TIN Nodes
ITinNodeCollection tinNodeCollection = (ITinNodeCollection)tinEdit;
// Report Node Count
message.AddMessage("Input Node Count: " + inputFeatureClass.FeatureCount(null).ToString());
message.AddMessage("TIN Node Count: " + tinNodeCollection.NodeCount.ToString());
// Open Output Feature Class
IFeatureClass outputFeatureClass = m_GPUtilities.OpenFeatureClassFromString(outputParameterValue.GetAsText());
// Debug Message
message.AddMessage("Generating Polygons...");
// Create Voronoi Polygons
tinNodeCollection.ConvertToVoronoiRegions(outputFeatureClass, null, clippingPolygon, "", "");
// Release COM Objects
tinEdit.StopEditing(false);
System.Runtime.InteropServices.Marshal.ReleaseComObject(tinNodeCollection);
System.Runtime.InteropServices.Marshal.ReleaseComObject(tinEdit);
}
catch (Exception ex)
{
message.AddError(2, ex.Message);
}
}
//创建新的shp文件
public void creatNewFeatureClass(string out_PathFolder,string out_Name,string out_template)
{
try
{
ESRI.ArcGIS.DataManagementTools.CreateFeatureclass creatFeature = new CreateFeatureclass();
creatFeature.out_path = out_PathFolder;
creatFeature.out_name = out_Name;
creatFeature.geometry_type = "POLYGON";
creatFeature.template = out_template;
gp.Execute(creatFeature, null);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
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 override void OnClick()
{
CreateFeatureclass gpCreate = new CreateFeatureclass();
}
