Android Studio(java)上のOpenCVを使用して、黒色ピクセルを数える

Question

前提・実現したいこと

Android Studio上でOpenCVを使用してカメラから取得した映像の黒要素とそれ以外に分けて出力
を行い、さらに任意の領域(xy座標を指定するなどして)の黒色ピクセルを数えて
テキストに％表示したいと考えています。

###開発・実行環境
[開発]
Android Studio 4.0.1
MacBook Pro (macOS Mojave ver10.14.6)
-言語-　java

[実行]
OPPO Reno A 128GB

発生している問題・エラーメッセージ

黒要素とそれ以外に分けることはできたのですが
「任意の領域の黒色ピクセルを数える」というところが実現できていません。

「領域」というのが何を指すのか自分自身でも決めきれていません。
xy座標を指定するなどして長方形を描き、その長方形内の黒色の割合を求めれたらと思っています。

該当のソースコード

package com.example.blackline;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.camera.core.Camera;
import androidx.camera.core.CameraSelector;
import androidx.camera.core.ImageAnalysis;
import androidx.camera.core.ImageProxy;
import androidx.camera.core.Preview;
import androidx.camera.lifecycle.ProcessCameraProvider;
import androidx.camera.view.PreviewView;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.lifecycle.LifecycleOwner;

import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.util.Log;
import android.view.Surface;
import android.widget.ImageView;
import android.widget.TextView;

import com.google.common.util.concurrent.ListenableFuture;

import org.opencv.android.Utils;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgproc.Imgproc;
import org.opencv.core.Rect;

import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static org.opencv.core.CvType.CV_8SC3;
import static org.opencv.core.CvType.CV_8UC1;
import static org.opencv.imgproc.Imgproc.medianBlur;

public class MainActivity extends AppCompatActivity {
    /*** Fixed values ***/
    private static final String TAG = "MyApp";
    private int REQUEST_CODE_FOR_PERMISSIONS = 1234;;
    private final String[] REQUIRED_PERMISSIONS = new String[]{"android.permission.CAMERA", "android.permission.WRITE_EXTERNAL_STORAGE"};

    /*** Views ***/
    private PreviewView previewView;
    private ImageView imageView;
    private  TextView textView;
    /*** For CameraX ***/
    private Camera camera = null;
    private Preview preview = null;
    private ImageAnalysis imageAnalysis = null;
    private ExecutorService cameraExecutor = Executors.newSingleThreadExecutor();
    int i = 0;
    int y = 0;
    int x = 0;
    int binary;

    static {
        System.loadLibrary("opencv_java4");
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        previewView = findViewById(R.id.previewView);
        imageView = findViewById(R.id.imageView);
//        textView =findViewById(R.id.textView);

        if (checkPermissions()) {
            startCamera();
        } else {
            ActivityCompat.requestPermissions(this, REQUIRED_PERMISSIONS, REQUEST_CODE_FOR_PERMISSIONS);
        }
    }

    private void startCamera() {
        final ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(this);
        Context context = this;
        cameraProviderFuture.addListener(new Runnable() {
            @Override
            public void run() {
                try {
                    ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
                    preview = new Preview.Builder().build();
                    imageAnalysis = new ImageAnalysis.Builder().build();
                    imageAnalysis.setAnalyzer(cameraExecutor, new MyImageAnalyzer());
                    CameraSelector cameraSelector = new CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build();

                    cameraProvider.unbindAll();
                    camera = cameraProvider.bindToLifecycle((LifecycleOwner)context, cameraSelector, preview, imageAnalysis);
                    preview.setSurfaceProvider(previewView.createSurfaceProvider(camera.getCameraInfo()));
                } catch(Exception e) {
                    Log.e(TAG, "[startCamera] Use case binding failed", e);
                }
            }
        }, ContextCompat.getMainExecutor(this));
    }

    private class MyImageAnalyzer implements ImageAnalysis.Analyzer {
        private Mat matPrevious = null;
        @Override
        public void analyze(@NonNull ImageProxy image) {
            /* Create cv::mat(RGB888) from image(NV21) */
            Mat matOrg = getMatFromImage(image);
            /* Fix image rotation (it looks image in PreviewView is automatically fixed by CameraX???) */
            Mat mat = fixMatRotation(matOrg);
            medianBlur(mat,mat, 5);
//            Mat mat_bin = mat.clone();
//            Mat mat_hsv = mat.clone();
            // ↓ここから黒色とそれ以外に分けています↓
            Imgproc.cvtColor(mat,mat, Imgproc.COLOR_RGBA2BGR);
            Imgproc.cvtColor(mat,mat, Imgproc.COLOR_BGR2HSV);
            Core.inRange(mat, new Scalar(0,0,0), new Scalar(179,128,100),mat);
            Imgproc.cvtColor(mat,mat, Imgproc.COLOR_GRAY2BGRA);
//            Imgproc.rectangle(mat,new Point(200,250),new Point(300,500),new Scalar(76,255,0),2);
            Log.i(TAG, "[analyze] width = " + image.getWidth() + ", height = " + image.getHeight() + "Rotation = " + previewView.getDisplay().getRotation());
            Log.i(TAG, "[analyze] mat width = " + matOrg.cols() + ", mat height = " + matOrg.rows());

            /* Do some image processing */
//            Mat matOutput = new Mat(mat.rows(), mat.cols(), mat.type());
//            if (matPrevious == null) matPrevious = mat;
//            Core.absdiff(mat, matPrevious, matOutput);
//            matPrevious = mat;

            /* Draw something for test */
            Imgproc.rectangle(mat, new Rect(10, 10, 100, 100), new Scalar(255, 0, 0));
//            Imgproc.putText(mat, "mat",new Point(100,100), 10, 10, new Scalar(255, 0, 0));
            /* Convert cv::mat to bitmap for drawing*/
            Bitmap bitmap = Bitmap.createBitmap(mat.cols(),mat.rows(),Bitmap.Config.ARGB_8888);
            Utils.matToBitmap(mat,bitmap);
　　　　　　　//↑ここまで黒色とそれ以外に分けています↑
            /* Display the result onto ImageView */
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    imageView.setImageBitmap(bitmap);
                }
            });

            /* Close the image otherwise, this function is not called next time */
            image.close();
        }

        private Mat getMatFromImage(ImageProxy image) {
            /* https://stackoverflow.com/questions/30510928/convert-android-camera2-api-yuv-420-888-to-rgb */
            ByteBuffer yBuffer = image.getPlanes()[0].getBuffer();
            ByteBuffer uBuffer = image.getPlanes()[1].getBuffer();
            ByteBuffer vBuffer = image.getPlanes()[2].getBuffer();
            int ySize = yBuffer.remaining();
            int uSize = uBuffer.remaining();
            int vSize = vBuffer.remaining();
            byte[] nv21 = new byte[ySize + uSize + vSize];
            yBuffer.get(nv21, 0, ySize);
            vBuffer.get(nv21, ySize, vSize);
            uBuffer.get(nv21, ySize + vSize, uSize);
            Mat yuv = new Mat(image.getHeight() + image.getHeight() / 2, image.getWidth(), CV_8UC1);
            yuv.put(0, 0, nv21);
            Mat mat = new Mat();
            Imgproc.cvtColor(yuv, mat, Imgproc.COLOR_YUV2RGB_NV21, 3);
            return mat;
        }

        private Mat fixMatRotation(Mat matOrg) {
            Mat mat;
            switch (previewView.getDisplay().getRotation()){
                default:
                case Surface.ROTATION_0:
                    mat = new Mat(matOrg.cols(), matOrg.rows(), matOrg.type());
                    Core.transpose(matOrg, mat);
                    Core.flip(mat, mat, 1);
                    break;
                case Surface.ROTATION_90:
                    mat = matOrg;
                    break;
                case Surface.ROTATION_270:
                    mat = matOrg;
                    Core.flip(mat, mat, -1);
                    break;
            }
            return mat;
        }
    }

    private boolean checkPermissions(){
        for(String permission : REQUIRED_PERMISSIONS){
            if(ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED){
                return false;
            }
        }
        return true;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
//        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if(requestCode == REQUEST_CODE_FOR_PERMISSIONS){
            if(checkPermissions()){
                startCamera();
            } else{
                Log.i(TAG, "[onRequestPermissionsResult] Failed to get permissions");
                this.finish();
            }
        }
    }
}

コメントの「↓ここから黒色とそれ以外に分けています↓」　と　「↑ここまで黒色とそれ以外に分けています↑」
の部分がOpenCVを使った画像処理になります。
多分この続きに黒色ピクセルを数えるという処理を書くのが適切なんだろうとは思っています。

上記の部分以外は、カメラからの映像を出力などに使っているので気にしなくても大丈夫だと思います。

これらのプログラムをスマホに書き込むと以下のような映像が取得できます。

理想は下の白黒映像のどこかに分かりやすく「〇〇ピクセル」のように出力したいと考えています。

Comments

[fana]

> 任意の領域の黒色ピクセルを数える

この話で「領域」とは何を指しますか？

[NieR2B]

修正の依頼ありがとうございます。

投稿内容を修正させていただきましたが、
xy座標を指定するなどして長方形を描き、その長方形内の黒色の割合を求めれたらと思っています。

ご期待に沿う回答だったでしょうか？
また何かあれば修正していくのでご助力の程よろしくお願いします。

Answer 1

OpenCVにcountNonZeroという関数があります．
「黒orNot」というマスク(黒の箇所の画素値が非0で，他が0な絵)が存在するのであれば，とりあえずこの関数で「黒」側の画素数がわかります．

「領域」の与え方が「矩形領域」ならば，まぁこの関数一発で終了でしょう．

「領域」が複雑な形状の場合は，
例えば，その形状のマスク（領域内255,領域外を0とするような絵）を作って「黒orNot」マスクとANDしてからcountNonZeroを使うとかで良いのではないでしょうか．

Comments

[NieR2B]

int pixel = Core.countNonZero(mat);
と書くことで映像全体の黒を数えることはできるようになったと思います。
しかし、矩形領域を与える方法と結果をディスプレイに表示する方法が分からないので止まってしまいました。

[fana]

私はその環境を知らないので，入力系や出力系の話は答えようがないです．

表示に関してはOpenCVの世界で画像に putText() で描いてしまうという手も採れなくはないと思いますが，putText()はフォントや描画できる文字種の制約がきついので，その環境で使える何らかの表示手段を用いる方が良いのかもしれません．

[NieR2B]

返信していただきありがとうございます。
なるほどputText()で描くというのと、環境に合わせた(Android StudioならText Viewかな)数値出力を試していきたいと思います。

あ、矩形領域を与えるのは
Rect roi = new Rect(10, 10, 100,100);
Mat trim = new Mat(mat, roi);
int pixel = Core.countNonZero(trim);
とすることで矩形領域の白黒判別が出来るようになったんですかね？

[fana]

矩形であればそんな感じで部分画像に対して countNonZero すれば良いかと．

[NieR2B]

範囲をかたどることはできたのですが
countNonZeroを入れた時にアプリが強制終了していますようになってしまいました。
多分アプリ立ち上げに時にcountNonZeroを行っているから
とかいう理由だとは思うのですがいかがでしょうか？

難しい質問ならもう一度これだけで質問をし直した方がいいのでしょうか？

[fana]

【本件が処理方法(?)の話であり && その件はとりあえずＯＫで && 現状の強制終了の話というのが処理タイミング関係の話(?)で全く別の話】なのであれば，
(現状の強制終了が起こるコードを提示しての)別質問にした方がよいのかも．