protected RecordingLayer()
{
IsChecked = false;
ModuleStreetSmart streetSmart = ModuleStreetSmart.Current;
CycloMediaGroupLayer groupLayer = streetSmart.CycloMediaGroupLayer;
_constantsRecordingLayer = ConstantsRecordingLayer.Instance;
if (groupLayer != null)
{
foreach (var layer in groupLayer)
{
if (layer.IsRemoved)
{
IsChecked = layer.Name != _constantsRecordingLayer.RecordingLayerName && IsChecked;
}
else
{
IsChecked = layer.Name == _constantsRecordingLayer.RecordingLayerName || IsChecked;
}
}
groupLayer.PropertyChanged += OnLayerPropertyChanged;
}
}
protected StreetSmart()
{
ProjectClosedEvent.Subscribe(OnProjectClosed);
_currentDispatcher = Dispatcher.CurrentDispatcher;
_inRestart = false;
_inClose = false;
_apiKey = ApiKey.Instance;
_settings = Settings.Instance;
_constants = ConstantsViewer.Instance;
_login = Login.Instance;
_login.PropertyChanged += OnLoginPropertyChanged;
_configuration = FileConfiguration.Instance;
_configuration.PropertyChanged += OnConfigurationPropertyChanged;
_openNearest = new List <string>();
_crossCheck = null;
_lastSpatialReference = null;
_configurationPropertyChanged = new List <string>();
GetVectorLayerListAsync();
ModulestreetSmart streetSmartModule = ModulestreetSmart.Current;
_viewerList = streetSmartModule.ViewerList;
_measurementList = streetSmartModule.MeasurementList;
_cycloMediaGroupLayer = streetSmartModule.CycloMediaGroupLayer;
Initialize();
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
string imageId = value as string;
var image = new Bitmap(80, 20);
if (parameter != null)
{
string strParameter = parameter.ToString();
float fontSize = float.Parse(strParameter);
ModulestreetSmart streetSmart = ModulestreetSmart.Current;
ViewerList viewerList = streetSmart.ViewerList;
Viewer thisViewer = viewerList.GetImageId(imageId);
Color color = thisViewer?.Color ?? Color.Gray;
Brush brush = new SolidBrush(Color.FromArgb(255, color));
using (var sf = new StringFormat())
{
using (var ga = Graphics.FromImage(image))
{
ga.Clear(Color.Transparent);
Rectangle rectangle = new Rectangle(2, 2, 76, 16);
ga.DrawRectangle(new Pen(Brushes.Black, 1), rectangle);
ga.FillRectangle(brush, rectangle);
sf.Alignment = StringAlignment.Center;
Font font = new Font("Arial", fontSize);
ga.DrawString(imageId, font, Brushes.Black, rectangle, sf);
}
}
}
return(image.ToBitmapSource());
}
private async void OnImageIdChanged(object sender, TextChangedEventArgs e)
{
TextBox textBox = sender as TextBox;
string imageId = textBox?.Text ?? string.Empty;
PaneImageIdSearch paneImageIdSearch = ((dynamic)DataContext);
paneImageIdSearch.ImageInfo.Clear();
if (imageId.Length == 8)
{
ModulestreetSmart streetSmart = ModulestreetSmart.Current;
CycloMediaGroupLayer groupLayer = streetSmart.CycloMediaGroupLayer;
foreach (var layer in groupLayer)
{
SpatialReference spatialReference = await layer.GetSpatialReferenceAsync();
string epsgCode = $"EPSG:{spatialReference.Wkid}";
FeatureCollection featureCollection = FeatureCollection.Load(imageId, epsgCode);
if (featureCollection.NumberOfFeatures >= 1)
{
foreach (Recording recording in featureCollection.FeatureMembers.Recordings)
{
paneImageIdSearch.ImageInfo.Add(recording);
}
}
}
}
}
public VectorLayerList()
{
_updateHeight = false;
_currentToolId = string.Empty;
ModuleStreetSmart modulestreetSmart = ModuleStreetSmart.Current;
_measurementList = modulestreetSmart.MeasurementList;
_cycloMediaGroupLayer = modulestreetSmart.CycloMediaGroupLayer;
EditTool = EditTools.NoEditTool;
}
protected override async void OnClick()
{
OnUpdate();
ModuleStreetSmart streetSmart = ModuleStreetSmart.Current;
if (IsChecked)
{
await streetSmart.RemoveLayerAsync(_constantsRecordingLayer.RecordingLayerName);
}
else
{
await streetSmart.AddLayersAsync(_constantsRecordingLayer.RecordingLayerName);
}
}
public VectorLayer(FeatureLayer layer, VectorLayerList vectorLayerList)
{
_vectorLayerList = vectorLayerList;
Layer = layer;
_settings = Settings.Instance;
Overlay = null;
_selection = null;
_updateMeasurements = false;
StreetSmartModule streetSmart = StreetSmartModule.Current;
_viewerList = streetSmart.ViewerList;
_measurementList = streetSmart.MeasurementList;
_ci = CultureInfo.InvariantCulture;
}
private async Task AddLayerAsync(Layer layer)
{
FeatureLayer featureLayer = layer as FeatureLayer;
ModuleStreetSmart streetSmart = ModuleStreetSmart.Current;
CycloMediaGroupLayer cycloGrouplayer = streetSmart?.CycloMediaGroupLayer;
if (featureLayer != null && cycloGrouplayer != null && !cycloGrouplayer.IsKnownName(featureLayer.Name))
{
if (!this.Aggregate(false, (current, vecLayer) => vecLayer.Layer == layer || current))
{
var vectorLayer = new VectorLayer(featureLayer, this);
bool initialized = await vectorLayer.InitializeEventsAsync();
if (initialized)
{
Add(vectorLayer);
vectorLayer.PropertyChanged += OnVectorLayerPropertyChanged;
LayerAdded?.Invoke(vectorLayer);
}
}
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
string result = string.Empty;
string imageId = value as string;
ModulestreetSmart streetSmart = ModulestreetSmart.Current;
CycloMediaGroupLayer groupLayer = streetSmart.CycloMediaGroupLayer;
AutoResetEvent taskWaiter = new AutoResetEvent(false);
const int timeOut = 3000;
Task.Run(async() =>
{
Recording recording = await groupLayer.GetRecordingAsync(imageId);
double stdX = recording == null ? 0 : (recording.LongitudePrecision ?? 0);
double stdY = recording == null ? 0 : (recording.LatitudePrecision ?? 0);
double stdZ = recording == null ? 0 : (recording.HeightPrecision ?? 0);
result = $"{stdX:0.00} {stdY:0.00} {stdZ:0.00}";
taskWaiter.Set();
});
taskWaiter.WaitOne(timeOut);
return(result);
}
public StreetSmart()
{
InitializeComponent();
_settings = FileSettings.Instance;
_constants = ConstantsViewer.Instance;
_login = FileLogin.Instance;
_configuration = FileConfiguration.Instance;
_openNearest = new List <string>();
_crossCheck = null;
_lastSpatialReference = null;
_layers = new List <CycloMediaLayer>();
_startOpenNearest = false;
GetVectorLayerListAsync();
ModulestreetSmart streetSmartModule = ModulestreetSmart.Current;
_viewerList = streetSmartModule.ViewerList;
_measurementList = streetSmartModule.MeasurementList;
_cycloMediaGroupLayer = streetSmartModule.CycloMediaGroupLayer;
}
private async void GetVectorLayerListAsync()
{
ModulestreetSmart streetSmartModule = ModulestreetSmart.Current;
_vectorLayerList = await streetSmartModule.GetVectorLayerListAsync();
}
public async Task CreateMeasurement(ArcGISGeometryType geometryType)
{
if (Api != null)
{
MeasurementGeometryType measurementGeometryType = MeasurementGeometryType.Unknown;
switch (geometryType)
{
case ArcGISGeometryType.Point:
if (GlobeSpotterConfiguration.MeasurePoint)
{
measurementGeometryType = MeasurementGeometryType.Point;
}
break;
case ArcGISGeometryType.Polyline:
if (GlobeSpotterConfiguration.MeasureLine)
{
measurementGeometryType = MeasurementGeometryType.LineString;
}
break;
case ArcGISGeometryType.Polygon:
if (GlobeSpotterConfiguration.MeasurePolygon)
{
measurementGeometryType = MeasurementGeometryType.Polygon;
}
break;
}
if (measurementGeometryType != MeasurementGeometryType.Unknown)
{
ModulestreetSmart streetSmartModule = ModulestreetSmart.Current;
ViewerList viewerList = streetSmartModule.ViewerList;
IPanoramaViewer panoramaViewer = viewerList.ActiveViewer;
if (panoramaViewer != null)
{
if (Count == 0)
{
Measurement measurement = new Measurement(null, null, DrawPoint, Api)
{
ObjectId = _lastObjectId,
VectorLayer = _lastVectorLayer
};
Add(new Guid().ToString(), measurement);
measurement.Open();
}
//if (_lastSketch)
//{
Measurement measurement2 = this.ElementAt(0).Value;
measurement2.VectorLayer = _lastVectorLayer;
measurement2.SetSketch();
//}
IMeasurementOptions options = MeasurementOptionsFactory.Create(measurementGeometryType);
Api.StartMeasurementMode(panoramaViewer, options);
}
}
}
}
/*
* 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("StreetSmartArcGISPro_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);
ModuleStreetSmart streetSmart = ModuleStreetSmart.Current;
CycloMediaGroupLayer groupLayer = streetSmart?.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 (!streetSmart.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;
}));
}
