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