private static void RegisterProcessors(IServiceCollection services)
{
//services.Configure<ProcessingConfiguration>(section);
var configuration = new ProcessingConfiguration();
var section = Configuration?.GetSection(ProcessingConfiguration.SectionName);
section.Bind(configuration);
foreach (var processorTypeName in configuration.Processors)
{
var processorType = Type.GetType(processorTypeName);
if (processorType is null)
{
throw new ConfigurationErrorsException(
$"The processor {processorTypeName} indicated in configuration was not found.");
}
if (!processorType.IsAssignableTo(typeof(IProcessor)))
{
throw new ConfigurationErrorsException(
$"The processor {processorTypeName} indicated in configuration must implement IProcessor.");
}
services.AddSingleton(typeof(IProcessor), processorType);
}
services.AddSingleton <IProcessorRegistry, ProcessorRegistry>();
}
public static void StartProcessing(string inputFile, string outputPath, ProcessingConfiguration configuration)
{
// Prepara caminho para salvar imagem
string filename = Path.GetFileName(inputFile);
string outputFilePath = outputPath + "\\" + filename;
Directory.CreateDirectory(outputPath);
// Abre imagem
Bitmap image = new Bitmap(inputFile);
// Gera mini
int miniWidth = image.Width / configuration.ResizeFactor;
int miniHeight = image.Height / configuration.ResizeFactor;
Bitmap mini = new Bitmap(image, miniWidth, miniHeight);
image.Dispose();
if (configuration.BorderThickness != 0)
{
mini = drawBorder(mini, configuration.BorderThickness);
}
outputFilePath = Path.ChangeExtension(outputFilePath, "jpg");
saveImage(outputFilePath, mini);
mini.Dispose();
}
public async Task <Result <Unit, Error> > Persist(Name name, ProcessingConfiguration configuration)
{
var snapshot = new ConfigurationSnapshot
{
Name = name.ToString(),
AvoidDuplicates = configuration.AvoidDuplicates,
Sizes = configuration.Sizes.Select(s => new SizeConfigurationSnapshot
{
Tag = s.Tag.ToString(),
MaxWidth = s.MaxWidth.ToNullable(),
MaxHeight = s.MaxHeight.ToNullable(),
Format = s.Format.FileExtension,
Quality = s.Quality.ToScaler(),
Crop = s.Crop.Map(c => new CropConfigurationSnapshot
{
AspectRatio = c.AspectRatio.ToString(),
Color = c.BackgroundColor.Map(c => c.ToScalar()).ToNullable(),
CropStrategy = c.CropStrategy.ToString()
}).UnwrapOrDefault()
}).ToArray()
};
await _client.Configurations.ReplaceOneAsync(g => g.Name == snapshot.Name, snapshot, new ReplaceOptions { IsUpsert = true });
return(Result.Unit());
}
private ProcessingConfiguration readProcessingConfiguration()
{
int factor = txtFactor.Text == "" ? 0 : int.Parse(txtFactor.Text);
int border = txtThickness.Text == "" ? 0 : int.Parse(txtThickness.Text);
var config = new ProcessingConfiguration(factor, border);
return(config);
}
private static void generateMinis(Bitmap image, string outputMinifilePath, ProcessingConfiguration config)
{
int miniWidth = image.Width / config.MinisFactor;
int miniHeight = image.Height / config.MinisFactor;
Bitmap mini = new Bitmap(image, miniWidth, miniHeight);
if (config.ShouldDrawBorder)
{
mini = drawBorder(mini, config.BorderThickness);
}
saveImage(outputMinifilePath, mini, SaveFormatEnum.JPG90);
mini.Dispose();
}
private ProcessingConfiguration ToConfiguration(ConfigurationSnapshot snapshot)
{
return(ProcessingConfiguration.New(
avoidDuplicates: snapshot.AvoidDuplicates,
sizes: snapshot.Sizes.Select(s => new SizeConfiguration(
tag: Name.FromString(s.Tag).UnwrapOrThrow(),
maxWidth: s.MaxWidth.ToOption(),
maxHeight: s.MaxHeight.ToOption(),
crop: s.Crop != null
? Option.Some(new CropConfiguration(
aspectRatio: AspectRatio.FromString(s.Crop.AspectRatio).UnwrapOrThrow(),
cropStrategy: (CropStrategy)Enum.Parse(typeof(CropStrategy), s.Crop.CropStrategy, true),
backgroundColor: s.Crop.Color.ToOption().Map(s => new Color(s))
)) : Option.None(),
quality: Quality.FromScalar(s.Quality).UnwrapOrThrow(),
format: ImageFormat.FromExtension(s.Format).UnwrapOrThrow()
)).ToArray()
).UnwrapOrThrow());
}
public void StartProcessing(string inputFile, string outputFolderPath, ProcessingConfiguration processingConfiguration)
{
// Prepara caminho para salvar imagem
string filename = Path.GetFileName(inputFile);
string outputFilePath = outputFolderPath + "\\" + filename;
// Abre imagem
Bitmap inputBitmap = new Bitmap(inputFile);
// Processa imagem (coordenadas + cores)
Bitmap processedBitmap = processImage(inputBitmap);
// Setar resolução da imagem de destino para ser a mesma da origem
processedBitmap.SetResolution(inputBitmap.HorizontalResolution, inputBitmap.VerticalResolution);
inputBitmap.Dispose();
// Rodar imagem (se necessário)
rotateImage(processedBitmap, processingConfiguration.RotateFinalImage);
// Cortar imagem (se necessário)
if (processingConfiguration.ShouldCropImage)
{
processedBitmap = cropImage(processedBitmap, processingConfiguration.MaxCroppedWidth, processingConfiguration.MaxCroppedHeight);
}
// Gerar minis
if (processingConfiguration.ShouldGenerateMinis)
{
string outputMiniFolderPath = outputFolderPath + "\\minis";
string outputMiniFilePath = outputMiniFolderPath + "\\" + filename;
Directory.CreateDirectory(outputMiniFolderPath);
generateMinis(processedBitmap, outputMiniFilePath, processingConfiguration);
}
// Salvar imagem final
saveImage(outputFilePath, processedBitmap, processingConfiguration.SaveFormat);
processedBitmap.Dispose();
}
private ProcessingConfiguration readProcessingConfiguration()
{
// Função que lê as configurações de processamento
// Ler formato para salvar imagem
Logger.Log("Lendo formato para salvar imagem...");
SaveFormatEnum saveFormat;
var saveFormatSelected = (ComboBoxItem)cmbSaveFormat.SelectedItem;
switch (saveFormatSelected.Content)
{
case "TIFF":
saveFormat = SaveFormatEnum.TIFF;
break;
case "TIFF LZW":
saveFormat = SaveFormatEnum.TIFFLZW;
break;
case "JPG 90%":
saveFormat = SaveFormatEnum.JPG90;
break;
case "JPG 100%":
saveFormat = SaveFormatEnum.JPG100;
break;
default:
return(null);
}
Logger.Log("Formato selecionado: " + saveFormatSelected.Content);
// Ler se a imagem será rotacionada
Logger.Log("Lendo se a imagem será rotacionada...");
RotateFinalImageEnum rotateFinalImage;
var rotateSelected = (ComboBoxItem)cmbRotateImage.SelectedItem;
switch (rotateSelected.Content)
{
case "Não":
rotateFinalImage = RotateFinalImageEnum.NO;
break;
case "90° CCW":
rotateFinalImage = RotateFinalImageEnum.R90CCW;
break;
case "90° CW":
rotateFinalImage = RotateFinalImageEnum.R90CW;
break;
case "180°":
rotateFinalImage = RotateFinalImageEnum.R180;
break;
default:
return(null);
}
Logger.Log("Rotação selecionada: " + rotateSelected.Content);
// Ler se a imagem deverá ser cortada
Logger.Log("Lendo se a imagem deverá ser cortada...");
bool shouldCropImage;
var shouldCrop = (ComboBoxItem)cmbCropImage.SelectedItem;
switch (shouldCrop.Content)
{
case "Não":
shouldCropImage = false;
break;
case "Sim":
shouldCropImage = true;
break;
default:
return(null);
}
Logger.Log("Cortar imagem: " + shouldCrop.Content);
// Ler os valores de corte
Logger.Log("Lendo valores de corte...");
int height = txtCropHeight.Text == "" ? 0 : int.Parse(txtCropHeight.Text);
int width = txtCropWidth.Text == "" ? 0 : int.Parse(txtCropWidth.Text);
Logger.Log("Corte da imagem (LxC): " + height + "x" + width);
// Salvar os valores lidos no objeto de configuração que será usado durante o processamento
var processingConfiguration = new ProcessingConfiguration(saveFormat, rotateFinalImage, shouldCropImage, height, width);
return(processingConfiguration);
}
private EventProcessor GetEventProcessor(ProcessingConfiguration processingConfiguration)
{
return(new EventProcessor(
_eventMatcherFactory.GetEventMatcher(processingConfiguration.Match), _actionExecutorFactory.GetActionExecutor(processingConfiguration.Action)));
}
public FFmpegEngine(ProcessingConfiguration config)
{
_config = config ?? throw new ArgumentNullException(nameof(config));
}
public static void StartProcessing(string inputFile, string outputFolderPath, ProcessingConfiguration processingConfiguration)
{
// Prepara caminho para salvar imagem
string filename = Path.GetFileName(inputFile);
string outputFilePath = outputFolderPath + "\\" + filename;
// Abre imagem
Logger.Log("Abrindo imagem na memória...");
Bitmap inputBitmap = new Bitmap(inputFile);
Logger.Log("Imagem aberta!");
// Rodar imagem (se necessário)
Logger.Log("Rotacionando imagem... Configuração: " + processingConfiguration.RotateFinalImage);
rotateImage(inputBitmap, processingConfiguration.RotateFinalImage);
Logger.Log("Imagem rotacionada! (foi ignorado se configurado para não rodar)");
// Cortar imagem (se necessário)
if (processingConfiguration.ShouldCropImage)
{
Logger.Log("Cortando imagem... Configuração (LxC): " + processingConfiguration.MaxCroppedHeight + "x" + processingConfiguration.MaxCroppedWidth);
inputBitmap = cropImage(inputBitmap, processingConfiguration.MaxCroppedWidth, processingConfiguration.MaxCroppedHeight);
Logger.Log("Imagem cortada!");
}
// Salvar imagem final
try
{
Logger.Log("Salvando imagem final... Formato: " + processingConfiguration.SaveFormat);
saveImage(outputFilePath, inputBitmap, processingConfiguration.SaveFormat);
Logger.Log("Imagem final salva em: " + outputFilePath);
}
catch (Exception ex)
{
Logger.Log("Erro ao salvar a imagem: " + filename);
Logger.SaveError(filename);
Logger.Log(ex.Message);
}
Logger.Log("Liberando imagem da memória...");
inputBitmap.Dispose();
Logger.Log("Memória liberada!");
}
Create(Id id, uint rowVersion, Option <byte[]> meta, byte[] raw, ProcessingConfiguration configuration)
{
using var processor = _processorFactory.Create(raw);
var originalResolution = processor.ReadResolution();
var originalAspectRatio = AspectRatio.FromResolution(originalResolution);
var originalColorScheme = processor.ReadColorScheme();
var passByTag = new Dictionary <ImageProcessingPass, Name>();
var imageSizes = new List <ImageSize>();
var thumbnails = new List <Thumbnail>();
foreach (var size in configuration.Sizes)
{
var resolution = CalculateSize(size, originalResolution);
var crop = size.Crop.Match(c => c.AspectRatio != originalAspectRatio ? Option.Some(c.CropStrategy) : Option.None(), () => Option.None());
var color = size.Crop.Match(c => c.BackgroundColor, () => Option.None()).UnwrapOr(() => originalColorScheme.EdgeColor);
var pass = new ImageProcessingPass(resolution, crop, size.Format, size.Quality, color);
if (configuration.AvoidDuplicates)
{
if (passByTag.TryGetValue(pass, out var duplicate))
{
imageSizes.Add(new ImageSize(
size.Tag,
resolution,
size.Crop.Match(c => c.AspectRatio, () => originalAspectRatio),
crop,
size.Format,
size.Quality,
Option.Some(duplicate)));
continue;
}
}
passByTag[pass] = size.Tag;
var data = processor.Process(pass);
thumbnails.Add(new Thumbnail(
thumbnailId: new ThumbnailId(id, size.Tag, Option.Some(size.Format)),
data: data
));
imageSizes.Add(new ImageSize(
tag: size.Tag,
resolution: resolution,
aspectRatio: size.Crop.Match(c => c.AspectRatio, () => originalAspectRatio),
cropStrategy: crop,
imageFormat: size.Format,
quality: size.Quality,
duplicateOf: Option.None()
));
}
return(Task.FromResult(
Image.New(
id,
rowVersion,
_clock.GetCurrentInstant(),
meta,
originalColorScheme.FillColor,
originalColorScheme.EdgeColor,
Md5.ComputeHash(raw).UnwrapOrThrow(),
imageSizes
)
.MapSuccess <(Image Image, IReadOnlyCollection <Thumbnail> Thumbnails)>(image => (image, thumbnails))
));
}
private ProcessingConfiguration readProcessingConfiguration()
{
// Função que lê as configurações de processamento
// Ler formato para salvar imagem
SaveFormatEnum saveFormat;
var saveFormatSelected = (ComboBoxItem)cmbSaveFormat.SelectedItem;
switch (saveFormatSelected.Content)
{
case "TIFF":
saveFormat = SaveFormatEnum.TIFF;
break;
case "TIFF LZW":
saveFormat = SaveFormatEnum.TIFFLZW;
break;
case "JPG 90%":
saveFormat = SaveFormatEnum.JPG90;
break;
case "JPG 100%":
saveFormat = SaveFormatEnum.JPG100;
break;
default:
return(null);
}
// Lê se deve gerar as minis
bool shouldGenerateMinis;
var shouldGenerate = (ComboBoxItem)cmbGenerateMinis.SelectedItem;
switch (shouldGenerate.Content)
{
case "Sim":
shouldGenerateMinis = true;
break;
case "Não":
shouldGenerateMinis = false;
break;
default:
return(null);
}
// Lê o valor do fator das minis
int minisFactor = txtMinisFactor.Text == "" ? 0 : int.Parse(txtMinisFactor.Text);
// Lê se deve pintar a borda de preto
bool shouldDrawBorder;
var shouldDraw = (ComboBoxItem)cmbMinisBorder.SelectedItem;
switch (shouldDraw.Content)
{
case "Sim":
shouldDrawBorder = true;
break;
case "Não":
shouldDrawBorder = false;
break;
default:
return(null);
}
// Lê o tamanho da borda
int borderThickness = txtBorderThickness.Text == "" ? 0 : int.Parse(txtBorderThickness.Text);
// Ler se a imagem será rotacionada
RotateFinalImageEnum rotateFinalImage;
var rotateSelected = (ComboBoxItem)cmbRotateImage.SelectedItem;
switch (rotateSelected.Content)
{
case "Não":
rotateFinalImage = RotateFinalImageEnum.NO;
break;
case "90° CCW":
rotateFinalImage = RotateFinalImageEnum.R90CCW;
break;
case "90° CW":
rotateFinalImage = RotateFinalImageEnum.R90CW;
break;
case "180°":
rotateFinalImage = RotateFinalImageEnum.R180;
break;
default:
return(null);
}
// Ler se a imagem deverá ser cortada
bool shouldCropImage;
var shouldCrop = (ComboBoxItem)cmbCropImage.SelectedItem;
switch (shouldCrop.Content)
{
case "Não":
shouldCropImage = false;
break;
case "Sim":
shouldCropImage = true;
break;
default:
return(null);
}
// Ler os valores de corte
int height = txtCropHeight.Text == "" ? 0 : int.Parse(txtCropHeight.Text);
int width = txtCropWidth.Text == "" ? 0 : int.Parse(txtCropWidth.Text);
// Salvar os valores lidos no objeto de configuração que será usado durante o processamento
var processingConfiguration = new ProcessingConfiguration(saveFormat, shouldGenerateMinis, minisFactor, shouldDrawBorder, borderThickness,
rotateFinalImage, shouldCropImage, height, width);
return(processingConfiguration);
}
public async Task <IActionResult> Put([FromRoute] string galleryName, [FromBody] ProcessingConfiguration config)
{
var result = await _service.SetAsync(galleryName, config);
return(result.AsActionResult());
}
