public void PaletteQuantizerConstructor()
{
var expected = new QuantizerOptions {
MaxColors = 128
};
var quantizer = new PaletteQuantizer(Palette, expected);
Assert.Equal(expected.MaxColors, quantizer.Options.MaxColors);
Assert.Equal(QuantizerConstants.DefaultDither, quantizer.Options.Dither);
expected = new QuantizerOptions {
Dither = null
};
quantizer = new PaletteQuantizer(Palette, expected);
Assert.Equal(QuantizerConstants.MaxColors, quantizer.Options.MaxColors);
Assert.Null(quantizer.Options.Dither);
expected = new QuantizerOptions {
Dither = KnownDitherings.Atkinson
};
quantizer = new PaletteQuantizer(Palette, expected);
Assert.Equal(QuantizerConstants.MaxColors, quantizer.Options.MaxColors);
Assert.Equal(KnownDitherings.Atkinson, quantizer.Options.Dither);
expected = new QuantizerOptions {
Dither = KnownDitherings.Atkinson, MaxColors = 0
};
quantizer = new PaletteQuantizer(Palette, expected);
Assert.Equal(QuantizerConstants.MinColors, quantizer.Options.MaxColors);
Assert.Equal(KnownDitherings.Atkinson, quantizer.Options.Dither);
}
public void PaletteQuantizerCanCreateFrameQuantizer()
{
var quantizer = new PaletteQuantizer(Palette);
IFrameQuantizer <Rgba32> frameQuantizer = quantizer.CreateFrameQuantizer <Rgba32>(Configuration.Default);
Assert.NotNull(frameQuantizer);
Assert.NotNull(frameQuantizer.Options);
Assert.Equal(QuantizerConstants.DefaultDither, frameQuantizer.Options.Dither);
frameQuantizer.Dispose();
quantizer = new PaletteQuantizer(Palette, new QuantizerOptions {
Dither = null
});
frameQuantizer = quantizer.CreateFrameQuantizer <Rgba32>(Configuration.Default);
Assert.NotNull(frameQuantizer);
Assert.Null(frameQuantizer.Options.Dither);
frameQuantizer.Dispose();
quantizer = new PaletteQuantizer(Palette, new QuantizerOptions {
Dither = KnownDitherings.Atkinson
});
frameQuantizer = quantizer.CreateFrameQuantizer <Rgba32>(Configuration.Default);
Assert.NotNull(frameQuantizer);
Assert.Equal(KnownDitherings.Atkinson, frameQuantizer.Options.Dither);
frameQuantizer.Dispose();
}
private void EncodeGlobal <TPixel>(Image <TPixel> image, QuantizedFrame <TPixel> quantized, int transparencyIndex, Stream stream)
where TPixel : struct, IPixel <TPixel>
{
var palleteQuantizer = new PaletteQuantizer <TPixel>(quantized.Palette, this.quantizer.Diffuser);
for (int i = 0; i < image.Frames.Count; i++)
{
ImageFrame <TPixel> frame = image.Frames[i];
ImageFrameMetadata metadata = frame.Metadata;
GifFrameMetadata frameMetadata = metadata.GetFormatMetadata(GifFormat.Instance);
this.WriteGraphicalControlExtension(frameMetadata, transparencyIndex, stream);
this.WriteImageDescriptor(frame, false, stream);
if (i == 0)
{
this.WriteImageData(quantized, stream);
}
else
{
using (IFrameQuantizer <TPixel> palleteFrameQuantizer = palleteQuantizer.CreateFrameQuantizer(image.GetConfiguration()))
using (QuantizedFrame <TPixel> paletteQuantized = palleteFrameQuantizer.QuantizeFrame(frame))
{
this.WriteImageData(paletteQuantized, stream);
}
}
}
}
private void EncodeGlobal <TPixel>(Image <TPixel> image, QuantizedFrame <TPixel> quantized, int transparencyIndex, Stream stream)
where TPixel : struct, IPixel <TPixel>
{
var palleteQuantizer = new PaletteQuantizer(this.quantizer.Diffuser);
for (int i = 0; i < image.Frames.Count; i++)
{
ImageFrame <TPixel> frame = image.Frames[i];
this.WriteGraphicalControlExtension(frame.MetaData, transparencyIndex, stream);
this.WriteImageDescriptor(frame, false, stream);
if (i == 0)
{
this.WriteImageData(quantized, stream);
}
else
{
using (QuantizedFrame <TPixel> paletteQuantized = palleteQuantizer.CreateFrameQuantizer(() => quantized.Palette).QuantizeFrame(frame))
{
this.WriteImageData(paletteQuantized, stream);
}
}
}
}
private void EncodeGlobal <TPixel>(Image <TPixel> image, IndexedImageFrame <TPixel> quantized, int transparencyIndex, Stream stream)
where TPixel : unmanaged, IPixel <TPixel>
{
// The palette quantizer can reuse the same pixel map across multiple frames
// since the palette is unchanging. This allows a reduction of memory usage across
// multi frame gifs using a global palette.
EuclideanPixelMap <TPixel> pixelMap = default;
bool pixelMapSet = false;
for (int i = 0; i < image.Frames.Count; i++)
{
ImageFrame <TPixel> frame = image.Frames[i];
ImageFrameMetadata metadata = frame.Metadata;
GifFrameMetadata frameMetadata = metadata.GetGifMetadata();
this.WriteGraphicalControlExtension(frameMetadata, transparencyIndex, stream);
this.WriteImageDescriptor(frame, false, stream);
if (i == 0)
{
this.WriteImageData(quantized, stream);
}
else
{
if (!pixelMapSet)
{
pixelMapSet = true;
pixelMap = new EuclideanPixelMap <TPixel>(this.configuration, quantized.Palette);
}
using var paletteFrameQuantizer = new PaletteQuantizer <TPixel>(this.configuration, this.quantizer.Options, pixelMap);
using IndexedImageFrame <TPixel> paletteQuantized = paletteFrameQuantizer.QuantizeFrame(frame, frame.Bounds());
this.WriteImageData(paletteQuantized, stream);
}
}
}
public static Bitmap Quantize(Bitmap bitmap, int colourCount)
{
var quantizer = new PaletteQuantizer();
for (int x = 0; x < bitmap.Width; x++)
{
for (int y = 0; y < bitmap.Height; y++)
{
var colour = bitmap.GetPixel(x, y);
quantizer.AddColour(colour);
}
}
quantizer.Quantize(colourCount);
var ret = new Bitmap(bitmap.Width, bitmap.Height);
for (int x = 0; x < bitmap.Width; x++)
{
for (int y = 0; y < bitmap.Height; y++)
{
var colour = quantizer.GetQuantizedColour(bitmap.GetPixel(x, y));
ret.SetPixel(x, y, colour);
}
}
return(ret);
}
private async void ProcessImage(ProjectItem item, TileSetModel tileSet, string filePath)
{
string imagesFolder = (string)Application.Current.FindResource(_folderImagesKey);
ProjectModel projectModel = ModelManager.Get <ProjectModel>();
string imageFolderFullPath = Path.Combine(projectModel.ProjectPath, imagesFolder);
if (!Directory.Exists(imageFolderFullPath))
{
_ = Directory.CreateDirectory(imageFolderFullPath);
}
PaletteQuantizer quantizer = new PaletteQuantizer
{
InputFileName = filePath,
ColorCache = PaletteQuantizer.EColorCache.OctreeSearch,
Method = PaletteQuantizer.EMethod.NESQuantizer
};
// todo: If the source image is the same as the output image, Crash!!
Image outputImage = await quantizer.Convert();
string outputImagePath = Path.Combine(imageFolderFullPath, item.DisplayName + ".bmp");
tileSet.ImagePath = Path.Combine(imagesFolder, item.DisplayName + ".bmp");
tileSet.ImageWidth = outputImage.Width;
tileSet.ImageHeight = outputImage.Height;
item.FileHandler.Save();
outputImage.Save(outputImagePath, ImageFormat.Bmp);
SignalManager.Get <UpdateTileSetImageSignal>().Dispatch();
}
/// <summary>
/// Initializes a new instance of the <see cref="PaletteFrameQuantizer{TPixel}"/> class.
/// </summary>
/// <param name="quantizer">The palette quantizer.</param>
/// <param name="colors">An array of all colors in the palette.</param>
public PaletteFrameQuantizer(PaletteQuantizer quantizer, TPixel[] colors)
: base(quantizer, true)
{
Guard.MustBeBetweenOrEqualTo(colors.Length, 1, 256, nameof(colors));
this.palette = colors;
this.paletteVector = new Vector4[this.palette.Length];
PixelOperations <TPixel> .Instance.ToScaledVector4(this.palette, this.paletteVector, this.palette.Length);
}
public void QuantizersDitherByDefault()
{
var palette = new PaletteQuantizer <Rgba32>();
var octree = new OctreeQuantizer <Rgba32>();
var wu = new WuQuantizer <Rgba32>();
Assert.True(palette.Dither);
Assert.True(octree.Dither);
Assert.True(wu.Dither);
}
/// <summary>
/// Generates an indexed 256-color palette from the specified image and overwrites the current palette with it.
/// Ordinarily, this would be the original mipmap.
/// </summary>
/// <param name="inImage">Image.</param>
private void GeneratePalette(Image inImage)
{
// TODO: Replace with an algorithm that produces a better result. For now, it works.
PaletteQuantizer quantizer = new PaletteQuantizer(new ArrayList());
using (Bitmap quantizedMap = quantizer.Quantize(inImage))
{
this.Palette.Clear();
this.Palette.AddRange(quantizedMap.Palette.Entries);
}
}
public void QuantizersDitherByDefault()
{
var palette = new PaletteQuantizer();
var octree = new OctreeQuantizer();
var wu = new WuQuantizer();
Assert.NotNull(palette.Diffuser);
Assert.NotNull(octree.Diffuser);
Assert.NotNull(wu.Diffuser);
Assert.True(palette.CreateFrameQuantizer <Rgba32>().Dither);
Assert.True(octree.CreateFrameQuantizer <Rgba32>().Dither);
Assert.True(wu.CreateFrameQuantizer <Rgba32>().Dither);
}
public void PaletteQuantizerConstructor()
{
var quantizer = new PaletteQuantizer(Rgb);
Assert.Equal(Rgb, quantizer.Palette);
Assert.Equal(KnownDiffusers.FloydSteinberg, quantizer.Diffuser);
quantizer = new PaletteQuantizer(Rgb, false);
Assert.Equal(Rgb, quantizer.Palette);
Assert.Null(quantizer.Diffuser);
quantizer = new PaletteQuantizer(Rgb, KnownDiffusers.Atkinson);
Assert.Equal(Rgb, quantizer.Palette);
Assert.Equal(KnownDiffusers.Atkinson, quantizer.Diffuser);
}
public static Image2 Quantize(this Image2 source, Quantization mode = Quantization.Octree, int maxColors = 256)
{
IQuantizer quantizer;
switch (mode){
case Quantization.Wu:
quantizer = new WuQuantizer();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer();
break;
default:
quantizer = new OctreeQuantizer();
break;
}
return Quantize(source, quantizer, maxColors);
}
public void PaletteQuantizerYieldsCorrectTransparentPixel <TPixel>(TestImageProvider <TPixel> provider, bool dither)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image = provider.GetImage())
{
Assert.True(image[0, 0].Equals(default(TPixel)));
var quantizer = new PaletteQuantizer(dither);
foreach (ImageFrame <TPixel> frame in image.Frames)
{
QuantizedFrame <TPixel> quantized = quantizer.CreateFrameQuantizer <TPixel>().QuantizeFrame(frame);
int index = this.GetTransparentIndex(quantized);
Assert.Equal(index, quantized.GetPixelSpan()[0]);
}
}
}
public static Image2 Quantize(this Image2 source, Quantization mode = Quantization.Octree, int maxColors = 256)
{
IQuantizer quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer();
break;
default:
quantizer = new OctreeQuantizer();
break;
}
return(Quantize(source, quantizer, maxColors));
}
/// <summary>
/// Applies quantization to the image.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="mode">The quantization mode to apply to perform the operation.</param>
/// <param name="maxColors">The maximum number of colors to return. Defaults to 256.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static IImageProcessingContext <TPixel> Quantize <TPixel>(this IImageProcessingContext <TPixel> source, Quantization mode = Quantization.Octree, int maxColors = 256)
where TPixel : struct, IPixel <TPixel>
{
IQuantizer <TPixel> quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer <TPixel>();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer <TPixel>();
break;
default:
quantizer = new OctreeQuantizer <TPixel>();
break;
}
return(Quantize(source, quantizer, maxColors));
}
/// <summary>
/// Applies quantization to the image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="mode">The quantization mode to apply to perform the operation.</param>
/// <param name="maxColors">The maximum number of colors to return. Defaults to 256.</param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Quantize <TColor>(this Image <TColor> source, Quantization mode = Quantization.Octree, int maxColors = 256)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
IQuantizer <TColor> quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer <TColor>();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer <TColor>();
break;
default:
quantizer = new OctreeQuantizer <TColor>();
break;
}
return(Quantize(source, quantizer, maxColors));
}
public void PaletteQuantizerCanCreateFrameQuantizer()
{
var quantizer = new PaletteQuantizer(Rgb);
IFrameQuantizer <Rgba32> frameQuantizer = quantizer.CreateFrameQuantizer <Rgba32>(Configuration.Default);
Assert.NotNull(frameQuantizer);
Assert.True(frameQuantizer.Dither);
Assert.Equal(KnownDiffusers.FloydSteinberg, frameQuantizer.Diffuser);
quantizer = new PaletteQuantizer(Rgb, false);
frameQuantizer = quantizer.CreateFrameQuantizer <Rgba32>(Configuration.Default);
Assert.NotNull(frameQuantizer);
Assert.False(frameQuantizer.Dither);
Assert.Null(frameQuantizer.Diffuser);
quantizer = new PaletteQuantizer(Rgb, KnownDiffusers.Atkinson);
frameQuantizer = quantizer.CreateFrameQuantizer <Rgba32>(Configuration.Default);
Assert.NotNull(frameQuantizer);
Assert.True(frameQuantizer.Dither);
Assert.Equal(KnownDiffusers.Atkinson, frameQuantizer.Diffuser);
}
/// <summary>
/// Applies quantization to the image.
/// </summary>
/// <typeparam name="T">The pixel format.</typeparam>
/// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="mode">The quantization mode to apply to perform the operation.</param>
/// <param name="maxColors">The maximum number of colors to return. Defaults to 256.</param>
/// <returns>The <see cref="Image{T,TP}"/>.</returns>
public static Image <T, TP> Quantize <T, TP>(this Image <T, TP> source, Quantization mode = Quantization.Octree, int maxColors = 256)
where T : IPackedVector <TP>
where TP : struct
{
IQuantizer <T, TP> quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer <T, TP>();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer <T, TP>();
break;
default:
quantizer = new OctreeQuantizer <T, TP>();
break;
}
return(Quantize(source, quantizer, maxColors));
}
public Node(PaletteQuantizer parent)
{
this.parent = parent;
}
private void CreatePreviewPalette()
{
IColorQuantizer quantizer = new PaletteQuantizer();
//List<Color32> colors;
if (texturePalette != null)
{
Texture2D tp = GetReadableTexture(texturePalette);
Color32[] cs32 = tp.GetPixels32();
if (tp.width == 256 && tp.height == 1)
{
//Don't use quantizer
selectedPalette = new List <Color32>();
foreach (var c32 in cs32)
{
selectedPalette.Add(c32);
}
}
else
{
foreach (var c32 in cs32)
{
quantizer.AddColor(c32);
}
selectedPalette = quantizer.GetPalette(255);
}
}
else
{
for (int i = 0; i < selectedVoxelInfo.Count; i++)
{
VoxInfo v = selectedVoxelInfo[i];
quantizer.AddColor(v.col);
}
selectedPalette = quantizer.GetPalette(colorTotal);
}
previewPalette = new Texture2D(8, 32, TextureFormat.ARGB32, false);
previewPalette.filterMode = FilterMode.Point;
int xp = 0;
int yp = 0;
foreach (var c in selectedPalette)
{
previewPalette.SetPixel(xp, yp, c);
xp++;
if (xp >= 8)
{
xp = 0;
yp++;
}
}
previewPalette.Apply();
foreach (VoxInfo v in selectedVoxelInfo)
{
v.idx = (Byte)(ClosestColor(selectedPalette, v.col) + 1);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PaletteFrameQuantizer{TPixel}"/> class.
/// </summary>
/// <param name="quantizer">The palette quantizer</param>
public PaletteFrameQuantizer(PaletteQuantizer quantizer)
: base(quantizer, true)
{
this.colors = quantizer.GetPalette <TPixel>();
}
public void PaletteQuantizerThrowsOnInvalidGenericMethodCall()
{
var quantizer = new PaletteQuantizer <Rgba32>(Rgb);
Assert.Throws <InvalidOperationException>(() => ((IQuantizer)quantizer).CreateFrameQuantizer <Rgb24>(Configuration.Default));
}
