protected OrderedReaderTestBase(
IImageProvider <MutableByteImage> imageProvider,
IMutableImageFactory <MutableByteImage> factory,
int imagesCount) :
base(imageProvider, factory, imagesCount)
{
}
public ImageStreamReader(ILogger logger, IMutableImageFactory <T> factory, Stream inputStream, int width, int height, PixelFormat format = PixelFormat.Format24bppRgb)
: base(logger, factory)
{
this.Width = width;
this.Height = height;
this.Format = format;
this.InputStream = inputStream;
}
public ReaderTestBase(
IImageProvider <T> imageProvider,
IMutableImageFactory <T> factory,
int imagesCount)
{
this.imageProvider = imageProvider;
this.ImagesCount = imagesCount;
this.factory = factory;
}
private static async Task RunBenchmark(TestOptions options, ILogger logger, IMutableImageFactory <MutableByteImage> factory)
{
try
{
logger.WriteLine("Running Benchmarks", Verbosity.Info);
logger.WriteLine("Testing Filters", Verbosity.Info);
foreach (var filter in new List <IFilter <MutableByteImage> > {
new MinFilter(new MinFilterOptions {
}),
new MinVecFilter(new MinFilterOptions {
}),
new MaxFilter(new MaxFilterOptions {
}),
new MaxVecFilter(new MaxFilterOptions {
}),
new AttackDecayFilter(new AttackDecayFilterOptions {
}),
new AttackDecayVecFilter(new AttackDecayFilterOptions {
})
})
{
Stopwatch stopwatch = new Stopwatch();
var imageReader = new TestImageReader <MutableByteImage>
(options.Count,
options.Width,
options.Height,
PixelFormat.Format24bppRgb,
logger,
factory);
var imageWriter = new ImageStreamWriter <MutableByteImage>(logger, factory, Stream.Null);
var strategy = new StackAllMergeStrategy <MutableByteImage>(logger, factory);
stopwatch.Start();
await strategy.Process(imageReader, new List <IFilter <MutableByteImage> > {
filter
}, imageWriter);
stopwatch.Stop();
logger.WriteLine($"Filter {filter.Name} took {stopwatch.ElapsedMilliseconds}", Verbosity.Info);
}
}
catch (Exception e)
{
logger.LogException(e);
throw;
}
}
public ImageMutliFileOrderedReader(ILogger logger, IMutableImageFactory <T> factory, IImageReaderOptions options)
: base(logger, factory)
{
if (options?.Files != null && options.Files.Count() > 0)
{
this.filenames = new Queue <string>(options.Files);
}
else
{
this.filenames = new Queue <string>(Directory.GetFiles(options.FolderName, options.Filter, new EnumerationOptions
{
AttributesToSkip = FileAttributes.System,
IgnoreInaccessible = true,
MatchCasing = MatchCasing.CaseInsensitive
}));
}
this.logger.WriteLine($"Items found: {filenames.Count}", Verbosity.Info);
}
public ThreadProcessingStrategy(ILogger logger, IMutableImageFactory <T> factory) : base(logger, factory)
{
}
public TestImageReader(int count, int width, int height, PixelFormat format, ILogger logger, IMutableImageFactory <T> factory) : base(logger, factory)
{
this.width = width;
this.height = height;
this.format = format;
this.count = count;
var random = new Random();
long length = width * 1L * height * Image.GetPixelFormatSize(format) / 8L;
data1 = new byte[length];
data2 = new byte[length];
random.NextBytes(data1);
random.NextBytes(data2);
}
public ProcessingStrategy(ILogger logger, IMutableImageFactory <T> factory)
{
this.factory = factory;
this.logger = logger;
}
public FfmpegVideoReader(FfmpegVideoReaderArguments arguments, IMutableImageFactory <MutableByteImage> factory, ILogger logger)
{
_arguments = arguments;
_logger = logger;
_factory = factory;
}
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();
}
public ImageStreamWriter(ILogger logger, IMutableImageFactory <T> factory, Stream outputStream)
: base(logger, factory)
{
this.outputStream = outputStream;
}
public ImageFileWriter(string filename, string outputFolder, IMutableImageFactory <T> factory)
{
Filename = filename;
OutputFolder = outputFolder;
Factory = factory;
}
public ImageWriter(ILogger logger, IMutableImageFactory <T> factory)
{
this.logger = logger;
this.factory = factory;
}
public TestImageWriter(ILogger logger, IMutableImageFactory <T> factory)
: base(logger, factory)
{
}
private static (IImageReader <MutableByteImage>, bool throwMe) SetInput(CommonOptions commonOptions, IMutableImageFactory <MutableByteImage> factory, ILogger logger)
{
if (commonOptions.UseInputPipe)
{
var inputSize = commonOptions.InputSize;
if (string.IsNullOrWhiteSpace(inputSize))
{
throw new ArgumentException("Inputsize must be defined for inputpipes ");
}
var wh = Regex.Split(inputSize, "[^0-9]");
int.TryParse(wh[0], out int width);
int.TryParse(wh[1], out int height);
return(new ImageStreamReader <MutableByteImage>(
logger,
factory,
Console.OpenStandardOutput(width * height * 3),
width,
height,
PixelFormat.Format24bppRgb), false);
}
if (commonOptions.InputFiles != null && commonOptions.InputFiles.Count() > 0)
{
return(new ImageMutliFileOrderedReader <MutableByteImage>(logger, factory, new ReaderOptions {
Files = commonOptions.InputFiles.ToArray()
}), false);
}
if (!string.IsNullOrWhiteSpace(commonOptions.InputFolder))
{
logger?.WriteLine("Currently only *.jpg input supported", Verbosity.Warning);
if (!Directory.Exists(commonOptions.InputFolder))
{
logger?.WriteLine($"InputFolder does not exist {commonOptions.InputFolder}", Verbosity.Warning);
}
return(new ImageMutliFileOrderedReader <MutableByteImage>(logger, factory, new ReaderOptions {
FolderName = commonOptions.InputFolder, Filter = commonOptions.InputFilter
}), false);
}
logger?.WriteLine("No Input Mode defined", Verbosity.Error);
return(null, true);
}
private static (IImageWriter <MutableByteImage>, bool throwMe) SetOutput(CommonOptions commonOptions, ILogger logger, IMutableImageFactory <MutableByteImage> factory)
{
if (commonOptions.UseOutputPipe)
{
return(new ImageStreamWriter <MutableByteImage>(logger, factory, Console.OpenStandardOutput()), false);
}
if (!string.IsNullOrWhiteSpace(commonOptions.OutputFolder) &&
!string.IsNullOrWhiteSpace(commonOptions.OutputFile))
{
return(new ImageFileWriter <MutableByteImage>(commonOptions.OutputFile, commonOptions.OutputFolder, factory), false);
}
logger?.WriteLine("No Output Mode defined", Verbosity.Error);
logger?.WriteLine("Consider specifying --UseOutputPipe or --OutputFolder and --OutputFile", Verbosity.Error);
logger?.WriteLine("", Verbosity.Error);
return(null, true);
}
public StackAllMergeStrategy(ILogger logger, IMutableImageFactory <T> factory) : base(logger, factory)
{
}
public ImageReaderBase(ILogger logger, IMutableImageFactory <T> factory)
{
this.logger = logger;
this.factory = factory;
}
