feat(hunts): fit the detail zone map's initial view to the spawn cluster

The zone map always opened fit to the whole texture, so a mob whose
candidates cluster in a small corner of the map (as little as 47% of
the panel for outer_la_noscea) left the dots small and clustered
together even though their positions were correct.

Add PhotoZoomView.FocusOn(stage, size, normalizedBounds, padding), on
top of a new SnapTo that clamps to the existing zoom range and reuses
the existing pan clamp, so a target region can be framed immediately
without the user ever seeing the unfocused full-texture view. Hunts
computes the bounding box of the current detailMapPoints (not the
aetheryte points, which can sit far from the candidate cluster and
would fight the zoom) and focuses on it once per newly opened mob,
deferred to the first Draw of the map panel since the stage and
texture size aren't known until then. Live phase/zone narrowing while
a page stays open does not re-focus, to avoid yanking the view under
the user; only opening a different mob does.

Author: Deldee

src/Aetherphone.Tests/PhotoZoomViewTests.cs

@@ -0,0 +1,61 @@
+using System.Numerics;
+using Aetherphone.Core;
+using Aetherphone.Windows.Components;
+using Xunit;
+
+namespace Aetherphone.Tests;
+
+public sealed class PhotoZoomViewTests
+{
+    private static readonly Rect Stage = new(Vector2.Zero, new Vector2(260f, 260f));
+    private static readonly Vector2 TextureSize = new(2048f, 2048f);
+
+    [Fact]
+    public void FocusOnATightClusterClampsToMaxZoom()
+    {
+        var view = new PhotoZoomView();
+        var bounds = new Rect(new Vector2(0.45f, 0.45f), new Vector2(0.55f, 0.55f));
+
+        view.FocusOn(Stage, TextureSize, bounds);
+
+        Assert.Equal(4f, view.Zoom, 3);
+    }
+
+    [Fact]
+    public void FocusOnTheFullCanvasStaysAtMinZoomWithNoPan()
+    {
+        var view = new PhotoZoomView();
+        var bounds = new Rect(Vector2.Zero, Vector2.One);
+
+        view.FocusOn(Stage, TextureSize, bounds, paddingFraction: 0f);
+
+        Assert.Equal(1f, view.Zoom, 3);
+        Assert.Equal(0f, view.Pan.X, 3);
+        Assert.Equal(0f, view.Pan.Y, 3);
+    }
+
+    [Fact]
+    public void FocusOnAnOffCenterClusterPansTowardItWithoutExceedingTheClamp()
+    {
+        var view = new PhotoZoomView();
+        var bounds = new Rect(new Vector2(0.05f, 0.4f), new Vector2(0.25f, 0.6f));
+
+        view.FocusOn(Stage, TextureSize, bounds);
+
+        Assert.True(view.Zoom > 1f);
+        var fit = PhotoZoomView.FitScale(Stage, TextureSize);
+        var drawn = TextureSize * fit * view.Zoom;
+        var maxPanX = MathF.Max(0f, (drawn.X - Stage.Width) * 0.5f);
+        Assert.InRange(view.Pan.X, -maxPanX, maxPanX);
+    }
+
+    [Fact]
+    public void SnapToClampsZoomToTheConfiguredRange()
+    {
+        var view = new PhotoZoomView();
+
+        view.SnapTo(Stage, TextureSize, 50f, Vector2.Zero);
+
+        Assert.Equal(4f, view.Zoom, 3);
+    }
+}

src/Aetherphone/Apps/Hunts/HuntsApp.Detail.cs

@@ -49,6 +49,7 @@ internal sealed partial class HuntsApp
     private readonly Dictionary<(uint TerritoryId, string ZoneId, string Language), string> zoneLabelCache = new();
     private readonly PhotoZoomView detailMapZoom = new();
     private bool detailMapHovered;
+    private bool detailMapPendingFocus;
 
     private (int WindowNum, int PhaseNum)? detailMapActivePhase;
     private string? detailMapConfirmedZoneId;
@@ -85,7 +86,7 @@ private void OpenDetailFor(string mobId, string worldId, int zoneInstance)
             detailMapActivePhase = hunts.PhaseFor(mobId, worldId, zoneInstance);
             detailMapConfirmedZoneId = hunts.ZoneIdFor(mobId, worldId, zoneInstance);
             ResolveDetailMap(mobCatalog.Find(mobId), detailMapActivePhase, detailMapConfirmedZoneId);
-            detailMapZoom.Reset();
+            detailMapPendingFocus = true;
             detailMapHovered = false;
         }
 
@@ -522,6 +523,12 @@ private string ResolveZoneLabel(string zoneId, uint territoryId)
     private void DrawDetailZoneMapContent(Rect stage, IDalamudTextureWrap texture, float scale, int? confirmedPoiId,
         HuntsView view, uint territoryId)
     {
+        if (detailMapPendingFocus)
+        {
+            detailMapPendingFocus = false;
+            FocusDetailMap(stage, texture.Size);
+        }
+
         var drawList = ImGui.GetWindowDrawList();
         detailMapZoom.Draw(stage, texture, frameTheme, Metrics.Radius.Card * scale, showButtons: false);
 
@@ -577,6 +584,27 @@ private void DrawDetailZoneMapContent(Rect stage, IDalamudTextureWrap texture, f
         drawList.PopClipRect();
     }
 
+    private void FocusDetailMap(Rect stage, Vector2 textureSize)
+    {
+        if (detailMapPoints.Count == 0)
+        {
+            detailMapZoom.Reset();
+            return;
+        }
+
+        var min = new Vector2(float.MaxValue, float.MaxValue);
+        var max = new Vector2(float.MinValue, float.MinValue);
+        for (var index = 0; index < detailMapPoints.Count; index++)
+        {
+            var (rawX, rawY) = detailMapPoints[index].ParsedLocation();
+            var (normalizedX, normalizedY) = MapPixelMath.NormalizeToFullCanvas(rawX, rawY);
+            min = new Vector2(MathF.Min(min.X, normalizedX), MathF.Min(min.Y, normalizedY));
+            max = new Vector2(MathF.Max(max.X, normalizedX), MathF.Max(max.Y, normalizedY));
+        }
+
+        detailMapZoom.FocusOn(stage, textureSize, new Rect(min, max));
+    }
+
     private void DrawSpawnDot(ImDrawListPtr drawList, Vector2 center, float scale, int poiId, bool confirmed,
         bool finalLocation)
     {

src/Aetherphone/Windows/Components/Media/PhotoZoomView.cs

@@ -43,6 +43,27 @@ public void Reset()
         dragging = false;
     }
 
+    public void SnapTo(Rect stage, Vector2 size, float zoomValue, Vector2 panValue)
+    {
+        targetZoom = Math.Clamp(zoomValue, MinZoom, MaxZoom);
+        targetPan = panValue;
+        ClampPan(stage, size);
+        zoom.SnapTo(targetZoom);
+        panX.SnapTo(targetPan.X);
+        panY.SnapTo(targetPan.Y);
+        dragging = false;
+    }
+
+    public void FocusOn(Rect stage, Vector2 size, Rect normalizedBounds, float paddingFraction = 0.3f)
+    {
+        var span = MathF.Max(normalizedBounds.Width, normalizedBounds.Height) * (1f + paddingFraction);
+        var focusZoom = span > 0f ? 1f / span : MaxZoom;
+        var drawn = size * FitScale(stage, size) * Math.Clamp(focusZoom, MinZoom, MaxZoom);
+        var center = normalizedBounds.Center;
+        var pan = new Vector2(drawn.X * (0.5f - center.X), drawn.Y * (0.5f - center.Y));
+        SnapTo(stage, size, focusZoom, pan);
+    }
+
     public bool Draw(Rect stage, IDalamudTextureWrap texture, PhoneTheme theme, float rounding,
         bool showButtons = true, Rect? controls = null)
     {