/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); // Close the requested job try { IJTXJobManager jobManager = this.WmxDatabase.JobManager; IJTXJob3 job = jobManager.GetJob(m_jobToClose) as IJTXJob3; IJTXConfiguration3 configMgr = this.WmxDatabase.ConfigurationManager as IJTXConfiguration3; if (job.Stage != jtxJobStage.jtxJobStageClosed && !job.CanClose()) { throw new WmauException(WmauErrorCodes.C_CANNOT_CLOSE_JOB_ERROR); } msgs.AddMessage("Closing job " + m_jobToClose + " (" + job.Name + ")"); job.Close(); // Once the job is closed, do the other things that still need to be handled // separately (status updates, notifications, ...) Common.WmauHelperFunctions.UpdateJobStatus(this.WmxDatabase, job); job.Store(); job.LogJobAction( configMgr.GetActivityType(ESRI.ArcGIS.JTX.Utilities.Constants.ACTTYPE_CLOSE_JOB), null, string.Empty); Common.WmauHelperFunctions.SendNotification( ESRI.ArcGIS.JTX.Utilities.Constants.NOTIF_JOB_CLOSED, this.WmxDatabase, job); // Set the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_JOB_CLOSED); IGPLong outValue = new GPLongClass(); outValue.Value = m_jobToClose; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Update the internal parameters used by this GP tool string styleFileName = this.DetermineStyleFileName(this.m_xmlFilePath); // Retrieve the TA workbook IJTXConfiguration3 defaultDbReadonly = WmxDatabase.ConfigurationManager as IJTXConfiguration3; IJTXTaskAssistantWorkflowRecord tamRecord = defaultDbReadonly.GetTaskAssistantWorkflowRecord(this.m_sourceName); // Delete any existing workflow or style files that we're going to replace this.DeleteFile(this.m_xmlFilePath); this.DeleteFile(styleFileName); // Save the TAM workbook data out to file this.SaveStringToXmlFile(tamRecord.WorkflowXML, this.m_xmlFilePath); this.SaveStringToXmlFile(tamRecord.StyleXML, styleFileName); msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (System.IO.IOException ioEx) { try { WmauError error = new WmauError(WmauErrorCodes.C_FILE_ACCESS_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ioEx.Message); } catch { // Catch anything else that possibly happens } } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_TAM_DOWNLOAD_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } // Retrieve the parameter in which the list of MXDs will be stored WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameter3 param = paramMap.GetParam(C_PARAM_MAP_DOCUMENT_LIST); IGPParameterEdit3 paramEdit = paramMap.GetParamEdit(C_PARAM_MAP_DOCUMENT_LIST); // Set up the multi-value objects IGPMultiValue mvValue = new GPMultiValueClass(); mvValue.MemberDataType = param.DataType; // Get the list of MXD names and add them all to the multivalue SortedList <string, string> mapDocuments = this.ListMapDocumentsInDatabase(); foreach (string mapDocName in mapDocuments.Keys) { IGPString strVal = new GPStringClass(); strVal.Value = mapDocName; mvValue.AddValue(strVal as IGPValue); msgs.AddMessage("Map Document: " + mapDocName); } paramEdit.Value = (IGPValue)mvValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { WmauParameterMap paramMap = new WmauParameterMap(paramValues); IJTXConfiguration3 configMgr = this.WmxDatabase.ConfigurationManager as IJTXConfiguration3; // Determine which query the user has selected SortedList <string, IJTXJobQuery> queryMap = new SortedList <string, IJTXJobQuery>(); AddQueriesFromContainer(configMgr.GetPublicQueryContainer(), string.Empty, queryMap); if (!queryMap.Keys.Contains(m_queryName)) { throw new WmauException(WmauErrorCodes.C_UNKNOWN_QUERY_ERROR); } // Run the selected job query IJTXJobQuery tempQuery = queryMap[m_queryName]; // TODO: Change this to use ".Evaluate()" once it's fixed List <int> jobIds = ParseJobIdsFromXml(tempQuery.EvaluateXML()); jobIds.Sort(); // Store the job IDs from the query into the output GP param IGPMultiValue outputValues = new GPMultiValueClass(); outputValues.MemberDataType = paramMap.GetParam(C_PARAM_OUT_JOB_ID_LIST).DataType; for (int i = 0; i < jobIds.Count; i++) { IGPLong jobIdVal = new GPLongClass(); jobIdVal.Value = jobIds[i]; outputValues.AddValue(jobIdVal as IGPValue); msgs.AddMessage("Found job: " + jobIds[i]); } paramMap.GetParamEdit(C_PARAM_OUT_JOB_ID_LIST).Value = (IGPValue)outputValues; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } // Retrieve the MXD and delete it IJTXConfiguration3 configMgr = WmxDatabase.ConfigurationManager as IJTXConfiguration3; IJTXMap map = configMgr.GetJTXMap(m_mxdName); configMgr.DeleteJTXMap(map.ID); // Update the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_MXD_NAME); IGPString outValue = new GPStringClass(); outValue.Value = m_mxdName; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_DELETE_MXD_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } finally { // Release any COM objects here! } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Retrieve the parameter in which the list of workbook names will be stored WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameter3 param = paramMap.GetParam(C_PARAM_TAM_WORKBOOK_LIST); IGPParameterEdit3 paramEdit = paramMap.GetParamEdit(C_PARAM_TAM_WORKBOOK_LIST); // Set up the multi-value objects IGPMultiValue mvValue = new GPMultiValueClass(); mvValue.MemberDataType = param.DataType; // Get the list of TA workbook names and add them all to the multivalue SortedList <string, string> tamWorkbooks = this.ListTamWorkbooksInDatabase(); foreach (string workbookAlias in tamWorkbooks.Keys) { IGPString strVal = new GPStringClass(); strVal.Value = workbookAlias; mvValue.AddValue(strVal as IGPValue); msgs.AddMessage("Workbook: " + workbookAlias); } paramEdit.Value = (IGPValue)mvValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { WmauParameterMap paramMap = new WmauParameterMap(paramValues); // Retrieve the parameter in which the list of workbook names will be stored IGPParameter3 param = paramMap.GetParam(C_PARAM_JOB_ID_LIST); IGPParameterEdit3 paramEdit = paramMap.GetParamEdit(C_PARAM_JOB_ID_LIST); IGPParameter3 filterParam = paramMap.GetParam(C_PARAM_SQL_QUERY_FILTER); // Get the multivalue object into which the output will be stored IGPMultiValue outputValues = new GPMultiValueClass(); outputValues.MemberDataType = param.DataType; for (int i = 0; i < outputValues.Count; i++) { outputValues.Remove(i); } // Get the list of job IDs and add them all to the multivalue SortedList <int, string> jobs = this.ListJobsInDatabase(filterParam.Value.GetAsText()); msgs.AddMessage("Jobs matching query:"); foreach (KeyValuePair <int, string> item in jobs) { IGPLong value = new GPLongClass(); value.Value = item.Key; outputValues.AddValue(value as IGPValue); msgs.AddMessage(" " + value.Value.ToString() + " (" + item.Value + ")"); } paramEdit.Value = (IGPValue)outputValues; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); // Assign the requested job try { IJTXJobManager jobManager = this.WmxDatabase.JobManager; IJTXConfiguration3 configMgr = this.WmxDatabase.ConfigurationManager as IJTXConfiguration3; IJTXJob3 job = jobManager.GetJob(m_jobId) as IJTXJob3; // As of Jan. 2011, the core Workflow Manager libraries do not // seem to check if the user has the privilege to add a comment // if a job as a hold on it. So run the check here. IJTXJobHolds jobHolds = job as IJTXJobHolds; if (jobHolds.Holds != null && jobHolds.Holds.Count > 0 && !CurrentUserHasPrivilege(ESRI.ArcGIS.JTX.Utilities.Constants.PRIV_CAN_ADD_COMMENTS_FOR_HELD_JOBS)) { throw new WmauException(WmauErrorCodes.C_NO_ADD_COMMENTS_HELD_JOBS_ERROR); } // If we get this far, then add the comment to the job. IJTXActivityType commentType = configMgr.GetActivityType(ESRI.ArcGIS.JTX.Utilities.Constants.ACTTYPE_COMMENT); job.LogJobAction(commentType, null, m_comment); job.Store(); // Set the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_JOB_ID); IGPLong outValue = new GPLongClass(); outValue.Value = m_jobId; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); // Assign the requested job try { IJTXJobManager jobManager = this.WmxDatabase.JobManager; IJTXWorkflowExecution3 jobExec = jobManager.GetJob(m_jobId) as IJTXWorkflowExecution3; // Don't try to deal with the case of multiple active steps int[] currentStepIds = jobExec.GetCurrentSteps(); if (currentStepIds.Length != 1) { throw new WmauException(WmauErrorCodes.C_NO_OR_MULTIPLE_STEPS_ERROR); } jobExec.RunStepChecks(currentStepIds[0], true); IJTXExecuteInfo execInfo = jobExec.RunStep(currentStepIds[0], false, true, false, this); if (execInfo.ThrewError) { throw new WmauException( WmauErrorCodes.C_JOB_EXECUTION_ERROR, new Exception(execInfo.ErrorCode.ToString() + ": " + execInfo.ErrorDescription)); } // Set the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_JOB_ID); IGPLong outValue = new GPLongClass(); outValue.Value = m_jobId; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
public IGPMessages Validate(IArray paramValues, bool updateValues, IGPEnvironmentManager envMgr) { if (m_util == null) // delay constructor activities.... they segfault arcmap { m_util = new GPUtilitiesClass(); m_outp_schema = new AoTable( AoField.Integer("left_fid"), AoField.Integer("right_fid") ); } IGPMessages ms = m_util.InternalValidate(ParameterInfo, paramValues, updateValues, true, envMgr); bool passed = AoGPParameter.ValidateAll(m_parms, paramValues, ms); IGPMessage m = (IGPMessage)ms; if (!passed || m.IsError()) { ms.AddError(2, "An error here."); return(ms); } // TODO: Set up the output schema. IGPParameter outparam = paramValues.get_Element(3) as IGPParameter; IGPFeatureLayer fl = outparam.Value as IGPFeatureLayer; if (fl == null) { fl = new GPFeatureLayerClass(); } fl.DEFeatureClass = new DEFeatureClassClass(); (fl.DEFeatureClass as IDETable).Fields = m_outp_schema.Fields; // Set up its catalog path / name.. // IDataElement de = (fc as IDataElement; // if ( (old_val == null || old_val.DEFeatureClass == null) && src_path != null && src_path.DEFeatureClass != null) { // //src_path = m_util.UnpackGPValue(src_path) as IGPFeatureLayer; // IDataElement srcde = src_path.DEFeatureClass as IDataElement; // lazy cut-n-paste shortcut // de.CatalogPath = srcde.GetPath() + "\\" + srcde.GetBaseName() + "_bndgen." + srcde.GetExtension();// old_val.CatalogPath; // de.Children = srcde.Children; // de.ChildrenExpanded = srcde.ChildrenExpanded; // de.MetadataRetrieved = srcde.MetadataRetrieved; // //de.Name = old_val.Name + "bndgen"; // de.Type = srcde.Type; // } m_util.PackGPValue(fl as IGPValue, outparam); return(ms); }
/// <summary> /// Mandatory override. Provide GP tool body and logic. /// </summary> public virtual void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Basic error checking; ensure a Workflow Manager database is defined if (!IsWorkflowManagerDatabaseSet()) { WmauError error = new WmauError(WmauErrorCodes.C_INVALID_WMX_DB_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message); throw new WmxDefaultDbNotSetException(); } // Update the internal parameters used by this GP tool this.ExtractParameters(paramValues); }
/// <summary> /// Post validates the given set of values. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="environmentManager">Provides access to all the current environments and settings of the current client.</param> /// <param name="messages">The messages that are reported to the user.</param> /// <remarks> /// This method is called after returning from the internal validation routine performed by the geoprocessing /// framework. This method is where you can examine the messages created from internal validation and change them if /// desired. /// You should only change existing messages here and should not add any new messages. /// </remarks> public void UpdateMessages(IArray parameters, IGPEnvironmentManager environmentManager, IGPMessages messages) { try { var list = parameters.AsEnumerable <IGPParameter>().ToDictionary(o => o.Name, o => o); this.UpdateMessages(list, environmentManager, messages, this.Utilities); } catch (Exception ex) { messages.AddError(-1, ex.StackTrace); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Send the notification IJTXJobManager jobManager = this.WmxDatabase.JobManager; Common.WmauHelperFunctions.SendNotification( m_notificationName, this.WmxDatabase, jobManager.GetJob(m_jobId)); // Set the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_JOB_ID); IGPLong outValue = new GPLongClass(); outValue.Value = m_jobId; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
/// <summary> /// Executes the geoprocessing function using the given array of parameter values. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="trackCancel">The track cancel.</param> /// <param name="environmentManager">Provides access to all the current environments and settings of the current client.</param> /// <param name="messages">The messages.</param> /// <exception cref="System.ArgumentOutOfRangeException"> /// parameters;A function tool must always have an output. At the minimum, /// your function should output a Boolean value containing success or failure. /// </exception> public virtual void Execute(IArray parameters, ITrackCancel trackCancel, IGPEnvironmentManager environmentManager, IGPMessages messages) { try { if (parameters.AsEnumerable <IGPParameter>().All(o => o.Direction != esriGPParameterDirection.esriGPParameterDirectionOutput)) { throw new ArgumentOutOfRangeException(nameof(parameters), @"A function tool must always have an output. At the minimum, your function should output a Boolean value containing success or failure."); } var list = this.Unpack(parameters); this.Execute(list, trackCancel, environmentManager, messages, this.Utilities); } catch (Exception ex) { messages.AddError(-1, ex.StackTrace); } }
// Execute: Execute the function given the array of the parameters public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message) { // Get the first Input Parameter IGPParameter parameter = (IGPParameter)paramvalues.get_Element(0); // UnPackGPValue. This ensures you get the value either form the dataelement or GpVariable (ModelBuilder) IGPValue parameterValue = m_GPUtilities.UnpackGPValue(parameter); // Open Input Dataset IFeatureClass inputFeatureClass; IQueryFilter qf; m_GPUtilities.DecodeFeatureLayer(parameterValue, out inputFeatureClass, out qf); if (inputFeatureClass == null) { message.AddError(2, "Could not open input dataset."); return; } // Add the field if it does not exist. int indexA; parameter = (IGPParameter)paramvalues.get_Element(1); string field = parameter.Value.GetAsText(); indexA = inputFeatureClass.FindField(field); if (indexA < 0) { IFieldEdit fieldEdit = new FieldClass(); fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble; fieldEdit.Name_2 = field; inputFeatureClass.AddField(fieldEdit); } int featcount = inputFeatureClass.FeatureCount(null); //Set the properties of the Step Progressor IStepProgressor pStepPro = (IStepProgressor)trackcancel; pStepPro.MinRange = 0; pStepPro.MaxRange = featcount; pStepPro.StepValue = (1); pStepPro.Message = "Calculating Area"; pStepPro.Position = 0; pStepPro.Show(); // Create an Update Cursor indexA = inputFeatureClass.FindField(field); IFeatureCursor updateCursor = inputFeatureClass.Update(qf, false); IFeature updateFeature = updateCursor.NextFeature(); IGeometry geometry; IArea area; double dArea; while (updateFeature != null) { geometry = updateFeature.Shape; area = (IArea)geometry; dArea = area.Area; updateFeature.set_Value(indexA, dArea); updateCursor.UpdateFeature(updateFeature); updateFeature.Store(); updateFeature = updateCursor.NextFeature(); pStepPro.Step(); } pStepPro.Hide(); // Release the update cursor to remove the lock on the input data. System.Runtime.InteropServices.Marshal.ReleaseComObject(updateCursor); }
public void Execute(IArray paramvalues, ITrackCancel TrackCancel, IGPEnvironmentManager envMgr, IGPMessages message) { IAoInitialize aoInitialize = new AoInitializeClass(); esriLicenseStatus naStatus = esriLicenseStatus.esriLicenseUnavailable; IGPUtilities2 gpUtil = null; IDataset osmDataset = null; try { if (!aoInitialize.IsExtensionCheckedOut(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork)) { naStatus = aoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork); } gpUtil = new GPUtilitiesClass(); // OSM Dataset Param IGPParameter osmDatasetParam = paramvalues.get_Element(in_osmFeatureDataset) as IGPParameter; IDEDataset2 osmDEDataset = gpUtil.UnpackGPValue(osmDatasetParam) as IDEDataset2; if (osmDEDataset == null) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), osmDatasetParam.Name)); return; } osmDataset = gpUtil.OpenDatasetFromLocation(((IDataElement)osmDEDataset).CatalogPath) as IDataset; // Network Config File Param IGPParameter osmNetConfigParam = paramvalues.get_Element(in_NetworkConfigurationFile) as IGPParameter; IGPValue osmNetConfigFile = gpUtil.UnpackGPValue(osmNetConfigParam) as IGPValue; if ((osmNetConfigFile == null) || (string.IsNullOrEmpty(osmNetConfigFile.GetAsText()))) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), osmNetConfigParam.Name)); return; } // Target Network Dataset Param IGPParameter ndsParam = paramvalues.get_Element(out_NetworkDataset) as IGPParameter; IDataElement deNDS = gpUtil.UnpackGPValue(ndsParam) as IDataElement; if (deNDS == null) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), ndsParam.Name)); return; } // Create Network Dataset using (NetworkDataset nd = new NetworkDataset(osmNetConfigFile.GetAsText(), osmDataset, deNDS.Name, message, TrackCancel)) { if (nd.CanCreateNetworkDataset()) { nd.CreateNetworkDataset(); } } } catch (UserCancelException ex) { message.AddWarning(ex.Message); } catch (Exception ex) { message.AddError(120008, ex.Message); #if DEBUG message.AddError(120008, ex.StackTrace); #endif } finally { if (osmDataset != null) { ComReleaser.ReleaseCOMObject(osmDataset); } if (naStatus == esriLicenseStatus.esriLicenseCheckedOut) { aoInitialize.CheckInExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork); } if (gpUtil != null) { ComReleaser.ReleaseCOMObject(gpUtil); } GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); // Back up the database IJTXTransfer transfer = WmxDatabase as IJTXTransfer; try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } msgs.AddMessage("Retrieving data from Workflow Manager database..."); string xml = transfer.ExportConfiguration(); // Pretty-print the JXL file, if the user has selected that option if (this.m_prettyPrint) { msgs.AddMessage("Making the data more easily human-readable..."); XmlDocument xmlDoc = new XmlDocument(); XmlTextReader xmlTextReader = new XmlTextReader(xml, XmlNodeType.Document, null); xmlTextReader.WhitespaceHandling = WhitespaceHandling.None; xmlDoc.Load(xmlTextReader); xmlTextReader.Close(); msgs.AddMessage("Saving data to file..."); System.IO.TextWriter textWriter = new System.IO.StreamWriter(this.m_jxlFilePath, false, System.Text.Encoding.UTF8, xml.Length); XmlTextWriter xmlTextWriter = new XmlTextWriter(textWriter); xmlTextWriter.Formatting = Formatting.Indented; xmlDoc.Save(xmlTextWriter); xmlTextWriter.Close(); textWriter.Close(); } else { msgs.AddMessage("Saving data to file..."); System.IO.TextWriter textWriter = new System.IO.StreamWriter(this.m_jxlFilePath, false, System.Text.Encoding.UTF8, xml.Length); textWriter.Write(xml); textWriter.Close(); } msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_JXL_BACKUP_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } } }
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; }
/// <summary> /// Returns a list of all of the workspaces in the C_DB_WORKSHEET_NAME worksheet. /// Workspaces that could not be opened will not be included. /// </summary> /// <returns></returns> public List <Common.WorkspaceInfo> GetWorkspacesFromSpreadsheet() { // Error checking: make sure that the required worksheet can be found if (!this.Open()) { WmauError error = new WmauError(WmauErrorCodes.C_EXCEL_WORKBOOK_ERROR); m_gpMessages.AddError(error.ErrorCodeAsInt, error.Message); throw new Exception(error.Message); } Worksheet worksheet = this.GetWorksheetByName(C_DB_WORKSHEET_NAME); if (worksheet == null) { WmauError error = new WmauError(WmauErrorCodes.C_EXCEL_WORKSHEET_ERROR); m_gpMessages.AddError(error.ErrorCodeAsInt, error.Message); throw new Exception(error.Message); } // Create the output element List <Common.WorkspaceInfo> workspaceList = new List <Common.WorkspaceInfo>(); // Do some math and set up the "column header" range (used to determine which field is which) int numColumns = worksheet.UsedRange.Columns.Count; int numRows = worksheet.UsedRange.Rows.Count; int dataStartRowNum = 2; int dataEndRowNum = dataStartRowNum + numRows; string headerStartCell = "A1"; string headerEndCell = GetExcelColumnFromIndex(numColumns) + "1"; Range headerRange = worksheet.get_Range(headerStartCell, headerEndCell); // Iterate through all of the data rows (i.e., workspaces) in the worksheet for (int rowNum = dataStartRowNum; rowNum < dataEndRowNum; rowNum++) { string name = string.Empty; try { // Create a range for this row of cells string dataStartCell = "A" + rowNum.ToString(); string dataEndCell = GetExcelColumnFromIndex(numColumns) + rowNum.ToString(); Range dataRange = worksheet.get_Range(dataStartCell, dataEndCell); // Initialize the various values of the workspace configuration object name = GetValueAsText(dataRange, FindCellMatchingText(headerRange, C_DB_ALIAS).Column); if (string.IsNullOrEmpty(name)) { // Stop reading through the worksheet once we've found a row without any workspace listed break; } // Create the workspace configuration object that will be set up from this row Common.WorkspaceInfo workspaceInfo = new Common.WorkspaceInfo(); workspaceInfo.Name = name; workspaceInfo.Server = GetValueAsText(dataRange, FindCellMatchingText(headerRange, C_SERVER).Column); workspaceInfo.Instance = GetValueAsText(dataRange, FindCellMatchingText(headerRange, C_INSTANCE).Column); workspaceInfo.Database = GetValueAsText(dataRange, FindCellMatchingText(headerRange, C_DATABASE).Column); workspaceInfo.Version = GetValueAsText(dataRange, FindCellMatchingText(headerRange, C_VERSION).Column); workspaceInfo.UseOsAuthentication = GetValueAsBool(dataRange, FindCellMatchingText(headerRange, C_OS_AUTH).Column); workspaceInfo.UseIndividualLogins = GetValueAsBool(dataRange, FindCellMatchingText(headerRange, C_INDIVIDUAL_LOGINS).Column); if (workspaceInfo.UseOsAuthentication) { if (workspaceInfo.UseIndividualLogins) { throw new Exception("Workspace '" + name + "': OS authentication and individual logins are mutually exclusive"); } // Nothing else to do if OS authentication is being used } else { if (workspaceInfo.UseIndividualLogins) { List <Common.WorkspaceInfo.LoginInfo> loginList = GetLoginInfoFromSpreadsheet(workspaceInfo.Name); foreach (Common.WorkspaceInfo.LoginInfo login in loginList) { workspaceInfo.AddLogin( login.WmxUsername, login.DatabaseUsername, login.DatabasePassword, login.IsPasswordEncrypted); } } else { string username = GetValueAsText(dataRange, FindCellMatchingText(headerRange, C_USERNAME).Column); string password = GetValueAsText(dataRange, FindCellMatchingText(headerRange, C_PASSWORD).Column); bool isEncrypted = GetValueAsBool(dataRange, FindCellMatchingText(headerRange, C_IS_ENCRYPTED).Column); // Only base64-encoded encrypted passwords are supported by this // utility, so unencode the password before sending it along to // the WMX object if (isEncrypted) { byte[] pwBytes = System.Convert.FromBase64String(password); password = System.Text.UTF8Encoding.UTF8.GetString(pwBytes); } // Store the shared username and password workspaceInfo.AddLogin(string.Empty, username, password, isEncrypted); } } workspaceList.Add(workspaceInfo); } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_WORKSPACE_FETCH_ERROR); string errMsg = error.Message; errMsg += System.Environment.NewLine + ex.Message; errMsg += System.Environment.NewLine + "Skipping workspace '" + name + "'"; m_gpMessages.AddError(error.ErrorCodeAsInt, errMsg); continue; } } this.Close(); return(workspaceList); }
// Execute: Execute the function given the array of the parameters public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message) { IFeatureClass outputFeatureClass = null; try { // get the input feature class IGPMultiValue inputFeatureClasses_Parameter = (IGPMultiValue)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(0)); layer[] input_featureClasses = new layer[inputFeatureClasses_Parameter.Count]; for (int i = 0; i < inputFeatureClasses_Parameter.Count; i++) { IGPValue inputFeatureClass_Parameter = inputFeatureClasses_Parameter.get_Value(i); IFeatureClass inputFeatureClass; IQueryFilter inputQF; m_GPUtilities.DecodeFeatureLayer(inputFeatureClass_Parameter, out inputFeatureClass, out inputQF); input_featureClasses[i] = new layer() { featureclass = inputFeatureClass, qFilter = inputQF}; } if (input_featureClasses.Length == 0 || input_featureClasses.Any(w=> w.featureclass == null)) { message.AddError(2, "Could not open one or more input dataset."); return; } //IFields additionalFields = new FieldsClass(); //additionalFields.AddField(FEATURE_SOURCE_FIELD_NAME, esriFieldType.esriFieldTypeString); //additionalFields.AddField(FEATURE_ID_FIELD_NAME, esriFieldType.esriFieldTypeInteger); //additionalFields.AddField( // input_featureClasses[0].featureclass.Fields.get_Field( // input_featureClasses[0].featureclass.Fields.FindField( // input_featureClasses[0].featureclass.ShapeFieldName))); // create the output feature class IGPValue outputFeatureClass_Parameter = m_GPUtilities.UnpackGPValue(paramvalues.get_Element(1)); outputFeatureClass = GPHelperFunctions.CreateFeatureClass(outputFeatureClass_Parameter, envMgr); if (outputFeatureClass == null) { message.AddError(2, "Could not create output dataset."); return; } IGPString curveTypeParameter = (IGPString)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(2)); ArcConstructionMethods method; if (!Enum.TryParse<ArcConstructionMethods>(curveTypeParameter.Value, true, out method)) { message.AddError(2, string.Format("The value {0} is not expected. Expected values are: {1}.", curveTypeParameter.Value, string.Join(",", Enum.GetNames(typeof(ArcConstructionMethods))))); return; } IStepProgressor stepPro = (IStepProgressor)trackcancel; GPHelperFunctions.dropSpatialIndex(outputFeatureClass); BoostVoronoi bv = new BoostVoronoi(100); double minX = int.MaxValue, minY = int.MaxValue, maxX = int.MinValue, maxY = int.MinValue; List<site_key> point_sites = new List<site_key>(); List<site_key> segment_sites = new List<site_key>(); for (short i = 0; i < input_featureClasses.Length; i++) { layer l = input_featureClasses[i]; int featcount = l.featureclass.FeatureCount(l.qFilter); stepPro.MinRange = 0; stepPro.MaxRange = featcount; stepPro.StepValue = (1); stepPro.Message = "Reading features"; stepPro.Position = 0; stepPro.Show(); IFeatureCursor cursor = null; IFeature row = null; try { cursor = l.featureclass.Search(l.qFilter, false); while ((row = cursor.NextFeature()) != null) { stepPro.Step(); IPoint point = row.Shape as IPoint; if (point != null) { double X = point.X; double Y = point.Y; minX = Math.Min(minX, X); maxX = Math.Max(maxX, X); minY = Math.Min(minY, Y); maxY = Math.Max(maxY, Y); bv.AddPoint(point.X, point.Y); point_sites.Add(new site_key(i, row.OID)); } IMultipoint multipoint = row.Shape as IMultipoint; if (multipoint != null) { IPointCollection pointCollection = (IPointCollection)multipoint; IEnumVertex vertices = pointCollection.EnumVertices; IPoint vertex = null; int part, index; vertices.Next(out vertex, out part, out index); minX = Math.Min(minX, multipoint.Envelope.XMin); maxX = Math.Max(maxX, multipoint.Envelope.XMax); minY = Math.Min(minY, multipoint.Envelope.YMin); maxY = Math.Max(maxY, multipoint.Envelope.YMax); while (vertex != null) { bv.AddPoint(vertex.X, vertex.Y); point_sites.Add(new site_key(i, row.OID)); vertices.Next(out vertex, out part, out index); } } IPolyline polyline = row.Shape as IPolyline; if (polyline != null) { double fromX = polyline.FromPoint.X; double fromY = polyline.FromPoint.Y; double toX = polyline.ToPoint.X; double toY = polyline.ToPoint.Y; if (toX < fromX) { minX = Math.Min(minX, toX); maxX = Math.Max(maxX, fromX); } else { minX = Math.Min(minX, fromX); maxX = Math.Max(maxX, toX); } if (toY < fromY) { minY = Math.Min(minY, toY); maxY = Math.Max(maxY, fromY); } else { minY = Math.Min(minY, fromY); maxY = Math.Max(maxY, toY); } bv.AddSegment( polyline.FromPoint.X, polyline.FromPoint.Y, polyline.ToPoint.X, polyline.ToPoint.Y ); segment_sites.Add(new site_key(i, row.OID)); } Marshal.ReleaseComObject(row); } } finally { if (row != null) Marshal.ReleaseComObject(row); if (cursor != null) Marshal.ReleaseComObject(cursor); stepPro.Hide(); } } message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY)); int width = Math.Max((int)((maxX - minX) * 0.1), 1); int height = Math.Max((int)((maxY - minY) * 0.1), 1); maxX = maxX + width; minX = minX - width; maxY = maxY + height; minY = minY - height; message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY)); bv.AddSegment(minX, minY, maxX, minY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(maxX, minY, maxX, maxY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(maxX, maxY, minX, maxY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(minX, maxY, minX, minY); segment_sites.Add(new site_key(-1, -1)); stepPro.Message = "Solve Voronoi"; stepPro.MaxRange = 0; stepPro.MaxRange = 0; stepPro.Show(); bv.Construct(); stepPro.Hide(); int featureSourceIndx = outputFeatureClass.Fields.FindField(FEATURE_SOURCE_FIELD_NAME); int featureIDIndx = outputFeatureClass.Fields.FindField(FEATURE_ID_FIELD_NAME); IFeatureCursor inserts = null; IFeatureBuffer buffer = null; try { object missing = Type.Missing; ISpatialReference spatialReference = ((IGeoDataset)outputFeatureClass).SpatialReference; inserts = outputFeatureClass.Insert(false); buffer = outputFeatureClass.CreateFeatureBuffer(); List<Cell> cells = bv.Cells; message.AddMessage(string.Format("{0} cells calculated", cells.Count)); List<Edge> edges = bv.Edges; message.AddMessage(string.Format("{0} edges calculated", edges.Count)); List<Vertex> vertices = bv.Vertices; message.AddMessage(string.Format("{0} vertexes calculated", vertices.Count)); stepPro.Message = "Write cells"; stepPro.MaxRange = 0; stepPro.MaxRange = cells.Count; stepPro.Show(); for (int cellIndex = 0; cellIndex < cells.Count; cellIndex++) { try { if(cellIndex % 5000 == 0) message.AddMessage(String.Format("{0}. {1} cells processed.", DateTime.Now, cellIndex)); Cell cell = cells[cellIndex]; int currentSite = cell.Site; IGeometryCollection geometryCollection = new GeometryBagClass() { SpatialReference = spatialReference }; //ignores any sliver cells if (cell.IsOpen || cell.EdgesIndex.Count < 3) continue; ISegmentCollection segmentCollection = createSegments(cell, bv, method, spatialReference); if (((IArea)segmentCollection).Area <= 0) { message.AddMessage("A invalid geometry has been detected, try reversing the orientation."); ISegmentCollection reversed_segmentCollection = new PolygonClass() { SpatialReference = spatialReference }; for (int i = segmentCollection.SegmentCount - 1; i >= 0; i--) { ISegment segment = (ISegment)segmentCollection.get_Segment(i); segment.ReverseOrientation(); reversed_segmentCollection.AddSegment(segment); } segmentCollection = reversed_segmentCollection; } ((IPolygon)segmentCollection).SpatialReference = spatialReference; if (((IArea)segmentCollection).Area <= 0) { message.AddWarning("An empty shell has been created"); for (int i = 0; i < segmentCollection.SegmentCount; i++) { ISegment segment = (ISegment)segmentCollection.get_Segment(i); message.AddMessage(String.Format("From {0}, {1} To {2},{3}", segment.FromPoint.X, segment.FromPoint.Y, segment.ToPoint.X, segment.ToPoint.Y)); } } //set attributes site_key sk = (currentSite >= point_sites.Count) ? segment_sites[currentSite - point_sites.Count] : point_sites[currentSite]; if (!sk.isEmpty) { buffer.set_Value(featureSourceIndx, input_featureClasses[sk.featureClassIndex].featureclass.AliasName); buffer.set_Value(featureIDIndx, sk.objectID); } else { buffer.set_Value(featureSourceIndx, DBNull.Value); buffer.set_Value(featureIDIndx, DBNull.Value); } IPolygon voronoiPolygon = (IPolygon)segmentCollection; buffer.Shape = (IPolygon)voronoiPolygon; inserts.InsertFeature(buffer); } catch (Exception e) { message.AddWarning("Failed to create a cell"); } } } finally { if (buffer != null) Marshal.ReleaseComObject(buffer); if (inserts != null) Marshal.ReleaseComObject(inserts); } GPHelperFunctions.createSpatialIndex(outputFeatureClass); } catch (Exception exx) { message.AddError(2, exx.Message); message.AddMessage(exx.ToString()); } finally { if (outputFeatureClass != null) Marshal.ReleaseComObject(outputFeatureClass); ((IProgressor)trackcancel).Hide(); } }
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; }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } // Stash away the executing user's information, if appropriate string username = ESRI.ArcGIS.JTXUI.ConfigurationCache.GetCurrentSystemUser(ESRI.ArcGIS.JTXUI.ConfigurationCache.UseUserDomain); IJTXConfiguration3 configMgr = this.WmxDatabase.ConfigurationManager as IJTXConfiguration3; IJTXUser3 executingUser = configMgr.GetUser(username) as IJTXUser3; // Import the AD information string domain = System.Environment.UserDomainName; string domainUsername = string.Empty; string domainPassword = string.Empty; int numUsers = 0; int numGroups = 0; ActiveDirectoryHelper.SyncronizeJTXDatabaseWithActiveDirectory(this.WmxDatabase, domain, domainUsername, domainPassword, m_userGroup, m_groupGroup, out numGroups, out numUsers); // If the tool was set to preserve the current user's account and the user // was removed from the DB, then re-add their account if (configMgr.GetUser(username) == null) { if (m_preserveCurrentUser) { IJTXConfigurationEdit2 configEdit = this.WmxDatabase.ConfigurationManager as IJTXConfigurationEdit2; IJTXUserConfig newUser = configEdit.CreateUser() as IJTXUserConfig; newUser.FirstName_2 = executingUser.FirstName; newUser.FullName_2 = executingUser.FullName; newUser.LastName_2 = executingUser.LastName; newUser.UserName_2 = executingUser.UserName; (newUser as IJTXUser3).IsAdministrator = executingUser.IsAdministrator; newUser.Store(); msgs.AddMessage("User '" + username + "' not found in Active Directory group '" + m_userGroup + "'; re-added placeholder to Workflow Manager database"); } else { msgs.AddWarning("User '" + username + "' removed from Workflow Manager database"); } } // Update the output parameters WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParam = paramMap.GetParamEdit(C_PARAM_OUT_NUM_USERS); IGPLong value = new GPLongClass(); value.Value = numUsers; outParam.Value = value as IGPValue; outParam = paramMap.GetParamEdit(C_PARAM_OUT_NUM_GROUPS); value = new GPLongClass(); value.Value = numGroups; outParam.Value = value as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } finally { // Release any COM objects here! } }
private void parseOSMDocument(string osmFileLocation, ref IGPMessages message, ref List<string> nodeList, ref List<string> wayList, ref List<string> relationList, ref List<string> downloadedDocuments, string baseURL, api apiCapabilities) { try { XmlSerializer nodeSerializer = new XmlSerializer(typeof(node)); XmlSerializer waySerializer = new XmlSerializer(typeof(way)); XmlSerializer relationSerializer = new XmlSerializer(typeof(relation)); string requestURL = String.Empty; using (System.Xml.XmlReader osmFileXmlReader = System.Xml.XmlReader.Create(osmFileLocation)) { osmFileXmlReader.MoveToContent(); while (osmFileXmlReader.Read()) { if (osmFileXmlReader.IsStartElement()) { if (osmFileXmlReader.Name == "node") { string currentNodeString = osmFileXmlReader.ReadOuterXml(); // turn the xml node representation into a node class representation node currentNode = nodeSerializer.Deserialize(new System.IO.StringReader(currentNodeString)) as node; if (!nodeList.Contains(currentNode.id)) { nodeList.Add(currentNode.id); } } else if (osmFileXmlReader.Name == "way") { string currentWayString = osmFileXmlReader.ReadOuterXml(); // turn the xml way representation into a way class representation way currentWay = waySerializer.Deserialize(new System.IO.StringReader(currentWayString)) as way; if (!wayList.Contains(currentWay.id)) { wayList.Add(currentWay.id); } //if (currentWay.nd != null) //{ // foreach (nd wayNd in currentWay.nd) // { // if (!nodeList.Contains(wayNd.@ref)) // { // string resolveMessage = string.Format(resourceManager.GetString("GPTools_OSMGPDownload_resolveid"), resourceManager.GetString("GPTools_OSM_node"), wayNd.@ref); // message.AddMessage(resolveMessage); // requestURL = baseURL + "/api/0.6/node/" + wayNd.@ref + "/full"; // string nodeDownloadDocument = downloadOSMDocument(ref message, requestURL, apiCapabilities); // parseOSMDocument(nodeDownloadDocument, ref message, ref nodeList, ref wayList, ref relationList, ref downloadedDocuments, baseURL, apiCapabilities); // downloadedDocuments.Insert(1, nodeDownloadDocument); // } // } //} } else if (osmFileXmlReader.Name == "relation") { string currentRelationString = osmFileXmlReader.ReadOuterXml(); // turn the xml way representation into a way class representation relation currentRelation = relationSerializer.Deserialize(new System.IO.StringReader(currentRelationString)) as relation; if (!relationList.Contains(currentRelation.id)) { relationList.Add(currentRelation.id); } foreach (object relationItem in currentRelation.Items) { if (relationItem is member) { //if (((member)relationItem).type == memberType.node) //{ // string memberNodeID = ((member)relationItem).@ref; // if (!nodeList.Contains(memberNodeID)) // { // string resolveMessage = string.Format(resourceManager.GetString("GPTools_OSMGPDownload_resolveid"), resourceManager.GetString("GPTools_OSM_node"), memberNodeID); // message.AddMessage(resolveMessage); // requestURL = baseURL + "/api/0.6/node/" + memberNodeID + "/full"; // string nodeDownloadDocument = downloadOSMDocument(ref message, requestURL, apiCapabilities); // parseOSMDocument(nodeDownloadDocument, ref message, ref nodeList, ref wayList, ref relationList, ref downloadedDocuments, baseURL, apiCapabilities); // downloadedDocuments.Insert(1, nodeDownloadDocument); // } //} if (((member)relationItem).type == memberType.way) { string memberWayID = ((member)relationItem).@ref; if (!wayList.Contains(memberWayID)) { string resolveMessage = string.Format(resourceManager.GetString("GPTools_OSMGPDownload_resolveid"), resourceManager.GetString("GPTools_OSM_way"), memberWayID); message.AddMessage(resolveMessage); requestURL = baseURL + "/api/0.6/way/" + memberWayID + "/full"; string wayDownloadDocument = downloadOSMDocument(ref message, requestURL, apiCapabilities); if (!String.IsNullOrEmpty(wayDownloadDocument)) { parseOSMDocument(wayDownloadDocument, ref message, ref nodeList, ref wayList, ref relationList, ref downloadedDocuments, baseURL, apiCapabilities); downloadedDocuments.Insert(1, wayDownloadDocument); } } } else if (((member)relationItem).type == memberType.relation) { string memberRelationID = ((member)relationItem).@ref; if (!wayList.Contains(memberRelationID)) { string resolveMessage = string.Format(resourceManager.GetString("GPTools_OSMGPDownload_resolveid"), resourceManager.GetString("GPTools_OSM_relation"), memberRelationID); message.AddMessage(resolveMessage); requestURL = baseURL + "/api/0.6/relation/" + memberRelationID + "/full"; string relationDownloadDocument = downloadOSMDocument(ref message, requestURL, apiCapabilities); if (!String.IsNullOrEmpty(relationDownloadDocument)) { parseOSMDocument(relationDownloadDocument, ref message, ref nodeList, ref wayList, ref relationList, ref downloadedDocuments, baseURL, apiCapabilities); downloadedDocuments.Insert(1, relationDownloadDocument); } } } } } } } } osmFileXmlReader.Close(); } } catch (Exception ex) { message.AddError(120051, ex.Message); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } IJTXConfiguration3 configMgr = WmxDatabase.ConfigurationManager as IJTXConfiguration3; IJTXMapEdit wmxMapDoc = configMgr.GetJTXMap(this.m_targetName) as IJTXMapEdit; // If we're not allowed to overwrite an existing map document, then do some error checking if (!this.m_overwriteExisting && wmxMapDoc != null) { msgs.AddWarning("Did not overwrite Map Document: " + this.m_targetName); return; } else if (wmxMapDoc != null) { msgs.AddMessage("Replacing Map Document '" + this.m_targetName + "' in database..."); } else // wmxMapDoc == null { msgs.AddMessage("Adding Map Document '" + this.m_targetName + "' to database..."); wmxMapDoc = configMgr.CreateJTXMap() as IJTXMapEdit; } IMapDocument mapDoc = new MapDocumentClass() as IMapDocument; mapDoc.Open(this.m_mxdFilePath, string.Empty); wmxMapDoc.Name = this.m_targetName; if (!string.IsNullOrEmpty(this.m_targetCategory)) { wmxMapDoc.Category = this.m_targetCategory; } if (!string.IsNullOrEmpty(this.m_description)) { wmxMapDoc.Description = this.m_description; } wmxMapDoc.Directory = string.Empty; wmxMapDoc.FileName = string.Empty; wmxMapDoc.MapDocument = mapDoc; wmxMapDoc.Store(); mapDoc.Close(); // Update the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_TARGET_NAME); IGPString outValue = new GPStringClass(); outValue.Value = m_targetName; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_MXD_UPLOAD_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } // Create the object needed to get at the data workspaces IJTXDatabaseConnectionManager dbConnectionManager = new JTXDatabaseConnectionManagerClass(); IJTXDatabaseConnection dbConnection = dbConnectionManager.GetConnection(this.WmxDatabase.Alias); // Loop through the data workspaces until we find the one we're looking for, then // delete it bool removedWorkspace = false; for (int i = 0; i < dbConnection.DataWorkspaceCount; i++) { IJTXWorkspaceConfiguration workspaceCfg = dbConnection.get_DataWorkspace(i); if (workspaceCfg.Name.Equals(m_dataWorkspace)) { dbConnection.RemoveDataWorkspace(i); removedWorkspace = true; break; } } // Raise an error if we somehow couldn't find it (should never happen with // the domain on the input param) if (!removedWorkspace) { throw new WmauException(WmauErrorCodes.C_WORKSPACE_NOT_FOUND_ERROR); } // Set the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_DATA_WORKSPACE); IGPString outParamStr = new GPStringClass(); outParamStr.Value = m_dataWorkspace; outParamEdit.Value = outParamStr as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } finally { // Release any COM objects here! } }
internal void loadOSMNodes(string osmFileLocation, ref ITrackCancel TrackCancel, ref IGPMessages message,IGPValue targetGPValue, IFeatureClass osmPointFeatureClass, bool conserveMemory, bool fastLoad, int nodeCapacity, ref Dictionary<string, simplePointRef> osmNodeDictionary, IFeatureWorkspace featureWorkspace, ISpatialReference downloadSpatialReference, OSMDomains availableDomains, bool checkForExisting) { XmlReader osmFileXmlReader = null; XmlSerializer nodeSerializer = null; try { osmFileXmlReader = System.Xml.XmlReader.Create(osmFileLocation); nodeSerializer = new XmlSerializer(typeof(node)); ISpatialReferenceFactory spatialRef = new SpatialReferenceEnvironmentClass(); ISpatialReference wgs84 = spatialRef.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984); bool shouldProject = !((IClone)wgs84).IsEqual((IClone)downloadSpatialReference); int osmPointIDFieldIndex = osmPointFeatureClass.FindField("OSMID"); Dictionary<string, int> osmPointDomainAttributeFieldIndices = new Dictionary<string, int>(); Dictionary<string, int> osmPointDomainAttributeFieldLength = new Dictionary<string, int>(); foreach (var domains in availableDomains.domain) { int currentFieldIndex = osmPointFeatureClass.FindField(domains.name); if (currentFieldIndex != -1) { osmPointDomainAttributeFieldIndices.Add(domains.name, currentFieldIndex); osmPointDomainAttributeFieldLength.Add(domains.name, osmPointFeatureClass.Fields.get_Field(currentFieldIndex).Length); } } int tagCollectionPointFieldIndex = osmPointFeatureClass.FindField("osmTags"); int osmUserPointFieldIndex = osmPointFeatureClass.FindField("osmuser"); int osmUIDPointFieldIndex = osmPointFeatureClass.FindField("osmuid"); int osmVisiblePointFieldIndex = osmPointFeatureClass.FindField("osmvisible"); int osmVersionPointFieldIndex = osmPointFeatureClass.FindField("osmversion"); int osmChangesetPointFieldIndex = osmPointFeatureClass.FindField("osmchangeset"); int osmTimeStampPointFieldIndex = osmPointFeatureClass.FindField("osmtimestamp"); int osmMemberOfPointFieldIndex = osmPointFeatureClass.FindField("osmMemberOf"); int osmSupportingElementPointFieldIndex = osmPointFeatureClass.FindField("osmSupportingElement"); int osmWayRefCountFieldIndex = osmPointFeatureClass.FindField("wayRefCount"); // set up the progress indicator IStepProgressor stepProgressor = TrackCancel as IStepProgressor; if (stepProgressor != null) { stepProgressor.MinRange = 0; stepProgressor.MaxRange = nodeCapacity; stepProgressor.StepValue = (1); stepProgressor.Message = _resourceManager.GetString("GPTools_OSMGPFileReader_loadingNodes"); stepProgressor.Position = 0; stepProgressor.Show(); } // flag to determine if a computation of indices is required bool indexBuildRequired = false; if (nodeCapacity > 0) indexBuildRequired = true; int pointCount = 0; // let's insert all the points first if (osmPointFeatureClass != null) { IFeatureBuffer pointFeature = null; IFeatureClassLoad pointFeatureLoad = null; using (ComReleaser comReleaser = new ComReleaser()) { using (SchemaLockManager schemaLockManager = new SchemaLockManager(osmPointFeatureClass as ITable)) { if (((IWorkspace)featureWorkspace).WorkspaceFactory.WorkspaceType == esriWorkspaceType.esriRemoteDatabaseWorkspace) { pointFeatureLoad = osmPointFeatureClass as IFeatureClassLoad; } IFeatureCursor pointInsertCursor = osmPointFeatureClass.Insert(true); comReleaser.ManageLifetime(pointInsertCursor); pointFeature = osmPointFeatureClass.CreateFeatureBuffer(); comReleaser.ManageLifetime(pointFeature); if (pointFeatureLoad != null) { pointFeatureLoad.LoadOnlyMode = true; } osmFileXmlReader.MoveToContent(); while (osmFileXmlReader.Read()) { if (osmFileXmlReader.IsStartElement()) { if (osmFileXmlReader.Name == "node") { string currentNodeString = osmFileXmlReader.ReadOuterXml(); // turn the xml node representation into a node class representation ESRI.ArcGIS.OSM.OSMClassExtension.node currentNode = null; using (StringReader nodeReader = new System.IO.StringReader(currentNodeString)) { currentNode = nodeSerializer.Deserialize(nodeReader) as ESRI.ArcGIS.OSM.OSMClassExtension.node; } // check if a feature with the same OSMID already exists, because the can only be one if (checkForExisting == true) { if (CheckIfExists(osmPointFeatureClass as ITable, currentNode.id)) { continue; } } try { //if (pointFeature == null) //{ pointFeature = osmPointFeatureClass.CreateFeatureBuffer(); comReleaser.ManageLifetime(pointFeature); //} IPoint pointGeometry = new PointClass(); comReleaser.ManageLifetime(pointGeometry); pointGeometry.X = Convert.ToDouble(currentNode.lon, new CultureInfo("en-US")); pointGeometry.Y = Convert.ToDouble(currentNode.lat, new CultureInfo("en-US")); pointGeometry.SpatialReference = wgs84; if (shouldProject) { pointGeometry.Project(downloadSpatialReference); } pointFeature.Shape = pointGeometry; pointFeature.set_Value(osmPointIDFieldIndex, currentNode.id); string isSupportingNode = ""; if (_osmUtility.DoesHaveKeys(currentNode)) { // if case it has tags I assume that the node presents an entity of it own, // hence it is not a supporting node in the context of supporting a way or relation isSupportingNode = "no"; if (conserveMemory == false) { osmNodeDictionary[currentNode.id] = new simplePointRef(Convert.ToSingle(currentNode.lon, new CultureInfo("en-US")), Convert.ToSingle(currentNode.lat, new CultureInfo("en-US")), 0, 0); } } else { // node has no tags -- at this point I assume that the absence of tags indicates that it is a supporting node // for a way or a relation isSupportingNode = "yes"; if (conserveMemory == false) { osmNodeDictionary[currentNode.id] = new simplePointRef(Convert.ToSingle(currentNode.lon, new CultureInfo("en-US")), Convert.ToSingle(currentNode.lat, new CultureInfo("en-US")), 0, 0); } } insertTags(osmPointDomainAttributeFieldIndices, osmPointDomainAttributeFieldLength, tagCollectionPointFieldIndex, pointFeature, currentNode.tag); if (fastLoad == false) { if (osmSupportingElementPointFieldIndex > -1) { pointFeature.set_Value(osmSupportingElementPointFieldIndex, isSupportingNode); } if (osmWayRefCountFieldIndex > -1) { pointFeature.set_Value(osmWayRefCountFieldIndex, 0); } // store the administrative attributes // user, uid, version, changeset, timestamp, visible if (osmUserPointFieldIndex > -1) { if (!String.IsNullOrEmpty(currentNode.user)) { pointFeature.set_Value(osmUserPointFieldIndex, currentNode.user); } } if (osmUIDPointFieldIndex > -1) { if (!String.IsNullOrEmpty(currentNode.uid)) { pointFeature.set_Value(osmUIDPointFieldIndex, Convert.ToInt32(currentNode.uid)); } } if (osmVisiblePointFieldIndex > -1) { pointFeature.set_Value(osmVisiblePointFieldIndex, currentNode.visible.ToString()); } if (osmVersionPointFieldIndex > -1) { if (!String.IsNullOrEmpty(currentNode.version)) { pointFeature.set_Value(osmVersionPointFieldIndex, Convert.ToInt32(currentNode.version)); } } if (osmChangesetPointFieldIndex > -1) { if (!String.IsNullOrEmpty(currentNode.changeset)) { pointFeature.set_Value(osmChangesetPointFieldIndex, Convert.ToInt32(currentNode.changeset)); } } if (osmTimeStampPointFieldIndex > -1) { if (!String.IsNullOrEmpty(currentNode.timestamp)) { try { pointFeature.set_Value(osmTimeStampPointFieldIndex, Convert.ToDateTime(currentNode.timestamp)); } catch (Exception ex) { message.AddWarning(String.Format(_resourceManager.GetString("GPTools_OSMGPFileReader_invalidTimeFormat"), ex.Message)); } } } } try { pointInsertCursor.InsertFeature(pointFeature); pointCount = pointCount + 1; if (stepProgressor != null) { stepProgressor.Position = pointCount; } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); message.AddWarning(ex.Message); } if (TrackCancel.Continue() == false) { return; } if ((pointCount % 50000) == 0) { message.AddMessage(String.Format(_resourceManager.GetString("GPTools_OSMGPFileReader_pointsloaded"), pointCount)); pointInsertCursor.Flush(); System.GC.Collect(); } if (pointGeometry != null) Marshal.ReleaseComObject(pointGeometry); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); message.AddWarning(ex.Message); } finally { if (pointFeature != null) { Marshal.ReleaseComObject(pointFeature); if (pointFeature != null) pointFeature = null; } } currentNode = null; } } } if (stepProgressor != null) { stepProgressor.Hide(); } pointInsertCursor.Flush(); osmFileXmlReader.Close(); message.AddMessage(String.Format(_resourceManager.GetString("GPTools_OSMGPFileReader_pointsloaded"), pointCount)); message.AddMessage(_resourceManager.GetString("GPTools_buildingpointidx")); if (pointFeatureLoad != null) { pointFeatureLoad.LoadOnlyMode = false; } } } if (TrackCancel.Continue() == false) { return; } using (ComReleaser comReleaser = new ComReleaser()) { IFeatureCursor updatePoints = osmPointFeatureClass.Update(null, false); comReleaser.ManageLifetime(updatePoints); IFeature feature2Update = updatePoints.NextFeature(); while (feature2Update != null) { IPoint pointGeometry = feature2Update.Shape as IPoint; pointGeometry.ID = feature2Update.OID; feature2Update.Shape = pointGeometry; if (conserveMemory == false) { string osmid = Convert.ToString(feature2Update.get_Value(osmPointIDFieldIndex)); if (osmNodeDictionary.ContainsKey(osmid)) osmNodeDictionary[osmid].pointObjectID = feature2Update.OID; } updatePoints.UpdateFeature(feature2Update); if (TrackCancel.Continue() == false) { return; } if (feature2Update != null) Marshal.ReleaseComObject(feature2Update); if (pointGeometry != null) Marshal.ReleaseComObject(pointGeometry); feature2Update = updatePoints.NextFeature(); } } if (indexBuildRequired) { IGeoProcessor2 geoProcessor = new GeoProcessorClass(); bool storedOriginal = geoProcessor.AddOutputsToMap; try { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass(); IGPValue pointFeatureClass = gpUtilities3.MakeGPValueFromObject(osmPointFeatureClass); string fcLocation = GetLocationString(targetGPValue, osmPointFeatureClass); IIndexes featureClassIndexes = osmPointFeatureClass.Indexes; int indexPosition = -1; featureClassIndexes.FindIndex("osmID_IDX", out indexPosition); if (indexPosition == -1) { { geoProcessor.AddOutputsToMap = false; IVariantArray parameterArrary = CreateAddIndexParameterArray(fcLocation, "OSMID", "osmID_IDX", "UNIQUE", ""); IGeoProcessorResult2 gpResults2 = geoProcessor.Execute("AddIndex_management", parameterArrary, TrackCancel) as IGeoProcessorResult2; } } if (pointCount > 500) { if (pointFeatureLoad == null) { UpdateSpatialGridIndex(TrackCancel, message, geoProcessor, fcLocation); } } } catch (COMException comEx) { message.AddWarning(comEx.Message); } catch (Exception ex) { message.AddWarning(ex.Message); } finally { geoProcessor.AddOutputsToMap = storedOriginal; } } } } catch (Exception ex) { message.AddError(120100, String.Format(_resourceManager.GetString("GPTools_Utility_NodeLoadError"), ex.Message)); } finally { if (osmFileXmlReader != null) osmFileXmlReader = null; if (nodeSerializer != null) nodeSerializer = null; } }
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; }
public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages messages) { // Re-validate. IGPMessages ms = m_util.InternalValidate(ParameterInfo, paramvalues, false, false, envMgr); messages.AddMessage("MWSW Boundary Generator, v. 0.0"); if (((IGPMessage)(ms)).IsError()) { messages.AddMessages(ms); return; } if (!AoGPParameter.ValidateAll(m_parms, paramvalues, messages)) { return; } try { IGPValue inlyr = m_util.UnpackGPValue((paramvalues.get_Element(0) as IGPParameter).Value); IGPDouble ang_tol = m_util.UnpackGPValue((paramvalues.get_Element(1) as IGPParameter).Value) as IGPDouble; IGPDouble dist_tol = m_util.UnpackGPValue((paramvalues.get_Element(2) as IGPParameter).Value) as IGPDouble; IGPValue outlyr = m_util.UnpackGPValue((paramvalues.get_Element(3) as IGPParameter).Value); // DumpIt("In layer",inlyr,messages); // DumpIt("Out layer",outlyr,typeof(IGPValue),messages); IFeatureClass inputfc; IQueryFilter inputqf; m_util.DecodeFeatureLayer(inlyr, out inputfc, out inputqf); // DumpIt("In Featureclass",inputfc,typeof(IFeatureClass),messages); // DumpIt("In QF",inputqf,typeof(IQueryFilter),messages); messages.AddMessage("In angle tolerance: " + ang_tol.Value); messages.AddMessage("In distance tolerance: " + dist_tol.Value); messages.AddMessage("Input featureclass: " + inputfc.AliasName); messages.AddMessage("Output path: " + outlyr.GetAsText()); trackcancel.Progressor.Show(); trackcancel.Progressor.Message = "Processing..."; string outp_txt = outlyr.GetAsText(); AoFeatureClassName fcname = new AoFeatureClassName(outp_txt); ISpatialReference spref = AoTable.From(inputfc)[inputfc.ShapeFieldName].Field.GeometryDef.SpatialReference; string shapename = fcname.ShapeFieldName != "" ? fcname.ShapeFieldName : "Shape"; m_outp_schema[shapename] = AoField.Shape(shapename, esriGeometryType.esriGeometryPolyline, spref); // TODO: shapefiles seem to get an FID automatically, // while geodb needs an 'OBJECTID', // who knows about other workspace types? // Is there a way to figure this out w/o looking at the type? IFeatureClass outputfc = fcname.Workspace.CreateFeatureClass(fcname.Basename, m_outp_schema.Fields, null, null, esriFeatureType.esriFTSimple, shapename, ""); IStepProgressor progressor = trackcancel.Progressor as IStepProgressor; progressor.MaxRange = 200; BGenImp implementation = new BGenImp(spref, ang_tol.Value, dist_tol.Value); implementation.Run(inputfc, outputfc, delegate(double howfar) { progressor.Position = (int)(200.0 * howfar); }); messages.AddMessage("Finished, worked through " + implementation.TotalSegments + " line segments total."); return; } catch (Exception e) { while (e != null) { messages.AddError(1, "Exception: " + e.Message); e = e.InnerException; } } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); // Set the default properties for the specified job type try { IJTXConfiguration3 configMgr = this.WmxDatabase.ConfigurationManager as IJTXConfiguration3; IJTXConfigurationEdit2 configEdit = this.WmxDatabase.ConfigurationManager as IJTXConfigurationEdit2; IJTXJobTypeEdit3 jobType = configEdit.GetJobType(m_jobTypeName) as IJTXJobTypeEdit3; // Set the default data workspace for the selected job type if (m_dataWorkspaceName.Equals(C_OPT_NONE)) { jobType.DefaultDataWorkspace = null; msgs.AddMessage("Clearing default data workspace for job type '" + m_jobTypeName + "'"); } else { // Translate the workspace name to a DB name object IJTXDataWorkspaceName dwName = Common.WmauHelperFunctions.LookupWorkspaceNameObj(this.WmxDatabase, m_dataWorkspaceName); msgs.AddMessage("Default data workspace for job type '" + m_jobTypeName + "' is now '" + dwName.Name + "'"); jobType.DefaultDataWorkspace = dwName; } // Set the default parent version for the selected job type if (m_parentVersion.Equals(C_OPT_NONE)) { msgs.AddMessage("Clearing default parent version for job type '" + m_jobTypeName + "'"); jobType.DefaultParentVersionName_2 = string.Empty; } else { msgs.AddMessage("Default parent version for job type '" + m_jobTypeName + "' is now '" + m_parentVersion + "'"); jobType.DefaultParentVersionName_2 = m_parentVersion; } // Save the changes to the job type jobType.Store(); // Set the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_DATA_WORKSPACE); IGPString outValue = new GPStringClass(); outValue.Value = m_jobTypeName; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
// Execute: Execute the function given the array of the parameters public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message) { IFeatureClass outputFeatureClass = null; try { // get the input feature class IGPMultiValue inputFeatureClasses_Parameter = (IGPMultiValue)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(0)); layer[] input_featureClasses = new layer[inputFeatureClasses_Parameter.Count]; for (int i = 0; i < inputFeatureClasses_Parameter.Count; i++) { IGPValue inputFeatureClass_Parameter = inputFeatureClasses_Parameter.get_Value(i); IFeatureClass inputFeatureClass; IQueryFilter inputQF; m_GPUtilities.DecodeFeatureLayer(inputFeatureClass_Parameter, out inputFeatureClass, out inputQF); input_featureClasses[i] = new layer() { featureclass = inputFeatureClass, qFilter = inputQF }; } if (input_featureClasses.Length == 0 || input_featureClasses.Any(w => w.featureclass == null)) { message.AddError(2, "Could not open one or more input dataset."); return; } //IFields additionalFields = new FieldsClass(); //additionalFields.AddField(FEATURE_SOURCE_FIELD_NAME, esriFieldType.esriFieldTypeString); //additionalFields.AddField(FEATURE_ID_FIELD_NAME, esriFieldType.esriFieldTypeInteger); //additionalFields.AddField( // input_featureClasses[0].featureclass.Fields.get_Field( // input_featureClasses[0].featureclass.Fields.FindField( // input_featureClasses[0].featureclass.ShapeFieldName))); // create the output feature class IGPValue outputFeatureClass_Parameter = m_GPUtilities.UnpackGPValue(paramvalues.get_Element(1)); outputFeatureClass = GPHelperFunctions.CreateFeatureClass(outputFeatureClass_Parameter, envMgr); if (outputFeatureClass == null) { message.AddError(2, "Could not create output dataset."); return; } IGPString curveTypeParameter = (IGPString)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(2)); ArcConstructionMethods method; if (!Enum.TryParse <ArcConstructionMethods>(curveTypeParameter.Value, true, out method)) { message.AddError(2, string.Format("The value {0} is not expected. Expected values are: {1}.", curveTypeParameter.Value, string.Join(",", Enum.GetNames(typeof(ArcConstructionMethods))))); return; } IStepProgressor stepPro = (IStepProgressor)trackcancel; GPHelperFunctions.dropSpatialIndex(outputFeatureClass); BoostVoronoi bv = new BoostVoronoi(100); double minX = int.MaxValue, minY = int.MaxValue, maxX = int.MinValue, maxY = int.MinValue; List <site_key> point_sites = new List <site_key>(); List <site_key> segment_sites = new List <site_key>(); for (short i = 0; i < input_featureClasses.Length; i++) { layer l = input_featureClasses[i]; int featcount = l.featureclass.FeatureCount(l.qFilter); stepPro.MinRange = 0; stepPro.MaxRange = featcount; stepPro.StepValue = (1); stepPro.Message = "Reading features"; stepPro.Position = 0; stepPro.Show(); IFeatureCursor cursor = null; IFeature row = null; try { cursor = l.featureclass.Search(l.qFilter, false); while ((row = cursor.NextFeature()) != null) { stepPro.Step(); IPoint point = row.Shape as IPoint; if (point != null) { double X = point.X; double Y = point.Y; minX = Math.Min(minX, X); maxX = Math.Max(maxX, X); minY = Math.Min(minY, Y); maxY = Math.Max(maxY, Y); bv.AddPoint(point.X, point.Y); point_sites.Add(new site_key(i, row.OID)); } IMultipoint multipoint = row.Shape as IMultipoint; if (multipoint != null) { IPointCollection pointCollection = (IPointCollection)multipoint; IEnumVertex vertices = pointCollection.EnumVertices; IPoint vertex = null; int part, index; vertices.Next(out vertex, out part, out index); minX = Math.Min(minX, multipoint.Envelope.XMin); maxX = Math.Max(maxX, multipoint.Envelope.XMax); minY = Math.Min(minY, multipoint.Envelope.YMin); maxY = Math.Max(maxY, multipoint.Envelope.YMax); while (vertex != null) { bv.AddPoint(vertex.X, vertex.Y); point_sites.Add(new site_key(i, row.OID)); vertices.Next(out vertex, out part, out index); } } IPolyline polyline = row.Shape as IPolyline; if (polyline != null) { double fromX = polyline.FromPoint.X; double fromY = polyline.FromPoint.Y; double toX = polyline.ToPoint.X; double toY = polyline.ToPoint.Y; if (toX < fromX) { minX = Math.Min(minX, toX); maxX = Math.Max(maxX, fromX); } else { minX = Math.Min(minX, fromX); maxX = Math.Max(maxX, toX); } if (toY < fromY) { minY = Math.Min(minY, toY); maxY = Math.Max(maxY, fromY); } else { minY = Math.Min(minY, fromY); maxY = Math.Max(maxY, toY); } bv.AddSegment( polyline.FromPoint.X, polyline.FromPoint.Y, polyline.ToPoint.X, polyline.ToPoint.Y ); segment_sites.Add(new site_key(i, row.OID)); } Marshal.ReleaseComObject(row); } } finally { if (row != null) { Marshal.ReleaseComObject(row); } if (cursor != null) { Marshal.ReleaseComObject(cursor); } stepPro.Hide(); } } message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY)); int width = Math.Max((int)((maxX - minX) * 0.1), 1); int height = Math.Max((int)((maxY - minY) * 0.1), 1); maxX = maxX + width; minX = minX - width; maxY = maxY + height; minY = minY - height; message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY)); bv.AddSegment(minX, minY, maxX, minY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(maxX, minY, maxX, maxY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(maxX, maxY, minX, maxY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(minX, maxY, minX, minY); segment_sites.Add(new site_key(-1, -1)); stepPro.Message = "Solve Voronoi"; stepPro.MaxRange = 0; stepPro.MaxRange = 0; stepPro.Show(); bv.Construct(); stepPro.Hide(); int featureSourceIndx = outputFeatureClass.Fields.FindField(FEATURE_SOURCE_FIELD_NAME); int featureIDIndx = outputFeatureClass.Fields.FindField(FEATURE_ID_FIELD_NAME); IFeatureCursor inserts = null; IFeatureBuffer buffer = null; try { object missing = Type.Missing; ISpatialReference spatialReference = ((IGeoDataset)outputFeatureClass).SpatialReference; inserts = outputFeatureClass.Insert(false); buffer = outputFeatureClass.CreateFeatureBuffer(); List <Cell> cells = bv.Cells; message.AddMessage(string.Format("{0} cells calculated", cells.Count)); List <Edge> edges = bv.Edges; message.AddMessage(string.Format("{0} edges calculated", edges.Count)); List <Vertex> vertices = bv.Vertices; message.AddMessage(string.Format("{0} vertexes calculated", vertices.Count)); stepPro.Message = "Write cells"; stepPro.MaxRange = 0; stepPro.MaxRange = cells.Count; stepPro.Show(); for (int cellIndex = 0; cellIndex < cells.Count; cellIndex++) { try { if (cellIndex % 5000 == 0) { message.AddMessage(String.Format("{0}. {1} cells processed.", DateTime.Now, cellIndex)); } Cell cell = cells[cellIndex]; int currentSite = cell.Site; IGeometryCollection geometryCollection = new GeometryBagClass() { SpatialReference = spatialReference }; //ignores any sliver cells if (cell.IsOpen || cell.EdgesIndex.Count < 3) { continue; } ISegmentCollection segmentCollection = createSegments(cell, bv, method, spatialReference); if (((IArea)segmentCollection).Area <= 0) { message.AddMessage("A invalid geometry has been detected, try reversing the orientation."); ISegmentCollection reversed_segmentCollection = new PolygonClass() { SpatialReference = spatialReference }; for (int i = segmentCollection.SegmentCount - 1; i >= 0; i--) { ISegment segment = (ISegment)segmentCollection.get_Segment(i); segment.ReverseOrientation(); reversed_segmentCollection.AddSegment(segment); } segmentCollection = reversed_segmentCollection; } ((IPolygon)segmentCollection).SpatialReference = spatialReference; if (((IArea)segmentCollection).Area <= 0) { message.AddWarning("An empty shell has been created"); for (int i = 0; i < segmentCollection.SegmentCount; i++) { ISegment segment = (ISegment)segmentCollection.get_Segment(i); message.AddMessage(String.Format("From {0}, {1} To {2},{3}", segment.FromPoint.X, segment.FromPoint.Y, segment.ToPoint.X, segment.ToPoint.Y)); } } //set attributes site_key sk = (currentSite >= point_sites.Count) ? segment_sites[currentSite - point_sites.Count] : point_sites[currentSite]; if (!sk.isEmpty) { buffer.set_Value(featureSourceIndx, input_featureClasses[sk.featureClassIndex].featureclass.AliasName); buffer.set_Value(featureIDIndx, sk.objectID); } else { buffer.set_Value(featureSourceIndx, DBNull.Value); buffer.set_Value(featureIDIndx, DBNull.Value); } IPolygon voronoiPolygon = (IPolygon)segmentCollection; buffer.Shape = (IPolygon)voronoiPolygon; inserts.InsertFeature(buffer); } catch (Exception e) { message.AddWarning("Failed to create a cell"); } } } finally { if (buffer != null) { Marshal.ReleaseComObject(buffer); } if (inserts != null) { Marshal.ReleaseComObject(inserts); } } GPHelperFunctions.createSpatialIndex(outputFeatureClass); } catch (Exception exx) { message.AddError(2, exx.Message); message.AddMessage(exx.ToString()); } finally { if (outputFeatureClass != null) { Marshal.ReleaseComObject(outputFeatureClass); } ((IProgressor)trackcancel).Hide(); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } IJTXSpatialNotificationManager snManager = this.WmxDatabase.SpatialNotificationManager; IJTXSpatialNotifierNameSet allSnNames = snManager.SpatialNotifiers; IJTXNotificationConfiguration notificationConfig = this.WmxDatabase.ConfigurationManager as IJTXNotificationConfiguration; // Create a new spatial notification IJTXChangeRule2 changeRule = snManager.AddChangeRule() as IJTXChangeRule2; // Set the name changeRule.Name = m_snName; // Set the notifier IJTXNotificationType srcNotifType = notificationConfig.GetNotificationType(m_emailNotifier); // Set the properties of the spatial notification's e-mail notification to match that // of the source e-mail notification (phew!) IJTXEmailSpatialNotifier emailNotifier = this.CreateSpatialNotifierByName(C_TYPE_EMAIL_NOTIFIER) as IJTXEmailSpatialNotifier; emailNotifier.Subject = srcNotifType.SubjectTemplate; emailNotifier.Body = srcNotifType.MessageTemplate; emailNotifier.SenderEmail = srcNotifType.SenderTemplate; emailNotifier.SenderDisplayName = srcNotifType.SenderDisplayNameTemplate; string[] subscribers = srcNotifType.get_Subscribers(); IStringArray subscribersObj = new StrArrayClass(); foreach (string subscriber in subscribers) { subscribersObj.Add(subscriber); } emailNotifier.Subscribers = subscribersObj; changeRule.Notifier = emailNotifier as IJTXSpatialNotifier; // Set the description, if applicable if (!string.IsNullOrEmpty(m_snDescription)) { changeRule.Description = m_snDescription; } // Set the summarization behavior changeRule.SummarizeNotifications = m_summarize; // Store the resulting change rule changeRule.Store(); // Update the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParam = paramMap.GetParamEdit(C_PARAM_OUT_NAME); IGPString strValue = new GPStringClass(); strValue.Value = m_snName; outParam.Value = strValue as IGPValue; msgs.AddWarning("To avoid database corruption, at least one dataset or area evaluator must be added to notification '" + m_snName + "' immediately!"); msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_SN_CREATION_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } finally { // Release any COM objects here! } }
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; }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); WorkspaceWorksheetReader reader = null; try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } reader = new WorkspaceWorksheetReader(this.m_excelFilePath, msgs); // Prepare to set/build the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameter3 outParam = paramMap.GetParam(C_PARAM_OUT_WORKSPACES_CREATED); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_WORKSPACES_CREATED); IGPMultiValue outMultiValue = new GPMultiValueClass(); outMultiValue.MemberDataType = outParam.DataType; // Load the workspace info from the spreadsheet List <Common.WorkspaceInfo> dataWorkspaces = reader.GetWorkspacesFromSpreadsheet(); // Loop through each of the workspaces IJTXDatabaseConnectionManager dbConnectionManager = new JTXDatabaseConnectionManagerClass(); IJTXDatabaseConnection dbConnection = dbConnectionManager.GetConnection(WmxDatabase.Alias); foreach (Common.WorkspaceInfo wmauWorkspaceInfo in dataWorkspaces) { string workspaceName = wmauWorkspaceInfo.Name; if (Common.WmauHelperFunctions.LookupWorkspaceNameObj(this.WmxDatabase, workspaceName) != null) { msgs.AddWarning("Skipping existing workspace '" + workspaceName + "'"); } else { IJTXWorkspaceConfiguration workspaceInfo = dbConnection.AddDataWorkspace(); this.CopyDataWorkspace(wmauWorkspaceInfo, ref workspaceInfo, msgs); workspaceInfo.Store(); msgs.AddMessage("Added new workspace '" + workspaceName + "'"); IGPString outElement = new GPStringClass(); outElement.Value = workspaceName; outMultiValue.AddValue(outElement as IGPValue); } } // Set the value of the output parameter outParamEdit.Value = outMultiValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_WORKSPACE_LOAD_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } } finally { if (reader != null) { reader.Close(); } } }
public void Execute(IArray paramvalues, ITrackCancel TrackCancel, IGPEnvironmentManager envMgr, IGPMessages message) { IAoInitialize aoInitialize = new AoInitializeClass(); esriLicenseStatus naStatus = esriLicenseStatus.esriLicenseUnavailable; IGPUtilities2 gpUtil = null; IDataset osmDataset = null; try { if (!aoInitialize.IsExtensionCheckedOut(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork)) naStatus = aoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork); gpUtil = new GPUtilitiesClass(); // OSM Dataset Param IGPParameter osmDatasetParam = paramvalues.get_Element(in_osmFeatureDataset) as IGPParameter; IDEDataset2 osmDEDataset = gpUtil.UnpackGPValue(osmDatasetParam) as IDEDataset2; if (osmDEDataset == null) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), osmDatasetParam.Name)); return; } osmDataset = gpUtil.OpenDatasetFromLocation(((IDataElement)osmDEDataset).CatalogPath) as IDataset; // Network Config File Param IGPParameter osmNetConfigParam = paramvalues.get_Element(in_NetworkConfigurationFile) as IGPParameter; IGPValue osmNetConfigFile = gpUtil.UnpackGPValue(osmNetConfigParam) as IGPValue; if ((osmNetConfigFile == null) || (string.IsNullOrEmpty(osmNetConfigFile.GetAsText()))) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), osmNetConfigParam.Name)); return; } // Target Network Dataset Param IGPParameter ndsParam = paramvalues.get_Element(out_NetworkDataset) as IGPParameter; IDataElement deNDS = gpUtil.UnpackGPValue(ndsParam) as IDataElement; if (deNDS == null) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), ndsParam.Name)); return; } // Create Network Dataset using (NetworkDataset nd = new NetworkDataset(osmNetConfigFile.GetAsText(), osmDataset, deNDS.Name, message, TrackCancel)) { if (nd.CanCreateNetworkDataset()) nd.CreateNetworkDataset(); } } catch (UserCancelException ex) { message.AddWarning(ex.Message); } catch (Exception ex) { message.AddError(120008, ex.Message); #if DEBUG message.AddError(120008, ex.StackTrace); #endif } finally { if (osmDataset != null) ComReleaser.ReleaseCOMObject(osmDataset); if (naStatus == esriLicenseStatus.esriLicenseCheckedOut) aoInitialize.CheckInExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork); if (gpUtil != null) ComReleaser.ReleaseCOMObject(gpUtil); GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); } }
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); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); // Assign the requested job try { IJTXJobManager jobManager = this.WmxDatabase.JobManager; IJTXJob3 job = jobManager.GetJob(m_jobId) as IJTXJob3; IJTXConfiguration3 configMgr = this.WmxDatabase.ConfigurationManager as IJTXConfiguration3; // As of Jan. 2011, the core Workflow Manager libraries do not // seem to check if the user has the privilege to add an attachment // if a job as a hold on it. So run the check here. IJTXJobHolds jobHolds = job as IJTXJobHolds; if (jobHolds.Holds != null && jobHolds.Holds.Count > 0 && !CurrentUserHasPrivilege(ESRI.ArcGIS.JTX.Utilities.Constants.PRIV_CAN_ADD_ATTACHES_FOR_HELD_JOBS)) { throw new WmauException(WmauErrorCodes.C_NO_ADD_ATTACHMENTS_HELD_JOBS_ERROR); } // If we get this far, then figure out how to associate the attachment // with the job, and add the attachment. jtxFileStorageType attachmentType; if (m_attachmentType.Equals(C_OPT_EMBEDDED)) { attachmentType = jtxFileStorageType.jtxStoreInDB; } else { attachmentType = jtxFileStorageType.jtxStoreAsLink; } msgs.AddMessage("Adding attachment '" + m_attachmentPath + "' to job " + m_jobId + " (" + job.Name + ")"); job.AddAttachment(m_attachmentPath, attachmentType, m_attachmentType); job.Store(); // Do the other things that still need to be handled manually, such as logging // the job's reassignment and sending any necessary notifications. IPropertySet propSet = new PropertySetClass(); propSet.SetProperty(C_PROP_VAL_ATTACHMENT, "'" + m_attachmentPath + "'"); job.LogJobAction( configMgr.GetActivityType(ESRI.ArcGIS.JTX.Utilities.Constants.ACTTYPE_ADD_ATTACHMENT), propSet, string.Empty); Common.WmauHelperFunctions.SendNotification( ESRI.ArcGIS.JTX.Utilities.Constants.NOTIF_ATTACHMENT_ADDED, this.WmxDatabase, job); // Set the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_JOB_ID); IGPLong outValue = new GPLongClass(); outValue.Value = m_jobId; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { WmauError error = new WmauError(WmauErrorCodes.C_UNSPECIFIED_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { IJTXJob4 job = null; // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); ////////////////////////////////////////////////////////////////////// // TODO: Update the job-creation logic. // // In subsequent builds of Workflow Manager (post-10.0), there may be // a new API that creates jobs and handles much of the logic included // in this function (and this class at large). If so, this GP tool // should be revised to make use of this simplified interface. // // Anyone using this tool as a reference, particularly with regards // to creating Workflow Manager jobs, should keep this in mind. ////////////////////////////////////////////////////////////////////// // Try to create the job, as requested try { IJTXJobManager2 jobManager = this.WmxDatabase.JobManager as IJTXJobManager2; IJTXConfiguration configMgr = this.WmxDatabase.ConfigurationManager as IJTXConfiguration; IJTXJobType4 jobTypeObj = configMgr.GetJobType(m_jobTypeAsString) as IJTXJobType4; // Set up the description object to be used to create this job IJTXJobDescription jobDescription = new JTXJobDescriptionClass(); jobDescription.JobTypeName = m_jobTypeAsString; jobDescription.AOI = GetPolygonFromSpecifiedLayer(m_aoiLayer); // Set up the ownership & assignment of the job jobDescription.OwnedBy = m_jobOwner; if (m_assigneeType.Equals(C_OPT_ASSIGN_TO_GROUP)) { jobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeGroup; jobDescription.AssignedTo = m_assignee; } else if (m_assigneeType.Equals(C_OPT_ASSIGN_TO_USER)) { jobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeUser; jobDescription.AssignedTo = m_assignee; } else if (m_assigneeType.Equals(C_OPT_UNASSIGNED)) { jobDescription.AssignedType = jtxAssignmentType.jtxAssignmentTypeUnassigned; jobDescription.AssignedTo = string.Empty; } else { // Do nothing; let the job type defaults take over msgs.AddMessage("Using job type defaults for job assignment"); jobDescription.AssignedType = jobTypeObj.DefaultAssignedType; jobDescription.AssignedTo = jobTypeObj.DefaultAssignedTo; } // Start date if (m_startDate != null && m_startDate.Value != null) { string tempStr = m_startDate.Value.ToString(); // Workflow Manager stores times as UTC times; input times must // therefore be pre-converted DateTime tempDate = DateTime.Parse(tempStr); jobDescription.StartDate = TimeZone.CurrentTimeZone.ToUniversalTime(tempDate); } else { msgs.AddMessage("Using job type defaults for start date"); jobDescription.StartDate = jobTypeObj.DefaultStartDate; } // Due date if (m_dueDate != null && m_dueDate.Value != null) { string tempStr = m_dueDate.Value.ToString(); // Workflow Manager stores times as UTC times; input times must // therefore be pre-converted DateTime tempDate = DateTime.Parse(tempStr); jobDescription.DueDate = TimeZone.CurrentTimeZone.ToUniversalTime(tempDate); } else { msgs.AddMessage("Using job type defaults for due date"); jobDescription.DueDate = jobTypeObj.DefaultDueDate; } // Priority if (!m_priority.Equals(string.Empty)) { IJTXPriority priority = configMgr.GetPriority(m_priority); jobDescription.Priority = priority; } else { msgs.AddMessage("Using job type defaults for priority"); jobDescription.Priority = jobTypeObj.DefaultPriority; } // Parent job if (m_parentJobId > 0) { jobDescription.ParentJobId = m_parentJobId; } // Data workspace if (m_dataWorkspaceId.Equals(C_OPT_VAL_NOT_SET)) { jobDescription.DataWorkspaceID = string.Empty; } else if (!m_dataWorkspaceId.Equals(string.Empty)) { jobDescription.DataWorkspaceID = m_dataWorkspaceId; } else { msgs.AddMessage("Using job type defaults for data workspace"); if (jobTypeObj.DefaultDataWorkspace != null) { jobDescription.DataWorkspaceID = jobTypeObj.DefaultDataWorkspace.DatabaseID; } } // Parent version if (m_parentVersion.Equals(C_OPT_VAL_NOT_SET)) { jobDescription.ParentVersionName = string.Empty; } else if (!m_parentVersion.Equals(string.Empty)) { jobDescription.ParentVersionName = m_parentVersion; } else { msgs.AddMessage("Using job type defaults for parent version"); jobDescription.ParentVersionName = jobTypeObj.DefaultParentVersionName; } // Auto-execution jobDescription.AutoExecuteOnCreate = m_executeNewJob; // Create the new job int expectedNumJobs = 1; bool checkAoi = true; IJTXJobSet jobSet = null; IJTXExecuteInfo execInfo; try { jobSet = jobManager.CreateJobsFromDescription(jobDescription, expectedNumJobs, checkAoi, out execInfo); } catch (System.Runtime.InteropServices.COMException comEx) { throw new WmauException(WmauErrorCodes.C_CREATE_JOB_ERROR, comEx); } if ((execInfo != null && execInfo.ThrewError) || jobSet == null || jobSet.Count != expectedNumJobs) { if (execInfo != null && !string.IsNullOrEmpty(execInfo.ErrorDescription)) { throw new WmauException( WmauErrorCodes.C_CREATE_JOB_ERROR, new Exception(execInfo.ErrorCode.ToString() + ": " + execInfo.ErrorDescription)); } else { throw new WmauException(WmauErrorCodes.C_CREATE_JOB_ERROR); } } // If it gets all the way down here without errors, set the output ID with the // ID of the job that was created. job = jobSet.Next() as IJTXJob4; WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPValue jobIdGpVal = new GPLongClass(); jobIdGpVal.SetAsText(job.ID.ToString()); IGPParameterEdit3 jobIdParam = paramMap.GetParamEdit(C_PARAM_NEWJOBID); jobIdParam.Value = jobIdGpVal; msgs.AddMessage("Created job: " + job.ID.ToString() + " (" + job.Name + ")"); msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); if (job != null) { this.WmxDatabase.JobManager.DeleteJob(job.ID, true); } } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_CREATE_JOB_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); if (job != null) { this.WmxDatabase.JobManager.DeleteJob(job.ID, true); } } catch { // Catch anything else that possibly happens } } }
private string downloadOSMDocument(ref IGPMessages message, string requestURL, api apiCapabilities) { string osmDownloadDocument = String.Empty; HttpWebResponse httpResponse = null; try { // OSM does not understand URL encoded query parameters HttpWebRequest httpClient = HttpWebRequest.Create(requestURL) as HttpWebRequest; httpClient = AssignProxyandCredentials(httpClient); // read the timeout parameter int secondsToTimeout = Convert.ToInt32(apiCapabilities.timeout.seconds); httpClient.Timeout = secondsToTimeout * 1000; httpResponse = httpClient.GetResponse() as HttpWebResponse; osmDownloadDocument = System.IO.Path.GetTempFileName(); using (System.IO.FileStream fileStream = new System.IO.FileStream(osmDownloadDocument, FileMode.Append, FileAccess.Write)) { using (StreamReader streamReader = new StreamReader(httpResponse.GetResponseStream())) { UTF8Encoding encoding = new UTF8Encoding(); byte[] byteBuffer = encoding.GetBytes(streamReader.ReadToEnd()); fileStream.Write(byteBuffer, 0, byteBuffer.Length); } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); message.AddError(120009, ex.Message); if (ex is WebException) { WebException webException = ex as WebException; if (webException != null) { if (webException.Response != null) { string serverErrorMessage = webException.Response.Headers["Error"]; if (!String.IsNullOrEmpty(serverErrorMessage)) { message.AddError(120009, serverErrorMessage); } } } } } finally { if (httpResponse != null) { httpResponse.Close(); } } return osmDownloadDocument; }
/// <summary> /// Required by IGPFunction2 interface; this function is called when the GP tool is ready to be executed. /// </summary> /// <param name="paramValues"></param> /// <param name="trackCancel"></param> /// <param name="envMgr"></param> /// <param name="msgs"></param> public override void Execute(IArray paramValues, ITrackCancel trackCancel, IGPEnvironmentManager envMgr, IGPMessages msgs) { // Do some common error-checking base.Execute(paramValues, trackCancel, envMgr, msgs); try { // Ensure that the current user has admin access to the current Workflow Manager DB if (!CurrentUserIsWmxAdministrator()) { throw new WmauException(WmauErrorCodes.C_USER_NOT_ADMIN_ERROR); } // Retrieve the TA workbook IJTXConfiguration3 defaultDbReadonly = WmxDatabase.ConfigurationManager as IJTXConfiguration3; IJTXTaskAssistantWorkflowRecord tamRecord = defaultDbReadonly.GetTaskAssistantWorkflowRecord(this.m_targetName); string styleFileName = this.DetermineStyleFileName(this.m_xmlFilePath); // If we're not allowed to overwrite an existing TA record, then do some error checking if (!this.m_overwriteExisting && tamRecord != null) { msgs.AddWarning("Did not overwrite Task Assistant workbook: " + this.m_targetName); return; } else if (tamRecord != null) { msgs.AddMessage("Replacing Task Assistant workbook '" + m_targetName + "' in database..."); defaultDbReadonly.ReplaceTaskAssistantWorkflowRecord(this.m_targetName, this.m_targetName, this.m_xmlFilePath, styleFileName); } else // tamRecord == null { msgs.AddMessage("Adding Task Assistant workbook '" + m_targetName + "' to database..."); defaultDbReadonly.AddTaskAssistantWorkflowRecord(this.m_targetName, this.m_xmlFilePath, styleFileName); } // Update the output parameter WmauParameterMap paramMap = new WmauParameterMap(paramValues); IGPParameterEdit3 outParamEdit = paramMap.GetParamEdit(C_PARAM_OUT_TARGET_NAME); IGPString outValue = new GPStringClass(); outValue.Value = m_targetName; outParamEdit.Value = outValue as IGPValue; msgs.AddMessage(Properties.Resources.MSG_DONE); } catch (WmauException wmEx) { try { msgs.AddError(wmEx.ErrorCodeAsInt, wmEx.Message); } catch { // Catch anything else that possibly happens } } catch (Exception ex) { try { WmauError error = new WmauError(WmauErrorCodes.C_TAM_UPLOAD_ERROR); msgs.AddError(error.ErrorCodeAsInt, error.Message + "; " + ex.Message); } catch { // Catch anything else that possibly happens } } }