Lays down every contract the later parcels of owner review 1 phase 5 build on, so they compile against shared types without touching each other's files. - Settings format 3: export.playback (direction, loops, fades, hold), omitted at its default and member by member; RequiredFormat is 3 only while used. - OutputProgram public API with a forward-only body; still-frame job parameters (StillFrame, StillPhoto) routed to format-3 nodes only. - Render.Sha256/Kind, RenderCopy, RenderKind; JobKind.VideoCopy = 24. - Migration 0010 (sqlite, postgres): renders.sha256/kind, ix_renders_created, render_copies without a foreign key. - Videos protocol DTOs, client calls, ServerCapabilities.Videos (declared, not announced yet), ServerSettingsDto.VideosPath. - IVideoLibrary with a NotImplemented stub registered on the server; TrashKind.Videos, VideoTrashNames, VideoErrors. - en and it strings for the whole phase, five icons, decisions 1-22 and the open-question defaults; tests that used format 3 as "newer" now use 4. Refs #21 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
613 lines
29 KiB
C#
613 lines
29 KiB
C#
using System.IO;
|
||
using System.Text.Json;
|
||
using Chronos.App.Editor;
|
||
using Chronos.Core.Advice;
|
||
using Chronos.Core.Analysis;
|
||
using Chronos.Core.Imaging.Geometry;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Core.Project;
|
||
using Chronos.Protocol;
|
||
using Chronos.Testing;
|
||
|
||
namespace Chronos.App.Tests.Editor;
|
||
|
||
public sealed class EditorSessionTests
|
||
{
|
||
private static (EditorSession Session, FakeSequenceSource Source) Open(ProjectSettings? project = null, bool deep = true)
|
||
{
|
||
var content = EditorFixture.Content(EditorFixture.Sunset, project, deep);
|
||
var source = new FakeSequenceSource(EditorFixture.Sunset, content);
|
||
return (new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)), source);
|
||
}
|
||
|
||
[Test]
|
||
public async Task EditsAreSavedAndUndoable()
|
||
{
|
||
var (session, source) = Open();
|
||
await using (session)
|
||
{
|
||
Assert.True(session.Edit(p => EditorSettings.Deflicker.WithManual(p, true)));
|
||
await session.FlushAsync();
|
||
Assert.True(source.Stored.Exposure.Deflicker is { IsAuto: false, Manual: true });
|
||
|
||
Assert.True(session.Undo());
|
||
await session.FlushAsync();
|
||
Assert.True(source.Stored.Exposure.Deflicker.IsAuto, "undo is saved too");
|
||
Assert.True(session.Redo());
|
||
await session.FlushAsync();
|
||
Assert.False(source.Stored.Exposure.Deflicker.IsAuto);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task RapidEditsSaveOnce()
|
||
{
|
||
var (session, source) = Open();
|
||
await using (session)
|
||
{
|
||
Assert.False(session.HasPendingSave);
|
||
for (var i = 1; i <= 20; i++) session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = i / 20.0 } }, "offset");
|
||
Assert.True(session.HasPendingSave, "closing the window waits for this save");
|
||
await session.FlushAsync();
|
||
Assert.False(session.HasPendingSave);
|
||
Assert.Equal(1, source.Saves);
|
||
Assert.Equal(1.0, source.Stored.Exposure.ExposureOffsetEv);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AChangeStoredMeanwhileIsMergedIntoTheEditor()
|
||
{
|
||
var (session, source) = Open();
|
||
await using (session)
|
||
{
|
||
source.ExternalEdit = p => p with { Camera = p.Camera with { OffsetY = -0.2 } };
|
||
session.Edit(p => p with { HeroFrame = 5 });
|
||
Assert.True(await session.FlushAsync());
|
||
Assert.Equal(5, session.Project.HeroFrame);
|
||
Assert.Equal(-0.2, session.Project.Camera.OffsetY, "their change shows up in the editor");
|
||
Assert.True(session.Undo());
|
||
Assert.Null(session.Project.HeroFrame);
|
||
Assert.Equal(-0.2, session.Project.Camera.OffsetY, "undo keeps their change");
|
||
Assert.True(await session.FlushAsync());
|
||
Assert.Equal(-0.2, source.Stored.Camera.OffsetY, "and the undone project stored over it keeps it too");
|
||
Assert.True(session.Redo());
|
||
Assert.Equal(-0.2, session.Project.Camera.OffsetY);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AdviceFromAReloadSurvivesUndo()
|
||
{
|
||
var (session, source) = Open(deep: false);
|
||
await using (session)
|
||
{
|
||
session.Edit(p => p with { HeroFrame = 2 });
|
||
Assert.True(await session.FlushAsync());
|
||
// The deep analysis finished: its advice is stored, the editor reads it back.
|
||
source.Content = EditorFixture.Content(EditorFixture.Sunset, deep: true) with { Sequence = session.Content.Sequence };
|
||
var advice = Advisor.Recommend(source.Content.Light, source.Content.Deep, SequenceContext.FromFrames(source.Content.Frames));
|
||
source.Stored = Advisor.Apply(source.Stored, advice);
|
||
await session.ReloadAsync();
|
||
Assert.True(session.Project.Exposure.Deflicker.HasAdvice);
|
||
|
||
Assert.True(session.Undo());
|
||
Assert.Null(session.Project.HeroFrame);
|
||
Assert.True(session.Project.Exposure.Deflicker.HasAdvice, "undo does not wipe the advice");
|
||
Assert.True(await session.FlushAsync());
|
||
Assert.True(source.Stored.Exposure.Deflicker.HasAdvice, "nor does the save that follows");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AnEditMadeBeforeInsertedFramesWereReadIsSavedOnTheFramesItNamed()
|
||
{
|
||
var (session, source) = OpenShort();
|
||
await using (session)
|
||
{
|
||
Assert.True(session.SetExcluded([3], true));
|
||
Assert.True(await session.FlushAsync());
|
||
// Two earlier photos are inserted (a download, an import, a scan): the stored exclusion moved with its frame.
|
||
var frames = session.Content.Frames;
|
||
InsertEarlier(source, 2);
|
||
source.Stored = source.Stored with { ExcludedFrames = [5] };
|
||
source.FailNextSave = new FramesChangedException("frames changed");
|
||
|
||
// The editor still shows the frames it read when the user excludes another one.
|
||
Assert.True(session.SetExcluded([6], true));
|
||
Assert.True(await session.FlushAsync());
|
||
|
||
Assert.Equal(frames.Count + 2, session.Content.Count, "the frames were read again");
|
||
Assert.SequenceEqual([5, 8], source.Stored.ExcludedFrames);
|
||
Assert.SequenceEqual([frames[3].Id, frames[6].Id], session.Project.ExcludedFrames.Select(i => session.Content.Frames[i].Id));
|
||
Assert.True(session.Undo());
|
||
Assert.SequenceEqual([5], session.Project.ExcludedFrames, "undo steps name the same frames");
|
||
Assert.True(session.Undo());
|
||
Assert.Empty(session.Project.ExcludedFrames);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AReadAfterFramesWereInsertedMovesTheOpenProjectWithThem()
|
||
{
|
||
var (session, source) = OpenShort();
|
||
await using (session)
|
||
{
|
||
Assert.True(session.SetExcluded([3], true));
|
||
Assert.True(session.SetHero(4));
|
||
Assert.True(await session.FlushAsync());
|
||
InsertEarlier(source, 2);
|
||
source.Stored = source.Stored with { ExcludedFrames = [5], HeroFrame = 6 };
|
||
|
||
await session.ReloadAsync();
|
||
|
||
Assert.SequenceEqual([5], session.Project.ExcludedFrames);
|
||
Assert.Equal(6, session.Project.HeroFrame);
|
||
Assert.True(session.Undo());
|
||
Assert.Null(session.Project.HeroFrame);
|
||
Assert.SequenceEqual([5], session.Project.ExcludedFrames, "the step before Set hero names the same frame");
|
||
Assert.True(await session.FlushAsync());
|
||
Assert.SequenceEqual([5], source.Stored.ExcludedFrames);
|
||
Assert.Null(source.Stored.HeroFrame);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ARenderAfterFramesWereInsertedEmbedsThePositionsOfTheFramesTheUserChose()
|
||
{
|
||
var (session, source) = OpenShort();
|
||
await using (session)
|
||
{
|
||
Assert.True(session.SetExcluded([3], true));
|
||
Assert.True(session.SetHero(4));
|
||
Assert.True(await session.FlushAsync());
|
||
var frames = session.Content.Frames;
|
||
// Two earlier photos are inserted and the index moves the stored positions; the user renders without an edit.
|
||
InsertEarlier(source, 2);
|
||
source.Stored = source.Stored with { ExcludedFrames = [5], HeroFrame = 6 };
|
||
|
||
await session.EnsureFramesAsync();
|
||
var requests = session.RenderRequests(session.Project.Export);
|
||
|
||
Assert.Equal(frames.Count + 2, session.Content.Count, "the frames were read again");
|
||
var parameters = JsonSerializer.Deserialize(requests[0].ParametersJson!, ProtocolJson.Default.RenderJobParameters)!;
|
||
var embedded = ProjectSettings.FromJson(parameters.SettingsJson!);
|
||
Assert.SequenceEqual([5], embedded.ExcludedFrames);
|
||
Assert.Equal(6, embedded.HeroFrame);
|
||
Assert.Equal(frames[3].Id, session.Content.Frames[embedded.ExcludedFrames[0]].Id);
|
||
Assert.Equal(frames[4].Id, session.Content.Frames[embedded.HeroFrame!.Value].Id);
|
||
Assert.True(session.Undo());
|
||
Assert.Null(session.Project.HeroFrame);
|
||
Assert.SequenceEqual([5], session.Project.ExcludedFrames, "undo steps name the same frames");
|
||
|
||
// Frames that did not change are not read again.
|
||
var loads = source.Loads;
|
||
await session.EnsureFramesAsync();
|
||
Assert.Equal(loads, source.Loads);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AServerSequenceWhoseFramesChangedIsOutdatedBeforeItsRender()
|
||
{
|
||
var sequence = EditorFixture.Sequence(12);
|
||
var content = EditorFixture.Content(sequence, deep: false);
|
||
var source = new FakeSequenceSource(sequence, content) { IsRemote = true };
|
||
var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
|
||
await using (session)
|
||
{
|
||
InsertEarlier(source, 1);
|
||
|
||
await session.EnsureFramesAsync();
|
||
|
||
Assert.True(source.IsOutdated);
|
||
Assert.True(session.IsReadOnly);
|
||
Assert.Equal(0, source.Loads, "its proxies are not the server's frames: nothing is read");
|
||
Assert.Equal(12, session.Content.Count);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ReadsThatOverlapFollowTheFramesInTheOrderTheyWereRead()
|
||
{
|
||
var (session, source) = OpenShort();
|
||
await using (session)
|
||
{
|
||
Assert.True(session.SetExcluded([3], true));
|
||
Assert.True(await session.FlushAsync());
|
||
var frames = session.Content.Frames;
|
||
// A job ends after an earlier photo was inserted, and its read of the sequence is slow to complete.
|
||
InsertEarlier(source, 1);
|
||
source.Stored = source.Stored with { ExcludedFrames = [4] };
|
||
var slow = new TaskCompletionSource();
|
||
source.NextLoadGate = slow.Task;
|
||
var first = session.ReloadAsync();
|
||
// Another job ends after two more were inserted: its read waits for the first one and follows its frames.
|
||
InsertEarlier(source, 2);
|
||
source.Stored = source.Stored with { ExcludedFrames = [6] };
|
||
var second = session.ReloadAsync();
|
||
slow.SetResult();
|
||
await Task.WhenAll(first, second);
|
||
|
||
Assert.Equal(frames.Count + 3, session.Content.Count);
|
||
Assert.SequenceEqual([6], session.Project.ExcludedFrames);
|
||
Assert.Equal(frames[3].Id, session.Content.Frames[6].Id);
|
||
}
|
||
}
|
||
|
||
/// <summary>A short sequence without its analysis, whose frame ids are all different (the synthetic ids repeat every 64 frames).</summary>
|
||
private static (EditorSession Session, FakeSequenceSource Source) OpenShort()
|
||
{
|
||
var sequence = EditorFixture.Sequence(12);
|
||
var content = EditorFixture.Content(sequence, deep: false);
|
||
var source = new FakeSequenceSource(sequence, content);
|
||
return (new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)), source);
|
||
}
|
||
|
||
/// <summary>Photos captured before the first frame join the source's sequence, as an insertion renumbers it.</summary>
|
||
private static void InsertEarlier(FakeSequenceSource source, int count)
|
||
{
|
||
var first = source.Content.Frames[0];
|
||
var early = Enumerable.Range(0, count).Select(i => first with { Id = Guid.CreateVersion7(), CapturedAt = first.CapturedAt!.Value.AddMinutes(i - count) });
|
||
IReadOnlyList<Frame> frames = [.. early.Concat(source.Content.Frames).Select((f, i) => f with { Index = i })];
|
||
source.Content = source.Content with { Frames = frames, Light = LightAnalyzer.Analyze(frames) };
|
||
}
|
||
|
||
[Test]
|
||
public async Task AFailedSaveStaysPendingUntilItIsStored()
|
||
{
|
||
var (session, source) = Open();
|
||
await using (session)
|
||
{
|
||
var reported = 0;
|
||
session.SaveFailed += _ => reported++;
|
||
source.FailNextSave = new IOException("share offline");
|
||
session.Edit(p => p with { HeroFrame = 1 });
|
||
Assert.False(await session.FlushAsync(), "the flush reports the failure");
|
||
Assert.Equal(1, reported);
|
||
Assert.True(session.HasPendingSave, "closing the window must not drop the edit");
|
||
Assert.NotNull(session.LastSaveError);
|
||
Assert.Null(source.Stored.HeroFrame);
|
||
|
||
Assert.True(await session.FlushAsync(), "the retry stores it without another edit");
|
||
Assert.Equal(1, source.Stored.HeroFrame);
|
||
Assert.False(session.HasPendingSave);
|
||
Assert.Null(session.LastSaveError);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task OptimiseSectionTakesTheHeavierDecisionsAsOneStep()
|
||
{
|
||
// The user turned deflicker off by hand; the analysis measured flicker, so Optimise returns it to Auto (on).
|
||
var start = new ProjectSettings();
|
||
start = start with { Exposure = start.Exposure with { Deflicker = start.Exposure.Deflicker.WithManual(false) } };
|
||
var (session, _) = Open(start);
|
||
await using (session)
|
||
{
|
||
var advice = session.Advice.Find(AdvisorParameters.Deflicker);
|
||
Assert.NotNull(advice);
|
||
Assert.Equal(true, advice!.Value);
|
||
session.Edit(p => Advisor.Apply(p, session.Advice));
|
||
Assert.False(EditorSettings.Deflicker.Effective(session.Project, null), "advice never overrides a manual value");
|
||
|
||
var changes = session.Optimise(AdvisorSection.Exposure);
|
||
Assert.True(EditorSettings.Deflicker.Effective(session.Project, null));
|
||
Assert.True(session.Project.Exposure.Deflicker.IsAuto);
|
||
var change = Assert.Contains(changes, c => c.Parameter == AdvisorParameters.Deflicker);
|
||
Assert.Equal(false, change.Before);
|
||
Assert.Equal(true, change.After);
|
||
|
||
Assert.True(session.Undo());
|
||
Assert.False(session.Project.Exposure.Deflicker.IsAuto, "one undo restores the manual choice");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task WithoutAnalysisOptimiseChangesNothingItCannotMeasure()
|
||
{
|
||
var (session, _) = Open(deep: false);
|
||
await using (session)
|
||
{
|
||
Assert.True(session.Advice.Find(AdvisorParameters.Deflicker)!.IsMissingData);
|
||
var changes = session.Optimise(AdvisorSection.Exposure);
|
||
Assert.DoesNotContain(AdvisorParameters.Deflicker, changes.Select(c => c.Parameter));
|
||
Assert.False(session.Project.Exposure.Deflicker.HasAdvice);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ResetReturnsTheSectionToAuto()
|
||
{
|
||
var (session, _) = Open();
|
||
await using (session)
|
||
{
|
||
session.Edit(p => EditorSettings.Stabilize.WithManual(p, true));
|
||
session.Edit(p => EditorSettings.ShutterAngle.WithManual(p, 90.0));
|
||
session.Edit(p => EditorSettings.Deflicker.WithManual(p, true));
|
||
Assert.False(EditorSettings.IsSectionAuto(session.Project, AdvisorSection.Motion));
|
||
Assert.True(session.ResetSection(AdvisorSection.Motion));
|
||
Assert.True(EditorSettings.IsSectionAuto(session.Project, AdvisorSection.Motion));
|
||
Assert.False(session.Project.Exposure.Deflicker.IsAuto, "other sections keep their values");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ExclusionsAndHeroAreFrameIndices()
|
||
{
|
||
var (session, _) = Open();
|
||
await using (session)
|
||
{
|
||
Assert.True(session.SetExcluded([5, 3, 400], excluded: true));
|
||
Assert.SequenceEqual([3, 5], session.Project.ExcludedFrames);
|
||
Assert.True(session.SetExcluded([3], excluded: false));
|
||
Assert.SequenceEqual([5], session.Project.ExcludedFrames);
|
||
Assert.False(session.SetHero(999));
|
||
Assert.True(session.SetHero(10));
|
||
Assert.Equal(10, session.Project.HeroFrame);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task RenderRequestsEmbedTheProjectAndTheExport()
|
||
{
|
||
var (session, source) = Open();
|
||
await using (session)
|
||
{
|
||
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.7 } });
|
||
var export = session.ExportFor("4k-hevc");
|
||
Assert.Empty(export.Batch);
|
||
var request = session.RenderRequest(export with { Batch = ["1080p-h264"] });
|
||
Assert.Equal(JobKind.Render, request.Kind);
|
||
Assert.SequenceEqual([session.Content.Sequence.Id], request.Targets);
|
||
Assert.Equal(JobPriority.User, request.Priority);
|
||
var parameters = JsonSerializer.Deserialize(request.ParametersJson!, ProtocolJson.Default.RenderJobParameters)!;
|
||
Assert.Equal("hevc", parameters.Codec);
|
||
Assert.Equal(3840, parameters.Width);
|
||
Assert.Contains("1080p-h264", parameters.PresetJson);
|
||
var embedded = ProjectSettings.FromJson(parameters.SettingsJson!);
|
||
Assert.Equal(0.7, embedded.Exposure.ExposureOffsetEv);
|
||
Assert.Equal("4k-hevc", embedded.Export.Preset.Manual);
|
||
|
||
await session.SubmitAsync(request);
|
||
await session.SubmitAsync(session.AnalysisRequest());
|
||
Assert.Equal(2, source.Submitted.Count);
|
||
Assert.Equal(JobKind.DeepAnalyse, source.Submitted[1].Kind);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ASequencePresetKeepsTheUsersFramesAndNaming()
|
||
{
|
||
var (session, _) = Open();
|
||
await using (session)
|
||
{
|
||
session.SetExcluded([1, 2], excluded: true);
|
||
session.SetHero(9);
|
||
session.Edit(p => p with { Export = p.Export with { NameTemplate = "{title}", Overrides = new ExportOverrides { Width = 640 } } });
|
||
var preset = session.Presets.First(p => p.Id == "social-vertical");
|
||
Assert.True(session.ApplyPreset(preset));
|
||
Assert.Equal("9:16", session.Project.Camera.Aspect.Manual);
|
||
Assert.Equal("vertical-1080x1920", session.Project.Export.Preset.Manual);
|
||
Assert.Null(session.Project.Export.Overrides.Width, "the preset's own values");
|
||
Assert.SequenceEqual([1, 2], session.Project.ExcludedFrames);
|
||
Assert.Equal(9, session.Project.HeroFrame);
|
||
Assert.Equal("{title}", session.Project.Export.NameTemplate);
|
||
Assert.True(session.Undo());
|
||
Assert.Equal(640, session.Project.Export.Overrides.Width);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ReloadBringsNewAnalysisAndKeepsUserValues()
|
||
{
|
||
var (session, source) = Open(deep: false);
|
||
await using (session)
|
||
{
|
||
Assert.Null(session.Content.Deep);
|
||
session.Edit(p => p with { HeroFrame = 2 });
|
||
source.Content = EditorFixture.Content(EditorFixture.Sunset, deep: true) with { Sequence = session.Content.Sequence };
|
||
source.Stored = Advisor.Apply(source.Stored, session.Advice);
|
||
var changed = 0;
|
||
session.ContentChanged += () => changed++;
|
||
await session.ReloadAsync();
|
||
Assert.Equal(1, changed);
|
||
Assert.NotNull(session.Content.Deep);
|
||
Assert.False(session.Advice.Find(AdvisorParameters.Deflicker)!.IsMissingData, "advice from the new analysis");
|
||
Assert.Equal(2, session.Project.HeroFrame);
|
||
}
|
||
}
|
||
|
||
// ---- Orientation and framing (owner review 1, R5/R6) ----
|
||
|
||
/// <summary>A project with a manual aspect (the advice never decides it) and a crop.</summary>
|
||
private static ProjectSettings WithAspect(string aspect, double[]? crop = null)
|
||
{
|
||
var project = new ProjectSettings();
|
||
return project with { Camera = project.Camera with { Aspect = project.Camera.Aspect.WithManual(aspect), Crop = crop } };
|
||
}
|
||
|
||
[Test]
|
||
public async Task EachOrientationPressIsOneUndoStepAndTurnsTheCropWithThePicture()
|
||
{
|
||
var (session, _) = Open(WithAspect("16:9", [0.1, 0.2, 0.4, 0.3]));
|
||
await using (session)
|
||
{
|
||
Assert.True(session.Orient(OrientationOp.RotateRight));
|
||
Assert.Equal(90, session.Project.Camera.Rotate);
|
||
Assert.Equal("9:16", session.Project.Camera.Aspect.Manual, "the proportions turn with the picture");
|
||
Assert.SequenceEqual([0.5, 0.1, 0.3, 0.4], session.Project.Camera.Crop!, "the crop keeps the content");
|
||
Assert.True(session.Orient(OrientationOp.Mirror));
|
||
Assert.True(session.Project.Camera.Mirror);
|
||
Assert.SequenceEqual([0.2, 0.1, 0.3, 0.4], session.Project.Camera.Crop!, "mirror maps x to 1 − x − w");
|
||
|
||
Assert.True(session.Undo());
|
||
Assert.False(session.Project.Camera.Mirror, "one press, one step");
|
||
Assert.Equal(90, session.Project.Camera.Rotate);
|
||
Assert.True(session.Undo());
|
||
Assert.Equal(0, session.Project.Camera.Rotate);
|
||
Assert.SequenceEqual([0.1, 0.2, 0.4, 0.3], session.Project.Camera.Crop!);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task OptimiseAfterATurnAdvisesTheAspectOfTheTurnedView()
|
||
{
|
||
var (session, _) = Open();
|
||
await using (session)
|
||
{
|
||
session.Edit(p => Advisor.Apply(p, session.Advice));
|
||
var advised = EditorSettings.Aspect.Effective(session.Project, null);
|
||
Assert.True(advised is "16:9" or "9:16", "the analysis advises a video aspect");
|
||
Assert.True(session.Orient(OrientationOp.RotateRight));
|
||
var turned = EditorSettings.Aspect.Effective(session.Project, null);
|
||
Assert.NotEqual(advised, turned, "the turn transposes the advised aspect");
|
||
|
||
session.Optimise(AdvisorSection.Camera);
|
||
Assert.Equal(turned, EditorSettings.Aspect.Effective(session.Project, null), "the advice is worked out on the turned view");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ATurnSeenThroughAMirrorTurnsThePictureTheWayTheUserPressed()
|
||
{
|
||
var (session, _) = Open(WithAspect("16:9"));
|
||
await using (session)
|
||
{
|
||
session.Orient(OrientationOp.RotateRight);
|
||
Assert.Equal(90, session.Project.Camera.Rotate, "clockwise as stored");
|
||
session.Orient(OrientationOp.Mirror);
|
||
session.Orient(OrientationOp.RotateRight);
|
||
Assert.Equal(0, session.Project.Camera.Rotate, "through one mirror, a clockwise press is an anticlockwise stored turn");
|
||
session.Orient(OrientationOp.Flip);
|
||
session.Orient(OrientationOp.RotateRight);
|
||
Assert.Equal(90, session.Project.Camera.Rotate, "mirror and flip together are a half turn: the sense is kept");
|
||
Assert.True(session.Project.Camera is { Mirror: true, Flip: true });
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task FourRightTurnsGiveBackTheSameCanonicalText()
|
||
{
|
||
var keyed = WithAspect("16:9", [0.1, 0.2, 0.4, 0.3]);
|
||
keyed = keyed with { Camera = keyed.Camera with { Keyframes = [new CameraKey(4, 0.3, 0.6, 1.5, 2)], Straighten = 1.5 } };
|
||
var (session, _) = Open(keyed);
|
||
await using (session)
|
||
{
|
||
var before = session.Project.ToJson();
|
||
for (var i = 0; i < 4; i++) Assert.True(session.Orient(OrientationOp.RotateRight));
|
||
Assert.Equal(before, session.Project.ToJson());
|
||
Assert.Equal(2, session.Project.RequiredFormat, "a straighten needs format 2");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AnAspectChangeRefitsALockedCropAroundItsCentre()
|
||
{
|
||
var (session, _) = Open(WithAspect("16:9"));
|
||
await using (session)
|
||
{
|
||
var ratio = session.CropLockRatio(session.Project);
|
||
var box = CropFrame.Clamp(new RectD(0.2, 0.2, 0.5, 0.5 / ratio), ratio);
|
||
Assert.True(session.Edit(p => p with { Camera = p.Camera with { Crop = CropFrame.ToCrop(box) } }));
|
||
Assert.True(session.Edit(p => EditorSettings.Aspect.WithManual(p, "9:16")));
|
||
var refitted = CropFrame.Of(session.Project.Camera.Crop);
|
||
Assert.Approximately(session.CropLockRatio(session.Project), refitted.Width / refitted.Height, 1e-9, "locked to the new proportions");
|
||
Assert.Approximately(box.CenterX, refitted.CenterX, 1e-9, "the same centre");
|
||
Assert.Approximately(box.CenterY, refitted.CenterY, 1e-9);
|
||
Assert.Approximately(box.Width * box.Height, refitted.Width * refitted.Height, 1e-9, "the same area");
|
||
Assert.True(session.Undo());
|
||
Assert.SequenceEqual(CropFrame.ToCrop(box)!, session.Project.Camera.Crop!, "the aspect and the refit are one step");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ALegacyCropPlacedByOffsetsIsLeftForTheRenderToFit()
|
||
{
|
||
var legacy = WithAspect("16:9", [0, 0, 1, 0.8]);
|
||
legacy = legacy with { Camera = legacy.Camera with { OffsetX = 0.5 } };
|
||
var (session, _) = Open(legacy);
|
||
await using (session)
|
||
{
|
||
Assert.True(session.Edit(p => EditorSettings.Aspect.WithManual(p, "1:1")));
|
||
Assert.SequenceEqual([0.0, 0, 1, 0.8], session.Project.Camera.Crop!);
|
||
Assert.Equal(0.5, session.Project.Camera.OffsetX);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ResetFramingClearsTheCropAndTheOrientationAndKeepsTheKeyframesOnTheirContent()
|
||
{
|
||
var framed = WithAspect("9:16", [0.2, 0, 0.3, 1]);
|
||
var key = new CameraKey(3, 0.4, 0.5, 2, 0);
|
||
framed = framed with
|
||
{
|
||
Camera = framed.Camera with { OffsetX = 0.2, OffsetY = -0.1, Rotate = 270, Mirror = true, Flip = true, Straighten = -3.5, Keyframes = [key] },
|
||
Look = new LookSettings { Filter = "sepia" },
|
||
};
|
||
var (session, _) = Open(framed);
|
||
await using (session)
|
||
{
|
||
Assert.True(EditorSession.HasFraming(session.Project.Camera));
|
||
Assert.True(session.ResetFraming());
|
||
var camera = session.Project.Camera;
|
||
Assert.Null(camera.Crop);
|
||
Assert.True(camera is { OffsetX: 0, OffsetY: 0, Rotate: 0, Mirror: false, Flip: false, Straighten: 0 });
|
||
var back = OrientationEdit.Apply(OrientationEdit.Apply(OrientationEdit.Apply(OrientationEdit.Apply(OrientationEdit.Apply(framed,
|
||
OrientationOp.Flip), OrientationOp.Mirror), OrientationOp.RotateLeft), OrientationOp.RotateLeft), OrientationOp.RotateLeft);
|
||
Assert.SequenceEqual(back.Camera.Keyframes, camera.Keyframes, "keyframes stay on the content they framed");
|
||
Assert.Equal(1, camera.Keyframes.Count);
|
||
Assert.Equal("16:9", camera.Aspect.Manual, "the aspect turns back with the picture");
|
||
Assert.Equal("sepia", session.Project.Look?.Filter, "nor the look");
|
||
Assert.False(EditorSession.HasFraming(camera));
|
||
Assert.False(session.ResetFraming(), "nothing left to clear");
|
||
Assert.True(session.Undo());
|
||
Assert.Equal(270, session.Project.Camera.Rotate, "one step");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public void ResetFramingTurnsAKeyframeBackWithThePicture()
|
||
{
|
||
var turned = new ProjectSettings();
|
||
turned = turned with { Camera = turned.Camera with { Rotate = 90, Aspect = turned.Camera.Aspect.WithManual("9:16"), Keyframes = [new CameraKey(2, 0.2, 0.3, 1.5, 0)] } };
|
||
var reset = EditorSession.WithoutFraming(turned);
|
||
var (x, y) = OrientationEdit.MapPoint(0.2, 0.3, OrientationOp.RotateLeft);
|
||
Assert.True(reset.Camera.Keyframes[0] is { CenterX: var cx, CenterY: var cy } && cx == x && cy == y, "moved as the picture turns back");
|
||
Assert.True((x, y) != (0.2, 0.3));
|
||
Assert.Equal("16:9", reset.Camera.Aspect.Manual);
|
||
var again = OrientationEdit.Apply(reset, OrientationOp.RotateRight);
|
||
Assert.True(again.Camera is { Rotate: 90 } && again.Camera.Keyframes[0] is { CenterX: 0.2, CenterY: 0.3 }, "turning again puts it where it was");
|
||
Assert.Equal("9:16", again.Camera.Aspect.Manual);
|
||
}
|
||
|
||
[Test]
|
||
public async Task ASequencePresetKeepsTheOrientationAndTheLook()
|
||
{
|
||
var turned = new ProjectSettings() with { Look = new LookSettings { Filter = "mono", Strength = 0.5 } };
|
||
turned = turned with { Camera = turned.Camera with { Rotate = 90, Mirror = true, Straighten = 2 } };
|
||
var (session, _) = Open(turned);
|
||
await using (session)
|
||
{
|
||
Assert.True(session.ApplyPreset(session.Presets.First(p => p.Id == "social-vertical")));
|
||
Assert.True(session.Project.Camera is { Rotate: 90, Mirror: true, Straighten: 2 });
|
||
Assert.Equal("mono", session.Project.Look?.Filter);
|
||
Assert.Equal(0.5, session.Project.Look?.Strength);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AReadOnlyProjectIsNeitherTurnedNorReset()
|
||
{
|
||
var (session, source) = Open(WithAspect("16:9", [0.1, 0.2, 0.4, 0.3]));
|
||
await using (session)
|
||
{
|
||
source.IsReadOnly = true;
|
||
Assert.False(session.Orient(OrientationOp.RotateLeft));
|
||
Assert.False(session.ResetFraming());
|
||
Assert.Equal(0, session.Project.Camera.Rotate);
|
||
Assert.NotNull(session.Project.Camera.Crop);
|
||
}
|
||
}
|
||
}
|