public static Bitmap Binarize(Bitmap bm, double threshhold)
{
//Binarize
int size = bm.Width * bm.Height;
int[] pixels = new int[size];
bm.GetPixels( pixels, 0, bm.Width, 0, 0, bm.Width, bm.Height );
// Calculate overall lightness of image
int c;
for (int i = 0; i < size; i++)
{
c = pixels[i];
double whiteDist = Math.Sqrt(Math.Pow(0xff - ((c&0x00FF0000 )>>16),2) + Math.Pow(0xff - ((c & 0x0000FF00 )>>8), 2) + Math.Pow(0xff - (c&0x000000FF), 2));
double blackDist = Math.Sqrt(Math.Pow(0x00 - ((c&0x00FF0000 )>>16),2) + Math.Pow(0x00 - ((c & 0x0000FF00 )>>8), 2) + Math.Pow(0x00 - (c&0x000000FF), 2));
double distance = blackDist + whiteDist;
if (whiteDist / distance > threshhold / 30.0) {
pixels [i] = Color.Black;
} else {
pixels [i] = Color.White;
}
}
Bitmap newBitmap = bm.Copy (bm.GetConfig (), true);
newBitmap.SetPixels (pixels, 0, bm.Width, 0, 0, bm.Width, bm.Height);
return newBitmap;
}
public static bool Reshape(ANDROIDBITMAP bmp, ANDROIDBITMAP.Config fmt, int w, int h)
{
if (bmp == null)
{
throw new ArgumentNullException(nameof(bmp));
}
if (fmt == null)
{
throw new Diagnostics.PixelFormatNotSupportedException(fmt, nameof(fmt));
}
if (w <= 0)
{
throw new ArgumentOutOfRangeException(nameof(w));
}
if (h <= 0)
{
throw new ArgumentOutOfRangeException(nameof(h));
}
if (bmp.Width == w && bmp.Height == h && bmp.GetConfig() == fmt)
{
return(false);
}
if (!bmp.IsMutable)
{
throw new ArgumentException(nameof(bmp));
}
bmp.Reconfigure(w, h, fmt);
return(true);
}
/// <summary>
/// Convert a Bitmap to and from this Mat
/// </summary>
/// <param name="mat">The mat to copy Bitmap into</param>
/// <param name="bitmap">The bitmap to copy into mat</param>
public static void SetBitmap(this Mat mat, Android.Graphics.Bitmap bitmap)
{
Android.Graphics.Bitmap.Config config = bitmap.GetConfig();
if (config.Equals(Android.Graphics.Bitmap.Config.Argb8888))
{
using (BitmapArgb8888Image bi = new BitmapArgb8888Image(bitmap))
{
CvInvoke.CvtColor(bi, mat, ColorConversion.Rgba2Bgra);
}
}
else if (config.Equals(Android.Graphics.Bitmap.Config.Rgb565))
{
Size size = new Size(bitmap.Width, bitmap.Height);
int[] values = new int[size.Width * size.Height];
bitmap.GetPixels(values, 0, size.Width, 0, 0, size.Width, size.Height);
GCHandle handle = GCHandle.Alloc(values, GCHandleType.Pinned);
using (Mat bgra = new Mat(size, DepthType.Cv8U, 4, handle.AddrOfPinnedObject(), size.Width * 4))
{
bgra.CopyTo(mat);
}
handle.Free();
}
else
{
throw new NotImplementedException(String.Format("Coping from Bitmap of {0} is not implemented", config));
}
}
public static Bitmap ToCropped(Bitmap source, double zoomFactor, double xOffset, double yOffset, double cropWidthRatio, double cropHeightRatio)
{
double sourceWidth = source.Width;
double sourceHeight = source.Height;
double desiredWidth = sourceWidth;
double desiredHeight = sourceHeight;
double desiredRatio = cropWidthRatio / cropHeightRatio;
double currentRatio = sourceWidth / sourceHeight;
if (currentRatio > desiredRatio)
desiredWidth = (cropWidthRatio * sourceHeight / cropHeightRatio);
else if (currentRatio < desiredRatio)
desiredHeight = (cropHeightRatio * sourceWidth / cropWidthRatio);
xOffset = xOffset * desiredWidth;
yOffset = yOffset * desiredHeight;
desiredWidth = desiredWidth / zoomFactor;
desiredHeight = desiredHeight / zoomFactor;
float cropX = (float)(((sourceWidth - desiredWidth) / 2) + xOffset);
float cropY = (float)(((sourceHeight - desiredHeight) / 2) + yOffset);
if (cropX < 0)
cropX = 0;
if (cropY < 0)
cropY = 0;
if (cropX + desiredWidth > sourceWidth)
cropX = (float)(sourceWidth - desiredWidth);
if (cropY + desiredHeight > sourceHeight)
cropY = (float)(sourceHeight - desiredHeight);
Bitmap bitmap = Bitmap.CreateBitmap((int)desiredWidth, (int)desiredHeight, source.GetConfig());
using (Canvas canvas = new Canvas(bitmap))
using (Paint paint = new Paint())
using (BitmapShader shader = new BitmapShader(source, Shader.TileMode.Clamp, Shader.TileMode.Clamp))
using (Matrix matrix = new Matrix())
{
if (cropX != 0 || cropY != 0)
{
matrix.SetTranslate(-cropX, -cropY);
shader.SetLocalMatrix(matrix);
}
paint.SetShader(shader);
paint.AntiAlias = false;
RectF rectF = new RectF(0, 0, (int)desiredWidth, (int)desiredHeight);
canvas.DrawRect(rectF, paint);
return bitmap;
}
}
public static Bitmap ConvertConfig(Bitmap bitmap, Bitmap.Config config)
{
if (bitmap.GetConfig().Equals(config))
return Bitmap.CreateBitmap(bitmap);
Bitmap convertedBitmap = Bitmap.CreateBitmap(bitmap.Width, bitmap.Height, config);
Canvas canvas = new Canvas(convertedBitmap);
Android.Graphics.Paint paint = new Android.Graphics.Paint();
paint.Color = Android.Graphics.Color.Black;
canvas.DrawBitmap(bitmap, 0, 0, paint);
return convertedBitmap;
}
public static Bitmap ToColorSpace(Bitmap source, ColorMatrix colorMatrix)
{
int width = source.Width;
int height = source.Height;
Bitmap bitmap = Bitmap.CreateBitmap(width, height, source.GetConfig());
using (Canvas canvas = new Canvas(bitmap))
using (Paint paint = new Paint())
{
paint.SetColorFilter(new ColorMatrixColorFilter(colorMatrix));
canvas.DrawBitmap(source, 0, 0, paint);
return bitmap;
}
}
//#region Conversion with Bitmap
/// <summary>
/// The Get property provide a more efficient way to convert Image<Gray, Byte>, Image<Bgr, Byte> and Image<Bgra, Byte> into Bitmap
/// such that the image data is <b>shared</b> with Bitmap.
/// If you change the pixel value on the Bitmap, you change the pixel values on the Image object as well!
/// For other types of image this property has the same effect as ToBitmap()
/// <b>Take extra caution not to use the Bitmap after the Image object is disposed</b>
/// The Set property convert the bitmap to this Image type.
/// </summary>
public static Image <TColor, TDepth> ToImage <TColor, TDepth>(this Bitmap bitmap)
where TColor : struct, IColor
where TDepth : new()
{
#region reallocate memory if necessary
Size size = new Size(bitmap.Width, bitmap.Height);
Image <TColor, TDepth> image = new Image <TColor, TDepth>(size);
/*
* if (image.Ptr == IntPtr.Zero)
* {
* image.AllocateData(size.Height, size.Width, image.NumberOfChannels);
* }
* else if (!Size.Equals(size))
* {
* image.DisposeObject();
* image.AllocateData(size.Height, size.Width, image.NumberOfChannels);
* }*/
#endregion
Android.Graphics.Bitmap.Config config = bitmap.GetConfig();
if (config.Equals(Android.Graphics.Bitmap.Config.Argb8888))
{
using (BitmapArgb8888Image bi = new BitmapArgb8888Image(bitmap))
{
image.ConvertFrom(bi);
}
}
else if (config.Equals(Android.Graphics.Bitmap.Config.Rgb565))
{
int[] values = new int[size.Width * size.Height];
bitmap.GetPixels(values, 0, size.Width, 0, 0, size.Width, size.Height);
GCHandle handle = GCHandle.Alloc(values, GCHandleType.Pinned);
using (Image <Bgra, Byte> bgra = new Image <Bgra, byte>(size.Width, size.Height, size.Width * 4, handle.AddrOfPinnedObject()))
{
image.ConvertFrom(bgra);
}
handle.Free();
}
else
{
throw new NotImplementedException(String.Format("Coping from Bitmap of {0} is not implemented", config));
}
return(image);
}
/// <summary>
/// Convert the Mat to Bitmap
/// </summary>
/// <param name="mat">The Mat to convert to Bitmap</param>
/// <param name="bitmap">The bitmap, must be of the same size and has bitmap config type of either Argb888 or Rgb565</param>
/// <returns>The Bitmap</returns>
public static void ToBitmap(this Mat mat, Android.Graphics.Bitmap bitmap)
{
System.Drawing.Size size = mat.Size;
if (!(size.Width == bitmap.Width && size.Height == bitmap.Height))
{
throw new Exception("Bitmap size doesn't match the Mat size");
}
Android.Graphics.Bitmap.Config config = bitmap.GetConfig();
if (config == Android.Graphics.Bitmap.Config.Argb8888)
{
int channels = mat.NumberOfChannels;
using (BitmapArgb8888Image bi = new BitmapArgb8888Image(bitmap))
{
if (channels == 1)
{
CvInvoke.CvtColor(mat, bi.Mat, ColorConversion.Gray2Rgba);
}
else if (channels == 3)
{
CvInvoke.CvtColor(mat, bi, ColorConversion.Bgr2Rgba);
}
else if (channels == 4)
{
CvInvoke.CvtColor(mat, bi, ColorConversion.Bgra2Rgba);
}
else
{
using (Image <Rgba, Byte> tmp = mat.ToImage <Rgba, Byte>())
{
tmp.Copy(bi, null);
}
}
}
}
else if (config == Android.Graphics.Bitmap.Config.Rgb565)
{
using (BitmapRgb565Image bi = new BitmapRgb565Image(bitmap))
using (Image <Bgr, Byte> tmp = mat.ToImage <Bgr, Byte>())
bi.ConvertFrom(tmp);
}
else
{
throw new NotImplementedException("Only Bitmap config of Argb888 or Rgb565 is supported.");
}
}
private static Bitmap CreateOverlayedBitmap(Bitmap bitmap, int width, int height)
{
int[] originalPixels = new int[bitmap.Width * bitmap.Height];
bitmap.GetPixels(originalPixels, 0, bitmap.Width, 0, 0, bitmap.Width, bitmap.Height);
int[] pixels = new int[width * height];
int xStart = (width - bitmap.Width) / 2;
int xEnd = (width + bitmap.Width) / 2;
for (int y = 0; y < height; y++)
{
int rowStart = y*width;
int originalRowStart = y*bitmap.Width;
for (int ox = 0, x = xStart; x < xEnd; x++, ox++)
{
pixels[rowStart + x] = originalPixels[originalRowStart + ox];
}
}
return Bitmap.CreateBitmap(pixels, width, height, bitmap.GetConfig());
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
if (resultCode == Result.Ok && requestCode == 1)
{
_imageSelected = true;
Android.Net.Uri selectedImageUri = data.Data;
_originalBitmap = BitmapFactory.DecodeStream(ContentResolver.OpenInputStream(selectedImageUri));
//Create a new mutable Bitmap from original
_canvasBitmap = Bitmap.CreateBitmap(_originalBitmap.Width, _originalBitmap.Height, _originalBitmap.GetConfig());
//Initialize the canvas assigning the mutable Bitmap to it
_canvas = new Canvas(_canvasBitmap);
SetBitmapToImageViewer();
}
}
public static Bitmap Blur(Context context, Bitmap input)
{
try {
var rsScript = RenderScript.Create (context);
var alloc = Allocation.CreateFromBitmap (rsScript, input);
var blur = ScriptIntrinsicBlur.Create (rsScript, alloc.Element);
blur.SetRadius (25);
blur.SetInput (alloc);
var result = Bitmap.CreateBitmap (input.Width, input.Height, input.GetConfig ());
var outAlloc = Allocation.CreateFromBitmap (rsScript, result);
blur.ForEach (outAlloc);
outAlloc.CopyTo (result);
rsScript.Destroy ();
return result;
} catch (Exception e) {
Log.Error ("Blurrer", "Error while trying to blur, fallbacking. " + e.ToString ());
return Bitmap.CreateBitmap (input);
}
}
public Bitmap Transform(Bitmap source)
{
Bitmap result = Bitmap.CreateBitmap(source.Width, source.Height, source.GetConfig());
Bitmap noise;
try
{
noise = picasso.Load(Resource.Drawable.noise).Get();
}
catch (Exception)
{
throw new Exception("Failed to apply transformation! Missing resource.");
}
BitmapShader shader = new BitmapShader(noise, Shader.TileMode.Repeat, Shader.TileMode.Repeat);
ColorMatrix colorMatrix = new ColorMatrix();
colorMatrix.SetSaturation(0);
ColorMatrixColorFilter filter = new ColorMatrixColorFilter(colorMatrix);
Paint paint = new Paint(PaintFlags.AntiAlias);
paint.SetColorFilter(filter);
Canvas canvas = new Canvas(result);
canvas.DrawBitmap(source, 0, 0, paint);
paint.SetColorFilter(null);
paint.SetShader(shader);
paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.Multiply));
canvas.DrawRect(0, 0, canvas.Width, canvas.Height, paint);
source.Recycle();
noise.Recycle();
return result;
}
public static Bitmap ToColorSpace(Bitmap source, ColorMatrix colorMatrix)
{
var config = source.GetConfig();
if (config == null)
config = Bitmap.Config.Argb8888; // This will support transparency
int width = source.Width;
int height = source.Height;
Bitmap bitmap = Bitmap.CreateBitmap(width, height, config);
using (Canvas canvas = new Canvas(bitmap))
using (Paint paint = new Paint())
{
paint.SetColorFilter(new ColorMatrixColorFilter(colorMatrix));
canvas.DrawBitmap(source, 0, 0, paint);
return bitmap;
}
}
private static Bitmap ChangeColor(Bitmap bitmap, Color fromColor, Color targetColor, float tolerance = 20)
{
int width = bitmap.Width;
int height = bitmap.Height;
int[] pixels = new int[width * height];
float[] redRange = new float[2]{
(float)Math.Max(fromColor.R - (tolerance / 2), 0.0),
(float)Math.Min(fromColor.R + (tolerance / 2), 255.0)};
float[] greenRange = new float[2]{
(float)Math.Max(fromColor.G - (tolerance / 2), 0.0),
(float)Math.Min(fromColor.G + (tolerance / 2), 255.0)};
float[] blueRange = new float[2]{
(float)Math.Max(fromColor.B - (tolerance / 2), 0.0),
(float)Math.Min(fromColor.B + (tolerance / 2), 255.0)};
bitmap.GetPixels(pixels, 0, width, 0, 0, width, height);
for (int i = 0; i < pixels.Length; i++)
{
if (pixels[i] == fromColor)
{
pixels[i] = new Color(targetColor.R, targetColor.G, targetColor.B, targetColor.A - 1);
}
int red = Color.GetRedComponent(pixels[i]);
int green = Color.GetGreenComponent(pixels[i]);
int blue = Color.GetBlueComponent(pixels[i]);
int alpha = Color.GetAlphaComponent(pixels[i]);
if (((red >= redRange[0]) && (red <= redRange[1])) &&
((green >= greenRange[0]) && (green <= greenRange[1])) &&
((blue >= blueRange[0]) && (blue <= blueRange[1])) &&
((alpha > 0 && alpha < 254)))
{
pixels[i] = new Color(targetColor.R, targetColor.G, targetColor.B, targetColor.A - 1);
}
}
if (bitmap.IsMutable)
{
bitmap.SetPixels(pixels, 0, width, 0, 0, width, height);
return bitmap;
}
else
{
var mutableBitmap = bitmap.Copy(bitmap.GetConfig(), true);
mutableBitmap.SetPixels(pixels, 0, width, 0, 0, width, height);
return mutableBitmap;
}
}
// Source: http://incubator.quasimondo.com/processing/superfast_blur.php
public static Bitmap ToLegacyBlurred(Bitmap source, Context context, int radius)
{
Bitmap img = source.Copy(source.GetConfig(), true);
int w = img.Width;
int h = img.Height;
int wm = w-1;
int hm = h-1;
int wh = w*h;
int div = radius+radius+1;
int[] r = new int[wh];
int[] g = new int[wh];
int[] b = new int[wh];
int rsum,gsum,bsum,x,y,i,p,p1,p2,yp,yi,yw;
int[] vmin = new int[Math.Max(w,h)];
int[] vmax = new int[Math.Max(w,h)];
int[] pix= new int[w*h];
img.GetPixels(pix, 0, w, 0,0,w, h);
int[] dv = new int[256*div];
for (i=0;i<256*div;i++){
dv[i]=(i/div);
}
yw=yi=0;
for (y=0;y<h;y++){
rsum=gsum=bsum=0;
for(i=-radius;i<=radius;i++){
p=pix[yi+Math.Min(wm,Math.Max(i,0))];
rsum+=(p & 0xff0000)>>16;
gsum+=(p & 0x00ff00)>>8;
bsum+= p & 0x0000ff;
}
for (x=0;x<w;x++){
r[yi]=dv[rsum];
g[yi]=dv[gsum];
b[yi]=dv[bsum];
if(y==0){
vmin[x]=Math.Min(x+radius+1,wm);
vmax[x]=Math.Max(x-radius,0);
}
p1=pix[yw+vmin[x]];
p2=pix[yw+vmax[x]];
rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
yi++;
}
yw+=w;
}
for (x=0;x<w;x++){
rsum=gsum=bsum=0;
yp=-radius*w;
for(i=-radius;i<=radius;i++){
yi=Math.Max(0,yp)+x;
rsum+=r[yi];
gsum+=g[yi];
bsum+=b[yi];
yp+=w;
}
yi=x;
for (y=0;y<h;y++){
// Preserve alpha channel: ( 0xff000000 & pix[yi] )
pix[yi] = (int)((0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum]);
if(x==0){
vmin[y]=Math.Min(y+radius+1,hm)*w;
vmax[y]=Math.Max(y-radius,0)*w;
}
p1=x+vmin[y];
p2=x+vmax[y];
rsum+=r[p1]-r[p2];
gsum+=g[p1]-g[p2];
bsum+=b[p1]-b[p2];
yi+=w;
}
}
img.SetPixels(pix,0, w,0,0,w,h);
return img;
}
public static bool Reshape(ref ANDROIDBITMAP bmp, BitmapInfo info, ANDROIDBITMAP.Config defFmt)
{
var bmpCfg = ToAndroidBitmapConfig(info.PixelFormat, bmp != null ? bmp.GetConfig() : defFmt);
return(Reshape(ref bmp, bmpCfg, info.Width, info.Height));
}
public static Bitmap changeBitmapContrastBrightness (Bitmap bmp, float contrast, float brightness)
{
ColorMatrix cm = new ColorMatrix (new float[] {
contrast, 0, 0, 0, brightness,
0, contrast, 0, 0, brightness,
0, 0, contrast, 0, brightness,
0, 0, 0, 1, 0
});
cm.SetSaturation (0);
Bitmap ret = Bitmap.CreateBitmap (bmp.Width, bmp.Height, bmp.GetConfig ());
Canvas canvas = new Canvas (ret);
Paint paint = new Paint ();
paint.SetColorFilter (new ColorMatrixColorFilter (cm));
canvas.DrawBitmap (bmp, 0, 0, paint);
return ret;
}
private Bitmap CreateBlurredImage(Bitmap inputBitmap)
{
try
{
var rs = RenderScript.Create(m_Context);
var theInstrinsic = ScriptIntrinsicBlur.Create(rs, Element.U8_4(rs));
var outputBitmap = Bitmap.CreateBitmap(inputBitmap.Width, inputBitmap.Height, inputBitmap.GetConfig());
var tmpIn = Allocation.CreateFromBitmap(rs, inputBitmap);
var tmpOut = Allocation.CreateFromBitmap(rs, outputBitmap);
theInstrinsic.SetRadius(m_BlurRadius);
theInstrinsic.SetInput(tmpIn);
theInstrinsic.ForEach(tmpOut);
tmpOut.CopyTo(outputBitmap);
rs.Destroy();
return outputBitmap;
}
catch (Exception)
{
}
return null;
}
