private void btnNew_Click(object sender, EventArgs e)
{
if (this.listBox1.SelectedIndex > -1)
{
frmGaphicTransformation transformation = new frmGaphicTransformation();
ISpatialReferenceFactory factory = new SpatialReferenceEnvironmentClass();
ISpatialReference reference = null;
if (this.cboTarget.SelectedIndex == 0)
{
reference = factory.CreateGeographicCoordinateSystem(4214);
}
else if (this.cboTarget.SelectedIndex == 1)
{
reference = factory.CreateGeographicCoordinateSystem(4610);
}
else
{
reference = factory.CreateGeographicCoordinateSystem(4326);
}
transformation.SourceSpatialReference =
(this.listBox1.SelectedItem as ObjectWrap).Object as ISpatialReference;
transformation.TargetSpatialReference = reference;
if (transformation.ShowDialog() == DialogResult.OK)
{
this.txtConvertMethod.Text = transformation.GeoTransformations.Name;
this.txtConvertMethod.Tag = transformation.GeoTransformations;
this.btnEdit.Enabled = true;
}
}
}
public static IGeometry projectGeometry(IGeometry polygon, int pcs)
{
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference pFromSpatialReference = spatialReferenceFactory.CreateGeographicCoordinateSystem(4490);
if (polygon.SpatialReference != null)
{
pFromSpatialReference = polygon.SpatialReference;
}
ISpatialReference pToSpatialReference;
if (pcs == 4326 || pcs == 4490)
{
pToSpatialReference = spatialReferenceFactory.CreateGeographicCoordinateSystem(4490);
}
else
{
pToSpatialReference = spatialReferenceFactory.CreateProjectedCoordinateSystem(pcs);
}
polygon.SpatialReference = pFromSpatialReference;
polygon.Project(pToSpatialReference);
return(polygon);
}
private void btnOK_Click(object sender, EventArgs e)
{
if (this.cboTargetGCS.SelectedIndex == -1)
{
MessageBox.Show("请选择目标地理框架");
}
else if (this.txtSourGCS.Tag != null)
{
if (this.cboHCSTransformMethod.SelectedIndex == -1)
{
MessageBox.Show("请选择转转方法");
}
else if (this.txtName.Text.Trim().Length == 0)
{
MessageBox.Show("请输入新建地理坐标转转名称");
}
else
{
ISpatialReferenceFactory factory = new SpatialReferenceEnvironmentClass();
ISpatialReference to = null;
if (this.cboTargetGCS.SelectedIndex == 0)
{
to = factory.CreateGeographicCoordinateSystem(4214);
}
else if (this.cboTargetGCS.SelectedIndex == 1)
{
to = factory.CreateGeographicCoordinateSystem(4610);
}
else
{
to = factory.CreateGeographicCoordinateSystem(4326);
}
if (this.igeoTransformation_1 != null)
{
this.igeoTransformation_1.Name = this.txtName.Text.Trim();
}
else
{
IGeoTransformation geoTransformation =
(this.cboHCSTransformMethod.SelectedItem as Class1).GeoTransformation;
geoTransformation.PutSpatialReferences(this.txtSourGCS.Tag as ISpatialReference, to);
geoTransformation.Name = this.txtName.Text;
this.igeoTransformation_1 = geoTransformation;
}
base.DialogResult = DialogResult.OK;
}
}
}
public IPoint ProjectWgsToPulkovoWithGeoTransformation(IPoint inputPoint, CoordinateSystemModel coordinateSystemModel, esriTransformDirection transformationDirection)
{
if (inputPoint == null)
{
return(null);
}
var bufferPoint = new PointClass {
X = inputPoint.X, Y = inputPoint.Y, SpatialReference = inputPoint.SpatialReference
};
//Create Spatial Reference Factory
var spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
var targetSpatialReference = spatialReferenceFactory.CreateGeographicCoordinateSystem(coordinateSystemModel.ESRIWellKnownID);
var coordinateFrameGeoTransformation = new CoordinateFrameTransformationClass();
coordinateFrameGeoTransformation.PutSpatialReferences(bufferPoint.SpatialReference, targetSpatialReference);
coordinateFrameGeoTransformation.PutParameters(Constants.PulkovoToWGS.XAxisTranslation,
Constants.PulkovoToWGS.YAxisTranslation,
Constants.PulkovoToWGS.ZAxisTranslation,
Constants.PulkovoToWGS.XAxisRotation,
Constants.PulkovoToWGS.YAxisRotation,
Constants.PulkovoToWGS.ZAxisRotation,
Constants.PulkovoToWGS.ScaleDifference);
var geometry = bufferPoint as IGeometry5;
geometry.ProjectEx(targetSpatialReference, transformationDirection, coordinateFrameGeoTransformation, false, 0.0, 0.0);
return(geometry as IPoint);
}
public IPoint CreatePoint(double X, double Y, CoordinateSystemModel geoModel, bool createGeoCoordinateSystem = false)
{
var resultPoint = new PointClass();
resultPoint.PutCoords(X, Y);
//Create Spatial Reference Factory
var spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference spatialReference;
if (createGeoCoordinateSystem)
{
//Geographical Coordinate System
spatialReference = spatialReferenceFactory.CreateGeographicCoordinateSystem(geoModel.ESRIWellKnownID);
}
else
{
//Projected Coordinate System to project into
spatialReference = spatialReferenceFactory.CreateProjectedCoordinateSystem(geoModel.ESRIWellKnownID);
}
spatialReference.SetFalseOriginAndUnits(geoModel.FalseOriginX, geoModel.FalseOriginY, geoModel.Units);
resultPoint.SpatialReference = spatialReference;
return(resultPoint);
}
public static IFields CreateFields(esriGeometryType geoType)
{
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;
IFields fields = ocDescription.RequiredFields;
int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName);
IField field = fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = field.GeometryDef;
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.GeometryType_2 = geoType;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
var sr = spatialReferenceFactory.CreateGeographicCoordinateSystem(4326);
geometryDefEdit.SpatialReference_2 = sr;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
field = new FieldClass();
IFieldEdit fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Name";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
return(fields);
}
protected ISpatialReference GetGeographicSpatialReference(int gcsType)
{
var pSrf = new SpatialReferenceEnvironmentClass();
var geographicCoordinateSystem = pSrf.CreateGeographicCoordinateSystem(gcsType);
var spatialReference = (ISpatialReference)geographicCoordinateSystem;
return spatialReference;
}
public static ISpatialReference GetSpatialRefFromWkid(int wkid)
{
try
{
if (wkid == 0)
{
return(null);
}
ISpatialReferenceFactory srf = new SpatialReferenceEnvironmentClass();
ISpatialReference spaRef;
try
{
spaRef = srf.CreateProjectedCoordinateSystem(wkid);
}
catch (Exception)
{
spaRef = srf.CreateGeographicCoordinateSystem(wkid);
}
return(spaRef);
}
catch (Exception ex)
{
}
return(null);
}
private void projectCoords(out double lat, out double lon, IPoint pPoint)
{
ISpatialReference pSR;
SpatialReferenceEnvironment pSREnv = new SpatialReferenceEnvironmentClass();
// using the WKID 2270 == Oregon State Plane South
// =-======================================================
IProjectedCoordinateSystem pPCS = pSREnv.CreateProjectedCoordinateSystem(2270);
pSR = pPCS;
IPoint pLocalPoint = new PointClass();
pLocalPoint.SpatialReference = pSR;
pLocalPoint.PutCoords(pPoint.X, pPoint.Y);
ISpatialReference pWGSSR;
SpatialReferenceEnvironment pSREnv2 = new SpatialReferenceEnvironmentClass();
// this uses the esri enum instead of the 4326 wkid
// again, either is fine
IGeographicCoordinateSystem pGCS = pSREnv2.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
pWGSSR = pGCS;
pWGSSR.SetFalseOriginAndUnits(-180, -90, 1000000);
pLocalPoint.Project(pWGSSR);
lat = pLocalPoint.Y;
lon = pLocalPoint.X;
}
private void createProjectedCoordinateSystem()
{
ISpatialReferenceFactory2 spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
IProjectionGEN projection = spatialReferenceFactory.CreateProjection((int)esriSRProjectionType.esriSRProjection_Sinusoidal) as IProjectionGEN;
IGeographicCoordinateSystem geographicCoordinateSystem = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
ILinearUnit unit = spatialReferenceFactory.CreateUnit((int)esriSRUnitType.esriSRUnit_Meter) as ILinearUnit;
IParameter[] parameters = projection.GetDefaultParameters();
IProjectedCoordinateSystemEdit projectedCoordinateSystemEdit = new ProjectedCoordinateSystemClass();
object name = "Newfoundland"; object alias = "NF_LAB";
object abbreviation = "NF";
object remarks = "Most Eastern Province in Canada";
object usage = "When making maps of Newfoundland";
object geographicCoordinateSystemObject = geographicCoordinateSystem as object;
object unitObject = unit as object;
object projectionObject = projection as object;
object parametersObject = parameters as object;
projectedCoordinateSystemEdit.Define(ref name, ref alias, ref abbreviation, ref remarks, ref usage, ref geographicCoordinateSystemObject, ref unitObject, ref projectionObject, ref parametersObject);
IProjectedCoordinateSystem userDefinedProjectedCoordinateSystem = projectedCoordinateSystemEdit as IProjectedCoordinateSystem;
m_map.SpatialReference = userDefinedProjectedCoordinateSystem;
m_activeView.Refresh();
MessageBox.Show("自定义ProjectedCoordinateSystem完成！");
}
// Get the bounding box of the map frame in wgs84 unprojected
// ### Not not yet implemented, all returned values are wgs84 -> Return the values either in 'native' i.e. incoming coordinate system or convert them to wgs84
public static Dictionary <string, string> getMapFrameWgs84BoundingBox(IMxDocument pMxDoc, string mapFrameName)
{
// Declare and initalise variables
Dictionary <string, string> dict = new Dictionary <string, string>();
IMap pMap = Utilities.getMapFrame(pMxDoc, mapFrameName);
IActiveView pActiveView = pMap as IActiveView;
IEnvelope2 pEnvelope = pActiveView.Extent as IEnvelope2;
// Get the spatial reference of the map frame
// If not Geographic / WGS 84, convert it
var spatialRefDict = getDataFrameSpatialReference(pMxDoc, mapFrameName);
if (spatialRefDict["type"] != "Geographic" && spatialRefDict["datum"] != "WGS 1984")
{
//Convert active view to wgs 84
Debug.WriteLine("Reprojecting to wgs84");
ISpatialReferenceFactory srFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference wgs84;
//GCS to project from
IGeographicCoordinateSystem gcs = srFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
wgs84 = gcs;
wgs84.SetFalseOriginAndUnits(-180, -90, 1000000);
pEnvelope.Project(wgs84);
}
dict.Add("xMin", pEnvelope.XMin.ToString());
dict.Add("yMin", pEnvelope.YMin.ToString());
dict.Add("xMax", pEnvelope.XMax.ToString());
dict.Add("yMax", pEnvelope.YMax.ToString());
return(dict);
}
/// <summary>
/// 将图形定义为指定投影坐标系，并转换成地理坐标系
/// （需要预先知道源几何图形坐标系，可用于源图形坐标系未定义或定义错误的情况）
/// </summary>
/// <param name="geometry">被定义和转换坐标系的几何图形</param>
/// <param name="prjType">投影坐标系，先将图形定义为此坐标系（eg:(int)esriSRGeoCS3Type.esriSRGeoCS_Xian1980)</param>
/// <param name="gcsType">地理坐标系（经纬度坐标系），图形坐标系将转为此坐标系（eg:(int)esriSRProjCS4Type.esriSRProjCS_Xian1980_3_Degree_GK_Zone_37）</param>
/// <returns></returns>
public static void DefinitionPRJtoGCS(this IGeometry geometry, int prjType, int gcsType)
{
ISpatialReferenceFactory spatialRefFact = new SpatialReferenceEnvironmentClass();
geometry.SpatialReference = spatialRefFact.CreateProjectedCoordinateSystem(prjType);
geometry.Project(spatialRefFact.CreateGeographicCoordinateSystem(gcsType));
}
private void Mainwindow_Load(object sender, System.EventArgs e)
{
// 取得 MapControl 和 PageLayoutControl 的引用
pTocControl = (ITOCControl2)axTOCControl1.Object;
pMapControl = (IMapControl3)axMapControl1.Object;
// 创建菜单
pToolMenuMap = new ToolbarMenuClass();
pToolMenuLayer = new ToolbarMenuClass();
pToolMenuLayer.AddItem(new ZoomToLayer(), -1, 0, true, esriCommandStyles.esriCommandStyleTextOnly);
pToolMenuLayer.AddItem(new RemoveLayer(), -1, 1, true, esriCommandStyles.esriCommandStyleTextOnly);
pToolMenuLayer.SetHook(pMapControl);
ISpatialReferenceFactory srFact = new SpatialReferenceEnvironmentClass();///
gcs = srFact.CreateGeographicCoordinateSystem(4214);
axMapControl1.MapScale = 4000000;
axMapControl2.MapScale = 125000000;
// axMapControl2.
IDisplayTransformationScales DTS = axMapControl2.ActiveView.ScreenDisplay.DisplayTransformation as IDisplayTransformationScales;
DTS.RemoveAllUserScales();
DTS.AddUserScale(125000000);
DTS.ScaleSnapping = esriScaleSnapping.esriUserScaleSnapping;
}
private List <TileInfo> GetTile()
{
var schema = _tileSource.Schema;
IEnvelope pEnvelope = new EnvelopeClass();
ISpatialReferenceFactory pSpatRefFact = new SpatialReferenceEnvironmentClass();
pEnvelope.SpatialReference = pSpatRefFact.CreateGeographicCoordinateSystem(4326);
pEnvelope.XMin = extent[0];
pEnvelope.XMax = extent[2];
pEnvelope.YMin = extent[1];
pEnvelope.YMax = extent[3];
var env = Projector.ProjectEnvelope(pEnvelope, schema.Srs);
var mapWidth = 256 * num;
var mapHeight = 256 * num;
float resolution = (float)level;
var centerPoint = env.GetCenterPoint();
var transform = new Transform(centerPoint, resolution, mapWidth, mapHeight);
Extent exte = new Extent(pEnvelope.XMin, pEnvelope.YMin, pEnvelope.XMax, pEnvelope.YMax);
var level1 = Utilities.GetNearestLevel(schema.Resolutions, transform.Resolution);
var tempExtent = new Extent(12597408.0986328, 2623556.09863281, 12629205.9013672, 2655353.90136719);
var tiles = schema.GetTilesInView(tempExtent, 10);
return(tiles.ToList());
}
/// <summary>
/// Gets the geographic spatial reference.
/// </summary>
/// <param name="projection">The spatial reference geographic coordinate system type; i.e. factory code. Use an element <b>value</b> from the
/// <see cref="ESRI.ArcGIS.Geometry.esriSRGeoCSType "/>, <see cref="ESRI.ArcGIS.Geometry.esriSRGeoCS2Type "/>,
/// or <see cref="ESRI.ArcGIS.Geometry.esriSRGeoCS3Type "/> enumerations as the geographicCoordinateSystemType to create a particular
/// predefined geographic coordinate system.
/// <para>This is the <b>value</b> for a given geographic coordinate system constant.</para>
/// </param>
/// <returns></returns>
public static ISpatialReference GetGeographicSpatialReference(int geographicCoordinateSystemType)
{
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem geographicCoordinateSystem = spatialReferenceFactory.CreateGeographicCoordinateSystem(geographicCoordinateSystemType);
return(geographicCoordinateSystem);
}
/// <summary>
/// create a crazy coordinate system
/// </summary>
/// <returns></returns>
private ISpatialReference CreateGeographicSpatialReference()
{
ISpatialReferenceFactory spatialRefFatcory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem geoCoordSys;
geoCoordSys = spatialRefFatcory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
//assign a user defined datum to the SR (just for the test)
IDatum datum = new DatumClass();
IDatumEdit datumEdit = (IDatumEdit)datum;
ISpheroid spheroid = spatialRefFatcory.CreateSpheroid((int)esriSRSpheroidType.esriSRSpheroid_Clarke1880);
datumEdit.DefineEx("MyDatum", "My Datum", "MDTM", "", spheroid);
IPrimeMeridian primeMeridian = spatialRefFatcory.CreatePrimeMeridian((int)esriSRPrimeMType.esriSRPrimeM_Greenwich);
IAngularUnit angularUnits = spatialRefFatcory.CreateUnit((int)esriSRUnitType.esriSRUnit_Degree) as IAngularUnit;
IGeographicCoordinateSystemEdit geoCoordSysEdit = (IGeographicCoordinateSystemEdit)geoCoordSys;
geoCoordSysEdit.DefineEx("MyGeoCoordSys", "MyGeoCoordSys", "MGCS", "", "", datum, primeMeridian, angularUnits);
geoCoordSys.SetFalseOriginAndUnits(-180.0, -180.0, 5000000.0);
geoCoordSys.SetZFalseOriginAndUnits(0.0, 100000.0);
geoCoordSys.SetMFalseOriginAndUnits(0.0, 100000.0);
return(geoCoordSys as ISpatialReference);
}
/// <summary>
/// 创建地理坐标系
/// </summary>
/// <param name="gcsType"></param>
/// <returns></returns>
static public ISpatialReference CreateGeographicCoordinateSystem(int gcsType)
{
SpatialReferenceEnvironmentClass sfe = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem gcs = sfe.CreateGeographicCoordinateSystem(gcsType);
return(gcs);
}
public static IPoint PRJtoGCS(IPoint point)
{
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
point.Project(spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCS3Type.esriSRGeoCS_Xian1980));
return(point);
}
public static ISpatialReference CreateGeographicCoordinate(esriSRProjCS4Type gcsType)
{
ISpatialReferenceFactory pSpatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference pSpatialReference = pSpatialReferenceFactory.CreateGeographicCoordinateSystem((int)gcsType);
return(pSpatialReference);
}
public MvtSubLayer(IApplication application, string url)
{
LayerWeight = 100;
_application = application;
layerNames = new HashSet <string>();
if (!url.Contains("mapzen"))
{
_tileSource = new MapBoxVectorTileSource(url);
}
else
{
_tileSource = new MapBoxVectorTileSource(url, "mvt");
}
var srf = new SpatialReferenceEnvironmentClass();
var sr = srf.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
SpatialReference = sr;
var mxdoc = (IMxDocument)_application.Document;
var map = mxdoc.FocusMap;
if (map.SpatialReference == null)
{
map.SpatialReference = sr;
}
}
public void Startup(ref object initializationData)
{
try
{
m_application = initializationData as IApplication;
if (m_application == null)
{
return;
}
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
m_wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
//Get the editor.
UID editorUid = new UID();
editorUid.Value = "esriEditor.Editor";
m_editor3 = m_application.FindExtensionByCLSID(editorUid) as IEditor3;
m_editEvents2 = m_editor3 as IEditEvents2_Event;
m_editEvents = m_editor3 as IEditEvents_Event;
m_editEvents.OnCreateFeature += new IEditEvents_OnCreateFeatureEventHandler(m_editEvents_OnCreateFeature);
m_editEvents.OnChangeFeature += new IEditEvents_OnChangeFeatureEventHandler(m_editEvents_OnChangeFeature);
m_editEvents.OnDeleteFeature += new IEditEvents_OnDeleteFeatureEventHandler(m_editEvents_OnDeleteFeature);
m_editEvents.OnStartEditing += new IEditEvents_OnStartEditingEventHandler(m_editEvents_OnStartEditing);
resourceManager = new ResourceManager("ESRI.ArcGIS.OSM.Editor.OSMFeatureInspectorStrings", this.GetType().Assembly);
_osmUtility = new OSMClassExtension.OSMUtility();
// retrtrieve osm editor specfic information
m_editorConfigurationSettings = OSMGPFactory.ReadOSMEditorSettings();
}
catch { }
}
public IPoint ConvertToWgsMeters(IPoint wgsInputPoint)
{
var spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference wgsMetersSpatialReference = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
wgsInputPoint.Project(wgsMetersSpatialReference);
return(wgsInputPoint);
}
protected ISpatialReference GetGeographicSpatialReference(int gcsType)
{
var pSrf = new SpatialReferenceEnvironmentClass();
var geographicCoordinateSystem = pSrf.CreateGeographicCoordinateSystem(gcsType);
var spatialReference = (ISpatialReference)geographicCoordinateSystem;
return(spatialReference);
}
/// <summary>
///
/// </summary>
/// <param name="projectionCode">projectionCode (aka: WKID)</param>
/// <returns></returns>
public static ISpatialReference CreateGeographicSpatialReference(int projectionCode)
{
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem gcs = spatialReferenceFactory.CreateGeographicCoordinateSystem(projectionCode);
ISpatialReference sr = gcs;
return(sr);
}
private ISpatialReference CreateGeoCoordSys()
{
ISpatialReferenceFactory2 spatialRefFactory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem wgs84GeoCoordSys = spatialRefFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
return((ISpatialReference)wgs84GeoCoordSys);
}
/// <summary>
/// 经纬度转投影坐标
/// </summary>
/// <param name="pPoint"></param>
/// <param name="GCSType"></param>
/// <param name="PRJType"></param>
/// <returns></returns>
private static IPoint GCStoPRJ(IPoint pPoint, int GCSType, int PRJType)
{
ISpatialReferenceFactory pSRF = new SpatialReferenceEnvironmentClass();
pPoint.SpatialReference = pSRF.CreateGeographicCoordinateSystem(GCSType);
pPoint.Project(pSRF.CreateProjectedCoordinateSystem(PRJType));
return(pPoint);
}
// this method is called when the tool is active and the user clicks down on the mouse - it captures the x,y coords and then reprojects them to wgs and opens a browser with streetview
public override void OnMouseDown(int Button, int Shift, int X, int Y)
{
try
{
//show busy mouse
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
//get access to the document (the current mxd), and the active view (data view or layout view), and the focus map (the data frame with focus, aka: the visible map)
IMxDocument pMxDocument = clsGlobals.arcApplication.Document as IMxDocument;
IActiveView pActiveView = pMxDocument.ActiveView;
IMap pMap = pActiveView.FocusMap;
//IScreenDisplay screenDisplay = pActiveView.ScreenDisplay;
//IDisplayTransformation displayTransformation = screenDisplay.DisplayTransformation;
//displayTransformation.ToMapPoint((System.Int32)X, (System.Int32)Y);
IEnvelope pEnvelope = pActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y).Envelope;
//the following lines of code are needed to reproject the map units into google maps lat long
//Create Spatial Reference Factory
ISpatialReferenceFactory srFactory = new SpatialReferenceEnvironmentClass();
IProjectedCoordinateSystem arcProjCoordSysUTM12_North = srFactory.CreateProjectedCoordinateSystem(26912);
IGeographicCoordinateSystem arcGeographicCoordSysWgs84 = srFactory.CreateGeographicCoordinateSystem(4326);//esriSRGeoCS_WGS1984 4326 WGS 1984.
//get the point on the map that was clicked on
IPoint pMapPoint = new ESRI.ArcGIS.Geometry.Point();
pMapPoint.X = Convert.ToDouble(pEnvelope.XMax);
pMapPoint.Y = Convert.ToDouble(pEnvelope.YMax);
//give the arcmap point a spatial reference
pMapPoint.SpatialReference = arcProjCoordSysUTM12_North;
//reproject that point to nad83 arizona central state plane
pMapPoint.Project(arcGeographicCoordSysWgs84);
//MessageBox.Show(pMapPoint.X + ", " + pMapPoint.Y, "caption", MessageBoxButtons.OK, MessageBoxIcon.Information);
//open the default internet browser and pass in the apn number to the assessor's gis website, and then zoom to the apn
System.Diagnostics.Process.Start("https://maps.google.com/maps?q=&layer=c&cbll=" + pMapPoint.Y + "," + pMapPoint.X + "&cbp=12,0,0,0,0");
//deactivate the tool
//this.m_deactivate = true;
//this.Deactivate();
//base.Deactivate();
//this.Deactivate();
}
catch (Exception ex)
{
MessageBox.Show("Error Message: " + Environment.NewLine + ex.Message + Environment.NewLine + Environment.NewLine +
"Error Source: " + Environment.NewLine + ex.Source + Environment.NewLine + Environment.NewLine +
"Error Location:" + Environment.NewLine + ex.StackTrace,
"UTRANS Editor tool error!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
/// <summary>
/// 坐标系转换-----投影坐标系转WGS84
/// </summary>
/// <param name="x">x坐标</param>
/// <param name="y">y坐标</param>
/// <returns>转换后的IPoint</returns>
public static IPoint getGeoPoint(double x, double y)
{
IPoint pProjPoint = new PointClass();
pProjPoint.PutCoords(x, y);
ISpatialReferenceFactory pSRF = new SpatialReferenceEnvironmentClass();
pProjPoint.SpatialReference = pSRF.CreateProjectedCoordinateSystem((int)(esriSRProjCSType.esriSRProjCS_WGS1984UTM_31N));
pProjPoint.Project(pSRF.CreateGeographicCoordinateSystem((int)(esriSRGeoCSType.esriSRGeoCS_WGS1984)));
return pProjPoint; //此时为经纬度点
}
public void Test()
{
//定义一个几何字段，类型为点类型
ISpatialReferenceFactory2 originalSpatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference originalSpatialReference = originalSpatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
IGeometryDefEdit pGeoDef = new GeometryDefClass();
IGeometryDefEdit pGeoDefEdit = pGeoDef as IGeometryDefEdit;
pGeoDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pGeoDefEdit.SpatialReference_2 = originalSpatialReference;
//定义一个字段集合对象
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
//定义shape字段
IField pField = new FieldClass();
IFieldEdit pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFieldsEdit.AddField(pField);
pFieldEdit.GeometryDef_2 = pGeoDef;
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "STCD";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SLM10";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SLM20";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SLM40";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactory();
IFeatureWorkspace pFWS = pWorkspaceFactory.OpenFromFile(workspaceDirectory, 0) as IFeatureWorkspace;
IFeatureClass pFtClass = pFWS.CreateFeatureClass("Test", pFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", null);
}
public static IGeometry ConvertProjToGeo(IGeometry geometry)
{
ISpatialReferenceFactory2 originalSpatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference originalSpatialReference = originalSpatialReferenceFactory.CreateProjectedCoordinateSystem((int)esriSRProjCSType.esriSRProjCS_WGS1984UTM_49N);
ISpatialReferenceFactory2 currentSpatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference currentSpatialReference = currentSpatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
return(GeometryUtilities.ConvertCS(geometry, originalSpatialReference, currentSpatialReference));
}
public OSMGPExport2OSM()
{
resourceManager = new ResourceManager("ESRI.ArcGIS.OSM.GeoProcessing.OSMGPToolsStrings", this.GetType().Assembly);
osmGPFactory = new OSMGPFactory();
_osmUtility = new OSMUtility();
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
m_wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
}
public OSMGPExport2OSM()
{
resourceManager = new ResourceManager("ESRI.ArcGIS.OSM.GeoProcessing.OSMGPToolsStrings", this.GetType().Assembly);
osmGPFactory = new OSMGPFactory();
_osmUtility = new OSMUtility();
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
m_wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
}
/// <summary>
/// Creates a WGS84 Spatial Reference
/// </summary>
/// <returns>ISpatialReference WGS84</returns>
public static ISpatialReference WGS84SpatialReference()
{
SpatialReferenceEnvironment spatialReferenceEnv = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem geoCS = spatialReferenceEnv.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
ISpatialReference spatialReference = geoCS;
spatialReference.SetFalseOriginAndUnits(-180, -90, 1000000);
return(spatialReference);
}
private static ISpatialReference CreateSpatialReference(esriSRGeoCSType coordinateSystem)
{
ISpatialReferenceFactory sRefFactory = new SpatialReferenceEnvironmentClass();
ISpatialReferenceResolution sRefResolution =
sRefFactory.CreateGeographicCoordinateSystem(Convert.ToInt32(coordinateSystem)) as
ISpatialReferenceResolution;
sRefResolution.ConstructFromHorizon();
((ISpatialReferenceTolerance) sRefResolution).SetDefaultXYTolerance();
return sRefResolution as ISpatialReference;
}
private ISpatialReference DefineGCS()
{
ISpatialReferenceFactory srFactory = new SpatialReferenceEnvironmentClass();
//ISpatialReference gcs = srFactory.CreateGeographicCoordinateSystem(wkid);
//ISpatialReference gcs = srFactory.CreateProjectedCoordinateSystem((int)esriSRProjCSType.esriSRProjCS_NAD1983N_AmericaAlbers);
ISpatialReference gcs = srFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_NAD1983);
// wkid = 4269 (GCS_NAD_1983)
// wkid = 102008 (North American Albers Equal Area Conic)
return gcs;
}
private static bool IsGeographicSpatialReference(int gcsType)
{
try
{
var pSrf = new SpatialReferenceEnvironmentClass();
var geographicCoordinateSystem = pSrf.CreateGeographicCoordinateSystem(gcsType);
// ReSharper disable once UnusedVariable
var spatialReference = (ISpatialReference)geographicCoordinateSystem;
return true;
}
catch
{
return false;
}
}
public static IFeatureClass CreateFeatureClass(fulcrumform form, string pathToGeoDB)
{
try
{
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem geographicCoordinateSystem = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
ISpatialReference sr = geographicCoordinateSystem;
IWorkspaceFactory2 wsf = new FileGDBWorkspaceFactoryClass();
IWorkspace2 workspace = (IWorkspace2)wsf.OpenFromFile(pathToGeoDB, 0);
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
string fcName = GetUniqueFeatureClassName(form.name, workspace);
IFields fieldsCollection = new FieldsClass();
IFieldEdit newField = fieldsCollection as IFieldEdit;
IFeatureClassDescription fcDesc = new ESRI.ArcGIS.Geodatabase.FeatureClassDescriptionClass();
IObjectClassDescription ocDesc = (IObjectClassDescription)fcDesc;
// create required fields using the required fields method
IFields fields = ocDesc.RequiredFields;
//Grab the GeometryDef from the shape field, edit it and give it back
int shapeFieldIndex = fields.FindField(fcDesc.ShapeFieldName);
IField shapeField = fields.get_Field(shapeFieldIndex);
IGeometryDef geomDef = shapeField.GeometryDef;
IGeometryDefEdit geomDefEdit = (IGeometryDefEdit)geomDef;
geomDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
geomDefEdit.GridCount_2 = 1;
geomDefEdit.set_GridSize(0, 0);
geomDefEdit.SpatialReference_2 = sr;
IFields newFields = CreateNewFields(form, fields, sr);
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass
(fcName, newFields, ocDesc.InstanceCLSID, ocDesc.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDesc.ShapeFieldName, "");
return featureClass;
}
catch (Exception e)
{
string errMsg = e.Message;
return null;
}
}
private IPoint PRJtoGCS(double x, double y)
{
IPoint pPoint = new PointClass();
pPoint.PutCoords(x, y);
ISpatialReferenceFactory pSRF = new SpatialReferenceEnvironmentClass();
pPoint.SpatialReference = pSRF.CreateProjectedCoordinateSystem(4269);
pPoint.Project(pSRF.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_NAD1983));
return pPoint;
}
private List<TileInfo> GetTile()
{
var schema = _tileSource.Schema;
IEnvelope pEnvelope = new EnvelopeClass();
ISpatialReferenceFactory pSpatRefFact = new SpatialReferenceEnvironmentClass();
pEnvelope.SpatialReference = pSpatRefFact.CreateGeographicCoordinateSystem(4326);
pEnvelope.XMin = extent[0];
pEnvelope.XMax = extent[2];
pEnvelope.YMin = extent[1];
pEnvelope.YMax = extent[3];
var env = Projector.ProjectEnvelope(pEnvelope, schema.Srs);
var mapWidth = 256 * num;
var mapHeight = 256 * num;
float resolution = (float)level;
var centerPoint = env.GetCenterPoint();
var transform = new Transform(centerPoint, resolution, mapWidth, mapHeight);
Extent exte = new Extent(pEnvelope.XMin, pEnvelope.YMin, pEnvelope.XMax, pEnvelope.YMax);
var level1 = Utilities.GetNearestLevel(schema.Resolutions, transform.Resolution);
var tempExtent = new Extent(12597408.0986328, 2623556.09863281, 12629205.9013672, 2655353.90136719);
var tiles = schema.GetTilesInView(tempExtent, 10);
return tiles.ToList();
}
/// 将经纬度点转换为平面坐标。
private IPoint GetProject2(double x, double y)
{
ISpatialReferenceFactory pfactory = new SpatialReferenceEnvironmentClass();
IProjectedCoordinateSystem flatref = pfactory.CreateProjectedCoordinateSystem(102003);
IGeographicCoordinateSystem earthref = pfactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_NAD1983);
IPoint pt = new PointClass();
pt.PutCoords(x, y);
IGeometry geo = (IGeometry)pt;
geo.SpatialReference = earthref;
geo.Project(flatref);
return pt;
}
public static IPoint XY2JWD(double x, double y, int gcsType, int pcsType)
{
try
{
IPoint point = new PointClass();
point.PutCoords(x, y);
ISpatialReferenceFactory factory = new SpatialReferenceEnvironmentClass();
point.SpatialReference = factory.CreateProjectedCoordinateSystem(pcsType);
point.Project(factory.CreateGeographicCoordinateSystem(gcsType));
return point;
}
catch
{
return null;
}
}
private void CreatePoint(double x, double y)
{
IPoint pPoint = new PointClass();
IMap pMap = axMapControl.Map;
IActiveView pActiveView = pMap as IActiveView;
IGraphicsContainer pGraphicsContainer;
IElement pElement = new MarkerElementClass();
pGraphicsContainer = (IGraphicsContainer)pActiveView;
IFormattedTextSymbol pTextSymbol = new TextSymbolClass();
IBalloonCallout pBalloonCallout = CreateBalloonCallout(x, y);
IRgbColor pColor = new RgbColorClass();
pColor.Red = 150;
pColor.Green = 0;
pColor.Blue = 0;
pTextSymbol.Color = pColor;
ITextBackground pTextBackground;
pTextBackground = (ITextBackground)pBalloonCallout;
//pTextSymbol.Background = pTextBackground;
//((ITextElement)pElement).Symbol = pTextSymbol;
//((ITextElement)pElement).Text = "测试";
pPoint.X = x + 42;
pPoint.Y = y + 42;
pPoint.PutCoords(x, y);
ISpatialReferenceFactory pSRF = new SpatialReferenceEnvironmentClass();
pPoint.SpatialReference = pSRF.CreateProjectedCoordinateSystem(2414);
pPoint.Project(pSRF.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_Beijing1954));
pElement.Geometry = pPoint;
pGraphicsContainer.AddElement(pElement, 1);
pActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, null);
}
/// <summary>
/// Get current view extent (in geographical coordinate system).
/// </summary>
/// <remarks>
/// If error occurred, exception would be thrown.
/// </remarks>
/// <returns>view extent as an envelope object</returns>
private esri.gpt.csw.Envelope CurrentMapViewExtent()
{
esri.gpt.csw.Envelope envCurrentViewExent;
IMxDocument mxDoc = (IMxDocument)m_application.Document;
IMap map = mxDoc.FocusMap;
IActiveView activeView = (IActiveView)map;
IEnvelope extent = activeView.Extent;
if (extent == null) return null;
ISpatialReference CurrentMapSpatialReference = extent.SpatialReference;
if (CurrentMapSpatialReference == null) throw new Exception(StringResources.SpatialReferenceNotDefined);
if (CurrentMapSpatialReference is IUnknownCoordinateSystem)
{
// unknown cooridnate system
throw new Exception(StringResources.UnknownCoordinateSystem);
}
else if (CurrentMapSpatialReference is IGeographicCoordinateSystem)
{
// already in geographical coordinate system, reuse coordinate values
envCurrentViewExent = new esri.gpt.csw.Envelope(extent.XMin, extent.YMin, extent.XMax, extent.YMax);
}
else if (CurrentMapSpatialReference is IProjectedCoordinateSystem)
{
// project to geographical coordinate system
ISpatialReferenceFactory srFactory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem gcs = srFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_NAD1983);
gcs.SetFalseOriginAndUnits(-180, -90, 1000000);
extent.Project(gcs);
envCurrentViewExent = new esri.gpt.csw.Envelope(extent.XMin, extent.YMin, extent.XMax, extent.YMax);
}
else
{
ShowErrorMessageBox(StringResources.UnsupportedCoordinateSystem);
envCurrentViewExent = null;
}
return envCurrentViewExent;
}
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;
// classes to carry out the basic client/server communication
HttpWebResponse httpResponse = null;
string changeSetID = "-1";
IGPString baseURLGPString = new GPStringClass();
ICursor searchCursor = null;
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPParameter userNameParameter = paramvalues.get_Element(in_userNameNumber) as IGPParameter;
IGPString userNameGPValue = gpUtilities3.UnpackGPValue(userNameParameter) as IGPString;
IHttpBasicGPValue userCredentialGPValue = new HttpBasicGPValue();
if (userNameGPValue != null)
{
userCredentialGPValue.UserName = userNameGPValue.Value;
}
else
{
return;
}
IGPParameter passwordParameter = paramvalues.get_Element(in_passwordNumber) as IGPParameter;
IGPStringHidden passwordGPValue = gpUtilities3.UnpackGPValue(passwordParameter) as IGPStringHidden;
if (passwordGPValue != null)
{
userCredentialGPValue.PassWord = passwordGPValue.Value;
}
else
{
return;
}
ITable revisionTable = null;
int secondsToTimeout = 10;
try
{
UpdateMessages(paramvalues, envMgr, message);
if ((message.MaxSeverity == esriGPMessageSeverity.esriGPMessageSeverityAbort) ||
(message.MaxSeverity == esriGPMessageSeverity.esriGPMessageSeverityError))
{
message.AddMessages(message);
return;
}
IGPParameter baseURLParameter = paramvalues.get_Element(in_uploadURLNumber) as IGPParameter;
baseURLGPString = gpUtilities3.UnpackGPValue(baseURLParameter) as IGPString;
IGPParameter commentParameter = paramvalues.get_Element(in_uploadCommentNumber) as IGPParameter;
IGPString uploadCommentGPString = gpUtilities3.UnpackGPValue(commentParameter) as IGPString;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
m_wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
System.Xml.Serialization.XmlSerializer serializer = null;
serializer = new XmlSerializer(typeof(osm));
osm createChangeSetOSM = new osm();
string user_displayname = "";
int userID = -1;
// set the "default" value of the OSM server
int maxElementsinChangeSet = 50000;
HttpWebRequest httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/capabilities") as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
httpClient.Timeout = secondsToTimeout * 1000;
createChangeSetOSM.generator = m_Generator;
createChangeSetOSM.version = "0.6";
changeset createChangeSet = new changeset();
createChangeSet.id = "0";
createChangeSet.open = changesetOpen.@false;
List<tag> changeSetTags = new List<tag>();
tag createdByTag = new tag();
createdByTag.k = "created_by";
createdByTag.v = "ArcGIS Editor for OpenStreetMap";
changeSetTags.Add(createdByTag);
tag commentTag = new tag();
commentTag.k = "comment";
commentTag.v = uploadCommentGPString.Value;
changeSetTags.Add(commentTag);
createChangeSet.tag = changeSetTags.ToArray();
createChangeSetOSM.Items = new object[] { createChangeSet };
api apiCapabilities = null;
// retrieve some server settings
try
{
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;
httpResponse.Close();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
message.AddWarning(ex.Message);
}
if (apiCapabilities != null)
{
// read the timeout parameter
secondsToTimeout = Convert.ToInt32(apiCapabilities.timeout.seconds);
httpClient.Timeout = secondsToTimeout * 1000;
// update the setting of allowed features per changeset from the actual capabilities response
maxElementsinChangeSet = Convert.ToInt32(apiCapabilities.changesets.maximum_elements);
}
// retrieve some information about the user
try
{
httpClient = null;
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/user/details") as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
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();
user userInformation = osmCapabilities.Items[0] as user;
if (userInformation != null)
{
user_displayname = userInformation.display_name;
userID = Convert.ToInt32(userInformation.id);
}
}
catch (ArgumentOutOfRangeException ex)
{
message.AddError(120044, ex.Message);
return;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
message.AddWarning(ex.Message);
}
IGPParameter revisionTableParameter = paramvalues.get_Element(in_changesTablesNumber) as IGPParameter;
int featureUpdateCounter = 0;
IQueryFilter revisionTableQueryFilter = null;
try
{
gpUtilities3.DecodeTableView(gpUtilities3.UnpackGPValue(revisionTableParameter), out revisionTable, out revisionTableQueryFilter);
}
catch
{
message.AddError(120045,resourceManager.GetString("GPTools_OSMGPUpload_missingRevisionTable"));
return;
}
int revChangeSetIDFieldIndex = revisionTable.Fields.FindField("osmchangeset");
int revActionFieldIndex = revisionTable.Fields.FindField("osmaction");
int revElementTypeFieldIndex = revisionTable.Fields.FindField("osmelementtype");
int revVersionFieldIndex = revisionTable.Fields.FindField("osmversion");
int revFCNameFieldIndex = revisionTable.Fields.FindField("sourcefcname");
int revOldIDFieldIndex = revisionTable.Fields.FindField("osmoldid");
int revNewIDFieldIndex = revisionTable.Fields.FindField("osmnewid");
int revStatusFieldIndex = revisionTable.Fields.FindField("osmstatus");
int revStatusCodeFieldIndex = revisionTable.Fields.FindField("osmstatuscode");
int revErrorMessageFieldIndex = revisionTable.Fields.FindField("osmerrormessage");
int revLongitudeFieldIndex = revisionTable.Fields.FindField("osmlon");
int revLatitudeFieldIndex = revisionTable.Fields.FindField("osmlat");
// let's find all the rows that have a different status than OK - meaning success
IQueryFilter queryFilter = new QueryFilterClass();
searchCursor = revisionTable.Search(queryFilter, false);
IRow searchRowToUpdate = null;
// lookup table to adjust all osm ID references if there are know entities
Dictionary<long, long> nodeosmIDLookup = new Dictionary<long, long>();
Dictionary<long, long> wayosmIDLookup = new Dictionary<long, long>();
Dictionary<long, long> relationosmIDLookup = new Dictionary<long, long>();
// let's pre-populate the lookup IDs with already know entities
// it is necessary if the revision table is used more than once and in different sessions
queryFilter.WhereClause = "NOT " + revisionTable.SqlIdentifier("osmnewid") + " IS NULL";
using (ComReleaser comReleaser = new ComReleaser())
{
ICursor searchIDCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchIDCursor);
IRow searchRow = searchIDCursor.NextRow();
comReleaser.ManageLifetime(searchRow);
while (searchRow != null)
{
if (revOldIDFieldIndex > -1 && revNewIDFieldIndex > -1)
{
string elementType = Convert.ToString(searchRow.get_Value(revElementTypeFieldIndex));
switch (elementType)
{
case "node":
if (nodeosmIDLookup.ContainsKey(Convert.ToInt64(searchRow.get_Value(revOldIDFieldIndex))) == false)
{
nodeosmIDLookup.Add(Convert.ToInt64(searchRow.get_Value(revOldIDFieldIndex)), Convert.ToInt64(searchRow.get_Value(revNewIDFieldIndex)));
}
break;
case "way":
if (wayosmIDLookup.ContainsKey(Convert.ToInt64(searchRow.get_Value(revOldIDFieldIndex))) == false)
{
wayosmIDLookup.Add(Convert.ToInt64(searchRow.get_Value(revOldIDFieldIndex)), Convert.ToInt64(searchRow.get_Value(revNewIDFieldIndex)));
}
break;
case "relation":
if (relationosmIDLookup.ContainsKey(Convert.ToInt64(searchRow.get_Value(revOldIDFieldIndex))) == false)
{
relationosmIDLookup.Add(Convert.ToInt64(searchRow.get_Value(revOldIDFieldIndex)), Convert.ToInt64(searchRow.get_Value(revNewIDFieldIndex)));
}
break;
default:
break;
}
}
searchRow = searchIDCursor.NextRow();
}
}
IFeatureClass pointFeatureClass = null;
int pointOSMIDFieldIndex = -1;
IFeatureClass lineFeatureClass = null;
IFeatureClass polygonFeatureClass = null;
ITable relationTable = null;
int osmDelimiterPosition = ((IDataset)revisionTable).Name.IndexOf("_osm_");
string osmBaseName = ((IDataset)revisionTable).Name.Substring(0, osmDelimiterPosition);
IFeatureWorkspace osmFeatureWorkspace = ((IDataset)revisionTable).Workspace as IFeatureWorkspace;
if (osmFeatureWorkspace != null)
{
pointFeatureClass = osmFeatureWorkspace.OpenFeatureClass(osmBaseName + "_osm_pt");
pointOSMIDFieldIndex = pointFeatureClass.FindField("OSMID");
lineFeatureClass = osmFeatureWorkspace.OpenFeatureClass(osmBaseName + "_osm_ln");
polygonFeatureClass = osmFeatureWorkspace.OpenFeatureClass(osmBaseName + "_osm_ply");
relationTable = osmFeatureWorkspace.OpenTable(osmBaseName + "_osm_relation");
}
// determine version of extension
int internalExtensionVersion = pointFeatureClass.OSMExtensionVersion();
string sData = OsmRest.SerializeUtils.CreateXmlSerializable(createChangeSetOSM, serializer, Encoding.ASCII, "text/xml");
HttpWebRequest httpClient2 = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/changeset/create") as HttpWebRequest;
httpClient2.Method = "PUT";
httpClient2 = OSMGPDownload.AssignProxyandCredentials(httpClient2);
SetBasicAuthHeader(httpClient2, userCredentialGPValue.EncodedUserNamePassWord);
httpClient2.Timeout = secondsToTimeout * 1000;
try
{
Stream requestStream = httpClient2.GetRequestStream();
StreamWriter mywriter = new StreamWriter(requestStream);
mywriter.Write(sData);
mywriter.Close();
WebResponse clientResponse = httpClient2.GetResponse();
Stream readStream = clientResponse.GetResponseStream();
StreamReader streamReader = new StreamReader(readStream);
changeSetID = streamReader.ReadToEnd();
streamReader.Close();
message.AddMessage(String.Format(resourceManager.GetString("GPTools_OSMGPUpload_openChangeSet"), changeSetID));
}
catch (Exception ex)
{
if (httpResponse != null)
{
if (httpResponse.StatusCode != System.Net.HttpStatusCode.OK)
{
foreach (var errorItem in httpResponse.Headers.GetValues("Error"))
{
message.AddError(120009, errorItem);
}
message.AddError(120009, httpResponse.StatusCode.ToString());
message.AddError(120009, ex.Message);
}
}
else
{
message.AddError(120047, ex.Message);
}
return;
}
IGPParameter uploadFormatParameter = paramvalues.get_Element(in_uploadFormatNumber) as IGPParameter;
IGPBoolean useOSMChangeFormatGPValue = gpUtilities3.UnpackGPValue(uploadFormatParameter) as IGPBoolean;
// Al Hack
if (useOSMChangeFormatGPValue == null)
{
useOSMChangeFormatGPValue = new GPBoolean();
useOSMChangeFormatGPValue.Value = false;
}
SQLFormatter sqlFormatter = new SQLFormatter(revisionTable);
if (useOSMChangeFormatGPValue.Value == true)
{
#region osmchange upload format
osmChange osmChangeDocument = new osmChange();
osmChangeDocument.generator = m_Generator;
osmChangeDocument.version = "0.6";
// xml elements to describe the changeset
create uploadCreates = null;
modify uploadModify = null;
delete uploadDelete = null;
// helper classes to keep track of elements entered into a changeset
List<object> listOfCreates = null;
List<object> listOfModifies = null;
List<object> listOfDeletes = null;
List<object> changeSetItems = new List<object>();
#region upload create actions
// loop through creates
queryFilter.WhereClause = "(" + sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'create'";
using (ComReleaser comReleaser = new ComReleaser())
{
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
searchRowToUpdate = searchCursor.NextRow();
comReleaser.ManageLifetime(searchRowToUpdate);
// if we have at least one entry with a create action, then add the 'create' element to the changeset representation
if (searchRowToUpdate != null)
{
uploadCreates = new create();
listOfCreates = new List<object>();
}
while (searchRowToUpdate != null)
{
try
{
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
string action = String.Empty;
if (revActionFieldIndex != -1)
{
action = searchRowToUpdate.get_Value(revActionFieldIndex) as string;
}
string elementType = String.Empty;
if (revElementTypeFieldIndex != -1)
{
elementType = searchRowToUpdate.get_Value(revElementTypeFieldIndex) as string;
}
string sourceFCName = String.Empty;
if (revFCNameFieldIndex != -1)
{
sourceFCName = searchRowToUpdate.get_Value(revFCNameFieldIndex) as string;
}
long osmOldID = -1;
if (revOldIDFieldIndex != -1)
{
osmOldID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if (featureUpdateCounter > 0 & (featureUpdateCounter % maxElementsinChangeSet) == 0)
{
// add any outstanding creations to the changeset items
if (listOfCreates != null && uploadCreates != null)
{
uploadCreates.Items = listOfCreates.ToArray();
// in case there are any creates let's add them to the changeset document
changeSetItems.Add(uploadCreates);
}
// add all the changeset items to the changeset document
osmChangeDocument.Items = changeSetItems.ToArray();
// submit changeset
try
{
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/changeset/" + changeSetID + "/upload") as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
httpClient.Method = "POST";
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
httpClient.Timeout = secondsToTimeout * 1000;
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(osmChangeDocument, null, Encoding.UTF8, "text/xml");
message.AddMessage(String.Format(resourceManager.GetString("GPTools_OSMGPUpload_featureSubmit"), featureUpdateCounter));
OsmRest.HttpUtils.Post(httpClient, sContent);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
diffResult diffResultResonse = OsmRest.HttpUtils.GetResponse(httpResponse);
// parse changes locally and update local data sources
if (diffResultResonse != null)
{
ParseResultDiff(diffResultResonse, revisionTable, pointFeatureClass, lineFeatureClass, polygonFeatureClass, relationTable, user_displayname, userID, changeSetID, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
}
catch (Exception ex)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
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);
}
}
if (httpResponse != null)
{
httpResponse.Close();
}
return;
}
finally
{
// reset the list and containers of modifications for the next batch
listOfCreates.Clear();
changeSetItems.Clear();
if (httpResponse != null)
{
httpResponse.Close();
}
}
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
switch (elementType)
{
case "node":
node createNode = CreateNodeRepresentation(pointFeatureClass, action, osmOldID, changeSetID, 1, null, internalExtensionVersion);
listOfCreates.Add(createNode);
break;
case "way":
way createWay = null;
if (sourceFCName.Contains("_osm_ln"))
{
createWay = CreateWayRepresentation(lineFeatureClass, action, osmOldID, changeSetID, 1, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
createWay = CreateWayRepresentation(polygonFeatureClass, action, osmOldID, changeSetID, 1, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
listOfCreates.Add(createWay);
break;
case "relation":
relation createRelation = null;
if (sourceFCName.Contains("_osm_ln"))
{
createRelation = CreateRelationRepresentation((ITable)lineFeatureClass, action, osmOldID, changeSetID, 1, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
createRelation = CreateRelationRepresentation((ITable)polygonFeatureClass, action, osmOldID, changeSetID, 1, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_relation"))
{
createRelation = CreateRelationRepresentation(relationTable, action, osmOldID, changeSetID, 1, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
listOfCreates.Add(createRelation);
break;
default:
break;
}
// increment the counter keeping track of the submitted changes
featureUpdateCounter = featureUpdateCounter + 1;
}
catch
{
}
searchRowToUpdate = searchCursor.NextRow();
}
if (listOfCreates != null && uploadCreates != null)
{
// sort the list of created elements in the order of nodes, ways, relations
listOfCreates.Sort(new OSMElementComparer());
uploadCreates.Items = listOfCreates.ToArray();
// in case there are any creates let's add them to the changeset document
changeSetItems.Add(uploadCreates);
}
}
#endregion
#region upload modify actions
// loop through modifies
using (ComReleaser comReleaser = new ComReleaser())
{
queryFilter.WhereClause = "(" +
sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'modify'";
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
searchRowToUpdate = searchCursor.NextRow();
if (searchRowToUpdate != null)
{
uploadModify = new modify();
listOfModifies = new List<object>();
}
while (searchRowToUpdate != null)
{
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
try
{
string action = String.Empty;
if (revActionFieldIndex != -1)
{
action = searchRowToUpdate.get_Value(revActionFieldIndex) as string;
}
string elementType = String.Empty;
if (revElementTypeFieldIndex != -1)
{
elementType = searchRowToUpdate.get_Value(revElementTypeFieldIndex) as string;
}
string sourceFCName = String.Empty;
if (revFCNameFieldIndex != -1)
{
sourceFCName = searchRowToUpdate.get_Value(revFCNameFieldIndex) as string;
}
long osmOldID = -1;
if (revOldIDFieldIndex != -1)
{
osmOldID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
long modifyID = -1;
if (revNewIDFieldIndex != -1)
{
object osmIDValue = searchRowToUpdate.get_Value(revNewIDFieldIndex);
if (osmIDValue == DBNull.Value)
{
osmIDValue = osmOldID;
}
try
{
modifyID = Convert.ToInt64(osmIDValue);
}
catch { }
// modifies should only happen to osm IDs > 0
// if that condition is not met let's skip this feature as something is not right
if (modifyID < 0)
{
searchRowToUpdate = searchCursor.NextRow();
continue;
}
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
// add any outstanding modifications to the changeset items
if (listOfModifies != null && uploadModify != null)
{
uploadModify.Items = listOfModifies.ToArray();
// in case there are any creates let's add them to the changeset document
changeSetItems.Add(uploadModify);
}
// add all the changeset items to the changeset document
osmChangeDocument.Items = changeSetItems.ToArray();
// submit changeset
try
{
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/changeset/" + changeSetID + "/upload") as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
httpClient.Method = "POST";
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
httpClient.Timeout = secondsToTimeout * 1000;
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(osmChangeDocument, null, Encoding.UTF8, "text/xml");
OsmRest.HttpUtils.Post(httpClient, sContent);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
diffResult diffResultResonse = OsmRest.HttpUtils.GetResponse(httpResponse);
// parse changes locally and update local data sources
if (diffResultResonse != null)
{
ParseResultDiff(diffResultResonse, revisionTable, pointFeatureClass, lineFeatureClass, polygonFeatureClass, relationTable, user_displayname, userID, changeSetID, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
}
catch (Exception ex)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
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);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
return;
}
finally
{
// reset the list and containers of modifications for the next batch
listOfModifies.Clear();
changeSetItems.Clear();
if (httpResponse != null)
{
httpResponse.Close();
}
}
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
switch (elementType)
{
case "node":
node updateNode = CreateNodeRepresentation(pointFeatureClass, action, modifyID, changeSetID, osmVersion, null, internalExtensionVersion);
listOfModifies.Add(updateNode);
break;
case "way":
way updateWay = null;
if (sourceFCName.Contains("_osm_ln"))
{
updateWay = CreateWayRepresentation(lineFeatureClass, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
updateWay = CreateWayRepresentation(polygonFeatureClass, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
listOfModifies.Add(updateWay);
break;
case "relation":
relation updateRelation = null;
if (sourceFCName.Contains("_osm_ln"))
{
updateRelation = CreateRelationRepresentation((ITable)lineFeatureClass, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
updateRelation = CreateRelationRepresentation((ITable)polygonFeatureClass, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_relation"))
{
updateRelation = CreateRelationRepresentation(relationTable, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
listOfModifies.Add(updateRelation);
break;
default:
break;
}
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
}
catch
{
}
searchRowToUpdate = searchCursor.NextRow();
}
if (listOfModifies != null && uploadModify != null)
{
uploadModify.Items = listOfModifies.ToArray();
// in case there are any creates let's add them to the changeset document
changeSetItems.Add(uploadModify);
}
}
#endregion
#region upload delete actions
// loop through deletes in "reverse" - relation, then way, then node
string[] elementTypes = new string[] { "relation", "way", "node" };
foreach (string osmElementType in elementTypes)
{
using (ComReleaser comReleaser = new ComReleaser())
{
queryFilter.WhereClause = "(" + sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'delete' AND "
+ sqlFormatter.SqlIdentifier("osmelementtype") + " = '" + osmElementType + "'";
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
searchRowToUpdate = searchCursor.NextRow();
if (searchRowToUpdate != null)
{
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
if (uploadDelete == null)
{
uploadDelete = new delete();
listOfDeletes = new List<object>();
}
}
while (searchRowToUpdate != null)
{
try
{
string action = String.Empty;
if (revActionFieldIndex != -1)
{
action = searchRowToUpdate.get_Value(revActionFieldIndex) as string;
}
string elementType = String.Empty;
if (revElementTypeFieldIndex != -1)
{
elementType = searchRowToUpdate.get_Value(revElementTypeFieldIndex) as string;
}
string sourceFCName = String.Empty;
if (revFCNameFieldIndex != -1)
{
sourceFCName = searchRowToUpdate.get_Value(revFCNameFieldIndex) as string;
}
long osmOldID = -1;
if (revOldIDFieldIndex != -1)
{
osmOldID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
// add any outstanding creations to the changeset items
if (listOfDeletes != null && uploadDelete != null)
{
uploadDelete.Items = listOfDeletes.ToArray();
// in case there are any creates let's add them to the changeset document
changeSetItems.Add(uploadDelete);
}
// add all the changeset items to the changeset document
osmChangeDocument.Items = changeSetItems.ToArray();
// submit changeset
try
{
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/changeset/" + changeSetID + "/upload") as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
httpClient.Method = "POST";
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
httpClient.Timeout = secondsToTimeout * 1000;
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(osmChangeDocument, null, Encoding.UTF8, "text/xml");
OsmRest.HttpUtils.Post(httpClient, sContent);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
diffResult diffResultResonse = OsmRest.HttpUtils.GetResponse(httpResponse);
// parse changes locally and update local data sources
if (diffResultResonse != null)
{
ParseResultDiff(diffResultResonse, revisionTable, pointFeatureClass, lineFeatureClass, polygonFeatureClass, relationTable, user_displayname, userID, changeSetID, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
}
catch (Exception ex)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
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);
}
}
if (httpResponse != null)
{
httpResponse.Close();
}
return;
}
finally
{
// reset the list and containers of modifications for the next batch
listOfDeletes.Clear();
changeSetItems.Clear();
if (httpResponse != null)
{
httpResponse.Close();
}
}
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
switch (elementType)
{
case "node":
IPoint deletePoint = null;
if (revLongitudeFieldIndex != -1 && revLatitudeFieldIndex != -1)
{
try
{
// let's reconstruct the delete point
deletePoint = new PointClass();
deletePoint.X = Convert.ToDouble(searchRowToUpdate.get_Value(revLongitudeFieldIndex));
deletePoint.Y = Convert.ToDouble(searchRowToUpdate.get_Value(revLatitudeFieldIndex));
deletePoint.SpatialReference = m_wgs84;
}
catch (Exception ex)
{
message.AddWarning(ex.Message);
}
if (deletePoint == null)
{
// inform the about the issue - no successful creation of point and continue on to the next delete instruction
// in the revision table
message.AddWarning(resourceManager.GetString("GPTools_OSMGPUpload_invalidPoint"));
searchRowToUpdate = searchCursor.NextRow();
continue;
}
}
node deleteNode = CreateNodeRepresentation(pointFeatureClass, action, osmOldID, changeSetID, osmVersion, deletePoint, internalExtensionVersion);
listOfDeletes.Add(deleteNode);
break;
case "way":
way deleteWay = null;
if (sourceFCName.Contains("_osm_ln"))
{
deleteWay = CreateWayRepresentation(lineFeatureClass, action, osmOldID, changeSetID, osmVersion, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
deleteWay = CreateWayRepresentation(polygonFeatureClass, action, osmOldID, changeSetID, osmVersion, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
listOfDeletes.Add(deleteWay);
break;
case "relation":
relation deleteRelation = null;
if (sourceFCName.Contains("_osm_ln"))
{
deleteRelation = CreateRelationRepresentation((ITable)lineFeatureClass, action, osmOldID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
deleteRelation = CreateRelationRepresentation((ITable)polygonFeatureClass, action, osmOldID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_relation"))
{
deleteRelation = CreateRelationRepresentation(relationTable, action, osmOldID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
listOfDeletes.Add(deleteRelation);
break;
default:
break;
}
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
}
catch
{
}
searchRowToUpdate = searchCursor.NextRow();
}
}
}
if (listOfDeletes != null && uploadDelete != null)
{
uploadDelete.Items = listOfDeletes.ToArray();
// in case there are any creates let's add them to the changeset document
changeSetItems.Add(uploadDelete);
}
#endregion
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
// add all the changeset items to the changeset document
osmChangeDocument.Items = changeSetItems.ToArray();
// submit changeset
try
{
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/changeset/" + changeSetID + "/upload") as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
httpClient.Method = "POST";
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
httpClient.Timeout = secondsToTimeout * 1000;
message.AddMessage(String.Format(resourceManager.GetString("GPTools_OSMGPUpload_featureSubmit"), featureUpdateCounter));
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(osmChangeDocument, null, Encoding.UTF8, "text/xml");
OsmRest.HttpUtils.Post(httpClient, sContent);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
//Exception with an error HTTP 400
diffResult diffResultResonse = OsmRest.HttpUtils.GetResponse(httpResponse);
message.AddMessage(resourceManager.GetString("GPTools_OSMGPUpload_updatelocalData"));
// parse changes locally and update local data sources
if (diffResultResonse != null)
{
ParseResultDiff(diffResultResonse, revisionTable, pointFeatureClass, lineFeatureClass, polygonFeatureClass, relationTable, user_displayname, userID, changeSetID, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
try
{
if (ex is WebException)
{
WebException webException = ex as WebException;
string serverErrorMessage = webException.Response.Headers["Error"];
if (!String.IsNullOrEmpty(serverErrorMessage))
{
message.AddError(120009, serverErrorMessage);
}
}
}
catch (Exception innerexception)
{
message.AddError(120009, innerexception.Message);
}
}
finally
{
if (httpResponse != null)
{
httpResponse.Close();
}
}
#endregion
}
else
{
#region single upload format
#region submit the create nodes first
queryFilter.WhereClause = "(" +
sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'create' AND "
+ sqlFormatter.SqlIdentifier("osmelementtype") + " = 'node'";
using (ComReleaser comReleaser = new ComReleaser())
{
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
while ((searchRowToUpdate = searchCursor.NextRow()) != null)
{
try
{
string action = String.Empty;
if (revActionFieldIndex != -1)
{
action = searchRowToUpdate.get_Value(revActionFieldIndex) as string;
}
string elementType = String.Empty;
if (revElementTypeFieldIndex != -1)
{
elementType = searchRowToUpdate.get_Value(revElementTypeFieldIndex) as string;
}
string sourceFCName = String.Empty;
if (revFCNameFieldIndex != -1)
{
sourceFCName = searchRowToUpdate.get_Value(revFCNameFieldIndex) as string;
}
long osmOldID = -1;
if (revOldIDFieldIndex != -1)
{
osmOldID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
osm createNode = CreateOSMNodeRepresentation(pointFeatureClass, action, osmOldID, changeSetID, -1, null, internalExtensionVersion);
httpClient = null;
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/" + elementType + "/create") as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
httpClient.Method = "PUT";
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
httpClient.Timeout = secondsToTimeout * 1000;
httpResponse = null;
string nodeContent = OsmRest.SerializeUtils.CreateXmlSerializable(createNode, serializer, Encoding.UTF8, "text/xml");
if (String.IsNullOrEmpty(nodeContent))
{
continue;
}
OsmRest.HttpUtils.Put(httpClient, nodeContent);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
createNode = null;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
if (httpResponse != null)
{
string newIDString = OsmRest.HttpUtils.GetResponseContent(httpResponse);
nodeosmIDLookup.Add(osmOldID, Convert.ToInt64(newIDString));
// update the revision table
if (revNewIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revNewIDFieldIndex, Convert.ToString(newIDString));
}
if (revVersionFieldIndex != -1)
{
searchRowToUpdate.set_Value(revVersionFieldIndex, 1);
}
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, httpResponse.StatusCode.ToString());
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (revChangeSetIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revChangeSetIDFieldIndex, Convert.ToString(changeSetID));
}
// update the source point feature class as well
updateSource((ITable)pointFeatureClass, action, osmOldID, Convert.ToInt64(newIDString), user_displayname, userID, 1, Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup,internalExtensionVersion);
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
finally
{
try
{
searchRowToUpdate.Store();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
}
}
#endregion
#region next the create ways
queryFilter.WhereClause = "(" +
sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'create' AND "
+ sqlFormatter.SqlIdentifier("osmelementtype") + " = 'way'";
using (ComReleaser comReleaser = new ComReleaser())
{
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
while ((searchRowToUpdate = searchCursor.NextRow()) != null)
{
try
{
string action = String.Empty;
if (revActionFieldIndex != -1)
{
action = searchRowToUpdate.get_Value(revActionFieldIndex) as string;
}
string elementType = String.Empty;
if (revElementTypeFieldIndex != -1)
{
elementType = searchRowToUpdate.get_Value(revElementTypeFieldIndex) as string;
}
string sourceFCName = String.Empty;
if (revFCNameFieldIndex != -1)
{
sourceFCName = searchRowToUpdate.get_Value(revFCNameFieldIndex) as string;
}
long osmOldID = -1;
if (revOldIDFieldIndex != -1)
{
osmOldID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
bool isPolygon = false;
if (sourceFCName.IndexOf("_osm_ply") > -1)
{
isPolygon = true;
}
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
osm createWay = new osm();
if (isPolygon == false)
{
createWay = CreateOSMWayRepresentation(lineFeatureClass, action, osmOldID, changeSetID, -1, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
else
{
createWay = CreateOSMWayRepresentation(polygonFeatureClass, action, osmOldID, changeSetID, -1, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
try
{
HttpWebRequest httpClient3 = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/" + elementType + "/create") as HttpWebRequest;
httpClient3 = OSMGPDownload.AssignProxyandCredentials(httpClient3);
httpClient3.Method = "PUT";
SetBasicAuthHeader(httpClient3, userCredentialGPValue.EncodedUserNamePassWord);
httpClient.Timeout = secondsToTimeout * 1000;
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(createWay, serializer, Encoding.UTF8, "text/xml");
OsmRest.HttpUtils.Put(httpClient3, sContent);
createWay = null;
httpResponse = null;
httpResponse = httpClient3.GetResponse() as HttpWebResponse;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
if (httpResponse != null)
{
string newIDString = OsmRest.HttpUtils.GetResponseContent(httpResponse);
wayosmIDLookup.Add(osmOldID, Convert.ToInt64(newIDString));
// update the revision table
if (revNewIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revNewIDFieldIndex, Convert.ToString(newIDString));
}
if (revVersionFieldIndex != -1)
{
searchRowToUpdate.set_Value(revVersionFieldIndex, 1);
}
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, httpResponse.StatusCode.ToString());
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (revChangeSetIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revChangeSetIDFieldIndex, Convert.ToString(changeSetID));
}
// update the source line/polygon feature class as well
if (isPolygon == false)
{
updateSource((ITable)lineFeatureClass, action, osmOldID, Convert.ToInt64(newIDString), user_displayname, userID, 1, Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else
{
updateSource((ITable)polygonFeatureClass, action, osmOldID, Convert.ToInt64(newIDString), user_displayname, userID, 1, Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
finally
{
try
{
searchRowToUpdate.Store();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
}
}
#endregion
#region and then create relations
queryFilter.WhereClause = "(" +
sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'create' AND "
+ sqlFormatter.SqlIdentifier("osmelementtype") + " = 'relation'";
using (ComReleaser comReleaser = new ComReleaser())
{
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
while ((searchRowToUpdate = searchCursor.NextRow()) != null)
{
try
{
string action = String.Empty;
if (revActionFieldIndex != -1)
{
action = searchRowToUpdate.get_Value(revActionFieldIndex) as string;
}
string elementType = String.Empty;
if (revElementTypeFieldIndex != -1)
{
elementType = searchRowToUpdate.get_Value(revElementTypeFieldIndex) as string;
}
string sourceFCName = String.Empty;
if (revFCNameFieldIndex != -1)
{
sourceFCName = searchRowToUpdate.get_Value(revFCNameFieldIndex) as string;
}
long osmOldID = -1;
if (revOldIDFieldIndex != -1)
{
osmOldID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
bool isPolygon = false;
if (sourceFCName.IndexOf("_osm_ply") > -1)
{
isPolygon = true;
}
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
osm createRelation = null;
// the relation is acutally multi-part line
if (sourceFCName.Contains("_osm_ln"))
{
createRelation = CreateOSMRelationRepresentation((ITable)lineFeatureClass, action, osmOldID, changeSetID, -1, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
createRelation = CreateOSMRelationRepresentation((ITable)polygonFeatureClass, action, osmOldID, changeSetID, -1, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else
{
createRelation = CreateOSMRelationRepresentation(relationTable, action, osmOldID, changeSetID, -1, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
try
{
HttpWebRequest httpClient4 = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/" + elementType + "/create") as HttpWebRequest;
httpClient4 = OSMGPDownload.AssignProxyandCredentials(httpClient4);
SetBasicAuthHeader(httpClient4, userCredentialGPValue.EncodedUserNamePassWord);
httpClient4.Timeout = secondsToTimeout * 1000;
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(createRelation, serializer, Encoding.UTF8, "text/xml");
OsmRest.HttpUtils.Put(httpClient4, sContent);
httpResponse = null;
httpResponse = httpClient4.GetResponse() as HttpWebResponse;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
if (httpResponse != null)
{
string newIDString = OsmRest.HttpUtils.GetResponseContent(httpResponse);
relationosmIDLookup.Add(osmOldID, Convert.ToInt64(newIDString));
// update the revision table
if (revNewIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revNewIDFieldIndex, Convert.ToString(newIDString));
}
if (revVersionFieldIndex != -1)
{
searchRowToUpdate.set_Value(revVersionFieldIndex, 1);
}
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, httpResponse.StatusCode.ToString());
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (revChangeSetIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revChangeSetIDFieldIndex, Convert.ToInt32(changeSetID));
}
if (sourceFCName.Contains("_osm_ln"))
{
updateSource((ITable)lineFeatureClass, action, osmOldID, Convert.ToInt64(newIDString), user_displayname, userID, 1, Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else if (sourceFCName.Contains("_osm_ply"))
{
updateSource((ITable)polygonFeatureClass, action, osmOldID, Convert.ToInt64(newIDString), user_displayname, userID, 1, Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else
{
// update the source table holding the relation information class as well
updateSource(relationTable, action, osmOldID, Convert.ToInt64(newIDString), user_displayname, userID, 1, Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
finally
{
try
{
searchRowToUpdate.Store();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
}
}
#endregion
#region after that submit the modify node, way, relation
using (ComReleaser comReleaser = new ComReleaser())
{
queryFilter.WhereClause = "(" +
sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'modify'";
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
while ((searchRowToUpdate = searchCursor.NextRow()) != null)
{
try
{
string action = String.Empty;
if (revActionFieldIndex != -1)
{
action = searchRowToUpdate.get_Value(revActionFieldIndex) as string;
}
string elementType = String.Empty;
if (revElementTypeFieldIndex != -1)
{
elementType = searchRowToUpdate.get_Value(revElementTypeFieldIndex) as string;
}
string sourceFCName = String.Empty;
if (revFCNameFieldIndex != -1)
{
sourceFCName = searchRowToUpdate.get_Value(revFCNameFieldIndex) as string;
}
long osmOldID = -1;
if (revOldIDFieldIndex != -1)
{
osmOldID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
switch (elementType)
{
case "node":
#region submit nodes to OSM server
switch (action)
{
case "modify":
long modifyID = -1;
if (revNewIDFieldIndex != -1)
{
object osmIDValue = searchRowToUpdate.get_Value(revNewIDFieldIndex);
if (osmIDValue == DBNull.Value)
{
osmIDValue = osmOldID;
}
try
{
modifyID = Convert.ToInt64(osmIDValue);
}
catch { }
// modifies should only happen to osm IDs > 0
// if that condition is not met let's skip this feature as something is not right
if (modifyID < 0)
{
continue;
}
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
try
{
HttpWebRequest httpClient5 = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/" + elementType + "/" + modifyID.ToString()) as HttpWebRequest;
httpClient5 = OSMGPDownload.AssignProxyandCredentials(httpClient5);
SetBasicAuthHeader(httpClient5, userCredentialGPValue.EncodedUserNamePassWord);
osm updateNode = CreateOSMNodeRepresentation(pointFeatureClass, action, modifyID, changeSetID, osmVersion, null, internalExtensionVersion);
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(updateNode, serializer, Encoding.UTF8, "text/xml");
// if the serialized node at this time is a null or an empty string let's continue to the next point
if (String.IsNullOrEmpty(sContent))
{
continue;
}
OsmRest.HttpUtils.Put(httpClient5, sContent);
httpResponse = httpClient5.GetResponse() as HttpWebResponse;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
if (httpResponse != null)
{
string newVersionString = OsmRest.HttpUtils.GetResponseContent(httpResponse);
// update the revision table
if (revVersionFieldIndex != -1)
{
searchRowToUpdate.set_Value(revVersionFieldIndex, Convert.ToString(newVersionString));
}
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, httpResponse.StatusCode.ToString());
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (revChangeSetIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revChangeSetIDFieldIndex, Convert.ToInt32(changeSetID));
}
// for a modify the old id is still the new id
if (revNewIDFieldIndex != -1 && revOldIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revNewIDFieldIndex, searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
// update the source point feature class as well
updateSource((ITable)pointFeatureClass, action, modifyID, modifyID, user_displayname, userID, Convert.ToInt32(newVersionString), Convert.ToInt32(changeSetID), null, null, null, internalExtensionVersion);
httpResponse.Close();
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
break;
case "delete":
// the delete operations are handled separately
break;
default:
break;
}
break;
#endregion
case "way":
#region submit ways to the OSM server
// determine if we have a polygon or a polyline feature class
bool isPolygon = false;
if (sourceFCName.IndexOf("_osm_ply") > -1)
{
isPolygon = true;
}
switch (action)
{
case "modify":
long modifyID = -1;
if (revNewIDFieldIndex != -1)
{
object osmIDValue = searchRowToUpdate.get_Value(revNewIDFieldIndex);
if (osmIDValue == DBNull.Value)
{
osmIDValue = osmOldID;
}
try
{
modifyID = Convert.ToInt64(osmIDValue);
}
catch { }
// modifies should only happen to osm IDs > 0
// if that condition is not met let's skip this feature as something is not right
if (modifyID < 0)
{
continue;
}
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
osm updateWay = new osm();
if (isPolygon == false)
{
updateWay = CreateOSMWayRepresentation(lineFeatureClass, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
else
{
updateWay = CreateOSMWayRepresentation(polygonFeatureClass, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
}
try
{
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(updateWay, serializer, Encoding.UTF8, "text/xml");
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/" + elementType + "/" + modifyID.ToString()) as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
OsmRest.HttpUtils.Put(httpClient, sContent);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
if (httpResponse != null)
{
string newVersionString = OsmRest.HttpUtils.GetResponseContent(httpResponse);
// update the revision table
if (revVersionFieldIndex != -1)
{
searchRowToUpdate.set_Value(revVersionFieldIndex, Convert.ToString(newVersionString));
}
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, httpResponse.StatusCode.ToString());
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (revChangeSetIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revChangeSetIDFieldIndex, Convert.ToInt32(changeSetID));
}
// for a modify the old id is still the new id
if (revNewIDFieldIndex != -1 && revOldIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revNewIDFieldIndex, searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
// update the source line/polygon feature class as well
if (isPolygon == false)
{
updateSource((ITable)lineFeatureClass, action, modifyID, modifyID, user_displayname, userID, Convert.ToInt32(newVersionString), Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
else
{
updateSource((ITable)polygonFeatureClass, action, modifyID, modifyID, user_displayname, userID, Convert.ToInt32(newVersionString), Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
}
httpResponse.Close();
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
break;
case "delete":
// the delete operations are handled separately
break;
default:
break;
}
break;
#endregion
case "relation":
#region submit relations to the OSM server
switch (action)
{
case "create":
break;
case "modify":
long modifyID = -1;
if (revNewIDFieldIndex != -1)
{
object osmIDValue = searchRowToUpdate.get_Value(revNewIDFieldIndex);
if (osmIDValue == DBNull.Value)
{
osmIDValue = osmOldID;
}
try
{
modifyID = Convert.ToInt64(osmIDValue);
}
catch { }
// modifies should only happen to osm IDs > 0
// if that condition is not met let's skip this feature as something is not right
if (modifyID < 0)
{
continue;
}
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
osm updateRelation = CreateOSMRelationRepresentation(relationTable, action, modifyID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
try
{
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(updateRelation, serializer, Encoding.UTF8, "text/xml");
httpClient = HttpWebRequest.Create(baseURLGPString.Value + "/api/0.6/" + elementType + "/" + modifyID.ToString()) as HttpWebRequest;
httpClient = OSMGPDownload.AssignProxyandCredentials(httpClient);
SetBasicAuthHeader(httpClient, userCredentialGPValue.EncodedUserNamePassWord);
OsmRest.HttpUtils.Put(httpClient, sContent);
httpResponse = httpClient.GetResponse() as HttpWebResponse;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
if (httpResponse != null)
{
string newVersionString = OsmRest.HttpUtils.GetResponseContent(httpResponse);
// update the revision table
if (revVersionFieldIndex != -1)
{
searchRowToUpdate.set_Value(revVersionFieldIndex, Convert.ToInt32(newVersionString));
}
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, httpResponse.StatusCode.ToString());
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (revChangeSetIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revChangeSetIDFieldIndex, Convert.ToInt32(changeSetID));
}
// for a modify the old id is still the new id
if (revNewIDFieldIndex != -1 && revOldIDFieldIndex != -1)
{
searchRowToUpdate.set_Value(revNewIDFieldIndex, searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
// update the source table holding the relation information class as well
updateSource(relationTable, action, modifyID, modifyID, user_displayname, userID, Convert.ToInt32(newVersionString), Convert.ToInt32(changeSetID), nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
httpResponse.Close();
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
break;
case "delete":
// the delete operations are handled separately
break;
default:
break;
}
break;
#endregion
default:
break;
}
}
catch (Exception ex)
{
message.AddAbort(ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
}
finally
{
try
{
searchRowToUpdate.Store();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
}
}
#endregion
#region now let's handle the delete in the reverse order - relation first, then ways, and then nodes as the last entity
#region delete relations
// now let's handle the delete in the reverse order - relation first, then ways, and then nodes as the last entity
queryFilter.WhereClause = "("
+ sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'delete' AND "
+ sqlFormatter.SqlIdentifier("osmelementtype") + " = 'relation'";
using (ComReleaser comReleaser = new ComReleaser())
{
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
while ((searchRowToUpdate = searchCursor.NextRow()) != null)
{
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
long osmID = -1;
if (revOldIDFieldIndex != -1)
{
osmID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
osm deleteRelation = CreateOSMRelationRepresentation(relationTable, "delete", osmID, changeSetID, osmVersion, nodeosmIDLookup, wayosmIDLookup, relationosmIDLookup, internalExtensionVersion);
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(deleteRelation, serializer, Encoding.UTF8, "text/xml");
string errorMessage = String.Empty;
try
{
httpResponse = OsmRest.HttpUtils.Delete(baseURLGPString.Value + "/api/0.6/relation/" + Convert.ToString(osmID), sContent, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout) as HttpWebResponse;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, (int)httpResponse.StatusCode);
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
try
{
searchRowToUpdate.Store();
}
catch { }
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
}
}
#endregion
#region handle delete ways
queryFilter.WhereClause = "("
+ sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'delete' AND "
+ sqlFormatter.SqlIdentifier("osmelementtype") + " = 'way'";
using (ComReleaser comReleaser = new ComReleaser())
{
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
while ((searchRowToUpdate = searchCursor.NextRow()) != null)
{
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
long osmID = -1;
if (revOldIDFieldIndex != -1)
{
osmID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
osm deleteWay = CreateOSMWayRepresentation(lineFeatureClass, "delete", osmID, changeSetID, osmVersion, wayosmIDLookup, pointFeatureClass, pointOSMIDFieldIndex, internalExtensionVersion);
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(deleteWay, serializer, Encoding.UTF8, "text/xml");
try
{
httpResponse = null;
httpResponse = OsmRest.HttpUtils.Delete(baseURLGPString.Value + "/api/0.6/way/" + Convert.ToString(osmID), sContent, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout) as HttpWebResponse;
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
string errorMessage = String.Empty;
// just grab the response and set it on the database
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, (int)httpResponse.StatusCode);
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
catch (Exception ex)
{
message.AddError(1200009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
try
{
searchRowToUpdate.Store();
}
catch { }
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
}
}
#endregion
#region handle delete points
queryFilter.WhereClause = "("
+ sqlFormatter.SqlIdentifier("osmstatuscode") + " <> 200 OR "
+ sqlFormatter.SqlIdentifier("osmstatus") + " IS NULL) AND "
+ sqlFormatter.SqlIdentifier("osmaction") + " = 'delete' AND "
+ sqlFormatter.SqlIdentifier("osmelementtype") + " = 'node'";
using (ComReleaser comReleaser = new ComReleaser())
{
searchCursor = revisionTable.Search(queryFilter, false);
comReleaser.ManageLifetime(searchCursor);
while ((searchRowToUpdate = searchCursor.NextRow()) != null)
{
// if the overall number of uploaded elements is too big for a single changeset we do need to split it up
// into multiple sets
if ((featureUpdateCounter % maxElementsinChangeSet) == 0)
{
CreateNextChangeSet(message, createChangeSetOSM, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, ref changeSetID, baseURLGPString, ref featureUpdateCounter);
}
long osmID = -1;
if (revOldIDFieldIndex != -1)
{
osmID = Convert.ToInt64(searchRowToUpdate.get_Value(revOldIDFieldIndex));
}
int osmVersion = -1;
if (revVersionFieldIndex != -1)
{
osmVersion = Convert.ToInt32(searchRowToUpdate.get_Value(revVersionFieldIndex));
}
IPoint deletePoint = null;
if (revLongitudeFieldIndex != -1 && revLatitudeFieldIndex != -1)
{
try
{
// let's reconstruct the delete point
deletePoint = new PointClass();
deletePoint.X = Convert.ToDouble(searchRowToUpdate.get_Value(revLongitudeFieldIndex));
deletePoint.Y = Convert.ToDouble(searchRowToUpdate.get_Value(revLatitudeFieldIndex));
deletePoint.SpatialReference = m_wgs84;
}
catch (Exception ex)
{
message.AddWarning(ex.Message);
}
if (deletePoint == null)
{
// inform the about the issue - no successful creation of point and continue on to the next delete instruction
// in the revision table
message.AddWarning(resourceManager.GetString("GPTools_OSMGPUpload_invalidPoint"));
continue;
}
}
osm deleteNode = CreateOSMNodeRepresentation(pointFeatureClass, "delete", osmID, changeSetID, osmVersion, deletePoint, internalExtensionVersion);
string sContent = OsmRest.SerializeUtils.CreateXmlSerializable(deleteNode, serializer, Encoding.UTF8, "text/xml");
if (String.IsNullOrEmpty(sContent))
{
continue;
}
string errorMessage = String.Empty;
try
{
httpResponse = OsmRest.HttpUtils.Delete(baseURLGPString.Value + "/api/0.6/node/" + Convert.ToString(osmID), sContent, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout) as HttpWebResponse;
if (revStatusFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusFieldIndex, (int)httpResponse.StatusCode);
}
if (revStatusCodeFieldIndex != -1)
{
searchRowToUpdate.set_Value(revStatusCodeFieldIndex, (int)httpResponse.StatusCode);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
catch (Exception ex)
{
message.AddError(120009, ex.Message);
if (ex is WebException)
{
updateErrorStatus(message, revStatusFieldIndex, revStatusCodeFieldIndex, revErrorMessageFieldIndex, ref searchRowToUpdate, ex);
}
if (httpResponse != null)
{
httpResponse.Close();
}
}
// track the update/sync requests against the server
featureUpdateCounter = featureUpdateCounter + 1;
try
{
searchRowToUpdate.Store();
}
catch { }
if (TrackCancel.Continue() == false)
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
return;
}
}
}
#endregion
#endregion
#endregion
}
}
catch (Exception ex)
{
message.AddError(120058, ex.Message);
message.AddError(120058, ex.StackTrace);
}
finally
{
closeChangeSet(message, userCredentialGPValue.EncodedUserNamePassWord, secondsToTimeout, changeSetID, baseURLGPString);
if (revisionTable != null)
{
try
{
ISchemaLock tableSchemaLock = revisionTable as ISchemaLock;
if (tableSchemaLock != null)
{
tableSchemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
}
}
catch (Exception eLock)
{
message.AddError(120059, resourceManager.GetString("GPTools_OSMGPUpload_LockErrorTitle") + eLock.Message);
}
}
if (revisionTable != null)
{
Marshal.FinalReleaseComObject(revisionTable);
}
// if the searchCursor still has a reference somewhere do release it now - and as a result release any remaining table locks
if (searchCursor != null)
{
Marshal.FinalReleaseComObject(searchCursor);
}
gpUtilities3.RemoveInternalData();
gpUtilities3.ReleaseInternals();
//Marshal.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)
{
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());
}
}
}
//coordinate 点坐标创建shp图层。
public static void CreatePolygonFeatureclass(IPolygon pPolygon, string shpfolder, string shpname)
{
IWorkspaceFactory pWorkSpaceFac = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pFeatureWorkSpace = pWorkSpaceFac.OpenFromFile(shpfolder, 0) as IFeatureWorkspace;
try
{//如果图层存在则删除
FileInfo fFile = new FileInfo(shpfolder + @"\" + shpname+ ".shp");//
if (fFile.Exists)
{
if (MessageBox.Show("此文件名已经存在，要覆盖吗？", "覆盖文件", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
DirectoryInfo fold = new DirectoryInfo(shpfolder);
FileInfo[] files = fold.GetFiles(shpname + ".*");
foreach (FileInfo f in files)
{
f.Delete();
}
}
else
return;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
//if (File.Exists(shpfolder+shpname))//如果shp存在则替换它。
//{
// if (MessageBox.Show("发现同名文件，是否覆盖源文件?", "询问", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
// {
// IFeatureClass featureclass = pFeatureWorkSpace.OpenFeatureClass(shpname);
// IDataset pDataset = featureclass as IDataset;
// pDataset.Delete();
// }
// else
// return;
//}
//创建字段集2
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;//创建必要字段
IFields fields = ocDescription.RequiredFields;
int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName);
IField field = fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = field.GeometryDef;
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
//geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
//geometryDefEdit.SpatialReference_2 = spatialReference;
geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass();
// IProjectedCoordinateSystem pcsSys = pSpatialRefFac.CreateProjectedCoordinateSystem((int)esriSRProjCS4Type.esriSRProjCS_Xian1980_3_Degree_GK_Zone_39);
IGeographicCoordinateSystem pcsSys = pSpatialRefFac.CreateGeographicCoordinateSystem(4490);
geometryDefEdit.SpatialReference_2 = pcsSys;
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null; //将传入字段 转成 validatedFields
fieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkSpace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
field = new FieldClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)fields;
IFieldEdit pFieldEdit = (IFieldEdit)field;
pFieldEdit = (IFieldEdit)field;
pFieldEdit.Name_2 = "面积";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
pFieldsEdit.AddField(field);
IArea s = pPolygon as IArea;
double area = s.Area*100;
double length=pPolygon.Length*100;
MessageBox.Show("该区域面积为：" + Convert.ToDouble(area).ToString("0.000") + "平方公里（km2）" +"\r\n" + "边长为：" + Convert.ToDouble(length).ToString("0.000") + "千米（KM）");
try
{
IFeatureClass pFeatureClass;
//pFeatureClass = pFeatureWorkSpace.OpenFeatureClass(shpname);
pFeatureClass = pFeatureWorkSpace.CreateFeatureClass(shpname, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, "");
IFeature pFeature = pFeatureClass.CreateFeature();
pFeature.Shape = pPolygon;
// pFeature.set_Value(pFeature.Fields.FindField("面积"), area);
pFeature.Store();
}
catch
{
// MessageBox.Show("存储失败！请检查目录下是否有同名文件···", "提示");
//return;
}
}
public static void cp(IPolygon pPolygon)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Shape文件（*.shp）|*.shp";
saveFileDialog.Title = "新建面shp文件";
saveFileDialog.CheckFileExists = true;
saveFileDialog.RestoreDirectory = true;
DialogResult dialogResult = saveFileDialog.ShowDialog();
string shpPath;
string shpName;
IWorkspaceFactory pWorkSpaceFactory = new ShapefileWorkspaceFactory();
if (dialogResult == DialogResult.OK)
{
IFeatureClass pFeatureClass;
string date = DateTime.Now.ToLongDateString().ToString();
//saveFileDialog.FileName = date + "采集的坐标点";
string fileFullName = saveFileDialog.FileName;
int index = fileFullName.LastIndexOf("\\");
shpName = fileFullName.Substring(index + 1);
shpPath = fileFullName.Substring(0, index);
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)pWorkSpaceFactory.OpenFromFile(shpPath, 0);
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pFeatureWorkspace;
IGeometryDef pGeometryDef = new GeometryDef();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon;//点、线、面什么的
ISpatialReferenceFactory2 ipSpaRefFa = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem ipGeoCorSys = new GeographicCoordinateSystemClass();
ipGeoCorSys = ipSpaRefFa.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
ISpatialReference ipSpaRef = ipGeoCorSys;
pGeometryDefEdit.SpatialReference_2 = ipSpaRef;
/*if (System.IO.File.Exists(saveFileDialog.FileName))
{
if (MessageBox.Show("是否替换原文件？", "询问", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
pFeatureClass = pFeatureWorkspace.OpenFeatureClass(shpName);
IDataset pDataset = (IDataset)pFeatureClass;
pDataset.Delete();
}
else
return;
}
else
{
fileFullName = null;
return;
}*/
//设置字段
double area;
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
IField pField = new FieldClass();
IFieldEdit pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFieldEdit.GeometryDef_2 = pGeometryDef;
pFieldsEdit.AddField(pField);
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "面积";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
pFieldsEdit.AddField(pField);
//创建shp
pWorkspaceEdit.StartEditOperation();//启动编辑
pFeatureClass = pFeatureWorkspace.CreateFeatureClass(shpName, pFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
pPolygon = new PolygonClass();
IArea s = pPolygon as IArea;
area = s.Area;
IFeature pfeature = pFeatureClass.CreateFeature();
pfeature.Shape = pPolygon;
pfeature.set_Value(pfeature.Fields.FindField("面积"), area.ToString());
pfeature.Store();
pWorkspaceEdit.StopEditOperation();
IFeatureLayer pFeaturelayer = new FeatureLayerClass();
pFeaturelayer.FeatureClass = pFeatureClass;
pFeaturelayer.Name = "采集坐标图层";
}
}
public static void CreatePolygonFeature(IPolygon pPolygon, string shpfolder, string shpname)
{
IWorkspaceFactory pWorkSpaceFac = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pFeatureWorkSpace = pWorkSpaceFac.OpenFromFile(shpfolder, 0) as IFeatureWorkspace;
try
{//如果图层存在则删除
FileInfo fFile = new FileInfo(shpfolder + @"\" + shpname + ".shp");//
if (fFile.Exists)
{
DirectoryInfo fold = new DirectoryInfo(shpfolder);
FileInfo[] files = fold.GetFiles(shpname + ".*");
foreach (FileInfo f in files)
{
f.Delete();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
//创建字段集2
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;//创建必要字段
IFields fields = ocDescription.RequiredFields;
int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName);
IField field = fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = field.GeometryDef;
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem pcsSys = pSpatialRefFac.CreateGeographicCoordinateSystem(4490);
geometryDefEdit.SpatialReference_2 = pcsSys;
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null; //将传入字段 转成 validatedFields
fieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkSpace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
/*
field = new FieldClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)fields;
IFieldEdit pFieldEdit = (IFieldEdit)field;
pFieldEdit = (IFieldEdit)field;
pFieldEdit.Name_2 = "面积";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
pFieldsEdit.AddField(field);*/
IArea s = pPolygon as IArea;
double area = Math.Abs(s.Area * 10000);
double length = Math.Abs(pPolygon.Length * 100);
MessageBox.Show("该区域面积为：" + Convert.ToDouble(area).ToString("0.000") + "平方公里（km2）" + "\r\n" + "边长为：" + Convert.ToDouble(length).ToString("0.000") + "千米（KM）");
try
{
IFeatureClass pFeatureClass;
pFeatureClass = pFeatureWorkSpace.CreateFeatureClass(shpname, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, "");
IFeature pFeature = pFeatureClass.CreateFeature();
pFeature.Shape = pPolygon;
//pFeature.set_Value(pFeature.Fields.FindField("面积"), area);
pFeature.Store();
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// draw footprints on the map
/// </summary>
/// <param name="record">Record for which the footprint needs to be drwan</param>
/// <param name="refreshview">Indicates if the view is refreshed or not after the element is drawn</param>
/// <param name="deleteelements">Indicates if the element can be deleted or not</param>
private void drawfootprint(CswRecord record, bool refreshview, bool deleteelements)
{
//create the triangle outline symbol
ISimpleLineSymbol lineSymbol = new SimpleLineSymbolClass();
lineSymbol.Style = esriSimpleLineStyle.esriSLSSolid;
lineSymbol.Width = 2.0;
//create the triangle's fill symbol
ISimpleFillSymbol simpleFillSymbol = new SimpleFillSymbolClass();
simpleFillSymbol.Outline = (ILineSymbol)lineSymbol;
simpleFillSymbol.Style = esriSimpleFillStyle.esriSFSDiagonalCross;
IMxDocument mxDoc;
mxDoc = (IMxDocument)m_application.Document;
//the original projection system
ISpatialReference spatialReference;
IGeographicCoordinateSystem geographicCoordinateSystem;
SpatialReferenceEnvironmentClass spatialReferenceEnviorment = new SpatialReferenceEnvironmentClass();
geographicCoordinateSystem = spatialReferenceEnviorment.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
spatialReference = (ISpatialReference)geographicCoordinateSystem;
//set the geometry of the element
IPoint point = new ESRI.ArcGIS.Geometry.PointClass();
point.SpatialReference = spatialReference;
point.PutCoords(record.BoundingBox.Minx, record.BoundingBox.Miny);
IPoint point1 = new ESRI.ArcGIS.Geometry.PointClass();
point1.SpatialReference = spatialReference;
point1.PutCoords(record.BoundingBox.Minx, record.BoundingBox.Maxy);
IPoint point2 = new ESRI.ArcGIS.Geometry.PointClass();
point2.SpatialReference = spatialReference;
point2.PutCoords(record.BoundingBox.Maxx, record.BoundingBox.Maxy);
IPoint point3 = new ESRI.ArcGIS.Geometry.PointClass();
point3.SpatialReference = spatialReference;
point3.PutCoords(record.BoundingBox.Maxx, record.BoundingBox.Miny);
IPointCollection pointCollection;
pointCollection = new ESRI.ArcGIS.Geometry.PolygonClass();
object x = Type.Missing;
object y = Type.Missing;
pointCollection.AddPoint(point, ref x, ref y);
pointCollection.AddPoint(point1, ref x, ref y);
pointCollection.AddPoint(point2, ref x, ref y);
pointCollection.AddPoint(point3, ref x, ref y);
PolygonElementClass element = new PolygonElementClass();
element.Symbol = simpleFillSymbol;
element.SpatialReference = spatialReference;
element.Geometry.SpatialReference = spatialReference;
element.Geometry = (IGeometry)pointCollection;
element.Geometry.Project(mxDoc.ActiveView.Extent.SpatialReference);
//add the graphics element to the map
IGraphicsContainer graphicsContainer;
graphicsContainer = (IGraphicsContainer)mxDoc.FocusMap;
if (deleteelements) {
graphicsContainer.DeleteAllElements();
}
graphicsContainer.AddElement(element, 0);
if (refreshview) {
mxDoc.ActiveView.Extent = element.Geometry.Envelope;
mxDoc.ActiveView.Refresh();
}
}
/// <summary>
/// create a WGS1984 geographic coordinate system.
/// In this case, the underlying data provided by the service is in WGS1984.
/// </summary>
/// <returns></returns>
private ISpatialReference CreateGeographicSpatialReference()
{
ISpatialReferenceFactory spatialRefFatcory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem geoCoordSys;
geoCoordSys = spatialRefFatcory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
geoCoordSys.SetFalseOriginAndUnits(-180.0, -180.0, 5000000.0);
geoCoordSys.SetZFalseOriginAndUnits(0.0, 100000.0);
geoCoordSys.SetMFalseOriginAndUnits(0.0, 100000.0);
return geoCoordSys as ISpatialReference;
}
private Envelope GetCurrentExtent()
{
Envelope currentExtent;
IEnvelope extent = ArcMap.Document.ActiveView.Extent;
if (extent == null) return null;
ISpatialReference CurrentMapSpatialReference = extent.SpatialReference;
if (CurrentMapSpatialReference == null)
{
//MessageBox.Show("Spatial Reference is Not Defined");
currentExtent = null;
}
if (CurrentMapSpatialReference is IUnknownCoordinateSystem)
{
// unknown cooridnate system
MessageBox.Show("Unknown Coordinate System\n\nNo extent will be used for search");
currentExtent = null;
}
else if (CurrentMapSpatialReference is IGeographicCoordinateSystem)
{
// already in geographical coordinate system, reuse coordinate values
currentExtent = new Envelope(extent.XMin, extent.YMin, extent.XMax, extent.YMax);
}
else if (CurrentMapSpatialReference is IProjectedCoordinateSystem)
{
// project to geographical coordinate system
ISpatialReferenceFactory srFactory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem gcs = srFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
gcs.SetFalseOriginAndUnits(-180, -90, 1000000);
extent.Project(gcs);
currentExtent = new Envelope(extent.XMin, extent.YMin, extent.XMax, extent.YMax);
}
else
{
MessageBox.Show("Unsupported Coordinate System\n\nNo extent will be used for search");
currentExtent = null;
}
return currentExtent;
}
//将任意坐标系统转换为自定义Albers大地坐标（米）
public static IPoint GeoToGra(IPoint point)
{
IPoint pt = new PointClass();
pt.PutCoords(point.X, point.Y);
ISpatialReferenceFactory2 pFact = new SpatialReferenceEnvironmentClass();
//定义地理坐标，由输入的对象决定，也可以自己定义，参考： esriSRGeoCSType
IGeographicCoordinateSystem pGCS = new GeographicCoordinateSystemClass();
pGCS = pFact.CreateGeographicCoordinateSystem(point.SpatialReference.FactoryCode);
//自定义投影方式
IProjectedCoordinateSystem pProjectedCS = new ProjectedCoordinateSystemClass();
IProjectedCoordinateSystemEdit pProjectedCSEdit = pProjectedCS as IProjectedCoordinateSystemEdit;
//定义投影方式，参考： esriSRProjectionType
IProjection pProjection = new ProjectionClass();
pProjection = pFact.CreateProjection((int)esriSRProjectionType.esriSRProjection_Albers);
//定义投影单位，参考：esriSRUnitType
ILinearUnit pUnit = new LinearUnitClass();
pUnit = pFact.CreateUnit((int)esriSRUnitType.esriSRUnit_Meter) as ILinearUnit;
//定义其他参数，参考：esriSRParameterType
IParameter[] pParm = new IParameter[6];
pParm[0] = pFact.CreateParameter((int)esriSRParameterType.esriSRParameter_FalseEasting);
pParm[0].Value = 0;
pParm[1] = pFact.CreateParameter((int)esriSRParameterType.esriSRParameter_FalseNorthing);
pParm[1].Value = 0;
pParm[2] = pFact.CreateParameter((int)esriSRParameterType.esriSRParameter_CentralMeridian);
pParm[2].Value = 110;
pParm[3] = pFact.CreateParameter((int)esriSRParameterType.esriSRParameter_StandardParallel1);
pParm[3].Value = 25;
pParm[4] = pFact.CreateParameter((int)esriSRParameterType.esriSRParameter_StandardParallel2);
pParm[4].Value = 47;
pParm[5] = pFact.CreateParameter((int)esriSRParameterType.esriSRParameter_LatitudeOfOrigin);
pParm[5].Value = 0;
//设置投影相关信息
object name = "User_Defined_Albers";
object alias = "Albers";
object abbreviation = "Albers";
object remarks = "User_Defined_Albers is the projection";
object usage = "";
object gcs = pGCS;
object projectedUnit = pUnit;
object projection = pProjection;
object parameters = pParm;
pProjectedCSEdit.Define(ref name, ref alias, ref abbreviation, ref remarks, ref usage, ref gcs, ref projectedUnit, ref projection, ref parameters);
//获取自定义空间参考
ISpatialReference pSpatialRef = pProjectedCS as ISpatialReference;
IGeometry pGeometry = (IGeometry)pt;
pGeometry.SpatialReference = pGCS as ISpatialReference;
//重投影处理
pGeometry.Project(pSpatialRef);
return pt;
}
private void MakeCoordinateSystems()
{
//Create a spatial reference environment and get theISpatialReferenceFactory2 interface
ISpatialReferenceFactory2 spatRefFact = new SpatialReferenceEnvironmentClass();
//Create a geographic coordinate system and get the IGeographicCoordinateSystem interface
m_GeographicCoordinateSystem = spatRefFact.CreateGeographicCoordinateSystem((int) esriSRGeoCSType.esriSRGeoCS_WGS1984);
//Create a projected coordinate system and get the IProjectedCoordinateSystem interface
m_ProjectedCoordinateSystem = spatRefFact.CreateProjectedCoordinateSystem((int)esriSRProjCSType.esriSRProjCS_World_Mollweide);
//Set the map controls spatial reference property
m_MapControl.SpatialReference = m_ProjectedCoordinateSystem;
}
/// <summary>
/// 坐标系转换-----WGS84转投影坐标系
/// </summary>
/// <param name="point">转换前的IPoint</param>
/// <returns>转换后的IPoint</returns>
public static IPoint getProjectPoint(IPoint point)
{
try
{
ISpatialReferenceFactory pSRF = new SpatialReferenceEnvironmentClass();
point.SpatialReference = pSRF.CreateGeographicCoordinateSystem((int)(esriSRGeoCSType.esriSRGeoCS_WGS1984));
point.Project(pSRF.CreateProjectedCoordinateSystem((int)(esriSRProjCSType.esriSRProjCS_WGS1984UTM_31N)));
}
catch //(Exception e)
{
// MessageBox.Show(e.ToString());
}
return point;
}
public static IPoint JWD2XY(IPoint pJWDPoint, int gcsType, int pcsType)
{
try
{
ISpatialReferenceFactory factory = new SpatialReferenceEnvironmentClass();
pJWDPoint.SpatialReference = factory.CreateGeographicCoordinateSystem(gcsType);
pJWDPoint.Project(factory.CreateProjectedCoordinateSystem(pcsType));
return pJWDPoint;
}
catch
{
return null;
}
}
public static void initEditing()
{
if (AAState.PerformUpdates == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_3a"));
return;
}
// wire events
if (reInitExt() == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_3b"));
AAState.PerformUpdates = false;
}
if (AAState._editor.EditWorkspace != null)
{
if (AAState._editor.EditWorkspace.Type == esriWorkspaceType.esriFileSystemWorkspace)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_3c"));
AAState.PerformUpdates = false;
}
}
if (AAState.PerformUpdates)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_3d"));
if (Debug().ToUpper() == "TRUE")
{
AAState._filePath = Globals.getDebugPath();
if (AAState._filePath != "")
{
AAState._sw = Globals.createTextFile(AAState._filePath, FileMode.Create);
}
Globals.LogLocations = AAState._filePath;
}
else
{
AAState._sw = null;
Globals.LogLocations = "";
}
// Get user Info
reInitExt();
//obtain rotation calculator
AAState.rCalc = new RotationCalculator(ArcMap.Application);
//Create WGS_84 SR
ISpatialReferenceFactory srFactory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem gcs = srFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
_sr1 = gcs;
_editEvents.OnChangeFeature += FeatureChange;
_editEvents.OnCreateFeature += FeatureCreate;
_editEvents2.BeforeStopOperation += StopOperation; // SG Jan 2013
}
else
{
AAState.PerformUpdates = false;
_editEvents.OnChangeFeature -= FeatureChange;
_editEvents.OnCreateFeature -= FeatureCreate;
_editEvents2.BeforeStopOperation -= StopOperation; // SG Jan 2013
}
ArcMap.Application.StatusBar.set_Message(0, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorDone_3a"));
}
public void Startup(ref object initializationData)
{
try
{
m_application = initializationData as IApplication;
if (m_application == null)
return;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
m_wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
//Get the editor.
UID editorUid = new UID();
editorUid.Value = "esriEditor.Editor";
m_editor3 = m_application.FindExtensionByCLSID(editorUid) as IEditor3;
m_editEvents2 = m_editor3 as IEditEvents2_Event;
m_editEvents = m_editor3 as IEditEvents_Event;
m_editEvents.OnCreateFeature += new IEditEvents_OnCreateFeatureEventHandler(m_editEvents_OnCreateFeature);
m_editEvents.OnChangeFeature += new IEditEvents_OnChangeFeatureEventHandler(m_editEvents_OnChangeFeature);
m_editEvents.OnDeleteFeature += new IEditEvents_OnDeleteFeatureEventHandler(m_editEvents_OnDeleteFeature);
m_editEvents.OnStartEditing += new IEditEvents_OnStartEditingEventHandler(m_editEvents_OnStartEditing);
resourceManager = new ResourceManager("ESRI.ArcGIS.OSM.Editor.OSMFeatureInspectorStrings", this.GetType().Assembly);
_osmUtility = new OSMClassExtension.OSMUtility();
// retrtrieve osm editor specfic information
m_editorConfigurationSettings = OSMGPFactory.ReadOSMEditorSettings();
}
catch { }
}
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 UpdateMessages(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr, ESRI.ArcGIS.Geodatabase.IGPMessages Messages)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
// check for a valid download url
IGPParameter downloadURLParameter = paramvalues.get_Element(in_downloadURLNumber) as IGPParameter;
if (downloadURLParameter.HasBeenValidated == false)
{
IGPString downloadURLGPString = downloadURLParameter.Value as IGPString;
if (downloadURLGPString != null)
{
if (String.IsNullOrEmpty(downloadURLGPString.Value) == false)
{
try
{
Uri downloadURI = new Uri(downloadURLGPString.Value);
// attempt a download request from the given URL to get the server capabilities
m_osmAPICapabilities = CheckValidServerURL(downloadURLGPString.Value);
// if we can construct a valid URI class then we are accepting the value and store it in the user settings as well
if (m_editorConfigurationSettings != null)
{
if (m_editorConfigurationSettings.ContainsKey("osmbaseurl"))
{
m_editorConfigurationSettings["osmbaseurl"] = downloadURLGPString.Value;
}
else
{
m_editorConfigurationSettings.Add("osmbaseurl", downloadURLGPString.Value);
}
OSMGPFactory.StoreOSMEditorSettings(m_editorConfigurationSettings);
}
}
catch (Exception ex)
{
StringBuilder errorMessage = new StringBuilder();
errorMessage.AppendLine(resourceManager.GetString("GPTools_OSMGPDownload_invaliddownloadurl"));
errorMessage.AppendLine(ex.Message);
Messages.ReplaceError(in_downloadURLNumber, -3, errorMessage.ToString());
m_osmAPICapabilities = null;
}
}
}
}
if (m_osmAPICapabilities == null)
{
return;
}
// check for extent
IGPParameter downloadExtentParameter = paramvalues.get_Element(in_downloadExtentNumber) as IGPParameter;
if (downloadExtentParameter.HasBeenValidated == false)
{
IGPValue downloadExtent = gpUtilities3.UnpackGPValue(downloadExtentParameter);
if (downloadExtent != null)
{
esriGPExtentEnum gpExtent;
IEnvelope downloadEnvelope = gpUtilities3.GetExtent(downloadExtent, out gpExtent);
if (downloadEnvelope == null)
return;
if (downloadEnvelope.IsEmpty == true)
return;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass() as ISpatialReferenceFactory;
ISpatialReference wgs84 = spatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984) as ISpatialReference;
downloadEnvelope.Project(wgs84);
Marshal.ReleaseComObject(wgs84);
Marshal.ReleaseComObject(spatialReferenceFactory);
IArea downloadArea = downloadEnvelope as IArea;
double maximumAcceptableOSMArea = Convert.ToDouble(m_osmAPICapabilities.area.maximum, new CultureInfo("en-US"));
if (downloadArea.Area > maximumAcceptableOSMArea)
{
Messages.ReplaceError(in_downloadExtentNumber, -3, resourceManager.GetString("GPTools_OSMGPDownload_exceedDownloadROI"));
}
}
}
// check for valid geodatabase path
// if the user is pointing to a valid directory on disk, flag it as an error
IGPParameter targetDatasetParameter = paramvalues.get_Element(out_targetDatasetNumber) as IGPParameter;
IGPValue targetDatasetGPValue = gpUtilities3.UnpackGPValue(targetDatasetParameter);
if (targetDatasetGPValue == null)
{
Messages.ReplaceError(out_targetDatasetNumber, -98, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), targetDatasetParameter.Name));
}
if (targetDatasetGPValue.IsEmpty() == false)
{
if (System.IO.Directory.Exists(targetDatasetGPValue.GetAsText()))
{
Messages.ReplaceError(out_targetDatasetNumber, -4, resourceManager.GetString("GPTools_OSMGPDownload_directory_is_not_target_dataset"));
}
}
// check one of the output feature classes for version compatibility
IGPParameter pointFeatureClassParameter = paramvalues.get_Element(out_osmPointsNumber) as IGPParameter;
IDEFeatureClass pointDEFeatureClass = gpUtilities3.UnpackGPValue(pointFeatureClassParameter) as IDEFeatureClass;
if (pointDEFeatureClass != null)
{
if (((IGPValue)pointDEFeatureClass).IsEmpty() == false)
{
if (gpUtilities3.Exists((IGPValue)pointDEFeatureClass))
{
IFeatureClass ptfc = gpUtilities3.Open(gpUtilities3.UnpackGPValue(pointFeatureClassParameter)) as IFeatureClass;
IPropertySet osmExtensionPropertySet = ptfc.ExtensionProperties;
if (osmExtensionPropertySet == null)
{
Messages.ReplaceError(out_targetDatasetNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmPointsNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmLinesNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmPolygonsNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
}
else
{
try
{
int extensionVersion = Convert.ToInt32(osmExtensionPropertySet.GetProperty("VERSION"));
object names;
object values;
osmExtensionPropertySet.GetAllProperties(out names, out values);
if (extensionVersion != OSMClassExtensionManager.Version)
{
Messages.ReplaceError(out_targetDatasetNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), extensionVersion, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmPointsNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), extensionVersion, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmLinesNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), extensionVersion, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmPolygonsNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), extensionVersion, OSMClassExtensionManager.Version));
}
}
catch
{
Messages.ReplaceError(out_targetDatasetNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmPointsNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmLinesNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
Messages.ReplaceError(out_osmPolygonsNumber, -5, string.Format(resourceManager.GetString("GPTools_IncompatibleExtensionVersion"), 1, OSMClassExtensionManager.Version));
}
}
}
}
}
}
private IPoint GCStoPRJ(IPoint pPoint, int GCSType, int PRJType)
{
ISpatialReferenceFactory pSRF = new SpatialReferenceEnvironmentClass();
pPoint.SpatialReference = pSRF.CreateGeographicCoordinateSystem(GCSType);
pPoint.Project(pSRF.CreateProjectedCoordinateSystem(PRJType));
return pPoint;
}