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)); }