feat(import): import a whole folder as one sequence per format

Owner review 2, R9: Import › Folder… gains a "Group" choice for picked
folders: Sessions (as before) or Whole folder. A whole folder, with its
subfolders when Subfolders is on, becomes one sequence per file format;
camera bodies and pauses are ignored, while RAW+JPEG of the same shots
stays two sequences so no frame is ever doubled. Only the user's splits
break it, and Merge joins a split part back.

The planner implements it (ImportOptions.Grouping, Core, Linux-tested):
the session key is "folder-" plus a hash of this PC's name, the full
path and the format, so an interrupted or repeated import continues the
same sequence; the default title is the folder's name. The plan shows
one row per format with the format and the number of cameras. Cards and
drives always import by sessions; the choice is not part of a card
profile and a folder starts on Sessions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-10-26 22:00:55 +01:00
1 parent 5209579631
commit 445dfd41a3
14 files changed
+419 -26

No files matched your search

+55 -9
View File
@@ -2,6 +2,7 @@ using System.Globalization;
using System.Security.Cryptography;
using System.Text;
using Chronos.Core.Archiving;
using Chronos.Core.Imaging;
using Chronos.Core.Naming;
namespace Chronos.Core.Import;
@@ -33,16 +34,29 @@ public static class ImportPlanner
{
var folderTemplate = PathTemplate.Parse(options.FolderTemplate);
var fileTemplate = PathTemplate.Parse(options.FileTemplate);
var wholeFolder = options.Grouping == ImportGrouping.WholeFolder;
var folderName = wholeFolder ? FolderName(sourceRoot) : null;
var drafts = new List<(string Key, List<CardPhoto> Photos)>();
foreach (var body in photos.GroupBy(BodyKey, StringComparer.Ordinal))
// A whole folder groups by file format alone, never by camera body: RAW+JPEG of the same shots must stay two
// sequences, or each frame would appear twice in one.
Func<CardPhoto, string> groupKey = wholeFolder ? FormatKey : BodyKey;
foreach (var group in photos.GroupBy(groupKey, StringComparer.Ordinal))
{
var ordered = body.OrderBy(p => p.CaptureTime).ThenBy(p => p.File.RelativePath, StringComparer.Ordinal).ToList();
var ranges = SessionSplitter.Split(ordered.ConvertAll(p => p.CaptureTime), options.SessionGap, options.MinimumSessionFrames,
i => options.SplitBefore.Contains(ordered[i].File.RelativePath) ? true : options.MergeAt.Contains(ordered[i].File.RelativePath) ? false : null);
foreach (var range in ranges)
var ordered = group.OrderBy(p => p.CaptureTime).ThenBy(p => p.File.RelativePath, StringComparer.Ordinal).ToList();
var times = ordered.ConvertAll(p => p.CaptureTime);
bool? UserBreak(int i) =>
options.SplitBefore.Contains(ordered[i].File.RelativePath) ? true : options.MergeAt.Contains(ordered[i].File.RelativePath) ? false : null;
// Only the user's splits break a whole folder: no pause starts a session and no group is too small to stand.
var ranges = wholeFolder
? SessionSplitter.Split(times, TimeSpan.MaxValue, 1, UserBreak)
: SessionSplitter.Split(times, options.SessionGap, options.MinimumSessionFrames, UserBreak);
for (var r = 0; r < ranges.Count; r++)
{
var members = ordered.GetRange(range.Start, range.Count);
drafts.Add((SessionKey(body.Key, members[0].CaptureTime), members));
var members = ordered.GetRange(ranges[r].Start, ranges[r].Count);
var key = wholeFolder
? FolderKey(sourceRoot, members[0].Metadata.Format, r == 0 ? null : members[0].CaptureTime)
: SessionKey(group.Key, members[0].CaptureTime);
drafts.Add((key, members));
}
}
drafts.Sort((a, b) => a.Photos[0].CaptureTime.CompareTo(b.Photos[0].CaptureTime) is var c and not 0 ? c : string.CompareOrdinal(a.Key, b.Key));
@@ -53,7 +67,7 @@ public static class ImportPlanner
{
var (key, members) = drafts[s];
var first = members[0];
options.Titles.TryGetValue(key, out var title);
var title = options.Titles.GetValueOrDefault(key) ?? folderName;
var context = Context(first, first.CaptureTime, s + 1, 1, title);
var folder = await lookup.FindSessionFolderAsync(key, cancellationToken).ConfigureAwait(false)
?? UniqueFolder(folderTemplate.ExpandFolder(context), claimedFolders, lookup);
@@ -74,11 +88,13 @@ public static class ImportPlanner
CameraMake = first.Metadata.Make,
CameraModel = first.Metadata.Model,
CameraSerial = first.Metadata.BodySerial,
Cameras = CountCameras(members),
Format = first.Metadata.Format,
Start = first.CaptureTime,
End = members[^1].CaptureTime,
Folder = folder,
Title = title,
DefaultTitle = folderName,
Items = items,
});
}
@@ -88,6 +104,7 @@ public static class ImportPlanner
SourceRoot = Path.GetFullPath(sourceRoot),
DestinationRoot = Path.GetFullPath(destinationRoot),
Created = DateTimeOffset.UtcNow,
Grouping = options.Grouping,
Sessions = sessions,
Problems = problems,
AvailableBytes = FreeSpace(destinationRoot),
@@ -139,12 +156,41 @@ public static class ImportPlanner
};
/// <summary>Camera body and file format: RAW+JPEG shooting yields two sequences instead of doubled frames.</summary>
private static string BodyKey(CardPhoto p) => $"{p.Metadata.Make}|{p.Metadata.Model}|{p.Metadata.BodySerial}|{p.Metadata.Format}";
private static string BodyKey(CardPhoto p) => $"{CameraKey(p)}|{p.Metadata.Format}";
private static string CameraKey(CardPhoto p) => $"{p.Metadata.Make}|{p.Metadata.Model}|{p.Metadata.BodySerial}";
/// <summary>Camera bodies that took the photos; a photo without a camera in its metadata is no body of its own.</summary>
private static int CountCameras(List<CardPhoto> photos) =>
System.Math.Max(1, photos.Where(p => p.Metadata.Model is not null).Select(CameraKey).Distinct(StringComparer.Ordinal).Count());
/// <summary>File format alone (a whole folder): RAW+JPEG still yields two sequences instead of doubled frames.</summary>
private static string FormatKey(CardPhoto p) => p.Metadata.Format.ToString();
private static string SessionKey(string bodyKey, DateTime start) =>
"card-" + Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(bodyKey)))[..8] + "-"
+ start.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
/// <summary>
/// The key of a whole folder's sequence: the same folder of this PC and the same format always give the same key,
/// so an interrupted import resumes into its sequence and a later import of the folder adds to it. A part the user
/// split off also carries the time of its first photo.
/// </summary>
internal static string FolderKey(string sourceRoot, ImageFileFormat format, DateTime? splitAt = null)
{
var path = Path.TrimEndingDirectorySeparator(Path.GetFullPath(sourceRoot));
// Windows compares paths without case: D:\Trip and d:\trip are one folder.
if (OperatingSystem.IsWindows()) path = path.ToUpperInvariant();
// The same path on another PC is another folder: a server files every client's uploads by these keys.
var identity = $"{Environment.MachineName.ToUpperInvariant()}|{path}|{format}";
var key = "folder-" + Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(identity)))[..16];
return splitAt is { } start ? key + "-" + start.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture) : key;
}
/// <summary>The picked folder's own name, the default title of a whole folder; null for a drive root.</summary>
private static string? FolderName(string sourceRoot) =>
Path.GetFileName(Path.TrimEndingDirectorySeparator(Path.GetFullPath(sourceRoot))) is { Length: > 0 } name ? name : null;
private static string UniqueFolder(string folder, HashSet<string> claimed, IImportLookup lookup)
{
if (folder.Length == 0) folder = "Import";