public static IEnumerable<ImageJob> ProcessImageJobs(ImageJobs imageJobs) { return imageJobs .Images .Select(TryProcessImageJob) .SelectWhereValueExist(i => i); }
/// <summary> /// Culls the deleted snapshots from ImageJobs and produces a new ImageJobs object /// with the remaining snapshots /// </summary> /// <param name="oldImageJobs">The old ImageJobs object</param> /// <param name="remainingSnapshots">The path to all of the remaining snapshots</param> /// <returns>A new ImageJobs object</returns> public static ImageJobs CoalesceDeletedSnapshots( ImageJobs oldImageJobs, IEnumerable<string> remainingSnapshots ) { var setOfRemainingSnapshots = new HashSet<string>(remainingSnapshots); var newImageJobs = oldImageJobs.Images.Select(s => ProcessImageJob(s, setOfRemainingSnapshots)); return new ImageJobs { Images = newImageJobs.ToArray(), }; }
/// <summary> /// Harvest all of the possible images for a given ImageJob /// </summary> /// <param name="imageJobs">The old ImageJobs object</param> /// <param name="mediaFilePaths">The path to every single media file</param> /// <returns>An new ImageJobs object with paths to the snapshots for every ImageJob</returns> public static ImageJobs HarvestCandidateImages( ImageJobs imageJobs, IEnumerable<string> mediaFilePaths ) { IDictionary<TimeSpan, ImageJobGroup> imageGroups = ImageJobGrouper.GroupImageJobs(imageJobs); IDictionary<ImageJobGroup, IEnumerable<string>> mapFromGroupsToSnapshots = imageGroups.AsParallel().ToDictionary(kvp => kvp.Value, kvp => TakeSnapshots(kvp.Value, mediaFilePaths)); return new ImageJobs { Images = UpdateImageJobs(mapFromGroupsToSnapshots).ToArray(), }; }
/// <summary> /// Delete the snapshots that are referenced in <paramref name="oldImageJobs"/> but /// not in <paramref name="newImageJobs"/> /// </summary> /// <param name="oldImageJobs">The old image job</param> /// <param name="newImageJobs">The new image job</param> public static void DeleteUnusedSnapshots(ImageJobs oldImageJobs, ImageJobs newImageJobs) { IEnumerable<string> masterSetOfFiles = from imageJob in oldImageJobs.Images from snapshot in imageJob.ImageSnapshots select snapshot; IEnumerable<string> snapshotsToKeep = from imageJob in newImageJobs.Images from snapshot in imageJob.ImageSnapshots select snapshot; var filesToRemove = masterSetOfFiles.Except(snapshotsToKeep); foreach (var fileToRemove in filesToRemove) { File.Delete(fileToRemove); } }
/// <summary> /// Main method that executes on startup /// </summary> /// <param name="args"></param> public static void Main(string[] args) { var imageJobs = CommonFunctions.TryReadStandardIn(); if (imageJobs.IsNothing()) { PrintHelp(); return; } var processedImageJobs = ScrapeJobProcessor.ProcessImageJobs(imageJobs.Value); var newImageModel = new ImageJobs { Images = processedImageJobs.ToArray(), }; Console.WriteLine(JsonConvert.SerializeObject(newImageModel)); CommonFunctions.CloseAllStandardFileHandles(); }
public static void Main(string[] args) { if (args.Length < 1) { PrintHelp(); return; } IEnumerable<ImageSliceContext> processedSlices = ImageProcessor.ProcessFiles(args); IEnumerable<Maybe<ImageJob>> imageJobsMaybe = processedSlices.Select(Convert); var imageJobs = new ImageJobs { Images = imageJobsMaybe.SelectWhereValueExist(t => t).ToArray(), }; Console.WriteLine(JsonConvert.SerializeObject(imageJobs, Formatting.None)); CommonFunctions.CloseAllStandardFileHandles(); }
private static ImageJobs ShiftAllJobs(ImageJobs oldImageJobs, int secondsToShift) { var shiftedImageJobList = new List<ImageJob>(); foreach (ImageJob job in oldImageJobs.Images) { shiftedImageJobList.Add(new ImageJob { ImageSnapshots = job.ImageSnapshots, OriginalFilePath = job.OriginalFilePath, SliceImagePath = job.SliceImagePath, SnapshotTimestamp = job.SnapshotTimestamp + new TimeSpan(0, 0, secondsToShift), }); } return new ImageJobs { Images = shiftedImageJobList.ToArray(), }; }
/// <summary> /// The main function that executes for the Match process /// </summary> /// <param name="args"></param> public static void Main(string[] args) { Maybe<ImageJobs> imageJobsMaybe = CommonFunctions.TryReadStandardIn(); if (imageJobsMaybe.IsNothing()) { PrintHelp(); return; } using (new TimingToken("Match", true)) { IDictionary<ImageJob, IEnumerable<string>> jobToSnapshotMap = ImageMatcher.GetMatches(imageJobsMaybe.Value); ImageJob[] processedJobs = UpdateSnapshotResults(jobToSnapshotMap).ToArray(); var processedImageJobs = new ImageJobs { Images = processedJobs, }; SnapshotDeleter.DeleteUnusedSnapshots(imageJobsMaybe.Value, processedImageJobs); Console.WriteLine(JsonConvert.SerializeObject(processedImageJobs)); } CommonFunctions.CloseAllStandardFileHandles(); }
/// <summary> /// Groups ImageJobs by their timestamp /// </summary> /// <param name="imageJobs">The ImageJobs object containing all of the individual ImageJob(s)</param> /// <returns>A map between timestamps and ImageJobGroups</returns> public static IDictionary<TimeSpan, ImageJobGroup> GroupImageJobs(ImageJobs imageJobs) { var groups = new Dictionary<TimeSpan, ImageJobGroup>(); foreach (var imageJob in imageJobs.Images) { var focusTimeSpan = imageJob.SnapshotTimestamp; ImageJobGroup group; if (groups.TryGetValue(focusTimeSpan, out group) == false) { group = new ImageJobGroup { Jobs = new HashSet<ImageJob>(), Timestamp = focusTimeSpan, }; groups.Add(focusTimeSpan, group); } group.Jobs.Add(imageJob); } return groups; }
/// <summary> /// Detects the best matching snapshot for an ImageJob /// </summary> /// <param name="imageJobs">The ImageJobs to match</param> /// <returns>A dictionary between an ImageJob its matching snapshot</returns> public static IDictionary<ImageJob, IEnumerable<string>> GetMatches(ImageJobs imageJobs) { return imageJobs.Images.ToDictionary(i => i, TryFindMatchingSnapshots); }
private async static Task<string> ProcessImageJobAsync(ImageJob imageJob, string folderOfMediaFiles) { var newImageJobs = new ImageJobs { Images = new[] { imageJob }, }; var serializedNewImageJobs = JsonConvert.SerializeObject(newImageJobs); using (var rip = new GeneralProcess(RIP, string.Format("\"{0}\"", folderOfMediaFiles))) { using (var dedup = new GeneralProcess(DEDUP)) { using (var match = new GeneralProcess(MATCH)) { string ripOutput = await rip.ExecuteAsync(serializedNewImageJobs.ToMaybe()); string dedupOutput = await dedup.ExecuteAsync(ripOutput.ToMaybe()); string matchOutput = await match.ExecuteAsync(dedupOutput.ToMaybe()); MoveCompletedPhotos(matchOutput); return matchOutput; } } } }
private static IEnumerable<string> GetAllImagePaths(ImageJobs imageJobs) { return new HashSet<string>(imageJobs.Images.SelectMany(s => s.ImageSnapshots)); }
/// <summary> /// Load all of the images from disk and resize them /// </summary> /// <param name="imageJobs"></param> /// <returns></returns> public static IEnumerable<SnapshotContext> LoadSnapshots(ImageJobs imageJobs) { return GetAllImagePaths(imageJobs) .Select(TryLoadSnapshot) .SelectWhereValueExist(i => i); }