public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPParameter3 inputLayersParameter = paramvalues.get_Element(in_LayersNumber) as IGPParameter3;
IGPMultiValue inputLayersGPValue = gpUtilities3.UnpackGPValue(inputLayersParameter) as IGPMultiValue;
if (inputLayersGPValue == null)
{
return;
}
// check if there are input layer provided
if (inputLayersGPValue.Count == 0)
{
return;
}
IGPParameter3 outputLayerParameter = paramvalues.get_Element(out_groupLayerNumber) as IGPParameter3;
IGPValue outputLayerGPValue = gpUtilities3.UnpackGPValue(outputLayerParameter);
// if the output layer value is still empty and build a proposal for a name
if (outputLayerGPValue.IsEmpty())
{
// read the proposed name from the resources
string proposedOutputLayerName = resourceManager.GetString("GPTools_GPCombineLayers_outputgrouplayer_proposedname");
string proposedOutputLayerNameTest = proposedOutputLayerName;
int layerIndex = 2;
// check if a layer with the same name already exists
// if it does then attempt to append some index numbers to build a unique, new name
ILayer foundLayer = gpUtilities3.FindMapLayer(proposedOutputLayerNameTest);
while (foundLayer != null)
{
proposedOutputLayerNameTest = proposedOutputLayerName + " (" + layerIndex + ")";
foundLayer = gpUtilities3.FindMapLayer(proposedOutputLayerNameTest);
layerIndex = layerIndex + 1;
if (layerIndex > 10000)
{
break;
}
}
outputLayerGPValue.SetAsText(proposedOutputLayerNameTest);
gpUtilities3.PackGPValue(outputLayerGPValue, outputLayerParameter);
}
}
public void UpdateParameters(IArray paramvalues, IGPEnvironmentManager pEnvMgr)
{
IGPUtilities2 gpUtil = null;
try
{
gpUtil = new GPUtilitiesClass();
IGPParameter targetDatasetParameter = paramvalues.get_Element(in_osmFeatureDataset) as IGPParameter;
IDataElement dataElement = gpUtil.UnpackGPValue(targetDatasetParameter) as IDataElement;
string osmDatasetPath = dataElement.CatalogPath;
IGPParameter gppNetworkDataset = paramvalues.get_Element(out_NetworkDataset) as IGPParameter;
IGPValue gpvNetworkDataset = gpUtil.UnpackGPValue(gppNetworkDataset);
string ndsPath = gpvNetworkDataset.GetAsText();
string ndsDir = string.Empty;
if (!string.IsNullOrEmpty(ndsPath))
{
ndsDir = System.IO.Path.GetDirectoryName(ndsPath);
}
if (!ndsDir.Equals(osmDatasetPath))
{
string ndsName = System.IO.Path.GetFileName(ndsPath);
if (string.IsNullOrEmpty(ndsName))
{
ndsName = _defaultNetworkDatasetName;
}
ndsName = System.IO.Path.GetFileName(osmDatasetPath) + "_" + ndsName;
gpvNetworkDataset.SetAsText(System.IO.Path.Combine(osmDatasetPath, ndsName));
gpUtil.PackGPValue(gpvNetworkDataset, gppNetworkDataset);
}
}
finally
{
if (gpUtil != null)
{
ComReleaser.ReleaseCOMObject(gpUtil);
}
}
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPParameter targetDatasetParameter = paramvalues.get_Element(out_targetDatasetNumber) as IGPParameter;
IGPValue targetDatasetGPValue = gpUtilities3.UnpackGPValue(targetDatasetParameter);
if (targetDatasetGPValue == null)
return;
if (targetDatasetGPValue.GetAsText().Length == 0)
{
return;
}
IDEFeatureDataset targetDEFeatureDataset = targetDatasetGPValue as IDEFeatureDataset;
if (targetDEFeatureDataset == null)
return;
IDataElement dataElement = targetDEFeatureDataset as IDataElement;
if (dataElement == null)
return;
string nameOfPointFeatureClass = dataElement.GetBaseName() + "_osm_pt";
string nameOfLineFeatureClass = dataElement.GetBaseName() + "_osm_ln";
string nameOfPolygonFeatureClass = dataElement.GetBaseName() + "_osm_ply";
string outpointsPath = dataElement.CatalogPath + System.IO.Path.DirectorySeparatorChar + nameOfPointFeatureClass;
IGPParameter outPointsFeatureClassParameter = paramvalues.get_Element(out_osmPointsNumber) as IGPParameter;
IGPValue outPointsFeatureClass = gpUtilities3.UnpackGPValue(outPointsFeatureClassParameter);
outPointsFeatureClass.SetAsText(outpointsPath);
gpUtilities3.PackGPValue(outPointsFeatureClass, outPointsFeatureClassParameter);
string outlinesPath = dataElement.CatalogPath + System.IO.Path.DirectorySeparatorChar + nameOfLineFeatureClass;
IGPParameter outLinesFeatureClassParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
IGPValue outLinesFeatureClass = gpUtilities3.UnpackGPValue(outLinesFeatureClassParameter);
outLinesFeatureClass.SetAsText(outlinesPath);
gpUtilities3.PackGPValue(outLinesFeatureClass, outLinesFeatureClassParameter);
string outpolygonsPath = dataElement.CatalogPath + System.IO.Path.DirectorySeparatorChar + nameOfPolygonFeatureClass;
IGPParameter outPolygonFeatureClassParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
IGPValue outPolygonFeatureClass = gpUtilities3.UnpackGPValue(outPolygonFeatureClassParameter);
outPolygonFeatureClass.SetAsText(outpolygonsPath);
gpUtilities3.PackGPValue(outPolygonFeatureClass, outPolygonFeatureClassParameter);
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
_message = message;
IFeatureClass osmPointFeatureClass = null;
IFeatureClass osmLineFeatureClass = null;
IFeatureClass osmPolygonFeatureClass = null;
try
{
DateTime syncTime = DateTime.Now;
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter baseURLParameter = paramvalues.get_Element(in_downloadURLNumber) as IGPParameter;
IGPString baseURLString = gpUtilities3.UnpackGPValue(baseURLParameter) as IGPString;
if (baseURLString == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), baseURLParameter.Name));
}
IGPParameter downloadExtentParameter = paramvalues.get_Element(in_downloadExtentNumber) as IGPParameter;
IGPValue downloadExtentGPValue = gpUtilities3.UnpackGPValue(downloadExtentParameter);
esriGPExtentEnum gpExtent;
IEnvelope downloadEnvelope = gpUtilities3.GetExtent(downloadExtentGPValue, out gpExtent);
IGPParameter includeAllReferences = paramvalues.get_Element(in_includeReferencesNumber) as IGPParameter;
IGPBoolean includeAllReferencesGPValue = gpUtilities3.UnpackGPValue(includeAllReferences) as IGPBoolean;
if (includeAllReferencesGPValue == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), includeAllReferences.Name));
}
IEnvelope newExtent = null;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
ISpatialReference wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
// this determines the spatial reference as defined from the gp environment settings and the initial wgs84 SR
ISpatialReference downloadSpatialReference = gpUtilities3.GetGPSpRefEnv(envMgr, wgs84, newExtent, 0, 0, 0, 0, null);
downloadEnvelope.Project(wgs84);
Marshal.ReleaseComObject(wgs84);
Marshal.ReleaseComObject(spatialReferenceFactory);
HttpWebRequest httpClient;
System.Xml.Serialization.XmlSerializer serializer = null;
serializer = new XmlSerializer(typeof(osm));
// get the capabilities from the server
HttpWebResponse httpResponse = null;
api apiCapabilities = null;
CultureInfo enUSCultureInfo = new CultureInfo("en-US");
#if DEBUG
Console.WriteLine("Debbuging");
message.AddMessage("Debugging...");
#endif
message.AddMessage(resourceManager.GetString("GPTools_OSMGPDownload_startingDownloadRequest"));
try
{
httpClient = HttpWebRequest.Create(baseURLString.Value + "/api/capabilities") as HttpWebRequest;
httpClient = AssignProxyandCredentials(httpClient);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
osm osmCapabilities = null;
Stream stream = httpResponse.GetResponseStream();
XmlTextReader xmlReader = new XmlTextReader(stream);
osmCapabilities = serializer.Deserialize(xmlReader) as osm;
xmlReader.Close();
apiCapabilities = osmCapabilities.Items[0] as api;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
message.AddError(120009, ex.Message);
if (ex is WebException)
{
WebException webException = ex as WebException;
string serverErrorMessage = webException.Response.Headers["Error"];
if (!String.IsNullOrEmpty(serverErrorMessage))
{
message.AddError(120009, serverErrorMessage);
}
}
}
finally
{
if (httpResponse != null)
{
httpResponse.Close();
}
httpClient = null;
}
if (apiCapabilities != null)
{
// check for the extent
double roiArea = ((IArea)downloadEnvelope).Area;
double capabilitiyArea = Convert.ToDouble(apiCapabilities.area.maximum, new CultureInfo("en-US"));
if (roiArea > capabilitiyArea)
{
message.AddAbort(resourceManager.GetString("GPTools_OSMGPDownload_exceedDownloadROI"));
return;
}
}
// check for user interruption
if (TrackCancel.Continue() == false)
{
return;
}
// list containing either only one document for a single bbox request or multiple if relation references need to be resolved
List<string> downloadedOSMDocuments = new List<string>();
string requestURL = baseURLString.Value + "/api/0.6/map?bbox=" + downloadEnvelope.XMin.ToString("f5", enUSCultureInfo) + "," + downloadEnvelope.YMin.ToString("f5", enUSCultureInfo) + "," + downloadEnvelope.XMax.ToString("f5", enUSCultureInfo) + "," + downloadEnvelope.YMax.ToString("f5", enUSCultureInfo);
string osmMasterDocument = downloadOSMDocument(ref message, requestURL, apiCapabilities);
// check if the initial request was successfull
// it might have failed at this point because too many nodes were requested or because of something else
if (String.IsNullOrEmpty(osmMasterDocument))
{
message.AddAbort(resourceManager.GetString("GPTools_OSMGPDownload_noValidOSMResponse"));
return;
}
// add the "master document" ) original bbox request to the list
downloadedOSMDocuments.Add(osmMasterDocument);
if (includeAllReferencesGPValue.Value)
{
List<string> nodeList = new List<string>();
List<string> wayList = new List<string>();
List<string> relationList = new List<string>();
// check for user interruption
if (TrackCancel.Continue() == false)
{
return;
}
parseOSMDocument(osmMasterDocument, ref message, ref nodeList, ref wayList, ref relationList, ref downloadedOSMDocuments, baseURLString.Value, apiCapabilities);
}
string metadataAbstract = resourceManager.GetString("GPTools_OSMGPDownload_metadata_abstract");
string metadataPurpose = resourceManager.GetString("GPTools_OSMGPDownload_metadata_purpose");
IGPParameter targetDatasetParameter = paramvalues.get_Element(out_targetDatasetNumber) as IGPParameter;
IDEDataset2 targetDEDataset2 = gpUtilities3.UnpackGPValue(targetDatasetParameter) as IDEDataset2;
IGPValue targetDatasetGPValue = gpUtilities3.UnpackGPValue(targetDatasetParameter);
string targetDatasetName = ((IGPValue)targetDEDataset2).GetAsText();
IDataElement targetDataElement = targetDEDataset2 as IDataElement;
IDataset targetDataset = gpUtilities3.OpenDatasetFromLocation(targetDataElement.CatalogPath);
IName parentName = null;
try
{
parentName = gpUtilities3.CreateParentFromCatalogPath(targetDataElement.CatalogPath);
}
catch
{
message.AddError(120033, resourceManager.GetString("GPTools_OSMGPFileReader_unable_to_create_fd"));
return;
}
// test if the feature classes already exists,
// if they do and the environments settings are such that an overwrite is not allowed we need to abort at this point
IGeoProcessorSettings gpSettings = (IGeoProcessorSettings)envMgr;
if (gpSettings.OverwriteOutput == true)
{
}
else
{
if (gpUtilities3.Exists((IGPValue)targetDEDataset2) == true)
{
message.AddError(120010, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_basenamealreadyexists"), targetDataElement.Name));
return;
}
}
string Container = "";
IDEUtilities deUtilities = new DEUtilitiesClass();
deUtilities.ParseContainer(targetDataElement.CatalogPath, ref Container);
IFeatureWorkspace featureWorkspace = gpUtilities3.OpenFromString(Container) as IFeatureWorkspace;
if (featureWorkspace == null)
{
message.AddError(120011, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nofeatureworkspace"), Container));
return;
}
// load the descriptions from which to derive the domain values
OSMDomains availableDomains = null;
System.Xml.XmlTextReader reader = null;
try
{
if (File.Exists(m_editorConfigurationSettings["osmdomainsfilepath"]))
{
reader = new System.Xml.XmlTextReader(m_editorConfigurationSettings["osmdomainsfilepath"]);
}
}
// If is in the server and hasn't been install all the configuration files
catch
{
if (File.Exists(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetAssembly(typeof(OSMGPDownload)).Location), "osm_domains.xml")))
{
reader = new System.Xml.XmlTextReader(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetAssembly(typeof(OSMGPDownload)).Location), "osm_domains.xml"));
}
}
if (reader == null)
{
message.AddError(120012, resourceManager.GetString("GPTools_OSMGPDownload_NoDomainConfigFile"));
return;
}
try
{
serializer = new XmlSerializer(typeof(OSMDomains));
availableDomains = serializer.Deserialize(reader) as OSMDomains;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
message.AddError(120013, ex.Message);
return;
}
#region define and add domains to the workspace
// we are using domains to guide the edit templates in the editor for ArcGIS desktop
Dictionary<string, IDomain> codedValueDomains = new Dictionary<string, IDomain>();
foreach (var domain in availableDomains.domain)
{
ICodedValueDomain pointCodedValueDomain = new CodedValueDomainClass();
((IDomain)pointCodedValueDomain).Name = domain.name + "_pt";
((IDomain)pointCodedValueDomain).FieldType = esriFieldType.esriFieldTypeString;
ICodedValueDomain lineCodedValueDomain = new CodedValueDomainClass();
((IDomain)lineCodedValueDomain).Name = domain.name + "_ln";
((IDomain)lineCodedValueDomain).FieldType = esriFieldType.esriFieldTypeString;
ICodedValueDomain polygonCodedValueDomain = new CodedValueDomainClass();
((IDomain)polygonCodedValueDomain).Name = domain.name + "_ply";
((IDomain)polygonCodedValueDomain).FieldType = esriFieldType.esriFieldTypeString;
for (int i = 0; i < domain.domainvalue.Length; i++)
{
for (int domainGeometryIndex = 0; domainGeometryIndex < domain.domainvalue[i].geometrytype.Length; domainGeometryIndex++)
{
switch (domain.domainvalue[i].geometrytype[domainGeometryIndex])
{
case geometrytype.point:
pointCodedValueDomain.AddCode(domain.domainvalue[i].value, domain.domainvalue[i].value);
break;
case geometrytype.line:
lineCodedValueDomain.AddCode(domain.domainvalue[i].value, domain.domainvalue[i].value);
break;
case geometrytype.polygon:
polygonCodedValueDomain.AddCode(domain.domainvalue[i].value, domain.domainvalue[i].value);
break;
default:
break;
}
}
}
// add the domain tables to the domains collection
codedValueDomains.Add(((IDomain)pointCodedValueDomain).Name, (IDomain)pointCodedValueDomain);
codedValueDomains.Add(((IDomain)lineCodedValueDomain).Name, (IDomain)lineCodedValueDomain);
codedValueDomains.Add(((IDomain)polygonCodedValueDomain).Name, (IDomain)polygonCodedValueDomain);
}
IWorkspaceDomains workspaceDomain = featureWorkspace as IWorkspaceDomains;
foreach (var domain in codedValueDomains.Values)
{
IDomain testDomain = null;
try
{
testDomain = workspaceDomain.get_DomainByName(domain.Name);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
}
if (testDomain == null)
{
workspaceDomain.AddDomain(domain);
}
}
#endregion
IGPEnvironment configKeyword = getEnvironment(envMgr, "configKeyword");
IGPString gpString = null;
if (configKeyword != null)
gpString = configKeyword.Value as IGPString;
string storageKeyword = String.Empty;
if (gpString != null)
{
storageKeyword = gpString.Value;
}
IFeatureDataset targetFeatureDataset = null;
if (gpUtilities3.Exists((IGPValue)targetDEDataset2))
{
targetFeatureDataset = gpUtilities3.OpenDataset((IGPValue)targetDEDataset2) as IFeatureDataset;
}
else
{
targetFeatureDataset = featureWorkspace.CreateFeatureDataset(targetDataElement.Name, downloadSpatialReference);
}
ESRI.ArcGIS.esriSystem.UID osmClassExtensionUID = new ESRI.ArcGIS.esriSystem.UIDClass();
//GUID for the OSM feature class extension
osmClassExtensionUID.Value = "{65CA4847-8661-45eb-8E1E-B2985CA17C78}";
downloadSpatialReference = ((IGeoDataset)targetFeatureDataset).SpatialReference;
OSMToolHelper osmToolHelper = new OSMToolHelper();
#region create point/line/polygon feature classes and tables
// points
try
{
osmPointFeatureClass = osmToolHelper.CreatePointFeatureClass((IWorkspace2)featureWorkspace, targetFeatureDataset, targetDataElement.Name + "_osm_pt", null, null, osmClassExtensionUID, storageKeyword, availableDomains, metadataAbstract, metadataPurpose);
}
catch (Exception ex)
{
message.AddError(120014, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpointfeatureclass"), ex.Message));
return;
}
if (osmPointFeatureClass == null)
{
return;
}
// change the property set of the osm class extension to skip any change detection during the initial data load
osmPointFeatureClass.RemoveOSMClassExtension();
// lines
try
{
osmLineFeatureClass = osmToolHelper.CreateLineFeatureClass((IWorkspace2)featureWorkspace, targetFeatureDataset, targetDataElement.Name + "_osm_ln", null, null, osmClassExtensionUID, storageKeyword, availableDomains, metadataAbstract, metadataPurpose);
}
catch (Exception ex)
{
message.AddError(120015, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nulllinefeatureclass"), ex.Message));
return;
}
if (osmLineFeatureClass == null)
{
return;
}
// change the property set of the osm class extension to skip any change detection during the initial data load
osmLineFeatureClass.RemoveOSMClassExtension();
// polygons
try
{
osmPolygonFeatureClass = osmToolHelper.CreatePolygonFeatureClass((IWorkspace2)featureWorkspace, targetFeatureDataset, targetDataElement.Name + "_osm_ply", null, null, osmClassExtensionUID, storageKeyword, availableDomains, metadataAbstract, metadataPurpose);
}
catch (Exception ex)
{
message.AddError(120016, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpolygonfeatureclass"), ex.Message));
return;
}
if (osmPolygonFeatureClass == null)
{
return;
}
// change the property set of the osm class extension to skip any change detection during the initial data load
osmPolygonFeatureClass.RemoveOSMClassExtension();
// relation table
ITable relationTable = null;
try
{
relationTable = osmToolHelper.CreateRelationTable((IWorkspace2)featureWorkspace, targetDataElement.Name + "_osm_relation", null, storageKeyword, metadataAbstract, metadataPurpose);
}
catch (Exception ex)
{
message.AddError(120017, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullrelationtable"), ex.Message));
return;
}
if (relationTable == null)
{
return;
}
// revision table
ITable revisionTable = null;
try
{
revisionTable = osmToolHelper.CreateRevisionTable((IWorkspace2)featureWorkspace, targetDataElement.Name + "_osm_revision", null, storageKeyword);
}
catch (Exception ex)
{
message.AddError(120018, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullrelationtable"), ex.Message));
return;
}
if (revisionTable == null)
{
return;
}
// check for user interruption
if (TrackCancel.Continue() == false)
{
return;
}
#endregion
#region clean any existing data from loading targets
ESRI.ArcGIS.Geoprocessing.IGeoProcessor2 gp = new ESRI.ArcGIS.Geoprocessing.GeoProcessorClass();
IGeoProcessorResult gpResult = new GeoProcessorResultClass();
try
{
IVariantArray truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_pt");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_ln");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_ply");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "_osm_relation");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "_osm_revision");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
}
catch (Exception ex)
{
message.AddWarning(ex.Message);
}
#endregion
Dictionary<string, OSMToolHelper.simplePointRef> osmNodeDictionary = null;
foreach (string osmDownloadDocument in downloadedOSMDocuments.Reverse<string>())
{
long nodeCapacity = 0;
long wayCapacity = 0;
long relationCapacity = 0;
message.AddMessage(resourceManager.GetString("GPTools_OSMGPFileReader_countingNodes"));
osmToolHelper.countOSMStuff(osmDownloadDocument, ref nodeCapacity, ref wayCapacity, ref relationCapacity, ref TrackCancel);
message.AddMessage(String.Format(resourceManager.GetString("GPTools_OSMGPFileReader_countedElements"), nodeCapacity, wayCapacity, relationCapacity));
if (osmNodeDictionary == null)
osmNodeDictionary = new Dictionary<string, OSMToolHelper.simplePointRef>(Convert.ToInt32(nodeCapacity));
#region load points
osmToolHelper.loadOSMNodes(osmDownloadDocument, ref TrackCancel, ref message, targetDatasetGPValue, osmPointFeatureClass, false, false, Convert.ToInt32(nodeCapacity), ref osmNodeDictionary, featureWorkspace, downloadSpatialReference, availableDomains, false);
#endregion
if (TrackCancel.Continue() == false)
{
return;
}
#region load ways
if (wayCapacity > 0)
{
List<string> missingWays = null;
missingWays = osmToolHelper.loadOSMWays(osmDownloadDocument, ref TrackCancel, ref message, targetDatasetGPValue, osmPointFeatureClass, osmLineFeatureClass, osmPolygonFeatureClass, false, false, Convert.ToInt32(wayCapacity), ref osmNodeDictionary, featureWorkspace, downloadSpatialReference, availableDomains, false);
}
#endregion
if (TrackCancel.Continue() == false)
{
return;
}
# region for conserve memory condition, update refcount
int refCounterFieldIndex = osmPointFeatureClass.Fields.FindField("wayRefCount");
if (refCounterFieldIndex > -1)
{
foreach (var refNode in osmNodeDictionary)
{
try
{
IFeature updateFeature = osmPointFeatureClass.GetFeature(refNode.Value.pointObjectID);
int refCount = refNode.Value.RefCounter;
if (refCount == 0)
{
refCount = 1;
}
updateFeature.set_Value(refCounterFieldIndex, refCount);
updateFeature.Store();
}
catch { }
}
}
#endregion
// check for user interruption
if (TrackCancel.Continue() == false)
{
return;
}
ESRI.ArcGIS.Geoprocessor.Geoprocessor geoProcessor = new ESRI.ArcGIS.Geoprocessor.Geoprocessor();
#region for local geodatabases enforce spatial integrity
bool storedOriginal = geoProcessor.AddOutputsToMap;
geoProcessor.AddOutputsToMap = false;
try
{
if (osmLineFeatureClass != null)
{
if (((IDataset)osmLineFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
{
IVariantArray lineRepairParameters = new VarArrayClass();
lineRepairParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_ln");
lineRepairParameters.Add("DELETE_NULL");
IGeoProcessorResult2 gpResults = gp.Execute("RepairGeometry_management", lineRepairParameters, TrackCancel) as IGeoProcessorResult2;
message.AddMessages(gpResults.GetResultMessages());
}
}
if (osmPolygonFeatureClass != null)
{
if (((IDataset)osmPolygonFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
{
IVariantArray polygonRepairParameters = new VarArrayClass();
polygonRepairParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_ply");
polygonRepairParameters.Add("DELETE_NULL");
IGeoProcessorResult2 gpResults = gp.Execute("RepairGeometry_management", polygonRepairParameters, TrackCancel) as IGeoProcessorResult2;
message.AddMessages(gpResults.GetResultMessages());
}
}
}
catch
{
message.AddWarning(resourceManager.GetString("GPTools_OSMGPDownload_repairgeometryfailure"));
}
geoProcessor.AddOutputsToMap = storedOriginal;
#endregion
#region load relations
if (relationCapacity > 0)
{
List<string> missingRelations = null;
missingRelations = osmToolHelper.loadOSMRelations(osmDownloadDocument, ref TrackCancel, ref message, targetDatasetGPValue, osmPointFeatureClass, osmLineFeatureClass, osmPolygonFeatureClass, Convert.ToInt32(relationCapacity), relationTable, availableDomains, false, false);
}
#endregion
}
#region update the references counts and member lists for nodes
message.AddMessage(resourceManager.GetString("GPTools_OSMGPFileReader_updatereferences"));
IFeatureCursor pointUpdateCursor = null;
using (SchemaLockManager ptLockManager = new SchemaLockManager(osmPointFeatureClass as ITable))
{
using (ComReleaser comReleaser = new ComReleaser())
{
int updateCount = 0;
pointUpdateCursor = osmPointFeatureClass.Update(null, false);
updateCount = ((ITable)osmPointFeatureClass).RowCount(null);
IStepProgressor stepProgressor = TrackCancel as IStepProgressor;
if (stepProgressor != null)
{
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = updateCount;
stepProgressor.Position = 0;
stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPFileReader_updatepointrefcount");
stepProgressor.StepValue = 1;
stepProgressor.Show();
}
comReleaser.ManageLifetime(pointUpdateCursor);
IFeature pointFeature = pointUpdateCursor.NextFeature();
int osmPointIDFieldIndex = osmPointFeatureClass.FindField("OSMID");
int osmWayRefCountFieldIndex = osmPointFeatureClass.FindField("wayRefCount");
int positionCounter = 0;
while (pointFeature != null)
{
positionCounter++;
string nodeID = Convert.ToString(pointFeature.get_Value(osmPointIDFieldIndex));
// let get the reference counter from the internal node dictionary
if (osmNodeDictionary[nodeID].RefCounter == 0)
{
pointFeature.set_Value(osmWayRefCountFieldIndex, 1);
}
else
{
pointFeature.set_Value(osmWayRefCountFieldIndex, osmNodeDictionary[nodeID].RefCounter);
}
pointUpdateCursor.UpdateFeature(pointFeature);
if (pointFeature != null)
Marshal.ReleaseComObject(pointFeature);
pointFeature = pointUpdateCursor.NextFeature();
if (stepProgressor != null)
{
stepProgressor.Position = positionCounter;
}
}
if (stepProgressor != null)
{
stepProgressor.Hide();
}
}
}
#endregion
// clean all the downloaded OSM files
foreach (string osmFile in downloadedOSMDocuments)
{
if (File.Exists(osmFile))
{
try
{
File.Delete(osmFile);
}
catch { }
}
}
SyncState.StoreLastSyncTime(targetDatasetName, syncTime);
gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
// repackage the feature class into their respective gp values
IGPParameter pointFeatureClassParameter = paramvalues.get_Element(out_osmPointsNumber) as IGPParameter;
IGPValue pointFeatureClassPackGPValue = gpUtilities3.UnpackGPValue(pointFeatureClassParameter);
gpUtilities3.PackGPValue(pointFeatureClassPackGPValue, pointFeatureClassParameter);
IGPParameter lineFeatureClassParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
IGPValue lineFeatureClassPackGPValue = gpUtilities3.UnpackGPValue(lineFeatureClassParameter);
gpUtilities3.PackGPValue(lineFeatureClassPackGPValue, lineFeatureClassParameter);
IGPParameter polygonFeatureClassParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
IGPValue polygon1FeatureClassPackGPValue = gpUtilities3.UnpackGPValue(polygonFeatureClassParameter);
gpUtilities3.PackGPValue(polygon1FeatureClassPackGPValue, polygonFeatureClassParameter);
gpUtilities3.ReleaseInternals();
Marshal.ReleaseComObject(gpUtilities3);
Marshal.ReleaseComObject(baseURLString);
Marshal.ReleaseComObject(downloadExtentGPValue);
Marshal.ReleaseComObject(downloadEnvelope);
Marshal.ReleaseComObject(includeAllReferences);
Marshal.ReleaseComObject(downloadSpatialReference);
if (osmToolHelper != null)
osmToolHelper = null;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
message.AddError(120019, ex.Message);
}
finally
{
try
{
if (osmPointFeatureClass != null)
{
osmPointFeatureClass.ApplyOSMClassExtension();
Marshal.ReleaseComObject(osmPointFeatureClass);
}
if (osmLineFeatureClass != null)
{
osmLineFeatureClass.ApplyOSMClassExtension();
Marshal.ReleaseComObject(osmLineFeatureClass);
}
if (osmPolygonFeatureClass != null)
{
osmPolygonFeatureClass.ApplyOSMClassExtension();
Marshal.ReleaseComObject(osmPolygonFeatureClass);
}
}
catch (Exception ex)
{
message.AddError(120020, ex.ToString());
}
}
}
public void UpdateParameters(IArray paramvalues, IGPEnvironmentManager pEnvMgr)
{
IGPUtilities2 gpUtil = null;
try
{
gpUtil = new GPUtilitiesClass();
IGPParameter targetDatasetParameter = paramvalues.get_Element(in_osmFeatureDataset) as IGPParameter;
IDataElement dataElement = gpUtil.UnpackGPValue(targetDatasetParameter) as IDataElement;
string osmDatasetPath = dataElement.CatalogPath;
IGPParameter gppNetworkDataset = paramvalues.get_Element(out_NetworkDataset) as IGPParameter;
IGPValue gpvNetworkDataset = gpUtil.UnpackGPValue(gppNetworkDataset);
string ndsPath = gpvNetworkDataset.GetAsText();
string ndsDir = string.Empty;
if (!string.IsNullOrEmpty(ndsPath))
ndsDir = System.IO.Path.GetDirectoryName(ndsPath);
if (!ndsDir.Equals(osmDatasetPath))
{
string ndsName = System.IO.Path.GetFileName(ndsPath);
if (string.IsNullOrEmpty(ndsName))
ndsName = _defaultNetworkDatasetName;
ndsName = System.IO.Path.GetFileName(osmDatasetPath) + "_" + ndsName;
gpvNetworkDataset.SetAsText(System.IO.Path.Combine(osmDatasetPath, ndsName));
gpUtil.PackGPValue(gpvNetworkDataset, gppNetworkDataset);
}
}
finally
{
if (gpUtil != null)
ComReleaser.ReleaseCOMObject(gpUtil);
}
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
IFeatureClass osmPointFeatureClass = null;
IFeatureClass osmLineFeatureClass = null;
IFeatureClass osmPolygonFeatureClass = null;
OSMToolHelper osmToolHelper = null;
try
{
DateTime syncTime = DateTime.Now;
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
osmToolHelper = new OSMToolHelper();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter osmFileParameter = paramvalues.get_Element(in_osmFileNumber) as IGPParameter;
IGPValue osmFileLocationString = gpUtilities3.UnpackGPValue(osmFileParameter) as IGPValue;
// ensure that the specified file does exist
bool osmFileExists = false;
try
{
osmFileExists = System.IO.File.Exists(osmFileLocationString.GetAsText());
}
catch (Exception ex)
{
message.AddError(120029, String.Format(resourceManager.GetString("GPTools_OSMGPMultiLoader_problemaccessingfile"), ex.Message));
return;
}
if (osmFileExists == false)
{
message.AddError(120030, String.Format(resourceManager.GetString("GPTools_OSMGPFileReader_osmfiledoesnotexist"), osmFileLocationString.GetAsText()));
return;
}
long nodeCapacity = 0;
long wayCapacity = 0;
long relationCapacity = 0;
// this assume a clean, tidy XML file - if this is not the case, there will by sync issues later on
osmToolHelper.countOSMStuffFast(osmFileLocationString.GetAsText(), ref nodeCapacity, ref wayCapacity, ref relationCapacity, ref TrackCancel);
if (nodeCapacity == 0 && wayCapacity == 0 && relationCapacity == 0)
{
return;
}
message.AddMessage(String.Format(resourceManager.GetString("GPTools_OSMGPMultiLoader_countedElements"), nodeCapacity, wayCapacity, relationCapacity));
// determine the number of threads to be used
IGPEnvironment parallelProcessingFactorEnvironment = OSMToolHelper.getEnvironment(envMgr, "parallelProcessingFactor");
IGPString parallelProcessingFactorString = parallelProcessingFactorEnvironment.Value as IGPString;
// the default value is to use half the cores for additional threads - I am aware that we are comparing apples and oranges but I need a number
int numberOfThreads = Convert.ToInt32(System.Environment.ProcessorCount / 2);
if (!(parallelProcessingFactorEnvironment.Value.IsEmpty()))
{
if (!Int32.TryParse(parallelProcessingFactorString.Value, out numberOfThreads))
{
// this case we have a percent string
string resultString = Regex.Match(parallelProcessingFactorString.Value, @"\d+").Value;
numberOfThreads = Convert.ToInt32(Int32.Parse(resultString) / 100 * System.Environment.ProcessorCount);
}
}
// tread the special case of 0
if (numberOfThreads <= 0)
numberOfThreads = 1;
IGPEnvironment configKeyword = OSMToolHelper.getEnvironment(envMgr, "configKeyword");
IGPString gpString = configKeyword.Value as IGPString;
string storageKeyword = String.Empty;
if (gpString != null)
{
storageKeyword = gpString.Value;
}
// determine the temp folder to be use for the intermediate files
IGPEnvironment scratchWorkspaceEnvironment = OSMToolHelper.getEnvironment(envMgr, "scratchWorkspace");
IDEWorkspace deWorkspace = scratchWorkspaceEnvironment.Value as IDEWorkspace;
String scratchWorkspaceFolder = String.Empty;
if (deWorkspace != null)
{
if (scratchWorkspaceEnvironment.Value.IsEmpty())
{
scratchWorkspaceFolder = (new System.IO.FileInfo(osmFileLocationString.GetAsText())).DirectoryName;
}
else
{
if (deWorkspace.WorkspaceType == esriWorkspaceType.esriRemoteDatabaseWorkspace)
{
scratchWorkspaceFolder = System.IO.Path.GetTempPath();
}
else if (deWorkspace.WorkspaceType == esriWorkspaceType.esriFileSystemWorkspace)
{
scratchWorkspaceFolder = ((IDataElement)deWorkspace).CatalogPath;
}
else
{
scratchWorkspaceFolder = (new System.IO.FileInfo(((IDataElement)deWorkspace).CatalogPath)).DirectoryName;
}
}
}
else
{
scratchWorkspaceFolder = (new System.IO.FileInfo(osmFileLocationString.GetAsText())).DirectoryName;
}
string metadataAbstract = resourceManager.GetString("GPTools_OSMGPFileReader_metadata_abstract");
string metadataPurpose = resourceManager.GetString("GPTools_OSMGPFileReader_metadata_purpose");
IGPParameter osmPointsFeatureClassParameter = paramvalues.get_Element(out_osmPointsNumber) as IGPParameter;
IGPValue osmPointsFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmPointsFeatureClassParameter) as IGPValue;
IName workspaceName = gpUtilities3.CreateParentFromCatalogPath(osmPointsFeatureClassGPValue.GetAsText());
IWorkspace2 pointFeatureWorkspace = workspaceName.Open() as IWorkspace2;
string[] pointFCNameElements = osmPointsFeatureClassGPValue.GetAsText().Split(System.IO.Path.DirectorySeparatorChar);
IGPParameter tagPointCollectionParameter = paramvalues.get_Element(in_pointFieldNamesNumber) as IGPParameter;
IGPMultiValue tagPointCollectionGPValue = gpUtilities3.UnpackGPValue(tagPointCollectionParameter) as IGPMultiValue;
List<String> pointTagstoExtract = null;
if (tagPointCollectionGPValue.Count > 0)
{
pointTagstoExtract = new List<string>();
for (int valueIndex = 0; valueIndex < tagPointCollectionGPValue.Count; valueIndex++)
{
string nameOfTag = tagPointCollectionGPValue.get_Value(valueIndex).GetAsText();
pointTagstoExtract.Add(nameOfTag);
}
}
else
{
pointTagstoExtract = OSMToolHelper.OSMSmallFeatureClassFields();
}
// points
try
{
osmPointFeatureClass = osmToolHelper.CreateSmallPointFeatureClass(pointFeatureWorkspace,
pointFCNameElements[pointFCNameElements.Length - 1], storageKeyword, metadataAbstract,
metadataPurpose, pointTagstoExtract);
}
catch (Exception ex)
{
message.AddError(120035, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpointfeatureclass"), ex.Message));
return;
}
if (osmPointFeatureClass == null)
{
return;
}
int osmPointIDFieldIndex = osmPointFeatureClass.FindField("OSMID");
Dictionary<string, int> mainPointAttributeFieldIndices = new Dictionary<string, int>();
foreach (string fieldName in OSMToolHelper.OSMSmallFeatureClassFields())
{
int currentFieldIndex = osmPointFeatureClass.FindField(fieldName);
if (currentFieldIndex != -1)
{
mainPointAttributeFieldIndices.Add(fieldName, currentFieldIndex);
}
}
int tagCollectionPointFieldIndex = osmPointFeatureClass.FindField("osmTags");
int osmSupportingElementPointFieldIndex = osmPointFeatureClass.FindField("osmSupportingElement");
IGPParameter osmLineFeatureClassParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
IGPValue osmLineFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmLineFeatureClassParameter) as IGPValue;
IName lineWorkspaceName = gpUtilities3.CreateParentFromCatalogPath(osmLineFeatureClassGPValue.GetAsText());
IWorkspace2 lineFeatureWorkspace = lineWorkspaceName.Open() as IWorkspace2;
string[] lineFCNameElements = osmLineFeatureClassGPValue.GetAsText().Split(System.IO.Path.DirectorySeparatorChar);
IGPParameter tagLineCollectionParameter = paramvalues.get_Element(in_lineFieldNamesNumber) as IGPParameter;
IGPMultiValue tagLineCollectionGPValue = gpUtilities3.UnpackGPValue(tagLineCollectionParameter) as IGPMultiValue;
List<String> lineTagstoExtract = null;
if (tagLineCollectionGPValue.Count > 0)
{
lineTagstoExtract = new List<string>();
for (int valueIndex = 0; valueIndex < tagLineCollectionGPValue.Count; valueIndex++)
{
string nameOfTag = tagLineCollectionGPValue.get_Value(valueIndex).GetAsText();
lineTagstoExtract.Add(nameOfTag);
}
}
else
{
lineTagstoExtract = OSMToolHelper.OSMSmallFeatureClassFields();
}
// lines
try
{
osmLineFeatureClass = osmToolHelper.CreateSmallLineFeatureClass(lineFeatureWorkspace, lineFCNameElements[lineFCNameElements.Length -1],
storageKeyword, metadataAbstract, metadataPurpose, lineTagstoExtract);
}
catch (Exception ex)
{
message.AddError(120036, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nulllinefeatureclass"), ex.Message));
return;
}
if (osmLineFeatureClass == null)
{
return;
}
int osmLineIDFieldIndex = osmLineFeatureClass.FindField("OSMID");
Dictionary<string, int> mainLineAttributeFieldIndices = new Dictionary<string, int>();
foreach (string fieldName in OSMToolHelper.OSMSmallFeatureClassFields())
{
int currentFieldIndex = osmLineFeatureClass.FindField(fieldName);
if (currentFieldIndex != -1)
{
mainLineAttributeFieldIndices.Add(fieldName, currentFieldIndex);
}
}
int tagCollectionPolylineFieldIndex = osmLineFeatureClass.FindField("osmTags");
int osmSupportingElementPolylineFieldIndex = osmLineFeatureClass.FindField("osmSupportingElement");
IGPParameter osmPolygonFeatureClassParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
IGPValue osmPolygonFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmPolygonFeatureClassParameter) as IGPValue;
IName polygonWorkspaceName = gpUtilities3.CreateParentFromCatalogPath(osmPolygonFeatureClassGPValue.GetAsText());
IWorkspace2 polygonFeatureWorkspace = polygonWorkspaceName.Open() as IWorkspace2;
string[] polygonFCNameElements = osmPolygonFeatureClassGPValue.GetAsText().Split(System.IO.Path.DirectorySeparatorChar);
IGPParameter tagPolygonCollectionParameter = paramvalues.get_Element(in_polygonFieldNamesNumber) as IGPParameter;
IGPMultiValue tagPolygonCollectionGPValue = gpUtilities3.UnpackGPValue(tagPolygonCollectionParameter) as IGPMultiValue;
List<String> polygonTagstoExtract = null;
if (tagPolygonCollectionGPValue.Count > 0)
{
polygonTagstoExtract = new List<string>();
for (int valueIndex = 0; valueIndex < tagPolygonCollectionGPValue.Count; valueIndex++)
{
string nameOfTag = tagPolygonCollectionGPValue.get_Value(valueIndex).GetAsText();
polygonTagstoExtract.Add(nameOfTag);
}
}
else
{
polygonTagstoExtract = OSMToolHelper.OSMSmallFeatureClassFields();
}
// polygons
try
{
osmPolygonFeatureClass = osmToolHelper.CreateSmallPolygonFeatureClass(polygonFeatureWorkspace,
polygonFCNameElements[polygonFCNameElements.Length -1], storageKeyword, metadataAbstract,
metadataPurpose, polygonTagstoExtract);
}
catch (Exception ex)
{
message.AddError(120037, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpolygonfeatureclass"), ex.Message));
return;
}
if (osmPolygonFeatureClass == null)
{
return;
}
int osmPolygonIDFieldIndex = osmPolygonFeatureClass.FindField("OSMID");
Dictionary<string, int> mainPolygonAttributeFieldIndices = new Dictionary<string, int>();
foreach (var fieldName in OSMToolHelper.OSMSmallFeatureClassFields())
{
int currentFieldIndex = osmPolygonFeatureClass.FindField(fieldName);
if (currentFieldIndex != -1)
{
mainPolygonAttributeFieldIndices.Add(fieldName, currentFieldIndex);
}
}
int tagCollectionPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmTags");
int osmSupportingElementPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmSupportingElement");
ComReleaser.ReleaseCOMObject(osmPointFeatureClass);
osmPointFeatureClass = null;
ComReleaser.ReleaseCOMObject(osmLineFeatureClass);
osmLineFeatureClass = null;
ComReleaser.ReleaseCOMObject(osmPolygonFeatureClass);
osmPolygonFeatureClass = null;
List<string> nodeOSMFileNames = new List<string>(numberOfThreads);
List<string> nodeGDBFileNames = new List<string>(numberOfThreads);
List<string> wayOSMFileNames = new List<string>(numberOfThreads);
List<string> wayGDBFileNames = new List<string>(numberOfThreads);
List<string> relationOSMFileNames = new List<string>(numberOfThreads);
List<string> relationGDBFileNames = new List<string>(numberOfThreads);
if (TrackCancel.Continue() == false)
{
return;
}
// split the original OSM xml file into smaller pieces for the python processes
osmToolHelper.splitOSMFile(osmFileLocationString.GetAsText(), scratchWorkspaceFolder, nodeCapacity, wayCapacity, relationCapacity, numberOfThreads,
out nodeOSMFileNames, out nodeGDBFileNames, out wayOSMFileNames, out wayGDBFileNames, out relationOSMFileNames, out relationGDBFileNames);
IGPParameter deleteSourceOSMFileParameter = paramvalues.get_Element(in_deleteOSMSourceFileNumber) as IGPParameter;
IGPBoolean deleteSourceOSMFileGPValue = gpUtilities3.UnpackGPValue(deleteSourceOSMFileParameter) as IGPBoolean;
if (deleteSourceOSMFileGPValue.Value)
{
try
{
System.IO.File.Delete(osmFileLocationString.GetAsText());
}
catch (Exception ex)
{
message.AddWarning(ex.Message);
}
}
if (TrackCancel.Continue() == false)
{
return;
}
if (nodeOSMFileNames.Count == 0)
{
nodeOSMFileNames.Add(osmFileLocationString.GetAsText());
nodeGDBFileNames.Add(osmPointsFeatureClassGPValue.GetAsText());
wayOSMFileNames.Add(osmFileLocationString.GetAsText());
wayGDBFileNames.Add(osmLineFeatureClassGPValue.GetAsText());
relationOSMFileNames.Add(osmFileLocationString.GetAsText());
relationGDBFileNames.Add(osmPolygonFeatureClassGPValue.GetAsText());
}
else
{
// for the nodes let's load one of the parts directly into the target file geodatabase
nodeGDBFileNames[0] = ((IWorkspace)pointFeatureWorkspace).PathName;
}
// define variables helping to invoke core tools for data management
IGeoProcessorResult2 gpResults2 = null;
IGeoProcessor2 geoProcessor = new GeoProcessorClass();
IGPParameter deleteSupportingNodesParameter = paramvalues.get_Element(in_deleteSupportNodesNumber) as IGPParameter;
IGPBoolean deleteSupportingNodesGPValue = gpUtilities3.UnpackGPValue(deleteSupportingNodesParameter) as IGPBoolean;
#region load points
osmToolHelper.loadOSMNodes(nodeOSMFileNames, nodeGDBFileNames, pointFCNameElements[pointFCNameElements.Length - 1], osmPointsFeatureClassGPValue.GetAsText(), pointTagstoExtract, deleteSupportingNodesGPValue.Value, ref message, ref TrackCancel);
#endregion
if (TrackCancel.Continue() == false)
{
return;
}
#region load ways
osmToolHelper.loadOSMWays(wayOSMFileNames, osmPointsFeatureClassGPValue.GetAsText(), wayGDBFileNames, lineFCNameElements[lineFCNameElements.Length - 1], polygonFCNameElements[polygonFCNameElements.Length - 1], lineTagstoExtract, polygonTagstoExtract, ref message, ref TrackCancel);
#endregion
#region for local geodatabases enforce spatial integrity
bool storedOriginalLocal = geoProcessor.AddOutputsToMap;
geoProcessor.AddOutputsToMap = false;
try
{
osmLineFeatureClass = ((IFeatureWorkspace)lineFeatureWorkspace).OpenFeatureClass(lineFCNameElements[lineFCNameElements.Length - 1]);
if (osmLineFeatureClass != null)
{
if (((IDataset)osmLineFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
{
gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
IGPParameter outLinesParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
IGPValue lineFeatureClass = gpUtilities3.UnpackGPValue(outLinesParameter);
DataManagementTools.RepairGeometry repairlineGeometry = new DataManagementTools.RepairGeometry(osmLineFeatureClass);
IVariantArray repairGeometryParameterArray = new VarArrayClass();
repairGeometryParameterArray.Add(lineFeatureClass.GetAsText());
repairGeometryParameterArray.Add("DELETE_NULL");
gpResults2 = geoProcessor.Execute(repairlineGeometry.ToolName, repairGeometryParameterArray, TrackCancel) as IGeoProcessorResult2;
message.AddMessages(gpResults2.GetResultMessages());
ComReleaser.ReleaseCOMObject(gpUtilities3);
}
}
}
catch { }
finally
{
ComReleaser.ReleaseCOMObject(osmLineFeatureClass);
}
try
{
osmPolygonFeatureClass = ((IFeatureWorkspace)polygonFeatureWorkspace).OpenFeatureClass(polygonFCNameElements[polygonFCNameElements.Length - 1]);
if (osmPolygonFeatureClass != null)
{
if (((IDataset)osmPolygonFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
{
gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
IGPParameter outPolygonParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
IGPValue polygonFeatureClass = gpUtilities3.UnpackGPValue(outPolygonParameter);
DataManagementTools.RepairGeometry repairpolygonGeometry = new DataManagementTools.RepairGeometry(osmPolygonFeatureClass);
IVariantArray repairGeometryParameterArray = new VarArrayClass();
repairGeometryParameterArray.Add(polygonFeatureClass.GetAsText());
repairGeometryParameterArray.Add("DELETE_NULL");
gpResults2 = geoProcessor.Execute(repairpolygonGeometry.ToolName, repairGeometryParameterArray, TrackCancel) as IGeoProcessorResult2;
message.AddMessages(gpResults2.GetResultMessages());
ComReleaser.ReleaseCOMObject(gpUtilities3);
}
}
}
catch { }
finally
{
ComReleaser.ReleaseCOMObject(osmPolygonFeatureClass);
}
geoProcessor.AddOutputsToMap = storedOriginalLocal;
#endregion
if (TrackCancel.Continue() == false)
{
return;
}
#region load relations
osmToolHelper.loadOSMRelations(relationOSMFileNames, osmLineFeatureClassGPValue.GetAsText(), osmPolygonFeatureClassGPValue.GetAsText(), relationGDBFileNames, lineTagstoExtract, polygonTagstoExtract, ref TrackCancel, ref message);
#endregion
// check for user interruption
if (TrackCancel.Continue() == false)
{
return;
}
#region for local geodatabases enforce spatial integrity
//storedOriginalLocal = geoProcessor.AddOutputsToMap;
//geoProcessor.AddOutputsToMap = false;
//try
//{
// osmLineFeatureClass = ((IFeatureWorkspace)lineFeatureWorkspace).OpenFeatureClass(lineFCNameElements[lineFCNameElements.Length - 1]);
// if (osmLineFeatureClass != null)
// {
// if (((IDataset)osmLineFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
// {
// gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
// IGPParameter outLinesParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
// IGPValue lineFeatureClass = gpUtilities3.UnpackGPValue(outLinesParameter);
// DataManagementTools.RepairGeometry repairlineGeometry = new DataManagementTools.RepairGeometry(osmLineFeatureClass);
// IVariantArray repairGeometryParameterArray = new VarArrayClass();
// repairGeometryParameterArray.Add(lineFeatureClass.GetAsText());
// repairGeometryParameterArray.Add("DELETE_NULL");
// gpResults2 = geoProcessor.Execute(repairlineGeometry.ToolName, repairGeometryParameterArray, TrackCancel) as IGeoProcessorResult2;
// message.AddMessages(gpResults2.GetResultMessages());
// ComReleaser.ReleaseCOMObject(gpUtilities3);
// }
// }
//}
//catch { }
//finally
//{
// ComReleaser.ReleaseCOMObject(osmLineFeatureClass);
//}
//try
//{
// osmPolygonFeatureClass = ((IFeatureWorkspace)polygonFeatureWorkspace).OpenFeatureClass(polygonFCNameElements[polygonFCNameElements.Length - 1]);
// if (osmPolygonFeatureClass != null)
// {
// if (((IDataset)osmPolygonFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
// {
// gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
// IGPParameter outPolygonParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
// IGPValue polygonFeatureClass = gpUtilities3.UnpackGPValue(outPolygonParameter);
// DataManagementTools.RepairGeometry repairpolygonGeometry = new DataManagementTools.RepairGeometry(osmPolygonFeatureClass);
// IVariantArray repairGeometryParameterArray = new VarArrayClass();
// repairGeometryParameterArray.Add(polygonFeatureClass.GetAsText());
// repairGeometryParameterArray.Add("DELETE_NULL");
// gpResults2 = geoProcessor.Execute(repairpolygonGeometry.ToolName, repairGeometryParameterArray, TrackCancel) as IGeoProcessorResult2;
// message.AddMessages(gpResults2.GetResultMessages());
// ComReleaser.ReleaseCOMObject(gpUtilities3);
// }
// }
//}
//catch { }
//finally
//{
// ComReleaser.ReleaseCOMObject(osmPolygonFeatureClass);
//}
//geoProcessor.AddOutputsToMap = storedOriginalLocal;
#endregion
if (TrackCancel.Continue() == false)
{
return;
}
if (deleteSupportingNodesGPValue.Value)
{
message.AddMessage(String.Format(resourceManager.GetString("GPTools_OSMGPMultiLoader_remove_supportNodes")));
storedOriginalLocal = geoProcessor.AddOutputsToMap;
geoProcessor.AddOutputsToMap = false;
// create a layer file to select the points that have attributes
osmPointFeatureClass = ((IFeatureWorkspace)pointFeatureWorkspace).OpenFeatureClass(pointFCNameElements[pointFCNameElements.Length - 1]);
IVariantArray makeFeatureLayerParameterArray = new VarArrayClass();
makeFeatureLayerParameterArray.Add(osmPointsFeatureClassGPValue.GetAsText());
string tempLayerFile = System.IO.Path.GetTempFileName();
makeFeatureLayerParameterArray.Add(tempLayerFile);
makeFeatureLayerParameterArray.Add(String.Format("{0} = 'no'", osmPointFeatureClass.SqlIdentifier("osmSupportingElement")));
geoProcessor.Execute("MakeFeatureLayer_management", makeFeatureLayerParameterArray, TrackCancel);
// copy the features into its own feature class
IVariantArray copyFeatureParametersArray = new VarArrayClass();
copyFeatureParametersArray.Add(tempLayerFile);
string tempFeatureClass = String.Join("\\", new string[] {
((IWorkspace)pointFeatureWorkspace).PathName, "t_" + pointFCNameElements[pointFCNameElements.Length - 1] });
copyFeatureParametersArray.Add(tempFeatureClass);
geoProcessor.Execute("CopyFeatures_management", copyFeatureParametersArray, TrackCancel);
// delete the temp file
System.IO.File.Delete(tempLayerFile);
// delete the original feature class
IVariantArray deleteParameterArray = new VarArrayClass();
deleteParameterArray.Add(osmPointsFeatureClassGPValue.GetAsText());
geoProcessor.Execute("Delete_management", deleteParameterArray, TrackCancel);
// rename the temp feature class back to the original
IVariantArray renameParameterArray = new VarArrayClass();
renameParameterArray.Add(tempFeatureClass);
renameParameterArray.Add(osmPointsFeatureClassGPValue.GetAsText());
geoProcessor.Execute("Rename_management", renameParameterArray, TrackCancel);
geoProcessor.AddOutputsToMap = storedOriginalLocal;
ComReleaser.ReleaseCOMObject(osmPointFeatureClass);
ComReleaser.ReleaseCOMObject(geoProcessor);
}
gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
// repackage the feature class into their respective gp values
IGPParameter pointFeatureClassParameter = paramvalues.get_Element(out_osmPointsNumber) as IGPParameter;
IGPValue pointFeatureClassGPValue = gpUtilities3.UnpackGPValue(pointFeatureClassParameter);
gpUtilities3.PackGPValue(pointFeatureClassGPValue, pointFeatureClassParameter);
IGPParameter lineFeatureClassParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
IGPValue line1FeatureClassGPValue = gpUtilities3.UnpackGPValue(lineFeatureClassParameter);
gpUtilities3.PackGPValue(line1FeatureClassGPValue, lineFeatureClassParameter);
IGPParameter polygonFeatureClassParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
IGPValue polygon1FeatureClassGPValue = gpUtilities3.UnpackGPValue(polygonFeatureClassParameter);
gpUtilities3.PackGPValue(polygon1FeatureClassGPValue, polygonFeatureClassParameter);
ComReleaser.ReleaseCOMObject(osmFileLocationString);
gpUtilities3.ReleaseInternals();
ComReleaser.ReleaseCOMObject(gpUtilities3);
}
catch (Exception ex)
{
message.AddError(120055, ex.Message);
message.AddError(120055, ex.StackTrace);
}
finally
{
try
{
osmToolHelper = null;
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
}
catch (Exception ex)
{
message.AddError(120056, ex.ToString());
}
}
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPParameter3 inputLayersParameter = paramvalues.get_Element(in_LayersNumber) as IGPParameter3;
IGPMultiValue inputLayersGPValue = gpUtilities3.UnpackGPValue(inputLayersParameter) as IGPMultiValue;
if (inputLayersGPValue == null)
{
return;
}
// check if there are input layer provided
if (inputLayersGPValue.Count == 0)
{
return;
}
IGPParameter3 outputLayerParameter = paramvalues.get_Element(out_groupLayerNumber) as IGPParameter3;
IGPValue outputLayerGPValue = gpUtilities3.UnpackGPValue(outputLayerParameter);
// if the output layer value is still empty and build a proposal for a name
if (outputLayerGPValue.IsEmpty())
{
// read the proposed name from the resources
string proposedOutputLayerName = resourceManager.GetString("GPTools_GPCombineLayers_outputgrouplayer_proposedname");
string proposedOutputLayerNameTest = proposedOutputLayerName;
int layerIndex = 2;
// check if a layer with the same name already exists
// if it does then attempt to append some index numbers to build a unique, new name
ILayer foundLayer = gpUtilities3.FindMapLayer(proposedOutputLayerNameTest);
while (foundLayer != null)
{
proposedOutputLayerNameTest = proposedOutputLayerName + " (" + layerIndex + ")";
foundLayer = gpUtilities3.FindMapLayer(proposedOutputLayerNameTest);
layerIndex = layerIndex + 1;
if (layerIndex > 10000)
{
break;
}
}
outputLayerGPValue.SetAsText(proposedOutputLayerNameTest);
gpUtilities3.PackGPValue(outputLayerGPValue, outputLayerParameter);
}
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPValue inputLayersGPValue = gpUtilities3.UnpackGPValue(paramvalues.get_Element(in_LayersNumber));
IGPMultiValue inputLayersMultiValue = gpUtilities3.UnpackGPValue(inputLayersGPValue) as IGPMultiValue;
IGPParameter outputGroupLayerParameter = paramvalues.get_Element(out_groupLayerNumber) as IGPParameter;
IGPValue outputGPGroupLayer = gpUtilities3.UnpackGPValue(outputGroupLayerParameter);
IGPCompositeLayer outputCompositeLayer = outputGPGroupLayer as IGPCompositeLayer;
if (outputCompositeLayer == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), outputGroupLayerParameter.Name));
return;
}
IGroupLayer groupLayer = null;
// find the last position of the "\" string
// in case we find such a thing, i.e. position is >= -1 then let's assume that we are dealing with a layer file on disk
// otherwise let's create a new group layer instance
string outputGPLayerNameAsString = outputGPGroupLayer.GetAsText();
int separatorPosition = outputGPLayerNameAsString.LastIndexOf(System.IO.Path.DirectorySeparatorChar);
string layerName = String.Empty;
if (separatorPosition > -1)
{
layerName = outputGPGroupLayer.GetAsText().Substring(separatorPosition + 1);
}
else
{
layerName = outputGPGroupLayer.GetAsText();
}
ILayer foundLayer = null;
IGPLayer existingGPLayer = gpUtilities3.FindMapLayer2(layerName, out foundLayer);
if (foundLayer != null)
{
gpUtilities3.RemoveFromMapEx((IGPValue)existingGPLayer);
gpUtilities3.RemoveInternalLayerEx(foundLayer);
}
groupLayer = new GroupLayer();
((ILayer)groupLayer).Name = layerName;
for (int layerIndex = 0; layerIndex < inputLayersMultiValue.Count; layerIndex++)
{
IGPValue gpLayerToAdd = inputLayersMultiValue.get_Value(layerIndex) as IGPValue;
ILayer sourceLayer = gpUtilities3.DecodeLayer(gpLayerToAdd);
groupLayer.Add(sourceLayer);
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(groupLayer);
if (separatorPosition > -1)
{
try
{
// in the case that we are dealing with a layer file on disk
// let's persist the group layer information into the file
ILayerFile pointLayerFile = new LayerFileClass();
if (System.IO.Path.GetExtension(outputGPLayerNameAsString).ToUpper().Equals(".LYR"))
{
if (pointLayerFile.get_IsPresent(outputGPLayerNameAsString))
{
try
{
gpUtilities3.Delete(outputGPGroupLayer);
}
catch (Exception ex)
{
message.AddError(120001, ex.Message);
return;
}
}
pointLayerFile.New(outputGPLayerNameAsString);
pointLayerFile.ReplaceContents(groupLayer);
pointLayerFile.Save();
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(pointLayerFile.Layer);
}
catch (Exception ex)
{
message.AddError(120002, ex.Message);
return;
}
}
gpUtilities3.PackGPValue(outputGPGroupLayer, outputGroupLayerParameter);
}
catch (Exception ex)
{
message.AddError(120049, ex.Message);
}
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
// find feature class inside the given feature dataset
IGPParameter osmFeatureDatasetParameter = paramvalues.get_Element(in_osmFeatureDatasetNumber) as IGPParameter;
IDEFeatureDataset osmFeatureDataset = gpUtilities3.UnpackGPValue(osmFeatureDatasetParameter) as IDEFeatureDataset;
string osmPointFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_pt";
string osmLineFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ln";
string osmPolygonFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ply";
IFeatureClass osmPointFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPointFeatureClassString);
IFeatureClass osmLineFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmLineFeatureClassString);
IFeatureClass osmPoylgonFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPolygonFeatureClassString);
// open the specified layers holding the symbology and editing templates
IGPParameter osmPointSymbolTemplateParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter;
IGPValue osmGPPointLayerValue = gpUtilities3.UnpackGPValue(osmPointSymbolTemplateParameter);
IGPParameter outputPointGPParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter;
IGPValue outputPointLayerGPValue = gpUtilities3.UnpackGPValue(outputPointGPParameter);
bool isLayerOnDisk = false;
// create a clone of the source layer
// we will then go ahead and adjust the data source (dataset) of the cloned layer
IObjectCopy objectCopy = new ObjectCopyClass();
ICompositeLayer adjustedPointTemplateLayer = objectCopy.Copy(osmGPPointLayerValue) as ICompositeLayer;
IGPGroupLayer osmPointGroupTemplateLayer = adjustedPointTemplateLayer as IGPGroupLayer;
ICompositeLayer compositeLayer = gpUtilities3.Open((IGPValue)osmPointGroupTemplateLayer) as ICompositeLayer;
//ICompositeLayer adjustedPointTemplateLayer = osmGPPointLayerValue as ICompositeLayer;
//IGPGroupLayer osmPointGroupTemplateLayer = osmGPPointLayerValue as IGPGroupLayer;
//IClone cloneSource = osmPointGroupTemplateLayer as IClone;
//ICompositeLayer compositeLayer = m_gpUtilities3.Open((IGPValue)cloneSource.Clone()) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPointLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
IFeatureLayerDefinition2 featureLayerDefinition2 = null;
ISQLSyntax sqlSyntax = null;
IGPLayer adjustedPointGPLayer = null;
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer != null)
{
if (geoFeatureLayer.ShapeType == osmPointFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPointFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPointFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPointFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
}
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile pointLayerFile = new LayerFileClass();
if (pointLayerFile.get_IsPresent(outputPointLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPointLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120041, ex.Message);
return;
}
}
pointLayerFile.New(outputPointLayerGPValue.GetAsText());
pointLayerFile.ReplaceContents((ILayer)compositeLayer);
pointLayerFile.Save();
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)pointLayerFile.Layer);
}
// IGPLayer adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPointGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPointGPLayer, outputPointGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmLineSymbolTemplateParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter;
IGPValue osmGPLineLayerValue = gpUtilities3.UnpackGPValue(osmLineSymbolTemplateParameter) as IGPValue;
IGPParameter outputLineGPParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter;
IGPValue outputLineLayerGPValue = gpUtilities3.UnpackGPValue(outputLineGPParameter);
IGPValue adjustedLineTemplateLayer = objectCopy.Copy(osmGPLineLayerValue) as IGPValue;
IGPGroupLayer osmLineGroupTemplateLayer = adjustedLineTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmLineGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPLineLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmLineFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmLineFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmLineFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmLineFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (string.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile lineLayerFile = new LayerFileClass();
if (lineLayerFile.get_IsPresent(outputLineLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputLineLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120042, ex.Message);
return;
}
}
lineLayerFile.New(outputLineLayerGPValue.GetAsText());
lineLayerFile.ReplaceContents((ILayer)compositeLayer);
lineLayerFile.Save();
}
IGPLayer adjustLineGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustLineGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustLineGPLayer, outputLineGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmPolygonSymbolTemplateParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter;
IGPValue osmGPPolygonLayerValue = gpUtilities3.UnpackGPValue(osmPolygonSymbolTemplateParameter);
IGPParameter outputPolygonGPParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter;
IGPValue outputPolygonLayerGPValue = gpUtilities3.UnpackGPValue(outputPolygonGPParameter);
IGPValue adjustedPolygonTemplateLayer = objectCopy.Copy(osmGPPolygonLayerValue) as IGPValue;
IGPGroupLayer osmPolygonGroupTemplateLayer = adjustedPolygonTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmPolygonGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPolygonLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmPoylgonFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPoylgonFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPoylgonFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPoylgonFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile polygonLayerFile = new LayerFileClass();
if (polygonLayerFile.get_IsPresent(outputPolygonLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPolygonLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120043, ex.Message);
return;
}
}
polygonLayerFile.New(outputPolygonLayerGPValue.GetAsText());
polygonLayerFile.ReplaceContents((ILayer)compositeLayer);
polygonLayerFile.Save();
}
IGPLayer adjustedPolygonGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPolygonGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPolygonGPLayer, outputPolygonGPParameter);
}
}
catch (Exception ex)
{
message.AddError(-10, ex.Message);
}
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
#region update the output point parameter based on the input of template point layer
IGPParameter inputPointLayerParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter;
IGPValue inputPointLayer = gpUtilities3.UnpackGPValue(inputPointLayerParameter);
IGPParameter3 outputPointLayerParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter3;
if (((inputPointLayer).IsEmpty() == false) && (outputPointLayerParameter.Altered == false))
{
IGPValue outputPointGPValue = gpUtilities3.UnpackGPValue(outputPointLayerParameter);
if (outputPointGPValue.IsEmpty())
{
IClone clonedObject = inputPointLayer as IClone;
IGPValue clonedGPValue = clonedObject.Clone() as IGPValue;
// if it is an internal group layer
IGPGroupLayer inputPointGroupLayer = clonedObject as IGPGroupLayer;
if (inputPointGroupLayer != null)
{
string proposedLayerName = "Points";
string tempLayerName = proposedLayerName;
int index = 1;
ILayer currentMapLayer = gpUtilities3.FindMapLayer(proposedLayerName);
while (currentMapLayer != null)
{
tempLayerName = proposedLayerName + "_" + index.ToString();
currentMapLayer = gpUtilities3.FindMapLayer(tempLayerName);
index = index + 1;
}
clonedGPValue.SetAsText(tempLayerName);
gpUtilities3.PackGPValue(clonedGPValue, outputPointLayerParameter);
}
else
{
IDELayer deLayer = clonedGPValue as IDELayer;
if (deLayer != null)
{
FileInfo sourceLyrFileInfo = new FileInfo(clonedGPValue.GetAsText());
// check the output location of the file with respect to the gp environment settings
sourceLyrFileInfo = new FileInfo(DetermineLyrLocation(pEnvMgr.GetEnvironments(), sourceLyrFileInfo));
if (sourceLyrFileInfo.Exists)
{
int layerFileIndex = 1;
string tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
while (File.Exists(tempFileLyrName))
{
tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
layerFileIndex = layerFileIndex + 1;
}
clonedGPValue.SetAsText(tempFileLyrName);
gpUtilities3.PackGPValue(clonedGPValue, outputPointLayerParameter);
}
else
{
clonedGPValue.SetAsText(sourceLyrFileInfo.FullName);
gpUtilities3.PackGPValue(clonedGPValue, outputPointLayerParameter);
}
}
}
}
}
#endregion
#region update the output line parameter based on the input of template line layer
IGPParameter inputLineLayerParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter;
IGPValue inputLineLayer = gpUtilities3.UnpackGPValue(inputLineLayerParameter);
IGPParameter3 outputLineLayerParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter3;
if (((inputLineLayer).IsEmpty() == false) && (outputLineLayerParameter.Altered == false))
{
IGPValue outputLineGPValue = gpUtilities3.UnpackGPValue(outputLineLayerParameter);
if (outputLineGPValue.IsEmpty())
{
IClone clonedObject = inputLineLayer as IClone;
IGPValue clonedGPValue = clonedObject.Clone() as IGPValue;
// if it is an internal group layer
IGPGroupLayer inputLineGroupLayer = clonedObject as IGPGroupLayer;
if (inputLineGroupLayer != null)
{
string proposedLayerName = "Lines";
string tempLayerName = proposedLayerName;
int index = 1;
ILayer currentMapLayer = gpUtilities3.FindMapLayer(proposedLayerName);
while (currentMapLayer != null)
{
tempLayerName = proposedLayerName + "_" + index.ToString();
currentMapLayer = gpUtilities3.FindMapLayer(tempLayerName);
index = index + 1;
}
clonedGPValue.SetAsText(tempLayerName);
gpUtilities3.PackGPValue(clonedGPValue, outputLineLayerParameter);
}
else
{
IDELayer deLayer = clonedGPValue as IDELayer;
if (deLayer != null)
{
FileInfo sourceLyrFileInfo = new FileInfo(clonedGPValue.GetAsText());
// check the output location of the file with respect to the gp environment settings
sourceLyrFileInfo = new FileInfo(DetermineLyrLocation(pEnvMgr.GetEnvironments(), sourceLyrFileInfo));
if (sourceLyrFileInfo.Exists)
{
int layerFileIndex = 1;
string tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
while (File.Exists(tempFileLyrName))
{
tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
layerFileIndex = layerFileIndex + 1;
}
clonedGPValue.SetAsText(tempFileLyrName);
gpUtilities3.PackGPValue(clonedGPValue, outputLineLayerParameter);
}
else
{
clonedGPValue.SetAsText(sourceLyrFileInfo.FullName);
gpUtilities3.PackGPValue(clonedGPValue, outputLineLayerParameter);
}
}
}
}
}
#endregion
#region update the output polygon parameter based on the input of template polygon layer
IGPParameter inputPolygonLayerParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter;
IGPValue inputPolygonLayer = gpUtilities3.UnpackGPValue(inputPolygonLayerParameter);
IGPParameter3 outputPolygonLayerParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter3;
if (((inputPolygonLayer).IsEmpty() == false) && (outputPolygonLayerParameter.Altered == false))
{
IGPValue outputPolygonGPValue = gpUtilities3.UnpackGPValue(outputPolygonLayerParameter);
if (outputPolygonGPValue.IsEmpty())
{
IClone clonedObject = inputPolygonLayer as IClone;
IGPValue clonedGPValue = clonedObject.Clone() as IGPValue;
// if it is an internal group layer
IGPGroupLayer inputPolygonGroupLayer = clonedObject as IGPGroupLayer;
if (inputPolygonGroupLayer != null)
{
string proposedLayerName = "Polygons";
string tempLayerName = proposedLayerName;
int index = 1;
ILayer currentMapLayer = gpUtilities3.FindMapLayer(proposedLayerName);
while (currentMapLayer != null)
{
tempLayerName = proposedLayerName + "_" + index.ToString();
currentMapLayer = gpUtilities3.FindMapLayer(tempLayerName);
index = index + 1;
}
clonedGPValue.SetAsText(tempLayerName);
gpUtilities3.PackGPValue(clonedGPValue, outputPolygonLayerParameter);
}
else
{
IDELayer deLayer = clonedGPValue as IDELayer;
if (deLayer != null)
{
FileInfo sourceLyrFileInfo = new FileInfo(clonedGPValue.GetAsText());
// check the output location of the file with respect to the gp environment settings
sourceLyrFileInfo = new FileInfo(DetermineLyrLocation(pEnvMgr.GetEnvironments(), sourceLyrFileInfo));
if (sourceLyrFileInfo.Exists)
{
int layerFileIndex = 1;
string tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
while (File.Exists(tempFileLyrName))
{
tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
layerFileIndex = layerFileIndex + 1;
}
clonedGPValue.SetAsText(tempFileLyrName);
gpUtilities3.PackGPValue(clonedGPValue, outputPolygonLayerParameter);
}
else
{
clonedGPValue.SetAsText(sourceLyrFileInfo.FullName);
gpUtilities3.PackGPValue(clonedGPValue, outputPolygonLayerParameter);
}
}
}
}
}
#endregion
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPParameter revisionTableParameter = paramvalues.get_Element(in_changesTablesNumber) as IGPParameter;
IGPValue revisionTableGPValue = gpUtilities3.UnpackGPValue(revisionTableParameter);
if (revisionTableGPValue.IsEmpty() == false)
{
if (gpUtilities3.Exists(revisionTableGPValue) == false)
{
IGPEnvironment workspaceEnvironment = gpUtilities3.GetEnvironment(pEnvMgr.GetEnvironments(), "workspace");
IGPValue workspace = workspaceEnvironment.Value;
if (workspace.IsEmpty() == false)
{
string old_locationValue = workspace.GetAsText() + System.IO.Path.DirectorySeparatorChar + revisionTableGPValue.GetAsText();
try
{
string location = gpUtilities3.QualifyOutputCatalogPath(old_locationValue);
if (location.Length != old_locationValue.Length)
{
revisionTableGPValue.SetAsText(location);
gpUtilities3.PackGPValue(revisionTableGPValue, revisionTableParameter);
}
}
catch { }
}
}
}
gpUtilities3.ReleaseInternals();
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
IFeatureClass osmPointFeatureClass = null;
IFeatureClass osmLineFeatureClass = null;
IFeatureClass osmPolygonFeatureClass = null;
OSMToolHelper osmToolHelper = null;
try
{
DateTime syncTime = DateTime.Now;
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
osmToolHelper = new OSMToolHelper();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter osmFileParameter = paramvalues.get_Element(in_osmFileNumber) as IGPParameter;
IGPValue osmFileLocationString = gpUtilities3.UnpackGPValue(osmFileParameter) as IGPValue;
// ensure that the specified file does exist
bool osmFileExists = false;
try
{
osmFileExists = System.IO.File.Exists(osmFileLocationString.GetAsText());
}
catch (Exception ex)
{
message.AddError(120029, String.Format(resourceManager.GetString("GPTools_OSMGPFileReader_problemaccessingfile"), ex.Message));
return;
}
if (osmFileExists == false)
{
message.AddError(120030, String.Format(resourceManager.GetString("GPTools_OSMGPFileReader_osmfiledoesnotexist"), osmFileLocationString.GetAsText()));
return;
}
IGPParameter conserveMemoryParameter = paramvalues.get_Element(in_conserveMemoryNumber) as IGPParameter;
IGPBoolean conserveMemoryGPValue = gpUtilities3.UnpackGPValue(conserveMemoryParameter) as IGPBoolean;
if (conserveMemoryGPValue == null)
{
message.AddError(120031, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), conserveMemoryParameter.Name));
return;
}
message.AddMessage(resourceManager.GetString("GPTools_OSMGPFileReader_countingNodes"));
long nodeCapacity = 0;
long wayCapacity = 0;
long relationCapacity = 0;
Dictionary<esriGeometryType, List<string>> attributeTags = new Dictionary<esriGeometryType, List<string>>();
IGPParameter tagCollectionParameter = paramvalues.get_Element(in_attributeSelector) as IGPParameter;
IGPMultiValue tagCollectionGPValue = gpUtilities3.UnpackGPValue(tagCollectionParameter) as IGPMultiValue;
List<String> tagstoExtract = null;
if (tagCollectionGPValue.Count > 0)
{
tagstoExtract = new List<string>();
for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++)
{
string nameOfTag = tagCollectionGPValue.get_Value(valueIndex).GetAsText();
if (nameOfTag.ToUpper().Equals("ALL"))
{
tagstoExtract = new List<string>();
break;
}
else
{
tagstoExtract.Add(nameOfTag);
}
}
}
// if there is an "ALL" keyword then we scan for all tags, otherwise we only add the desired tags to the feature classes and do a 'quick'
// count scan
if (tagstoExtract != null)
{
if (tagstoExtract.Count > 0)
{
// if the number of tags is > 0 then do a simple feature count and take name tags names from the gp value
osmToolHelper.countOSMStuff(osmFileLocationString.GetAsText(), ref nodeCapacity, ref wayCapacity, ref relationCapacity, ref TrackCancel);
attributeTags.Add(esriGeometryType.esriGeometryPoint, tagstoExtract);
attributeTags.Add(esriGeometryType.esriGeometryPolyline, tagstoExtract);
attributeTags.Add(esriGeometryType.esriGeometryPolygon, tagstoExtract);
}
else
{
// the count should be zero if we encountered the "ALL" keyword
// in this case count the features and create a list of unique tags
attributeTags = osmToolHelper.countOSMCapacityAndTags(osmFileLocationString.GetAsText(), ref nodeCapacity, ref wayCapacity, ref relationCapacity, ref TrackCancel);
}
}
else
{
// no tags we defined, hence we do a simple count and create an empty list indicating that no additional fields
// need to be created
osmToolHelper.countOSMStuff(osmFileLocationString.GetAsText(), ref nodeCapacity, ref wayCapacity, ref relationCapacity, ref TrackCancel);
attributeTags.Add(esriGeometryType.esriGeometryPoint, new List<string>());
attributeTags.Add(esriGeometryType.esriGeometryPolyline, new List<string>());
attributeTags.Add(esriGeometryType.esriGeometryPolygon, new List<string>());
}
if (nodeCapacity == 0 && wayCapacity == 0 && relationCapacity == 0)
{
return;
}
if (conserveMemoryGPValue.Value == false)
{
osmNodeDictionary = new Dictionary<string, OSMToolHelper.simplePointRef>(Convert.ToInt32(nodeCapacity));
}
message.AddMessage(String.Format(resourceManager.GetString("GPTools_OSMGPFileReader_countedElements"), nodeCapacity, wayCapacity, relationCapacity));
// prepare the feature dataset and classes
IGPParameter targetDatasetParameter = paramvalues.get_Element(out_targetDatasetNumber) as IGPParameter;
IGPValue targetDatasetGPValue = gpUtilities3.UnpackGPValue(targetDatasetParameter);
IDEDataset2 targetDEDataset2 = targetDatasetGPValue as IDEDataset2;
if (targetDEDataset2 == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), targetDatasetParameter.Name));
return;
}
string targetDatasetName = ((IGPValue)targetDEDataset2).GetAsText();
IDataElement targetDataElement = targetDEDataset2 as IDataElement;
IDataset targetDataset = gpUtilities3.OpenDatasetFromLocation(targetDataElement.CatalogPath);
IName parentName = null;
try
{
parentName = gpUtilities3.CreateParentFromCatalogPath(targetDataElement.CatalogPath);
}
catch
{
message.AddError(120033, resourceManager.GetString("GPTools_OSMGPFileReader_unable_to_create_fd"));
return;
}
// test if the feature classes already exists,
// if they do and the environments settings are such that an overwrite is not allowed we need to abort at this point
IGeoProcessorSettings gpSettings = (IGeoProcessorSettings)envMgr;
if (gpSettings.OverwriteOutput == true)
{
}
else
{
if (gpUtilities3.Exists((IGPValue)targetDEDataset2) == true)
{
message.AddError(120032, String.Format(resourceManager.GetString("GPTools_OSMGPFileReader_basenamealreadyexists"), targetDataElement.Name));
return;
}
}
// load the descriptions from which to derive the domain values
OSMDomains availableDomains = null;
// Reading the XML document requires a FileStream.
System.Xml.XmlTextReader reader = null;
string xmlDomainFile = "";
m_editorConfigurationSettings.TryGetValue("osmdomainsfilepath", out xmlDomainFile);
if (System.IO.File.Exists(xmlDomainFile))
{
reader = new System.Xml.XmlTextReader(xmlDomainFile);
}
if (reader == null)
{
message.AddError(120033, resourceManager.GetString("GPTools_OSMGPDownload_NoDomainConfigFile"));
return;
}
System.Xml.Serialization.XmlSerializer domainSerializer = null;
try
{
domainSerializer = new XmlSerializer(typeof(OSMDomains));
availableDomains = domainSerializer.Deserialize(reader) as OSMDomains;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
message.AddError(120034, ex.Message);
return;
}
reader.Close();
message.AddMessage(resourceManager.GetString("GPTools_preparedb"));
Dictionary<string, IDomain> codedValueDomains = new Dictionary<string, IDomain>();
foreach (var domain in availableDomains.domain)
{
ICodedValueDomain pointCodedValueDomain = new CodedValueDomainClass();
((IDomain)pointCodedValueDomain).Name = domain.name + "_pt";
((IDomain)pointCodedValueDomain).FieldType = esriFieldType.esriFieldTypeString;
ICodedValueDomain lineCodedValueDomain = new CodedValueDomainClass();
((IDomain)lineCodedValueDomain).Name = domain.name + "_ln";
((IDomain)lineCodedValueDomain).FieldType = esriFieldType.esriFieldTypeString;
ICodedValueDomain polygonCodedValueDomain = new CodedValueDomainClass();
((IDomain)polygonCodedValueDomain).Name = domain.name + "_ply";
((IDomain)polygonCodedValueDomain).FieldType = esriFieldType.esriFieldTypeString;
for (int i = 0; i < domain.domainvalue.Length; i++)
{
for (int domainGeometryIndex = 0; domainGeometryIndex < domain.domainvalue[i].geometrytype.Length; domainGeometryIndex++)
{
switch (domain.domainvalue[i].geometrytype[domainGeometryIndex])
{
case geometrytype.point:
pointCodedValueDomain.AddCode(domain.domainvalue[i].value, domain.domainvalue[i].value);
break;
case geometrytype.line:
lineCodedValueDomain.AddCode(domain.domainvalue[i].value, domain.domainvalue[i].value);
break;
case geometrytype.polygon:
polygonCodedValueDomain.AddCode(domain.domainvalue[i].value, domain.domainvalue[i].value);
break;
default:
break;
}
}
}
// add the domain tables to the domains collection
codedValueDomains.Add(((IDomain)pointCodedValueDomain).Name, (IDomain)pointCodedValueDomain);
codedValueDomains.Add(((IDomain)lineCodedValueDomain).Name, (IDomain)lineCodedValueDomain);
codedValueDomains.Add(((IDomain)polygonCodedValueDomain).Name, (IDomain)polygonCodedValueDomain);
}
IWorkspaceDomains workspaceDomain = null;
IFeatureWorkspace featureWorkspace = null;
// if the target dataset already exists we can go ahead and QI to it directly
if (targetDataset != null)
{
workspaceDomain = targetDataset.Workspace as IWorkspaceDomains;
featureWorkspace = targetDataset.Workspace as IFeatureWorkspace;
}
else
{
// in case it doesn't exist yet we will open the parent (the workspace - geodatabase- itself) and
// use it as a reference to create the feature dataset and the feature classes in it.
IWorkspace newWorkspace = ((IName)parentName).Open() as IWorkspace;
workspaceDomain = newWorkspace as IWorkspaceDomains;
featureWorkspace = newWorkspace as IFeatureWorkspace;
}
foreach (var domain in codedValueDomains.Values)
{
IDomain testDomain = null;
try
{
testDomain = workspaceDomain.get_DomainByName(domain.Name);
}
catch { }
if (testDomain == null)
{
workspaceDomain.AddDomain(domain);
}
}
// this determines the spatial reference as defined from the gp environment settings and the initial wgs84 SR
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
ISpatialReference wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
ISpatialReference downloadSpatialReference = gpUtilities3.GetGPSpRefEnv(envMgr, wgs84, null, 0, 0, 0, 0, null);
Marshal.ReleaseComObject(wgs84);
Marshal.ReleaseComObject(spatialReferenceFactory);
IGPEnvironment configKeyword = OSMGPDownload.getEnvironment(envMgr, "configKeyword");
IGPString gpString = configKeyword.Value as IGPString;
string storageKeyword = String.Empty;
if (gpString != null)
{
storageKeyword = gpString.Value;
}
IFeatureDataset targetFeatureDataset = null;
if (gpUtilities3.Exists((IGPValue)targetDEDataset2))
{
targetFeatureDataset = gpUtilities3.OpenDataset((IGPValue)targetDEDataset2) as IFeatureDataset;
}
else
{
targetFeatureDataset = featureWorkspace.CreateFeatureDataset(targetDataElement.Name, downloadSpatialReference);
}
downloadSpatialReference = ((IGeoDataset)targetFeatureDataset).SpatialReference;
string metadataAbstract = resourceManager.GetString("GPTools_OSMGPFileReader_metadata_abstract");
string metadataPurpose = resourceManager.GetString("GPTools_OSMGPFileReader_metadata_purpose");
// assign the custom class extension for use with the OSM feature inspector
UID osmClassUID = new UIDClass();
osmClassUID.Value = "{65CA4847-8661-45eb-8E1E-B2985CA17C78}";
// points
try
{
osmPointFeatureClass = osmToolHelper.CreatePointFeatureClass((IWorkspace2)featureWorkspace, targetFeatureDataset, targetDataElement.Name + "_osm_pt", null, null, null, storageKeyword, availableDomains, metadataAbstract, metadataPurpose, attributeTags[esriGeometryType.esriGeometryPoint]);
}
catch (Exception ex)
{
message.AddError(120035, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpointfeatureclass"), ex.Message));
return;
}
if (osmPointFeatureClass == null)
{
return;
}
// change the property set of the osm class extension to skip any change detection during the initial data load
osmPointFeatureClass.RemoveOSMClassExtension();
int osmPointIDFieldIndex = osmPointFeatureClass.FindField("OSMID");
Dictionary<string, int> osmPointDomainAttributeFieldIndices = new Dictionary<string, int>();
foreach (var domains in availableDomains.domain)
{
int currentFieldIndex = osmPointFeatureClass.FindField(domains.name);
if (currentFieldIndex != -1)
{
osmPointDomainAttributeFieldIndices.Add(domains.name, currentFieldIndex);
}
}
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");
// lines
try
{
osmLineFeatureClass = osmToolHelper.CreateLineFeatureClass((IWorkspace2)featureWorkspace, targetFeatureDataset, targetDataElement.Name + "_osm_ln", null, null, null, storageKeyword, availableDomains, metadataAbstract, metadataPurpose, attributeTags[esriGeometryType.esriGeometryPolyline]);
}
catch (Exception ex)
{
message.AddError(120036, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nulllinefeatureclass"), ex.Message));
return;
}
if (osmLineFeatureClass == null)
{
return;
}
// change the property set of the osm class extension to skip any change detection during the initial data load
osmLineFeatureClass.RemoveOSMClassExtension();
int osmLineIDFieldIndex = osmLineFeatureClass.FindField("OSMID");
Dictionary<string, int> osmLineDomainAttributeFieldIndices = new Dictionary<string, int>();
foreach (var domains in availableDomains.domain)
{
int currentFieldIndex = osmLineFeatureClass.FindField(domains.name);
if (currentFieldIndex != -1)
{
osmLineDomainAttributeFieldIndices.Add(domains.name, currentFieldIndex);
}
}
int tagCollectionPolylineFieldIndex = osmLineFeatureClass.FindField("osmTags");
int osmUserPolylineFieldIndex = osmLineFeatureClass.FindField("osmuser");
int osmUIDPolylineFieldIndex = osmLineFeatureClass.FindField("osmuid");
int osmVisiblePolylineFieldIndex = osmLineFeatureClass.FindField("osmvisible");
int osmVersionPolylineFieldIndex = osmLineFeatureClass.FindField("osmversion");
int osmChangesetPolylineFieldIndex = osmLineFeatureClass.FindField("osmchangeset");
int osmTimeStampPolylineFieldIndex = osmLineFeatureClass.FindField("osmtimestamp");
int osmMemberOfPolylineFieldIndex = osmLineFeatureClass.FindField("osmMemberOf");
int osmMembersPolylineFieldIndex = osmLineFeatureClass.FindField("osmMembers");
int osmSupportingElementPolylineFieldIndex = osmLineFeatureClass.FindField("osmSupportingElement");
// polygons
try
{
osmPolygonFeatureClass = osmToolHelper.CreatePolygonFeatureClass((IWorkspace2)featureWorkspace, targetFeatureDataset, targetDataElement.Name + "_osm_ply", null, null, null, storageKeyword, availableDomains, metadataAbstract, metadataPurpose, attributeTags[esriGeometryType.esriGeometryPolygon]);
}
catch (Exception ex)
{
message.AddError(120037, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpolygonfeatureclass"), ex.Message));
return;
}
if (osmPolygonFeatureClass == null)
{
return;
}
// change the property set of the osm class extension to skip any change detection during the initial data load
osmPolygonFeatureClass.RemoveOSMClassExtension();
int osmPolygonIDFieldIndex = osmPolygonFeatureClass.FindField("OSMID");
Dictionary<string, int> osmPolygonDomainAttributeFieldIndices = new Dictionary<string, int>();
foreach (var domains in availableDomains.domain)
{
int currentFieldIndex = osmPolygonFeatureClass.FindField(domains.name);
if (currentFieldIndex != -1)
{
osmPolygonDomainAttributeFieldIndices.Add(domains.name, currentFieldIndex);
}
}
int tagCollectionPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmTags");
int osmUserPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmuser");
int osmUIDPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmuid");
int osmVisiblePolygonFieldIndex = osmPolygonFeatureClass.FindField("osmvisible");
int osmVersionPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmversion");
int osmChangesetPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmchangeset");
int osmTimeStampPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmtimestamp");
int osmMemberOfPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmMemberOf");
int osmMembersPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmMembers");
int osmSupportingElementPolygonFieldIndex = osmPolygonFeatureClass.FindField("osmSupportingElement");
// relation table
ITable relationTable = null;
try
{
relationTable = osmToolHelper.CreateRelationTable((IWorkspace2)featureWorkspace, targetDataElement.Name + "_osm_relation", null, storageKeyword, metadataAbstract, metadataPurpose);
}
catch (Exception ex)
{
message.AddError(120038, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullrelationtable"), ex.Message));
return;
}
if (relationTable == null)
{
return;
}
int osmRelationIDFieldIndex = relationTable.FindField("OSMID");
int tagCollectionRelationFieldIndex = relationTable.FindField("osmTags");
int osmUserRelationFieldIndex = relationTable.FindField("osmuser");
int osmUIDRelationFieldIndex = relationTable.FindField("osmuid");
int osmVisibleRelationFieldIndex = relationTable.FindField("osmvisible");
int osmVersionRelationFieldIndex = relationTable.FindField("osmversion");
int osmChangesetRelationFieldIndex = relationTable.FindField("osmchangeset");
int osmTimeStampRelationFieldIndex = relationTable.FindField("osmtimestamp");
int osmMemberOfRelationFieldIndex = relationTable.FindField("osmMemberOf");
int osmMembersRelationFieldIndex = relationTable.FindField("osmMembers");
int osmSupportingElementRelationFieldIndex = relationTable.FindField("osmSupportingElement");
// revision table
ITable revisionTable = null;
try
{
revisionTable = osmToolHelper.CreateRevisionTable((IWorkspace2)featureWorkspace, targetDataElement.Name + "_osm_revision", null, storageKeyword);
}
catch (Exception ex)
{
message.AddError(120039, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullrevisiontable"), ex.Message));
return;
}
if (revisionTable == null)
{
return;
}
#region clean any existing data from loading targets
ESRI.ArcGIS.Geoprocessing.IGeoProcessor2 gp = new ESRI.ArcGIS.Geoprocessing.GeoProcessorClass();
IGeoProcessorResult gpResult = new GeoProcessorResultClass();
try
{
IVariantArray truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_pt");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_ln");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "\\" + targetDataElement.Name + "_osm_ply");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "_osm_relation");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
truncateParameters = new VarArrayClass();
truncateParameters.Add(((IWorkspace)featureWorkspace).PathName + "\\" + targetDataElement.Name + "_osm_revision");
gpResult = gp.Execute("TruncateTable_management", truncateParameters, TrackCancel);
}
catch (Exception ex)
{
message.AddWarning(ex.Message);
}
#endregion
bool fastLoad = false;
//// check for user interruption
//if (TrackCancel.Continue() == false)
//{
// message.AddAbort(resourceManager.GetString("GPTools_toolabort"));
// return;
//}
//IFeatureCursor deleteCursor = null;
//using (ComReleaser comReleaser = new ComReleaser())
//{
// // let's make sure that we clean out any old data that might have existed in the feature classes
// deleteCursor = osmPointFeatureClass.Update(null, false);
// comReleaser.ManageLifetime(deleteCursor);
// for (IFeature feature = deleteCursor.NextFeature(); feature != null; feature = deleteCursor.NextFeature())
// {
// feature.Delete();
// // check for user interruption
// if (TrackCancel.Continue() == false)
// {
// message.AddAbort(resourceManager.GetString("GPTools_toolabort"));
// return;
// }
// }
//}
//using (ComReleaser comReleaser = new ComReleaser())
//{
// deleteCursor = osmLineFeatureClass.Update(null, false);
// comReleaser.ManageLifetime(deleteCursor);
// for (IFeature feature = deleteCursor.NextFeature(); feature != null; feature = deleteCursor.NextFeature())
// {
// feature.Delete();
// // check for user interruption
// if (TrackCancel.Continue() == false)
// {
// message.AddAbort(resourceManager.GetString("GPTools_toolabort"));
// return;
// }
// }
//}
//using (ComReleaser comReleaser = new ComReleaser())
//{
// deleteCursor = osmPolygonFeatureClass.Update(null, false);
// comReleaser.ManageLifetime(deleteCursor);
// for (IFeature feature = deleteCursor.NextFeature(); feature != null; feature = deleteCursor.NextFeature())
// {
// feature.Delete();
// // check for user interruption
// if (TrackCancel.Continue() == false)
// {
// message.AddAbort(resourceManager.GetString("GPTools_toolabort"));
// return;
// }
// }
//}
//ICursor tableCursor = null;
//using (ComReleaser comReleaser = new ComReleaser())
//{
// tableCursor = relationTable.Update(null, false);
// comReleaser.ManageLifetime(tableCursor);
// for (IRow row = tableCursor.NextRow(); row != null; row = tableCursor.NextRow())
// {
// row.Delete();
// // check for user interruption
// if (TrackCancel.Continue() == false)
// {
// message.AddAbort(resourceManager.GetString("GPTools_toolabort"));
// return;
// }
// }
//}
//using (ComReleaser comReleaser = new ComReleaser())
//{
// tableCursor = revisionTable.Update(null, false);
// comReleaser.ManageLifetime(tableCursor);
// for (IRow row = tableCursor.NextRow(); row != null; row = tableCursor.NextRow())
// {
// row.Delete();
// // check for user interruption
// if (TrackCancel.Continue() == false)
// {
// message.AddAbort(resourceManager.GetString("GPTools_toolabort"));
// return;
// }
// }
//}
// define variables helping to invoke core tools for data management
IGeoProcessorResult2 gpResults2 = null;
IGeoProcessor2 geoProcessor = new GeoProcessorClass();
#region load points
osmToolHelper.loadOSMNodes(osmFileLocationString.GetAsText(), ref TrackCancel, ref message, targetDatasetGPValue, osmPointFeatureClass, conserveMemoryGPValue.Value, fastLoad, Convert.ToInt32(nodeCapacity), ref osmNodeDictionary, featureWorkspace, downloadSpatialReference, availableDomains, false);
#endregion
if (TrackCancel.Continue() == false)
{
return;
}
#region load ways
List<string> missingWays = osmToolHelper.loadOSMWays(osmFileLocationString.GetAsText(), ref TrackCancel, ref message, targetDatasetGPValue, osmPointFeatureClass, osmLineFeatureClass, osmPolygonFeatureClass, conserveMemoryGPValue.Value, fastLoad, Convert.ToInt32(wayCapacity), ref osmNodeDictionary, featureWorkspace, downloadSpatialReference, availableDomains, false);
#endregion
if (downloadSpatialReference != null)
Marshal.ReleaseComObject(downloadSpatialReference);
#region for local geodatabases enforce spatial integrity
bool storedOriginalLocal = geoProcessor.AddOutputsToMap;
geoProcessor.AddOutputsToMap = false;
if (osmLineFeatureClass != null)
{
if (((IDataset)osmLineFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
{
gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
IGPParameter outLinesParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
IGPValue lineFeatureClass = gpUtilities3.UnpackGPValue(outLinesParameter);
DataManagementTools.RepairGeometry repairlineGeometry = new DataManagementTools.RepairGeometry(osmLineFeatureClass);
IVariantArray repairGeometryParameterArray = new VarArrayClass();
repairGeometryParameterArray.Add(lineFeatureClass.GetAsText());
repairGeometryParameterArray.Add("DELETE_NULL");
gpResults2 = geoProcessor.Execute(repairlineGeometry.ToolName, repairGeometryParameterArray, TrackCancel) as IGeoProcessorResult2;
message.AddMessages(gpResults2.GetResultMessages());
ComReleaser.ReleaseCOMObject(gpUtilities3);
}
}
if (osmPolygonFeatureClass != null)
{
if (((IDataset)osmPolygonFeatureClass).Workspace.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)
{
gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
IGPParameter outPolygonParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
IGPValue polygonFeatureClass = gpUtilities3.UnpackGPValue(outPolygonParameter);
DataManagementTools.RepairGeometry repairpolygonGeometry = new DataManagementTools.RepairGeometry(osmPolygonFeatureClass);
IVariantArray repairGeometryParameterArray = new VarArrayClass();
repairGeometryParameterArray.Add(polygonFeatureClass.GetAsText());
repairGeometryParameterArray.Add("DELETE_NULL");
gpResults2 = geoProcessor.Execute(repairpolygonGeometry.ToolName, repairGeometryParameterArray, TrackCancel) as IGeoProcessorResult2;
message.AddMessages(gpResults2.GetResultMessages());
ComReleaser.ReleaseCOMObject(gpUtilities3);
}
}
geoProcessor.AddOutputsToMap = storedOriginalLocal;
#endregion
if (TrackCancel.Continue() == false)
{
return;
}
#region load relations
List<string> missingRelations = osmToolHelper.loadOSMRelations(osmFileLocationString.GetAsText(), ref TrackCancel, ref message, targetDatasetGPValue, osmPointFeatureClass, osmLineFeatureClass, osmPolygonFeatureClass, Convert.ToInt32(relationCapacity), relationTable, availableDomains, fastLoad, false);
#endregion
// check for user interruption
if (TrackCancel.Continue() == false)
{
return;
}
//storedOriginalLocal = geoProcessor.AddOutputsToMap;
//try
//{
// geoProcessor.AddOutputsToMap = false;
// // add indexes for revisions
// //IGPValue revisionTableGPValue = gpUtilities3.MakeGPValueFromObject(revisionTable);
// string revisionTableString = targetDatasetGPValue.GetAsText() + System.IO.Path.DirectorySeparatorChar + ((IDataset)revisionTable).BrowseName;
// IVariantArray parameterArrary2 = osmToolHelper.CreateAddIndexParameterArray(revisionTableString, "osmoldid;osmnewid", "osmID_IDX", "", "");
// gpResults2 = geoProcessor.Execute("AddIndex_management", parameterArrary2, TrackCancel) as IGeoProcessorResult2;
// message.AddMessages(gpResults2.GetResultMessages());
//}
//catch (Exception ex)
//{
// message.AddWarning(ex.Message);
//}
//finally
//{
// geoProcessor.AddOutputsToMap = storedOriginalLocal;
//}
#region update the references counts and member lists for nodes
message.AddMessage(resourceManager.GetString("GPTools_OSMGPFileReader_updatereferences"));
IFeatureCursor pointUpdateCursor = null;
IQueryFilter pointQueryFilter = new QueryFilterClass();
// adjust of number of all other reference counter from 0 to 1
if (conserveMemoryGPValue.Value == true)
{
pointQueryFilter.WhereClause = osmPointFeatureClass.SqlIdentifier("wayRefCount") + " = 0";
pointQueryFilter.SubFields = osmPointFeatureClass.OIDFieldName + ",wayRefCount";
}
using (SchemaLockManager ptLockManager = new SchemaLockManager(osmPointFeatureClass as ITable))
{
using (ComReleaser comReleaser = new ComReleaser())
{
int updateCount = 0;
if (conserveMemoryGPValue.Value == true)
{
pointUpdateCursor = osmPointFeatureClass.Update(pointQueryFilter, false);
updateCount = ((ITable)osmPointFeatureClass).RowCount(pointQueryFilter);
}
else
{
pointUpdateCursor = osmPointFeatureClass.Update(null, false);
updateCount = ((ITable)osmPointFeatureClass).RowCount(null);
}
IStepProgressor stepProgressor = TrackCancel as IStepProgressor;
if (stepProgressor != null)
{
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = updateCount;
stepProgressor.Position = 0;
stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPFileReader_updatepointrefcount");
stepProgressor.StepValue = 1;
stepProgressor.Show();
}
comReleaser.ManageLifetime(pointUpdateCursor);
IFeature pointFeature = pointUpdateCursor.NextFeature();
int positionCounter = 0;
while (pointFeature != null)
{
positionCounter++;
string nodeID = Convert.ToString(pointFeature.get_Value(osmPointIDFieldIndex));
if (conserveMemoryGPValue.Value == false)
{
// let get the reference counter from the internal node dictionary
if (osmNodeDictionary[nodeID].RefCounter == 0)
{
pointFeature.set_Value(osmWayRefCountFieldIndex, 1);
}
else
{
pointFeature.set_Value(osmWayRefCountFieldIndex, osmNodeDictionary[nodeID].RefCounter);
}
}
else
{
// in the case of memory conservation let's go change the 0s to 1s
pointFeature.set_Value(osmWayRefCountFieldIndex, 1);
}
pointUpdateCursor.UpdateFeature(pointFeature);
if (pointFeature != null)
Marshal.ReleaseComObject(pointFeature);
pointFeature = pointUpdateCursor.NextFeature();
if (stepProgressor != null)
{
stepProgressor.Position = positionCounter;
}
}
if (stepProgressor != null)
{
stepProgressor.Hide();
}
Marshal.ReleaseComObject(pointQueryFilter);
}
}
#endregion
if (osmNodeDictionary != null)
{
// clear outstanding resources potentially holding points
osmNodeDictionary = null;
System.GC.Collect(2, GCCollectionMode.Forced);
}
if (missingRelations.Count > 0)
{
missingRelations.Clear();
missingRelations = null;
}
if (missingWays.Count > 0)
{
missingWays.Clear();
missingWays = null;
}
SyncState.StoreLastSyncTime(targetDatasetName, syncTime);
gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3;
// repackage the feature class into their respective gp values
IGPParameter pointFeatureClassParameter = paramvalues.get_Element(out_osmPointsNumber) as IGPParameter;
IGPValue pointFeatureClassGPValue = gpUtilities3.UnpackGPValue(pointFeatureClassParameter);
gpUtilities3.PackGPValue(pointFeatureClassGPValue, pointFeatureClassParameter);
IGPParameter lineFeatureClassParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter;
IGPValue line1FeatureClassGPValue = gpUtilities3.UnpackGPValue(lineFeatureClassParameter);
gpUtilities3.PackGPValue(line1FeatureClassGPValue, lineFeatureClassParameter);
IGPParameter polygonFeatureClassParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter;
IGPValue polygon1FeatureClassGPValue = gpUtilities3.UnpackGPValue(polygonFeatureClassParameter);
gpUtilities3.PackGPValue(polygon1FeatureClassGPValue, polygonFeatureClassParameter);
ComReleaser.ReleaseCOMObject(relationTable);
ComReleaser.ReleaseCOMObject(revisionTable);
ComReleaser.ReleaseCOMObject(targetFeatureDataset);
ComReleaser.ReleaseCOMObject(featureWorkspace);
ComReleaser.ReleaseCOMObject(osmFileLocationString);
ComReleaser.ReleaseCOMObject(conserveMemoryGPValue);
ComReleaser.ReleaseCOMObject(targetDataset);
gpUtilities3.ReleaseInternals();
ComReleaser.ReleaseCOMObject(gpUtilities3);
}
catch (Exception ex)
{
message.AddError(120055, ex.Message);
message.AddError(120055, ex.StackTrace);
}
finally
{
try
{
// TE -- 1/7/2015
// this is a 'breaking' change as the default loader won't no longer enable the edit extension
// the reasoning here is that most users would like the OSM in a 'read-only' fashion, and don't need to track
// changes to be properly transmitted back to the OSM server
//if (osmPointFeatureClass != null)
//{
// osmPointFeatureClass.ApplyOSMClassExtension();
// ComReleaser.ReleaseCOMObject(osmPointFeatureClass);
//}
//if (osmLineFeatureClass != null)
//{
// osmLineFeatureClass.ApplyOSMClassExtension();
// ComReleaser.ReleaseCOMObject(osmLineFeatureClass);
//}
//if (osmPolygonFeatureClass != null)
//{
// osmPolygonFeatureClass.ApplyOSMClassExtension();
// ComReleaser.ReleaseCOMObject(osmPolygonFeatureClass);
//}
osmToolHelper = null;
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
}
catch (Exception ex)
{
message.AddError(120056, ex.ToString());
}
}
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
IGPParameter targetDatasetParameter = paramvalues.get_Element(out_targetDatasetNumber) as IGPParameter;
IGPValue targetDatasetGPValue = gpUtilities3.UnpackGPValue(targetDatasetParameter);
IDEFeatureDataset targetDEFeatureDataset = targetDatasetGPValue as IDEFeatureDataset;
IGPParameter3 outPointsFeatureClassParameter = null;
IGPValue outPointsFeatureClass = null;
string outpointsPath = String.Empty;
IGPParameter3 outLinesFeatureClassParameter = null;
IGPValue outLinesFeatureClass = null;
string outlinesPath = String.Empty;
IGPParameter3 outPolygonFeatureClassParameter = null;
IGPValue outPolygonFeatureClass = null;
string outpolygonsPath = String.Empty;
if (((IGPValue)targetDEFeatureDataset).GetAsText().Length != 0)
{
IDataElement dataElement = targetDEFeatureDataset as IDataElement;
try
{
gpUtilities3.QualifyOutputDataElement(gpUtilities3.UnpackGPValue(targetDatasetParameter));
}
catch
{
return;
}
string nameOfPointFeatureClass = dataElement.GetBaseName() + "_osm_pt";
string nameOfLineFeatureClass = dataElement.GetBaseName() + "_osm_ln";
string nameOfPolygonFeatureClass = dataElement.GetBaseName() + "_osm_ply";
try
{
outpointsPath = dataElement.CatalogPath + System.IO.Path.DirectorySeparatorChar + nameOfPointFeatureClass;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
outPointsFeatureClassParameter = paramvalues.get_Element(out_osmPointsNumber) as IGPParameter3;
outPointsFeatureClass = gpUtilities3.UnpackGPValue(outPointsFeatureClassParameter);
outlinesPath = dataElement.CatalogPath + System.IO.Path.DirectorySeparatorChar + nameOfLineFeatureClass;
outLinesFeatureClassParameter = paramvalues.get_Element(out_osmLinesNumber) as IGPParameter3;
outLinesFeatureClass = gpUtilities3.UnpackGPValue(outLinesFeatureClassParameter);
outpolygonsPath = dataElement.CatalogPath + System.IO.Path.DirectorySeparatorChar + nameOfPolygonFeatureClass;
outPolygonFeatureClassParameter = paramvalues.get_Element(out_osmPolygonsNumber) as IGPParameter3;
outPolygonFeatureClass = gpUtilities3.UnpackGPValue(outPolygonFeatureClassParameter);
}
// TE - 10/20/2014
if (((IGPParameter)paramvalues.get_Element(in_attributeSelector)).Altered)
{
IGPParameter tagCollectionParameter = paramvalues.get_Element(in_attributeSelector) as IGPParameter;
IGPMultiValue tagCollectionGPValue = gpUtilities3.UnpackGPValue(tagCollectionParameter) as IGPMultiValue;
IGPCodedValueDomain codedTagDomain = tagCollectionParameter.Domain as IGPCodedValueDomain;
for (int attributeValueIndex = 0; attributeValueIndex < tagCollectionGPValue.Count; attributeValueIndex++)
{
string valueString = tagCollectionGPValue.get_Value(attributeValueIndex).GetAsText();
IGPValue testFieldValue = codedTagDomain.FindValue(valueString);
if (testFieldValue == null)
{
codedTagDomain.AddStringCode(valueString, valueString);
}
}
string illegalCharacters = "`~@#$%^&()-+=,{}.![];";
IFieldsEdit fieldsEdit = new FieldsClass();
for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++)
{
string tagString = tagCollectionGPValue.get_Value(valueIndex).GetAsText();
if (tagString != "ALL")
{
// Check if the input field already exists.
string cleanedTagKey = OSMToolHelper.convert2AttributeFieldName(tagString, illegalCharacters);
IFieldEdit fieldEdit = new FieldClass();
fieldEdit.Name_2 = cleanedTagKey;
fieldEdit.AliasName_2 = tagCollectionGPValue.get_Value(valueIndex).GetAsText();
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.Length_2 = 100;
fieldsEdit.AddField(fieldEdit);
}
}
IFields fields = fieldsEdit as IFields;
// Get the derived output feature class schema and empty the additional fields. This ensures
// that you don't get dublicate entries.
if (outPointsFeatureClassParameter != null)
{
IGPFeatureSchema polySchema = outPolygonFeatureClassParameter.Schema as IGPFeatureSchema;
if (polySchema != null)
{
// Add the additional field to the polygon output.
polySchema.AdditionalFields = fields;
}
else
{
polySchema = new GPFeatureSchemaClass();
polySchema.AdditionalFields = fields;
polySchema.GeometryType = esriGeometryType.esriGeometryPolygon;
polySchema.FeatureType = esriFeatureType.esriFTSimple;
}
}
if (outLinesFeatureClassParameter != null)
{
IGPFeatureSchema lineSchema = outLinesFeatureClassParameter.Schema as IGPFeatureSchema;
if (lineSchema != null)
{
// Add the additional field to the line output.
lineSchema.AdditionalFields = fields;
}
else
{
lineSchema = new GPFeatureSchemaClass();
lineSchema.AdditionalFields = fields;
lineSchema.GeometryType = esriGeometryType.esriGeometryPolyline;
lineSchema.FeatureType = esriFeatureType.esriFTSimple;
}
}
if (outPointsFeatureClassParameter != null)
{
IGPFeatureSchema pointSchema = outPointsFeatureClassParameter.Schema as IGPFeatureSchema;
if (pointSchema != null)
{
// Add the additional field to the point output.
pointSchema.AdditionalFields = fields;
}
else
{
pointSchema = new GPFeatureSchemaClass();
pointSchema.AdditionalFields = fields;
pointSchema.GeometryType = esriGeometryType.esriGeometryPoint;
pointSchema.FeatureType = esriFeatureType.esriFTSimple;
}
}
}
if (outPointsFeatureClassParameter != null)
{
outPointsFeatureClass.SetAsText(outpointsPath);
gpUtilities3.PackGPValue(outPointsFeatureClass, outPointsFeatureClassParameter);
}
if (outLinesFeatureClassParameter != null)
{
outLinesFeatureClass.SetAsText(outlinesPath);
gpUtilities3.PackGPValue(outLinesFeatureClass, outLinesFeatureClassParameter);
}
if (outPolygonFeatureClassParameter != null)
{
outPolygonFeatureClass.SetAsText(outpolygonsPath);
gpUtilities3.PackGPValue(outPolygonFeatureClass, outPolygonFeatureClassParameter);
}
gpUtilities3.ReleaseInternals();
if (gpUtilities3 != null)
ComReleaser.ReleaseCOMObject(gpUtilities3);
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPValue inputLayersGPValue = gpUtilities3.UnpackGPValue(paramvalues.get_Element(in_LayersNumber));
IGPMultiValue inputLayersMultiValue = gpUtilities3.UnpackGPValue(inputLayersGPValue) as IGPMultiValue;
IGPParameter outputGroupLayerParameter = paramvalues.get_Element(out_groupLayerNumber) as IGPParameter;
IGPValue outputGPGroupLayer = gpUtilities3.UnpackGPValue(outputGroupLayerParameter);
IGPCompositeLayer outputCompositeLayer = outputGPGroupLayer as IGPCompositeLayer;
if (outputCompositeLayer == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), outputGroupLayerParameter.Name));
return;
}
IGroupLayer groupLayer = null;
// find the last position of the "\" string
// in case we find such a thing, i.e. position is >= -1 then let's assume that we are dealing with a layer file on disk
// otherwise let's create a new group layer instance
string outputGPLayerNameAsString = outputGPGroupLayer.GetAsText();
int separatorPosition = outputGPLayerNameAsString.LastIndexOf(System.IO.Path.DirectorySeparatorChar);
string layerName = String.Empty;
if (separatorPosition > -1)
{
layerName = outputGPGroupLayer.GetAsText().Substring(separatorPosition + 1);
}
else
{
layerName = outputGPGroupLayer.GetAsText();
}
ILayer foundLayer = null;
IGPLayer existingGPLayer = gpUtilities3.FindMapLayer2(layerName, out foundLayer);
if (foundLayer != null)
{
gpUtilities3.RemoveFromMapEx((IGPValue)existingGPLayer);
gpUtilities3.RemoveInternalLayerEx(foundLayer);
}
groupLayer = new GroupLayer();
((ILayer)groupLayer).Name = layerName;
for (int layerIndex = 0; layerIndex < inputLayersMultiValue.Count; layerIndex++)
{
IGPValue gpLayerToAdd = inputLayersMultiValue.get_Value(layerIndex) as IGPValue;
ILayer sourceLayer = gpUtilities3.DecodeLayer(gpLayerToAdd);
groupLayer.Add(sourceLayer);
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(groupLayer);
if (separatorPosition > -1)
{
try
{
// in the case that we are dealing with a layer file on disk
// let's persist the group layer information into the file
ILayerFile pointLayerFile = new LayerFileClass();
if (System.IO.Path.GetExtension(outputGPLayerNameAsString).ToUpper().Equals(".LYR"))
{
if (pointLayerFile.get_IsPresent(outputGPLayerNameAsString))
{
try
{
gpUtilities3.Delete(outputGPGroupLayer);
}
catch (Exception ex)
{
message.AddError(120001, ex.Message);
return;
}
}
pointLayerFile.New(outputGPLayerNameAsString);
pointLayerFile.ReplaceContents(groupLayer);
pointLayerFile.Save();
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(pointLayerFile.Layer);
}
catch (Exception ex)
{
message.AddError(120002, ex.Message);
return;
}
}
gpUtilities3.PackGPValue(outputGPGroupLayer, outputGroupLayerParameter);
}
catch (Exception ex)
{
message.AddError(120049, ex.Message);
}
}
public void UpdateParameters(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
#region update the output point parameter based on the input of template point layer
IGPParameter inputPointLayerParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter;
IGPValue inputPointLayer = gpUtilities3.UnpackGPValue(inputPointLayerParameter);
IGPParameter3 outputPointLayerParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter3;
if (((inputPointLayer).IsEmpty() == false) && (outputPointLayerParameter.Altered == false))
{
IGPValue outputPointGPValue = gpUtilities3.UnpackGPValue(outputPointLayerParameter);
if (outputPointGPValue.IsEmpty())
{
IClone clonedObject = inputPointLayer as IClone;
IGPValue clonedGPValue = clonedObject.Clone() as IGPValue;
// if it is an internal group layer
IGPGroupLayer inputPointGroupLayer = clonedObject as IGPGroupLayer;
if (inputPointGroupLayer != null)
{
string proposedLayerName = "Points";
string tempLayerName = proposedLayerName;
int index = 1;
ILayer currentMapLayer = gpUtilities3.FindMapLayer(proposedLayerName);
while (currentMapLayer != null)
{
tempLayerName = proposedLayerName + "_" + index.ToString();
currentMapLayer = gpUtilities3.FindMapLayer(tempLayerName);
index = index + 1;
}
clonedGPValue.SetAsText(tempLayerName);
gpUtilities3.PackGPValue(clonedGPValue, outputPointLayerParameter);
}
else
{
IDELayer deLayer = clonedGPValue as IDELayer;
if (deLayer != null)
{
FileInfo sourceLyrFileInfo = new FileInfo(clonedGPValue.GetAsText());
// check the output location of the file with respect to the gp environment settings
sourceLyrFileInfo = new FileInfo(DetermineLyrLocation(pEnvMgr.GetEnvironments(), sourceLyrFileInfo));
if (sourceLyrFileInfo.Exists)
{
int layerFileIndex = 1;
string tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
while (File.Exists(tempFileLyrName))
{
tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
layerFileIndex = layerFileIndex + 1;
}
clonedGPValue.SetAsText(tempFileLyrName);
gpUtilities3.PackGPValue(clonedGPValue, outputPointLayerParameter);
}
else
{
clonedGPValue.SetAsText(sourceLyrFileInfo.FullName);
gpUtilities3.PackGPValue(clonedGPValue, outputPointLayerParameter);
}
}
}
}
}
#endregion
#region update the output line parameter based on the input of template line layer
IGPParameter inputLineLayerParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter;
IGPValue inputLineLayer = gpUtilities3.UnpackGPValue(inputLineLayerParameter);
IGPParameter3 outputLineLayerParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter3;
if (((inputLineLayer).IsEmpty() == false) && (outputLineLayerParameter.Altered == false))
{
IGPValue outputLineGPValue = gpUtilities3.UnpackGPValue(outputLineLayerParameter);
if (outputLineGPValue.IsEmpty())
{
IClone clonedObject = inputLineLayer as IClone;
IGPValue clonedGPValue = clonedObject.Clone() as IGPValue;
// if it is an internal group layer
IGPGroupLayer inputLineGroupLayer = clonedObject as IGPGroupLayer;
if (inputLineGroupLayer != null)
{
string proposedLayerName = "Lines";
string tempLayerName = proposedLayerName;
int index = 1;
ILayer currentMapLayer = gpUtilities3.FindMapLayer(proposedLayerName);
while (currentMapLayer != null)
{
tempLayerName = proposedLayerName + "_" + index.ToString();
currentMapLayer = gpUtilities3.FindMapLayer(tempLayerName);
index = index + 1;
}
clonedGPValue.SetAsText(tempLayerName);
gpUtilities3.PackGPValue(clonedGPValue, outputLineLayerParameter);
}
else
{
IDELayer deLayer = clonedGPValue as IDELayer;
if (deLayer != null)
{
FileInfo sourceLyrFileInfo = new FileInfo(clonedGPValue.GetAsText());
// check the output location of the file with respect to the gp environment settings
sourceLyrFileInfo = new FileInfo(DetermineLyrLocation(pEnvMgr.GetEnvironments(), sourceLyrFileInfo));
if (sourceLyrFileInfo.Exists)
{
int layerFileIndex = 1;
string tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
while (File.Exists(tempFileLyrName))
{
tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
layerFileIndex = layerFileIndex + 1;
}
clonedGPValue.SetAsText(tempFileLyrName);
gpUtilities3.PackGPValue(clonedGPValue, outputLineLayerParameter);
}
else
{
clonedGPValue.SetAsText(sourceLyrFileInfo.FullName);
gpUtilities3.PackGPValue(clonedGPValue, outputLineLayerParameter);
}
}
}
}
}
#endregion
#region update the output polygon parameter based on the input of template polygon layer
IGPParameter inputPolygonLayerParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter;
IGPValue inputPolygonLayer = gpUtilities3.UnpackGPValue(inputPolygonLayerParameter);
IGPParameter3 outputPolygonLayerParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter3;
if (((inputPolygonLayer).IsEmpty() == false) && (outputPolygonLayerParameter.Altered == false))
{
IGPValue outputPolygonGPValue = gpUtilities3.UnpackGPValue(outputPolygonLayerParameter);
if (outputPolygonGPValue.IsEmpty())
{
IClone clonedObject = inputPolygonLayer as IClone;
IGPValue clonedGPValue = clonedObject.Clone() as IGPValue;
// if it is an internal group layer
IGPGroupLayer inputPolygonGroupLayer = clonedObject as IGPGroupLayer;
if (inputPolygonGroupLayer != null)
{
string proposedLayerName = "Polygons";
string tempLayerName = proposedLayerName;
int index = 1;
ILayer currentMapLayer = gpUtilities3.FindMapLayer(proposedLayerName);
while (currentMapLayer != null)
{
tempLayerName = proposedLayerName + "_" + index.ToString();
currentMapLayer = gpUtilities3.FindMapLayer(tempLayerName);
index = index + 1;
}
clonedGPValue.SetAsText(tempLayerName);
gpUtilities3.PackGPValue(clonedGPValue, outputPolygonLayerParameter);
}
else
{
IDELayer deLayer = clonedGPValue as IDELayer;
if (deLayer != null)
{
FileInfo sourceLyrFileInfo = new FileInfo(clonedGPValue.GetAsText());
// check the output location of the file with respect to the gp environment settings
sourceLyrFileInfo = new FileInfo(DetermineLyrLocation(pEnvMgr.GetEnvironments(), sourceLyrFileInfo));
if (sourceLyrFileInfo.Exists)
{
int layerFileIndex = 1;
string tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
while (File.Exists(tempFileLyrName))
{
tempFileLyrName = sourceLyrFileInfo.DirectoryName + System.IO.Path.DirectorySeparatorChar + sourceLyrFileInfo.Name.Substring(0, sourceLyrFileInfo.Name.Length - sourceLyrFileInfo.Extension.Length) + "_" + layerFileIndex.ToString() + sourceLyrFileInfo.Extension;
layerFileIndex = layerFileIndex + 1;
}
clonedGPValue.SetAsText(tempFileLyrName);
gpUtilities3.PackGPValue(clonedGPValue, outputPolygonLayerParameter);
}
else
{
clonedGPValue.SetAsText(sourceLyrFileInfo.FullName);
gpUtilities3.PackGPValue(clonedGPValue, outputPolygonLayerParameter);
}
}
}
}
}
#endregion
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
// find feature class inside the given feature dataset
IGPParameter osmFeatureDatasetParameter = paramvalues.get_Element(in_osmFeatureDatasetNumber) as IGPParameter;
IDEFeatureDataset osmFeatureDataset = gpUtilities3.UnpackGPValue(osmFeatureDatasetParameter) as IDEFeatureDataset;
string osmPointFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_pt";
string osmLineFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ln";
string osmPolygonFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ply";
IFeatureClass osmPointFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPointFeatureClassString);
IFeatureClass osmLineFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmLineFeatureClassString);
IFeatureClass osmPoylgonFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPolygonFeatureClassString);
// open the specified layers holding the symbology and editing templates
IGPParameter osmPointSymbolTemplateParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter;
IGPValue osmGPPointLayerValue = gpUtilities3.UnpackGPValue(osmPointSymbolTemplateParameter);
IGPParameter outputPointGPParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter;
IGPValue outputPointLayerGPValue = gpUtilities3.UnpackGPValue(outputPointGPParameter);
bool isLayerOnDisk = false;
// create a clone of the source layer
// we will then go ahead and adjust the data source (dataset) of the cloned layer
IObjectCopy objectCopy = new ObjectCopyClass();
ICompositeLayer adjustedPointTemplateLayer = objectCopy.Copy(osmGPPointLayerValue) as ICompositeLayer;
IGPGroupLayer osmPointGroupTemplateLayer = adjustedPointTemplateLayer as IGPGroupLayer;
ICompositeLayer compositeLayer = gpUtilities3.Open((IGPValue)osmPointGroupTemplateLayer) as ICompositeLayer;
//ICompositeLayer adjustedPointTemplateLayer = osmGPPointLayerValue as ICompositeLayer;
//IGPGroupLayer osmPointGroupTemplateLayer = osmGPPointLayerValue as IGPGroupLayer;
//IClone cloneSource = osmPointGroupTemplateLayer as IClone;
//ICompositeLayer compositeLayer = m_gpUtilities3.Open((IGPValue)cloneSource.Clone()) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPointLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
IFeatureLayerDefinition2 featureLayerDefinition2 = null;
ISQLSyntax sqlSyntax = null;
IGPLayer adjustedPointGPLayer = null;
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer != null)
{
if (geoFeatureLayer.ShapeType == osmPointFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPointFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPointFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPointFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
}
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile pointLayerFile = new LayerFileClass();
if (pointLayerFile.get_IsPresent(outputPointLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPointLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120041,ex.Message);
return;
}
}
pointLayerFile.New(outputPointLayerGPValue.GetAsText());
pointLayerFile.ReplaceContents((ILayer)compositeLayer);
pointLayerFile.Save();
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)pointLayerFile.Layer);
}
// IGPLayer adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPointGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPointGPLayer, outputPointGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmLineSymbolTemplateParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter;
IGPValue osmGPLineLayerValue = gpUtilities3.UnpackGPValue(osmLineSymbolTemplateParameter) as IGPValue;
IGPParameter outputLineGPParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter;
IGPValue outputLineLayerGPValue = gpUtilities3.UnpackGPValue(outputLineGPParameter);
IGPValue adjustedLineTemplateLayer = objectCopy.Copy(osmGPLineLayerValue) as IGPValue;
IGPGroupLayer osmLineGroupTemplateLayer = adjustedLineTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmLineGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPLineLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmLineFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmLineFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmLineFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmLineFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (string.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile lineLayerFile = new LayerFileClass();
if (lineLayerFile.get_IsPresent(outputLineLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputLineLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120042, ex.Message);
return;
}
}
lineLayerFile.New(outputLineLayerGPValue.GetAsText());
lineLayerFile.ReplaceContents((ILayer)compositeLayer);
lineLayerFile.Save();
}
IGPLayer adjustLineGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustLineGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustLineGPLayer, outputLineGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmPolygonSymbolTemplateParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter;
IGPValue osmGPPolygonLayerValue = gpUtilities3.UnpackGPValue(osmPolygonSymbolTemplateParameter);
IGPParameter outputPolygonGPParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter;
IGPValue outputPolygonLayerGPValue = gpUtilities3.UnpackGPValue(outputPolygonGPParameter);
IGPValue adjustedPolygonTemplateLayer = objectCopy.Copy(osmGPPolygonLayerValue) as IGPValue;
IGPGroupLayer osmPolygonGroupTemplateLayer = adjustedPolygonTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmPolygonGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPolygonLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmPoylgonFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPoylgonFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPoylgonFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPoylgonFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile polygonLayerFile = new LayerFileClass();
if (polygonLayerFile.get_IsPresent(outputPolygonLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPolygonLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120043, ex.Message);
return;
}
}
polygonLayerFile.New(outputPolygonLayerGPValue.GetAsText());
polygonLayerFile.ReplaceContents((ILayer)compositeLayer);
polygonLayerFile.Save();
}
IGPLayer adjustedPolygonGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPolygonGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPolygonGPLayer, outputPolygonGPParameter);
}
}
catch (Exception ex)
{
message.AddError(-10,ex.Message);
}
}
