static void Main(string[] args)
{
int magicRatio = 200;
int imageSize = 1024;
using (MagickImage image = new MagickImage(MagickColor.FromRgb(255, 255, 255), imageSize, imageSize))
{
var pixels = image.GetPixels();
for (int a = 1; a < imageSize * magicRatio; ++a)
{
var range = Enumerable.Range(a + 1, (imageSize * magicRatio) - (a + 1));
Parallel.ForEach(range, new ParallelOptions {
MaxDegreeOfParallelism = 3
}, b =>
{
double c = Math.Pow((Math.Pow(a, 2) + Math.Pow(b, 2)), 1.0 / 2);
int check = (int)c;
//double a_k = int(a);
double a_k = (double)a / magicRatio;
double b_k = (double)b / magicRatio;
if (check == c)
{
int stepSize = 10000;
var pixel = pixels.GetPixel((int)a_k, (int)b_k);
//Console.WriteLine(a.ToString() + "," + b.ToString());
var x = (ushort)(pixel.GetChannel(0));
if (x >= stepSize)
{
x = (ushort)(pixel.GetChannel(0) - stepSize);
}
pixel.SetChannel(0, (ushort)(x));
pixel.SetChannel(1, (ushort)(x));
pixel.SetChannel(2, (ushort)(x));
pixels.Set(pixel);
pixel = pixels.GetPixel((int)b_k, (int)a_k);
//Console.WriteLine(a.ToString() + "," + b.ToString());
pixel.SetChannel(0, (ushort)(x));
pixel.SetChannel(1, (ushort)(x));
pixel.SetChannel(2, (ushort)(x));
pixels.Set(pixel);
}
});
//for (int b = a + 1; b < imageSize * magicRatio; ++b)
//{
//}
}
image.Write("output.png");
//Console.WriteLine("Done");
//Console.ReadLine();
}
}
private static async Task PdfConvertToPngAsync(Task <byte[]> fileBytes, string type)
{
var settings = new MagickReadSettings
{
ColorSpace = ColorSpace.Gray,
BackgroundColor = MagickColor.FromRgb(0xff, 0xff, 0xff),
Density = new Density(150)
};
var pathAndName = TempPath + DirDivider + type + "-";
using (var images = new MagickImageCollection())
{
// Add all the pages of the pdf file to the collection
images.Read(await fileBytes, settings);
var page = 1;
images.ToList().ForEach(
magickImage =>
{
magickImage.Trim();
magickImage.Density = new Density(150);
magickImage.Quality = 100;
magickImage.ColorType = ColorType.Grayscale;
magickImage.BackgroundColor = MagickColor.FromRgb(0xff, 0xff, 0xff);
magickImage.Alpha(AlphaOption.Remove);
// Write page to file that contains the page number
magickImage.Write(pathAndName + (page - 1) + ".png");
page++;
});
}
}
private static MagickImage GetCheckerBoard(int width, int height, int squareSize)
{
if (width == 0 || height == 0 || squareSize == 0)
{
return(new MagickImage());
}
var image = new MagickImage(MagickColors.Transparent, width, height);
var light = MagickColor.FromRgb(150, 150, 150);
var dark = MagickColor.FromRgb(100, 100, 100);
using (var tile = new MagickImage(MagickColors.Transparent, squareSize * 2, squareSize * 2)) {
var drawable = new Drawables()
// Fill the background with a light color
.FillColor(light)
.Rectangle(0, 0, squareSize * 2, squareSize * 2)
// Create the top left square
.FillColor(dark)
.Rectangle(0, 0, squareSize, squareSize)
// Create the bottom right square
.FillColor(dark)
.Rectangle(squareSize, squareSize, squareSize * 2, squareSize * 2);
tile.Draw(drawable);
// Tile the tile on the full image
image.Tile(tile, CompositeOperator.SrcOver);
}
return(image);
}
protected void PaintPixel(HashSet <VoronoiPoint> pixels, MagickImage map, Region[] regList)
{
using (IPixelCollection pix = map.GetPixels())
{
foreach (var pixel in pixels)
{
MagickColor col;
if (pixel.value == -1)
{
col = MapColours.mapWaterColours[WaterColours.RegionWater];
}
else if (pixel.value == -2)
{
col = MagickColor.FromRgb(0, 0, 0);
}
else
{
col = MagickColor.FromRgb((byte)regList[pixel.value].rgb[0], (byte)regList[pixel.value].rgb[1], (byte)regList[pixel.value].rgb[2]);
}
this.map.mapTiles[pixel.x, pixel.y].region = pixel.value;
pix.ModifyPixel(pixel.x, pixel.y, col);
}
}
UpdateImage(this.map.mapRegions);
}
public byte[] Squarify(byte[] image, Color backgroundColor, double borderSizeFactor, MagickFormat format)
{
using (var magickImage = new MagickImage(image))
{
int width = 0;
int height = 0;
if (magickImage.Width > magickImage.Height)
{
width = GetLongSide(magickImage.Width, borderSizeFactor);
height = GetShortSide(magickImage.Height, magickImage.Width, width);
}
else
{
height = GetLongSide(magickImage.Height, borderSizeFactor);
width = GetShortSide(magickImage.Width, magickImage.Height, height);
}
magickImage.Border(width, height);
magickImage.BorderColor = MagickColor.FromRgb(backgroundColor.R, backgroundColor.G, backgroundColor.B);
magickImage.Format = format;
return(magickImage.ToByteArray());
}
}
public static MagickImage ToImage(this float[,] data)
{
MagickImage mi = new MagickImage(MagickColor.FromRgb(0, 0, 0), data.GetLength(0), data.GetLength(1));
float min, max;
data.MinMax(out min, out max);
using (IPixelCollection pi = mi.GetPixels())
{
for (int y = 0; y < mi.Height; y++)
{
for (int x = 0; x < mi.Width; x++)
{
float norm = 0;
byte bnorm = 0;
if (data[x, y] != 0)
{
norm = (data[x, y].NormaliseToRange(min, max));
bnorm = (byte)(norm * 255);
}
pi.ModifyPixel(x, y, MagickColor.FromRgb(bnorm, bnorm, bnorm));
}
}
}
return(mi);
}
static void Main(string[] args)
{
//Default alpha
Percentage alpha = new Percentage(60);
//DeleteFolderIcon();
//Creates our .ico file with color and alpha
//ResetWindowsIconCache();
if (args.Length > 0)
{
if (args[0] == "/color" && args.Length > 4)
{
Console.WriteLine("color");
string dir = args[1]; //pass our path first
MagickColor color = MagickColor.FromRgb(Convert.ToByte(args[2]), Convert.ToByte(args[3]), Convert.ToByte(args[4]));
CreateIcon(dir, color, alpha);
SetFolderIcon(dir);
}
else if (args[0] == "/restore")
{
Console.WriteLine("restore");
}
}
else
{
Console.WriteLine("Please enter a parameter");
}
//Console.ReadKey();
}
private void DrawBboxes(byte[] photo, Bbox[] bboxes, ref Image img)
{
using (var image = new MagickImage(photo))
{
var drawables = new Drawables();
drawables.StrokeWidth(ViewImage.Source.Height >= 1000 ? 8 : 2);
drawables.FillColor(MagickColor.FromRgba(255, 255, 255, 0));
drawables.StrokeColor(MagickColor.FromRgb(255, 0, 0));
foreach (var bbox in bboxes)
{
drawables.Rectangle(bbox.X,
bbox.Y,
bbox.X + bbox.Width,
bbox.Y + bbox.Height
);
}
image.Draw(drawables);
using (var ms = new MemoryStream(image.ToByteArray()))
{
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.StreamSource = ms;
bitmap.EndInit();
img.Source = bitmap;
}
}
}
public void CreateSprite_ValidMixedFileAndByteArrayListInImagesParam_ShouldGenerateCss()
{
// Arrange
const string cssFilename = @"c:\sprite.css";
const string spriteUrl = "/sprite.png";
const int image1Height = 1;
const int image1Width = 2;
MagickColor image1Colour = MagickColor.FromRgb(1, 1, 1);
var imageFile1 = new FileInfo(@"C:\a.png");
byte[] imageByteArray2 = Convert.FromBase64String(Image100X56Base64);
var magickImage1 = new MagickImage(image1Colour, image1Width, image1Height);
var magickImage2 = new MagickImage(imageByteArray2);
_magickImageHelper.Setup(x => x.Create(imageFile1)).Returns(magickImage1);
_magickImageHelper.Setup(x => x.Create(imageByteArray2)).Returns(magickImage2);
_fileMock.Setup(x => x.Exists(imageFile1.FullName)).Returns(true);
var images = new List <ISpriteImage>
{
new FileSpriteImage(imageFile1),
new ByteArraySpriteImage("b", imageByteArray2)
};
// Act
_spriteManager.CreateSprite(images, null, new SpriteSettings(@"c:\sprite.png", spriteUrl, cssFilename));
// Assert
_cssProcessorMock.Verify(x => x.CreateCss($"#a-png{{height:{image1Height}px;width:{image1Width}px;background:url('{spriteUrl}') 0 0;}}#b{{height:56px;width:100px;background:url('{spriteUrl}') 0 -{image1Height}px;}}", cssFilename));
}
public override MagickImage ApplyFilter(MagickImage image)
{
image.BackgroundColor = MagickColor.FromRgb(0, 0, 0);
image.Deskew(new Percentage(Threshold));
image.RePage();
return(image);
}
public EditableImage Apply(EditableImage image)
{
var bmp = image.Image;
var borderWidth = (int)Math.Round(bmp.Width / 100 * BorderWidthPercentage);
// For thicker borders try and keep to jpeg size blocks.
if (borderWidth > 16)
{
borderWidth = (int)Math.Round(borderWidth / 8d) * 8;
}
int newWidth = bmp.Width + borderWidth * 2;
int newHeight = bmp.Height + borderWidth * 2;
var newImage = new MagickImage(MagickColor.FromRgb(Colour.R, Colour.G, Colour.B), newWidth, newHeight);
image.ApplyExistingSettingsToOtherImage(newImage);
using (var clonedOriginal = image.Image.Clone())
{
newImage.Composite(clonedOriginal, Gravity.Center);
image.Image = newImage;
return(image);
}
}
public void GenerateImage(string achievementName, long gs, AchievementType type, ulong imageID)
{
// first determine background image path
string backgroundImagePath;
switch (type)
{
case AchievementType.XboxOneRare:
backgroundImagePath = Configuration.PathAchievementXboxOneRareBackground;
break;
case AchievementType.Xbox360:
backgroundImagePath = Configuration.PathAchievementXbox360Background;
break;
default:
backgroundImagePath = Configuration.PathAchievementXboxOneBackground;
break;
}
// passing the relative path was breaking it, so now just going to pass it the file stream instead
string path = Path.Combine(Directory.GetCurrentDirectory(), backgroundImagePath);
using (var backgroundStream = new FileStream(path, FileMode.Open))
{
// now do stuff with the image
using (MagickImage image = new MagickImage(backgroundImagePath))
{
MagickImage headerLayer = new MagickImage(MagickColor.FromRgba(0, 0, 0, 0), image.Width, image.Height);
if (type == AchievementType.XboxOne || type == AchievementType.XboxOneRare)
{
headerLayer.Settings.FontFamily = "Segoe UI";
headerLayer.Settings.FontPointsize = 36;
headerLayer.Settings.TextGravity = Gravity.Southwest;
headerLayer.Settings.FillColor = MagickColor.FromRgb(255, 255, 255);
}
if (type == AchievementType.XboxOne || type == AchievementType.Xbox360)
{
var s = $"{gs} - {achievementName}";
headerLayer.Annotate(s, new MagickGeometry(225, 30, 700, 80), Gravity.West);
}
else if (type == AchievementType.XboxOneRare)
{
int rarePercent;
Random r = new Random();
rarePercent = r.Next(1, 5);
headerLayer.Annotate($"Rare achievement unlocked - {rarePercent}%", new MagickGeometry(155, 5, 400, 70), Gravity.West);
headerLayer.Annotate($"{gs} - {achievementName}", new MagickGeometry(195, 55, 400, 70), Gravity.West);
}
image.Composite(headerLayer, CompositeOperator.Over);
image.Write(GenerateImagePath(imageID));
}
}
// increment the generation counter
GenerationCounter++;
}
public void ShouldReadTheCorrectColors()
{
using (var image = new MagickImage(Files.Coders.PlayerPSD))
{
ColorAssert.Equal(MagickColors.White, image, 0, 0);
ColorAssert.Equal(MagickColor.FromRgb(15, 43, 255), image, 8, 6);
}
}
public void ShouldReadTheCorrectColors()
{
using (IMagickImage image = new MagickImage(Files.Coders.PlayerPSD))
{
ColorAssert.AreEqual(MagickColors.Transparent, image, 0, 0);
ColorAssert.AreEqual(MagickColor.FromRgb(15, 43, 255), image, 8, 6);
}
}
private static void CompareSatelliteImageExample()
{
ImageManager imageMan = new ImageManager();
MagickImage imageA = imageMan.GetMagickImageFromFile(
new FileInfo(DataRootPath + @"Tuktoyaktuk\Radarsat1_Images\RS1_m0700829_S7_19970329_151016_HH_SGF\RS1_m0700829_S7_19970329_151016_HH_SGF.tif"));
MagickImage imageB = imageMan.GetMagickImageFromFile(
new FileInfo(DataRootPath + @"Tuktoyaktuk\Radarsat1_Images\RS1_m0700835_S5_20120919_152932_HH_SGF\RS1_m0700835_S5_20120919_152932_HH_SGF.tif"));
CompareSettings compareSettings = new CompareSettings()
{
Metric = ErrorMetric.Absolute,
HighlightColor = MagickColor.FromRgb(255, 255, 255), // white
LowlightColor = MagickColor.FromRgb(0, 0, 0), // black
};
FileInfo info = new FileInfo(DataRootPath + @"Tuktoyaktuk\compareA.tif");
byte[] diffImage = imageMan.CompareImages(imageA, imageB, compareSettings);
byte[] thumbImage = imageMan.GetThumbnailFromImage(diffImage, ImageManager.ThumbnailSize.Large);
FileInfo thumbFile = new FileInfo(DataRootPath + @"Tuktoyaktuk\compareA_thumb_medium.jpeg");
if (diffImage.Length > 0)
{
using (FileStream fs = new FileStream(info.FullName, FileMode.Create, FileAccess.Write))
{
fs.Write(diffImage, 0, diffImage.Length);
}
}
if (thumbImage.Length > 0)
{
using (FileStream fs = new FileStream(thumbFile.FullName, FileMode.Create, FileAccess.Write))
{
fs.Write(thumbImage, 0, thumbImage.Length);
}
}
compareSettings.Metric = ErrorMetric.Fuzz;
FileInfo info2 = new FileInfo(DataRootPath + @"Tuktoyaktuk\compareFuzz.tif");
diffImage = imageMan.CompareImages(imageA, imageB, compareSettings);
if (diffImage.Length > 0)
{
using (FileStream fs = new FileStream(info.FullName, FileMode.Create, FileAccess.Write))
{
fs.Write(diffImage, 0, diffImage.Length);
}
}
compareSettings.Metric = ErrorMetric.MeanAbsolute;
FileInfo info3 = new FileInfo(DataRootPath + @"Tuktoyaktuk\compareMeanAbsolute.tif");
diffImage = imageMan.CompareImages(imageA, imageB, compareSettings);
if (diffImage.Length > 0)
{
using (FileStream fs = new FileStream(info.FullName, FileMode.Create, FileAccess.Write))
{
fs.Write(diffImage, 0, diffImage.Length);
}
}
}
public Dictionary <char, IMagickImage> GetPieceDictionaryOfSize(int size)
{
var assembly = Assembly.GetExecutingAssembly();
using (var resources = assembly.GetManifestResourceStream("ChessLib.Graphics.Images.pieceArray.svg"))
{
var readSettings = new MagickReadSettings
{
BackgroundColor = MagickColors.Transparent
};
using (var bm = new MagickImage(resources, readSettings))
{
var pieces = new List <IMagickImage>();
var colorFrom = new MagickColor(0, 0, 0);
var colorTo = _imageOptions.BlackPieceColor;
var alterPieceColor = _imageOptions.MagickBlackPieceColor != MagickColor.FromRgb(0, 0, 0) ||
_imageOptions.MagickWhitePieceColor != MagickColor.FromRgb(255, 255, 255);
for (var row = 0; row < 2; row++)
{
for (var col = 0; col < 6; col++)
{
var x = col * 60;
var y = row * 60;
var piece = bm.Clone(new MagickGeometry(x, y, 60, 60));
piece.Resize(size, size);
piece.Alpha(AlphaOption.Set);
pieces.Add(piece.Clone());
piece.Dispose();
}
}
var pieceMap = new Dictionary <char, IMagickImage>
{
{ 'k', pieces[0].Clone() },
{ 'q', pieces[1].Clone() },
{ 'r', pieces[2].Clone() },
{ 'b', pieces[3].Clone() },
{ 'n', pieces[4].Clone() },
{ 'p', pieces[5].Clone() },
{ 'K', pieces[6].Clone() },
{ 'Q', pieces[7].Clone() },
{ 'R', pieces[8].Clone() },
{ 'B', pieces[9].Clone() },
{ 'N', pieces[10].Clone() },
{ 'P', pieces[11].Clone() }
};
foreach (var piece in pieces)
{
piece.Dispose();
}
return(pieceMap);
}
}
}
public void RenderTexture()
{
var wrapper = TestUtils.LoadMaterialWrapper("render_texture.mat");
Assert.AreEqual(typeof(StandardMaterial), wrapper.GetType());
using (var image = wrapper.GenerateToonLitImage())
using (var main = new MagickImage(MagickColor.FromRgb(0, 0, 0), 1, 1))
{
var result = image.Compare(main);
Assert.AreEqual(0.0, result.MeanErrorPerPixel);
}
}
public void UnlitColor()
{
var wrapper = TestUtils.LoadMaterialWrapper("Unlit_Color.mat");
Assert.AreEqual(typeof(StandardMaterial), wrapper.GetType());
using (var image = wrapper.CompositeLayers())
using (var main = new MagickImage(MagickColor.FromRgb(255, 0, 0), 1, 1))
{
var result = image.Compare(main);
Assert.AreEqual(0.0, result.MeanErrorPerPixel);
}
}
private string FindRegionByColour(int[] colour)
{
foreach (KeyValuePair <string, BIRegion> kv in regions)
{
MagickColor mg = MagickColor.FromRgb((byte)kv.Value.rgb[0], (byte)kv.Value.rgb[1], (byte)kv.Value.rgb[2]);
if (CompareColour(colour, mg))
{
return(kv.Key);
}
}
return(null);
}
public void ShouldChangeTheImageToBlackAndWhite()
{
using (var image = new MagickImage(Files.FujiFilmFinePixS1ProPNG))
{
var startColor = MagickColor.FromRgb(60, 110, 150);
var stopColor = MagickColor.FromRgb(70, 120, 170);
image.ColorThreshold(startColor, stopColor);
ColorAssert.Equal(MagickColors.White, image, 300, 160);
ColorAssert.Equal(MagickColors.Black, image, 300, 260);
}
}
public Drawables GetDrawables(ProfileData data)
{
MagickColor color = MagickColor.FromRgb(data.MainRoleColor.R, data.MainRoleColor.G, data.MainRoleColor.B);
MagickImage mask = new MagickImage(Source);
data.Picture.Composite(mask, CompositeOperator.CopyAlpha);
return(new Drawables()
.FillColor(color)
.Rectangle(StartX - StrokeWidth,
StartY - StrokeWidth,
StartX + AvatarSize + StrokeWidth,
StartY + AvatarSize + StrokeWidth));
}
private void GetCityCoordinates(string filepath)
{
MagickImage img = new MagickImage(filepath);
Misc_Data.regionWater = new bool[img.Width, img.Height];
Misc_Data.editRegionWater = new bool[img.Width, img.Height];
var pixels = img.GetPixels();
MagickColor black = MagickColor.FromRgb(0, 0, 0);
MagickColor water = MagickColor.FromRgb(41, 140, 233);
img.Rotate(180);
for (int x = 0; x < img.Width; x++)
{
for (int y = 0; y < img.Height; y++)
{
int[] pixelCol = new int[] { pixels[x, y].ToColor().R, pixels[x, y].ToColor().G, pixels[x, y].ToColor().B };
if (CompareColour(pixelCol, black)) //check for city
{
int tr, tg, tb;
tr = pixels[x, y + 1].ToColor().R;
tg = pixels[x, y + 1].ToColor().G;
tb = pixels[x, y + 1].ToColor().B;
if (CompareColour(new int[] { tr, tg, tb }, water)) // check for water
{
tr = pixels[x, y - 1].ToColor().R;
tg = pixels[x, y - 1].ToColor().G;
tb = pixels[x, y - 1].ToColor().B;
}
string index = FindRegionByColour(new int[] { tr, tg, tb });
regions[index].x = x;
regions[index].y = (img.Height - y) - 1;
Misc_Data.regionWater[x, (img.Height - y) - 1] = false;
}
else if (CompareColour(pixelCol, water))
{
Misc_Data.regionWater[x, (img.Height - y) - 1] = true;
}
else
{
Misc_Data.regionWater[x, (img.Height - y) - 1] = false;
}
}
}
}
public static async Task SaveImages(IEnumerable <MagickImage> images, SelectableOutputFormats format, DirectoryInfo location, IProgress <ushort>?progressReporter = null) => await Task.WhenAll(
images.Select((image, iterator) => Task.Run(() =>
{
string fileName;
MagickFormat finalFormat;
image.Quality = 100;
image.Alpha(AlphaOption.Remove);
image.BackgroundColor = MagickColor.FromRgb(255, 255, 255);
if (image.DetermineColorType() == ColorType.Grayscale)
{
image.Grayscale();
}
if (iterator < 9)
{
fileName = $"00{iterator + 1}";
}
else if (iterator < 99)
{
fileName = $"0{iterator + 1}";
}
else
{
fileName = $"{iterator + 1}";
}
switch (format)
{
case SelectableOutputFormats.JPG:
finalFormat = MagickFormat.Jpg;
fileName += ".jpg";
break;
case SelectableOutputFormats.PNG:
finalFormat = image.ColorType == ColorType.Grayscale ? MagickFormat.Png8 : MagickFormat.Png24;
fileName += ".png";
break;
case SelectableOutputFormats.PSD:
finalFormat = MagickFormat.Psd;
fileName += ".psd";
break;
default:
throw new ArgumentOutOfRangeException(nameof(format), format, null);
}
image.Write($"{location}{Path.DirectorySeparatorChar}{fileName}", finalFormat);
progressReporter?.Report(1);
})));
public static byte[] Crop(this byte[] source, Rectangle keptArea)
{
if (keptArea.Width * keptArea.Height == 0)
{
using (var image = new MagickImage(MagickColor.FromRgb(0, 0, 0), 0, 0))
return(image.ToByteArray());
}
using (var image = new MagickImage(source))
{
image.Crop(keptArea.Left, keptArea.Top, keptArea.Width, keptArea.Height);
return(image.ToByteArray());
}
}
protected void DrawMap(MagickImage image, int[,] geog, int[] borders = null)
{
using (IPixelCollection pixels = image.GetPixels())
{
if (borders != null)
{
for (int x = borders[0]; x < borders[2]; x++)
{
for (int y = borders[1]; y < borders[3]; y++)
{
MagickColor col;
float val = (float)geog[x, y] / 100f;
byte bval = (byte)(val * 255);
if (bval < sealevel)
{
col = MapColours.mapWaterColours[WaterColours.HeightsWater];
}
else
{
col = MagickColor.FromRgb(bval, bval, bval);
}
pixels.ModifyPixel(x, y, col);
}
}
}
else if (borders == null)
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
MagickColor col;
float val = (float)geog[x, y] / 100f;
byte bval = (byte)(val * 255);
if (bval < sealevel)
{
col = MapColours.mapWaterColours[WaterColours.HeightsWater];
}
else
{
col = MagickColor.FromRgb(bval, bval, bval);
}
pixels.ModifyPixel(x, y, col);
}
}
}
}
UpdateImage(image);
}
static void Main(string[] args)
{
MonsterCreation m = new MonsterCreation();
return;
var colorYellow = MagickColor.FromRgb(255, 242, 0);
var colorBlue = MagickColor.FromRgb(0, 0, 255);
ReplaceColor(new MagickImage($"{basePath}rectYellow.png"),
colorYellow, colorBlue, "rectBlue.png");
CombimeImages(new MagickImage($"{basePath}partial1.png"), new MagickImage($"{basePath}partial2.png"), "combine.png");
}
public void CreateSprite_ValidFileListInImagesParam_ShouldGenerateSprite()
{
// Arrange
const string spriteFilename = @"C:\sprite.png";
const int image1Height = 1;
const int image1Width = 2;
const int image2Height = 3;
const int image2Width = 4;
var image1Colour = MagickColor.FromRgb(5, 6, 7);
var image2Colour = MagickColor.FromRgb(8, 9, 10);
var imageFile1 = new FileInfo(@"C:\a.png");
var imageFile2 = new FileInfo(@"C:\b.png");
var magickImage1 = new MagickImage(image1Colour, image1Width, image1Height);
var magickImage2 = new MagickImage(image2Colour, image2Width, image2Height);
_magickImageHelper.Setup(x => x.Create(imageFile1)).Returns(magickImage1);
_magickImageHelper.Setup(x => x.Create(imageFile2)).Returns(magickImage2);
_fileMock.Setup(x => x.Exists(imageFile1.FullName)).Returns(true);
_fileMock.Setup(x => x.Exists(imageFile2.FullName)).Returns(true);
var spriteImages = new List <IMagickImage>();
_imageProcessorMock.Setup(x => x.CreateSprite(It.IsAny <MagickImageCollection>(), It.IsAny <ISpriteSettings>())).Callback((MagickImageCollection a, ISpriteSettings b) => spriteImages.AddRange(a));
var images = new List <ISpriteImage>
{
new FileSpriteImage(imageFile1),
new FileSpriteImage(imageFile2)
};
var spriteSettings = new FileSystemSpriteSettings(spriteFilename, "/sprite.png", @"c:\sprite.css");
// Act
_spriteManager.CreateSprite(images, null, spriteSettings);
// Assert
_imageProcessorMock.Verify(x => x.CreateSprite(It.IsAny <MagickImageCollection>(), spriteSettings));
spriteImages.Count.ShouldBe(2);
spriteImages[0].BackgroundColor.ShouldBe(image1Colour);
spriteImages[0].Width.ShouldBe(image1Width);
spriteImages[0].Height.ShouldBe(image1Height);
spriteImages[1].BackgroundColor.ShouldBe(image2Colour);
spriteImages[1].Width.ShouldBe(image2Width);
spriteImages[1].Height.ShouldBe(image2Height);
}
public void LineNoize()
{
var rnd = new Random((int)Environment.TickCount);
var count = rnd.Next(6 * Math.Max(_current.Width, _current.Height));
for (int i = 0; i < count; i++)
{
var x1 = rnd.Next(0, _current.Width);
var y1 = rnd.Next(0, _current.Height);
var x2 = rnd.Next(-25, 25);
var y2 = rnd.Next(-25, 25);
byte[] rgb = new byte[3];
rnd.NextBytes(rgb);
DrawableFillColor fillColor = new DrawableFillColor(MagickColor.FromRgb(rgb[0], rgb[1], rgb[2]));
DrawableLine dl = new DrawableLine(x1, y1, x1 + x2, y1 + y2);
_current.Draw(fillColor, dl);
}
}
public static void DrawMap()
{
try
{
var result = new MagickImage(MagickColor.FromRgb(0, 0, 0), 4096, 4096)
{
Format = MagickFormat.Png
};
for (var i = -2048; i < 2048; i++) // x
{
for (var j = 2048; j > -2048; j--) // y
{
var pixelX = i + 2048;
var pixelY = j + 2048;
var biome = "hello";
var hash = biome.GetHashCode();
var r = (byte)((hash & 0xFF0000) >> 16);
var g = (byte)((hash & 0x00FF00) >> 8);
var b = (byte)(hash & 0x0000FF);
var color = MagickColor.FromRgb(r, g, b);
new Drawables()
.FillColor(color)
.StrokeColor(color)
.Point(pixelX, pixelY)
.Draw(result);
}
}
result.Write(new FileInfo(@"d:\temp\subnautica-map.png"));
}
catch (Exception e)
{
Log("Error in Draw Map");
Log(e.Message);
Log(e.StackTrace);
throw;
}
}
public IMagickImage Execute(IMagickImage image, ValueItemCollection values)
{
Variables = values;
if (RemoveBackgroundActive)
{
image.ColorAlpha(MagickColors.Transparent);
image.Alpha(AlphaOption.Set);
image.VirtualPixelMethod = VirtualPixelMethod.Transparent;
// image.ColorFuzz = new Percentage(RemoveBackgroundThreshold);
// image.TransparentChroma(new MagickColor("#FFFFFF"), new MagickColor("#F0F0F0"));
// image.Transparent(MagickColor.FromRgb(255, 255, 255));
var clone = image.Clone();
clone.ColorFuzz = new Percentage(RemoveBackgroundThreshold);
clone.TransparentChroma(new MagickColor("#FFFFFF"), new MagickColor("#F0F0F0"));
clone.Transparent(MagickColor.FromRgb(255, 255, 255));
if (RemoveBackgroundFeather > 0)
{
clone.Scale(new Percentage(10));
clone.Blur(0, RemoveBackgroundFeather, Channels.Alpha);
clone.Resize(image.Width, image.Width);
}
image.Composite(clone, CompositeOperator.CopyAlpha);
image.Alpha(AlphaOption.Background);
using (MagickImageCollection images = new MagickImageCollection())
{
var back = new MagickImage(MagickColors.White, image.Width, image.Height);
images.Add(back);
images.Add(image);
image = images.Flatten().Clone();
}
}
// image.Threshold(new Percentage(RemoveBackgroundThreshold));
// image.Transparent(MagickColor.FromRgb(255, 255, 255));
return(image);
}
