public IEnumerable <int> Process(IEnumerable <Color> colors) { var colorList = colors.ToArray(); _quantizer.CreatePalette(colorList); var processingAction = new Action <LineTask <Color[], int[]> >(taskModel => { var matrixWidth = Matrix.GetLength(0); var matrixHeight = Matrix.GetLength(1); for (int i = taskModel.Start; i < taskModel.Start + taskModel.Length; i++) { int x = i % _width % matrixWidth; int y = i / _width % matrixHeight; int threshold = Convert.ToInt32(Matrix[x, y]); var color = taskModel.Input[i]; int red = GetClampedValue(color.R + threshold, 0, 255); int green = GetClampedValue(color.G + threshold, 0, 255); int blue = GetClampedValue(color.B + threshold, 0, 255); taskModel.Output[i] = _quantizer.GetPaletteIndex(Color.FromArgb(color.A, red, green, blue)); } }); var indices = new int[colorList.Length]; ParallelProcessing.ProcessList(colorList, indices, processingAction, _quantizer.TaskCount); return(indices); }
public Bitmap GenerateNewBitmap(Bitmap bitmap, IColorQuantizer quantizer, int colorCount) { var colors = GetPalette(bitmap, quantizer, colorCount).ToArray(); Func <Color, Color> func = c => colors[quantizer.GetPaletteIndex(c)]; return(_imageBuilder.BuildBitmap(bitmap, func)); }
private void ProcessingAction(DelayedLineTask <ErrorDiffusionElement <Color, ColorComponentError>, int[]> delayedLineTask, int index) { // Get reference elements to work with var inputElement = delayedLineTask.Input[index]; var sourceColor = inputElement.Input; var error = inputElement.Error; // Add error component values to source color var errorDiffusedColor = Color.FromArgb( sourceColor.A, GetClampedValue(sourceColor.R + error.RedError, 0, 255), GetClampedValue(sourceColor.G + error.GreenError, 0, 255), GetClampedValue(sourceColor.B + error.BlueError, 0, 255)); // Quantize error diffused source color delayedLineTask.Output[index] = _quantizer.GetPaletteIndex(errorDiffusedColor); // Retrieve new quantized color for this point var targetColor = _quantizer.GetPalette()[delayedLineTask.Output[index]]; // Calculate errors to distribute for this point int redError = errorDiffusedColor.R - targetColor.R; int greenError = errorDiffusedColor.G - targetColor.G; int blueError = errorDiffusedColor.B - targetColor.B; // Retrieve point position var pixelX = index % _width; var pixelY = index / _width; // Process the matrix for (int shiftY = -MatrixSideHeight; shiftY <= MatrixSideHeight; shiftY++) { for (int shiftX = -MatrixSideWidth; shiftX <= MatrixSideWidth; shiftX++) { int targetX = pixelX + shiftX; int targetY = pixelY + shiftY; var coefficient = Matrix[shiftY + MatrixSideHeight, shiftX + MatrixSideWidth]; var errorFactor = ErrorFactorMatrix[shiftY + MatrixSideHeight, shiftX + MatrixSideWidth]; // If substantial error factor and target point in image bounds if (coefficient != 0 && targetX >= 0 && targetX < _width && targetY >= 0 && targetY < _height) { // Add error to target point for later processing var newTarget = delayedLineTask.Input[targetX + targetY * _width]; newTarget.Error.RedError += Convert.ToInt32(errorFactor * redError); newTarget.Error.GreenError += Convert.ToInt32(errorFactor * greenError); newTarget.Error.BlueError += Convert.ToInt32(errorFactor * blueError); } } } }
public void SetColor(Color color, IColorQuantizer quantizer) { // determines whether the format is indexed if (IsIndexed) { // last chance if quantizer is provided, use it if (quantizer != null) { Byte index = (Byte)quantizer.GetPaletteIndex(color, X, Y); ((IIndexedPixel)pixelData).SetIndex(bitOffset, index); } else // cannot write color to an index format { String message = string.Format("Cannot retrieve color for an indexed format. Use GetPixelIndex() instead."); throw new NotSupportedException(message); } } else // sets color to a non-indexed format { ((INonIndexedPixel)pixelData).SetColor(color); } }
public void SetColorToPixel(Pixel pixel, Color color, IColorQuantizer quantizer) { // determines whether the format is indexed if (pixel.IsIndexed) { // last chance if quantizer is provided, use it if (quantizer != null) { Byte index = (Byte)quantizer.GetPaletteIndex(color, pixel.X, pixel.Y); pixel.Index = index; } else // cannot write color to an index format { String message = string.Format("Cannot retrieve color for an indexed format. Use GetPixelIndex() instead."); throw new NotSupportedException(message); } } else // sets color to a non-indexed format { pixel.Color = color; } }
private Image GetQuantizedImage(Image image) { // checks whether a source image is valid if (image == null) { const String message = "Cannot quantize a null image."; throw new ArgumentNullException(message); } // locks the source image data Bitmap bitmap = (Bitmap)image; Rectangle bounds = Rectangle.FromLTRB(0, 0, bitmap.Width, bitmap.Height); BitmapData sourceData = bitmap.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); // prepares time statistics variables TimeSpan duration = new TimeSpan(0); DateTime before; try { // initalizes the pixel read buffer Int32[] sourceBuffer = new Int32[image.Width]; // sets the offset to the first pixel in the image Int64 sourceOffset = sourceData.Scan0.ToInt64(); for (Int32 row = 0; row < image.Height; row++) { // copies the whole row of pixels to the buffer Marshal.Copy(new IntPtr(sourceOffset), sourceBuffer, 0, image.Width); // scans all the colors in the buffer foreach (Color color in sourceBuffer.Select(argb => Color.FromArgb(argb))) { before = DateTime.Now; activeQuantizer.AddColor(color); duration += DateTime.Now - before; } // increases a source offset by a row sourceOffset += sourceData.Stride; } editTargetInfo.Text = string.Format("Quantized: {0} colors (duration {1})", 256, duration); // TODO } catch { bitmap.UnlockBits(sourceData); throw; } Bitmap result = new Bitmap(image.Width, image.Height, PixelFormat.Format8bppIndexed); // calculates the palette try { before = DateTime.Now; Int32 colorCount = GetColorCount(); List <Color> palette = activeQuantizer.GetPalette(colorCount); // sets our newly calculated palette to the target image ColorPalette imagePalette = result.Palette; duration += DateTime.Now - before; for (Int32 index = 0; index < palette.Count; index++) { imagePalette.Entries[index] = palette[index]; } result.Palette = imagePalette; } catch (Exception) { bitmap.UnlockBits(sourceData); throw; } // locks the target image data BitmapData targetData = result.LockBits(bounds, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed); try { // initializes read/write buffers Byte[] targetBuffer = new Byte[result.Width]; Int32[] sourceBuffer = new Int32[image.Width]; // sets the offsets on the beginning of both source and target image Int64 sourceOffset = sourceData.Scan0.ToInt64(); Int64 targetOffset = targetData.Scan0.ToInt64(); for (Int32 row = 0; row < image.Height; row++) { // reads the pixel row from the source image Marshal.Copy(new IntPtr(sourceOffset), sourceBuffer, 0, image.Width); // goes thru all the pixels, reads the color on the source image, and writes calculated palette index on the target for (Int32 index = 0; index < image.Width; index++) { Color color = Color.FromArgb(sourceBuffer[index]); before = DateTime.Now; targetBuffer[index] = (Byte)activeQuantizer.GetPaletteIndex(color); duration += DateTime.Now - before; } // writes the pixel row to the target image Marshal.Copy(targetBuffer, 0, new IntPtr(targetOffset), result.Width); // increases the offsets (on both images) by a row sourceOffset += sourceData.Stride; targetOffset += targetData.Stride; } } finally { // releases the locks on both images bitmap.UnlockBits(sourceData); result.UnlockBits(targetData); } // spits some duration statistics (those actually slow the processing quite a bit, turn them off to make it quicker) editSourceInfo.Text = string.Format("Original: {0} colors ({1} x {2})", activeQuantizer.GetColorCount(), image.Width, image.Height); // returns the quantized image return(result); }
public void SetColor(Color color, IColorQuantizer quantizer) { // determines whether the format is indexed if (IsIndexed) { // last chance if quantizer is provided, use it if (quantizer != null) { Byte index = (Byte) quantizer.GetPaletteIndex(color, X, Y); ((IIndexedPixel) pixelData).SetIndex(bitOffset, index); } else // cannot write color to an index format { String message = string.Format("Cannot retrieve color for an indexed format. Use GetPixelIndex() instead."); throw new NotSupportedException(message); } } else // sets color to a non-indexed format { ((INonIndexedPixel) pixelData).SetColor(color); } }
private Image GetQuantizedImage(Image image) { if (image == null) { const String message = "Cannot quantize your file. Please choose a new file."; throw new ArgumentNullException(message); } Bitmap bitmap = (Bitmap)image; Rectangle bounds = Rectangle.FromLTRB(0, 0, bitmap.Width, bitmap.Height); BitmapData sourceData = bitmap.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); try { int[] sourceBuffer = new int[image.Width]; Int64 sourceOffset = sourceData.Scan0.ToInt64(); for (int i = 0; i < image.Height; i++) { Marshal.Copy(new IntPtr(sourceOffset), sourceBuffer, 0, image.Width); foreach (Color color in sourceBuffer.Select(argb => Color.FromArgb(argb))) { activeQuantizer.AddColor(color); } sourceOffset += sourceData.Stride; } } catch { bitmap.UnlockBits(sourceData); throw; } Bitmap result = new Bitmap(image.Width, image.Height, PixelFormat.Format8bppIndexed); try { List <Color> palette = activeQuantizer.GetPalette(256); ColorPalette imagePalette = result.Palette; for (Int32 index = 0; index < palette.Count; index++) { imagePalette.Entries[index] = palette[index]; } PaletteBox.Image = GetPalette.GetPaletteBitmap(palette); result.Palette = imagePalette; } catch (Exception) { bitmap.UnlockBits(sourceData); throw; } BitmapData targetData = result.LockBits(bounds, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed); try { Byte[] targetBuffer = new Byte[result.Width]; int[] sourceBuffer = new int[image.Width]; Int64 sourceOffset = sourceData.Scan0.ToInt64(); Int64 targetOffset = targetData.Scan0.ToInt64(); for (int i = 0; i < image.Height; i++) { Marshal.Copy(new IntPtr(sourceOffset), sourceBuffer, 0, image.Width); for (int j = 0; j < image.Width; j++) { Color color = Color.FromArgb(sourceBuffer[j]); targetBuffer[j] = (Byte)activeQuantizer.GetPaletteIndex(color); } Marshal.Copy(targetBuffer, 0, new IntPtr(targetOffset), result.Width); sourceOffset += sourceData.Stride; targetOffset += targetData.Stride; } } finally { bitmap.UnlockBits(sourceData); result.UnlockBits(targetData); } this.Result = result; ColorDistanceBox.Text = ColorDistance.GetColorDistance(this.SourceImage, result).ToString(); return(result); }
public void SetColorToPixel(Pixel pixel, Color color, IColorQuantizer quantizer) { // determines whether the format is indexed if (pixel.IsIndexed) { // last chance if quantizer is provided, use it if (quantizer != null) { Byte index = (Byte)quantizer.GetPaletteIndex(color, pixel.X, pixel.Y); pixel.Index = index; } else // cannot write color to an index format { String message = string.Format("Cannot retrieve color for an indexed format. Use GetPixelIndex() instead."); throw new NotSupportedException(message); } } else // sets color to a non-indexed format { pixel.Color = color; } }
public Image GetQuantizedImage(Image image) { // checks whether a source image is valid if (image == null) { const String message = "Cannot quantize a null image."; throw new ArgumentNullException(message); } // locks the source image data Bitmap bitmap = (Bitmap)image; Rectangle bounds = Rectangle.FromLTRB(0, 0, bitmap.Width, bitmap.Height); BitmapData sourceData = bitmap.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); try { Int32[] sourceBuffer = new Int32[image.Width]; Int64 sourceOffset = sourceData.Scan0.ToInt64(); for (Int32 row = 0; row < image.Height; row++) { Marshal.Copy(new IntPtr(sourceOffset), sourceBuffer, 0, image.Width); foreach (Color color in sourceBuffer.Select(argb => Color.FromArgb(argb))) { quantizer.AddColor(color); } // increases a source offset by a row sourceOffset += sourceData.Stride; } } catch { bitmap.UnlockBits(sourceData); throw; } // calculates the palette Bitmap result = new Bitmap(image.Width, image.Height, PixelFormat.Format8bppIndexed); List <Color> palette = quantizer.GetPalette(256); ColorPalette imagePalette = result.Palette; for (Int32 index = 0; index < palette.Count; index++) { try { imagePalette.Entries[index] = palette[index]; } catch { } } result.Palette = imagePalette; // locks the target image data BitmapData targetData = result.LockBits(bounds, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed); try { Byte[] targetBuffer = new Byte[result.Width]; Int32[] sourceBuffer = new Int32[image.Width]; Int64 sourceOffset = sourceData.Scan0.ToInt64(); Int64 targetOffset = targetData.Scan0.ToInt64(); for (Int32 row = 0; row < image.Height; row++) { Marshal.Copy(new IntPtr(sourceOffset), sourceBuffer, 0, image.Width); for (Int32 index = 0; index < image.Width; index++) { Color color = Color.FromArgb(sourceBuffer[index]); targetBuffer[index] = quantizer.GetPaletteIndex(color); } Marshal.Copy(targetBuffer, 0, new IntPtr(targetOffset), result.Width); // increases the offsets by a row sourceOffset += sourceData.Stride; targetOffset += targetData.Stride; } } finally { // releases the locks on both images bitmap.UnlockBits(sourceData); result.UnlockBits(targetData); } return(result); }
public void Quantize(IColorQuantizer quantizer, int colorCount) { if (Disposed) { return; } int myWidth = Width; int myHeight = Height; Color *colors = GetColors(); quantizer.Prepare(this); bool usesAlpha = false; // weird stuff to make the quantizer work with alpha Color lastColor = new Color(255, 255, 255, 0); bool firstColorFound = false; for (int y = 0; y < myHeight; y++) { for (int x = 0; x < myWidth; x++) { int idx = x + y * myWidth; var col = *(colors + idx); if (col.A > 128) { col.A = 255; (*(colors + x + y * myWidth)) = col; if (!firstColorFound && usesAlpha) { for (int i = 0; i < idx; i++) { quantizer.AddColor(col, i % myWidth, Mathf.FloorToInt(i / myWidth)); } } firstColorFound = true; lastColor = col; quantizer.AddColor(col, x, y); } else { col = new Color(255, 255, 255, 0); (*(colors + x + y * myWidth)) = col; usesAlpha = true; if (firstColorFound) { quantizer.AddColor(lastColor, x, y); } } } } var palette = quantizer.GetPalette(colorCount); for (int y = 0; y < myHeight; y++) { for (int x = 0; x < myWidth; x++) { if ((*(colors + x + y * myWidth)).A == 255) { int index = quantizer.GetPaletteIndex(*(colors + x + y * myWidth), x, y); //Debug.Log(index); *(colors + x + y * myWidth) = palette[index]; } } } quantizer.Finish(); }
public static byte GetPaletteIndex(IColorQuantizer q, int x, int y, int r, int g, int b) { return((byte)q.GetPaletteIndex(Color.FromArgb(r, g, b), x, y)); }
/// <summary> /// Changes the pixel format. /// </summary> /// <param name="image">The image.</param> /// <param name="targetFormat">The target format.</param> /// <param name="quantizer">The color quantizer.</param> /// <returns>The converted image in a target format.</returns> public static Image ChangePixelFormat(this Image image, PixelFormat targetFormat, IColorQuantizer quantizer) { // checks for image validity if (image == null) { const String message = "Cannot change a pixel format for a null image."; throw new ArgumentNullException(message); } // checks whether a target format is supported if (!targetFormat.IsSupported()) { String message = string.Format("A pixel format '{0}' is not supported.", targetFormat); throw new NotSupportedException(message); } // checks whether there is a quantizer for a indexed format if (targetFormat.IsIndexed() && quantizer == null) { String message = string.Format("A quantizer is cannot be null for indexed pixel format '{0}'.", targetFormat); throw new NotSupportedException(message); } // creates an image with the target format Bitmap result = new Bitmap(image.Width, image.Height, targetFormat); ColorPalette imagePalette = image.Palette; // gathers some information about the target format Boolean hasSourceAlpha = image.PixelFormat.HasAlpha(); Boolean hasTargetAlpha = targetFormat.HasAlpha(); Boolean isSourceIndexed = image.PixelFormat.IsIndexed(); Boolean isTargetIndexed = targetFormat.IsIndexed(); Boolean isSourceDeepColor = image.PixelFormat.IsDeepColor(); Boolean isTargetDeepColor = targetFormat.IsDeepColor(); // if palette is needed create one first if (isTargetIndexed) { quantizer.Prepare(image); image.AddColorsToQuantizer(quantizer); Int32 targetColorCount = result.GetPaletteColorCount(); List<Color> palette = quantizer.GetPalette(targetColorCount); result.SetPalette(palette); } Action<Pixel, Pixel> changeFormat = (sourcePixel, targetPixel) => { // if both source and target formats are deep color formats, copies a value directly if (isSourceDeepColor && isTargetDeepColor) { UInt64 value = sourcePixel.Value; targetPixel.SetValue(value); } else { // retrieves a source image color Color color = isSourceIndexed ? imagePalette.Entries[sourcePixel.Index] : sourcePixel.Color; // if alpha is not present in the source image, but is present in the target, make one up if (!hasSourceAlpha && hasTargetAlpha) { Int32 argb = 255 << 24 | color.R << 16 | color.G << 8 | color.B; color = Color.FromArgb(argb); } // sets the color to a target pixel if (isTargetIndexed) { // for the indexed images, determines a color from the octree Byte paletteIndex = (Byte) quantizer.GetPaletteIndex(color); targetPixel.SetIndex(paletteIndex); } else { // for the non-indexed images, sets the color directly targetPixel.SetColor(color); } } }; // process image -> changes format image.ProcessImagePixels(result, changeFormat); // returns the image in the target format return result; }