Prepare Pro 1.0.14 release

Add contextual fiducial point downloads
Add mapped Pro fiducial point layer
2026-10-04 20:23:59 +02:00 · 2026-10-04 19:28:31 +02:00 · 2026-10-04 15:18:42 +02:00
6 changed files with 610 additions and 33 deletions
@@ -96,6 +96,16 @@
                        <small>Particelle e geometrie verdi di file e progetti</small>
                    </span>
                </label>
+                @if (CanUse(AppFeatures.FiducialPoints))
+                {
+                    <label class="map-layer-option">
+                        <input type="checkbox" @bind="ShowFiducialPoints" @bind:after="ApplyFiducialVisibility" />
+                        <span>
+                            <strong>Punti fiduciali</strong>
+                            <small>PF georiferiti caricati nella ricerca Pro</small>
+                        </span>
+                    </label>
+                }
                <section class="layer-tree-section">
                    <header>
                        <strong>Ordine livelli e oggetti</strong>
@@ -253,21 +263,41 @@
                                @(FiducialBusy ? "Ricerca..." : "Cerca Punti Fiduciali")
                            </button>

+                            <label class="toggle-line">
+                                <input type="checkbox" @bind="KeepPreviousFiducialPoints" @bind:after="ApplyKeepPreviousFiducials" />
+                                <span>Mantieni i PF dei fogli già caricati</span>
+                            </label>
+                            <small class="field-help">Ogni foglio resta un sottogruppo separato nel pannello Layer, da cui puoi nasconderlo o rimuoverlo.</small>
+
+                            <label class="toggle-line">
+                                <input type="checkbox" @bind="ShowFiducialPoints" @bind:after="ApplyFiducialVisibility" />
+                                <span>Mostra i PF sulla mappa</span>
+                            </label>
+                            <label>
+                                Colore PF
+                                <input type="color" @bind="FiducialColor" @bind:after="ApplyFiducialColor" />
+                            </label>
+
                            @if (!string.IsNullOrWhiteSpace(FiducialMessage))
                            {
                                <div class="catalog-progress"><span>@FiducialMessage</span></div>
                            }

-                            @if (FiducialPoints.Count > 0)
+                            @if (MappedFiducialPoints.Count > 0)
                            {
                                <section class="panel-section">
-                                    <h2>Punti trovati (@FiducialPoints.Count)</h2>
+                                    <h2>Punti cartografici (@MappedFiducialPoints.Count)</h2>
+                                    <button class="secondary-command" @onclick="FitFiducialPoints">Inquadra tutti i PF</button>
                                    <div class="fiducial-list">
-                                        @foreach (var point in FiducialPoints)
+                                        @foreach (var point in MappedFiducialPoints)
                                        {
                                            <article class="fiducial-item">
                                                <strong>@point.Identifier</strong>
-                                                <button class="secondary-command" @onclick="() => DownloadFiducialMonograph(point)">Scarica PDF monografia</button>
+                                                <small>Nord/X: @FormatCoordinate(point.CadastralNorth) · Est/Y: @FormatCoordinate(point.CadastralEast)</small>
+                                                @if (!string.IsNullOrWhiteSpace(point.MonographUrl))
+                                                {
+                                                    <button class="secondary-command" @onclick="() => DownloadFiducialMonograph(point.MonographUrl)">Scarica PDF monografia</button>
+                                                }
                                            </article>
                                        }
                                    </div>
@@ -275,8 +305,8 @@
                            }

                            <div class="service-note">
-                                <strong>Fonte ufficiale Agenzia delle Entrate</strong>
-                                <p>L'elenco e i PDF arrivano dal servizio pubblico delle monografie. Il layer sulla mappa sarà abilitato soltanto quando sono disponibili coordinate geografiche trasformate e verificabili.</p>
+                                <strong>Monografie ufficiali, posizione sperimentale</strong>
+                                <p>Elenco e PDF provengono dall'Agenzia delle Entrate; il posizionamento sperimentale usa il servizio cartografico GloboGIS. Le coordinate sono un ausilio: verificale prima di qualsiasi uso topografico o professionale.</p>
                            </div>
                        }
                    </section>
@@ -830,6 +860,7 @@
    private string SelectedFiducialMunicipalityCode { get; set; } = string.Empty;
    private string SelectedFiducialSheet { get; set; } = string.Empty;
    private string FiducialMessage { get; set; } = string.Empty;
+    private string FiducialColor { get; set; } = "#dc2626";
    private string Status { get; set; } = "online";
    private string SelectedBaseLayer { get; set; } = "satellite";
    private string GoogleMapsApiKey { get; set; } = string.Empty;
@@ -847,6 +878,8 @@
    private bool GpsOverlayCollapsed { get; set; }
    private bool ShowGpsPosition { get; set; } = true;
    private bool ShowSelectedParcels { get; set; } = true;
+    private bool ShowFiducialPoints { get; set; } = true;
+    private bool KeepPreviousFiducialPoints { get; set; } = true;
    private bool ShowImportedData { get; set; } = true;
    private bool DrawToolsVisible { get; set; }
    private bool TrailEnabled { get; set; }
@@ -910,6 +943,7 @@
    private IReadOnlyList<FiducialAreaOption> FiducialMunicipalities { get; set; } = [];
    private IReadOnlyList<FiducialAreaOption> FiducialSheets { get; set; } = [];
    private IReadOnlyList<FiducialPointEntry> FiducialPoints { get; set; } = [];
+    private IReadOnlyList<MappedFiducialPoint> MappedFiducialPoints { get; set; } = [];
    private IReadOnlyList<MapProjectSummary> Projects { get; set; } = [];
    private IReadOnlyList<MapProjectVersion> ProjectVersions { get; set; } = [];
    private MapProjectSummary? SelectedProject => Projects.FirstOrDefault(item => item.Id == SelectedProjectId);
@@ -1257,6 +1291,7 @@
        FiducialMunicipalities = [];
        FiducialSheets = [];
        FiducialPoints = [];
+        MappedFiducialPoints = [];
        if (string.IsNullOrWhiteSpace(SelectedFiducialProvinceCode))
        {
            FiducialMessage = string.Empty;
@@ -1286,6 +1321,7 @@
        SelectedFiducialSheet = string.Empty;
        FiducialSheets = [];
        FiducialPoints = [];
+        MappedFiducialPoints = [];
        if (string.IsNullOrWhiteSpace(SelectedFiducialMunicipalityCode))
        {
            FiducialMessage = string.Empty;
@@ -1313,42 +1349,119 @@

    private async Task SearchFiducials()
    {
-        var province = FiducialProvinces.FirstOrDefault(item => item.Code == SelectedFiducialProvinceCode);
        var municipality = FiducialMunicipalities.FirstOrDefault(item => item.Code == SelectedFiducialMunicipalityCode);
-        if (province is null || municipality is null || string.IsNullOrWhiteSpace(SelectedFiducialSheet))
+        if (municipality is null || string.IsNullOrWhiteSpace(SelectedFiducialSheet))
        {
            return;
        }

+        await LoadFiducialsForSheetAsync(
+            municipality.Code,
+            SelectedFiducialSheet,
+            municipality.Name);
+    }
+
+    private async Task LoadFiducialsForSheetAsync(
+        string municipalityCode,
+        string sheet,
+        string? municipalityName = null)
+    {
        FiducialBusy = true;
        FiducialPoints = [];
-        FiducialMessage = "Interrogo il servizio ufficiale delle monografie...";
+        MappedFiducialPoints = [];
+        FiducialMessage = "Recupero monografie e coordinate dei PF...";
+        await InvokeAsync(StateHasChanged);
        try
        {
-            FiducialPoints = await FiducialPointService.GetFiducialsAsync(
-                province.Name,
-                municipality.Name,
-                municipality.Code,
-                SelectedFiducialSheet);
-            FiducialMessage = FiducialPoints.Count == 0
-                ? "Nessun Punto Fiduciale pubblicato per il foglio selezionato."
-                : $"Trovati {FiducialPoints.Count} Punti Fiduciali.";
+            string? monographError = null;
+            try
+            {
+                FiducialPoints = await FiducialPointService.GetFiducialsAsync(
+                    municipalityCode,
+                    sheet);
+            }
+            catch (Exception error)
+            {
+                monographError = error.GetBaseException().Message;
+            }
+
+            var mapped = await FiducialPointService.GetMappedFiducialsAsync(
+                municipalityCode,
+                sheet);
+            var monographs = FiducialPoints.ToDictionary(
+                item => item.Identifier,
+                item => item.MonographUrl,
+                StringComparer.OrdinalIgnoreCase);
+            var currentMappedPoints = monographs.Count == 0
+                ? mapped
+                : mapped.Where(point => monographs.ContainsKey(point.Identifier)).ToArray();
+            MappedFiducialPoints = currentMappedPoints
+                .Select(point => point with
+                {
+                    MonographUrl = monographs.GetValueOrDefault(point.Identifier, string.Empty)
+                })
+                .ToArray();
+
+            await JS.InvokeVoidAsync(
+                "lmeMap.setFiducialPoints",
+                MappedFiducialPoints,
+                FiducialColor,
+                ShowFiducialPoints,
+                KeepPreviousFiducialPoints,
+                municipalityCode,
+                sheet,
+                string.IsNullOrWhiteSpace(municipalityName) ? municipalityCode : municipalityName);
+            FiducialMessage = MappedFiducialPoints.Count == 0
+                ? "Nessun Punto Fiduciale georiferito per il foglio selezionato."
+                : $"Caricati {MappedFiducialPoints.Count} PF del foglio {NormalizeSheetLabel(sheet)} e {FiducialPoints.Count} monografie ufficiali."
+                    + (monographError is null ? string.Empty : " Le monografie non sono al momento raggiungibili.");
+            await JS.InvokeVoidAsync("lmeMap.showInfo", FiducialMessage);
        }
        catch (Exception error)
        {
            FiducialMessage = $"Ricerca PF non riuscita: {error.GetBaseException().Message}";
+            await JS.InvokeVoidAsync("lmeMap.showInfo", FiducialMessage);
        }
        finally
        {
            FiducialBusy = false;
+            await InvokeAsync(StateHasChanged);
        }
    }

-    private async Task DownloadFiducialMonograph(FiducialPointEntry point)
+    [JSInvokable]
+    public async Task DownloadFiducialsForMapSelection(
+        string municipalityCode,
+        string sheet,
+        string contextLabel)
+    {
+        if (!CanUse(AppFeatures.FiducialPoints))
+        {
+            await ShowProRequiredAsync();
+            return;
+        }
+
+        if (FiducialBusy)
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", "È già in corso una ricerca dei Punti Fiduciali.");
+            return;
+        }
+
+        await JS.InvokeVoidAsync("lmeMap.showInfo", $"Scarico i PF per {contextLabel}...");
+        var municipality = await CatalogService.FindMunicipalityAsync(municipalityCode);
+        await LoadFiducialsForSheetAsync(municipalityCode, sheet, municipality?.Name);
+    }
+
+    private static string NormalizeSheetLabel(string sheet) =>
+        int.TryParse(new string((sheet ?? string.Empty).Where(char.IsDigit).ToArray()), out var number)
+            ? number.ToString(System.Globalization.CultureInfo.InvariantCulture)
+            : sheet ?? string.Empty;
+
+    private async Task DownloadFiducialMonograph(string monographUrl)
    {
        try
        {
-            await Launcher.Default.OpenAsync(new Uri(point.MonographUrl));
+            await Launcher.Default.OpenAsync(new Uri(monographUrl));
        }
        catch (Exception error)
        {
@@ -1356,6 +1469,30 @@
        }
    }

+    private async Task ApplyFiducialVisibility()
+    {
+        SaveFlagPreferences();
+        await JS.InvokeVoidAsync("lmeMap.setFiducialPointsVisible", ShowFiducialPoints);
+    }
+
+    private async Task ApplyFiducialColor()
+    {
+        SaveFlagPreferences();
+        await JS.InvokeVoidAsync("lmeMap.setFiducialColor", FiducialColor);
+    }
+
+    private Task ApplyKeepPreviousFiducials()
+    {
+        SaveFlagPreferences();
+        return Task.CompletedTask;
+    }
+
+    private async Task FitFiducialPoints() =>
+        await JS.InvokeVoidAsync("lmeMap.fitFiducialPoints");
+
+    private static string FormatCoordinate(double? value) =>
+        value?.ToString("0.000", System.Globalization.CultureInfo.InvariantCulture) ?? "-";
+
    private async Task OnMunicipalityChanged(ChangeEventArgs args)
    {
        SelectedMunicipalityCode = args.Value?.ToString() ?? string.Empty;
@@ -2374,6 +2511,7 @@
    private Task ApplyEntitlementsToMapAsync() => JS.InvokeVoidAsync("lmeMap.setEntitlements", new
    {
        advancedGeometry = CanUse(AppFeatures.AdvancedGeometry),
+        fiducialPoints = CanUse(AppFeatures.FiducialPoints),
        maxDrawingObjects = Entitlements.HasProAccess ? (int?)null : EntitlementService.BaseDrawingObjectLimit,
        drawingLimitMessage = L("drawings.base.limit.reached")
    }).AsTask();
@@ -2581,6 +2719,9 @@
        DrawToolsVisible = GetFlagPreference("draw_tools_visible", false);
        ShowGpsPosition = GetFlagPreference("show_gps_position", true);
        ShowSelectedParcels = GetFlagPreference("show_selected_parcels", true);
+        ShowFiducialPoints = GetFlagPreference("show_fiducial_points", true);
+        KeepPreviousFiducialPoints = GetFlagPreference("keep_previous_fiducials", true);
+        FiducialColor = Preferences.Default.Get($"{FlagPreferencePrefix}fiducial_color", "#dc2626");
        TrailEnabled = GetFlagPreference("trail_enabled", false);
        ExportImported = GetFlagPreference("export_imported", true);
        ExportImportedSheets = GetFlagPreference("export_imported_sheets", true);
@@ -2621,6 +2762,9 @@
        SetFlagPreference("draw_tools_visible", DrawToolsVisible);
        SetFlagPreference("show_gps_position", ShowGpsPosition);
        SetFlagPreference("show_selected_parcels", ShowSelectedParcels);
+        SetFlagPreference("show_fiducial_points", ShowFiducialPoints);
+        SetFlagPreference("keep_previous_fiducials", KeepPreviousFiducialPoints);
+        Preferences.Default.Set($"{FlagPreferencePrefix}fiducial_color", FiducialColor);
        SetFlagPreference("trail_enabled", TrailEnabled);
        SetFlagPreference("export_imported", ExportImported);
        SetFlagPreference("export_imported_sheets", ExportImportedSheets);
@@ -2658,6 +2802,8 @@
        await JS.InvokeVoidAsync("lmeMap.setDrawToolsVisible", DrawToolsVisible);
        await JS.InvokeVoidAsync("lmeMap.setGpsPositionVisible", ShowGpsPosition);
        await JS.InvokeVoidAsync("lmeMap.setSelectedParcelsVisible", ShowSelectedParcels);
+        await JS.InvokeVoidAsync("lmeMap.setFiducialColor", FiducialColor);
+        await JS.InvokeVoidAsync("lmeMap.setFiducialPointsVisible", ShowFiducialPoints);
        await JS.InvokeVoidAsync("lmeMap.toggleTrail", TrailEnabled);

        foreach (var layer in CadastralLayers)
@@ -20,6 +20,7 @@
        <ImplicitUsings>enable</ImplicitUsings>
        <EnableDefaultCssItems>false</EnableDefaultCssItems>
        <Nullable>enable</Nullable>
+        <DefaultItemExcludes>$(DefaultItemExcludes);obj/**;bin/**;obj-api36*/**;artifacts/**</DefaultItemExcludes>

        <!-- Display name -->
        <ApplicationTitle>LME Mappe Catastali Pro</ApplicationTitle>
@@ -28,8 +29,8 @@
        <ApplicationId>it.liviomerola.lmemappecatastali.pro</ApplicationId>

        <!-- Versions -->
-        <ApplicationDisplayVersion>1.0.12</ApplicationDisplayVersion>
-        <ApplicationVersion>112</ApplicationVersion>
+        <ApplicationDisplayVersion>1.0.14</ApplicationDisplayVersion>
+        <ApplicationVersion>114</ApplicationVersion>
        <Version>$(ApplicationDisplayVersion)</Version>

        <!-- To develop, package, and publish an app to the Microsoft Store, see: https://aka.ms/MauiTemplateUnpackaged -->
@@ -61,6 +62,7 @@

    <PropertyGroup Condition="'$(Configuration)' == 'Release' and $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">
        <AndroidTargetSdkVersion>36</AndroidTargetSdkVersion>
+        <RuntimeIdentifiers>android-arm;android-arm64</RuntimeIdentifiers>
        <AndroidPackageFormat>aab</AndroidPackageFormat>
        <AndroidUseAapt2>true</AndroidUseAapt2>
        <AndroidCreatePackagePerAbi>false</AndroidCreatePackagePerAbi>
@@ -40,6 +40,14 @@ public sealed class CadastralCatalogService
            .ToArray();
    }

+    public async Task<MunicipalityOption?> FindMunicipalityAsync(string municipalityCode)
+    {
+        var code = (municipalityCode ?? string.Empty).Trim();
+        var municipalities = await GetAllMunicipalitiesAsync();
+        return municipalities.FirstOrDefault(item =>
+            string.Equals(item.Code, code, StringComparison.OrdinalIgnoreCase));
+    }
+
    public async Task<IReadOnlyList<string>> GetSheetsAsync(
        MunicipalityOption municipality,
        IProgress<CatalogProgress>? progress = null,
@@ -1,5 +1,6 @@
 using System.Net;
 using System.Net.Http.Headers;
+using System.Text.Json;
 using System.Text.RegularExpressions;

 namespace LMEMappeCatastaliApp.Services;
@@ -7,6 +8,7 @@ namespace LMEMappeCatastaliApp.Services;
 public sealed partial class FiducialPointService
 {
    private const string ServiceBaseUrl = "https://www1.agenziaentrate.gov.it/servizi/Monografie/";
+    private const string MappedPointsUrl = "https://cartografia.globogis.it/arcgis/rest/services/fiduciali/Punti_fiduciali/MapServer/2/query";
    private readonly HttpClient _httpClient = new() { Timeout = TimeSpan.FromSeconds(30) };

    public FiducialPointService()
@@ -63,7 +65,25 @@ public sealed partial class FiducialPointService
            new Dictionary<string, string> { ["foglio"] = normalizedSheet },
            cancellationToken);

-        return DownloadLinkRegex().Matches(html)
+        return ParseFiducialLinks(html);
+    }
+
+    public async Task<IReadOnlyList<FiducialPointEntry>> GetFiducialsAsync(
+        string municipalityCode,
+        string sheet,
+        CancellationToken cancellationToken = default)
+    {
+        var code = NormalizeCode(municipalityCode);
+        var normalizedSheet = NormalizeSheet(sheet);
+        var html = await GetHtmlAsync(
+            $"risultato.php?co={Uri.EscapeDataString(code)}&foglio={Uri.EscapeDataString(normalizedSheet)}",
+            cancellationToken);
+
+        return ParseFiducialLinks(html);
+    }
+
+    private static IReadOnlyList<FiducialPointEntry> ParseFiducialLinks(string html) =>
+        DownloadLinkRegex().Matches(html)
            .Select(match =>
            {
                var relativeUrl = WebUtility.HtmlDecode(match.Groups["url"].Value);
@@ -75,6 +95,117 @@ public sealed partial class FiducialPointService
            .DistinctBy(item => item.Identifier, StringComparer.OrdinalIgnoreCase)
            .OrderBy(item => item.Identifier, StringComparer.OrdinalIgnoreCase)
            .ToArray();
+
+    public async Task<IReadOnlyList<MappedFiducialPoint>> GetMappedFiducialsAsync(
+        string municipalityCode,
+        string sheet,
+        CancellationToken cancellationToken = default)
+    {
+        var municipality = NormalizeCode(municipalityCode);
+        if (!int.TryParse(NormalizeSheet(sheet), out var sheetNumber))
+        {
+            throw new ArgumentException("Numero di foglio non valido.", nameof(sheet));
+        }
+
+        var query = new Dictionary<string, string>
+        {
+            ["f"] = "json",
+            ["where"] = $"COMUNENAZI='{municipality}' AND FOGLIO={sheetNumber}",
+            ["outFields"] = "ETICHETTA,PARTICELLA,NORD,EST,ATTENDIBIL,QUOTA,DATAAGGIOR,IDORIGINE,URL_AGENZI,FOGLIO,ALLEGATO,FIDUCIALE",
+            ["returnGeometry"] = "true",
+            ["outSR"] = "3857",
+            ["resultRecordCount"] = "500"
+        };
+        var url = $"{MappedPointsUrl}?{string.Join('&', query.Select(item => $"{item.Key}={Uri.EscapeDataString(item.Value)}"))}";
+        using var response = await _httpClient.GetAsync(url, cancellationToken);
+        response.EnsureSuccessStatusCode();
+        await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+        using var document = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken);
+        if (document.RootElement.TryGetProperty("error", out var error))
+        {
+            throw new InvalidOperationException(error.TryGetProperty("message", out var message)
+                ? message.GetString()
+                : "Servizio cartografico PF non disponibile.");
+        }
+
+        if (!document.RootElement.TryGetProperty("features", out var features))
+        {
+            return [];
+        }
+
+        return features.EnumerateArray()
+            .Select(feature => ParseMappedPoint(feature, municipality))
+            .Where(point => point is not null)
+            .Cast<MappedFiducialPoint>()
+            .DistinctBy(point => point.Identifier, StringComparer.OrdinalIgnoreCase)
+            .OrderBy(point => point.Identifier, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+    }
+
+    private static MappedFiducialPoint? ParseMappedPoint(JsonElement feature, string municipalityCode)
+    {
+        if (!feature.TryGetProperty("geometry", out var geometry)
+            || !TryGetDouble(geometry, "x", out var x)
+            || !TryGetDouble(geometry, "y", out var y))
+        {
+            return null;
+        }
+
+        var attributes = feature.GetProperty("attributes");
+        var label = GetString(attributes, "ETICHETTA");
+        var identifier = FormatIdentifier(label);
+        if (identifier == label)
+        {
+            var sheet = GetString(attributes, "FOGLIO").PadLeft(4, '0');
+            var number = GetString(attributes, "FIDUCIALE").PadLeft(2, '0');
+            identifier = $"PF{number}/{sheet}/{municipalityCode}";
+        }
+
+        const double earthRadius = 6378137d;
+        var longitude = x / earthRadius * 180d / Math.PI;
+        var latitude = (2d * Math.Atan(Math.Exp(y / earthRadius)) - Math.PI / 2d) * 180d / Math.PI;
+        return new MappedFiducialPoint(
+            identifier,
+            latitude,
+            longitude,
+            GetNullableDouble(attributes, "NORD"),
+            GetNullableDouble(attributes, "EST"),
+            GetString(attributes, "ATTENDIBIL"),
+            GetNullableDouble(attributes, "QUOTA"),
+            GetString(attributes, "PARTICELLA"),
+            GetString(attributes, "DATAAGGIOR"),
+            GetString(attributes, "IDORIGINE"));
+    }
+
+    private static bool TryGetDouble(JsonElement element, string name, out double value)
+    {
+        value = 0;
+        return element.TryGetProperty(name, out var property)
+            && (property.ValueKind == JsonValueKind.Number
+                ? property.TryGetDouble(out value)
+                : double.TryParse(property.ToString(), System.Globalization.NumberStyles.Float,
+                    System.Globalization.CultureInfo.InvariantCulture, out value));
+    }
+
+    private static double? GetNullableDouble(JsonElement element, string name) =>
+        TryGetDouble(element, name, out var value) ? value : null;
+
+    private static string GetString(JsonElement element, string name) =>
+        element.TryGetProperty(name, out var property) && property.ValueKind != JsonValueKind.Null
+            ? property.ToString().Trim()
+            : string.Empty;
+
+    private static string NormalizeSheet(string sheet)
+    {
+        var digits = new string((sheet ?? string.Empty).Where(char.IsDigit).ToArray());
+        if (string.IsNullOrWhiteSpace(digits))
+        {
+            throw new ArgumentException("Numero di foglio non valido.", nameof(sheet));
+        }
+
+        return int.TryParse(digits, out var number)
+            ? number.ToString(System.Globalization.CultureInfo.InvariantCulture)
+            : digits;
    }

    private async Task<string> GetHtmlAsync(string relativeUrl, CancellationToken cancellationToken)
@@ -146,3 +277,16 @@ public sealed partial class FiducialPointService
 public sealed record FiducialAreaOption(string Code, string Name);

 public sealed record FiducialPointEntry(string Identifier, string MonographUrl);
+
+public sealed record MappedFiducialPoint(
+    string Identifier,
+    double Latitude,
+    double Longitude,
+    double? CadastralNorth,
+    double? CadastralEast,
+    string Reliability,
+    double? Elevation,
+    string Parcel,
+    string UpdatedAt,
+    string OriginId,
+    string MonographUrl = "");
@@ -1185,6 +1185,17 @@ input[type="checkbox"] {
    text-decoration: none;
 }

+.lme-geometry-toolbar a.lme-fiducial-download {
+    font-size: 12px !important;
+    letter-spacing: 0;
+}
+
+.lme-geometry-toolbar a.is-disabled {
+    color: #8b949e;
+    background: #eef1f3;
+    opacity: 0.72;
+}
+
 .leaflet-help {
    display: grid;
    gap: 14px;
@@ -5,8 +5,9 @@ const lmeState = {
    currentBaseName: "satellite",
    layerOrder: [
        "gpsPosition",
-        "drawings",
        "gpsTrail",
+        "fiducials",
+        "drawings",
        "gpsParcels",
        "selectedParcels",
        "importedSheets",
@@ -35,6 +36,7 @@ const lmeState = {
    drawingDeleteButton: null,
    drawingScopeMenu: null,
    geometryToolsControl: null,
+    fiducialDownloadButton: null,
    ignoreMapClickUntil: 0,
    activeDrawHandler: null,
    drawEventsBound: false,
@@ -50,6 +52,9 @@ const lmeState = {
    gpsTrail: null,
    selectedParcelsLayer: null,
    selectedParcelsVisible: true,
+    fiducials: null,
+    fiducialsVisible: true,
+    fiducialColor: "#dc2626",
    gpsParcelLayer: null,
    gpsTrailEnabled: false,
    gpsTrailPoints: [],
@@ -131,6 +136,10 @@ window.lmeMap = {
    closeCadastrePreview,
    clearSelectedParcels,
    setSelectedParcelsVisible,
+    setFiducialPoints,
+    setFiducialPointsVisible,
+    setFiducialColor,
+    fitFiducialPoints,
    clearMapElements,
    fitImported,
    clearImported,
@@ -217,6 +226,7 @@ function setLocalization(options = {}) {

 function setEntitlements(options = {}) {
    lmeState.entitlements = { ...lmeState.entitlements, ...options };
+    updateFiducialDownloadButton();
 }

 function requireProFeature(feature) {
@@ -310,6 +320,7 @@ function init(dotNetReference) {
    lmeState.importedMeasurements = L.layerGroup().addTo(lmeState.map);
    lmeState.drawingMeasurements = L.layerGroup().addTo(lmeState.map);
    lmeState.selectedParcelsLayer = L.featureGroup().addTo(lmeState.map);
+    lmeState.fiducials = L.featureGroup().addTo(lmeState.map);
    lmeState.gpsParcelLayer = L.featureGroup().addTo(lmeState.map);
    const navigationSheetPane = lmeState.map.createPane("navigationSheetPane");
    navigationSheetPane.style.zIndex = "465";
@@ -1339,6 +1350,7 @@ function managedLayerPanes() {
        gpsTrail: "gpsTrailPane",
        gpsParcels: "gpsParcelsPane",
        selectedParcels: "selectedParcelsPane",
+        fiducials: "fiducialsPane",
        importedSheets: "importedSheetPane",
        imported: "importedPane",
        cadastre: "cadastrePane"
@@ -1369,7 +1381,8 @@ function restoreLayerOrder() {
    try {
        const saved = JSON.parse(localStorage.getItem("lmeMapLayerOrder") || "null");
        if (Array.isArray(saved)) {
-            lmeState.layerOrder = saved;
+            const remaining = saved.filter(key => !["gpsPosition", "gpsTrail", "fiducials"].includes(key));
+            lmeState.layerOrder = ["gpsPosition", "gpsTrail", "fiducials", ...remaining];
        }
    } catch {
    }
@@ -1427,6 +1440,7 @@ function layerManagerCategories() {
        { key: "gpsTrail", label: "Traccia GPS", roots: [lmeState.gpsTrail].filter(Boolean) },
        { key: "gpsParcels", label: "Particella rilevata dal GPS", roots: [lmeState.gpsParcelLayer].filter(Boolean) },
        { key: "selectedParcels", label: "Particelle catastali evidenziate", roots: [lmeState.selectedParcelsLayer].filter(Boolean) },
+        { key: "fiducials", label: "Punti fiduciali", roots: [lmeState.fiducials].filter(Boolean), blocks: true },
        { key: "importedSheets", label: "Cornici e fogli importati", roots: [lmeState.importedSheets].filter(Boolean), blocks: true },
        { key: "imported", label: "Progetti e dati importati", roots: [lmeState.imported].filter(Boolean), blocks: true },
        { key: "cadastre", label: "Layer catastali AdE", roots: [lmeState.cadastre].filter(Boolean) }
@@ -1614,11 +1628,11 @@ async function renameManagedBlock(category, source, records) {

 function managedCategoryCanRemove(category, records) {
    return records.length > 0
-        && ["drawings", "imported", "importedSheets", "selectedParcels", "gpsParcels"].includes(category.key);
+        && ["drawings", "imported", "importedSheets", "selectedParcels", "gpsParcels", "fiducials"].includes(category.key);
 }

 function managedObjectCanRemove(record) {
-    return ["drawings", "imported", "importedSheets", "selectedParcels", "gpsParcels"].includes(record.categoryKey);
+    return ["drawings", "imported", "importedSheets", "selectedParcels", "gpsParcels", "fiducials"].includes(record.categoryKey);
 }

 function managedCategoryCanMove(categoryKey) {
@@ -1880,6 +1894,7 @@ function managedObjectDetails(layer) {
 }

 function refreshLayerManager() {
+    updateFiducialDownloadButton();
    const container = document.getElementById("layerManagerTree");
    if (!container || !lmeState.map) {
        return;
@@ -2015,8 +2030,12 @@ function renderLayerManagerBlock(category, source, records) {
    const blockName = managedBlockName(source, records);
    const rowActions = layerManagerRowActions(
        `<button type="button" class="layer-rename-button" aria-label="Rinomina gruppo" title="Rinomina">Rinomina</button>`,
-        `<button type="button" class="layer-membership-button" aria-label="Sposta gruppo in un altro gruppo" title="Sposta nel gruppo">Sposta nel gruppo</button>`,
-        `<button type="button" class="layer-remove-button" aria-label="Rimuovi gruppo dal progetto" title="Rimuovi dal progetto">Rimuovi</button>`);
+        managedCategoryCanMove(category.key)
+            ? `<button type="button" class="layer-membership-button" aria-label="Sposta gruppo in un altro gruppo" title="Sposta nel gruppo">Sposta nel gruppo</button>`
+            : "",
+        managedObjectCanRemove(records[0])
+            ? `<button type="button" class="layer-remove-button" aria-label="Rimuovi gruppo dal progetto" title="Rimuovi dal progetto">Rimuovi</button>`
+            : "");
    block.classList.add("layer-manager-with-actions");
    const blockLocked = records.length > 0 && records.every(record => Boolean(record.layer?.feature?.properties?._lmeLocked));
    block.innerHTML = `<summary>${layerExpandButton(block.open, blockName)}<button type="button" class="layer-drag-handle" aria-label="Trascina blocco">☰</button><input type="checkbox" ${visible ? "checked" : ""} aria-label="Mostra ${escapeHtml(blockName)}"><span class="layer-manager-title">${escapeHtml(blockName)}</span><button type="button" class="layer-inline-lock ${blockLocked ? "is-locked" : ""}" aria-label="${blockLocked ? "Sblocca" : "Blocca"} gruppo" title="${blockLocked ? "Sblocca" : "Blocca"}">${blockLocked ? "🔒" : "🔓"}</button>${rowActions}${layerManagerMoveButtons("blocco")}<span class="layer-manager-count">${records.length}</span></summary><div class="layer-manager-children"></div>`;
@@ -2037,12 +2056,12 @@ function renderLayerManagerBlock(category, source, records) {
        event.stopPropagation();
        renameManagedBlock(category, source, records);
    });
-    block.querySelector(".layer-remove-button").addEventListener("click", event => {
+    block.querySelector(".layer-remove-button")?.addEventListener("click", event => {
        event.preventDefault();
        event.stopPropagation();
        removeManagedRecords(records, `il gruppo '${blockName}'`);
    });
-    block.querySelector(".layer-membership-button").addEventListener("click", event => {
+    block.querySelector(".layer-membership-button")?.addEventListener("click", event => {
        event.preventDefault();
        event.stopPropagation();
        showMoveManagedRecordsDialog(records, `il gruppo '${blockName}'`);
@@ -2932,6 +2951,7 @@ function showLeafletToolbarHelp() {
            <div><dt>✓</dt><dd><strong>Controlla e ripara</strong>Verifica gli oggetti selezionati e prova a correggere coordinate duplicate o poligoni non validi. Esempio: usalo quando un contorno importato non si esporta o si riempie male; al termine compare un riepilogo.</dd></div>
            <div><dt>◉</dt><dd><strong>Crea foro</strong>Seleziona esattamente due poligoni: prima l'area esterna, poi quella interna. Esempio: sottrai il cortile dal perimetro di un fabbricato o un'isola esclusa da un'area di lavoro.</dd></div>
            <div><dt>⇄</dt><dd><strong>Confronta due confini</strong>Seleziona esattamente due poligoni. L'app crea il solo primo in rosso, il solo secondo in blu e la sovrapposizione in verde, mostrando le rispettive aree.</dd></div>
+            <div><dt>PF</dt><dd><strong>Scarica Punti Fiduciali</strong>Seleziona una particella o un foglio catastale; in alternativa usa la particella rilevata dal GPS. I PF vengono aggiunti come sottogruppo del relativo foglio.</dd></div>
            <div><dt>?</dt><dd><strong>Guida</strong>Riapre questa descrizione. I risultati di riparazione e confronto vengono mostrati anche in una finestra, così l'operazione non resta senza riscontro.</dd></div>
        </dl>
    </div>`);
@@ -2947,6 +2967,7 @@ function addGeometryToolsControl() {
                { icon: "✓", title: "Controlla e ripara geometrie", run: validateAndRepairSelected },
                { icon: "◉", title: "Crea foro da due poligoni", run: createHoleFromSelected },
                { icon: "⇄", title: "Confronta due confini", run: compareSelectedGeometries },
+                { icon: "PF", title: "Scarica PF del foglio o della particella", run: downloadFiducialsForMapContext, fiducials: true },
                { icon: "?", title: "Guida strumenti mappa", run: showLeafletToolbarHelp }
            ];
            actions.forEach(action => {
@@ -2956,6 +2977,10 @@ function addGeometryToolsControl() {
                button.setAttribute("role", "button");
                button.setAttribute("aria-label", action.title);
                button.textContent = action.icon;
+                if (action.fiducials) {
+                    button.classList.add("lme-fiducial-download");
+                    lmeState.fiducialDownloadButton = button;
+                }
                L.DomEvent.on(button, "click", event => { L.DomEvent.stop(event); action.run(); });
            });
            L.DomEvent.disableClickPropagation(container);
@@ -2963,6 +2988,88 @@ function addGeometryToolsControl() {
        }
    });
    lmeState.geometryToolsControl = new GeometryTools().addTo(lmeState.map);
+    updateFiducialDownloadButton();
+}
+
+function downloadFiducialsForMapContext() {
+    if (!requireProFeature("fiducialPoints")) return false;
+    const context = currentFiducialMapContext();
+    if (!context) {
+        setInfo("Seleziona una particella o un foglio catastale. Se il GPS è attivo puoi usare anche la particella corrente.");
+        return false;
+    }
+    if (!lmeState.dotNetReference) {
+        setInfo("Servizio PF non ancora pronto. Riprova tra poco.");
+        return false;
+    }
+    void lmeState.dotNetReference.invokeMethodAsync(
+        "DownloadFiducialsForMapSelection",
+        context.municipalityCode,
+        context.sheet,
+        context.label);
+    return true;
+}
+
+function currentFiducialMapContext() {
+    const selected = selectedManagedRecords();
+    if (!selected.length && lmeState.managerHighlightedObjectId) {
+        const highlighted = lmeState.managerRecords?.get?.(lmeState.managerHighlightedObjectId);
+        if (highlighted) selected.push(highlighted);
+    }
+    const preferred = selected.filter(record => ["selectedParcels", "gpsParcels", "importedSheets", "imported"].includes(record.categoryKey));
+    for (const record of preferred) {
+        const context = fiducialContextFromLayer(record.layer);
+        if (context) return context;
+    }
+
+    const gpsLayers = managedRecordsForCategory(layerManagerCategories().find(category => category.key === "gpsParcels"));
+    for (const record of gpsLayers) {
+        const context = fiducialContextFromLayer(record.layer);
+        if (context) return context;
+    }
+    return null;
+}
+
+function fiducialContextFromLayer(layer) {
+    const properties = layer?.feature?.properties || {};
+    const municipalityCode = String(properties._lmeMunicipalityCode || "").trim().toUpperCase();
+    const sheet = normalizeFiducialSheet(properties._lmeSheet || properties.foglio || properties.FOGLIO || properties.sheet || properties.SHEET);
+    if (/^[A-Z][0-9A-Z]{3}$/.test(municipalityCode) && sheet) {
+        return { municipalityCode, sheet, label: `Comune ${municipalityCode}, foglio ${sheet}` };
+    }
+
+    const references = [
+        properties.NATIONALCADASTRALREFERENCE,
+        properties.NATIONALCADASTRALZONINGREFERENCE,
+        properties.INSPIREID_LOCALID,
+        properties._lmeParcelReference,
+        properties.LABEL
+    ].filter(Boolean).map(value => String(value).toUpperCase());
+    for (const reference of references) {
+        const match = reference.match(/(?:^|\.)([A-Z][0-9A-Z]{3})[_-](\d{4})(?:\d{2})?(?:[._-]|$)/);
+        if (match) {
+            const parsedSheet = normalizeFiducialSheet(match[2]);
+            return { municipalityCode: match[1], sheet: parsedSheet, label: `Comune ${match[1]}, foglio ${parsedSheet}` };
+        }
+    }
+    return null;
+}
+
+function normalizeFiducialSheet(value) {
+    const digits = String(value ?? "").match(/\d+/)?.[0] || "";
+    if (!digits) return "";
+    return String(Number.parseInt(digits, 10));
+}
+
+function updateFiducialDownloadButton() {
+    const button = lmeState.fiducialDownloadButton;
+    if (!button) return;
+    const enabled = Boolean(lmeState.entitlements?.fiducialPoints && currentFiducialMapContext());
+    button.classList.toggle("is-disabled", !enabled);
+    button.setAttribute("aria-disabled", String(!enabled));
+    button.title = enabled
+        ? "Scarica PF del foglio o della particella"
+        : "Seleziona una particella o un foglio per scaricare i PF";
 }

 async function numericEditManagedRecord(record) {
@@ -3075,7 +3182,8 @@ function restoreLastTrashItem() {
    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return false; }
    const entry = lmeState.trash.pop();
    if (!entry) { setInfo("Il cestino e' vuoto."); return false; }
-    const drawingsToRestore = entry.items.filter(item => !["imported", "importedSheets"].includes(item.categoryKey)).length;
+    const drawingsToRestore = entry.items.filter(item =>
+        !["imported", "importedSheets", "fiducials"].includes(item.categoryKey)).length;
    if (!canAddDrawingObjects(drawingsToRestore)) {
        lmeState.trash.push(entry);
        return false;
@@ -3084,6 +3192,12 @@ function restoreLastTrashItem() {
    entry.items.forEach(item => {
        if (item.categoryKey === "imported") addImportedFeatures({ type: "FeatureCollection", features: [item.feature] });
        else if (item.categoryKey === "importedSheets") addImportedSheetFeatures({ type: "FeatureCollection", features: [item.feature] });
+        else if (item.categoryKey === "fiducials") {
+            L.geoJSON(item.feature, {
+                pointToLayer: (feature, latlng) => createFiducialMarker(feature, latlng),
+                onEachFeature: (feature, layer) => bindFiducialPopup(feature, layer)
+            }).eachLayer(layer => lmeState.fiducials.addLayer(layer));
+        }
        else addDrawingFeature(item.feature);
    });
    refreshLayerManager();
@@ -3271,6 +3385,8 @@ function setManagedCategoryVisible(category, visible) {
        lmeState.importedSheetsVisible = visible;
    } else if (category.key === "selectedParcels") {
        lmeState.selectedParcelsVisible = visible;
+    } else if (category.key === "fiducials") {
+        lmeState.fiducialsVisible = visible;
    } else if (category.key === "gpsPosition") {
        lmeState.gpsPositionVisible = visible;
    }
@@ -3344,6 +3460,9 @@ function managedCategoryEnabled(categoryKey) {
    if (categoryKey === "selectedParcels") {
        return lmeState.selectedParcelsVisible;
    }
+    if (categoryKey === "fiducials") {
+        return lmeState.fiducialsVisible;
+    }
    return true;
 }

@@ -4721,7 +4840,7 @@ function circleToPolygon(center, radiusMeters) {
 function createProjectSnapshot(includeCadastralParcels) {
    const center = lmeState.map.getCenter();
    return JSON.stringify({
-        schemaVersion: 5,
+        schemaVersion: 6,
        view: {
            latitude: center.lat,
            longitude: center.lng,
@@ -4731,6 +4850,7 @@ function createProjectSnapshot(includeCadastralParcels) {
        imported: managedGroupGeoJson(lmeState.imported, "imported"),
        importedSheets: managedGroupGeoJson(lmeState.importedSheets, "importedSheets"),
        importedSheetsVisible: lmeState.importedSheetsVisible,
+        fiducials: managedGroupGeoJson(lmeState.fiducials, "fiducials"),
        displayOptions: captureDisplayOptions(),
        selectedParcels: includeCadastralParcels
            ? managedGroupGeoJson(lmeState.selectedParcelsLayer, "selectedParcels")
@@ -4766,6 +4886,7 @@ function loadProjectSnapshot(raw, projectName) {
        lmeState.drawingMeasurements.clearLayers();
        lmeState.importedMeasurements.clearLayers();
        lmeState.selectedParcelsLayer.clearLayers();
+        lmeState.fiducials.clearLayers();
        lmeState.gpsParcelLayer.clearLayers();

        const restoredDrawings = L.geoJSON(data.drawings || emptyFeatureCollection(), {
@@ -4826,6 +4947,10 @@ function loadProjectSnapshot(raw, projectName) {
                applyStyleFromProperties(layer);
            }
        }).addTo(lmeState.selectedParcelsLayer);
+        L.geoJSON(data.fiducials || emptyFeatureCollection(), {
+            pointToLayer: (feature, latlng) => createFiducialMarker(feature, latlng),
+            onEachFeature: (feature, layer) => bindFiducialPopup(feature, layer)
+        }).addTo(lmeState.fiducials);
        if (lmeState.importedSheetsVisible) {
            void ensureImportedSheetOutlines().then(() => {
                applyImportedSheetVisibility();
@@ -4848,6 +4973,7 @@ function loadProjectSnapshot(raw, projectName) {
            lmeState.drawings,
            lmeState.imported,
            lmeState.selectedParcelsLayer,
+            lmeState.fiducials,
            lmeState.gpsTrail
        ];
        if (lmeState.importedSheetsVisible) {
@@ -4898,6 +5024,8 @@ function captureDisplayOptions() {
        drawToolsVisible: Boolean(lmeState.drawControl),
        gpsPositionVisible: lmeState.gpsPositionVisible,
        selectedParcelsVisible: lmeState.selectedParcelsVisible,
+        fiducialsVisible: lmeState.fiducialsVisible,
+        fiducialColor: lmeState.fiducialColor,
        layerOrder: [...lmeState.layerOrder],
        layerObjectOrder: { ...lmeState.managerObjectOrder },
        layerCategoryNames: { ...lmeState.managerCategoryNames },
@@ -4965,6 +5093,10 @@ function applyProjectDisplayOptions(options) {
    }
    setGpsPositionVisible(options.gpsPositionVisible !== false);
    setSelectedParcelsVisible(options.selectedParcelsVisible !== false);
+    if (typeof options.fiducialColor === "string") {
+        setFiducialColor(options.fiducialColor);
+    }
+    setFiducialPointsVisible(options.fiducialsVisible !== false);
    toggleTrail(Boolean(options.trailEnabled));
    setDrawToolsVisible(Boolean(options.drawToolsVisible));
    applyStoredLayerManagerVisibility();
@@ -5634,6 +5766,138 @@ function activeCadastreLayers() {
    return drawOrder.filter(layer => lmeState.cadastreLayers.includes(layer));
 }

+function setFiducialPoints(points, color, visible = true, keepPrevious = false, municipalityCode = "", sheet = "", municipalityName = "") {
+    if (!lmeState.fiducials) return;
+    const source = Array.isArray(points) ? points : [];
+    if (source.length || lmeState.fiducials.getLayers().length) rememberMapChange();
+    const normalizedMunicipality = String(municipalityCode || "").trim().toUpperCase();
+    const normalizedSheet = normalizeFiducialSheet(sheet);
+    const sheetKey = normalizedMunicipality && normalizedSheet
+        ? `${normalizedMunicipality}:${normalizedSheet}`
+        : "fiducials-current";
+    const sheetLabel = `Foglio ${normalizedSheet || sheet}${municipalityName ? ` · ${municipalityName}` : ""}`;
+    if (!keepPrevious) {
+        managedRecordsForCategory(layerManagerCategories().find(category => category.key === "fiducials"))
+            .forEach(record => lmeState.managerSelectedObjectIds.delete(record.id));
+        lmeState.fiducials.clearLayers();
+        clearManagedCategoryState("fiducials");
+    } else {
+        managedRecordsForCategory(layerManagerCategories().find(category => category.key === "fiducials"))
+            .filter(record => record.layer?.feature?.properties?._lmeFiducialSheetKey === sheetKey)
+            .forEach(record => {
+                record.parent?.removeLayer?.(record.layer);
+                clearManagedObjectState(record.id);
+                lmeState.managerSelectedObjectIds.delete(record.id);
+            });
+    }
+    if (typeof color === "string" && /^#[0-9a-f]{6}$/i.test(color)) {
+        lmeState.fiducialColor = color;
+    }
+    source.forEach((point, index) => {
+        const latitude = Number(point.latitude ?? point.Latitude);
+        const longitude = Number(point.longitude ?? point.Longitude);
+        if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) return;
+        const feature = {
+            type: "Feature",
+            geometry: { type: "Point", coordinates: [longitude, latitude] },
+            properties: {
+                name: String(point.identifier ?? point.Identifier ?? `PF ${index + 1}`),
+                _lmeDisplayName: String(point.identifier ?? point.Identifier ?? `PF ${index + 1}`),
+                _lmeSource: sheetKey,
+                _lmeGroupName: sheetLabel,
+                _lmeFiducialSheetKey: sheetKey,
+                _lmeMunicipalityCode: normalizedMunicipality,
+                _lmeSheet: normalizedSheet,
+                _lmeColor: lmeState.fiducialColor,
+                _lmeFillColor: lmeState.fiducialColor,
+                _lmeWeight: 3,
+                _lmeOpacity: 1,
+                _lmeFillOpacity: 0.72,
+                cadastralNorth: point.cadastralNorth ?? point.CadastralNorth ?? null,
+                cadastralEast: point.cadastralEast ?? point.CadastralEast ?? null,
+                reliability: String(point.reliability ?? point.Reliability ?? ""),
+                elevation: point.elevation ?? point.Elevation ?? null,
+                parcel: String(point.parcel ?? point.Parcel ?? ""),
+                updatedAt: String(point.updatedAt ?? point.UpdatedAt ?? ""),
+                originId: String(point.originId ?? point.OriginId ?? ""),
+                monographUrl: String(point.monographUrl ?? point.MonographUrl ?? "")
+            }
+        };
+        const marker = createFiducialMarker(feature, L.latLng(latitude, longitude));
+        marker.feature = feature;
+        bindFiducialPopup(feature, marker);
+        lmeState.fiducials.addLayer(marker);
+    });
+    setFiducialPointsVisible(visible);
+    refreshLayerManager();
+    if (source.length) finishMapChange();
+}
+
+function createFiducialMarker(feature, latlng) {
+    const properties = feature?.properties || {};
+    const color = properties._lmeColor || lmeState.fiducialColor;
+    return L.circleMarker(latlng, {
+        pane: "fiducialsPane",
+        radius: 8,
+        color,
+        fillColor: properties._lmeFillColor || color,
+        weight: Number(properties._lmeWeight) || 3,
+        opacity: Number.isFinite(Number(properties._lmeOpacity)) ? Number(properties._lmeOpacity) : 1,
+        fillOpacity: Number.isFinite(Number(properties._lmeFillOpacity)) ? Number(properties._lmeFillOpacity) : 0.72
+    });
+}
+
+function bindFiducialPopup(feature, layer) {
+    const properties = feature?.properties || {};
+    const rows = [];
+    if (properties.cadastralNorth != null) rows.push(`Nord/X catastale: ${escapeHtml(properties.cadastralNorth)}`);
+    if (properties.cadastralEast != null) rows.push(`Est/Y catastale: ${escapeHtml(properties.cadastralEast)}`);
+    if (properties.reliability) rows.push(`Attendibilita: ${escapeHtml(properties.reliability)}`);
+    if (properties.elevation != null) rows.push(`Quota: ${escapeHtml(properties.elevation)}`);
+    if (properties.parcel) rows.push(`Particella: ${escapeHtml(properties.parcel)}`);
+    const url = String(properties.monographUrl || "");
+    const monograph = /^https:\/\//i.test(url)
+        ? `<p><a href="${escapeHtml(url)}" target="_blank" rel="noopener">Apri monografia ufficiale</a></p>`
+        : "";
+    layer.bindPopup(`<strong>${escapeHtml(properties._lmeDisplayName || properties.name || "Punto fiduciale")}</strong><p>${rows.join("<br>")}</p>${monograph}<small>Posizione cartografica sperimentale GloboGIS: verificare prima dell'uso topografico.</small>`);
+    applyStyleFromProperties(layer);
+}
+
+function setFiducialPointsVisible(enabled) {
+    lmeState.fiducialsVisible = Boolean(enabled);
+    if (!lmeState.map || !lmeState.fiducials) return;
+    if (lmeState.fiducialsVisible) {
+        lmeState.managerHiddenCategories.delete("fiducials");
+        if (!lmeState.map.hasLayer(lmeState.fiducials)) lmeState.fiducials.addTo(lmeState.map);
+        lmeState.fiducials.bringToFront?.();
+    } else {
+        lmeState.managerHiddenCategories.add("fiducials");
+        if (lmeState.map.hasLayer(lmeState.fiducials)) lmeState.map.removeLayer(lmeState.fiducials);
+    }
+    refreshLayerManager();
+}
+
+function setFiducialColor(color) {
+    if (!/^#[0-9a-f]{6}$/i.test(String(color))) return;
+    lmeState.fiducialColor = color;
+    lmeState.fiducials?.eachLayer(layer => {
+        if (layer.feature?.properties) {
+            layer.feature.properties._lmeColor = color;
+            layer.feature.properties._lmeFillColor = color;
+        }
+        applyStyleFromProperties(layer);
+    });
+    refreshLayerManager();
+}
+
+function fitFiducialPoints() {
+    if (!lmeState.fiducials?.getLayers().length) {
+        setInfo("Nessun Punto Fiduciale da inquadrare.");
+        return;
+    }
+    fitLayer(lmeState.fiducials);
+}
+
 function clearSelectedParcels() {
    const count = managedGroupGeoJson(lmeState.selectedParcelsLayer, "selectedParcels").features.length;
    if (count) rememberMapChange();
@@ -5672,6 +5936,7 @@ function setSelectedParcelsVisible(enabled) {
 function clearMapElements() {
    const count = managedGroupGeoJson(lmeState.selectedParcelsLayer, "selectedParcels").features.length
        + managedGroupGeoJson(lmeState.gpsParcelLayer, "gpsParcels").features.length
+        + managedGroupGeoJson(lmeState.fiducials, "fiducials").features.length
        + managedGroupGeoJson(lmeState.imported, "imported").features.length
        + managedGroupGeoJson(lmeState.importedSheets, "importedSheets").features.length
        + managedGroupGeoJson(lmeState.drawings, "drawings").features.length
@@ -5680,7 +5945,7 @@ function clearMapElements() {
        setInfo("La mappa non contiene elementi da pulire.");
        return;
    }
-    if (!window.confirm("Rimuovere particelle evidenziate, file importati, disegni, POI e traccia GPS dalla mappa?")) {
+    if (!window.confirm("Rimuovere particelle evidenziate, Punti Fiduciali, file importati, disegni, POI e traccia GPS dalla mappa?")) {
        return;
    }

@@ -5688,6 +5953,7 @@ function clearMapElements() {
    resetLayerManagerProjectState();
    lmeState.selectedParcelsLayer.clearLayers();
    lmeState.gpsParcelLayer.clearLayers();
+    lmeState.fiducials.clearLayers();
    lmeState.imported.clearLayers();
    lmeState.importedSheets.clearLayers();
    lmeState.drawings.clearLayers();
Author	SHA1	Message	Date
livio	bc037a57d4	Prepare Pro 1.0.14 release	2026-10-04 20:23:59 +02:00
livio	ce355f820c	Add contextual fiducial point downloads	2026-10-04 19:28:31 +02:00
livio	85e1c93d8a	Add mapped Pro fiducial point layer	2026-10-04 15:18:42 +02:00