annotations/Azaion.Annotator/Controls/MapMatcher.xaml.cs

using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using Azaion.Common;
using Azaion.Common.Database;
using Azaion.Common.DTO;
using Azaion.Common.DTO.Config;
using Azaion.Common.Extensions;
using Azaion.Common.Services;
using GMap.NET;
using GMap.NET.MapProviders;
using GMap.NET.WindowsPresentation;
using Microsoft.WindowsAPICodePack.Dialogs;

namespace Azaion.Annotator.Controls;

public partial class MapMatcher : UserControl
{
    private AppConfig _appConfig = null!;
    List<MediaFileInfo> _allMediaFiles = new();
    private Dictionary<int, Annotation> _annotations = new();
    private string _currentDir = null!;
    private IGpsMatcherService _gpsMatcherService = null!;

    public MapMatcher()
    {
        InitializeComponent();
    }

    public void Init(AppConfig appConfig, IGpsMatcherService gpsMatcherService)
    {
        _appConfig = appConfig;
        _gpsMatcherService = gpsMatcherService;
        GoogleMapProvider.Instance.ApiKey = appConfig.MapConfig.ApiKey;
        SatelliteMap.MapProvider = GMapProviders.GoogleSatelliteMap;
        SatelliteMap.Position = new PointLatLng(48.295985271707664, 37.14477539062501);
        SatelliteMap.MultiTouchEnabled = true;

        GpsFiles.MouseDoubleClick += async (sender, args) => { await OpenGpsLocation(GpsFiles.SelectedIndex); };
    }

    private async Task OpenGpsLocation(int gpsFilesIndex)
    {
        //var media = GpsFiles.Items[gpsFilesIndex] as MediaFileInfo;
        var ann = _annotations.GetValueOrDefault(gpsFilesIndex);
        if (ann == null)
            return;

        GpsImageEditor.Background = new ImageBrush
        {
            ImageSource = await Path.Combine(_currentDir, ann.Name).OpenImage()
        };
        if (ann.Lat != 0 && ann.Lon != 0)
            SatelliteMap.Position = new PointLatLng(ann.Lat, ann.Lon);
    }

    private void GpsFilesContextOpening(object sender, ContextMenuEventArgs e)
    {
        var listItem = sender as ListViewItem;
        GpsFilesContextMenu.DataContext = listItem!.DataContext;
    }

    private void OpenContainingFolder(object sender, RoutedEventArgs e)
    {
        var mediaFileInfo = (sender as MenuItem)?.DataContext as MediaFileInfo;
        if (mediaFileInfo == null)
            return;

        Process.Start("explorer.exe", "/select,\"" + mediaFileInfo.Path +"\"");
    }

    private async void OpenGpsTilesFolderClick(object sender, RoutedEventArgs e)
    {
        var dlg = new CommonOpenFileDialog
        {
            Title = "Open Video folder",
            IsFolderPicker = true,
            InitialDirectory = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory)
        };
        var dialogResult = dlg.ShowDialog();

        if (dialogResult != CommonFileDialogResult.Ok || string.IsNullOrEmpty(dlg.FileName))
            return;

        TbGpsMapFolder.Text = dlg.FileName;
        _currentDir = dlg.FileName;
        var dir = new DirectoryInfo(dlg.FileName);
        var mediaFiles = dir.GetFiles(_appConfig.AnnotationConfig.ImageFormats.ToArray())
            .Select(x => new MediaFileInfo
            {
                Name = x.Name,
                Path = x.FullName,
                MediaType = MediaTypes.Image
            }).ToList();

        _allMediaFiles = mediaFiles;
        GpsFiles.ItemsSource = new ObservableCollection<MediaFileInfo>(_allMediaFiles);

        _annotations = mediaFiles.Select((x, i) => (i, new Annotation
        {
            Name = x.Name,
            OriginalMediaName = x.Name
        })).ToDictionary(x => x.i, x => x.Item2);

        var initialLat = double.Parse(TbLat.Text);
        var initialLon = double.Parse(TbLon.Text);

        await _gpsMatcherService.RunGpsMatching(dir.FullName, initialLat, initialLon, async res => await SetMarker(res));
    }

    private Task SetMarker(GpsMatchResult result)
    {
        Dispatcher.Invoke(() =>
        {
            var marker = new GMapMarker(new PointLatLng(result.Latitude, result.Longitude));
            var ann = _annotations[result.Index];
            marker.Shape = new CircleVisual(marker, System.Windows.Media.Brushes.Blue)
            {
                Text = ann.Name
            };
            SatelliteMap.Markers.Add(marker);
            ann.Lat = result.Latitude;
            ann.Lon = result.Longitude;
            SatelliteMap.Position = new PointLatLng(result.Latitude, result.Longitude);
            SatelliteMap.ZoomAndCenterMarkers(null);
        });
        return Task.CompletedTask;
    }

    private async Task SetFromCsv(List<MediaFileInfo> mediaFiles)
    {

        var csvResults = GpsMatchResult.ReadFromCsv(Constants.CSV_PATH);
        var csvDict = csvResults
            .Where(x => x.MatchType == "stitched")
            .ToDictionary(x => x.Index);
        foreach (var ann in _annotations)
        {
            var csvRes = csvDict.GetValueOrDefault(ann.Key);
            if (csvRes == null)
                continue;
            await SetMarker(csvRes);
        }
    }

    private async void TestGps(object sender, RoutedEventArgs e)
    {
        if (string.IsNullOrEmpty(TbGpsMapFolder.Text))
            return;

        var initialLat = double.Parse(TbLat.Text);
        var initialLon = double.Parse(TbLon.Text);
        await _gpsMatcherService.RunGpsMatching(TbGpsMapFolder.Text, initialLat, initialLon, async res => await SetMarker(res));
    }
}