From 366dd9f303c4c7cc658fe3d3ebce74d4ca8ca074 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 11:17:38 +0000 Subject: [PATCH] feat(advice): time intervalometer sequences adaptively and list unreadable frames once MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The MakerNote interval-shooting hint (Panasonic TimerRecording) is kept as FrameFlags.Intervalometer from indexing on, so it reaches the sidecar, the index, sync and the protocol. When most frames carry it, gaps in the cadence are the intervalometer's deliberate pauses and the advisor picks adaptive timing (Advisor.Reason.Timing.Intervalometer, BRIEF §10.3). Frames both analyses find undecodable are now one finding over the union of both lists at the higher severity: the deep pass also lists missing, corrupt and beyond-this-host frames, which the light analysis never flags. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- i18n/en/Advisor.resx | 1 + i18n/it/Advisor.it.resx | 1 + src/Titano.Core/Advice/Advisor.cs | 25 +++++++++++++++---- src/Titano.Core/Advice/AdvisorKeys.cs | 1 + src/Titano.Core/Advice/AdvisorRules.cs | 17 +++++++++---- .../Analysis/LightAnalysisReport.cs | 3 +++ src/Titano.Core/Analysis/LightAnalyzer.cs | 1 + src/Titano.Core/Archiving/SequenceFrames.cs | 3 ++- src/Titano.Core/Model/Enums.cs | 6 +++++ 9 files changed, 47 insertions(+), 11 deletions(-) diff --git a/i18n/en/Advisor.resx b/i18n/en/Advisor.resx index c76505d4..27db3d3f 100644 --- a/i18n/en/Advisor.resx +++ b/i18n/en/Advisor.resx @@ -97,6 +97,7 @@ Smoothing the camera path over {0} frames removes shake and keeps deliberate pans.{0} smoothing sigma in frames Strong flicker ({0} EV): every frame lands on the smooth curve.{0} RMS flicker in EV Mild flicker ({0} EV): reliable frames keep 20% of their own variation.{0} RMS flicker in EV + The camera's intervalometer shot this sequence, so its pauses were deliberate (gaps: {0}): adaptive timing keeps them short and the pace even.{0} gap count Intervals vary by {0} s around {1} s: adaptive timing follows the capture clock so motion stays even.{0} interval jitter in seconds; {1} median interval in seconds {0} gaps in the cadence: adaptive timing keeps the output pace true to capture time.{0} gap count Steady {0} s interval (jitter {1} s): each photo becomes one video frame.{0} median interval in seconds; {1} jitter in seconds diff --git a/i18n/it/Advisor.it.resx b/i18n/it/Advisor.it.resx index c199c431..88a10f18 100644 --- a/i18n/it/Advisor.it.resx +++ b/i18n/it/Advisor.it.resx @@ -97,6 +97,7 @@ Smussare il percorso della fotocamera su {0} fotogrammi elimina la vibrazione e conserva le panoramiche volute. Sfarfallio forte ({0} EV): ogni fotogramma viene portato sulla curva regolare. Sfarfallio lieve ({0} EV): i fotogrammi affidabili conservano il 20% della propria variazione. + La sequenza è stata scattata dall'intervallometro della fotocamera, quindi le pause sono volute (pause: {0}): la temporizzazione adattiva le accorcia e mantiene il ritmo. Gli intervalli variano di {0} s attorno a {1} s: la temporizzazione adattiva segue l'orario di scatto e rende il movimento uniforme. {0} pause nella cadenza: la temporizzazione adattiva mantiene il ritmo fedele all'orario di scatto. Intervallo costante di {0} s (variazione {1} s): ogni foto diventa un fotogramma del video. diff --git a/src/Titano.Core/Advice/Advisor.cs b/src/Titano.Core/Advice/Advisor.cs index 32217eb1..2f447b58 100644 --- a/src/Titano.Core/Advice/Advisor.cs +++ b/src/Titano.Core/Advice/Advisor.cs @@ -16,17 +16,32 @@ public static class Advisor { /// /// Recommendations for every parameter the rules cover (see ), in section order, plus - /// every finding of both analyses; a finding both report (frames that cannot be decoded: the light analysis reads - /// the flags the deep pass recorded) is listed once, as the light analysis has it. Without a deep report, - /// pixel-based parameters get missing-data recommendations. + /// every finding of both analyses. Frames that cannot be decoded are reported by both (the light analysis reads the + /// undecodable flags, the deep pass also counts missing and corrupt files and those beyond this host's decoders): + /// they are listed once, over the union of both lists, at the higher severity. Without a deep report, pixel-based + /// parameters get missing-data recommendations. /// public static AdvisorResult Recommend(LightAnalysisReport light, DeepAnalysisReport? deep, SequenceContext context) { ArgumentNullException.ThrowIfNull(light); ArgumentNullException.ThrowIfNull(context); var findings = new List(light.Findings); - var lightKeys = light.Findings.Select(f => f.Key).ToHashSet(StringComparer.Ordinal); - if (deep is not null) findings.AddRange(deep.Findings.Select(f => f.ToFinding()).Where(f => !lightKeys.Contains(f.Key))); + foreach (var finding in deep?.Findings.Select(f => f.ToFinding()) ?? []) + { + var shared = finding.Key == DeepFindingKeys.UnreadableFrames ? findings.FindIndex(f => f.Key == finding.Key) : -1; + if (shared < 0) + { + findings.Add(finding); + continue; + } + var unreadable = light.UndecodableFrames.Union(deep!.Issues.Undecodable).Order().ToList(); + findings[shared] = findings[shared] with + { + Severity = (FindingSeverity)int.Max((int)findings[shared].Severity, (int)finding.Severity), + Arguments = [unreadable.Count], + Frames = [.. unreadable.Take(Finding.MaxFrames)], + }; + } return new AdvisorResult(new AdvisorRules(light, deep, context).Run(), findings); } diff --git a/src/Titano.Core/Advice/AdvisorKeys.cs b/src/Titano.Core/Advice/AdvisorKeys.cs index 305a8bd5..8c3c89d8 100644 --- a/src/Titano.Core/Advice/AdvisorKeys.cs +++ b/src/Titano.Core/Advice/AdvisorKeys.cs @@ -19,6 +19,7 @@ public static class AdvisorKeys public static string TimingSessions { get; } = LocKey("Advisor.Reason.Timing.Sessions"); public static string TimingIrregular { get; } = LocKey("Advisor.Reason.Timing.Irregular"); + public static string TimingIntervalometer { get; } = LocKey("Advisor.Reason.Timing.Intervalometer"); public static string TimingSparseGapsSmooth { get; } = LocKey("Advisor.Reason.Timing.SparseGapsSmooth"); public static string TimingSparseGaps { get; } = LocKey("Advisor.Reason.Timing.SparseGaps"); public static string TimingManyGaps { get; } = LocKey("Advisor.Reason.Timing.ManyGaps"); diff --git a/src/Titano.Core/Advice/AdvisorRules.cs b/src/Titano.Core/Advice/AdvisorRules.cs index 00cef188..4a34dcbe 100644 --- a/src/Titano.Core/Advice/AdvisorRules.cs +++ b/src/Titano.Core/Advice/AdvisorRules.cs @@ -185,11 +185,13 @@ internal sealed class AdvisorRules /// /// Timing mode, in order: several capture sessions (pauses ≥ the session gap) → Adaptive; jitter above 10 % of the - /// median interval → Adaptive; gaps that are sparse (≤ 2 % of intervals, each ≤ 10 × median) with smooth measured - /// motion (95th percentile ≤ 1 % of the long edge per frame) → Interpolated, or Constant when motion is unknown or - /// fast; denser gaps → Adaptive; otherwise Constant. Frame rate, in order: "fit to N s" target → the standard rate - /// nearest frames/N; under 240 frames → 24 (clip ≥ 10 s); over 10 min at 30 fps → 60; several sessions → 30; fast - /// motion (≥ 1 % of the long edge per frame) → 24; measured moderate motion (≥ 0.2 %) → 24; otherwise 30. + /// median interval → Adaptive; gaps in a sequence the camera's own intervalometer shot (most frames carry its + /// MakerNote hint), so its pauses were deliberate → Adaptive; gaps that are sparse (≤ 2 % of intervals, each ≤ 10 × + /// median) with smooth measured motion (95th percentile ≤ 1 % of the long edge per frame) → Interpolated, or Constant + /// when motion is unknown or fast; denser gaps → Adaptive; otherwise Constant. Frame rate, in order: "fit to N s" + /// target → the standard rate nearest frames/N; under 240 frames → 24 (clip ≥ 10 s); over 10 min at 30 fps → 60; + /// several sessions → 30; fast motion (≥ 1 % of the long edge per frame) → 24; measured moderate motion (≥ 0.2 %) → + /// 24; otherwise 30. /// private void Timing() { @@ -222,6 +224,11 @@ internal sealed class AdvisorRules _timing = TimingMode.Adaptive; Add(section, parameter, _timing, 0.7, AdvisorKeys.TimingIrregular, R(jitter, 2), R(median, 2)); } + else if (gaps.Count > 0 && 2 * _light.IntervalometerFrames > _light.FrameCount) + { + _timing = TimingMode.Adaptive; + Add(section, parameter, _timing, 0.8, AdvisorKeys.TimingIntervalometer, gaps.Count); + } else if (gaps.Count > 0) { var sparse = gaps.Count <= double.Max(1, 0.02 * _light.Intervals.Count) && gaps.All(g => g.Seconds <= 10 * median); diff --git a/src/Titano.Core/Analysis/LightAnalysisReport.cs b/src/Titano.Core/Analysis/LightAnalysisReport.cs index 9e7fe647..fedd5360 100644 --- a/src/Titano.Core/Analysis/LightAnalysisReport.cs +++ b/src/Titano.Core/Analysis/LightAnalysisReport.cs @@ -137,5 +137,8 @@ public sealed record LightAnalysisReport /// Frames that nothing decodes (format tier 3): renders skip them. public IReadOnlyList UndecodableFrames { get; init; } = []; + /// Frames the camera's own interval-shooting mode took (MakerNote hint, ). + public int IntervalometerFrames { get; init; } + public IReadOnlyList Findings { get; init; } = []; } diff --git a/src/Titano.Core/Analysis/LightAnalyzer.cs b/src/Titano.Core/Analysis/LightAnalyzer.cs index aa1f0c1a..be8685d8 100644 --- a/src/Titano.Core/Analysis/LightAnalyzer.cs +++ b/src/Titano.Core/Analysis/LightAnalyzer.cs @@ -61,6 +61,7 @@ public static class LightAnalyzer DayPhases = phases, PreviewOnlyFrames = previewOnly, UndecodableFrames = undecodable, + IntervalometerFrames = frames.Count(f => (f.Flags & FrameFlags.Intervalometer) != 0), Findings = findings, }; } diff --git a/src/Titano.Core/Archiving/SequenceFrames.cs b/src/Titano.Core/Archiving/SequenceFrames.cs index 8f79a8de..5f72d16b 100644 --- a/src/Titano.Core/Archiving/SequenceFrames.cs +++ b/src/Titano.Core/Archiving/SequenceFrames.cs @@ -14,7 +14,7 @@ public static class SequenceFrames return byTime != 0 ? byTime : string.CompareOrdinal(a.File, b.File); }); - /// A frame record from light metadata. + /// A frame record from light metadata (with when the MakerNote says so). /// Path relative to the sequence folder. /// Used when the file records no capture time of its own (only a file-system date). public static SidecarFrame FromMetadata(Guid id, string file, string? original, long size, string? sha256, FrameMetadata metadata, @@ -45,6 +45,7 @@ public static class SequenceFrames PreviewLength = metadata.LargestPreview?.Length, PreviewW = Positive(metadata.LargestPreview?.Width), PreviewH = Positive(metadata.LargestPreview?.Height), + Flags = metadata.IntervalShooting == true ? FrameFlags.Intervalometer : FrameFlags.None, }; } diff --git a/src/Titano.Core/Model/Enums.cs b/src/Titano.Core/Model/Enums.cs index 2bb39f50..d6dcfd3c 100644 --- a/src/Titano.Core/Model/Enums.cs +++ b/src/Titano.Core/Model/Enums.cs @@ -24,6 +24,12 @@ public enum FrameFlags Undecodable = 32, Black = 64, White = 128, + + /// + /// The camera's own interval-shooting or time-lapse mode took the frame (MakerNote hint, BRIEF §9): a capture fact, + /// not a problem; its pauses were deliberate (§10.3 adaptive timing). + /// + Intervalometer = 256, } [Flags]