public static void cvt_YUVtoGRAY(Mat src, Mat dst) { /** convert YUV image to RGB then GRAY colorspace */ mSrc = new Mat(); src.copyTo(mSrc); Imgproc.cvtColor(mSrc, dst, Imgproc.COLOR_YUV420sp2RGB); Imgproc.cvtColor(dst, dst, Imgproc.COLOR_RGB2GRAY); }
private static Bitmap canny(Bitmap image) { // convert image to matrix Mat Mat1 = new Mat(image.getWidth(), image.getHeight(), CvType.CV_32FC1); Utils.bitmapToMat(image, Mat1); // create temporary matrix2 Mat Mat2 = new Mat(image.getWidth(), image.getHeight(), CvType.CV_32FC1); // convert image to grayscale Imgproc.cvtColor(Mat1, Mat2, Imgproc.COLOR_BGR2GRAY); // doing a gaussian blur prevents getting a lot of false hits Imgproc.GaussianBlur(Mat2, Mat1, new Size(3, 3), 2, 2); // ? // now apply canny function int param_threshold1 = 25; // manually defined int param_threshold2 = param_threshold1 * 3; // Cannys recommendation Imgproc.Canny(Mat1, Mat2, param_threshold1, param_threshold2); // ? Imgproc.cvtColor(Mat2, Mat1, Imgproc.COLOR_GRAY2BGRA, 4); // convert matrix to output bitmap Bitmap output = Bitmap.createBitmap(image.getWidth(), image.getHeight(), Bitmap.Config.RGB_565); Utils.matToBitmap(Mat1, output); return output; }
public static Mat warp(Mat inputMat, Mat startM, int factor) { int resultWidth = 400 * factor; int resultHeight = 240 * factor; Mat outputMat = new Mat(resultWidth, resultHeight, CvType.CV_8UC4); Point ocvPOut1 = new Point(0, 0); Point ocvPOut2 = new Point(0, resultHeight); Point ocvPOut3 = new Point(resultWidth, resultHeight); Point ocvPOut4 = new Point(resultWidth, 0); List<Point> dest = new ArrayList<Point>(); dest.add(ocvPOut1); dest.add(ocvPOut2); dest.add(ocvPOut3); dest.add(ocvPOut4); Mat endM = Converters.vector_Point2f_to_Mat(dest); Mat perspectiveTransform = Imgproc.getPerspectiveTransform(startM, endM); Imgproc.warpPerspective( inputMat, outputMat, perspectiveTransform, new Size(resultWidth, resultHeight), Imgproc.INTER_AREA); Imgproc.GaussianBlur(outputMat, outputMat, new org.opencv.core.Size(5, 5), 5); Imgproc.resize(outputMat, outputMat, new Size(resultWidth / factor, resultHeight / factor)); Imgproc.threshold(outputMat, outputMat, 127, 255, Imgproc.THRESH_TOZERO); return outputMat; }
public static void main(String[] args) { try { System.loadLibrary(Core.NATIVE_LIBRARY_NAME); Mat source = Imgcodecs.imread("test_image.jpg", 0); Mat destination = new Mat(source.rows(), source.cols(), source.type()); Imgproc.GaussianBlur(source, source, new Size(45, 45), 0); Imgproc.adaptiveThreshold( source, source, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 75, 10); Core.bitwise_not(source, source); // Line detection Mat img2 = null; Imgproc.cvtColor(source, img2, Imgproc.COLOR_GRAY2RGB); Mat img3 = null; Imgproc.cvtColor(source, img3, Imgproc.COLOR_GRAY2RGB); MatOfInt4 lines = new MatOfInt4(); // Imgproc.HoughLines(img, lines, rho, theta, threshold); // Write to File Imgcodecs.imwrite("gaussian.jpg", source); System.out.println("Success!"); } catch (Exception e) { System.out.println("Error has occurred: " + e.getMessage()); } }
/** * Finds and extracts all contours in the given Mat. Optionally also removes contours with areas * below that of MIN_CONTOUR_AREA. * * @param mask A mask of all resistors in the image * @param originalImage The original image from which the mask was created * @param thresholdByArea If true, remove contours below threshold * @return The list a found contours */ private List<MatOfPoint> getContours(Mat mask, Mat originalImage, boolean thresholdByArea) { List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Mat hierarchy = new Mat(); Imgproc.findContours( mask, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE, new Point(0, 0)); // remove any remaining noise by only keeping contours which area > threshold if (thresholdByArea) { for (int i = 0; i < contours.size(); i++) { double area = Imgproc.contourArea(contours.get(i)); if (area < MIN_CONTOUR_AREA || area > 6000) { contours.remove(i); i--; } } } Mat drawing = Mat.zeros(originalImage.size(), CvType.CV_8U); for (int i = 0; i < contours.size(); i++) { Scalar color = new Scalar(255, 255, 255); Imgproc.drawContours(drawing, contours, i, color, 4, 8, hierarchy, 0, new Point()); } paintBR(drawing); return contours; }
/** * Locate rectangles in an image * * @param grayImage Grayscale image * @return Rectangle locations */ public RectangleLocationResult locateRectangles(Mat grayImage) { Mat gray = grayImage.clone(); // Filter out some noise Filter.downsample(gray, 2); Filter.upsample(gray, 2); Mat cacheHierarchy = new Mat(); Mat grayTemp = new Mat(); List<Rectangle> rectangles = new ArrayList<>(); List<Contour> contours = new ArrayList<>(); Imgproc.Canny(gray, grayTemp, 0, THRESHOLD_CANNY, APERTURE_CANNY, true); Filter.dilate(gray, 2); List<MatOfPoint> contoursTemp = new ArrayList<>(); // Find contours - the parameters here are very important to compression and retention Imgproc.findContours( grayTemp, contoursTemp, cacheHierarchy, Imgproc.CV_RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); // For each contour, test whether the contour is a rectangle // List<Contour> contours = new ArrayList<>(); MatOfPoint2f approx = new MatOfPoint2f(); for (MatOfPoint co : contoursTemp) { MatOfPoint2f matOfPoint2f = new MatOfPoint2f(co.toArray()); Contour c = new Contour(co); // Attempt to fit the contour to the best polygon Imgproc.approxPolyDP( matOfPoint2f, approx, c.arcLength(true) * EPLISON_APPROX_TOLERANCE_FACTOR, true); Contour approxContour = new Contour(approx); // Make sure the contour is big enough, CLOSED (convex), and has exactly 4 points if (approx.toArray().length == 4 && Math.abs(approxContour.area()) > 1000 && approxContour.isClosed()) { // TODO contours and rectangles array may not match up, but why would they? contours.add(approxContour); // Check each angle to be approximately 90 degrees double maxCosine = 0; for (int j = 2; j < 5; j++) { double cosine = Math.abs( MathUtil.angle( approx.toArray()[j % 4], approx.toArray()[j - 2], approx.toArray()[j - 1])); maxCosine = Math.max(maxCosine, cosine); } if (maxCosine < MAX_COSINE_VALUE) { // Convert the points to a rectangle instance rectangles.add(new Rectangle(approx.toArray())); } } } return new RectangleLocationResult(contours, rectangles); }
/** * @param inputImg * @return Mat */ public static Mat watershed(Mat inputImg) { Mat target = new Mat(inputImg.rows(), inputImg.cols(), CvType.CV_8UC3); Imgproc.cvtColor(inputImg, target, Imgproc.COLOR_BGR2RGB); // Conversion to 8UC1 grayscale image Mat grayScale = new Mat(inputImg.rows(), inputImg.cols(), CvType.CV_32SC1); Imgproc.cvtColor(inputImg, grayScale, Imgproc.COLOR_BGR2GRAY); // constructing a 3x3 kernel for morphological opening Mat openingKernel = Mat.ones(9, 9, CvType.CV_8U); // яскравість // target.convertTo(target, -1, 10d * 12 / 100, 0); // Imgproc.dilate(target, target, new Mat(), new Point(-1, -1), 1); Size s = new Size(27, 27); Imgproc.GaussianBlur(target, target, s, 1.7); Imgproc.morphologyEx(target, target, Imgproc.MORPH_OPEN, openingKernel); // dilation operation for extracting the background // Imgproc.dilate(target, target, openingKernel); // Imgproc.erode(target, target, new Mat(), new Point(-1, -1), 1); Mat seeds = new Mat(target.rows(), target.cols(), CvType.CV_32SC1); for (int i = 0; i < 10; i++) { seeds.put(((int) Math.random()) % target.rows(), ((int) Math.random()) % target.cols(), i); } Imgproc.watershed(target, seeds); // Imgproc.threshold(target,target, 50, 155, Imgproc.THRESH_BINARY ); return target; }
private Mat rotateImage(Mat src, double angle) { Point center = new Point(src.cols() / 2, src.rows() / 2); double scale = 1.0; Mat rotateMat = Imgproc.getRotationMatrix2D(center, angle, scale); Mat dst = new Mat(); Size frameSize = new Size(src.rows(), src.cols()); // adjust dst center point double m[] = new double[6]; rotateMat.get(0, 0, m); m[2] += (frameSize.width - src.cols()) / 2; m[5] += (frameSize.height - src.rows()) / 2; rotateMat.put(0, 0, m); Imgproc.warpAffine( src, dst, rotateMat, frameSize, Imgproc.INTER_LINEAR, Imgproc.BORDER_CONSTANT, Scalar.all(0)); return dst; }
public Mat onCameraFrame(Mat inputFrame) { inputFrame.copyTo(mRgba); Point center = new Point(mRgba.width() / 2, mRgba.height() / 2); double angle = -90; double scale = 1.0; Mat mapMatrix = Imgproc.getRotationMatrix2D(center, angle, scale); Imgproc.warpAffine(mRgba, mGrayMat, mapMatrix, mRgba.size(), Imgproc.INTER_LINEAR); return mGrayMat; }
/** * Rotate a Mat by the specified degree * * @param src The source Mat * @param angle The angle by which to rotate by * @return The rotated Mat */ public static Mat rotate(Mat src, double angle) { int len = src.cols() > src.rows() ? src.cols() : src.rows(); Point pt = new Point(len / 2.0, len / 2.0); Mat r = Imgproc.getRotationMatrix2D(pt, angle, 1.0); Mat dst = new Mat(); Imgproc.warpAffine(src, dst, r, new Size(len, len)); return dst; }
/** * @param source * @param size * @param delta * @return Mat */ public static Mat Laplacian(Mat source, int size, int delta) { int ddepth = CvType.CV_16S; Mat abs_dst, dst; Imgproc.GaussianBlur(source, source, new Size(3.0, 3.0), 0); Imgproc.GaussianBlur(source, source, new Size(3, 3), 0, 0, Imgproc.BORDER_DEFAULT); // cvtColor( src, gray, CV_RGB2GRAY ); /// Apply Laplace function Imgproc.Laplacian(source, source, CvType.CV_16S, size, 1, delta, Imgproc.BORDER_DEFAULT); return source; }
/** * @param image * @param size * @return Mat */ public static Mat cannyDetection(Mat image, int size) { Mat grayImage = new Mat(); Mat detectedEdges = new Mat(); // convert to grayscale Imgproc.cvtColor(image, grayImage, Imgproc.COLOR_BGR2GRAY); // reduce noise with a 3x3 kernel Imgproc.blur(grayImage, detectedEdges, new Size(3, 3)); // canny detector, with ratio of lower:upper threshold of 3:1 Imgproc.Canny(detectedEdges, detectedEdges, size, size / 3, 7, false); return detectedEdges; }
private static Bitmap imgtrafo( Bitmap image1, Bitmap image2, int p1_x, int p1_y, int p2_x, int p2_y, int p3_x, int p3_y, int p4_x, int p4_y) { // set output size same size as input int resultWidth = image1.getWidth(); int resultHeight = image1.getHeight(); Mat inputMat = new Mat(image1.getWidth(), image1.getHeight(), CvType.CV_32FC1); Utils.bitmapToMat(image1, inputMat); Mat outputMat = new Mat(resultWidth, resultHeight, CvType.CV_32FC1); Point ocvPIn1 = new Point(p1_x, p1_y); Point ocvPIn2 = new Point(p2_x, p2_y); Point ocvPIn3 = new Point(p3_x, p3_y); Point ocvPIn4 = new Point(p4_x, p4_y); List<Point> source = new ArrayList<Point>(); source.add(ocvPIn1); source.add(ocvPIn2); source.add(ocvPIn3); source.add(ocvPIn4); Mat inputQuad = Converters.vector_Point2f_to_Mat(source); Point ocvPOut1 = new Point(256, 40); // manually set Point ocvPOut2 = new Point(522, 62); Point ocvPOut3 = new Point(455, 479); Point ocvPOut4 = new Point(134, 404); List<Point> dest = new ArrayList<Point>(); dest.add(ocvPOut1); dest.add(ocvPOut2); dest.add(ocvPOut3); dest.add(ocvPOut4); Mat outputQuad = Converters.vector_Point2f_to_Mat(dest); Mat perspectiveTransform = Imgproc.getPerspectiveTransform(inputQuad, outputQuad); Imgproc.warpPerspective( inputMat, outputMat, perspectiveTransform, new Size(resultWidth, resultHeight)); // ? Bitmap output = Bitmap.createBitmap(resultWidth, resultHeight, Bitmap.Config.RGB_565); Utils.matToBitmap(outputMat, output); return output; }
public boolean hasChanges(Mat current) { int PIXEL_DIFF_THRESHOLD = 5; int IMAGE_DIFF_THRESHOLD = 5; Mat bg = new Mat(); Mat cg = new Mat(); Mat diff = new Mat(); Mat tdiff = new Mat(); Imgproc.cvtColor(base, bg, Imgproc.COLOR_BGR2GRAY); Imgproc.cvtColor(current, cg, Imgproc.COLOR_BGR2GRAY); Core.absdiff(bg, cg, diff); Imgproc.threshold(diff, tdiff, PIXEL_DIFF_THRESHOLD, 0.0, Imgproc.THRESH_TOZERO); if (Core.countNonZero(tdiff) <= IMAGE_DIFF_THRESHOLD) { return false; } Imgproc.threshold(diff, diff, PIXEL_DIFF_THRESHOLD, 255, Imgproc.THRESH_BINARY); Imgproc.dilate(diff, diff, new Mat()); Mat se = Imgproc.getStructuringElement(Imgproc.MORPH_ELLIPSE, new Size(5, 5)); Imgproc.morphologyEx(diff, diff, Imgproc.MORPH_CLOSE, se); List<MatOfPoint> points = new ArrayList<MatOfPoint>(); Mat contours = new Mat(); Imgproc.findContours(diff, points, contours, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); int n = 0; for (Mat pm : points) { log(lvl, "(%d) %s", n++, pm); printMatI(pm); } log(lvl, "contours: %s", contours); printMatI(contours); return true; }
public void processFrame(CameraEvents.Frame frameEvent) { if (service.getActivityMode() != ActivityEvent.Mode.WARP) return; if (mode == Mode.SAMPLEWARPPLANE || mode == Mode.SAMPLEWARPGLASS) { synchronized (this) { if (!isSetup) setupMatrices(); if (captureSample) { captureSample = false; Log.d(TAG, "Warp: Capturing Sample"); Mat frame = frameEvent.getCameraFrame().getRGB(); byte[] frameJPEG = frameEvent.getCameraFrame().getJPEG(); if (sampleBGR == null || sampleBGR.height() != frame.height() || sampleBGR.width() != frame.width()) sampleBGR = new Mat(frame.rows(), frame.cols(), CvType.CV_8UC3); Imgproc.cvtColor(frame, sampleBGR, Imgproc.COLOR_RGB2BGR); useSample = true; // TODO: Specialize it for this group/device com.dappervision.wearscript.Utils.eventBusPost( new SendEvent("warpsample", "", ValueFactory.createRawValue(frameJPEG))); } } } if (busy) return; synchronized (this) { busy = true; if (!isSetup) setupMatrices(); if (mode == Mode.CAM2GLASS) { Mat inputBGR; Mat frame = frameEvent.getCameraFrame().getRGB(); if (frameBGR == null || frameBGR.height() != frame.height() || frameBGR.width() != frame.width()) frameBGR = new Mat(frame.rows(), frame.cols(), CvType.CV_8UC3); Mat hSmallToGlassMat = getHSmallToGlassMat(frame.rows(), frame.cols()); if (hSmallToGlassMat == null) { Log.w(TAG, "Warp: Bad size"); busy = false; return; } Imgproc.cvtColor(frame, frameBGR, Imgproc.COLOR_RGB2BGR); inputBGR = frameBGR; Imgproc.warpPerspective( inputBGR, frameWarp, hSmallToGlassMat, new Size(frameWarp.width(), frameWarp.height())); drawFrame(frameWarp); } busy = false; } }
public Mat convertImageToBlackWhite(Mat imageMat, boolean applyGaussBlur) { Mat imageCloneMat = imageMat.clone(); if (applyGaussBlur) { Imgproc.GaussianBlur(imageCloneMat, imageCloneMat, new Size(3, 3), 0, 0); } double thresh = Imgproc.threshold( imageCloneMat, imageCloneMat, 0, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU); Imgproc.threshold(imageCloneMat, imageCloneMat, thresh, 255, Imgproc.THRESH_BINARY_INV); return (imageCloneMat); }
private void displayMarkersDebug(Mat imgMat, Scalar contourColor, Scalar codesColor) { ArrayList<MatOfPoint> components = new ArrayList<MatOfPoint>(); Mat hierarchy = new Mat(); DtouchMarker marker = new DtouchMarker(); boolean markerFound = findMarkers(imgMat, marker, components, hierarchy); if (markerFound) { String code = codeArrayToString(marker.getCode()); Point codeLocation = new Point(imgMat.cols() / 4, imgMat.rows() / 8); Core.putText(mRgba, code, codeLocation, Core.FONT_HERSHEY_COMPLEX, 1, codesColor, 3); Imgproc.drawContours( mRgba, components, marker.getComponentIndex(), contourColor, 3, 8, hierarchy, 2, new Point(0, 0)); } if (components != null) components.clear(); if (hierarchy != null) hierarchy.release(); components = null; hierarchy = null; }
public void init_sd_imgs() { try { if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { File sdCardDir = Environment.getExternalStorageDirectory(); String str_sd_dir = sdCardDir.getCanonicalPath(); String str_path = str_sd_dir + "/andrcvs/"; File dir = new File(str_path); Toast.makeText(MainActivity.this, str_path, Toast.LENGTH_LONG).show(); if (!dir.exists()) { dir.mkdirs(); for (int idx = 0; idx < res_imgs.length; idx++) { Bitmap bmp = BitmapFactory.decodeResource(getResources(), res_imgs[idx]); Mat mat_rgb = new Mat(); Utils.bitmapToMat(bmp, mat_rgb); String str_idx = String.format("%04d", idx + 1); String str_fn = str_path + "image_" + str_idx + ".jpg"; Imgproc.cvtColor(mat_rgb, mat_rgb, Imgproc.COLOR_BGR2RGB); Imgcodecs.imwrite(str_fn, mat_rgb); } } } } catch (Exception e) { e.printStackTrace(); } }
@Override public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) { // Imgproc.bilateralFilter(inputFrame.gray(), inputFrame.rgba(), 9, 75, 75); /* if (captureBackground) { captureBackground = false; background = new Mat(inputFrame.gray(), new Rect(0, 0, inputFrame.gray().width(), inputFrame.gray().height())); } if (background == null) { return inputFrame.rgba(); } return background;*/ background = inputFrame.gray(); Imgproc.cvtColor(background, mRgb, Imgproc.COLOR_GRAY2RGB); /*Imgproc.erode(mFGMask, mFGMask, new Mat()); Imgproc.dilate(mFGMask, mFGMask, new Mat()); Imgproc.findContours(mFGMask, contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_NONE); Imgproc.drawContours(mRgb, contours, -1, new Scalar(255, 0, 0), 2);*/ return mRgb; }
public static void main(String[] args) { try { System.loadLibrary(Core.NATIVE_LIBRARY_NAME); File input = new File("traffic_signal.jpg"); BufferedImage image = ImageIO.read(input); byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData(); Mat mat = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC3); mat.put(0, 0, data); Mat mat1 = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC1); Imgproc.cvtColor(mat, mat1, Imgproc.COLOR_RGB2GRAY); byte[] data1 = new byte[mat1.rows() * mat1.cols() * (int) (mat1.elemSize())]; mat1.get(0, 0, data1); BufferedImage image1 = new BufferedImage(mat1.cols(), mat1.rows(), BufferedImage.TYPE_BYTE_GRAY); image1.getRaster().setDataElements(0, 0, mat1.cols(), mat1.rows(), data1); File ouptut = new File("output\\grayscale_" + new Date().getTime() + ".jpg"); ImageIO.write(image1, "jpg", ouptut); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); } }
/** * Process the given Mat, finding, classifying and displaying all resistors present. * * @param originalImg The image to parse */ private void parseImage(Mat originalImg) { Mat workingCopy = new Mat(); originalImg.copyTo(workingCopy); // blur the original image to form resistor blobs. should remove white/silver/grey bands which // would otherwise // get picked up as part of the background, leads or shadows. Mat blurred = new Mat(); // Imgproc.medianBlur(workingCopy, blurred, 29); Imgproc.blur(workingCopy, blurred, new Size(20, 20)); // faster // get a mask off the background Mat resistorMask = new Mat(); generateResistorMask(blurred, Imgproc.THRESH_BINARY).copyTo(resistorMask); // find countours in mask List<MatOfPoint> contours = getContours(resistorMask, originalImg, true); // extract resistors in input image List<Resistor> resistors = extractResistorsFromContours(contours, originalImg, true); // segment and extract colour bands for each resistor extractColourBandsAndClassify(resistors, true); // calculate and display resistance value for each resistor based on classified colour bands calculateAndDisplayResistanceValues(resistors); }
private void createFigureBitmap() { if (mFigureBitmap != null) { mFigureBitmap.recycle(); } // ビットマップ用意 String targetPngFileUri = Camera72Utils.getTargetPngFileFullPath(mDirectory, mCurTarget); mFigureBitmap = BitmapFactory.decodeFile(targetPngFileUri, mOpt); // 抜き出しまだな場合 if (mFigureBitmap == null) { Utils.showToast(mContext, R.string.not_extract_message); String targetJpgFileUri = Camera72Utils.getFgJpgFileFullPath(mDirectory, mCurTarget); mFigureBitmap = BitmapFactory.decodeFile(targetJpgFileUri, mOpt); } Log.i(TAG, "targetPngFile = " + targetPngFileUri); // OpenCV用オブジェクトを用意 Mat mat = new Mat(mFigureBitmap.getHeight(), mFigureBitmap.getWidth(), CvType.CV_8UC4); org.opencv.android.Utils.bitmapToMat(mFigureBitmap, mat); // OpenCVで明るさ調整する Core.convertScaleAbs(mat, mat, mCvBrightScalar, 0); // OpenCVでぼかし調整する Imgproc.GaussianBlur(mat, mat, mCvGaussianSize, 0); // Bitmapに戻す org.opencv.android.Utils.matToBitmap(mat, mFigureBitmap); }
public void run() { do { synchronized (JavaCameraView.this) { try { JavaCameraView.this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (!mStopThread) { switch (mPreviewFormat) { case Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA: Imgproc.cvtColor(mBaseMat, mFrameChain[mChainIdx], Imgproc.COLOR_YUV2RGBA_NV21, 4); break; case Highgui.CV_CAP_ANDROID_GREY_FRAME: mFrameChain[mChainIdx] = mBaseMat.submat(0, mFrameHeight, 0, mFrameWidth); break; default: Log.e(TAG, "Invalid frame format! Only RGBA and Gray Scale are supported!"); } ; if (!mFrameChain[mChainIdx].empty()) deliverAndDrawFrame(mFrameChain[mChainIdx]); mChainIdx = 1 - mChainIdx; } } while (!mStopThread); Log.d(TAG, "Finish processing thread"); }
public MarkerTracker(Mat image, Mat template) { this.image = image; this.template = template; Log.i("Marker-Tracker", "image is null?::" + (null == image)); imgGray = new Mat(image.size(), image.type()); templGray = new Mat(template.size(), template.type()); // Convert them to grayscale Imgproc.cvtColor(image, imgGray, Imgproc.COLOR_BGRA2GRAY); // Core.normalize(imgGray, imgGray, 0, 255, Core.NORM_MINMAX); // Mat grayImage02 = new Mat(image02.rows(), image02.cols(), image02.type()); Imgproc.cvtColor(template, templGray, Imgproc.COLOR_BGRA2GRAY); // Core.normalize(templGray, templGray, 0, 255, Core.NORM_MINMAX); }
private Scalar converScalarHsv2Rgba(Scalar hsvColor) { Mat pointMatRgba = new Mat(); Mat pointMatHsv = new Mat(1, 1, CvType.CV_8UC3, hsvColor); Imgproc.cvtColor(pointMatHsv, pointMatRgba, Imgproc.COLOR_HSV2RGB_FULL, 4); return new Scalar(pointMatRgba.get(0, 0)); }
@Override protected Void doInBackground(Void... params) { publishProgress(0); Mat hsvImg = heatmap(data, progressDialog); Mat finishedImage = new Mat(); Imgproc.cvtColor(hsvImg, finishedImage, Imgproc.COLOR_HSV2BGR); File mediaStorageDir = new File(Environment.getExternalStorageDirectory().getPath(), "images/Colored_Images"); if (!mediaStorageDir.exists()) { if (!mediaStorageDir.mkdirs()) { Log.e(TAG, "failed to create directory"); return null; } } String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); Log.v( TAG, "SAVING: " + mediaStorageDir.getPath() + File.separator + "scan_" + timeStamp + ".jpg"); Highgui.imwrite( mediaStorageDir.getPath() + File.separator + "scan_" + timeStamp + ".jpg", finishedImage); return null; }
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.CV_8UC3); 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.COLOR_HSV2RGB_FULL, 4); }
public Mat onCameraFrame(CvCameraViewFrame inputFrame) { frame = inputFrame.rgba(); outputFrame = frame.clone(); if (homography != null) { if (markerValue != -1 && markerValue != oldMarkerValue) { oldMarkerValue = markerValue; outputLogo = logo.clone(); Core.putText( outputLogo, Integer.toString(markerValue), new Point(5, 505), Core.FONT_HERSHEY_SIMPLEX, 5, new Scalar(255, 0, 0), 5); } Imgproc.warpPerspective( outputLogo, outputFrame, homography, new Size(WIDTH, HEIGHT), Imgproc.INTER_NEAREST, Imgproc.BORDER_TRANSPARENT, new Scalar(0)); } return outputFrame; }
@Override public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) { mRgba = inputFrame.rgba(); Imgproc.cvtColor(mRgba, grayScaleImage, Imgproc.COLOR_RGBA2RGB); MatOfRect faces = new MatOfRect(); // detect faces if (cascadeClassifier != null) { cascadeClassifier.detectMultiScale( grayScaleImage, faces, 1.1, 2, 2, new Size(absoluteFaceSize, absoluteFaceSize), new Size()); } Rect[] facesArray = faces.toArray(); for (int i = 0; i < facesArray.length; i++) Core.rectangle(mRgba, facesArray[i].tl(), facesArray[i].br(), new Scalar(0, 255, 0, 255), 3); if (facesArray.length > 0) { facesInASecond.add(true); } else { facesInASecond.add(false); } return mRgba; }
/** * @param source * @param delta * @return Mat */ public static Mat Sobel(Mat source, int delta) { Mat grey = new Mat(); Imgproc.cvtColor(source, grey, Imgproc.COLOR_BGR2GRAY); Mat sobelx = new Mat(); Imgproc.Sobel(grey, sobelx, CvType.CV_32F, 1, delta); double minVal, maxVal; Core.MinMaxLocResult minMaxLocResult = Core.minMaxLoc(sobelx); minVal = minMaxLocResult.minVal; maxVal = minMaxLocResult.maxVal; Mat draw = new Mat(); sobelx.convertTo( draw, CvType.CV_8U, 255.0 / (maxVal - minVal), -minVal * 255.0 / (maxVal - minVal)); return draw; }