Files
Chronos/tests/Chronos.Core.Tests/Geometry/CropFrameTests.cs
T
Alby96andClaude Opus 5.5 bee66da63a feat(render): orient, straighten and let the chosen proportions win in the render geometry
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>
2026-11-04 19:35:05 +01:00

175 lines
8.7 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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}");
}
}