android एंड्रॉइड एप्लिकेशन में किसी ऑब्जेक्ट का रंग बदलना




opencv image-processing (3)

मेरा मानना ​​है कि आपने ग्रेस्केल छवि को रंगीन छवि में स्थानांतरित करने में त्रुटि की है।

आज़माएं: Imgproc.cvtColor(mRgba, mIntermediateMat, Imgproc.COLOR_YUV2RGBA_NV21, 4); इसके बजाय: Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_YUV2RGBA_NV21, 4);

मूल रूप से मेरा लक्ष्य पेंट एप्लिकेशन के लिए वास्तविक समय में ऑब्जेक्ट का रंग बदल जाता है। इस लक्ष्य को प्राप्त करने के लिए मैं निम्नलिखित अवधारणाओं का पालन करता हूं:

  1. मैंने वस्तु खोजने के लिए canny() विधि का उपयोग किया है।
  2. किनारे का पता लगाने के लिए findContours() का उपयोग करना।
  3. ऑब्जेक्ट को रंगने के लिए drawContours() का उपयोग drawContours()

यदि लक्ष्य प्राप्त करने के लिए आवश्यक कोई अन्य अवधारणा है तो कृपया मुझे सुझाव दें। मैंने कोशिश की है लेकिन सटीक समोच्च किनारे नहीं मिल रहा है।

मूल इनपुट:

अपेक्षित उत्पादन:

मौजूदा उत्पादन:

मुझे ग्रे स्केल में छवि मिल रही है लेकिन मैं आरजीबी मोड में चाहता हूं।

मेरा कोड यहाँ है:

package com.example.imageprocess;

import java.util.ArrayList;
import java.util.List;

import org.opencv.android.BaseLoaderCallback;
import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
import org.opencv.android.LoaderCallbackInterface;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgproc.Imgproc;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.WindowManager;

public class MainActivity extends Activity implements CvCameraViewListener2 {

        private Mat                    mRgba;
        private Mat                    mIntermediateMat;
        private Mat                    mGray;

        private CameraBridgeViewBase   mOpenCvCameraView;

        private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
            @Override
            public void onManagerConnected(int status) {
                switch (status) {
                    case LoaderCallbackInterface.SUCCESS:
                    {
                        Log.i("OPENCVACTIVITY", "OpenCV loaded successfully");

                        // Load native library after(!) OpenCV initialization
                       // System.loadLibrary("mixed_sample");

                        mOpenCvCameraView.enableView();
                    } break;
                    default:
                    {
                        super.onManagerConnected(status);
                    } break;
                }
            }
        };

       /* public MainActivity() {
            Log.i("OPENCVACTIVITY", "Instantiated new " + this.getClass());
        }
*/
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
          getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

            setContentView(R.layout.activity_main);

            mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.tutorial2_activity_surface_view);
            mOpenCvCameraView.setCvCameraViewListener(this);
    }



    @Override
    public void onPause()
    {
        super.onPause();
        if (mOpenCvCameraView != null)
            mOpenCvCameraView.disableView();
    }

    @Override
    public void onResume()
    {
        super.onResume();
        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this, mLoaderCallback);
    }

    public void onDestroy() {
        super.onDestroy();
        if (mOpenCvCameraView != null)
            mOpenCvCameraView.disableView();
    }

    @Override
    public void onCameraViewStarted(int width, int height) {
        // TODO Auto-generated method stub
         mRgba = new Mat(height, width, CvType.CV_8UC4);
            mIntermediateMat = new Mat(height, width, CvType.CV_8UC4);
            mGray = new Mat(height, width, CvType.CV_8UC1);

    }

    @Override
    public void onCameraViewStopped() {
         mRgba.release();
            mGray.release();
            mIntermediateMat.release();

    }

    @Override
    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
        Mat gaussian_output = new Mat();
         mRgba = inputFrame.rgba();
         Imgproc.Canny(inputFrame.gray(), mIntermediateMat, 80, 100);
         Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_YUV2RGBA_NV21, 4);
         Imgproc.GaussianBlur(mIntermediateMat, gaussian_output, new Size(5, 5), 5);
         List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
         Imgproc.findContours( gaussian_output, contours, new Mat(),Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE, new Point(0,0) );
         Scalar color = new Scalar(165, 30, 215);
        // Imgproc.drawContours(gaussian_output, contours, -1, color, 3);
         Mat hierarchy = new Mat();
      // find contours:
      Imgproc.findContours(gaussian_output, contours, hierarchy, Imgproc.RETR_TREE,Imgproc.CHAIN_APPROX_SIMPLE);
      for (int contourIdx = 0; contourIdx < contours.size(); contourIdx++) {
          Imgproc.drawContours(gaussian_output, contours, contourIdx,color, -1);
      }

        return gaussian_output;
    }


}

http://www.labbookpages.co.uk/software/imgProc/libPNG.html

आपको छवि प्रसंस्करण के लिए LIBPNG का उपयोग करना चाहिए। इसका उपयोग करके आप इसे रंग मैट्रिक्स सेट करके ग्रेस्केल या रंगीन छवि में परिवर्तित कर सकते हैं।


पार्टी के लिए थोड़ा देर हो चुकी है। मैंने कोड को आजमाया नहीं है, लेकिन मुझे संदेह है:

mIntermediateMat = new Mat(height, width, CvType.CV_8UC4);

भले ही mIntermediateMat यहां 8 बिट 4 चैनल चटाई है,

Imgproc.Canny(inputFrame.gray(), mIntermediateMat, 80, 100);

इसे यहां 8 बिट 1 चैनल मैट में बदल दिया गया था। रेफरी: कैनी डॉक्टर

आउटपुट एज नक्शा; यह एक ही आकार और छवि के रूप में टाइप करें।

नतीजतन,

Imgproc.GaussianBlur(mIntermediateMat, gaussian_output, new Size(5, 5), 5);

gaussian_output एक 8 बिट 1 चैनल चटाई है, और ...

return gaussian_output;

एक 8 बिट 1 चैनल (ग्रेस्केल) छवि देता है।





edge-detection