maddo/Catalog
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases 2 Packages Wiki Activity Actions

2024 reopening

Browse source
This commit is contained in:
MaddoScientisto 2024-10-14 18:54:30 +02:00
commit 99b67870a5
73 changed files with 27484 additions and 417 deletions
Download patch file Download diff file Expand all files Collapse all files

194
MaddoShared.backup/ImageCreationStuff.cs Normal file
View file

@ -0,0 +1,194 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using CatalogVbLib;
using Dasync.Collections;
namespace MaddoShared
{
public class ImageCreationStuff
{
public class Options
{
public bool AggiornaSottodirectory { get; set; }
public bool CreaSottocartelle { get; set; }
public int FilePerCartella { get; set; }
public string SuffissoCartelle { get; set; }
public int CifreContatore { get; set; }
public NumerazioneType NumerazioneType { get; set; }
public string SourcePath { get; set; }
public string DestinationPath { get; set; }
public int MaxThreads { get; set; }
public int ChunksSize { get; set; }
public bool LinearExecution { get; set; }
}
public async Task<string> CreaCatalogoParallel(Options options, ConcurrentBag<string> results, EventHandler<Tuple<string,int>> updateEvent, CancellationToken cancellationToken = default(CancellationToken))
{
var stopwatch = new Stopwatch();
stopwatch.Start();
// todo immagini counter
//todo set label
await CreaImmaginiParallel(options, results, updateEvent, cancellationToken);
// todo set finito label
stopwatch.Stop();
return $"{stopwatch.Elapsed.Hours}h {stopwatch.Elapsed.Minutes}m ${stopwatch.Elapsed.Seconds}s ({stopwatch.Elapsed.TotalSeconds}s)";
}
public async Task CreaImmaginiParallel(Options options, ConcurrentBag<string> results, EventHandler<Tuple<string, int>> updateEvent, CancellationToken cancellationToken = default(CancellationToken))
{
var dataToProcess = new List<FileData>();
if (options.AggiornaSottodirectory && options.CreaSottocartelle)
{
var helper = new FileHelperSharp();
dataToProcess = helper.GetFilesRecursive(new DirectoryInfo(options.SourcePath), new DirectoryInfo(options.DestinationPath),
"*.jpg", new FileHelperOptions()
{
FilesPerFolder = options.FilePerCartella,
Suffix = options.SuffissoCartelle,
CounterSize = options.CifreContatore,
NumerationType = options.NumerazioneType
});
}
else if (!options.CreaSottocartelle)
{
var files = Directory.EnumerateFiles(options.SourcePath, "*.jpg",
options.AggiornaSottodirectory
? SearchOption.AllDirectories
: SearchOption.TopDirectoryOnly);
dataToProcess = files.Select(x =>
{
var fInfo = new FileInfo(x);
var filePath = fInfo.DirectoryName;
var trimmedSourcePath = options.SourcePath.TrimEnd('\\');
var newFilePath = fInfo.FullName.Replace(trimmedSourcePath, "").TrimStart('\\');
newFilePath = Path.Combine(options.DestinationPath, newFilePath);
var destFolderPath = new FileInfo(newFilePath).DirectoryName;
var destFolderInfo = new DirectoryInfo(destFolderPath);
destFolderInfo.EnsureDirectoryExists();
return new FileData(fInfo, new DirectoryInfo(new FileInfo(newFilePath).DirectoryName));
}).ToList();
//// TODO
//dataToProcess =
// (from f in Directory.EnumerateFiles(options.SourcePath, "*.jpg",
// options.AggiornaSottodirectory
// ? SearchOption.AllDirectories
// : SearchOption.TopDirectoryOnly)
// select new FileData(new FileInfo(f),
// new DirectoryInfo(options.DestinationPath.PathCombine(
// new FileInfo(f).DirectoryName.Replace(options.SourcePath.TrimEnd(new char[] {'\\'}), "")
// )
// )
// )
// )
// .ToList();
}
var threads = options.MaxThreads == 0 ? Environment.ProcessorCount * 2 : options.MaxThreads;
var scheduler = new ConcurrentExclusiveSchedulerPair(TaskScheduler.Default, threads)
.ConcurrentScheduler;
//var allTasks = new List<Task>();
var test = from d in dataToProcess
select Task.Factory.StartNew(async () =>
{
await new ImageCreatorSharp(d.File, d.Directory).CreaImmagineThread(d.File.Name);
//var imgC = new ImageCreatorSharp(d.File, d.Directory);
//imgC.CreaImmagineThread(d.File.Name);
//imgC = null;
}, CancellationToken.None, TaskCreationOptions.None, scheduler);
//int count = 0;
if (options.LinearExecution)
{
foreach (var task in test)
{
await task;
}
}
else
{
if (options.ChunksSize == 0)
{
//var opts = new ParallelOptions() { MaxDegreeOfParallelism = threads, CancellationToken = cancellationToken, TaskScheduler = scheduler};
await dataToProcess.ParallelForEachAsync(async fileData =>
{
await new ImageCreatorSharp(fileData.File, fileData.Directory).CreaImmagineThread(fileData.File.Name);
results.Add(fileData.File.Name);
//count = Interlocked.Increment(ref count);
try
{
updateEvent?.Invoke(this, new Tuple<string, int>(fileData.File.Name, dataToProcess.Count) );
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}, maxDegreeOfParallelism: threads, false, cancellationToken);
}
else
{
var asdf = SplitList(dataToProcess.ToList(), options.ChunksSize).ToList();
foreach (var sdaf in asdf)
{
await sdaf.ParallelForEachAsync(async fileData =>
{
await new ImageCreatorSharp(fileData.File, fileData.Directory).CreaImmagineThread(fileData.File.Name);
results.Add(fileData.File.Name);
//count = Interlocked.Increment(ref count);
try
{
updateEvent?.Invoke(this, new Tuple<string, int>(fileData.File.Name, dataToProcess.Count));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}, maxDegreeOfParallelism: threads, false, cancellationToken);
}
}
}
}
public static IEnumerable<List<T>> SplitList<T>(List<T> bigList, int nSize = 3)
{
for (int i = 0; i < bigList.Count; i += nSize)
{
yield return bigList.GetRange(i, Math.Min(nSize, bigList.Count - i));
}
}
}
}