// =========================================================================
// Constructor
// =========================================================================
public FrmMeasurement()
{
InitializeComponent();
_ci = CultureInfo.InvariantCulture;
_frmGlobespotter = null;
SetOpenClose(false);
_entityId = 0;
_pointId = 0;
_measurementPoint = null;
_imageIdColor = new Dictionary <string, Color>();
_bitmapImageId = new List <string>();
_idBitmap = new List <Bitmap>();
_commandItem = null;
_measurementPointS = null;
_lastPointIdUpd = null;
_config = Config.Instance;
_goToClicked = false;
Font font = SystemFonts.MenuFont;
lvObservations.Font = (Font)font.Clone();
plButtons.Font = (Font)font.Clone();
plMeasurementDetails.Font = (Font)font.Clone();
txtPosition.Font = (Font)font.Clone();
txtPositionStd.Font = (Font)font.Clone();
txtNumber.Font = (Font)font.Clone();
}
public void OpenNearestImage(ApiMeasurementPoint apiPoint)
{
double x = apiPoint.x;
double y = apiPoint.y;
double z = apiPoint.z;
string coordinate = string.Format(_ci, "{0:#0.#},{1:#0.#},{2:#0.#}", x, y, z);
_api?.OpenNearestImage(coordinate, 1);
}
private void OpenPoint(int entityId, int pointId, FrmGlobespotter frmGlobespotter, MeasurementPoint measurementPoint)
{
_frmGlobespotter = frmGlobespotter;
if ((_entityId != entityId) || (_pointId != pointId))
{
UpdatePoint(_frmGlobespotter, measurementPoint, entityId, pointId, true);
AddObservations(entityId, pointId);
}
_measurementPoint = measurementPoint;
SetOpenClose(true);
}
public void LookAtMeasurement(ApiMeasurementPoint apiPoint)
{
double x = apiPoint.x;
double y = apiPoint.y;
double z = apiPoint.z;
int[] viewerIds = _api?.GetViewerIDs() ?? new int[0];
foreach (var viewerId in viewerIds)
{
_api?.LookAtCoordinate((uint)viewerId, x, y, z);
}
}
public async Task UpdatePointAsync(int pointId, ApiMeasurementPoint apiMeasurementPoint, int index)
{
if (!ContainsKey(pointId))
{
AddPoint(pointId);
}
if (ContainsKey(pointId))
{
MeasurementPoint measurementPoint = this[pointId];
await measurementPoint.UpdatePointAsync(apiMeasurementPoint, index);
}
}
public void LookAtMe()
{
ApiPoint point = _measurementPoint.ApiPoint;
Point3D coord = new Point3D(point.x, point.y, point.z);
DockPaneGlobeSpotter globeSpotter = DockPaneGlobeSpotter.Show();
if (globeSpotter != null)
{
globeSpotter.LookAt = coord;
globeSpotter.Replace = true;
globeSpotter.Nearest = false;
globeSpotter.Location = ImageId;
}
}
public async Task MeasurementPointUpdatedAsync(int entityId, int pointId)
{
if (GlobeSpotterConfiguration.MeasurePermissions)
{
_screenPointAdded = !_mapPointAdded;
PointMeasurementData measurementData = Api.GetMeasurementPointData(entityId, pointId);
ApiMeasurementPoint measurementPoint = measurementData.measurementPoint;
Measurement measurement = Get(entityId);
if (measurement != null)
{
int index = (int)Api?.GetMeasurementPointIndex(entityId, pointId);
await measurement.UpdatePointAsync(pointId, measurementPoint, index);
}
_screenPointAdded = false;
}
}
private void ClearForm(bool values)
{
foreach (var idBitmap in _idBitmap)
{
idBitmap.Dispose();
}
lvObservations.Items.Clear();
_bitmapImageId.Clear();
_idBitmap.Clear();
if (values)
{
_entityId = 0;
_pointId = 0;
_measurementPoint = null;
_measurementPointS = null;
SetOpenClose(false);
}
}
private void RemovePoint(int entityId, int pointId)
{
if ((entityId == _entityId) && (_pointId == pointId))
{
ClearForm(false);
DrawObservations();
txtNumber.Text = string.Empty;
txtPosition.Text = string.Empty;
txtPositionStd.Text = string.Empty;
RelO.Image = null;
Measurement measurement = Measurement.Get(entityId);
if (measurement.Count >= 1)
{
MeasurementPointS pointS = measurement.GetPointByNr(measurement.Count - 1);
pointId = pointS.PointId;
List <MeasurementObservation> observations = _frmGlobespotter.GetObservationPoints(entityId, pointId);
MeasurementPoint measurementPoint = _frmGlobespotter.GetMeasurementData(entityId, pointId);
foreach (var measurementObservation in observations)
{
if (measurementObservation != null)
{
AddObs(null, _frmGlobespotter, entityId, pointId, measurementObservation);
}
}
if (measurementPoint != null)
{
UpdatePoint(_frmGlobespotter, measurementPoint, entityId, pointId, true);
}
}
else
{
ClearForm(true);
}
}
}
private void UpdatePoint(FrmGlobespotter frmGlobespotter, MeasurementPoint point, int entityId, int pointId, bool alwaysOpen)
{
if (_entityId != entityId)
{
_lastPointIdUpd = null;
}
if (_lastPointIdUpd == null)
{
_lastPointIdUpd = pointId;
}
else if (pointId > _lastPointIdUpd)
{
_lastPointIdUpd = pointId;
}
if ((pointId == _lastPointIdUpd) || (_entityId != entityId) || alwaysOpen)
{
_frmGlobespotter = frmGlobespotter;
bool smartClick = _config.SmartClickEnabled;
if (!smartClick)
{
AddObservations(entityId, pointId);
}
if ((entityId != _entityId) || _goToClicked ||
(((pointId != _pointId) && (!smartClick)) || ((_lastPointIdUpd > _pointId) && smartClick)))
{
ClearForm(false);
_entityId = entityId;
_pointId = pointId;
DrawObservations();
}
_measurementPoint =
((double.IsNaN(point.x)) && (double.IsNaN(point.y)) && (double.IsNaN(point.z))) ? null : point;
Measurement measurement = Measurement.Get(_entityId);
_measurementPointS = measurement[_pointId];
var circle = new Bitmap(18, 18);
using (var ga = Graphics.FromImage(circle))
{
ga.Clear(Color.Transparent);
Brush color = point.reliableEstimate
? Brushes.Green
: ((lvObservations.Items.Count == 0) ? Brushes.Gray : Brushes.Red);
ga.DrawEllipse(new Pen(color, 1), 2, 2, 14, 14);
ga.FillEllipse(color, 2, 2, 14, 14);
}
txtNumber.Text = _measurementPointS.M.ToString(_ci);
string x = (double.IsNaN(point.x)) ? "---" : point.x.ToString("#0.00", _ci);
string y = (double.IsNaN(point.y)) ? "---" : point.y.ToString("#0.00", _ci);
string z = (double.IsNaN(point.z)) ? "---" : point.z.ToString("#0.00", _ci);
txtPosition.Text = string.Format(_ci, "{0}, {1}, {2}", x, y, z);
string stdx = (double.IsNaN(point.Std_x)) ? "---" : point.Std_x.ToString("#0.00", _ci);
string stdy = (double.IsNaN(point.Std_y)) ? "---" : point.Std_y.ToString("#0.00", _ci);
string stdz = (double.IsNaN(point.Std_z)) ? "---" : point.Std_z.ToString("#0.00", _ci);
txtPositionStd.Text = string.Format(_ci, "{0}, {1}, {2}", stdx, stdy, stdz);
RelO.Image = circle;
SetOpenClose(_opened);
}
}
// =========================================================================
// Private Functions
// =========================================================================
private void AddObs(Bitmap bitmap, FrmGlobespotter frmGlobespotter, int entityId, int pointId,
MeasurementObservation observation)
{
if (_entityId != entityId)
{
_lastPointIdUpd = null;
}
string imageId = observation.imageId;
GsExtension extension = GsExtension.GetExtension();
CycloMediaGroupLayer groupLayer = extension.CycloMediaGroupLayer;
IMappedFeature locationInfo = groupLayer.GetLocationInfo(imageId);
var recordingInfo = locationInfo as Recording;
double stdX = (recordingInfo == null) ? 0 : (recordingInfo.LongitudePrecision ?? 0);
double stdY = (recordingInfo == null) ? 0 : (recordingInfo.LatitudePrecision ?? 0);
double stdZ = (recordingInfo == null) ? 0 : (recordingInfo.HeightPrecision ?? 0);
string std = string.Format("{0:0.00} {1:0.00} {2:0.00}", stdX, stdY, stdZ);
if ((_entityId != entityId) || (_pointId != pointId))
{
ClearForm(false);
_entityId = entityId;
_pointId = pointId;
_measurementPoint = null;
_measurementPointS = null;
txtNumber.Text = string.Empty;
txtPosition.Text = string.Empty;
txtPositionStd.Text = string.Empty;
RelO.Image = null;
SetOpenClose(false);
}
Measurement measurement = Measurement.Get(_entityId);
if (measurement != null)
{
_measurementPointS = measurement[_pointId];
_measurementPointS.UpdateObservation(imageId, observation.x, observation.y, observation.z);
txtNumber.Text = _measurementPointS.M.ToString(_ci);
if (measurement.IsPointMeasurement)
{
SetOpenClose(true);
if (_commandItem == null)
{
_commandItem = ArcMap.Application.CurrentTool;
ArcUtils.SetToolActiveInToolBar("esriEditor.EditTool");
}
}
}
if (bitmap != null)
{
_bitmapImageId.Add(imageId);
_idBitmap.Add(bitmap);
}
bool add = true;
foreach (ListViewItem item in lvObservations.Items)
{
var obs = item.Tag as MeasurementObservation;
if (obs != null)
{
if (obs.imageId == imageId)
{
add = false;
}
}
}
if (add)
{
_frmGlobespotter = frmGlobespotter;
var items = new[] { imageId, std, "X" };
var listViewItem = new ListViewItem(items)
{
Tag = observation
};
lvObservations.Items.Add(listViewItem);
DrawObservations();
RedrawObservationList();
}
}
public static void UpdateMeasurementPoint(FrmGlobespotter frmGlobespotter, MeasurementPoint measurementPoint, int entityId, int pointId)
{
Instance.UpdatePoint(frmGlobespotter, measurementPoint, entityId, pointId, false);
}
public static void OpenMeasurementPoint(int entityId, int pointId, FrmGlobespotter frmGlobespotter, MeasurementPoint measurementPoint)
{
Instance.OpenPoint(entityId, pointId, frmGlobespotter, measurementPoint);
}
public void UpdatePoint(PointMeasurementData measurementData, int index)
{
_index = index;
bool notCreated = NotCreated;
MeasurementPointS measurementPoint = measurementData.measurementPoint;
double x = measurementPoint.x;
double y = measurementPoint.y;
double z = measurementPoint.z;
_point = ArcUtils.GsToMapPoint(x, y, z);
IActiveView activeView = ArcUtils.ActiveView;
var display = activeView.ScreenDisplay;
IDisplayTransformation dispTrans = display.DisplayTransformation;
double size = dispTrans.FromPoints(PointSize);
double xmin = x - size;
double xmax = x + size;
double ymin = y - size;
double ymax = y + size;
_oldEnvelope = _envelope;
foreach (var observation in _observations)
{
double[] obs = observation.Value;
if (obs.Length >= 2)
{
double xdir = (_point.X - obs[0]) / 2;
double ydir = (_point.Y - obs[1]) / 2;
xmin = Math.Min(xmin, _point.X + xdir);
ymin = Math.Min(ymin, _point.Y + ydir);
xmax = Math.Max(xmax, obs[0]);
ymax = Math.Max(ymax, obs[1]);
}
}
_envelope = new EnvelopeClass {
XMin = xmin, XMax = xmax, YMin = ymin, YMax = ymax
};
var avEvents = ArcUtils.ActiveViewEvents;
if (avEvents != null)
{
if (!notCreated)
{
avEvents.AfterDraw -= AvEventsAfterDraw;
}
avEvents.AfterDraw += AvEventsAfterDraw;
}
IEditor3 editor = ArcUtils.Editor;
var sketch = editor as IEditSketch3;
if ((sketch != null) && (_measurement != null))
{
IGeometry geometry = sketch.Geometry;
int nrPoints;
var ptColl = _measurement.ToPointCollection(geometry, out nrPoints);
if ((ptColl != null) && _measurement.IsSketch)
{
if (_intId <= nrPoints)
{
IPoint pointC = ptColl.Point[_intId - 1];
if (!IsSame(pointC))
{
ISketchOperation2 sketchOp = new SketchOperationClass();
sketchOp.Start(editor);
IPoint point = new PointClass {
X = _point.X, Y = _point.Y, Z = _point.Z, M = _index, ZAware = sketch.ZAware
};
if (_measurement.IsPointMeasurement)
{
sketch.Geometry = point;
}
else
{
ptColl.UpdatePoint((_intId - 1), point);
if ((_intId == 1) && ((nrPoints + 1) == ptColl.PointCount))
{
ptColl.UpdatePoint((ptColl.PointCount - 1), point);
}
sketch.Geometry = ptColl as IGeometry;
}
geometry = sketch.Geometry;
if (geometry != null)
{
sketchOp.Finish(geometry.Envelope, esriSketchOperationType.esriSketchOperationGeneral, geometry);
}
}
}
else
{
ISketchOperation2 sketchOp = new SketchOperationClass();
sketchOp.Start(editor);
IPoint point = new PointClass {
X = _point.X, Y = _point.Y, Z = _point.Z, M = _index, ZAware = sketch.ZAware
};
int nrPoints2 = ptColl.PointCount;
switch (nrPoints2)
{
case 0:
ptColl.AddPoint(point);
if (geometry is IPolygon4)
{
ptColl.AddPoint(point);
}
break;
case 1:
ptColl.AddPoint(point);
break;
default:
if (_intId <= (nrPoints + 1))
{
object point1 = ((_intId - 1) == nrPoints2) ? Type.Missing : (_intId - 1);
object point2 = Type.Missing;
ptColl.AddPoint(point, ref point1, ref point2);
}
break;
}
sketch.Geometry = ptColl as IGeometry;
geometry = sketch.Geometry;
if (geometry != null)
{
sketchOp.Finish(geometry.Envelope, esriSketchOperationType.esriSketchOperationGeneral, geometry);
}
}
}
else
{
if (geometry is IPoint)
{
if (geometry.IsEmpty)
{
if ((!double.IsNaN(_point.X)) && (!double.IsNaN(_point.Y)))
{
if (!_added)
{
IApplication application = ArcMap.Application;
ICommandItem tool = application.CurrentTool;
ICommand command = tool.Command;
if (!(command is IEditTool))
{
_added = true;
var editorZ = editor as IEditorZ;
double zOffset = 0.0;
if (editorZ != null)
{
zOffset = editorZ.ZOffset;
editorZ.ZOffset = _point.Z;
}
ISketchOperation2 sketchOp = new SketchOperationClass();
sketchOp.Start(editor);
IPoint point = new PointClass {
X = _point.X, Y = _point.Y, Z = _point.Z, M = _index, ZAware = sketch.ZAware
};
sketch.Geometry = point;
geometry = sketch.Geometry;
sketchOp.Finish(geometry.Envelope, esriSketchOperationType.esriSketchOperationGeneral, geometry);
sketch.FinishSketch();
if (editorZ != null)
{
editorZ.ZOffset = zOffset;
}
_added = false;
}
}
}
}
else
{
var pointC = geometry as IPoint;
if (!IsSame(pointC))
{
if ((!double.IsNaN(_point.X)) && (!double.IsNaN(_point.Y)))
{
ISketchOperation2 sketchOp = new SketchOperationClass();
sketchOp.Start(editor);
IPoint point = new PointClass {
X = _point.X, Y = _point.Y, Z = _point.Z, M = _index, ZAware = sketch.ZAware
};
sketch.Geometry = point;
geometry = sketch.Geometry;
sketchOp.Finish(geometry.Envelope, esriSketchOperationType.esriSketchOperationGeneral, geometry);
}
}
}
}
}
}
Update();
}
