在opencv中使用android手機相機？

Question

是否可以通過USB電纜將手機連接到電腦並將其用作網絡攝像頭？我知道有很多軟件允許它（至少用於無線），但是如何在opencv中使用它（我正在使用Java）？

Answer 1

我認爲這是可能的，但是我沒有測試它。首先下載這樣一個應用程序，該應用程序允許將您的手機用作網絡攝像頭，然後通過VideoCapture（0）連接到它，如果它是連接到您系統的唯一網絡攝像頭。此代碼應該適合測試，如果一切正常，您應該在JFrame中看到視頻：

import java.awt.Color; 
import java.awt.Graphics; 
import java.awt.Image; 
import java.awt.event.KeyEvent; 
import java.awt.event.KeyListener; 
import java.awt.image.BufferedImage; 
import java.awt.image.DataBufferByte; 
import java.awt.image.WritableRaster; 
import java.io.ByteArrayInputStream; 
import java.io.File; 
import java.io.InputStream; 

import javax.imageio.ImageIO; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 

import org.opencv.core.*; 
import org.opencv.highgui.Highgui;   
import org.opencv.highgui.VideoCapture;   

public class JPanelOpenCV extends JPanel{ 

    BufferedImage image; 

    public static void main (String args[]) throws InterruptedException{ 
     System.loadLibrary(Core.NATIVE_LIBRARY_NAME); 

     JPanelOpenCV t = new JPanelOpenCV(); 
     VideoCapture camera = new VideoCapture(0); 

     Mat frame = new Mat(); 
     camera.read(frame); 

     if(!camera.isOpened()){ 
      System.out.println("Error"); 
     } 
     else {     
      while(true){   

       if (camera.read(frame)){ 

        BufferedImage image = t.MatToBufferedImage(frame); 

        t.window(image, "Original Image", 0, 0); 

        t.window(t.grayscale(image), "Processed Image", 40, 60); 

        //t.window(t.loadImage("ImageName"), "Image loaded", 0, 0); 

        break; 
       } 
      } 
     } 
     camera.release(); 
    } 

    @Override 
    public void paint(Graphics g) { 
     g.drawImage(image, 0, 0, this); 
    } 

    public JPanelOpenCV() { 
    } 

    public JPanelOpenCV(BufferedImage img) { 
     image = img; 
    } 

    //Show image on window 
    public void window(BufferedImage img, String text, int x, int y) { 
     JFrame frame0 = new JFrame(); 
     frame0.getContentPane().add(new JPanelOpenCV(img)); 
     frame0.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     frame0.setTitle(text); 
     frame0.setSize(img.getWidth(), img.getHeight() + 30); 
     frame0.setLocation(x, y); 
     frame0.setVisible(true); 
    } 

    //Load an image 
    public BufferedImage loadImage(String file) { 
     BufferedImage img; 

     try { 
      File input = new File(file); 
      img = ImageIO.read(input); 

      return img; 
     } catch (Exception e) { 
      System.out.println("erro"); 
     } 

     return null; 
    } 

    //Save an image 
    public void saveImage(BufferedImage img) {   
     try { 
      File outputfile = new File("Images/new.png"); 
      ImageIO.write(img, "png", outputfile); 
     } catch (Exception e) { 
      System.out.println("error"); 
     } 
    } 

    //Grayscale filter 
    public BufferedImage grayscale(BufferedImage img) { 
     for (int i = 0; i < img.getHeight(); i++) { 
      for (int j = 0; j < img.getWidth(); j++) { 
       Color c = new Color(img.getRGB(j, i)); 

       int red = (int) (c.getRed() * 0.299); 
       int green = (int) (c.getGreen() * 0.587); 
       int blue = (int) (c.getBlue() * 0.114); 

       Color newColor = 
         new Color(
         red + green + blue, 
         red + green + blue, 
         red + green + blue); 

       img.setRGB(j, i, newColor.getRGB()); 
      } 
     } 

     return img; 
    } 

    public BufferedImage MatToBufferedImage(Mat frame) { 
     //Mat() to BufferedImage 
     int type = 0; 
     if (frame.channels() == 1) { 
      type = BufferedImage.TYPE_BYTE_GRAY; 
     } else if (frame.channels() == 3) { 
      type = BufferedImage.TYPE_3BYTE_BGR; 
     } 
     BufferedImage image = new BufferedImage(frame.width(), frame.height(), type); 
     WritableRaster raster = image.getRaster(); 
     DataBufferByte dataBuffer = (DataBufferByte) raster.getDataBuffer(); 
     byte[] data = dataBuffer.getData(); 
     frame.get(0, 0, data); 

     return image; 
    } 

} 

P.S.我認爲你的問題也是無關緊要的。

Answer 2

您可以簡單地創建相機活動和編寫代碼給出

package com.techamongus.opencvcamera; 

import android.annotation.SuppressLint; 
import android.app.Activity; 
import android.content.ContentValues; 
import android.content.Intent; 
import android.hardware.Camera; 
import android.net.Uri; 
import android.os.Build; 
import android.os.Bundle; 
import android.os.Environment; 
import android.provider.MediaStore; 
import android.support.v7.app.ActionBarActivity; 
import android.util.Log; 
import android.view.Menu; 
import android.view.MenuItem; 
import android.view.SubMenu; 
import android.view.Window; 
import android.view.WindowManager; 
import android.widget.Toast; 

import org.opencv.android.BaseLoaderCallback; 
import org.opencv.android.CameraBridgeViewBase; 
import org.opencv.android.JavaCameraView; 
import org.opencv.android.LoaderCallbackInterface; 
import org.opencv.android.OpenCVLoader; 
import org.opencv.core.Core; 
import org.opencv.core.Mat; 
import org.opencv.imgcodecs.Imgcodecs; 
import org.opencv.imgproc.Imgproc; 

import java.io.File; 
import java.util.List; 

public class CameraActivity extends Activity implements CameraBridgeViewBase.CvCameraViewListener2 { 

    // A tag for log output. 
    private static final String TAG = 
      CameraActivity.class.getSimpleName(); 
    // A key for storing the index of the active camera. 
    private static final String STATE_CAMERA_INDEX = "cameraIndex"; 
    // A key for storing the index of the active image size. 
    private static final String STATE_IMAGE_SIZE_INDEX = 
      "imageSizeIndex"; 
    // An ID for items in the image size submenu. 
    private static final int MENU_GROUP_ID_SIZE = 2; 
    // The index of the active camera. 
    private int mCameraIndex; 
    // The index of the active image size. 
    private int mImageSizeIndex; 
    // Whether the active camera is front-facing. 
    // If so, the camera view should be mirrored. 
    private boolean mIsCameraFrontFacing; 
    // The number of cameras on the device. 
    private int mNumCameras; 
    // The camera view. 
    private CameraBridgeViewBase mCameraView; 
    // The image sizes supported by the active camera. 
    private List<Camera.Size> mSupportedImageSizes; 
    // Whether the next camera frame should be saved as a photo. 
    private boolean mIsPhotoPending; 
    // A matrix that is used when saving photos. 
    private Mat mBgr; 
    // Whether an asynchronous menu action is in progress. 
    // If so, menu interaction should be disabled. 
    private boolean mIsMenuLocked; 
    // The OpenCV loader callback. 
    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) { 
     @Override 
     public void onManagerConnected(final int status) { 
      switch (status) { 
       case LoaderCallbackInterface.SUCCESS: 
        Log.d(TAG, "OpenCV loaded successfully"); 
        mCameraView.enableView(); 
        mBgr = new Mat(); 
        break; 
       default: 
        super.onManagerConnected(status); 
        break; 
      } 
     } 

    }; 
    @SuppressLint("NewApi") 
    @Override 
    protected void onCreate(final Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     final Window window = getWindow(); 
     window.addFlags(
       WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); 
     if (savedInstanceState != null) { 
      mCameraIndex = savedInstanceState.getInt(
        STATE_CAMERA_INDEX, 0); 
      mImageSizeIndex = savedInstanceState.getInt(
        STATE_IMAGE_SIZE_INDEX, 0); 
     } else { 
      mCameraIndex = 0; 
      mImageSizeIndex = 0; 
     } 
     final Camera camera; 
     if (Build.VERSION.SDK_INT >= 
       Build.VERSION_CODES.GINGERBREAD) { 
      Camera.CameraInfo cameraInfo = new Camera.CameraInfo(); 
      Camera.getCameraInfo(mCameraIndex, cameraInfo); 
      mIsCameraFrontFacing = 
        (cameraInfo.facing == 
          Camera.CameraInfo.CAMERA_FACING_FRONT); 
      mNumCameras = Camera.getNumberOfCameras(); 
      camera = Camera.open(mCameraIndex); 
     } else { // pre-Gingerbread 
      // Assume there is only 1 camera and it is rear-facing. 
      mIsCameraFrontFacing = false; 
      mNumCameras = 1; 
      camera = Camera.open(); 
     } 
     final Camera.Parameters parameters = camera.getParameters(); 
     camera.release(); 
     mSupportedImageSizes = 
       parameters.getSupportedPreviewSizes(); 
     final Camera.Size size = mSupportedImageSizes.get(mImageSizeIndex); 
     mCameraView = new JavaCameraView(this, mCameraIndex); 
     mCameraView.setMaxFrameSize(size.width, size.height); 
     mCameraView.setCvCameraViewListener(this); 
     setContentView(mCameraView); 
    } 
    public void onSaveInstanceState(Bundle savedInstanceState) { 
     // Save the current camera index. 
     savedInstanceState.putInt(STATE_CAMERA_INDEX, mCameraIndex); 
     // Save the current image size index. 
     savedInstanceState.putInt(STATE_IMAGE_SIZE_INDEX, 
       mImageSizeIndex); 
     super.onSaveInstanceState(savedInstanceState); 
    } 
    @SuppressLint("NewApi") 
    @Override 
    public void recreate() { 
     if (Build.VERSION.SDK_INT >= 
       Build.VERSION_CODES.HONEYCOMB) { 
      super.recreate(); 
     } else { 
      finish(); 
      startActivity(getIntent()); 
     } 
    } 
    @Override 
    public void onPause() { 
     if (mCameraView != null) { 
      mCameraView.disableView(); 
     } 
     super.onPause(); 
    } 
    @Override 
    public void onResume() { 
     super.onResume(); 
     OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_2_0, 
       this, mLoaderCallback); 
     mIsMenuLocked = false; 
    } 
    @Override 
    public void onDestroy() { 
     if (mCameraView != null) { 
      mCameraView.disableView(); 
     } 
     super.onDestroy(); 
    } 
    public Mat onCameraFrame(final CameraBridgeViewBase.CvCameraViewFrame inputFrame) { 
     final Mat rgba = inputFrame.rgba(); 
     if (mIsPhotoPending) { 
      mIsPhotoPending = false; 
      //takePhoto(rgba); 
     } 
     if (mIsCameraFrontFacing) { 
      // Mirror (horizontally flip) the preview. 
      Core.flip(rgba, rgba, 1); 
     } 
     return rgba; 
    } 

免責聲明：檢查我的博客鏈接 http://www.techamongus.com/2017/03/android-camera-in-opencv.html