public async static Task Main(string[] args)
{
Console.WriteLine(args[0]);
var filterFactory = new MutableByteImageFilterFactory(true);
var filters = new List <IFilter <MutableByteImage> >
{
filterFactory.CreateMaxFilter(new MaxOptions
{
Name = "max",
}),
filterFactory.CreateAttackDecayFilter(new AttackOptions
{
Attack = 1f,
Decay = 0.2f,
Name = "attackHF",
}),
filterFactory.CreateAttackDecayFilter(new AttackOptions
{
Attack = 1f,
Decay = 0.01f,
Name = "attackHS",
}),
filterFactory.CreateAttackDecayFilter(new AttackOptions
{
Attack = 0.2f,
Decay = 1f,
Name = "attackLF",
}),
filterFactory.CreateAttackDecayFilter(new AttackOptions
{
Attack = 0.01f,
Decay = 1f,
Name = "attackLS",
}),
filterFactory.CreateMinFilter(new MinOptions
{
Name = "min",
}),
};
var str = args[0];
foreach (var filter in filters)
{
using var logger = new Logger(Console.Out);
BoundedQueueFactory.Logger = logger;
Console.WriteLine(str);
var filename = Path.GetFileNameWithoutExtension(str);
var factory = new MutableByteImageFactory(logger);
/* var reader = new FfmpegVideoReader(new FfmpegVideoReaderArguments
* {
* InputFile = str
* }, factory, logger);*/
var directoryName = (File.Exists(args[0])) ? Path.GetDirectoryName(args[0]) : args[0];
var commonExtension = Directory.GetFiles(directoryName)
.Select(x => Path.GetExtension(x))
.GroupBy(x => x)
.OrderBy(x => x.Count()).First();
var reader = new ImageMutliFileOrderedReader <MutableByteImage>(logger, factory, new ReaderOptions
{
FolderName = args[0],
Filter = $"*{commonExtension.Key}",
});
var processingStrategy = new StackProgressiveStrategy <MutableByteImage>(logger, factory);
System.Diagnostics.Stopwatch st = new System.Diagnostics.Stopwatch();
st.Start();
//var writer = new ImageFileWriter<MutableByteImage>(filename, ".", factory);
var resultingFilename = /* @"H:\timelapses\stackedVideo\" +*/ Path.GetRandomFileName() + filename + "-" + filter.Name + ".mp4";
if (File.Exists(resultingFilename))
{
st.Stop();
Console.WriteLine($"Skipped {resultingFilename}");
continue;
}
var writer = new FfmpegVideoWriter(new FfmpegVideoWriterArguments
{
Framerate = 60,
OutputFile = resultingFilename
}, logger);
await processingStrategy.Process(reader, new List <IFilter <MutableByteImage> > {
filter
}, writer);
st.Stop();
Console.WriteLine($"it took {st.ElapsedMilliseconds}ms");
}
}
public static async Task Main(string[] args)
{
Stopwatch st = new Stopwatch();
st.Start();
IMutableImageFactory <MutableByteImage> factory = null;
List <IFilter <MutableByteImage> > filters = null;
IImageReader <MutableByteImage> inputMode = null;
IImageWriter <MutableByteImage> outputMode = null;
ILogger logger = null;
IImageProcessingStrategy <MutableByteImage> processingStrategy = null;
bool throwMe = false;
void setupCommons(CommonOptions info)
{
logger = CreateLogger(info);
bool throwMeHere = false;
(filters, throwMeHere) = ParseFilterParameters(info.Filters);
throwMe |= throwMeHere;
factory = new MutableByteImageFactory(logger);
logger?.WriteLine(info.ToString().Replace(",", Environment.NewLine), Verbosity.Info);
(inputMode, throwMeHere) = SetInput(info, factory, logger);
throwMe |= throwMeHere;
(outputMode, throwMeHere) = SetOutput(info, logger, factory);
throwMe |= throwMeHere;
}
var result = Parser.Default
.ParseArguments <InfoOptions,
StackAllOptions,
StackProgressiveOptions,
StackContinuousOptions,
TestOptions>(args)
.WithParsed <InfoOptions>(info =>
{
GetInfo(info);
return;
})
.WithParsed <StackAllOptions>(info =>
{
setupCommons(info);
// todo switch between stackall and stackallmerge, if supported by filter
// processingStrategy = new StackAllStrategy();
// might be unsafe
processingStrategy = new StackAllMergeStrategy <MutableByteImage>(logger, factory);
})
.WithParsed <StackProgressiveOptions>(info =>
{
setupCommons(info);
processingStrategy = new StackProgressiveStrategy <MutableByteImage>(logger, factory);
})
.WithParsed <StackContinuousOptions>(info =>
{
setupCommons(info);
if (info.Count == 0)
{
logger?.WriteLine("You have to define --stackCount for continuous stacking", Verbosity.Error);
throwMe = true;
}
processingStrategy = new StackContinousStrategy <MutableByteImage>(info.Count, logger, factory);
})
.WithParsed <TestOptions>(info =>
{
info.UseOutputPipe = false;
info.OutputFile = ".";
info.OutputFolder = ".";
logger = new Logger(Console.Out);
factory = new MutableByteImageFactory(logger);
inputMode = new TestImageReader <MutableByteImage>
(info.Count,
info.Width,
info.Height,
PixelFormat.Format24bppRgb,
logger,
factory);
outputMode = new TestImageWriter <MutableByteImage>(logger, factory);
processingStrategy = new StackAllMergeStrategy <MutableByteImage>(logger, factory);
RunBenchmark(info, logger, new MutableByteImageFactory(logger)).Wait();
Process.GetCurrentProcess().Close();
})
.WithNotParsed(x =>
logger?.WriteLine(String.Join(Environment.NewLine, x.Select(y => y.ToString()).ToArray()), Verbosity.Error));
if (throwMe)
{
logger?.WriteLine("Invalid Configuration, see issues above.", Verbosity.Error);
return;
}
if (inputMode == null || outputMode == null)
{
logger?.WriteLine($"Input: {inputMode}, Output:{outputMode}", Verbosity.Error);
logger?.WriteLine("IO undefined", Verbosity.Error);
return;
}
if (processingStrategy == null)
{
logger?.WriteLine("Not processing strategy defined", Verbosity.Error);
}
logger?.WriteLine($"{inputMode} {outputMode} {processingStrategy}", Verbosity.Info);
await processingStrategy.Process(inputMode, filters, outputMode);
st.Stop();
logger?.WriteLine($"Processing took {st.ElapsedMilliseconds / 1000d}", Verbosity.Info);
logger?.Dispose();
}
