public void Test_Append()
{
int width = 70;
int height = 46;
using (IMagickImageCollection collection = new MagickImageCollection())
{
ExceptionAssert.Throws <InvalidOperationException>(delegate()
{
collection.AppendHorizontally();
});
ExceptionAssert.Throws <InvalidOperationException>(delegate()
{
collection.AppendVertically();
});
collection.Read(Files.RoseSparkleGIF);
Assert.AreEqual(width, collection[0].Width);
Assert.AreEqual(height, collection[0].Height);
using (IMagickImage image = collection.AppendHorizontally())
{
Assert.AreEqual(width * 3, image.Width);
Assert.AreEqual(height, image.Height);
}
using (IMagickImage image = collection.AppendVertically())
{
Assert.AreEqual(width, image.Width);
Assert.AreEqual(height * 3, image.Height);
}
}
}
public static String BuildAppendHorizontally(List <AvactorInfo> imgs)
{
String filepath = String.Empty;
using (MagickImageCollection images = new MagickImageCollection())
{
foreach (var item in imgs)
{
MagickImage second = new MagickImage(item.FilePath);
if (item.IsResize)
{
second.Resize(50, 50);
}
images.Add(second);
}
using (IMagickImage result = images.AppendHorizontally())
{
// Save the result
filepath = Path.Combine(TempFolder, DateTime.Now.ToFileTime() + "Horizontally.png");
result.Write(filepath);
}
}
return(filepath);
}
public void ShouldDitherWhenSpecifiedInSettings()
{
using (IMagickImageCollection colors = new MagickImageCollection())
{
colors.Add(new MagickImage(MagickColors.Red, 1, 1));
colors.Add(new MagickImage(MagickColors.Green, 1, 1));
using (IMagickImage remapImage = colors.AppendHorizontally())
{
using (IMagickImageCollection collection = new MagickImageCollection())
{
collection.Read(Files.RoseSparkleGIF);
QuantizeSettings settings = new QuantizeSettings
{
DitherMethod = DitherMethod.FloydSteinberg,
};
collection.Map(remapImage, settings);
ColorAssert.AreEqual(MagickColors.Red, collection[0], 60, 17);
ColorAssert.AreEqual(MagickColors.Green, collection[0], 37, 24);
ColorAssert.AreEqual(MagickColors.Red, collection[1], 58, 30);
ColorAssert.AreEqual(MagickColors.Green, collection[1], 36, 26);
ColorAssert.AreEqual(MagickColors.Red, collection[2], 60, 40);
ColorAssert.AreEqual(MagickColors.Green, collection[2], 17, 21);
}
}
}
}
public void Test_Deconstruct()
{
using (IMagickImageCollection collection = new MagickImageCollection())
{
ExceptionAssert.Throws <InvalidOperationException>(delegate()
{
collection.Deconstruct();
});
collection.Add(new MagickImage(MagickColors.Red, 20, 20));
using (IMagickImageCollection frames = new MagickImageCollection())
{
frames.Add(new MagickImage(MagickColors.Red, 10, 20));
frames.Add(new MagickImage(MagickColors.Purple, 10, 20));
collection.Add(frames.AppendHorizontally());
}
Assert.AreEqual(20, collection[1].Width);
Assert.AreEqual(20, collection[1].Height);
Assert.AreEqual(new MagickGeometry(0, 0, 10, 20), collection[1].Page);
ColorAssert.AreEqual(MagickColors.Red, collection[1], 3, 3);
collection.Deconstruct();
Assert.AreEqual(10, collection[1].Width);
Assert.AreEqual(20, collection[1].Height);
Assert.AreEqual(new MagickGeometry(10, 0, 10, 20), collection[1].Page);
ColorAssert.AreEqual(MagickColors.Purple, collection[1], 3, 3);
}
}
public void Test_Evaluate()
{
using (IMagickImageCollection collection = new MagickImageCollection())
{
ExceptionAssert.Throws <InvalidOperationException>(delegate()
{
collection.Evaluate(EvaluateOperator.Exponential);
});
collection.Add(new MagickImage(MagickColors.Yellow, 40, 10));
using (IMagickImageCollection frames = new MagickImageCollection())
{
frames.Add(new MagickImage(MagickColors.Green, 10, 10));
frames.Add(new MagickImage(MagickColors.White, 10, 10));
frames.Add(new MagickImage(MagickColors.Black, 10, 10));
frames.Add(new MagickImage(MagickColors.Yellow, 10, 10));
collection.Add(frames.AppendHorizontally());
}
using (IMagickImage image = collection.Evaluate(EvaluateOperator.Min))
{
ColorAssert.AreEqual(MagickColors.Green, image, 0, 0);
ColorAssert.AreEqual(MagickColors.Yellow, image, 10, 0);
ColorAssert.AreEqual(MagickColors.Black, image, 20, 0);
ColorAssert.AreEqual(MagickColors.Yellow, image, 30, 0);
}
}
}
private void MergeImage(string phase, string[] words)
{
var position = 1;
using (MagickImageCollection images = new MagickImageCollection())
{
foreach (var line in words)
{
foreach (var word in line)
{
MagickImage image = new MagickImage($"~/Words/{word}/{word}-{phase}.png");
//image.Extent(90, 400, position == 1 ? Gravity.Center : Gravity.South);
image.Extent(-5, -90 * position, 90, 400);
//image.Resize(500, 350);
image.Transparent(new MagickColor("#ffffff"));
images.Add(image);
}
position++;
}
using (MagickImage horizontal = images.AppendHorizontally())
{
MagickImage background = new MagickImage("~/Words/background.png");
horizontal.Composite(background, CompositeOperator.DstAtop);
Directory.CreateDirectory($"{OutputPath}/{FolderName}");
horizontal.Write($"{OutputPath}/{FolderName}/{FolderName}-{phase}.png");
background.Dispose();
}
}
}
public static void ConvertPDFTOneImage()
{
MagickReadSettings settings = new MagickReadSettings();
// Settings the density to 300 dpi will create an image with a better quality
settings.Density = new Density(300);
using (MagickImageCollection images = new MagickImageCollection())
{
// Add all the pages of the pdf file to the collection
images.Read(SampleFiles.SnakewarePdf, settings);
// Create new image that appends all the pages horizontally
using (IMagickImage horizontal = images.AppendHorizontally())
{
// Save result as a png
horizontal.Write(SampleFiles.OutputDirectory + "Snakeware.horizontal.png");
}
// Create new image that appends all the pages horizontally
using (IMagickImage vertical = images.AppendVertically())
{
// Save result as a png
vertical.Write(SampleFiles.OutputDirectory + "Snakeware.vertical.png");
}
}
}
public static async Task MergeAllDir(int rowLength)
{
int counter = 1;
FileInfo[] files = IOUtils.GetFiles();
Logger.Log("-> Merging " + files.Length + " images...");
Program.PreProcessing();
if (rowLength <= 0)
{
rowLength = (int)Math.Sqrt(files.Length);
}
MagickImageCollection row = new MagickImageCollection();
MagickImageCollection rows = new MagickImageCollection();
int currImg = 1;
Logger.Log("Adding images to atlas...");
foreach (FileInfo file in files)
{
Program.ShowProgress("", counter, files.Length);
MagickImage currentImg = new MagickImage(file);
Logger.Log("Adding " + Path.GetFileName(currentImg.FileName) + "...", true);
row.Add(currentImg);
if (currImg >= rowLength)
{
currImg = 0; // Reset counter
var mergedRow = row.AppendHorizontally(); // Append
rows.Add(mergedRow);
row = new MagickImageCollection(); // Reset row
}
currImg++;
await Program.PutTaskDelay();
counter++;
if (counter > files.Length && currImg != 0 && row.Count > 0) // Merge the remaining images if we are done, even if they don't fill a row
{
var mergedRow = row.AppendHorizontally(); // Append
rows.Add(mergedRow);
}
}
Logger.Log("-> Creating output image... ");
var result = rows.AppendVertically();
result.BackgroundColor = new MagickColor("#" + (await Config.Get("backgroundColor")));
result.Format = MagickFormat.Png;
string outpath = Program.currentDir + "-merged.png";
result.Write(outpath);
Logger.Log("-> Written merged image to " + outpath);
Program.PostProcessing(files.Length);
}
public void ShouldThrowExceptionWhenCollectionIsEmpty()
{
using (IMagickImageCollection images = new MagickImageCollection())
{
ExceptionAssert.Throws <InvalidOperationException>(() =>
{
images.AppendHorizontally();
});
}
}
private IMagickImage <QuantumType> CreatePalleteImage()
{
using (var images = new MagickImageCollection())
{
images.Add(new MagickImage(MagickColors.Red, 1, 1));
images.Add(new MagickImage(MagickColors.Blue, 1, 1));
images.Add(new MagickImage(MagickColors.Green, 1, 1));
return(images.AppendHorizontally());
}
}
public static IMagickImage MergeImageRow(Dictionary <int, IMagickImage> images)
{
using (MagickImageCollection imgCollection = new MagickImageCollection())
{
foreach (var image in images)
{
imgCollection.Add(new MagickImage(image.Value));
}
return(imgCollection.AppendHorizontally());
}
}
public void Build()
{
// only stitch the source images for now
using var images = new MagickImageCollection();
foreach (var i in SynapseStills)
{
var img = new MagickImage(i);
img.Scale(Constants.SYNAPSE_WIDTH, Constants.SYNAPSE_HEIGHT);
images.Add(img);
}
// stitch horizontally as demonstrated in the assignment example
using var result = images.AppendHorizontally();
result.Write($"{OutputBaseName}.png");
}
private void BtnRead_Click(object sender, EventArgs e)
{
var dialog = new OpenFileDialog();
var result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
if (dialog.CheckFileExists)
{
var sw = new Stopwatch();
sw.Start();
SetLoading(true);
Task.Run(async() =>
{
MagickReadSettings settings = new MagickReadSettings
{
// Settings the density to 300 dpi will create an image with a better quality
//Density = new Density(96)
};
using (MagickImageCollection images = new MagickImageCollection())
{
// Add all the pages of the pdf file to the collection
images.Read(dialog.OpenFile(), settings);
for (int i = 1; i <= images.Count; i++)
{
//foreach (MagickImage image in images)
//{
// using (var stream = new MemoryStream())
// {
// previewBox.Image = image.ToBitmap();
// }
//}
var image = images.AppendHorizontally();
using (var stream = new MemoryStream())
{
previewBox.Image = image.ToBitmap();
}
}
}
}).ContinueWith(new Action <Task>((t) =>
{
SetLoading(false);
Console.WriteLine(sw.Elapsed);
}));
}
}
}
public void Build()
{
string[] imgs = Directory.GetFiles(InputFolder, INPUT_IMGS);
// only stitch the source images for now
using var images = new MagickImageCollection();
foreach (var i in imgs)
{
var img = new MagickImage(i);
img.Scale(Constants.SYNAPSE_WIDTH, Constants.SYNAPSE_HEIGHT);
images.Add(img);
}
// stitch horizontally as demonstrated in the assignment example
using var result = images.AppendHorizontally();
result.Write(OutputFile);
}
public void Test_Map()
{
using (IMagickImageCollection colors = new MagickImageCollection())
{
colors.Add(new MagickImage(MagickColors.Red, 1, 1));
colors.Add(new MagickImage(MagickColors.Green, 1, 1));
using (IMagickImage remapImage = colors.AppendHorizontally())
{
using (IMagickImageCollection collection = new MagickImageCollection())
{
ExceptionAssert.Throws <InvalidOperationException>(delegate()
{
collection.Map(null);
});
ExceptionAssert.Throws <InvalidOperationException>(delegate()
{
collection.Map(remapImage);
});
collection.Read(Files.RoseSparkleGIF);
ExceptionAssert.Throws <ArgumentNullException>(delegate()
{
collection.Map(null);
});
QuantizeSettings settings = new QuantizeSettings();
settings.DitherMethod = DitherMethod.FloydSteinberg;
collection.Map(remapImage, settings);
ColorAssert.AreEqual(MagickColors.Red, collection[0], 60, 17);
ColorAssert.AreEqual(MagickColors.Green, collection[0], 37, 24);
ColorAssert.AreEqual(MagickColors.Red, collection[1], 58, 30);
ColorAssert.AreEqual(MagickColors.Green, collection[1], 36, 26);
ColorAssert.AreEqual(MagickColors.Red, collection[2], 60, 40);
ColorAssert.AreEqual(MagickColors.Green, collection[2], 17, 21);
}
}
}
}
private static void RemapColors(IMagickImage image, IEnumerable <MagickColor> colors)
{
using (var images = new MagickImageCollection())
{
foreach (var color in colors)
{
images.Add(new MagickImage(color, 1, 1));
}
using (IMagickImage colorMap = images.AppendHorizontally())
{
image.Map(colorMap, new QuantizeSettings()
{
DitherMethod = DitherMethod.No
});
}
}
}
private ushort[] GetGrayChannel(MagickImage image)
{
using (var images = new MagickImageCollection())
{
images.Add(image.Clone());
images.Add(image.Clone());
images.Add(image.Clone());
using (var depolar = images.AppendHorizontally())
{
if (Smooth != 0.0)
{
depolar.Blur(0, Smooth);
}
if (Sharpen != 0.0)
{
depolar.Sharpen(0, Sharpen);
}
if (_method == UnperspectiveMethod.Derivative)
{
depolar.VirtualPixelMethod = VirtualPixelMethod.Tile;
depolar.SetArtifact("convolve:scale", "50%!");
depolar.SetArtifact("convolve:bias", "50%");
depolar.Morphology(MorphologyMethod.Convolve, "3x1: -1,0,1");
depolar.AutoLevel();
depolar.SetArtifact("convolve:bias", "0");
depolar.Morphology(MorphologyMethod.Convolve, "3x1: 1,0,-1");
depolar.AutoLevel();
depolar.Crop(image.Width, 1, Gravity.Center);
}
depolar.Depth = 16;
using (var pixels = depolar.GetPixels())
{
return(pixels.ToShortArray(0, 0, depolar.Width, 1, "R"));
}
}
}
}
public void Combine()
{
string[] videoImgs = Directory.GetFiles(
SynapseFolder, Constants.VIDEO_SYNAPSE_BASENAME + FILE_EXT);
string[] stillsImgs = Directory.GetFiles(
SynapseFolder, Constants.STILLS_SYNAPSE_BASENAME + FILE_EXT);
using var images = new MagickImageCollection();
foreach (var v in videoImgs)
{
images.Add(new MagickImage(v));
}
foreach (var s in stillsImgs)
{
images.Add(new MagickImage(s));
}
using var result = images.AppendHorizontally();
result.Write(Path.Join(SynapseFolder, "combined_synapse.png"));
}
public void ShouldThrowExceptionWhenCollectionIsEmptyAndImageIsNotNull()
{
using (IMagickImageCollection colors = new MagickImageCollection())
{
colors.Add(new MagickImage(MagickColors.Red, 1, 1));
colors.Add(new MagickImage(MagickColors.Green, 1, 1));
using (IMagickImage remapImage = colors.AppendHorizontally())
{
using (IMagickImageCollection collection = new MagickImageCollection())
{
ExceptionAssert.Throws <InvalidOperationException>(() =>
{
collection.Map(remapImage);
});
}
}
}
}
public void ShouldAppendTheImagesHorizontally()
{
int width = 70;
int height = 46;
using (IMagickImageCollection images = new MagickImageCollection())
{
images.Read(Files.RoseSparkleGIF);
Assert.AreEqual(width, images[0].Width);
Assert.AreEqual(height, images[0].Height);
using (IMagickImage image = images.AppendHorizontally())
{
Assert.AreEqual(width * 3, image.Width);
Assert.AreEqual(height, image.Height);
}
}
}
public static MagickImage MergeImages(string[] imgs, bool vertically, bool deleteSourceImgs)
{
MagickImageCollection collection = new MagickImageCollection();
foreach (string img in imgs)
{
collection.Add(img);
if (deleteSourceImgs)
{
File.Delete(img);
}
}
if (!vertically)
{
return((MagickImage)collection.AppendHorizontally());
}
else
{
return((MagickImage)collection.AppendVertically());
}
}
public static String BuildSquareImg(List <List <AvactorInfo> > imggroup)
{
String result = String.Empty;
if (imggroup == null || !imggroup.Any())
{
return(result);
}
using (MagickImageCollection verticallyImages = new MagickImageCollection())
{
foreach (var item in imggroup)
{
using (MagickImageCollection images = new MagickImageCollection())
{
foreach (var hitem in item)
{
MagickImage first = new MagickImage(hitem.FilePath);
first.Resize(hitem.Width, hitem.Heigh);
if (hitem.IsResize)
{
first.BackgroundColor = new MagickColor(Color.Gray);
}
images.Add(first);
}
verticallyImages.Add(images.AppendHorizontally());
}
}
using (IMagickImage vresult = verticallyImages.AppendVertically())
{
// Save the result
result = Path.Combine(TempFolder, DateTime.Now.ToFileTime() + ".png");
vresult.Write(result);
}
}
return(result);
}
private IMagickImage FillImage(IMagickImage magickImage)
{
IMagickImage result;
using (MagickImageCollection images = new MagickImageCollection())
{
int blackWidth = (1920 - magickImage.Width) / 2;
IMagickImage blackLeft = new MagickImage(blackColor, blackWidth, 1080);;
IMagickImage blackRight = new MagickImage(blackColor, blackWidth, 1080);;
images.Add(blackLeft);
images.Add(magickImage);
images.Add(blackRight);
result = images.AppendHorizontally();
blackLeft.Dispose();
blackRight.Dispose();
}
result.Orientation = OrientationType.TopLeft;
return(result);
}
public void Test_Append()
{
int width = 70;
int height = 46;
using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF))
{
Assert.AreEqual(width, collection[0].Width);
Assert.AreEqual(height, collection[0].Height);
using (MagickImage image = collection.AppendHorizontally())
{
Assert.AreEqual(width * 3, image.Width);
Assert.AreEqual(height, image.Height);
}
using (MagickImage image = collection.AppendVertically())
{
Assert.AreEqual(width, image.Width);
Assert.AreEqual(height * 3, image.Height);
}
}
}
public void Test_Append()
{
int width = 70;
int height = 46;
using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF))
{
Assert.AreEqual(width, collection[0].Width);
Assert.AreEqual(height, collection[0].Height);
using (MagickImage image = collection.AppendHorizontally())
{
Assert.AreEqual(width * 3, image.Width);
Assert.AreEqual(height, image.Height);
}
using (MagickImage image = collection.AppendVertically())
{
Assert.AreEqual(width, image.Width);
Assert.AreEqual(height * 3, image.Height);
}
}
}
private string GerarImagem(Stream stream)
{
MagickNET.SetGhostscriptDirectory(Directory.GetCurrentDirectory());
MagickNET.SetTempDirectory(Path.GetTempPath());
var settings = new MagickReadSettings
{
Density = new Density(300, 300)
};
using (var images = new MagickImageCollection())
{
images.Read(stream, settings);
using (var imagem = images.AppendHorizontally())
{
var caminhoArquivo = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".png");
imagem.Format = MagickFormat.Png;
imagem.Write(caminhoArquivo);
return(caminhoArquivo);
}
}
}
public static string CompareScreen()
{
try
{
logger.Debug("------|Start To Compare Screen");
finalImageFile = string.Empty;
string templateName = Template.templateName;
string baselinePath = InitializeParamter.ImageBaselinePath;
string imagePath = baselinePath.Replace("Baseline", "");
string actualPath = imagePath + @"Compare\Actual\";
string diffPath = imagePath + @"Compare\Diff\";
CreateDirectory(actualPath);
CreateDirectory(diffPath);
string date = DateTime.Now.ToString("yyyyMMdd");
string todayActualPath = Path.Combine(actualPath, date);
string todayDiffPath = Path.Combine(diffPath, date);
CreateDirectory(todayActualPath);
CreateDirectory(todayDiffPath);
//Define all of the image
string baselineImageFullName = Path.Combine(baselinePath, templateName + ".png");
string actualImageFullName = Path.Combine(todayActualPath, templateName + ".png");
string diffImageFullName = Path.Combine(todayDiffPath, templateName + "_diff.png");
string firstCombineImageFullName = Path.Combine(todayDiffPath, templateName + "_diff_Combine1.png"); //baseline + actual
string secondCombineImageFullName = Path.Combine(todayDiffPath, templateName + "_diff_Combine2.png"); // first + diff
string finalDiffImageFullName = Path.Combine(todayDiffPath, templateName + "_diff_final.png"); // second + Watermark
/*==========1. Get Actual =======================*/
var driver = Initialize.Driver;
Screenshot ss = ((ITakesScreenshot)driver).GetScreenshot();
ss.SaveAsFile(actualImageFullName, ImageFormat.Png);
/*----------1 End--------------------------------*/
/*==========2. Get Diff =======================*/
//Temp Solution To Get baseline
if (!File.Exists(baselineImageFullName))
{
baselineImageFullName = actualImageFullName;
}
using (MagickImage mi_actual = new MagickImage(actualImageFullName))
using (MagickImage mi_baseline = new MagickImage(baselineImageFullName))
using (MagickImage mi_diff = new MagickImage())
{
double distortion = mi_actual.Compare(mi_baseline, ErrorMetric.Absolute, mi_diff);
if (distortion != 0)
{
mi_diff.Write(diffImageFullName);
/*----------2 End--------------------------------*/
/*==========3. first Combine:baseline + actual===*/
using (MagickImageCollection collection = new MagickImageCollection())
{
collection.Add(new MagickImage(baselineImageFullName));
collection.Add(new MagickImage(actualImageFullName));
//MagickGeometry geo = new MagickGeometry("80x80%");
// Create a mosaic from both images
using (MagickImage result = collection.AppendHorizontally())
{
// Save the result
//result.Resize(geo);
//result.Scale(new Percentage(50));
//result.BorderColor = new MagickColor(System.Drawing.Color.Red);
result.Write(firstCombineImageFullName);
}
}
/*----------3 End--------------------------------*/
/*==========4. second Combine:first + diff ======*/
using (MagickImageCollection collection = new MagickImageCollection())
{
collection.Add(new MagickImage(firstCombineImageFullName));
collection.Add(new MagickImage(diffImageFullName));
//MagickGeometry geo = new MagickGeometry("150x150%");//wightxhight
using (MagickImage result = collection.AppendVertically())
{
//result.Resize(geo);
// Save the result
result.Write(secondCombineImageFullName);
}
}
/*----------4 End--------------------------------*/
/*==========5. final Combine:second + Watermark =*/
var imageBackgroundColor = new MagickColor("White");
var text = "Left: Baseline\nRight: Actual\nBottom: Different";
using (MagickImage image = new MagickImage(secondCombineImageFullName))
{
// Read the watermark that will be put on top of the image
using (MagickImage watermark = new MagickImage(imageBackgroundColor, 1000, 600))
{
watermark.Read("label:" + text);
// Draw the watermark in the bottom right corner
image.Composite(watermark, Gravity.Southeast, CompositeOperator.Over);
// Optionally make the watermark more transparent
watermark.Evaluate(Channels.Alpha, EvaluateOperator.Divide, 4);
// Or draw the watermark at a specific location
//image.Composite(watermark, 200, 50, CompositeOperator.Over);
}
// Save the result
image.Write(finalDiffImageFullName);
}
/*----------5 End--------------------------------*/
/*==========6. delete middle diff image==========*/
File.Delete(diffImageFullName);
File.Delete(firstCombineImageFullName);
File.Delete(secondCombineImageFullName);
// Rename final.png
string time = DateTime.Now.ToString("HHmmss");
string renameFinalImageFullName = finalDiffImageFullName.Replace("diff_final", time);
File.Move(finalDiffImageFullName, renameFinalImageFullName);
finalImageFile = renameFinalImageFullName;
/*----------6 End--------------------------------*/
return("Failure");
}
else
{
return("Pass");
}
}
}
catch (Exception e)
{
logger.Fatal("Fail To Compare Screen");
logger.Fatal(e.Message);
return("Failure");
}
}
static void Main(string[] args)
{
Console.WriteLine($"# of Threads: {NumThreads}");
DateTime startTime = DateTime.Now;
MagickImage original = new MagickImage("sample_images/white.png");
MagickImage target = new MagickImage("sample_images/target.png");
List <MagickImage> originalTiles = original.CropToTiles((original.Width / NumThreads) + 1, original.Height).Cast <MagickImage>().ToList();
List <MagickImage> targetTiles = target.CropToTiles((original.Width / NumThreads) + 1, original.Height).Cast <MagickImage>().ToList();
List <MagickImage>[] outputTilesProcessed = new List <MagickImage> [NumThreads];
//MagickImage working = (MagickImage)original.Clone(original.Width, original.Height);
Console.WriteLine($"ogT cnt: {originalTiles.Count}, tt cnt: {targetTiles.Count}");
List <Thread> threads = new List <Thread>();
DateTime threadStartTime = DateTime.Now;
for (int i = 0; i < NumThreads; i++)
{
int i_copied = i;
Thread t = new Thread(delegate()
{
outputTilesProcessed[i_copied] = ProcessTile(originalTiles[i_copied], targetTiles[i_copied]);
});
t.Start();
threads.Add(t);
}
while (!threads.All(t => !t.IsAlive))
{
Thread.Sleep(1);
}
Console.WriteLine($"Tile process time: {Math.Round((DateTime.Now - threadStartTime).TotalSeconds, 2)} seconds");
DateTime stitchStartTime = DateTime.Now;
using (MagickImageCollection gifCollection = new MagickImageCollection())
{
for (int i = 0; i < num_frames; i++)
{
using (MagickImageCollection frameCollection = new MagickImageCollection())
{
for (int j = 0; j < NumThreads; j++)
{
frameCollection.Add(outputTilesProcessed[j][i]);
}
gifCollection.Add(frameCollection.AppendHorizontally());
gifCollection[i].AnimationDelay = animation_delay;
}
}
Console.WriteLine($"Stitch time: {Math.Round((DateTime.Now - stitchStartTime).TotalSeconds, 2)} seconds");
DateTime optimizeWriteStartTime = DateTime.Now;
gifCollection.Optimize();
gifCollection.Write("output/output.gif");
Console.WriteLine($"Optimize and write time: {Math.Round((DateTime.Now - optimizeWriteStartTime).TotalSeconds, 2)} seconds");
}
Console.WriteLine($"Done, total elapsed time: {Math.Round((DateTime.Now - startTime).TotalSeconds, 2)} seconds");
//Gif animation = new Gif("output/output.gif", num_frames);
/*using (MagickImageCollection collection = new MagickImageCollection())
* {
* collection.Add(working);
* collection[0].AnimationDelay = animation_delay;
*
* //collection[0].Write("output/0.png");
*
* for (int i = 1; i < num_frames; i++)
* {
* DateTime startFrameTime = DateTime.Now;
* collection.Add(Method2_Magick((MagickImage)collection[i-1], target));
*
* collection[i].AnimationDelay = animation_delay;
*
* DateTime endFrameTime = DateTime.Now;
*
* Console.WriteLine($"Frame {i}/{num_frames-1} took {Math.Round((endFrameTime - startFrameTime).TotalSeconds, 2)} seconds to render");
*
* //Console.WriteLine($"{i}/{num_frames-1}");
*
*
* //collection[i].Write($"output/{i}.png");
*
* //working.Save($"output/{(char)i}.png");
* }
*
* DateTime startOptimizeAndSave = DateTime.Now;
*
* collection.Optimize();
*
* collection.Write("output/output.gif");
*
* DateTime endOptimizeAndSave = DateTime.Now;
*
* Console.WriteLine($"Optimize + save took {Math.Round((endOptimizeAndSave-startOptimizeAndSave).TotalSeconds, 2)} seconds");
* }
*
* DateTime endTime = DateTime.Now;
*
* Console.WriteLine($"Done, total elapsed time: {Math.Round((endTime-startTime).TotalSeconds, 2)} seconds");*/
}