Owner review 1, phase 4, package P1: the Core geometry behind the visual crop (R5) and the orientation controls (R6). - RenderGeometry: one warp stab⁻¹ · O⁻¹ · V with the crop and the keyframe centres in the view frame T (turned, mirrored, flipped, straightened); the output size comes from RenderSize, so a fixed preset adapts to the aspect (4K at 9:16 = 2160×3840) and AspectFromPreset is gone; the decode grows by the straighten cover zoom; ViewFor, ViewToFrame, EditableCrop and FootprintInView get their real bodies; a rotation that is not a quarter turn and an out-of-range straighten render as none or clamped, with their warnings. - FrameOrientation: the cover zoom is taken on the pixel-centre extents, so every output pixel samples inside the frame (full alpha coverage at ±15°, never a smeared border). - CropFrame: crops are written on the 12-decimal grid OrientationEdit remaps on, so four turns or two mirrors give back the same text; a stored crop is read value by value as the render reads it. - Advisor: the aspect (and the horizon framing) is advised on the view turned by the camera (SequenceContext.Rotate/Flip, ForCamera); the analyser passes the project's camera. - Self-test: proc.orient, proc.straighten, proc.portrait. - Tests: exact pixel permutations for turns, mirror and flip, the orientation algebra, straighten against an analytic ramp and its full coverage, Create sizes, a crop keeping its content through every press, CropFrame move/resize/refit/rows, OrientationEdit round trips and its agreement with FrameOrientation, the turned-view advice, determinism. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
175 lines
8.7 KiB
C#
175 lines
8.7 KiB
C#
using Chronos.Core.Imaging.Geometry;
|
||
using Chronos.Testing;
|
||
|
||
namespace Chronos.Core.Tests.Geometry;
|
||
|
||
public sealed class CropFrameTests
|
||
{
|
||
/// <summary>9:16 on a 6000×4000 view, in normalised units: 0.5625 × 4000 / 6000.</summary>
|
||
private const double Portrait = 0.375;
|
||
|
||
[Test]
|
||
public void TheLargestBoxIsCentredAndLocked()
|
||
{
|
||
AssertBox(new RectD(0.3125, 0, 0.375, 1), CropFrame.Largest(Portrait));
|
||
AssertBox(new RectD(0, 0, 1, 1), CropFrame.Largest(1));
|
||
AssertBox(new RectD(0, 0.25, 1, 0.5), CropFrame.Largest(2));
|
||
Assert.Throws<ArgumentOutOfRangeException>(() => CropFrame.Largest(0));
|
||
Assert.Throws<ArgumentOutOfRangeException>(() => CropFrame.Largest(double.NaN));
|
||
}
|
||
|
||
[Test]
|
||
public void StoredCropsReadAsTheRenderReadsThem()
|
||
{
|
||
AssertBox(new RectD(0, 0, 1, 1), CropFrame.Of(null));
|
||
AssertBox(new RectD(0, 0, 1, 1), CropFrame.Of([0.1, 0.2]));
|
||
AssertBox(new RectD(0, 0, 1, 1), CropFrame.Of([0.1, double.NaN, 0.3, 0.3]));
|
||
AssertBox(new RectD(0, 0, 1, 1), CropFrame.Of([0.5, 0.5, 0.0001, 0.5]));
|
||
AssertBox(new RectD(0.5, 0, 0.5, 0.25), CropFrame.Of([0.5, -1, 0.8, 0.25]));
|
||
Assert.True(CropFrame.IsWhole(null));
|
||
Assert.True(CropFrame.IsWhole([0, 0, 1, 1]));
|
||
Assert.False(CropFrame.IsWhole([0, 0, 0.9, 1]));
|
||
Assert.Null(CropFrame.ToCrop(new RectD(0, 0, 1, 1)));
|
||
Assert.SequenceEqual([0.25, 0.125, 0.5, 0.5], CropFrame.ToCrop(new RectD(0.25, 0.125, 0.5, 0.5))!);
|
||
// Written on a 12-decimal grid, never −0.
|
||
Assert.SequenceEqual([0.333333333333, 0, 0.5, 0.5], CropFrame.ToCrop(new RectD(1 / 3.0, -0.0, 0.5, 0.5))!);
|
||
Assert.False(double.IsNegative(CropFrame.ToCrop(new RectD(-0.0, 0.2, 0.5, 0.5))![0]));
|
||
}
|
||
|
||
[Test]
|
||
public void LockedBakesTheOffsetsOfALegacyCrop()
|
||
{
|
||
// A free crop of the whole view with the box pushed right: the render's FitCrop, normalised.
|
||
AssertBox(new RectD(0.625, 0, 0.375, 1), CropFrame.Locked(null, Portrait, offsetX: 1));
|
||
AssertBox(new RectD(0.3125, 0, 0.375, 1), CropFrame.Locked(null, Portrait, double.NaN, double.NaN));
|
||
var box = CropFrame.Locked([0.2, 0.1, 0.4, 0.8], Portrait, -1, 0);
|
||
AssertBox(new RectD(0.2, 0.1, 0.3, 0.8), box);
|
||
// A box the editor wrote comes back unchanged.
|
||
AssertBox(box, CropFrame.Locked(CropFrame.ToCrop(box), Portrait));
|
||
}
|
||
|
||
[Test]
|
||
public void MovingStaysInsideAndKeepsTheSize()
|
||
{
|
||
var box = new RectD(0.3, 0.2, 0.3, 0.4);
|
||
AssertBox(new RectD(0.4, 0.15, 0.3, 0.4), CropFrame.Move(box, 0.1, -0.05));
|
||
AssertBox(new RectD(0.7, 0, 0.3, 0.4), CropFrame.Move(box, 2, -1));
|
||
AssertBox(new RectD(0, 0.6, 0.3, 0.4), CropFrame.Move(box, -5, 5));
|
||
}
|
||
|
||
[Theory]
|
||
[Case(CropHandle.BottomRight, 0.9, 0.95, false)]
|
||
[Case(CropHandle.TopLeft, 0.0, 0.0, false)]
|
||
[Case(CropHandle.TopRight, 2.0, -3.0, false)]
|
||
[Case(CropHandle.Left, 0.31, 0.5, false)]
|
||
[Case(CropHandle.Top, 0.5, -1.0, false)]
|
||
[Case(CropHandle.Right, 0.4, 0.5, false)]
|
||
[Case(CropHandle.Bottom, 0.5, 0.3, false)]
|
||
[Case(CropHandle.BottomLeft, 0.1, 0.9, true)]
|
||
[Case(CropHandle.Right, 5.0, 0.5, true)]
|
||
[Case(CropHandle.TopLeft, 0.45, 0.45, true)]
|
||
public void ResizingKeepsTheRatioTheMinimumAndTheFrame(CropHandle handle, double x, double y, bool aboutCentre)
|
||
{
|
||
var start = new RectD(0.35, 0.3, 0.15, 0.4);
|
||
var box = CropFrame.ResizeFrom(start, handle, x, y, Portrait, aboutCentre);
|
||
Assert.Approximately(Portrait, box.Width / box.Height, 1e-12, "the ratio stays locked");
|
||
Assert.True(box.X >= -1e-12 && box.Y >= -1e-12 && box.Right <= 1 + 1e-12 && box.Bottom <= 1 + 1e-12, $"{box} lies inside the view");
|
||
Assert.GreaterOrEqual(box.Height, CropFrame.Largest(Portrait).Height * CropFrame.MinimumShare - 1e-12);
|
||
if (aboutCentre)
|
||
{
|
||
Assert.Approximately(start.CenterX, box.CenterX, 1e-12);
|
||
Assert.Approximately(start.CenterY, box.CenterY, 1e-12);
|
||
return;
|
||
}
|
||
// The opposite corner or edge stays where it was; an edge handle keeps the box centred on the other axis.
|
||
switch (handle)
|
||
{
|
||
case CropHandle.BottomRight:
|
||
Assert.Within(start.X, start.Y, box.X, box.Y, 1e-12);
|
||
break;
|
||
case CropHandle.TopLeft:
|
||
Assert.Within(start.Right, start.Bottom, box.Right, box.Bottom, 1e-12);
|
||
break;
|
||
case CropHandle.TopRight:
|
||
Assert.Within(start.X, start.Bottom, box.X, box.Bottom, 1e-12);
|
||
break;
|
||
case CropHandle.Left:
|
||
Assert.Within(start.Right, start.CenterY, box.Right, box.CenterY, 1e-12);
|
||
break;
|
||
case CropHandle.Right:
|
||
Assert.Within(start.X, start.CenterY, box.X, box.CenterY, 1e-12);
|
||
break;
|
||
case CropHandle.Top:
|
||
Assert.Within(start.CenterX, start.Bottom, box.CenterX, box.Bottom, 1e-12);
|
||
break;
|
||
case CropHandle.Bottom:
|
||
Assert.Within(start.CenterX, start.Y, box.CenterX, box.Y, 1e-12);
|
||
break;
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public void ResizingFollowsThePointer()
|
||
{
|
||
var start = new RectD(0.35, 0.3, 0.15, 0.4);
|
||
// Bottom-right to (0.5375, 0.8): both axes ask for a height of 0.5 (0.1875 / 0.375 and 0.8 − 0.3).
|
||
AssertBox(new RectD(0.35, 0.3, 0.1875, 0.5), CropFrame.ResizeFrom(start, CropHandle.BottomRight, 0.5375, 0.8, Portrait));
|
||
// Dragged past the anchor: the minimum box.
|
||
var least = CropFrame.ResizeFrom(start, CropHandle.BottomRight, 0, 0, Portrait);
|
||
Assert.Approximately(0.1, least.Height, 1e-12);
|
||
// Far out: as large as fits from the anchor (0.7 of height below it).
|
||
Assert.Approximately(0.7, CropFrame.ResizeFrom(start, CropHandle.BottomRight, 1, 1, Portrait).Height, 1e-12);
|
||
// The inside and no handle leave the box.
|
||
Assert.Equal(start, CropFrame.ResizeFrom(start, CropHandle.Inside, 0.9, 0.9, Portrait));
|
||
Assert.Equal(start, CropFrame.ResizeFrom(start, CropHandle.None, 0.9, 0.9, Portrait));
|
||
}
|
||
|
||
[Test]
|
||
public void ClampAndRefitKeepTheCentre()
|
||
{
|
||
// A 16:9 box (in units of a square view) refitted to 1:1 keeps its centre and its area.
|
||
var wide = new RectD(0.2, 0.3, 0.64, 0.36);
|
||
var square = CropFrame.Refit(wide, 1);
|
||
Assert.Approximately(square.Width, square.Height, 1e-12);
|
||
Assert.Within(wide.CenterX, wide.CenterY, square.CenterX, square.CenterY, 1e-12);
|
||
Assert.Approximately(wide.Width * wide.Height, square.Width * square.Height, 1e-12);
|
||
|
||
// Near an edge the refitted box moves inside rather than leaving the view.
|
||
var edge = CropFrame.Refit(new RectD(0.8, 0.1, 0.2, 0.8), 1);
|
||
Assert.Approximately(1, edge.Right, 1e-12);
|
||
Assert.Approximately(edge.Width, edge.Height, 1e-12);
|
||
|
||
// Too large or too small: the largest box, the minimum.
|
||
AssertBox(CropFrame.Largest(Portrait), CropFrame.Clamp(new RectD(-1, -1, 3, 3), Portrait));
|
||
Assert.Approximately(0.1, CropFrame.Clamp(new RectD(0.5, 0.5, 0.001, 0.001), Portrait).Height, 1e-12);
|
||
AssertBox(CropFrame.Largest(Portrait), CropFrame.Clamp(new RectD(double.NaN, 0, 0, 0), Portrait));
|
||
}
|
||
|
||
[Test]
|
||
public void RowsRoundTrip()
|
||
{
|
||
foreach (var (size, x, y) in new[] { (1.0, 0.0, 0.0), (0.5, -1.0, 1.0), (0.8, 0.25, -0.5), (0.1, 1.0, 0.3) })
|
||
{
|
||
var box = CropFrame.FromRows(size, x, y, Portrait);
|
||
Assert.Approximately(Portrait, box.Width / box.Height, 1e-12);
|
||
var rows = CropFrame.ToRows(box, Portrait);
|
||
Assert.Approximately(size, rows.Size, 1e-12);
|
||
Assert.Approximately(x, rows.X, 1e-12);
|
||
// The largest portrait box fills the height: no vertical slack, so y reads 0.
|
||
Assert.Approximately(size == 1 ? 0 : y, rows.Y, 1e-12);
|
||
AssertBox(box, CropFrame.FromRows(rows.Size, rows.X, rows.Y, Portrait));
|
||
}
|
||
AssertBox(CropFrame.Largest(Portrait), CropFrame.FromRows(double.NaN, double.NaN, 0, Portrait));
|
||
Assert.True(CropFrame.HasSlack(CropFrame.Largest(Portrait), horizontal: true));
|
||
Assert.False(CropFrame.HasSlack(CropFrame.Largest(Portrait), horizontal: false));
|
||
}
|
||
|
||
private static void AssertBox(RectD expected, RectD actual)
|
||
{
|
||
Assert.Approximately(expected.X, actual.X, 1e-12, $"x of {actual}");
|
||
Assert.Approximately(expected.Y, actual.Y, 1e-12, $"y of {actual}");
|
||
Assert.Approximately(expected.Width, actual.Width, 1e-12, $"width of {actual}");
|
||
Assert.Approximately(expected.Height, actual.Height, 1e-12, $"height of {actual}");
|
||
}
|
||
}
|