private async void OnMapViewInitialized(MapViewEventArgs args)
{
CycloMediaLayer.ResetYears();
LayersRemovedEvent.Subscribe(OnLayerRemoved);
DrawCompleteEvent.Subscribe(OnDrawComplete);
if (ContainsCycloMediaLayer(args.MapView))
{
await AddLayersAsync(args.MapView);
}
Settings settings = Settings.Instance;
Login login = Login.Instance;
settings.PropertyChanged += OnSettingsPropertyChanged;
login.PropertyChanged += OnLoginPropertyChanged;
if (settings.CycloramaViewerCoordinateSystem != null)
{
await CoordSystemUtils.CheckInAreaCycloramaSpatialReferenceAsync();
}
if (!_agreement.Value)
{
PropertySheet.ShowDialog("streetSmartArcGISPro_optionsPropertySheet", "streetSmartArcGISPro_agreementPage");
}
}
public List <XElement> GetByBbox(IEnvelope envelope, CycloMediaLayer cycloMediaLayer)
{
string epsgCode = cycloMediaLayer.EpsgCode;
epsgCode = SpatialReferences.Instance.ToKnownSrsName(epsgCode);
List <XElement> result;
if (cycloMediaLayer is WfsLayer)
{
var wfsLayer = cycloMediaLayer as WfsLayer;
string remoteLocation = string.Format(_ci, WfsBboxRequest, wfsLayer.Url, wfsLayer.Version, epsgCode,
envelope.XMin, envelope.YMin, envelope.XMax, envelope.YMax,
epsgCode, wfsLayer.TypeName);
var xml = (string)GetRequest(remoteLocation, GetXmlCallback, XmlConfig);
result = ParseXml(xml, (Namespaces.GmlNs + "featureMember"));
}
else
{
string postItem = string.Format(_ci, cycloMediaLayer.WfsRequest, epsgCode, envelope.XMin, envelope.YMin,
envelope.XMax,
envelope.YMax, DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:00-00:00"));
var xml = (string)PostRequest(RecordingService, GetXmlCallback, postItem, XmlConfig);
result = ParseXml(xml, (Namespaces.GmlNs + "featureMembers"));
}
return(result);
}
// =========================================================================
// Interface functions
// =========================================================================
public List <XElement> GetByImageId(string imageId, CycloMediaLayer cycloMediaLayer)
{
string epsgCode = cycloMediaLayer.EpsgCode;
epsgCode = SpatialReferences.Instance.ToKnownSrsName(epsgCode);
string remoteLocation = string.Format(RecordingRequest, RecordingService, epsgCode, imageId);
var xml = (string)GetRequest(remoteLocation, GetXmlCallback, XmlConfig);
return(ParseXml(xml, (Namespaces.GmlNs + "featureMembers")));
}
private void OnLayerRemoved(CycloMediaLayer cycloMediaLayer)
{
if (CycloMediaGroupLayer != null)
{
if (!CycloMediaGroupLayer.ContainsLayers)
{
RemoveLayers();
}
}
}
private void CycloMediaLayerRemoved(CycloMediaLayer layer)
{
try
{
if (layer != null)
{
Checked = (layer.Name != LayerName) && Checked;
}
}
catch (Exception ex)
{
_logClient.Error("GsHistoricalDataLayer.CycloMediaLayerRemoved", ex.Message, ex);
Trace.WriteLine(ex.Message, "GsHistoricalDataLayers.CycloMediaRemoved");
}
}
private void CycloMediaLayerAdded(CycloMediaLayer layer)
{
try
{
if (layer != null)
{
Checked = (layer.Name == LayerName) || Checked;
}
}
catch (Exception ex)
{
_logClient.Error("GsRecentDataLayer.CycloMediaLayterAdded", ex.Message, ex);
Trace.WriteLine(ex.Message, "GsRecentDataLayer.CycloMediaLayerAdded");
}
}
protected override void OnUpdate()
{
try
{
GsExtension extension = GsExtension.GetExtension();
IApplication application = ArcMap.Application;
Enabled = ((application != null) && extension.Enabled);
if (application != null)
{
var document = application.Document as IMxDocument;
if (document != null)
{
var tocDisplayView = document.CurrentContentsView as TOCDisplayView;
if (tocDisplayView != null)
{
var selectedItem = tocDisplayView.SelectedItem as ILayer;
if (selectedItem != null)
{
_vectorLayer = VectorLayer.GetLayer(selectedItem);
CycloMediaGroupLayer cycloMediaGroupLayer = extension.CycloMediaGroupLayer;
_cycloMediaLayer = (cycloMediaGroupLayer == null) ? null : cycloMediaGroupLayer.GetLayer(selectedItem);
if (_cycloMediaLayer != null)
{
Checked = _cycloMediaLayer.IsVisibleInGlobespotter;
Enabled = _cycloMediaLayer.IsVisible;
}
if (_vectorLayer != null)
{
Checked = _vectorLayer.IsVisibleInGlobespotter;
Enabled = _vectorLayer.IsVisible;
}
}
}
}
}
}
catch (Exception ex)
{
_logClient.Error("GsShowInCyclorama.OnUpdate", ex.Message, ex);
Trace.WriteLine(ex.Message, "GsShowInCyclorama.OnUpdate");
}
}
/// <summary>
/// This function calculates the imageId for location on the screen
/// </summary>
/// <param name="arg">The mouse arguments</param>
/// <param name="layer">The layer where the point has been found</param>
/// <returns>The imageId of the point</returns>
private static string GetImageIdFromPoint(MouseEventArgs arg, out CycloMediaLayer layer)
{
layer = null;
string result = string.Empty;
GsExtension extension = GsExtension.GetExtension();
if (extension.InsideScale())
{
int x = arg.X;
int y = arg.Y;
CycloMediaGroupLayer cycloMediaGroupLayer = extension.CycloMediaGroupLayer;
result = cycloMediaGroupLayer.GetFeatureFromPoint(x, y, out layer);
}
return(result);
}
private void UpdateRecordingLayer(CycloMediaLayer layer)
{
if (layer.IsVisible)
{
_api.SetRecordingLocationsVisible(layer.IsVisibleInGlobespotter);
_api.SetUseDateRange(layer.UseDateRange);
if (layer.UseDateRange)
{
DateTime dateFrom = _historicalRecordings.DateFrom;
DateTime dateTo = _historicalRecordings.DateTo;
_api.SetDateFrom($"{dateFrom.Year}-{dateFrom.Month}-{dateFrom.Day}");
_api.SetDateTo($"{dateTo.Year}-{dateTo.Month}-{dateTo.Day}");
}
}
else if (!_layers.Aggregate(false, (current, cyclLayer) => (cyclLayer.IsVisible || current)))
{
_api.SetRecordingLocationsVisible(false);
}
}
protected override async void OnUpdate()
{
MapView mapView = MapView.Active;
IReadOnlyList <Layer> layers = mapView?.GetSelectedLayers();
if (layers?.Count == 1)
{
Layer layer = layers[0];
GlobeSpotter globeSpotter = GlobeSpotter.Current;
CycloMediaGroupLayer groupLayer = globeSpotter.CycloMediaGroupLayer;
_cycloMediaLayer = groupLayer?.GetLayer(layer);
VectorLayerList vectorLayerList = await globeSpotter.GetVectorLayerListAsync();
_vectorLayer = vectorLayerList.GetLayer(layer);
if (_cycloMediaLayer != null)
{
IsChecked = _cycloMediaLayer.IsVisibleInGlobespotter;
Enabled = _cycloMediaLayer.IsVisible;
}
else if (_vectorLayer != null)
{
IsChecked = _vectorLayer.IsVisibleInGlobespotter;
Enabled = _vectorLayer.IsVisible;
}
else
{
IsChecked = false;
Enabled = false;
}
}
else
{
Enabled = false;
}
base.OnUpdate();
}
private void OpenDocument()
{
try
{
CycloMediaLayer.ResetYears();
var arcEvents = ArcUtils.ActiveViewEvents;
if (arcEvents != null)
{
arcEvents.ItemDeleted += ItemDeleted;
arcEvents.AfterDraw += Afterdraw;
}
if (OpenDocumentEvent != null)
{
OpenDocumentEvent();
}
if (ContainsCycloMediaLayer())
{
AddLayers();
}
CycloMediaLayer.LayerRemoveEvent += OnLayerRemoved;
GsRecentDataLayer.AddToMenu();
GsHistoricalDataLayer.AddToMenu();
GsCycloMediaOptions.AddToMenu();
GsMeasurementDetail.AddToMenu();
FrmMeasurement.Close();
FrmIdentify.Close();
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message, "GsExtension.OpenDocument");
}
}
/*
* protected async override void OnUpdate()
* {
* Cursor nowCursor = Cursor;
* Cursor = _containsFeatures ? Cursors.Arrow : _thisCursor;
*
* if (nowCursor != Cursor)
* {
* await FrameworkApplication.SetCurrentToolAsync("esri_mapping_exploreTool");
* await FrameworkApplication.SetCurrentToolAsync("globeSpotterArcGISPro_openImageTool");
* }
*
* base.OnUpdate();
* }
*
* protected override async void OnToolMouseMove(MapViewMouseEventArgs e)
* {
* await QueuedTask.Run(() =>
* {
* var constants = ConstantsRecordingLayer.Instance;
* double size = constants.SizeLayer;
* double halfSize = size / 2;
* MapView activeView = MapView.Active;
*
* WinPoint clientPoint = e.ClientPoint;
* WinPoint pointScreen = activeView.ClientToScreen(clientPoint);
* double x = pointScreen.X;
* double y = pointScreen.Y;
* WinPoint minPoint = new WinPoint(x - halfSize, y - halfSize);
* WinPoint maxPoint = new WinPoint(x + halfSize, y + halfSize);
* MapPoint minPoint1 = activeView.ScreenToMap(minPoint);
* MapPoint maxPoint1 = activeView.ScreenToMap(maxPoint);
* Envelope envelope = EnvelopeBuilder.CreateEnvelope(minPoint1, maxPoint1, minPoint1.SpatialReference);
* var features = MapView.Active?.GetFeatures(envelope);
* _containsFeatures = (features != null) && (features.Count >= 1);
* });
*
* base.OnToolMouseMove(e);
* }
*/
protected override Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
return(QueuedTask.Run(() =>
{
MapPoint point = geometry as MapPoint;
MapView activeView = MapView.Active;
if (point != null && activeView != null)
{
var constants = ConstantsRecordingLayer.Instance;
double size = constants.SizeLayer;
double halfSize = size / 2;
SpatialReference pointSpatialReference = point.SpatialReference;
var pointScreen = activeView.MapToScreen(point);
double x = pointScreen.X;
double y = pointScreen.Y;
WinPoint pointScreenMin = new WinPoint(x - halfSize, y - halfSize);
WinPoint pointScreenMax = new WinPoint(x + halfSize, y + halfSize);
var pointMapMin = activeView.ScreenToMap(pointScreenMin);
var pointMapMax = activeView.ScreenToMap(pointScreenMax);
Envelope envelope = EnvelopeBuilder.CreateEnvelope(pointMapMin, pointMapMax, pointSpatialReference);
var features = activeView.GetFeatures(envelope);
GlobeSpotter globeSpotter = GlobeSpotter.Current;
CycloMediaGroupLayer groupLayer = globeSpotter?.CycloMediaGroupLayer;
if (features != null && groupLayer != null)
{
_nearest = Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl);
if (_nearest)
{
Settings settings = Settings.Instance;
MySpatialReference cycloCoordSystem = settings.CycloramaViewerCoordinateSystem;
if (cycloCoordSystem != null)
{
SpatialReference cycloSpatialReference = cycloCoordSystem.ArcGisSpatialReference ??
cycloCoordSystem.CreateArcGisSpatialReferenceAsync().Result;
if (pointSpatialReference.Wkid != cycloSpatialReference.Wkid)
{
ProjectionTransformation projection = ProjectionTransformation.Create(pointSpatialReference,
cycloSpatialReference);
point = GeometryEngine.Instance.ProjectEx(point, projection) as MapPoint;
}
if (point != null)
{
CultureInfo ci = CultureInfo.InvariantCulture;
_location = string.Format(ci, "{0},{1}", point.X, point.Y);
if (!globeSpotter.InsideScale())
{
double minimumScale = ConstantsRecordingLayer.Instance.MinimumScale;
double scale = minimumScale / 2;
Camera camera = new Camera(point.X, point.Y, scale, 0.0);
MapView.Active?.ZoomTo(camera);
}
}
}
}
else
{
foreach (var feature in features)
{
Layer layer = feature.Key;
CycloMediaLayer cycloMediaLayer = groupLayer.GetLayer(layer);
if (cycloMediaLayer != null)
{
foreach (long uid in feature.Value)
{
Recording recording = cycloMediaLayer.GetRecordingAsync(uid).Result;
if (recording.IsAuthorized == null || (bool)recording.IsAuthorized)
{
_location = recording.ImageId;
}
}
}
}
}
}
}
return true;
}));
}
