/// <summary>
/// Creates a new cropped WriteableBitmap.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <param name="region">The rectangle that defines the crop region.</param>
/// <returns>A new WriteableBitmap that is a cropped version of the input.</returns>
public static WriteableBitmap Crop(this WriteableBitmap bmp, Rect region)
{
return(bmp.Crop((int)region.X, (int)region.Y, (int)region.Width, (int)region.Height));
}
private void DrawPreviewImage(WriteableBitmap bitmap)
{
if (live_view_image.ActualWidth == 0 || panel_preview.ActualWidth == 0)
return;
double dw = panel_preview.ActualWidth/live_view_image.ActualWidth;
double dh = panel_preview.ActualHeight/live_view_image.ActualHeight;
double d = bitmap.PixelWidth*dw/ZoomFactor;
double h = bitmap.PixelHeight*dh/ZoomFactor;
WriteableBitmap tempbitmap = bitmap.Crop((int) (CentralPoint.X - (d/2)), (int) (CentralPoint.Y - (h/2)),
(int) d, (int) h);
tempbitmap.Freeze();
img_preview.Source = tempbitmap;
}
private WriteableBitmap GetCroppedPart(WriteableBitmap source, RectangleF relativeRect)
{
double width = source.Width;
double height = source.Height;
double rleft = relativeRect.Left * width / 100;
double rtop = relativeRect.Top * height / 100;
double rwidth = relativeRect.Width * width / 100;
double rheight = relativeRect.Height * height / 100;
Rect r = new Rect(rleft, rtop, rwidth, rheight);
return source.Crop(r);
}
private static string ResizeAndCopyImageToShared(string imageUrl, int page)
{
var newUrl = string.Format("/Shared/ShellContent/{0}.jpg", page);
using (var isf = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!isf.FileExists(newUrl))
{
BitmapImage source = new BitmapImage(new Uri(imageUrl, UriKind.Relative));
WriteableBitmap bitmap = new WriteableBitmap(source);
bitmap.Crop(0, 0, 137, 137);
using (var fileStream = isf.CreateFile(newUrl))
{
bitmap.SaveJpeg(fileStream, 137, 137, 0, 100);
}
}
}
return newUrl;
}
public static WriteableBitmap DrawBlobBoundingBoxsCV(WriteableBitmap writeableBitmap, WriteableBitmap gradientBitmapRef, WriteableBitmap realBitmapRef)
{
Bitmap normalBitmap = BitmapFromWriteableBitmap(writeableBitmap);
var cvImage = new Image<Gray, byte>(new Bitmap(normalBitmap));
//var classifications = ClassifyBitmap( writeableBitmap, cvImage );
if (cvImage != null)
{
// This takes our nice looking color png and converts it to black and white
Image<Gray, byte> greyImg = cvImage.Convert<Gray, byte>();
// We again threshold it based on brightness...BUT WE INVERT THE PNG. BLOB DETECTOR DETECTS WHITE NOT BLACK
// this will esentially eliminate the color differences
// you could also do cool things like threshold only certain colors here for a color based blob detector
Image<Gray, Byte> greyThreshImg = greyImg.ThresholdBinaryInv(new Gray(150), new Gray(255));
Emgu.CV.Cvb.CvBlobs resultingImgBlobs = new Emgu.CV.Cvb.CvBlobs();
Emgu.CV.Cvb.CvBlobDetector bDetect = new Emgu.CV.Cvb.CvBlobDetector();
uint numWebcamBlobsFound = bDetect.Detect(greyThreshImg, resultingImgBlobs);
// This is a simple way of just drawing all blobs reguardless of their size and not iterating through them
// It draws on top of whatever you input. I am inputting the threshold image. Specifying an alpha to draw with of 0.5 so its half transparent.
//Emgu.CV.Image<Bgr, byte> blobImg = bDetect.DrawBlobs(webcamThreshImg, resultingWebcamBlobs, Emgu.CV.Cvb.CvBlobDetector.BlobRenderType.Default, 0.5);
// Here we can iterate through each blob and use the slider to set a threshold then draw a red box around it
Image<Rgb, byte> blobImg = greyThreshImg.Convert<Rgb, byte>();
Rgb red = new Rgb(255, 0, 0);
int blobNumber = 0;
// Lets try and iterate the blobs?
foreach (Emgu.CV.Cvb.CvBlob targetBlob in resultingImgBlobs.Values)
{
int imageArea = blobImg.Width*blobImg.Height;
int blobArea = targetBlob.Area;
int blobBoundingBoxArea = targetBlob.BoundingBox.Width*targetBlob.BoundingBox.Height;
// Only use blobs with area greater than some threshold
// If the blob bounding rect is basically size of the whole image ignore it for now
if (blobArea > 200.0 && blobBoundingBoxArea < (imageArea*0.99))
{
Rectangle rectangle = targetBlob.BoundingBox;
int CentroidX = (int)targetBlob.Centroid.X;
int CentroidY = (int)targetBlob.Centroid.Y;
int croppedWidth = rectangle.Width + 50;
int croppedHeight = rectangle.Height + 50;
int CroppedX = CentroidX - (int)(croppedWidth / 2.0);
int CroppedY = CentroidY - (int)(croppedHeight / 2.0);
var croppedBlobBitmap = writeableBitmap.Crop(CroppedX, CroppedY, croppedWidth, croppedHeight);
var croppedGradientBlobBitmap = gradientBitmapRef.Crop(CroppedX, CroppedY, croppedWidth, croppedHeight);
var croppedRealBitmapRef = realBitmapRef.Crop(CroppedX, CroppedY, croppedWidth, croppedHeight);
double blobAngle = -RadianToDegree(CalculateBlobAngle(targetBlob));
CroppedX = (int) (croppedWidth/2.0);
CroppedY = (int) (croppedHeight/2.0);
var rotatedandCroppedBlobBitmap = RotateWriteableBitmap(croppedBlobBitmap, blobAngle);
var rotatedGradientBlobBitmap = RotateColorWriteableBitmap(croppedGradientBlobBitmap, blobAngle);
var rotatedRealBitmapRef = RotateColorWriteableBitmap(croppedRealBitmapRef, blobAngle);
var refinedBitmap = DrawBlobBoundingBoxsAroundCroppedBitmap(rotatedandCroppedBlobBitmap, rotatedGradientBlobBitmap, rotatedRealBitmapRef, 1);
rotatedGradientBlobBitmap = DrawBlobBoundingBoxsAroundCroppedBitmap(rotatedandCroppedBlobBitmap, rotatedGradientBlobBitmap, rotatedRealBitmapRef, 2);
rotatedRealBitmapRef = DrawBlobBoundingBoxsAroundCroppedBitmap(rotatedandCroppedBlobBitmap, rotatedGradientBlobBitmap, rotatedRealBitmapRef, 3);
var areaCheck = refinedBitmap.PixelHeight*refinedBitmap.PixelWidth;
if (areaCheck >= 200)
{
blobNumber++;
var thresholded = refinedBitmap.Clone();
ThresholdBitmap(thresholded, 10, false);
BitmapColorer.ColorBitmap(thresholded);
System.Windows.Media.Color blobColor = PixelColorOfCentralBlob(thresholded);
BitmapColorer.EraseAllButCertainColorandWhite(thresholded, blobColor);
var shouldFlip = shouldFlipThresholdedBitmap(thresholded, blobColor);
if (shouldFlip)
{
thresholded = thresholded.Rotate(180);
rotatedGradientBlobBitmap = rotatedGradientBlobBitmap.Rotate(180);
rotatedRealBitmapRef = rotatedRealBitmapRef.Rotate(180);
}
var orientedBitmap = NormalizeBitmapSize(thresholded);
var orientedGradientBitmap = NormalizeBitmapSize(rotatedGradientBlobBitmap);
var orientedRealBitmap = NormalizeBitmapSize(rotatedRealBitmapRef);
ApplyBlobMaskToOtherBitmaps(orientedBitmap, orientedGradientBitmap, orientedRealBitmap, blobColor);
string fileName1 = saveDirectory + "\\croppedBlob" + blobNumber + ".png";
ExtensionMethods.Save(orientedRealBitmap, fileName1);
}
}
}
}
return writeableBitmap;
}
public static WriteableBitmap DrawBlobBoundingBoxsAroundCroppedBitmap(WriteableBitmap writeableBitmap,
WriteableBitmap gradientBitmapRef, WriteableBitmap realBitmapRef, int returnBitmapIndex)
{
Bitmap normalBitmap = BitmapFromWriteableBitmap(writeableBitmap);
var cvImage = new Image<Gray, byte>(new Bitmap(normalBitmap));
if (cvImage != null)
{
Image<Gray, byte> greyImg = cvImage.Convert<Gray, byte>();
Image<Gray, Byte> greyThreshImg = greyImg.ThresholdBinaryInv(new Gray(150), new Gray(255));
Emgu.CV.Cvb.CvBlobs resultingImgBlobs = new Emgu.CV.Cvb.CvBlobs();
Emgu.CV.Cvb.CvBlobDetector bDetect = new Emgu.CV.Cvb.CvBlobDetector();
uint numWebcamBlobsFound = bDetect.Detect(greyThreshImg, resultingImgBlobs);
Image<Rgb, byte> blobImg = greyThreshImg.Convert<Rgb, byte>();
Rgb red = new Rgb(255, 0, 0);
int blobNumber = 0;
foreach (Emgu.CV.Cvb.CvBlob targetBlob in resultingImgBlobs.Values)
{
int imageArea = blobImg.Width*blobImg.Height;
int blobArea = targetBlob.Area;
int blobBoundingBoxArea = targetBlob.BoundingBox.Width*targetBlob.BoundingBox.Height;
if (blobArea > 200.0 && blobBoundingBoxArea < (imageArea*0.99))
{
blobNumber++;
Rectangle rectangle = targetBlob.BoundingBox;
Rect convertedRect = new Rect(rectangle.X - 10, rectangle.Y - 10, rectangle.Width + 20,
rectangle.Height + 20);
//BitmapColorer.DrawRectangle(writeableBitmap, convertedRect);
writeableBitmap = writeableBitmap.Crop(rectangle.X - 10, rectangle.Y - 10, rectangle.Width + 20,
rectangle.Height + 20);
gradientBitmapRef = gradientBitmapRef.Crop(rectangle.X - 10, rectangle.Y - 10,
rectangle.Width + 20, rectangle.Height + 20);
realBitmapRef = realBitmapRef.Crop(rectangle.X - 10, rectangle.Y - 10, rectangle.Width + 20,
rectangle.Height + 20);
}
}
}
if (returnBitmapIndex == 1)
{
return writeableBitmap;
}
else if (returnBitmapIndex == 2)
{
return gradientBitmapRef;
}
else
{
return realBitmapRef;
}
}
// Image finished loading
private void OnImageLoaded(object sender, EventArgs e)
{
BitmapImage sourceImage = (BitmapImage)sender;
WriteableBitmap scaledImage = new WriteableBitmap(sourceImage);
scaledImage.Resize((int)Width, (int)Height, WriteableBitmapExtensions.Interpolation.Bilinear);
double w = Width;
double h = Height;
double cellWidth = w;
double cellHeight = h / NumBlinds;
for (int i = 0; i < NumBlinds; i++)
{
// Create the target cell
Image cell = new Image();
Rect rect = new Rect(0, i * cellHeight, cellWidth, cellHeight);
cell.SetValue(Canvas.TopProperty, rect.Y);
cell.SetValue(Canvas.LeftProperty, rect.X);
cell.Width = cellWidth;
cell.Height = cellHeight;
cell.Visibility = Visibility.Collapsed;
contentView.Children.Add(cell);
nextGrid.Add(cell);
WriteableBitmap slice = scaledImage.Crop(rect);
cell.Source = slice;
}
for(int i = 0; i < NumBlinds; i++)
{
animatedCellIndex.Add(i);
}
// Do animation
int firstCellIndex = animatedCellIndex[0];
PerformFlipAnimation(grid[firstCellIndex], nextGrid[firstCellIndex]);
}