public Mat OnCameraFrame(CameraBridgeViewBase.ICvCameraViewFrame inputFrame)
{
int viewMode = mViewMode;
switch (viewMode)
{
case VIEW_MODE_GRAY:
// input frame has gray scale format
Imgproc.CvtColor(inputFrame.Gray(), mRgba, Imgproc.ColorGray2rgba, 4);
break;
case VIEW_MODE_RGBA:
// input frame has RBGA format
mRgba = inputFrame.Rgba();
break;
case VIEW_MODE_CANNY:
// input frame has gray scale format
mRgba = inputFrame.Rgba();
Imgproc.Canny(inputFrame.Gray(), mIntermediateMat, 80, 100);
Imgproc.CvtColor(mIntermediateMat, mRgba, Imgproc.ColorGray2rgba, 4);
break;
case VIEW_MODE_FEATURES:
// input frame has RGBA format
mRgba = inputFrame.Rgba();
mGray = inputFrame.Gray();
FindFeatures(JNIEnv.Handle, JNIEnv.FindClass(typeof(Java.Lang.Object)), mGray.NativeObjAddr, mRgba.NativeObjAddr);
break;
}
return(mRgba);
}
public DroidCvPattern(Stream Stream, bool MakeMask)
{
var buffer = new byte[Stream.Length];
using var ms = new MemoryStream(buffer);
Stream.CopyTo(ms);
using var raw = new DisposableMat(new MatOfByte(buffer));
if (MakeMask)
{
using var rgbaMat = new DisposableMat(Imgcodecs.Imdecode(raw.Mat, Imgcodecs.CvLoadImageUnchanged));
Mat = new Mat();
Imgproc.CvtColor(rgbaMat.Mat, Mat, Imgproc.ColorRgba2gray);
Mask = new Mat();
// Extract alpha channel
Core.ExtractChannel(rgbaMat.Mat, Mask, 3);
// Mask containing 0 or 255
Imgproc.Threshold(Mask, Mask, 0, 255, Imgproc.ThreshBinary);
}
else
{
Mat = Imgcodecs.Imdecode(raw.Mat, Imgcodecs.CvLoadImageGrayscale);
}
}
public static Bitmap getEdgeDetectedImage(this Bitmap src, Filter_Type filter_type)
{
Bitmap resizedBitmap = Bitmap.CreateScaledBitmap(src, (src.Width * 256) / src.Height, 256, true);
OpenCV.Core.Mat resizedMat = new OpenCV.Core.Mat();
OpenCV.Android.Utils.BitmapToMat(resizedBitmap, resizedMat);
OpenCV.Core.Mat gaussianMat = new OpenCV.Core.Mat();
Imgproc.GaussianBlur(resizedMat, gaussianMat, new OpenCV.Core.Size(3, 3), 0, 0);
OpenCV.Core.Mat grayMat = new OpenCV.Core.Mat();
Imgproc.CvtColor(gaussianMat, grayMat, Imgproc.ColorRgba2gray, 2);
OpenCV.Core.Mat edgeDetectedMat = new OpenCV.Core.Mat();
if (filter_type == Filter_Type.CANNY)
{
Imgproc.Canny(grayMat, edgeDetectedMat, 100, 100);
}
else
{
OpenCV.Core.Mat sobelMat = new OpenCV.Core.Mat();
Imgproc.Sobel(grayMat, sobelMat, CvType.Cv8u, 1, 1);
Core.ConvertScaleAbs(sobelMat, edgeDetectedMat, 6, 1);
}
Bitmap resultBitmap = Bitmap.CreateBitmap(resizedBitmap.Width, resizedBitmap.Height, Bitmap.Config.Argb8888);
OpenCV.Android.Utils.MatToBitmap(edgeDetectedMat, resultBitmap);
return(resultBitmap);
}
public void SetHsvColor(Scalar hsvColor)
{
double minH = (hsvColor.Val[0] >= mColorRadius.Val[0]) ? hsvColor.Val[0] - mColorRadius.Val[0] : 0;
double maxH = (hsvColor.Val[0] + mColorRadius.Val[0] <= 255) ? hsvColor.Val[0] + mColorRadius.Val[0] : 255;
mLowerBound.Val[0] = minH;
mUpperBound.Val[0] = maxH;
mLowerBound.Val[1] = hsvColor.Val[1] - mColorRadius.Val[1];
mUpperBound.Val[1] = hsvColor.Val[1] + mColorRadius.Val[1];
mLowerBound.Val[2] = hsvColor.Val[2] - mColorRadius.Val[2];
mUpperBound.Val[2] = hsvColor.Val[2] + mColorRadius.Val[2];
mLowerBound.Val[3] = 0;
mUpperBound.Val[3] = 255;
Mat spectrumHsv = new Mat(1, (int)(maxH - minH), CvType.Cv8uc3);
for (int j = 0; j < maxH - minH; j++)
{
byte[] tmp = { (byte)(minH + j), (byte)255, (byte)255 };
spectrumHsv.Put(0, j, tmp);
}
Imgproc.CvtColor(spectrumHsv, mSpectrum, Imgproc.ColorHsv2rgbFull, 4);
}
void SetImage()
{
ImageView iView = FindViewById <ImageView> (Resource.Id.imageView1);
using (Bitmap img = BitmapFactory.DecodeResource(Resources, Resource.Drawable.lena))
{
if (img != null)
{
Mat m = new Mat();
grayM = new Mat();
Utils.BitmapToMat(img, m);
Imgproc.CvtColor(m, grayM, Imgproc.ColorBgr2gray);
Imgproc.CvtColor(grayM, m, Imgproc.ColorGray2rgba);
using (Bitmap bm = Bitmap.CreateBitmap(m.Cols(), m.Rows(), Bitmap.Config.Argb8888)) {
Utils.MatToBitmap(m, bm);
iView.SetImageBitmap(bm);
}
m.Release();
grayM.Release();
}
}
}
public IPattern TakeScreenshot()
{
_superUser.SendCommand($"/system/bin/screencap {_imgPath}");
using var f = File.OpenRead(_imgPath);
using var reader = new BinaryReader(f, Encoding.ASCII);
var w = reader.ReadInt32();
var h = reader.ReadInt32();
var format = reader.ReadInt32();
if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
{
reader.ReadInt32();
}
if (_buffer == null)
{
// If format is not RGBA, notify
if (format != 1)
{
AutomataApi.Toast($"Unexpected raw image format: {format}");
}
_buffer = new byte[w * h * 4];
_rootLoadMat = new Mat(h, w, CvType.Cv8uc4);
}
reader.Read(_buffer, 0, _buffer.Length);
_rootLoadMat.Put(0, 0, _buffer);
Imgproc.CvtColor(_rootLoadMat, _rootConvertMat, Imgproc.ColorRgba2gray);
return(new DroidCvPattern(_rootConvertMat, false));
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
adapter = new TabsAdapter(this, SupportFragmentManager);
pager = FindViewById <ViewPager>(Resource.Id.viewpager);
var tabs = FindViewById <TabLayout>(Resource.Id.tabs);
pager.Adapter = adapter;
tabs.SetupWithViewPager(pager);
pager.OffscreenPageLimit = 3;
pager.PageSelected += (sender, args) =>
{
var fragment = adapter.InstantiateItem(pager, args.Position) as IFragmentVisible;
fragment?.BecameVisible();
};
Toolbar.MenuItemClick += (sender, e) =>
{
var intent = new Intent(this, typeof(AddItemActivity));;
StartActivity(intent);
};
SupportActionBar.SetDisplayHomeAsUpEnabled(false);
SupportActionBar.SetHomeButtonEnabled(false);
var src = new Mat[2];
var dst = new Mat[2];
var keyPoints1 = new MatOfKeyPoint();
var keyPoints2 = new MatOfKeyPoint();
var descripter1 = new Mat();
var descripter2 = new Mat();
var dmatch = new MatOfDMatch();
var output = new Mat();
src[0] = Imgcodecs.Imread("path/to/source/1.png");
src[1] = Imgcodecs.Imread("path/to/source/2.png");
dst[0] = new Mat();
dst[1] = new Mat();
Imgproc.CvtColor(src[0], dst[0], Imgproc.COLORBayerGR2GRAY);
Imgproc.CvtColor(src[1], dst[1], Imgproc.COLORBayerGR2GRAY);
var akaze = FeatureDetector.Create(FeatureDetector.Akaze);
var executor = DescriptorExtractor.Create(DescriptorExtractor.Akaze);
akaze.Detect(dst[0], keyPoints1);
akaze.Detect(dst[1], keyPoints2);
executor.Compute(dst[0], keyPoints1, descripter1);
executor.Compute(dst[1], keyPoints2, descripter2);
var matcher = DescriptorMatcher.Create(DescriptorMatcher.BruteforceHamming);
matcher.Match(descripter1, descripter2, dmatch);
Features2d.DrawMatches(src[0], keyPoints1, src[1], keyPoints2, dmatch, output);
}
public Mat ToBGR(Mat mat)
{
Mat bgr = new Mat();
Imgproc.CvtColor(mat, bgr, Imgproc.ColorGray2bgr);
return(bgr);
}
public Mat ToGray(Mat mat)
{
Mat gray = new Mat();
Imgproc.CvtColor(mat, gray, Imgproc.ColorBgr2gray);
return(gray);
}
/// <summary>
/// Equalizes the histogram of an image and thresholds the result.
/// </summary>
/// <param name="src"> Image to eq & thresh </param>
/// <param name="thresh"> thresh level </param>
/// <param name="max"> max value to use </param>
/// <returns> binary image (high pixels are in range) </returns>
private Mat GetWhiteFromHistogramEq(Mat src, byte thresh, byte max)
{
Mat gray = new Mat(src.Size(), src.Type());
Imgproc.CvtColor(src, gray, Imgproc.ColorBgr2gray);
Imgproc.EqualizeHist(gray, gray);
Imgproc.Threshold(gray, gray, thresh, max, Imgproc.ThreshBinary);
return(gray);
}
private Scalar ConvertScalarHsv2Rgba(Scalar hsvColor)
{
Mat pointMatRgba = new Mat();
Mat pointMatHsv = new Mat(1, 1, CvType.Cv8uc3, hsvColor);
Imgproc.CvtColor(pointMatHsv, pointMatRgba, Imgproc.ColorHsv2rgbFull, 4);
return(new Scalar(pointMatRgba.Get(0, 0)));
}
public bool OnTouch(View v, MotionEvent e)
{
int cols = mRgba.Cols();
int rows = mRgba.Rows();
int xOffset = (mOpenCvCameraView.Width - cols) / 2;
int yOffset = (mOpenCvCameraView.Height - rows) / 2;
int x = (int)e.GetX() - xOffset;
int y = (int)e.GetY() - yOffset;
Log.Info("BlobDetection", "Touch image coordinates: (" + x + ", " + y + ")");
if ((x < 0) || (y < 0) || (x > cols) || (y > rows))
{
return(false);
}
Rect touchedRect = new Rect();
touchedRect.X = (x > 4) ? x - 4 : 0;
touchedRect.Y = (y > 4) ? y - 4 : 0;
touchedRect.Width = (x + 4 < cols) ? x + 4 - touchedRect.X : cols - touchedRect.X;
touchedRect.Height = (y + 4 < rows) ? y + 4 - touchedRect.Y : rows - touchedRect.Y;
Mat touchedRegionRgba = mRgba.Submat(touchedRect);
Mat touchedRegionHsv = new Mat();
Imgproc.CvtColor(touchedRegionRgba, touchedRegionHsv, Imgproc.ColorRgb2hsvFull);
// Calculate average color of touched region
mBlobColorHsv = Core.SumElems(touchedRegionHsv);
int pointCount = touchedRect.Width * touchedRect.Height;
for (int i = 0; i < mBlobColorHsv.Val.Count; i++)
{
mBlobColorHsv.Val[i] /= pointCount;
}
mBlobColorRgba = ConvertScalarHsv2Rgba(mBlobColorHsv);
Log.Info("BlobDetection", "Touched rgba color: (" + mBlobColorRgba.Val[0] + ", " + mBlobColorRgba.Val[1] +
", " + mBlobColorRgba.Val[2] + ", " + mBlobColorRgba.Val[3] + ")");
mDetector.SetHsvColor(mBlobColorHsv);
Imgproc.Resize(mDetector.Spectrum, mSpectrum, SPECTRUM_SIZE);
mIsColorSelected = true;
touchedRegionRgba.Release();
touchedRegionHsv.Release();
return(false); // don't need subsequent touch events
}
/// <summary>
/// HSV color filter, passes all pixels between the min-max limits.
/// </summary>
/// <param name="src"> Image to filter </param>
/// <param name="min"> lower hsv point </param>
/// <param name="max"> upper hsv point </param>
/// <returns> binary image (high pixels are in range) </returns>
public Mat FilterHSV(Mat src, Scalar min, Scalar max)
{
Mat hsv = new Mat(src.Size(), src.Type());
Imgproc.CvtColor(src, hsv, Imgproc.ColorBgr2hsv);
Mat result = new Mat(hsv.Size(), CvType.Cv8uc1);
Core.Core.InRange(hsv, min, max, result);
hsv.Release();
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="img"></param>
/// <returns></returns>
public static Bitmap greyImg(Bitmap img, double threshValue1, double blurValue)
{
//Matrix für das Bild
Mat imgMat = new Mat();
//Bild zu Matrix umwandeln
Utils.BitmapToMat(img, imgMat);
//-----------------Bild bearbeiten---------------------
//Variablen
//Size s = new Size(10.0, 10.0);
Size s = new Size(blurValue, blurValue);
OpenCV.Core.Point p = new OpenCV.Core.Point(0, 0);
//TODO Matrix größe beachten?
Bitmap bmp = null;
Mat tmpgrey = new Mat(10, 10, CvType.Cv8uc1, new Scalar(4));
Mat tmpblur = new Mat(10, 10, CvType.Cv8uc1, new Scalar(4));
Mat tmpthresh = new Mat(10, 10, CvType.Cv8uc1, new Scalar(4));
Mat imgresult = new Mat(10, 10, CvType.Cv8uc1, new Scalar(4));
try
{
//Grau
Imgproc.CvtColor(imgMat, tmpgrey, Imgproc.ColorBgr2gray, 4);
//Blur
Imgproc.Blur(tmpgrey, tmpblur, s, p);
//Thresh
//Orginal
//Imgproc.Threshold(tmpblur, tmpthresh, 90, 255, Imgproc.ThreshBinary);
Imgproc.Threshold(tmpblur, tmpthresh, threshValue1, 255, Imgproc.ThreshBinary);
//Kontrast
//tmpthresh.ConvertTo(imgresult, -1, 9.0, 10);
bmp = Bitmap.CreateBitmap(tmpthresh.Cols(), tmpthresh.Rows(), Bitmap.Config.Argb8888);
Utils.MatToBitmap(tmpthresh, bmp);
}
catch (CvException e) { System.Console.WriteLine(e.Message); }
return(bmp);
}
public SignType Update(Mat src, out Mat bin)
{
Mat hsv = new Mat(), gray = new Mat();
Imgproc.CvtColor(src, hsv, Imgproc.ColorBgr2hsv);
Imgproc.CvtColor(src, gray, Imgproc.ColorBgr2gray);
//ip->Binarialize(hsvImg, EColor::BLUE, binImg);
bin = FilterMarkings(hsv);
if (Detect(bin))
{
Recognize(bin, gray);
}
return(SignType.None);
}
public void Process(Mat rgbaImage)
{
Log.Info(TAG, "Process rgbaImages");
Imgproc.PyrDown(rgbaImage, mPyrDownMat);
Imgproc.PyrDown(mPyrDownMat, mPyrDownMat);
Imgproc.CvtColor(mPyrDownMat, mHsvMat, Imgproc.ColorRgb2hsvFull);
Core.InRange(mHsvMat, mLowerBound, mUpperBound, mMask);
Imgproc.Dilate(mMask, mDilatedMask, new Mat());
IList <MatOfPoint> contours = new JavaList <MatOfPoint>();
Imgproc.FindContours(mDilatedMask, contours, mHierarchy, Imgproc.RetrExternal, Imgproc.ChainApproxSimple);
// Find max contour area
double maxArea = 0;
foreach (var each in contours)
{
MatOfPoint wrapper = each;
double area = Imgproc.ContourArea(wrapper);
if (area > maxArea)
{
maxArea = area;
}
Log.Info(TAG, "Process rgbaImages\t-- Imgproc.ContourArea(wrapper)");
}
// Filter contours by area and resize to fit the original image size
mContours.Clear();
foreach (var each in contours)
{
MatOfPoint contour = each;
if (Imgproc.ContourArea(contour) > mMinContourArea * maxArea)
{
Core.Multiply(contour, new Scalar(4, 4), contour);
mContours.Add(contour);
Log.Info(TAG, "Process rgbaImages\t-- mContours.Add(contour)");
}
}
}
IPattern MatFromImage(Image Image)
{
var width = Image.Width;
var height = Image.Height;
var planes = Image.GetPlanes();
var buffer = planes[0].Buffer;
if (_readBitmap == null)
{
var pixelStride = planes[0].PixelStride;
var rowStride = planes[0].RowStride;
var rowPadding = rowStride - pixelStride * width;
_cropRequired = (rowPadding / pixelStride) != 0;
_readBitmap = Bitmap.CreateBitmap(width + rowPadding / pixelStride, height, Bitmap.Config.Argb8888);
}
_readBitmap.CopyPixelsFromBuffer(buffer);
if (_cropRequired)
{
var correctedBitmap = Bitmap.CreateBitmap(_readBitmap, 0, 0, width, height);
Org.Opencv.Android.Utils.BitmapToMat(correctedBitmap, _convertedMat);
// if a new Bitmap was created, we need to tell the Garbage Collector to delete it immediately
correctedBitmap.Recycle();
}
else
{
Org.Opencv.Android.Utils.BitmapToMat(_readBitmap, _convertedMat);
}
Imgproc.CvtColor(_convertedMat, _colorCorrectedMat, Imgproc.ColorRgba2gray);
return(new DroidCvPattern(_colorCorrectedMat, false));
}
private IList <MatOfPoint> ProcessImage()
{
Mat grayMat = new Mat();
Mat blurMat = new Mat();
Mat edgesMat = new Mat();
Mat final = new Mat();
Mat h = new Mat();
IList <MatOfPoint> contours = new JavaList <MatOfPoint>();
OpenCV.Android.Utils.BitmapToMat(originalImage, originalMat);
originalImage.Dispose();
Imgproc.CvtColor(originalMat, grayMat, Imgproc.ColorBgr2gray);
Imgproc.GaussianBlur(grayMat, blurMat, new OpenCV.Core.Size(3, 3), 0);
Imgproc.Canny(blurMat, edgesMat, 10, 250);
Mat kernel = Imgproc.GetStructuringElement(Imgproc.MorphRect, new Size(3, 3));
Imgproc.MorphologyEx(edgesMat, final, Imgproc.MorphClose, kernel);
Imgproc.FindContours(final, contours, h, Imgproc.RetrExternal, Imgproc.ChainApproxSimple);
return(contours);
}
public Mat OnCameraFrame(CameraBridgeViewBase.ICvCameraViewFrame inputFrame)
{
Mat rgba = inputFrame.Rgba();
Size sizeRgba = rgba.Size();
Mat rgbaInnerWindow;
int rows = (int)sizeRgba.Height;
int cols = (int)sizeRgba.Width;
int left = cols / 8;
int top = rows / 8;
int width = cols * 3 / 4;
int height = rows * 3 / 4;
switch (ImageManipulationsActivity.viewMode)
{
case ImageManipulationsActivity.VIEW_MODE_RGBA:
break;
case ImageManipulationsActivity.VIEW_MODE_HIST:
Mat hist = new Mat();
int thikness = (int)(sizeRgba.Width / (mHistSizeNum + 10) / 5);
if (thikness > 5)
{
thikness = 5;
}
int offset = (int)((sizeRgba.Width - (5 * mHistSizeNum + 4 * 10) * thikness) / 2);
// RGB
for (int c = 0; c < 3; c++)
{
Imgproc.CalcHist(Arrays.AsList(rgba).Cast <Mat>().ToList(), mChannels[c], mMat0, hist, mHistSize, mRanges);
Core.Normalize(hist, hist, sizeRgba.Height / 2, 0, Core.NormInf);
hist.Get(0, 0, mBuff);
for (int h = 0; h < mHistSizeNum; h++)
{
mP1.X = mP2.X = offset + (c * (mHistSizeNum + 10) + h) * thikness;
mP1.Y = sizeRgba.Height - 1;
mP2.Y = mP1.Y - 2 - (int)mBuff[h];
Imgproc.Line(rgba, mP1, mP2, mColorsRGB[c], thikness);
}
}
// Value and Hue
Imgproc.CvtColor(rgba, mIntermediateMat, Imgproc.ColorRgb2hsvFull);
// Value
Imgproc.CalcHist(Arrays.AsList(mIntermediateMat).Cast <Mat>().ToList(), mChannels[2], mMat0, hist, mHistSize, mRanges);
Core.Normalize(hist, hist, sizeRgba.Height / 2, 0, Core.NormInf);
hist.Get(0, 0, mBuff);
for (int h = 0; h < mHistSizeNum; h++)
{
mP1.X = mP2.X = offset + (3 * (mHistSizeNum + 10) + h) * thikness;
mP1.Y = sizeRgba.Height - 1;
mP2.Y = mP1.Y - 2 - (int)mBuff[h];
Imgproc.Line(rgba, mP1, mP2, mWhilte, thikness);
}
// Hue
Imgproc.CalcHist(Arrays.AsList(mIntermediateMat).Cast <Mat>().ToList(), mChannels[0], mMat0, hist, mHistSize, mRanges);
Core.Normalize(hist, hist, sizeRgba.Height / 2, 0, Core.NormInf);
hist.Get(0, 0, mBuff);
for (int h = 0; h < mHistSizeNum; h++)
{
mP1.X = mP2.X = offset + (4 * (mHistSizeNum + 10) + h) * thikness;
mP1.Y = sizeRgba.Height - 1;
mP2.Y = mP1.Y - 2 - (int)mBuff[h];
Imgproc.Line(rgba, mP1, mP2, mColorsHue[h], thikness);
}
break;
case ImageManipulationsActivity.VIEW_MODE_CANNY:
rgbaInnerWindow = rgba.Submat(top, top + height, left, left + width);
Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
Imgproc.CvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.ColorGray2bgra, 4);
rgbaInnerWindow.Release();
break;
case ImageManipulationsActivity.VIEW_MODE_SOBEL:
Mat gray = inputFrame.Gray();
Mat grayInnerWindow = gray.Submat(top, top + height, left, left + width);
rgbaInnerWindow = rgba.Submat(top, top + height, left, left + width);
Imgproc.Sobel(grayInnerWindow, mIntermediateMat, CvType.Cv8u, 1, 1);
Core.ConvertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0);
Imgproc.CvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.ColorGray2bgra, 4);
grayInnerWindow.Release();
rgbaInnerWindow.Release();
break;
case ImageManipulationsActivity.VIEW_MODE_SEPIA:
rgbaInnerWindow = rgba.Submat(top, top + height, left, left + width);
Core.Transform(rgbaInnerWindow, rgbaInnerWindow, mSepiaKernel);
rgbaInnerWindow.Release();
break;
case ImageManipulationsActivity.VIEW_MODE_ZOOM:
Mat zoomCorner = rgba.Submat(0, rows / 2 - rows / 10, 0, cols / 2 - cols / 10);
Mat mZoomWindow = rgba.Submat(rows / 2 - 9 * rows / 100, rows / 2 + 9 * rows / 100, cols / 2 - 9 * cols / 100, cols / 2 + 9 * cols / 100);
Imgproc.Resize(mZoomWindow, zoomCorner, zoomCorner.Size());
Size wsize = mZoomWindow.Size();
Imgproc.Rectangle(mZoomWindow, new Point(1, 1), new Point(wsize.Width - 2, wsize.Height - 2), new Scalar(255, 0, 0, 255), 2);
zoomCorner.Release();
mZoomWindow.Release();
break;
case ImageManipulationsActivity.VIEW_MODE_PIXELIZE:
rgbaInnerWindow = rgba.Submat(top, top + height, left, left + width);
Imgproc.Resize(rgbaInnerWindow, mIntermediateMat, mSize0, 0.1, 0.1, Imgproc.InterNearest);
Imgproc.Resize(mIntermediateMat, rgbaInnerWindow, rgbaInnerWindow.Size(), 0.0, 0.0, Imgproc.InterNearest);
rgbaInnerWindow.Release();
break;
case ImageManipulationsActivity.VIEW_MODE_POSTERIZE:
/*
* Imgproc.cvtColor(rgbaInnerWindow, mIntermediateMat, Imgproc.COLOR_RGBA2RGB);
* Imgproc.pyrMeanShiftFiltering(mIntermediateMat, mIntermediateMat, 5, 50);
* Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_RGB2RGBA);
*/
rgbaInnerWindow = rgba.Submat(top, top + height, left, left + width);
Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
rgbaInnerWindow.SetTo(new Scalar(0, 0, 0, 255), mIntermediateMat);
Core.ConvertScaleAbs(rgbaInnerWindow, mIntermediateMat, 1.0 / 16, 0);
Core.ConvertScaleAbs(mIntermediateMat, rgbaInnerWindow, 16, 0);
rgbaInnerWindow.Release();
break;
}
return(rgba);
}
public Mat OnCameraFrame(CameraBridgeViewBase.ICvCameraViewFrame inputFrame)
{
//mRgba = inputFrame.Rgba();
Bitmap bitmap = BitmapFactory.DecodeResource(Resources, Resource.Drawable.test2);
Mat mat = new Mat();
Android.Utils.BitmapToMat(bitmap, mat);
Imgproc.Resize(mat, mRgba, mRgba.Size());
mat.Release();
bitmap.Recycle();
bitmap.Dispose();
// Start
// Sign detection
Mat binSign;
mSignDetector.Update(mRgba, out binSign);
// Filter image based on color to find markings
Mat bin = mLaneMarkFilter.FilterMarkings(mRgba);
// Generate bird eye view
float marginX = 0.42f;
float marginY = 0.65f;
Mat a, b, birdsEyeView;
mTransformer.GetBirdEye(bin, mRgba, marginX, marginY, out a, out b, out birdsEyeView);
// Scale to mini bird view and draw to origin
Mat birdEyeMiniView = new Mat(birdsEyeView.Size(), CvType.Cv8uc4);// new Mat(birdsEyeView.Height() / 2, birdsEyeView.Width() / 2, mRgba.Type(), new Scalar(0, 255, 0, 255));
Imgproc.CvtColor(birdsEyeView, birdEyeMiniView, Imgproc.ColorGray2bgra);
Imgproc.Resize(birdEyeMiniView, birdEyeMiniView, new Size(birdsEyeView.Cols() / 2, birdsEyeView.Rows() / 2));
birdEyeMiniView.CopyTo(mRgba.RowRange(0, birdsEyeView.Rows() / 2).ColRange(0, birdsEyeView.Cols() / 2));
List <Core.Rect> rects = mSignDetector.GetSignRects();
SignDetector.SignType[] types = mSignDetector.GetSignTypes();
int iRect = 0;
foreach (var rect in rects)
{
if (types[iRect] != SignDetector.SignType.None)
{
Imgproc.Rectangle(mRgba, new Core.Point(rect.X, rect.Y), new Core.Point(rect.X + rect.Width, rect.Y + rect.Height), new Scalar(255, 0, 0, 255), 3);
}
iRect++;
}
//Imgproc.Resize(binSign, binSign, new Size(mRgba.Cols() / 2, mRgba.Rows() / 2));
//Mat binSignMini = new Mat(binSign.Size(), CvType.Cv8uc4);
//Imgproc.CvtColor(binSign, binSignMini, Imgproc.ColorGray2bgra);
//binSignMini.CopyTo(mRgba.RowRange(0, mRgba.Rows() / 2).ColRange(mRgba.Cols() / 2, mRgba.Cols()));
// End
// Release
birdsEyeView.Release();
birdEyeMiniView.Release();
a.Release();
b.Release();
bin.Release();
return(mRgba);
}
public static async Task <string> detectAndExtractText(Bitmap img)
{
//Matrix für die Bilder
Mat large = new Mat();
Mat small = new Mat();
Mat rgb = new Mat();
//Bild zu Matrix umwandeln
Utils.BitmapToMat(img, large);
// downsample and use it for processing
Imgproc.PyrDown(large, rgb);
//Grey
Imgproc.CvtColor(rgb, small, Imgproc.ColorBgr2gray);
//Gradiant
Mat grad = new Mat();
Size morphsize = new Size(3.0, 3.0);
Mat morphKernel = Imgproc.GetStructuringElement(Imgproc.MorphEllipse, morphsize);
Imgproc.MorphologyEx(small, grad, Imgproc.MorphGradient, morphKernel);
//Binarize
Mat bw = new Mat();
Imgproc.Threshold(grad, bw, 0.0, 255.0, Imgproc.ThreshBinary | Imgproc.ThreshOtsu);
// connect horizontally oriented regions
Mat connected = new Mat();
Size connectsize = new Size(9.0, 1.0);
morphKernel = Imgproc.GetStructuringElement(Imgproc.MorphRect, connectsize);
Imgproc.MorphologyEx(bw, connected, Imgproc.MorphClose, morphKernel);
// find contours
Mat mask = Mat.Zeros(bw.Size(), CvType.Cv8uc1);
JavaList <MatOfPoint> contours = new JavaList <MatOfPoint>();
Mat hierarchy = new Mat();
OpenCV.Core.Point contourPoint = new OpenCV.Core.Point(0, 0);
Imgproc.FindContours(connected, contours, hierarchy, Imgproc.RetrCcomp, Imgproc.ChainApproxSimple, contourPoint);
Scalar zero = new Scalar(0, 0, 0);
Scalar contourscal = new Scalar(255, 255, 255);
Scalar rectScalar = new Scalar(0, 255, 0);
OpenCV.Core.Rect rect;
Mat maskROI;
double r;
double[] contourInfo;
string resulttext = "";
string part;
Bitmap bmpOcr;
Mat croppedPart;
for (int i = 0; i >= 0;)
{
rect = Imgproc.BoundingRect(contours[i]);
maskROI = new Mat(mask, rect);
maskROI.SetTo(zero);
//fill the contour
Imgproc.DrawContours(mask, contours, i, contourscal, Core.Filled);
// ratio of non-zero pixels in the filled region
r = (double)Core.CountNonZero(maskROI) / (rect.Width * rect.Height);
/* assume at least 45% of the area is filled if it contains text */
/* constraints on region size */
/* these two conditions alone are not very robust. better to use something
* like the number of significant peaks in a horizontal projection as a third condition */
if (r > .45 && (rect.Height > 8 && rect.Width > 8))
{
//Imgproc.Rectangle(rgb, rect.Br(), rect.Tl(), rectScalar, 2);
try
{
croppedPart = rgb.Submat(rect);
bmpOcr = Bitmap.CreateBitmap(croppedPart.Width(), croppedPart.Height(), Bitmap.Config.Argb8888);
Utils.MatToBitmap(croppedPart, bmpOcr);
part = await OCR.getText(bmpOcr);
resulttext = resulttext + part;
Console.WriteLine("------------------Durchlauf-------------");
}
catch (Exception e)
{
Android.Util.Log.Debug("Fehler", "cropped part data error " + e.Message);
}
}
//Nächste Element bestimmen
contourInfo = hierarchy.Get(0, i);
i = (int)contourInfo[0];
}
return(resulttext);
}
public override bool OnOptionsItemSelected(IMenuItem item)
{
Log.Info(Tag, "Menu Item selected " + item);
if (item == _itemPickPhoto)
{
var imageIntent = new Intent();
imageIntent.SetType("image/*");
imageIntent.SetAction(Intent.ActionGetContent);
StartActivityForResult(Intent.CreateChooser(imageIntent, "Select photo"), 0);
}
else if (item == _itemGray)
{
// 灰度图
_gray = new Mat(_raw.Width(), _raw.Height(), CvType.Cv8uc1);
Imgproc.CvtColor(_raw, _gray, Imgproc.ColorRgb2gray);
ShowImage(_gray);
}
else if (item == _itemThreshold)
{
// 二值化
_threshold = new Mat(_image.Width, _image.Height, CvType.Cv8uc1);
Imgproc.Threshold(_gray, _threshold, 168, 255, Imgproc.ThreshBinary);
ShowImage(_threshold);
}
else if (item == _itemFindContours)
{
// 查找最大连通区域
IList <MatOfPoint> contours = new JavaList <MatOfPoint>();
Mat hierarchy = new Mat();
var target = _threshold.Clone();
Imgproc.FindContours(target, contours, hierarchy, Imgproc.RetrExternal, Imgproc.ChainApproxNone);
MatOfPoint max = new MatOfPoint();
double contour_area_max = 0;
if (contours.Any())
{
foreach (var contour in contours)
{
var contour_area_temp = Math.Abs(Imgproc.ContourArea(contour));
if (contour_area_temp > contour_area_max)
{
contour_area_max = contour_area_temp;
max = contour;
}
}
}
var last = new JavaList <MatOfPoint>();
last.Add(max);
Imgproc.DrawContours(_raw, last, -1, new Scalar(255, 0, 0));
ShowImage(_raw);
}
else if (item == _itemCreateTrimap)
{
// 生成三元图 暂时先用生成的图替代
var imageIntent = new Intent();
imageIntent.SetType("image/*");
imageIntent.SetAction(Intent.ActionGetContent);
StartActivityForResult(Intent.CreateChooser(imageIntent, "Select photo"), 1);
}
else if (item == _itemSharedMatting)
{
// 扣图
var sharedMatting = new SharedMatting();
sharedMatting.SetImage(_raw);
sharedMatting.SetTrimap(_trimap);
sharedMatting.SolveAlpha();
}
return(base.OnOptionsItemSelected(item));
}
/// <summary>
/// Run a sliding window algorithm on the bird eye view to find the 2 sides of the lane.
/// </summary>
/// <param name="birdEye">bird eye image</param>
/// <param name="res"> result of windowing </param>
/// <param name="windows"> number of stacked windows </param>
public void FitLinesInSlidingWindows(Mat birdEye, out Mat res, int windows)
{
LeftPoints = new List <Point>();
RightPoints = new List <Point>();
// erode by 2x2 kernel
Imgproc.Erode(birdEye, birdEye, Imgproc.GetStructuringElement(Imgproc.MorphRect, new Size(2, 2)));
// alloc res have the same size and type as bird eye
res = new Mat(birdEye.Size(), birdEye.Type());
// convert to BGR for result drawing
Imgproc.CvtColor(birdEye, res, Imgproc.ColorGray2bgr);
// crop half bottom of bird eye
Mat cropped = new Mat(birdEye, new Rect(0, birdEye.Height() / 2, birdEye.Width(), birdEye.Height() / 2));
// find left and right starting point
int left, right;
SlidingWindowsStartLoc(cropped, out left, out right);
// current window locations
int currentWindowLeft = left;
int currentWindowRight = right;
// window settings & buffer
int margin = 100;
int minpix = 140;
int winHeight = birdEye.Height() / windows;
// calculate windows
for (int i = 0; i < windows; i++)
{
// calculate window size and location
int winYhigh = birdEye.Height() - i * winHeight;
int winXleftLow = currentWindowLeft - margin;
int winXrightLow = currentWindowRight - margin;
Rect leftRect = new Rect(winXleftLow, winYhigh - winHeight, margin * 2, winHeight);
Rect rightRect = new Rect(winXrightLow, winYhigh - winHeight, margin * 2, winHeight);
Imgproc.Rectangle(res, new Point(leftRect.X, leftRect.Y), new Point(leftRect.X + leftRect.Width, leftRect.Y + leftRect.Height), new Scalar(20, 20, 255), 3);
Imgproc.Rectangle(res, new Point(rightRect.X, rightRect.Y), new Point(rightRect.X + rightRect.Width, rightRect.Y + rightRect.Height), new Scalar(20, 20, 255), 3);
int goodLeft;
int goodRight;
// save position
LeftPoints.Add(new Point(winXleftLow + margin, winYhigh - (winHeight / 2)));
RightPoints.Add(new Point(winXrightLow + margin, winYhigh - (winHeight / 2)));
Mat birdEyeROI;
birdEyeROI = birdEye.Submat(leftRect);
goodLeft = Core.Core.CountNonZero(birdEyeROI);
birdEyeROI = birdEye.Submat(rightRect);
goodRight = Core.Core.CountNonZero(birdEyeROI);
if (goodLeft > minpix)
{
// recenter
birdEyeROI = birdEye.Submat(leftRect);
currentWindowLeft = CenterOfLine(birdEyeROI) + leftRect.X;
}
if (goodRight > minpix)
{
// recenter
birdEyeROI = birdEye.Submat(rightRect);
currentWindowRight = CenterOfLine(birdEyeROI) + rightRect.X;
}
}
// Draw midpoints
foreach (Point p in LeftPoints)
{
//res.Draw(new Rectangle(new Point((int)p.X, (int)p.Y), new Size(20, 20)), new Bgr(50, 50, 230), 12);
Imgproc.Rectangle(res, new Point((int)p.X, (int)p.Y), new Point(p.X + 20, p.Y + 20), new Scalar(50, 50, 230), 12);
}
foreach (Point p in RightPoints)
{
//res.Draw(new Rectangle(new Point((int)p.X, (int)p.Y), new Size(20, 20)), new Bgr(50, 50, 230), 12);
Imgproc.Rectangle(res, new Point((int)p.X, (int)p.Y), new Point(p.X + 20, p.Y + 20), new Scalar(50, 50, 230), 12);
}
BirdEye = res;
}
public Mat OnCameraFrame(Mat frame)
{
//Only done on first frame.
//If ROI it not initailized, then we draw it on the frame.
//However, if we have already drawn it on previous frame
//then we don't need to draw it again.
if (roi == null)
{
roi = GetRoi(frame);
}
// TODO: provide these in a global config file
var contourMinHeight = frame.Height() / 34;
var contourMaxHeight = frame.Height() / 4;
// Initial rotation because camera starts in landscape mode.
var input = _openCV.Rotate(frame, -90);
rgba = input.Clone();
var submat = input.Submat(roi);
var submatClone = submat.Clone();
rgba = _openCV.DrawRectangle(rgba, roi, new Scalar(0, 255, 0));
// Turn image black and white.
var gray = _openCV.ToGray(submat);
// Brightness and contrast correction trough Histogram Equalization
var equalized = _openCV.EqualizeHistogram(gray);
// Blur image to reduce noise.
var blur = _openCV.GaussianBlur(equalized);
// Detect blobs using Otsu Tresholding
var blobs = _openCV.OtsuThresh(blur);
// Find contours in image. (clone because it this version of OpenCV applies some changes to the input image)
var clone = blobs.Clone();
var contours = _openCV.FindContours(clone);
// Filter contours based on size -> then by Y position and height of their bounding boxes.
var contoursBySize = _openCV.FilterContoursBySize(contours.Item1, contourMinHeight, contourMaxHeight);
var alignedContours = _openCV.FilterContoursByYPosition(contoursBySize.Item1, contoursBySize.Item2);
// Draw bounding boxes on input image for user visualization.
var withBoundingBoxes = _openCV.DrawBoundingBoxes(submatClone.Clone(), alignedContours.Item2);
withBoundingBoxes.CopyTo(rgba.Submat(roi));
// Discard the frame if less than 8 matching contours are found. We want all the digits on the gas meter before processing.
// TODO: if gasmeters have less than 8 digits, then what?
if (alignedContours.Item2.Count != 8)
{
return(rgba);
}
// Prepare output for OCR and stop the camera feed.
try
{
var digits = new List <Stream>();
var image = new Mat();
var digitsClone = new List <Stream>();
// Transform BGR image to RGB
Imgproc.CvtColor(submatClone, submatClone, Imgproc.ColorBgr2rgba, 4);
image = submatClone;
// Sort digit bounding boxes left to right
var sorted = _openCV.SortRects(alignedContours.Item2);
// Cut each digit individually based on bounding box.
foreach (Rect rect in sorted)
{
digits.Add(_openCV.MatToStream(new Mat(blobs, rect)));
digitsClone.Add(_openCV.MatToStream(new Mat(blobs, rect)));
}
// TODO: Crop output image to region of interest when that is implemented.
// Return digits and final image to display on confirmation page.
MessagingCenter.Send(new CameraResultMessage {
DigitsClone = digitsClone, Digits = digits, Image = _openCV.MatToStream(image)
}, CameraResultMessage.Key);
// Stop the camera feed and close the page
input.Release();
submat.Release();
gray.Release();
equalized.Release();
blur.Release();
blobs.Release();
clone.Release();
contours.Item2.Release();
submatClone.Release();
withBoundingBoxes.Release();
image.Release();
Finish();
}
catch (Exception)
{
// Processing the rectangles sometimes fail throwing an exception. These frames can discarded and the feed continues.
return(rgba);
}
return(rgba);
}
