private IEnumerable<OSMTurnInfo> EnumerateOsmTurnRestrictions(IFeatureWorkspace fws)
{
OSMUtility osmUtility = new OSMUtility();
ITable tableRelation = fws.OpenTable(_osmDataset.Name + "_osm_relation");
try
{
TaskManager.StartProgress(tableRelation.RowCount(null));
using (ComReleaser cr = new ComReleaser())
{
ICursor cursor = tableRelation.Search(null, false);
cr.ManageLifetime(cursor);
int idxTags = cursor.FindField("osmTags");
int idxMembers = cursor.FindField("osmMembers");
IRow row = null;
while ((row = cursor.NextRow()) != null)
{
tag[] tags = osmUtility.retrieveOSMTags(row, idxTags, _osmDataset.Workspace);
var tagsRestriction = tags.Where(t => t.k.Equals("restriction", StringComparison.CurrentCultureIgnoreCase));
foreach (tag tagRestrict in tagsRestriction)
{
OSMTurnInfo turn = new OSMTurnInfo();
turn.TurnType = tagRestrict.v;
foreach (member m in osmUtility.retrieveMembers(row, idxMembers))
{
if (m.role.Equals("from", StringComparison.CurrentCultureIgnoreCase))
turn.From = m;
else if (m.role.Equals("to", StringComparison.CurrentCultureIgnoreCase))
turn.To = m;
else if (m.role.Equals("via", StringComparison.CurrentCultureIgnoreCase))
turn.Via = m;
}
if (turn.HasValidMembers())
{
turn.FromFeature = FindEdgeFeature(turn.From.@ref);
turn.ToFeature = FindEdgeFeature(turn.To.@ref);
turn.ViaFeature = FindJunctionFeature(turn.Via.@ref);
if (turn.HasValidFeatures())
yield return turn;
}
}
TaskManager.StepProgress();
}
}
}
finally
{
TaskManager.EndProgress();
}
}
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 execute_Utilities = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClass) as IGPParameter;
IGPValue inputOSMGPValue = execute_Utilities.UnpackGPValue(inputOSMParameter);
IGPParameter tagCollectionParameter = paramvalues.get_Element(in_attributeSelector) as IGPParameter;
IGPMultiValue tagCollectionGPValue = execute_Utilities.UnpackGPValue(tagCollectionParameter) as IGPMultiValue;
if (tagCollectionGPValue == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), tagCollectionParameter.Name));
return;
}
bool useUpdateCursor = false;
IFeatureClass osmFeatureClass = null;
ITable osmInputTable = null;
IQueryFilter osmQueryFilter = null;
try
{
execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
if (osmFeatureClass != null)
{
if (osmFeatureClass.Extension is IOSMClassExtension)
{
useUpdateCursor = false;
}
else
{
useUpdateCursor = true;
}
}
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
string errorMessage = String.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelecto_unableopentable"), inputOSMGPValue.GetAsText());
message.AddError(120053, errorMessage);
return;
}
// find the field that holds tag binary/xml field
int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags");
// if the Field doesn't exist - wasn't found (index = -1) get out
if (osmTagCollectionFieldIndex == -1)
{
message.AddError(120005, resourceManager.GetString("GPTools_OSMGPAttributeSelector_notagfieldfound"));
return;
}
// check if the tag collection includes the keyword "ALL", if does then we'll need to extract all tags
bool extractAll = false;
for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++)
{
if (tagCollectionGPValue.get_Value(valueIndex).GetAsText().Equals("ALL"))
{
extractAll = true;
break;
}
}
//if (extractAll)
//{
// if (osmTagKeyCodedValues == null)
// extractAllTags(ref osmTagKeyCodedValues, osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex, false);
// if (osmTagKeyCodedValues == null)
// {
// message.AddAbort(resourceManager.GetString("GPTools_OSMGPAttributeSelector_Unable2RetrieveTags"));
// return;
// }
// // empty the existing gp multivalue object
// tagCollectionGPValue = new GPMultiValueClass();
// // fill the coded domain in gp multivalue object
// for (int valueIndex = 0; valueIndex < osmTagKeyCodedValues.CodeCount; valueIndex++)
// {
// tagCollectionGPValue.AddValue(osmTagKeyCodedValues.get_Value(valueIndex));
// }
//}
// get an overall feature count as that determines the progress indicator
int featureCount = osmInputTable.RowCount(osmQueryFilter);
// set up the progress indicator
IStepProgressor stepProgressor = TrackCancel as IStepProgressor;
if (stepProgressor != null)
{
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = featureCount;
stepProgressor.Position = 0;
stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPAttributeSelector_progressMessage");
stepProgressor.StepValue = 1;
stepProgressor.Show();
}
// let's get all the indices of the desired fields
// if the field already exists get the index and if it doesn't exist create it
Dictionary <string, int> tagsAttributesIndices = new Dictionary <string, int>();
Dictionary <int, int> attributeFieldLength = new Dictionary <int, int>();
IFeatureWorkspaceManage featureWorkspaceManage = ((IDataset)osmInputTable).Workspace as IFeatureWorkspaceManage;
String illegalCharacters = String.Empty;
ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax;
if (sqlSyntax != null)
{
illegalCharacters = sqlSyntax.GetInvalidCharacters();
}
IFieldsEdit fieldsEdit = osmInputTable.Fields as IFieldsEdit;
using (SchemaLockManager lockMgr = new SchemaLockManager(osmInputTable))
{
try
{
string tagKey = String.Empty;
ESRI.ArcGIS.Geoprocessing.IGeoProcessor2 gp = new ESRI.ArcGIS.Geoprocessing.GeoProcessorClass();
// if we have explicitly defined tags to extract then go through the list of values now
if (extractAll == false)
{
for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++)
{
if (TrackCancel.Continue() == false)
{
return;
}
try
{
// Check if the input field already exists.
string nameofTag = tagCollectionGPValue.get_Value(valueIndex).GetAsText();
tagKey = convert2AttributeFieldName(nameofTag, illegalCharacters);
int fieldIndex = osmInputTable.FindField(tagKey);
if (fieldIndex < 0)
{
// generate a new attribute field
IFieldEdit fieldEdit = new FieldClass();
fieldEdit.Name_2 = tagKey;
fieldEdit.AliasName_2 = nameofTag + resourceManager.GetString("GPTools_OSMGPAttributeSelector_aliasaddition");
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.Length_2 = 100;
osmInputTable.AddField(fieldEdit);
message.AddMessage(string.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelector_addField"), tagKey, nameofTag));
// re-generate the attribute index
fieldIndex = osmInputTable.FindField(tagKey);
}
if (fieldIndex > 0)
{
tagsAttributesIndices.Add(nameofTag, fieldIndex);
attributeFieldLength.Add(fieldIndex, osmInputTable.Fields.get_Field(fieldIndex).Length);
}
}
catch (Exception ex)
{
// the key is already there, this might result because from multiple upper and lower-case combinations of the same key
message.AddWarning(ex.Message + " (" + convert2OSMKey(tagKey, illegalCharacters) + ")");
}
}
}
else
{
List <string> listofAllTags = extractAllTags(osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex);
foreach (string nameOfTag in listofAllTags)
{
if (TrackCancel.Continue() == false)
{
return;
}
try
{
// Check if the input field already exists.
tagKey = convert2AttributeFieldName(nameOfTag, illegalCharacters);
int fieldIndex = osmInputTable.FindField(tagKey);
if (fieldIndex < 0)
{
// generate a new attribute field
IFieldEdit fieldEdit = new FieldClass();
fieldEdit.Name_2 = tagKey;
fieldEdit.AliasName_2 = nameOfTag + resourceManager.GetString("GPTools_OSMGPAttributeSelector_aliasaddition");
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.Length_2 = 100;
osmInputTable.AddField(fieldEdit);
message.AddMessage(string.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelector_addField"), tagKey, nameOfTag));
// re-generate the attribute index
fieldIndex = osmInputTable.FindField(tagKey);
}
if (fieldIndex > 0)
{
tagsAttributesIndices.Add(nameOfTag, fieldIndex);
attributeFieldLength.Add(fieldIndex, osmInputTable.Fields.get_Field(fieldIndex).Length);
}
}
catch (Exception ex)
{
// the key is already there, this might result because from multiple upper and lower-case combinations of the same key
message.AddWarning(ex.Message + " (" + convert2OSMKey(tagKey, illegalCharacters) + ")");
}
}
}
}
catch (Exception ex)
{
message.AddWarning(ex.Message);
}
}
try
{
execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
if (osmFeatureClass != null)
{
if (osmFeatureClass.Extension is IOSMClassExtension)
{
useUpdateCursor = false;
}
else
{
useUpdateCursor = true;
}
}
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
string errorMessage = String.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelecto_unableopentable"), inputOSMGPValue.GetAsText());
message.AddError(120053, errorMessage);
return;
}
using (ComReleaser comReleaser = new ComReleaser())
{
using (SchemaLockManager lockMgr = new SchemaLockManager(osmInputTable))
{
// get an update cursor for all the features to process
ICursor rowCursor = null;
if (useUpdateCursor)
{
rowCursor = osmInputTable.Update(osmQueryFilter, false);
}
else
{
rowCursor = osmInputTable.Search(osmQueryFilter, false);
}
comReleaser.ManageLifetime(rowCursor);
IRow osmRow = null;
Dictionary <string, string> tagKeys = new Dictionary <string, string>();
int progessIndex = 0;
#if DEBUG
message.AddMessage("useUpdateCursor: " + useUpdateCursor.ToString());
#endif
// as long as there are features....
while ((osmRow = rowCursor.NextRow()) != null)
{
// retrieve the tags of the current feature
tag[] storedTags = _osmUtility.retrieveOSMTags(osmRow, osmTagCollectionFieldIndex, ((IDataset)osmInputTable).Workspace);
bool rowChanged = false;
if (storedTags != null)
{
foreach (tag tagItem in storedTags)
{
// Check for matching values so we only change a minimum number of rows
if (tagsAttributesIndices.ContainsKey(tagItem.k))
{
int fieldIndex = tagsAttributesIndices[tagItem.k];
//...then stored the value in the attribute field
// ensure that the content of the tag actually does fit into the field length...otherwise do truncate it
string tagValue = tagItem.v;
int fieldLength = attributeFieldLength[fieldIndex];
if (tagValue.Length > fieldLength)
{
tagValue = tagValue.Substring(0, fieldLength);
}
osmRow.set_Value(fieldIndex, tagValue);
rowChanged = true;
}
else
{
#if DEBUG
//message.AddWarning(tagItem.k);
#endif
}
}
}
storedTags = null;
try
{
if (rowChanged)
{
if (useUpdateCursor)
{
rowCursor.UpdateRow(osmRow);
}
else
{
// update the feature through the cursor
osmRow.Store();
}
}
progessIndex++;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
message.AddWarning(ex.Message);
}
if (osmRow != null)
{
Marshal.ReleaseComObject(osmRow);
}
if (stepProgressor != null)
{
// update the progress UI
stepProgressor.Position = progessIndex;
}
// check for user cancellation (every 100 rows)
if ((progessIndex % 100 == 0) && (TrackCancel.Continue() == false))
{
return;
}
}
if (stepProgressor != null)
{
stepProgressor.Hide();
}
}
}
execute_Utilities.ReleaseInternals();
Marshal.ReleaseComObject(execute_Utilities);
}
catch (Exception ex)
{
message.AddError(120054, 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 execute_Utilities = new GPUtilitiesClass();
OSMUtility osmUtility = new OSMUtility();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClassNumber) as IGPParameter;
IGPValue inputOSMGPValue = execute_Utilities.UnpackGPValue(inputOSMParameter);
IGPParameter tagFieldsParameter = paramvalues.get_Element(in_attributeSelectorNumber) as IGPParameter;
IGPMultiValue tagCollectionGPValue = execute_Utilities.UnpackGPValue(tagFieldsParameter) as IGPMultiValue;
if (tagCollectionGPValue == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), tagFieldsParameter.Name));
return;
}
IFeatureClass osmFeatureClass = null;
ITable osmInputTable = null;
IQueryFilter osmQueryFilter = null;
try
{
execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
return;
}
// find the field that holds tag binary/xml field
int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags");
// if the Field doesn't exist - wasn't found (index = -1) get out
if (osmTagCollectionFieldIndex == -1)
{
message.AddError(120005, resourceManager.GetString("GPTools_OSMGPAttributeSelector_notagfieldfound"));
return;
}
// set up the progress indicator
IStepProgressor stepProgressor = TrackCancel as IStepProgressor;
if (stepProgressor != null)
{
int featureCount = osmInputTable.RowCount(osmQueryFilter);
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = featureCount;
stepProgressor.Position = 0;
stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPCombineAttributes_progressMessage");
stepProgressor.StepValue = 1;
stepProgressor.Show();
}
String illegalCharacters = String.Empty;
ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax;
if (sqlSyntax != null)
{
illegalCharacters = sqlSyntax.GetInvalidCharacters();
}
// establish the list of field indexes only once
Dictionary <string, int> fieldIndexes = new Dictionary <string, int>();
for (int selectedGPValueIndex = 0; selectedGPValueIndex < tagCollectionGPValue.Count; selectedGPValueIndex++)
{
// find the field index
int fieldIndex = osmInputTable.FindField(tagCollectionGPValue.get_Value(selectedGPValueIndex).GetAsText());
if (fieldIndex != -1)
{
string tagKeyName = osmInputTable.Fields.get_Field(fieldIndex).Name;
tagKeyName = OSMToolHelper.convert2OSMKey(tagKeyName, illegalCharacters);
fieldIndexes.Add(tagKeyName, fieldIndex);
}
}
ICursor updateCursor = null;
IRow osmRow = null;
using (ComReleaser comReleaser = new ComReleaser())
{
updateCursor = osmInputTable.Update(osmQueryFilter, false);
comReleaser.ManageLifetime(updateCursor);
osmRow = updateCursor.NextRow();
int progressIndex = 0;
while (osmRow != null)
{
// get the current tag collection from the row
ESRI.ArcGIS.OSM.OSMClassExtension.tag[] osmTags = osmUtility.retrieveOSMTags(osmRow, osmTagCollectionFieldIndex, ((IDataset)osmInputTable).Workspace);
Dictionary <string, string> tagsDictionary = new Dictionary <string, string>();
for (int tagIndex = 0; tagIndex < osmTags.Length; tagIndex++)
{
tagsDictionary.Add(osmTags[tagIndex].k, osmTags[tagIndex].v);
}
// look if the tag needs to be updated or added
bool tagsUpdated = false;
foreach (var fieldItem in fieldIndexes)
{
object fldValue = osmRow.get_Value(fieldItem.Value);
if (fldValue != System.DBNull.Value)
{
if (tagsDictionary.ContainsKey(fieldItem.Key))
{
if (!tagsDictionary[fieldItem.Key].Equals(fldValue))
{
tagsDictionary[fieldItem.Key] = Convert.ToString(fldValue);
tagsUpdated = true;
}
}
else
{
tagsDictionary.Add(fieldItem.Key, Convert.ToString(fldValue));
tagsUpdated = true;
}
}
else
{
if (tagsDictionary.ContainsKey(fieldItem.Key))
{
tagsDictionary.Remove(fieldItem.Key);
tagsUpdated = true;
}
}
}
if (tagsUpdated)
{
List <ESRI.ArcGIS.OSM.OSMClassExtension.tag> updatedTags = new List <ESRI.ArcGIS.OSM.OSMClassExtension.tag>();
foreach (var tagItem in tagsDictionary)
{
ESRI.ArcGIS.OSM.OSMClassExtension.tag newTag = new ESRI.ArcGIS.OSM.OSMClassExtension.tag();
newTag.k = tagItem.Key;
newTag.v = tagItem.Value;
updatedTags.Add(newTag);
}
// insert the tags back into the collection field
if (updatedTags.Count != 0)
{
osmUtility.insertOSMTags(osmTagCollectionFieldIndex, osmRow, updatedTags.ToArray(), ((IDataset)osmInputTable).Workspace);
updateCursor.UpdateRow(osmRow);
}
}
progressIndex++;
if (stepProgressor != null)
{
stepProgressor.Position = progressIndex;
}
if (osmRow != null)
{
Marshal.ReleaseComObject(osmRow);
}
osmRow = updateCursor.NextRow();
}
if (stepProgressor != null)
{
stepProgressor.Hide();
}
}
}
catch (Exception ex)
{
message.AddError(120007, ex.Message);
}
}
private IEnumerable <OSMTurnInfo> EnumerateOsmTurnRestrictions(IFeatureWorkspace fws)
{
OSMUtility osmUtility = new OSMUtility();
ITable tableRelation = fws.OpenTable(_osmDataset.Name + "_osm_relation");
try
{
TaskManager.StartProgress(tableRelation.RowCount(null));
using (ComReleaser cr = new ComReleaser())
{
ICursor cursor = tableRelation.Search(null, false);
cr.ManageLifetime(cursor);
int idxTags = cursor.FindField("osmTags");
int idxMembers = cursor.FindField("osmMembers");
IRow row = null;
while ((row = cursor.NextRow()) != null)
{
tag[] tags = osmUtility.retrieveOSMTags(row, idxTags, _osmDataset.Workspace);
var tagsRestriction = tags.Where(t => t.k.Equals("restriction", StringComparison.CurrentCultureIgnoreCase));
foreach (tag tagRestrict in tagsRestriction)
{
OSMTurnInfo turn = new OSMTurnInfo();
turn.TurnType = tagRestrict.v;
foreach (member m in osmUtility.retrieveMembers(row, idxMembers))
{
if (m.role.Equals("from", StringComparison.CurrentCultureIgnoreCase))
{
turn.From = m;
}
else if (m.role.Equals("to", StringComparison.CurrentCultureIgnoreCase))
{
turn.To = m;
}
else if (m.role.Equals("via", StringComparison.CurrentCultureIgnoreCase))
{
turn.Via = m;
}
}
if (turn.HasValidMembers())
{
turn.FromFeature = FindEdgeFeature(turn.From.@ref);
turn.ToFeature = FindEdgeFeature(turn.To.@ref);
turn.ViaFeature = FindJunctionFeature(turn.Via.@ref);
if (turn.HasValidFeatures())
{
yield return(turn);
}
}
}
TaskManager.StepProgress();
}
}
}
finally
{
TaskManager.EndProgress();
}
}
private String ConvertPointFeatureToXmlString(IFeature currentFeature, IWorkspace featureWorkspace, int tagsFieldIndex, int osmIDFieldIndex, int changesetIDFieldIndex, int osmVersionFieldIndex, int userIDFieldIndex, int userNameFieldIndex, int timeStampFieldIndex, int visibleFieldIndex, int extensionVersion)
{
StringBuilder xmlNodeStringBuilder = new StringBuilder(200);
if (currentFeature == null)
throw new ArgumentNullException("currentFeature");
object featureValue = DBNull.Value;
string latitudeString = String.Empty;
string longitudeString = String.Empty;
if (currentFeature.Shape.IsEmpty == false)
{
IPoint wgs84Point = currentFeature.Shape as IPoint;
wgs84Point.Project(m_wgs84);
NumberFormatInfo exportCultureInfo = new CultureInfo("en-US", false).NumberFormat;
exportCultureInfo.NumberDecimalDigits = 6;
latitudeString = wgs84Point.Y.ToString("N", exportCultureInfo);
longitudeString = wgs84Point.X.ToString("N", exportCultureInfo);
Marshal.ReleaseComObject(wgs84Point);
}
string osmIDString = String.Empty;
if (osmIDFieldIndex != -1)
{
osmIDString = Convert.ToString(currentFeature.get_Value(osmIDFieldIndex));
}
string changeSetString = String.Empty;
if (changesetIDFieldIndex != -1)
{
featureValue = currentFeature.get_Value(changesetIDFieldIndex);
if (featureValue != DBNull.Value)
{
changeSetString = Convert.ToString(currentFeature.get_Value(changesetIDFieldIndex));
}
}
string osmVersionString = String.Empty;
if (osmVersionFieldIndex != -1)
{
featureValue = currentFeature.get_Value(osmVersionFieldIndex);
if (featureValue != DBNull.Value)
{
osmVersionString = Convert.ToString(featureValue);
}
}
string userIDString = String.Empty;
if (userIDFieldIndex != -1)
{
featureValue = currentFeature.get_Value(userIDFieldIndex);
if (featureValue != DBNull.Value)
{
userIDString = Convert.ToString(featureValue);
}
}
string userNameString = String.Empty;
if (userNameFieldIndex != -1)
{
featureValue = currentFeature.get_Value(userNameFieldIndex);
if (featureValue != DBNull.Value)
{
userNameString = Convert.ToString(featureValue);
}
}
string timeStampString = String.Empty;
if (timeStampFieldIndex != -1)
{
featureValue = currentFeature.get_Value(timeStampFieldIndex);
if (featureValue != DBNull.Value)
{
timeStampString = Convert.ToDateTime(featureValue).ToUniversalTime().ToString("u");
}
}
string visibilityString = bool.TrueString;
if (visibleFieldIndex != -1)
{
featureValue = currentFeature.get_Value(visibleFieldIndex);
if (featureValue != DBNull.Value)
{
try
{
visibilityString = Convert.ToString(featureValue);
}
catch { }
}
}
tag[] tags = null;
if (tagsFieldIndex > -1)
{
tags = _osmUtility.retrieveOSMTags((IRow)currentFeature, tagsFieldIndex, featureWorkspace);
}
// no tags only the node itself
if (tags != null || tags.Length > 0)
{
xmlNodeStringBuilder.Append("<node id=\"");
xmlNodeStringBuilder.Append(osmIDString);
xmlNodeStringBuilder.Append("\" version=\"");
xmlNodeStringBuilder.Append(osmVersionString);
xmlNodeStringBuilder.Append("\" timestamp=\"");
xmlNodeStringBuilder.Append(timeStampString);
xmlNodeStringBuilder.Append("\" uid=\"");
xmlNodeStringBuilder.Append(userIDString);
xmlNodeStringBuilder.Append("\" user=\"");
xmlNodeStringBuilder.Append(userNameString);
xmlNodeStringBuilder.Append("\" changeset=\"");
xmlNodeStringBuilder.Append(changeSetString);
xmlNodeStringBuilder.Append("\" lat=\"");
xmlNodeStringBuilder.Append(latitudeString);
xmlNodeStringBuilder.Append("\" lon=\"");
xmlNodeStringBuilder.Append(longitudeString);
xmlNodeStringBuilder.AppendLine("\" />");
}
else
{
xmlNodeStringBuilder.Append("<node id=\"");
xmlNodeStringBuilder.Append(osmIDString);
xmlNodeStringBuilder.Append("\" version=\"");
xmlNodeStringBuilder.Append(osmVersionString);
xmlNodeStringBuilder.Append("\" timestamp=\"");
xmlNodeStringBuilder.Append(timeStampString);
xmlNodeStringBuilder.Append("\" uid=\"");
xmlNodeStringBuilder.Append(userIDString);
xmlNodeStringBuilder.Append("\" user=\"");
xmlNodeStringBuilder.Append(userNameString);
xmlNodeStringBuilder.Append("\" changeset=\"");
xmlNodeStringBuilder.Append(changeSetString);
xmlNodeStringBuilder.Append("\" lat=\"");
xmlNodeStringBuilder.Append(latitudeString);
xmlNodeStringBuilder.Append("\" lon=\"");
xmlNodeStringBuilder.Append(longitudeString);
xmlNodeStringBuilder.AppendLine("\" >");
foreach (tag item in tags)
{
xmlNodeStringBuilder.Append("<tag k=\"");
xmlNodeStringBuilder.Append(item.k);
xmlNodeStringBuilder.Append("\" v=\"");
xmlNodeStringBuilder.Append(item.v);
xmlNodeStringBuilder.AppendLine("\" />");
}
xmlNodeStringBuilder.AppendLine("</node>");
}
return xmlNodeStringBuilder.ToString();
}
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 execute_Utilities = new GPUtilitiesClass();
OSMUtility osmUtility = new OSMUtility();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClassNumber) as IGPParameter;
IGPValue inputOSMGPValue = execute_Utilities.UnpackGPValue(inputOSMParameter);
IGPParameter tagFieldsParameter = paramvalues.get_Element(in_attributeSelectorNumber) as IGPParameter;
IGPMultiValue tagCollectionGPValue = execute_Utilities.UnpackGPValue(tagFieldsParameter) as IGPMultiValue;
if (tagCollectionGPValue == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), tagFieldsParameter.Name));
return;
}
IFeatureClass osmFeatureClass = null;
ITable osmInputTable = null;
IQueryFilter osmQueryFilter = null;
try
{
execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter);
osmInputTable = osmFeatureClass as ITable;
}
catch { }
try
{
if (osmInputTable == null)
{
execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter);
}
}
catch { }
if (osmInputTable == null)
{
return;
}
// find the field that holds tag binary/xml field
int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags");
// if the Field doesn't exist - wasn't found (index = -1) get out
if (osmTagCollectionFieldIndex == -1)
{
message.AddError(120005, resourceManager.GetString("GPTools_OSMGPAttributeSelector_notagfieldfound"));
return;
}
// set up the progress indicator
IStepProgressor stepProgressor = TrackCancel as IStepProgressor;
if (stepProgressor != null)
{
int featureCount = osmInputTable.RowCount(osmQueryFilter);
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = featureCount;
stepProgressor.Position = 0;
stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPCombineAttributes_progressMessage");
stepProgressor.StepValue = 1;
stepProgressor.Show();
}
String illegalCharacters = String.Empty;
ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax;
if (sqlSyntax != null)
{
illegalCharacters = sqlSyntax.GetInvalidCharacters();
}
// establish the list of field indexes only once
Dictionary<string, int> fieldIndexes = new Dictionary<string, int>();
for (int selectedGPValueIndex = 0; selectedGPValueIndex < tagCollectionGPValue.Count; selectedGPValueIndex++)
{
// find the field index
int fieldIndex = osmInputTable.FindField(tagCollectionGPValue.get_Value(selectedGPValueIndex).GetAsText());
if (fieldIndex != -1)
{
string tagKeyName = osmInputTable.Fields.get_Field(fieldIndex).Name;
tagKeyName = OSMToolHelper.convert2OSMKey(tagKeyName, illegalCharacters);
fieldIndexes.Add(tagKeyName, fieldIndex);
}
}
ICursor updateCursor = null;
IRow osmRow = null;
using (ComReleaser comReleaser = new ComReleaser())
{
updateCursor = osmInputTable.Update(osmQueryFilter, false);
comReleaser.ManageLifetime(updateCursor);
osmRow = updateCursor.NextRow();
int progressIndex = 0;
while (osmRow != null)
{
// get the current tag collection from the row
ESRI.ArcGIS.OSM.OSMClassExtension.tag[] osmTags = osmUtility.retrieveOSMTags(osmRow, osmTagCollectionFieldIndex, ((IDataset)osmInputTable).Workspace);
Dictionary<string, string> tagsDictionary = new Dictionary<string, string>();
for (int tagIndex = 0; tagIndex < osmTags.Length; tagIndex++)
{
tagsDictionary.Add(osmTags[tagIndex].k, osmTags[tagIndex].v);
}
// look if the tag needs to be updated or added
bool tagsUpdated = false;
foreach (var fieldItem in fieldIndexes)
{
object fldValue = osmRow.get_Value(fieldItem.Value);
if (fldValue != System.DBNull.Value)
{
if (tagsDictionary.ContainsKey(fieldItem.Key))
{
if (!tagsDictionary[fieldItem.Key].Equals(fldValue))
{
tagsDictionary[fieldItem.Key] = Convert.ToString(fldValue);
tagsUpdated = true;
}
}
else
{
tagsDictionary.Add(fieldItem.Key, Convert.ToString(fldValue));
tagsUpdated = true;
}
}
}
if (tagsUpdated)
{
List<ESRI.ArcGIS.OSM.OSMClassExtension.tag> updatedTags = new List<ESRI.ArcGIS.OSM.OSMClassExtension.tag>();
foreach (var tagItem in tagsDictionary)
{
ESRI.ArcGIS.OSM.OSMClassExtension.tag newTag = new ESRI.ArcGIS.OSM.OSMClassExtension.tag();
newTag.k = tagItem.Key;
newTag.v = tagItem.Value;
updatedTags.Add(newTag);
}
// insert the tags back into the collection field
if (updatedTags.Count != 0)
{
osmUtility.insertOSMTags(osmTagCollectionFieldIndex, osmRow, updatedTags.ToArray(), ((IDataset)osmInputTable).Workspace);
updateCursor.UpdateRow(osmRow);
}
}
progressIndex++;
if (stepProgressor != null)
{
stepProgressor.Position = progressIndex;
}
if (osmRow != null)
Marshal.ReleaseComObject(osmRow);
osmRow = updateCursor.NextRow();
}
if (stepProgressor != null)
{
stepProgressor.Hide();
}
}
}
catch (Exception ex)
{
message.AddError(120007, ex.Message);
}
}
private node ConvertPointFeatureToOSMNode(IFeature currentFeature, IWorkspace featureWorkspace, int tagsFieldIndex, int osmIDFieldIndex, int changesetIDFieldIndex, int osmVersionFieldIndex, int userIDFieldIndex, int userNameFieldIndex, int timeStampFieldIndex, int visibleFieldIndex, int extensionVersion)
{
if (currentFeature == null)
{
throw new ArgumentNullException("currentFeature");
}
node osmNode = new node();
object featureValue = DBNull.Value;
if (currentFeature.Shape.IsEmpty == false)
{
IPoint wgs84Point = currentFeature.Shape as IPoint;
wgs84Point.Project(m_wgs84);
CultureInfo exportCultureInfo = new CultureInfo("en-US");
exportCultureInfo.NumberFormat.NumberDecimalDigits = 6;
osmNode.lat = Convert.ToString(wgs84Point.Y, exportCultureInfo);
osmNode.lon = Convert.ToString(wgs84Point.X, exportCultureInfo);
Marshal.ReleaseComObject(wgs84Point);
}
if (osmIDFieldIndex != -1)
{
osmNode.id = Convert.ToString(currentFeature.get_Value(osmIDFieldIndex));
}
if (changesetIDFieldIndex != -1)
{
featureValue = currentFeature.get_Value(changesetIDFieldIndex);
if (featureValue != DBNull.Value)
{
osmNode.changeset = Convert.ToString(currentFeature.get_Value(changesetIDFieldIndex));
}
}
if (osmVersionFieldIndex != -1)
{
featureValue = currentFeature.get_Value(osmVersionFieldIndex);
if (featureValue != DBNull.Value)
{
osmNode.version = Convert.ToString(featureValue);
}
}
if (userIDFieldIndex != -1)
{
featureValue = currentFeature.get_Value(userIDFieldIndex);
if (featureValue != DBNull.Value)
{
osmNode.uid = Convert.ToString(featureValue);
}
}
if (userNameFieldIndex != -1)
{
featureValue = currentFeature.get_Value(userNameFieldIndex);
if (featureValue != DBNull.Value)
{
osmNode.user = Convert.ToString(featureValue);
}
}
if (timeStampFieldIndex != -1)
{
featureValue = currentFeature.get_Value(timeStampFieldIndex);
if (featureValue != DBNull.Value)
{
osmNode.timestamp = Convert.ToDateTime(featureValue).ToUniversalTime().ToString("u");
}
}
if (visibleFieldIndex != -1)
{
featureValue = currentFeature.get_Value(visibleFieldIndex);
if (featureValue != DBNull.Value)
{
try
{
osmNode.visible = (nodeVisible)Enum.Parse(typeof(nodeVisible), Convert.ToString(featureValue));
}
catch
{
osmNode.visible = nodeVisible.@true;
}
}
}
if (tagsFieldIndex > -1)
{
tag[] tags = null;
tags = _osmUtility.retrieveOSMTags((IRow)currentFeature, tagsFieldIndex, featureWorkspace);
if (tags.Length != 0)
{
osmNode.tag = tags;
}
}
return(osmNode);
}