//public static int ConvertColor(double opacity, ColorInt color) //{ // if (opacity < 0.0 || opacity > 1.0) // { // throw new ArgumentOutOfRangeException("opacity", "Opacity must be between 0.0 and 1.0"); // } // color.A = (byte)(color.A * opacity); // return ConvertColor(color); //} /// <summary> /// Fills the whole WriteableBitmap with a color. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="color">The color used for filling.</param> public static void Clear(this BitmapBuffer bmp, ColorInt color) { int colr = color.ToPreMultAlphaColor(); using (var context = bmp.GetBitmapContext()) { int[] pixels = context.Pixels; int w = context.Width; int h = context.Height; int len = w * ARGB_SIZE; // Fill first line for (int x = 0; x < w; x++) { pixels[x] = colr; } // Copy first line int blockHeight = 1; int y = 1; while (y < h) { BitmapContext.BlockCopy(context, 0, context, y * len, blockHeight * len); y += blockHeight; blockHeight = Math.Min(2 * blockHeight, h - y); } } }
/// <summary> /// Sets the color of the pixel. /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate (row).</param> /// <param name="y">The y coordinate (column).</param> /// <param name="color">The color.</param> public static void SetPixel(this BitmapBuffer bmp, int x, int y, ColorInt color) { using (var context = bmp.GetBitmapContext()) { context.Pixels[y * context.Width + x] = color.ToPreMultAlphaColor(); } }
/// <summary> /// Sets the color of the pixel using an extra alpha value and a precalculated index (faster). /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="index">The coordinate index.</param> /// <param name="a">The alpha value of the color.</param> /// <param name="color">The color.</param> public static void SetPixeli(this BitmapBuffer bmp, int index, byte a, ColorInt color) { using (var context = bmp.GetBitmapContext()) { context.Pixels[index] = color.ToPreMultAlphaColor(); } }
/// <summary> /// Sets the color of the pixel including the alpha value. /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate (row).</param> /// <param name="y">The y coordinate (column).</param> /// <param name="a">The alpha value of the color.</param> /// <param name="r">The red value of the color.</param> /// <param name="g">The green value of the color.</param> /// <param name="b">The blue value of the color.</param> public static void SetPixel(this BitmapBuffer bmp, int x, int y, byte a, byte r, byte g, byte b) { using (var context = bmp.GetBitmapContext()) { context.Pixels[y * context.Width + x] = (a << 24) | (r << 16) | (g << 8) | b; } }
/// <summary> /// Sets the color of the pixel using a precalculated index (faster). /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="index">The coordinate index.</param> /// <param name="color">The color.</param> public static void SetPixeli(this BitmapBuffer bmp, int index, int color) { using (var context = bmp.GetBitmapContext()) { context.Pixels[index] = color; } }
/// <summary> /// Creates a new inverted WriteableBitmap and returns it. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <returns>The new inverted WriteableBitmap.</returns> public static BitmapBuffer Invert(this BitmapBuffer bmp) { using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { var result = BitmapBufferFactory.New(srcContext.Width, srcContext.Height); using (var resultContext = result.GetBitmapContext()) { int[] rp = resultContext.Pixels; int[] p = srcContext.Pixels; int length = srcContext.Length; for (int i = 0; i < length; i++) { // Extract int c = p[i]; int a = (c >> 24) & 0xff; int r = (c >> 16) & 0xff; int g = (c >> 8) & 0xff; int b = (c) & 0xff; // Invert r = 255 - r; g = 255 - g; b = 255 - b; // Set rp[i] = (a << 24) | (r << 16) | (g << 8) | b; } return(result); } } }
/// <summary> /// Sets the color of the pixel including the alpha value and using a precalculated index (faster). /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="index">The coordinate index.</param> /// <param name="a">The alpha value of the color.</param> /// <param name="r">The red value of the color.</param> /// <param name="g">The green value of the color.</param> /// <param name="b">The blue value of the color.</param> public static void SetPixeli(this BitmapBuffer bmp, int index, byte a, byte r, byte g, byte b) { using (var context = bmp.GetBitmapContext()) { context.Pixels[index] = (a << 24) | (r << 16) | (g << 8) | b; } }
///// <summary> ///// Applies the given function to all the pixels of the bitmap in ///// order to set their color. ///// </summary> ///// <param name="bmp">The WriteableBitmap.</param> ///// <param name="func">The function to apply. With parameters x, y and a color as a result</param> //public static void dbugForEach(this BitmapBuffer bmp, Func<int, int, ColorInt> func) //{ // using (var context = bmp.GetBitmapContext()) // { // int[] pixels = context.Pixels; // int w = context.Width; // int h = context.Height; // int index = 0; // for (int y = 0; y < h; y++) // { // for (int x = 0; x < w; x++) // { // pixels[index++] = func(x, y).ToPreMultAlphaColor(); // } // } // } //} ///// <summary> ///// Applies the given function to all the pixels of the bitmap in ///// order to set their color. ///// </summary> ///// <param name="bmp">The WriteableBitmap.</param> ///// <param name="func">The function to apply. With parameters x, y, source color and a color as a result</param> //public static void dbugForEach(this BitmapBuffer bmp, Func<int, int, ColorInt, ColorInt> func) //{ // using (var context = bmp.GetBitmapContext()) // { // int[] pixels = context.Pixels; // int w = context.Width; // int h = context.Height; // int index = 0; // for (int y = 0; y < h; y++) // { // for (int x = 0; x < w; x++) // { // int c = pixels[index]; // // Premultiplied Alpha! // byte a = (byte)(c >> 24); // // Prevent division by zero // int ai = a; // if (ai == 0) // { // ai = 1; // } // // Scale inverse alpha to use cheap integer mul bit shift // ai = ((255 << 8) / ai); // ColorInt srcColor = ColorInt.FromArgb(a, // (byte)((((c >> 16) & 0xFF) * ai) >> 8), // (byte)((((c >> 8) & 0xFF) * ai) >> 8), // (byte)((((c & 0xFF) * ai) >> 8))); // pixels[index++] = func(x, y, srcColor).ToPreMultAlphaColor(); // } // } // } //} /// <summary> /// Gets the color of the pixel at the x, y coordinate as integer. /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate of the pixel.</param> /// <param name="y">The y coordinate of the pixel.</param> /// <returns>The color of the pixel at x, y.</returns> public static int dbugGetPixeli(this BitmapBuffer bmp, int x, int y) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { return(context.Pixels[y * context.Width + x]); } }
/// <summary> /// Fills the whole WriteableBitmap with an empty color (0). /// </summary> /// <param name="bmp">The WriteableBitmap.</param> public static void Clear(this BitmapBuffer bmp) { using (var context = bmp.GetBitmapContext()) { context.Clear(); } }
/// <summary> /// Sets the color of the pixel. /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate (row).</param> /// <param name="y">The y coordinate (column).</param> /// <param name="color">The color.</param> public static void SetPixel(this BitmapBuffer bmp, int x, int y, int color) { using (var context = bmp.GetBitmapContext()) { context.Pixels[y * context.Width + x] = color; } }
/// <summary> /// Draws a closed Cardinal spline (cubic) defined by a point collection. /// The cardinal spline passes through each point in the collection. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn).</param> /// <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param> /// <param name="color">The color for the spline.</param> public static void DrawCurveClosed(this BitmapBuffer bmp, int[] points, float tension, int color) { using (var context = bmp.GetBitmapContext()) { // Use refs for faster access (really important!) speeds up a lot! int w = context.Width; int h = context.Height; int pn = points.Length; // First segment DrawCurveSegment(points[pn - 2], points[pn - 1], points[0], points[1], points[2], points[3], points[4], points[5], tension, color, context, w, h); // Middle segments int i; for (i = 2; i < pn - 4; i += 2) { DrawCurveSegment(points[i - 2], points[i - 1], points[i], points[i + 1], points[i + 2], points[i + 3], points[i + 4], points[i + 5], tension, color, context, w, h); } // Last segment DrawCurveSegment(points[i - 2], points[i - 1], points[i], points[i + 1], points[i + 2], points[i + 3], points[0], points[1], tension, color, context, w, h); // Last-to-First segment DrawCurveSegment(points[i], points[i + 1], points[i + 2], points[i + 3], points[0], points[1], points[2], points[3], tension, color, context, w, h); } }
/// <summary> /// Creates a new WriteableBitmap which is the grayscaled version of this one and returns it. The gray values are equal to the brightness values. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <returns>The new gray WriteableBitmap.</returns> public static BitmapBuffer Gray(this BitmapBuffer bmp) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int nWidth = context.Width; int nHeight = context.Height; int[] px = context.Pixels; BitmapBuffer result = BitmapBufferFactory.New(nWidth, nHeight); using (var dest = result.GetBitmapContext()) { int[] rp = dest.Pixels; int len = context.Length; for (int i = 0; i < len; i++) { // Extract int c = px[i]; int a = (c >> 24) & 0xff; int r = (c >> 16) & 0xff; int g = (c >> 8) & 0xff; int b = (c) & 0xff; // Convert to gray with constant factors 0.2126, 0.7152, 0.0722 r = g = b = ((r * 6966 + g * 23436 + b * 2366) >> 15); // Set rp[i] = (a << 24) | (r << 16) | (g << 8) | b; } } return(result); } }
/// <summary> /// Flips (reflects the image) either vertical or horizontal. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="flipMode">The flip mode.</param> /// <returns>A new WriteableBitmap that is a flipped version of the input.</returns> public static BitmapBuffer Flip(this BitmapBuffer bmp, FlipMode flipMode) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { // Use refs for faster access (really important!) speeds up a lot! int w = context.Width; int h = context.Height; int[] p = context.Pixels; int i = 0; BitmapBuffer result = BitmapBufferFactory.New(w, h); if (flipMode == FlipMode.Horizontal) { using (BitmapContext destContext = result.GetBitmapContext()) { int[] rp = destContext.Pixels; for (int y = h - 1; y >= 0; y--) { for (int x = 0; x < w; x++) { int srcInd = y * w + x; rp[i] = p[srcInd]; i++; } } } } else if (flipMode == FlipMode.Vertical) { using (BitmapContext destContext = result.GetBitmapContext()) { int[] rp = destContext.Pixels; for (int y = 0; y < h; y++) { for (int x = w - 1; x >= 0; x--) { int srcInd = y * w + x; rp[i] = p[srcInd]; i++; } } } } return(result); } }
/// <summary> /// Sets the color of the pixel using an extra alpha value. /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate (row).</param> /// <param name="y">The y coordinate (column).</param> /// <param name="a">The alpha value of the color.</param> /// <param name="color">The color.</param> public static void SetPixel(this BitmapBuffer bmp, int x, int y, byte a, ColorInt color) { using (var context = bmp.GetBitmapContext()) { // Add one to use mul and cheap bit shift for multiplicaltion context.Pixels[y * context.Width + x] = color.ToPreMultAlphaColor(); } }
/// <summary> /// Copies color information from an ARGB byte array into this WriteableBitmap starting at a specific buffer index. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="offset">The starting index in the buffer.</param> /// <param name="count">The number of bytes to copy from the buffer.</param> /// <param name="buffer">The color buffer as byte ARGB values.</param> /// <returns>The WriteableBitmap that was passed as parameter.</returns> public static BitmapBuffer FromByteArray(this BitmapBuffer bmp, byte[] buffer, int offset, int count) { using (var context = bmp.GetBitmapContext()) { BitmapContext.BlockCopy(buffer, offset, context, 0, count); return(bmp); } }
/// <summary> /// Draws a cubic Beziér spline defined by start, end and two control points. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x1">The x-coordinate of the start point.</param> /// <param name="y1">The y-coordinate of the start point.</param> /// <param name="cx1">The x-coordinate of the 1st control point.</param> /// <param name="cy1">The y-coordinate of the 1st control point.</param> /// <param name="cx2">The x-coordinate of the 2nd control point.</param> /// <param name="cy2">The y-coordinate of the 2nd control point.</param> /// <param name="x2">The x-coordinate of the end point.</param> /// <param name="y2">The y-coordinate of the end point.</param> /// <param name="color">The color.</param> public static void DrawBezier(this BitmapBuffer bmp, int x1, int y1, int cx1, int cy1, int cx2, int cy2, int x2, int y2, int color) { // Determine distances between controls points (bounding rect) to find the optimal stepsize int minX = Math.Min(x1, Math.Min(cx1, Math.Min(cx2, x2))); int minY = Math.Min(y1, Math.Min(cy1, Math.Min(cy2, y2))); int maxX = Math.Max(x1, Math.Max(cx1, Math.Max(cx2, x2))); int maxY = Math.Max(y1, Math.Max(cy1, Math.Max(cy2, y2))); // Get slope int lenx = maxX - minX; int len = maxY - minY; if (lenx > len) { len = lenx; } // Prevent division by zero if (len != 0) { using (var context = bmp.GetBitmapContext()) { // Use refs for faster access (really important!) speeds up a lot! int w = context.Width; int h = context.Height; // Init vars float step = STEP_FACTOR / len; int tx1 = x1; int ty1 = y1; int tx2, ty2; // Interpolate for (float t = step; t <= 1; t += step) { float tSq = t * t; float t1 = 1 - t; float t1Sq = t1 * t1; tx2 = (int)(t1 * t1Sq * x1 + 3 * t * t1Sq * cx1 + 3 * t1 * tSq * cx2 + t * tSq * x2); ty2 = (int)(t1 * t1Sq * y1 + 3 * t * t1Sq * cy1 + 3 * t1 * tSq * cy2 + t * tSq * y2); // Draw line DrawLine(context, w, h, tx1, ty1, tx2, ty2, color); tx1 = tx2; ty1 = ty2; } // Prevent rounding gap DrawLine(context, w, h, tx1, ty1, x2, y2, color); } } }
/// <summary> /// Clones the specified WriteableBitmap. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <returns>A copy of the WriteableBitmap.</returns> public static BitmapBuffer Clone(this BitmapBuffer bmp) { using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { BitmapBuffer result = BitmapBufferFactory.New(srcContext.Width, srcContext.Height); using (var destContext = result.GetBitmapContext()) { BitmapContext.BlockCopy(srcContext, 0, destContext, 0, srcContext.Length * ARGB_SIZE); } return(result); } }
/// <summary> /// Creates a new resized WriteableBitmap. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="width">The new desired width.</param> /// <param name="height">The new desired height.</param> /// <param name="interpolation">The interpolation method that should be used.</param> /// <returns>A new WriteableBitmap that is a resized version of the input.</returns> public static BitmapBuffer Resize(this BitmapBuffer bmp, int width, int height, Interpolation interpolation) { using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int[] pd = Resize(srcContext, srcContext.Width, srcContext.Height, width, height, interpolation); BitmapBuffer result = BitmapBufferFactory.New(width, height); using (var dstContext = result.GetBitmapContext()) { BitmapContext.BlockCopy(pd, 0, dstContext, 0, ARGB_SIZE * pd.Length); } return(result); } }
/// <summary> /// Gets the brightness / luminance of the pixel at the x, y coordinate as byte. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate of the pixel.</param> /// <param name="y">The y coordinate of the pixel.</param> /// <returns>The brightness of the pixel at x, y.</returns> public static byte GetBrightness(this BitmapBuffer bmp, int x, int y) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { // Extract color components int c = context.Pixels[y * context.Width + x]; byte r = (byte)(c >> 16); byte g = (byte)(c >> 8); byte b = (byte)(c); // Convert to gray with constant factors 0.2126, 0.7152, 0.0722 return((byte)((r * 6966 + g * 23436 + b * 2366) >> 15)); } }
/// <summary> /// Copies the Pixels from the WriteableBitmap into a ARGB byte array starting at a specific Pixels index. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="offset">The starting Pixels index.</param> /// <param name="count">The number of Pixels to copy, -1 for all</param> /// <returns>The color buffer as byte ARGB values.</returns> public static byte[] ToByteArray(this BitmapBuffer bmp, int offset, int count) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { if (count == -1) { // Copy all to byte array count = context.Length; } int len = count * ARGB_SIZE; byte[] result = new byte[len]; // ARGB BitmapContext.BlockCopy(context, offset, result, 0, len); return(result); } }
/// <summary> /// Creates a new cropped WriteableBitmap. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate of the rectangle that defines the crop region.</param> /// <param name="y">The y coordinate of the rectangle that defines the crop region.</param> /// <param name="width">The width of the rectangle that defines the crop region.</param> /// <param name="height">The height of the rectangle that defines the crop region.</param> /// <returns>A new WriteableBitmap that is a cropped version of the input.</returns> public static BitmapBuffer Crop(this BitmapBuffer bmp, int x, int y, int width, int height) { using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int srcWidth = srcContext.Width; int srcHeight = srcContext.Height; // If the rectangle is completely out of the bitmap if (x > srcWidth || y > srcHeight) { return(BitmapBufferFactory.New(0, 0)); } // Clamp to boundaries if (x < 0) { x = 0; } if (x + width > srcWidth) { width = srcWidth - x; } if (y < 0) { y = 0; } if (y + height > srcHeight) { height = srcHeight - y; } // Copy the pixels line by line using fast BlockCopy BitmapBuffer result = BitmapBufferFactory.New(width, height); using (var destContext = result.GetBitmapContext()) { for (int line = 0; line < height; line++) { int srcOff = ((y + line) * srcWidth + x) * ARGB_SIZE; int dstOff = line * width * ARGB_SIZE; BitmapContext.BlockCopy(srcContext, srcOff, destContext, dstOff, width * ARGB_SIZE); } return(result); } } }
/// <summary> /// Creates a new WriteableBitmap which is contrast adjusted version of this one and returns it. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="level">Level of contrast as double. [-255.0, 255.0] </param> /// <returns>The new WriteableBitmap.</returns> public static BitmapBuffer AdjustContrast(this BitmapBuffer bmp, double level) { int factor = (int)((259.0 * (level + 255.0)) / (255.0 * (259.0 - level)) * 255.0); using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int nWidth = context.Width; int nHeight = context.Height; int[] px = context.Pixels; BitmapBuffer result = BitmapBufferFactory.New(nWidth, nHeight); using (var dest = result.GetBitmapContext()) { int[] rp = dest.Pixels; int len = context.Length; for (int i = 0; i < len; i++) { // Extract int c = px[i]; int a = (c >> 24) & 0xff; int r = (c >> 16) & 0xff; int g = (c >> 8) & 0xff; int b = (c) & 0xff; // Adjust contrast based on computed factor //TODO: create lookup table for this r = ((factor * (r - 128)) >> 8) + 128; g = ((factor * (g - 128)) >> 8) + 128; b = ((factor * (b - 128)) >> 8) + 128; // Clamp r = r < 0 ? 0 : r > 255 ? 255 : r; g = g < 0 ? 0 : g > 255 ? 255 : g; b = b < 0 ? 0 : b > 255 ? 255 : b; // Set rp[i] = (a << 24) | (r << 16) | (g << 8) | b; } } return(result); } }
/// <summary> /// Creates a new WriteableBitmap which is gamma adjusted version of this one and returns it. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="value">Value of gamma for adjustment. Original is 1.0.</param> /// <returns>The new WriteableBitmap.</returns> public static BitmapBuffer AdjustGamma(this BitmapBuffer bmp, double value) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int nWidth = context.Width; int nHeight = context.Height; int[] srcPixels = context.Pixels; BitmapBuffer result = BitmapBufferFactory.New(nWidth, nHeight); using (var dest = result.GetBitmapContext()) { int[] rp = dest.Pixels; var gammaCorrection = 1.0 / value; int len = context.Length; for (int i = 0; i < len; i++) { // Extract int c = srcPixels[i]; int a = (c >> 24) & 0xff; int r = (c >> 16) & 0xff; int g = (c >> 8) & 0xff; int b = (c) & 0xff; //Gamma adjustment //TODO: create gamma-lookup table for this r = (int)(255.0 * Math.Pow((r / 255.0), gammaCorrection)); g = (int)(255.0 * Math.Pow((g / 255.0), gammaCorrection)); b = (int)(255.0 * Math.Pow((b / 255.0), gammaCorrection)); // Clamps r = r < 0 ? 0 : r > 255 ? 255 : r; g = g < 0 ? 0 : g > 255 ? 255 : g; b = b < 0 ? 0 : b > 255 ? 255 : b; // Set rp[i] = (a << 24) | (r << 16) | (g << 8) | b; } } return(result); } }
/// <summary> /// Creates a new WriteableBitmap which is brightness adjusted version of this one and returns it. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="nLevel">Level of contrast as double. [-255.0, 255.0] </param> /// <returns>The new WriteableBitmap.</returns> public static BitmapBuffer AdjustBrightness(this BitmapBuffer bmp, int nLevel) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int nWidth = context.Width; int nHeight = context.Height; int[] px = context.Pixels; BitmapBuffer result = BitmapBufferFactory.New(nWidth, nHeight); using (var dest = result.GetBitmapContext()) { int[] rp = dest.Pixels; int len = context.Length; for (int i = 0; i < len; i++) { // Extract int c = px[i]; int a = (c >> 24) & 0xff; int r = (c >> 16) & 0xff; int g = (c >> 8) & 0xff; int b = (c) & 0xff; // Brightness adjustment //TODO: create lookup table for this r += nLevel; g += nLevel; b += nLevel; // Clamp r = r < 0 ? 0 : r > 255 ? 255 : r; g = g < 0 ? 0 : g > 255 ? 255 : g; b = b < 0 ? 0 : b > 255 ? 255 : b; // Set rp[i] = (a << 24) | (r << 16) | (g << 8) | b; } } return(result); } }
/// <summary> /// Gets the color of the pixel at the x, y coordinate as a Color struct. /// For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x">The x coordinate of the pixel.</param> /// <param name="y">The y coordinate of the pixel.</param> /// <returns>The color of the pixel at x, y as a Color struct.</returns> public static ColorInt dbugGetPixel(this BitmapBuffer bmp, int x, int y) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int c = context.Pixels[y * context.Width + x]; byte a = (byte)(c >> 24); // Prevent division by zero int ai = a; if (ai == 0) { ai = 1; } // Scale inverse alpha to use cheap integer mul bit shift ai = ((255 << 8) / ai); return(ColorInt.FromArgb(a, (byte)((((c >> 16) & 0xFF) * ai) >> 8), (byte)((((c >> 8) & 0xFF) * ai) >> 8), (byte)((((c & 0xFF) * ai) >> 8)))); } }
/// <summary> /// Writes the WriteableBitmap as a TGA image to a stream. /// Used with permission from Nokola: http://nokola.com/blog/post/2010/01/21/Quick-and-Dirty-Output-of-WriteableBitmap-as-TGA-Image.aspx /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="destination">The destination stream.</param> public static void WriteTga(this BitmapBuffer bmp, Stream destination) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int width = context.Width; int height = context.Height; int[] pixels = context.Pixels; byte[] data = new byte[context.Length * ARGB_SIZE]; // Copy bitmap data as BGRA int offsetSource = 0; int width4 = width << 2; int width8 = width << 3; int offsetDest = (height - 1) * width4; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { // Account for pre-multiplied alpha int c = pixels[offsetSource]; byte a = (byte)(c >> 24); // Prevent division by zero int ai = a; if (ai == 0) { ai = 1; } // Scale inverse alpha to use cheap integer mul bit shift ai = ((255 << 8) / ai); data[offsetDest + 3] = (byte)a; // A data[offsetDest + 2] = (byte)((((c >> 16) & 0xFF) * ai) >> 8); // R data[offsetDest + 1] = (byte)((((c >> 8) & 0xFF) * ai) >> 8); // G data[offsetDest] = (byte)((((c & 0xFF) * ai) >> 8)); // B offsetSource++; offsetDest += ARGB_SIZE; } offsetDest -= width8; } // Create header var header = new byte[] { 0, // ID length 0, // no color map 2, // uncompressed, true color 0, 0, 0, 0, 0, 0, 0, 0, 0, // x and y origin (byte)(width & 0x00FF), (byte)((width & 0xFF00) >> 8), (byte)(height & 0x00FF), (byte)((height & 0xFF00) >> 8), 32, // 32 bit bitmap 0 }; // Write header and data using (var writer = new BinaryWriter(destination)) { writer.Write(header); writer.Write(data); } } }
/// <summary> /// Rotates the bitmap in any degree returns a new rotated WriteableBitmap. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="angle">Arbitrary angle in 360 Degrees (positive = clockwise).</param> /// <param name="crop">if true: keep the size, false: adjust canvas to new size</param> /// <returns>A new WriteableBitmap that is a rotated version of the input.</returns> public static BitmapBuffer RotateFree(this BitmapBuffer bmp, double angle, bool crop = true) { // rotating clockwise, so it's negative relative to Cartesian quadrants double cnAngle = -1.0 * (Math.PI / 180) * angle; // general iterators int i, j; // calculated indices in Cartesian coordinates int x, y; double fDistance, fPolarAngle; // for use in neighboring indices in Cartesian coordinates int iFloorX, iCeilingX, iFloorY, iCeilingY; // calculated indices in Cartesian coordinates with trailing decimals double fTrueX, fTrueY; // for interpolation double fDeltaX, fDeltaY; // interpolated "top" pixels double fTopRed, fTopGreen, fTopBlue, fTopAlpha; // interpolated "bottom" pixels double fBottomRed, fBottomGreen, fBottomBlue, fBottomAlpha; // final interpolated color components int iRed, iGreen, iBlue, iAlpha; int iCentreX, iCentreY; int iDestCentreX, iDestCentreY; int iWidth, iHeight, newWidth, newHeight; using (var bmpContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { iWidth = bmpContext.Width; iHeight = bmpContext.Height; if (crop) { newWidth = iWidth; newHeight = iHeight; } else { double rad = angle / (180 / Math.PI); newWidth = (int)Math.Ceiling(Math.Abs(Math.Sin(rad) * iHeight) + Math.Abs(Math.Cos(rad) * iWidth)); newHeight = (int)Math.Ceiling(Math.Abs(Math.Sin(rad) * iWidth) + Math.Abs(Math.Cos(rad) * iHeight)); } iCentreX = iWidth / 2; iCentreY = iHeight / 2; iDestCentreX = newWidth / 2; iDestCentreY = newHeight / 2; BitmapBuffer bmBilinearInterpolation = BitmapBufferFactory.New(newWidth, newHeight); using (var bilinearContext = bmBilinearInterpolation.GetBitmapContext()) { int[] newp = bilinearContext.Pixels; int[] oldp = bmpContext.Pixels; int oldw = bmpContext.Width; // assigning pixels of destination image from source image // with bilinear interpolation for (i = 0; i < newHeight; ++i) { for (j = 0; j < newWidth; ++j) { // convert raster to Cartesian x = j - iDestCentreX; y = iDestCentreY - i; // convert Cartesian to polar fDistance = Math.Sqrt(x * x + y * y); if (x == 0) { if (y == 0) { // center of image, no rotation needed newp[i * newWidth + j] = oldp[iCentreY * oldw + iCentreX]; continue; } if (y < 0) { fPolarAngle = 1.5 * Math.PI; } else { fPolarAngle = 0.5 * Math.PI; } } else { fPolarAngle = Math.Atan2(y, x); } // the crucial rotation part // "reverse" rotate, so minus instead of plus fPolarAngle -= cnAngle; // convert polar to Cartesian fTrueX = fDistance * Math.Cos(fPolarAngle); fTrueY = fDistance * Math.Sin(fPolarAngle); // convert Cartesian to raster fTrueX = fTrueX + iCentreX; fTrueY = iCentreY - fTrueY; iFloorX = (int)(Math.Floor(fTrueX)); iFloorY = (int)(Math.Floor(fTrueY)); iCeilingX = (int)(Math.Ceiling(fTrueX)); iCeilingY = (int)(Math.Ceiling(fTrueY)); // check bounds if (iFloorX < 0 || iCeilingX < 0 || iFloorX >= iWidth || iCeilingX >= iWidth || iFloorY < 0 || iCeilingY < 0 || iFloorY >= iHeight || iCeilingY >= iHeight) { continue; } fDeltaX = fTrueX - iFloorX; fDeltaY = fTrueY - iFloorY; int clrTopLeft = oldp[iFloorY * oldw + iFloorX]; int clrTopRight = oldp[iFloorY * oldw + iCeilingX]; int clrBottomLeft = oldp[iCeilingY * oldw + iFloorX]; int clrBottomRight = oldp[iCeilingY * oldw + iCeilingX]; fTopAlpha = (1 - fDeltaX) * ((clrTopLeft >> 24) & 0xFF) + fDeltaX * ((clrTopRight >> 24) & 0xFF); fTopRed = (1 - fDeltaX) * ((clrTopLeft >> 16) & 0xFF) + fDeltaX * ((clrTopRight >> 16) & 0xFF); fTopGreen = (1 - fDeltaX) * ((clrTopLeft >> 8) & 0xFF) + fDeltaX * ((clrTopRight >> 8) & 0xFF); fTopBlue = (1 - fDeltaX) * (clrTopLeft & 0xFF) + fDeltaX * (clrTopRight & 0xFF); // linearly interpolate horizontally between bottom neighbors fBottomAlpha = (1 - fDeltaX) * ((clrBottomLeft >> 24) & 0xFF) + fDeltaX * ((clrBottomRight >> 24) & 0xFF); fBottomRed = (1 - fDeltaX) * ((clrBottomLeft >> 16) & 0xFF) + fDeltaX * ((clrBottomRight >> 16) & 0xFF); fBottomGreen = (1 - fDeltaX) * ((clrBottomLeft >> 8) & 0xFF) + fDeltaX * ((clrBottomRight >> 8) & 0xFF); fBottomBlue = (1 - fDeltaX) * (clrBottomLeft & 0xFF) + fDeltaX * (clrBottomRight & 0xFF); // linearly interpolate vertically between top and bottom interpolated results iRed = (int)(Math.Round((1 - fDeltaY) * fTopRed + fDeltaY * fBottomRed)); iGreen = (int)(Math.Round((1 - fDeltaY) * fTopGreen + fDeltaY * fBottomGreen)); iBlue = (int)(Math.Round((1 - fDeltaY) * fTopBlue + fDeltaY * fBottomBlue)); iAlpha = (int)(Math.Round((1 - fDeltaY) * fTopAlpha + fDeltaY * fBottomAlpha)); // make sure color values are valid if (iRed < 0) { iRed = 0; } if (iRed > 255) { iRed = 255; } if (iGreen < 0) { iGreen = 0; } if (iGreen > 255) { iGreen = 255; } if (iBlue < 0) { iBlue = 0; } if (iBlue > 255) { iBlue = 255; } if (iAlpha < 0) { iAlpha = 0; } if (iAlpha > 255) { iAlpha = 255; } int a = iAlpha + 1; newp[i * newWidth + j] = (iAlpha << 24) | ((byte)((iRed * a) >> 8) << 16) | ((byte)((iGreen * a) >> 8) << 8) | ((byte)((iBlue * a) >> 8)); } } return(bmBilinearInterpolation); } } }
/// <summary> /// Rotates the bitmap in 90° steps clockwise and returns a new rotated WriteableBitmap. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="angle">The angle in degrees the bitmap should be rotated in 90° steps clockwise.</param> /// <returns>A new WriteableBitmap that is a rotated version of the input.</returns> public static BitmapBuffer Rotate(this BitmapBuffer bmp, int angle) { using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { // Use refs for faster access (really important!) speeds up a lot! int w = context.Width; int h = context.Height; int[] p = context.Pixels; int i = 0; BitmapBuffer result; angle %= 360; if (angle > 0 && angle <= 90) { result = BitmapBufferFactory.New(h, w); using (var destContext = result.GetBitmapContext()) { var rp = destContext.Pixels; for (int x = 0; x < w; x++) { for (int y = h - 1; y >= 0; y--) { int srcInd = y * w + x; rp[i] = p[srcInd]; i++; } } } } else if (angle > 90 && angle <= 180) { result = BitmapBufferFactory.New(w, h); using (var destContext = result.GetBitmapContext()) { var rp = destContext.Pixels; for (int y = h - 1; y >= 0; y--) { for (int x = w - 1; x >= 0; x--) { int srcInd = y * w + x; rp[i] = p[srcInd]; i++; } } } } else if (angle > 180 && angle <= 270) { result = BitmapBufferFactory.New(h, w); using (var destContext = result.GetBitmapContext()) { int[] rp = destContext.Pixels; for (int x = w - 1; x >= 0; x--) { for (int y = 0; y < h; y++) { int srcInd = y * w + x; rp[i] = p[srcInd]; i++; } } } } else { result = bmp.Clone(); } return(result); } }
/// <summary> /// Creates a new filtered WriteableBitmap. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="kernel">The kernel used for convolution.</param> /// <param name="kernelFactorSum">The factor used for the kernel summing.</param> /// <param name="kernelOffsetSum">The offset used for the kernel summing.</param> /// <returns>A new WriteableBitmap that is a filtered version of the input.</returns> public static BitmapBuffer Convolute(this BitmapBuffer bmp, int[,] kernel, int kernelFactorSum, int kernelOffsetSum) { int kh = kernel.GetUpperBound(0) + 1; int kw = kernel.GetUpperBound(1) + 1; if ((kw & 1) == 0) { throw new System.InvalidOperationException("Kernel width must be odd!"); } if ((kh & 1) == 0) { throw new System.InvalidOperationException("Kernel height must be odd!"); } using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly)) { int w = srcContext.Width; int h = srcContext.Height; BitmapBuffer result = BitmapBufferFactory.New(w, h); using (var resultContext = result.GetBitmapContext()) { int[] pixels = srcContext.Pixels; int[] resultPixels = resultContext.Pixels; int index = 0; int kwh = kw >> 1; int khh = kh >> 1; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++) { int a = 0; int r = 0; int g = 0; int b = 0; for (int kx = -kwh; kx <= kwh; kx++) { int px = kx + x; // Repeat pixels at borders if (px < 0) { px = 0; } else if (px >= w) { px = w - 1; } for (int ky = -khh; ky <= khh; ky++) { int py = ky + y; // Repeat pixels at borders if (py < 0) { py = 0; } else if (py >= h) { py = h - 1; } int col = pixels[py * w + px]; int k = kernel[ky + kwh, kx + khh]; a += ((col >> 24) & 0x000000FF) * k; r += ((col >> 16) & 0x000000FF) * k; g += ((col >> 8) & 0x000000FF) * k; b += ((col) & 0x000000FF) * k; } } int ta = ((a / kernelFactorSum) + kernelOffsetSum); int tr = ((r / kernelFactorSum) + kernelOffsetSum); int tg = ((g / kernelFactorSum) + kernelOffsetSum); int tb = ((b / kernelFactorSum) + kernelOffsetSum); // Clamp to byte boundaries byte ba = (byte)((ta > 255) ? 255 : ((ta < 0) ? 0 : ta)); byte br = (byte)((tr > 255) ? 255 : ((tr < 0) ? 0 : tr)); byte bg = (byte)((tg > 255) ? 255 : ((tg < 0) ? 0 : tg)); byte bb = (byte)((tb > 255) ? 255 : ((tb < 0) ? 0 : tb)); resultPixels[index++] = (ba << 24) | (br << 16) | (bg << 8) | (bb); } } return(result); } } }