org.opencv.highgui.VideoCapture Maven / Gradle / Ivy


//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.highgui;

import java.lang.String;
import org.opencv.core.Mat;

// C++: class VideoCapture
/**
 * Class for video capturing from video files or cameras.
 * The class provides C++ API for capturing video from cameras or for reading
 * video files. Here is how the class can be used:
 *
 * #include "opencv2/opencv.hpp" 

 *
 * // C++ code:
 *
 * using namespace cv;
 *
 * int main(int, char)
 *
 *
 * VideoCapture cap(0); // open the default camera
 *
 * if(!cap.isOpened()) // check if we succeeded
 *
 * return -1;
 *
 * Mat edges;
 *
 * namedWindow("edges",1);
 *
 * for(;;)
 *
 *
 * Mat frame;
 *
 * cap >> frame; // get a new frame from camera
 *
 * cvtColor(frame, edges, CV_BGR2GRAY);
 *
 * GaussianBlur(edges, edges, Size(7,7), 1.5, 1.5);
 *
 * Canny(edges, edges, 0, 30, 3);
 *
 * imshow("edges", edges);
 *
 * if(waitKey(30) >= 0) break;
 *
 *
 * // the camera will be deinitialized automatically in VideoCapture destructor
 *
 * return 0;
 *
 *
 * Note: In C API the black-box structure CvCapture is used instead
 * of VideoCapture.
 * 
 *
 * Note:
 * 
 *    A basic sample on using the VideoCapture interface can be found at
 * opencv_source_code/samples/cpp/starter_video.cpp
 *   
 Another basic video processing sample can be found at
 * opencv_source_code/samples/cpp/video_dmtx.cpp
 *   
 (Python) A basic sample on using the VideoCapture interface can be
 * found at opencv_source_code/samples/python2/video.py
 *   
 (Python) Another basic video processing sample can be found at
 * opencv_source_code/samples/python2/video_dmtx.py
 *   
 (Python) A multi threaded video processing sample can be found at
 * opencv_source_code/samples/python2/video_threaded.py
 * 
 *
 * @see org.opencv.highgui.VideoCapture
 */
public class VideoCapture {

    protected final long nativeObj;
    protected VideoCapture(long addr) { nativeObj = addr; }


    //
    // C++:   VideoCapture::VideoCapture()
    //

/**
 * VideoCapture constructors.
 *
 * Note: In C API, when you finished working with video, release
 * CvCapture structure with cvReleaseCapture(), or use
 * Ptr that calls cvReleaseCapture()
 * automatically in the destructor.
 *
 * @see org.opencv.highgui.VideoCapture.VideoCapture
 */
    public   VideoCapture()
    {

        nativeObj = VideoCapture_0();

        return;
    }


    //
    // C++:   VideoCapture::VideoCapture(string filename)
    //

/**
 * VideoCapture constructors.
 *
 * Note: In C API, when you finished working with video, release
 * CvCapture structure with cvReleaseCapture(), or use
 * Ptr that calls cvReleaseCapture()
 * automatically in the destructor.
 *
 * @param filename name of the opened video file (eg. video.avi) or image
 * sequence (eg. img_%02d.jpg, which will read samples like img_00.jpg,
 * img_01.jpg, img_02.jpg,...)
 *
 * @see org.opencv.highgui.VideoCapture.VideoCapture
 */
    public   VideoCapture(String filename)
    {

        nativeObj = VideoCapture_1(filename);

        return;
    }


    //
    // C++:   VideoCapture::VideoCapture(int device)
    //

/**
 * VideoCapture constructors.
 *
 * Note: In C API, when you finished working with video, release
 * CvCapture structure with cvReleaseCapture(), or use
 * Ptr that calls cvReleaseCapture()
 * automatically in the destructor.
 *
 * @param device id of the opened video capturing device (i.e. a camera index).
 * If there is a single camera connected, just pass 0.
 *
 * @see org.opencv.highgui.VideoCapture.VideoCapture
 */
    public   VideoCapture(int device)
    {

        nativeObj = VideoCapture_2(device);

        return;
    }


    //
    // C++:  double VideoCapture::get(int propId)
    //

/**
 * Returns the specified VideoCapture property
 *
 * Note: When querying a property that is not supported by the backend used by
 * the VideoCapture class, value 0 is returned.
 *
 * @param propId Property identifier. It can be one of the following:
 * 
 *    CV_CAP_PROP_POS_MSEC Current position of the video file in
 * milliseconds or video capture timestamp.
 *   
 CV_CAP_PROP_POS_FRAMES 0-based index of the frame to be
 * decoded/captured next.
 *   
 CV_CAP_PROP_POS_AVI_RATIO Relative position of the video file: 0 -
 * start of the film, 1 - end of the film.
 *   
 CV_CAP_PROP_FRAME_WIDTH Width of the frames in the video stream.
 *   
 CV_CAP_PROP_FRAME_HEIGHT Height of the frames in the video stream.
 *   
 CV_CAP_PROP_FPS Frame rate.
 *   
 CV_CAP_PROP_FOURCC 4-character code of codec.
 *   
 CV_CAP_PROP_FRAME_COUNT Number of frames in the video file.
 *   
 CV_CAP_PROP_FORMAT Format of the Mat objects returned by
 * retrieve().
 *   
 CV_CAP_PROP_MODE Backend-specific value indicating the current capture
 * mode.
 *   
 CV_CAP_PROP_BRIGHTNESS Brightness of the image (only for cameras).
 *   
 CV_CAP_PROP_CONTRAST Contrast of the image (only for cameras).
 *   
 CV_CAP_PROP_SATURATION Saturation of the image (only for cameras).
 *   
 CV_CAP_PROP_HUE Hue of the image (only for cameras).
 *   
 CV_CAP_PROP_GAIN Gain of the image (only for cameras).
 *   
 CV_CAP_PROP_EXPOSURE Exposure (only for cameras).
 *   
 CV_CAP_PROP_CONVERT_RGB Boolean flags indicating whether images should
 * be converted to RGB.
 *   
 CV_CAP_PROP_WHITE_BALANCE Currently not supported
 *   
 CV_CAP_PROP_RECTIFICATION Rectification flag for stereo cameras (note:
 * only supported by DC1394 v 2.x backend currently)
 * 
 *
 * @see org.opencv.highgui.VideoCapture.get
 */
    public  double get(int propId)
    {

        double retVal = get_0(nativeObj, propId);

        return retVal;
    }


    //
    // C++:  bool VideoCapture::grab()
    //

/**
 * Grabs the next frame from video file or capturing device.
 *
 * The methods/functions grab the next frame from video file or camera and
 * return true (non-zero) in the case of success.
 *
 * The primary use of the function is in multi-camera environments, especially
 * when the cameras do not have hardware synchronization. That is, you call
 * VideoCapture.grab() for each camera and after that call the
 * slower method VideoCapture.retrieve() to decode and get frame
 * from each camera. This way the overhead on demosaicing or motion jpeg
 * decompression etc. is eliminated and the retrieved frames from different
 * cameras will be closer in time.
 *
 * Also, when a connected camera is multi-head (for example, a stereo camera or
 * a Kinect device), the correct way of retrieving data from it is to call
 * "VideoCapture.grab" first and then call "VideoCapture.retrieve" one or more
 * times with different values of the channel parameter. See
 * https://github.com/Itseez/opencv/tree/master/samples/cpp/openni_capture.cpp
 *
 * @see org.opencv.highgui.VideoCapture.grab
 */
    public  boolean grab()
    {

        boolean retVal = grab_0(nativeObj);

        return retVal;
    }


    //
    // C++:  bool VideoCapture::isOpened()
    //

/**
 * Returns true if video capturing has been initialized already.
 *
 * If the previous call to VideoCapture constructor or
 * VideoCapture.open succeeded, the method returns true.
 *
 * @see org.opencv.highgui.VideoCapture.isOpened
 */
    public  boolean isOpened()
    {

        boolean retVal = isOpened_0(nativeObj);

        return retVal;
    }


    //
    // C++:  bool VideoCapture::open(string filename)
    //

/**
 * Open video file or a capturing device for video capturing
 *
 * The methods first call "VideoCapture.release" to close the already opened
 * file or camera.
 *
 * @param filename name of the opened video file (eg. video.avi) or image
 * sequence (eg. img_%02d.jpg, which will read samples like img_00.jpg,
 * img_01.jpg, img_02.jpg,...)
 *
 * @see org.opencv.highgui.VideoCapture.open
 */
    public  boolean open(String filename)
    {

        boolean retVal = open_0(nativeObj, filename);

        return retVal;
    }


    //
    // C++:  bool VideoCapture::open(int device)
    //

/**
 * Open video file or a capturing device for video capturing
 *
 * The methods first call "VideoCapture.release" to close the already opened
 * file or camera.
 *
 * @param device id of the opened video capturing device (i.e. a camera index).
 *
 * @see org.opencv.highgui.VideoCapture.open
 */
    public  boolean open(int device)
    {

        boolean retVal = open_1(nativeObj, device);

        return retVal;
    }


    //
    // C++:  bool VideoCapture::read(Mat& image)
    //

/**
 * Grabs, decodes and returns the next video frame.
 *
 * The methods/functions combine "VideoCapture.grab" and "VideoCapture.retrieve"
 * in one call. This is the most convenient method for reading video files or
 * capturing data from decode and return the just grabbed frame. If no frames
 * has been grabbed (camera has been disconnected, or there are no more frames
 * in video file), the methods return false and the functions return NULL
 * pointer.
 *
 * Note: OpenCV 1.x functions cvRetrieveFrame and cv.RetrieveFrame
 * return image stored inside the video capturing structure. It is not allowed
 * to modify or release the image! You can copy the frame using "cvCloneImage"
 * and then do whatever you want with the copy.
 *
 * @param image a image
 *
 * @see org.opencv.highgui.VideoCapture.read
 */
    public  boolean read(Mat image)
    {

        boolean retVal = read_0(nativeObj, image.nativeObj);

        return retVal;
    }


    //
    // C++:  void VideoCapture::release()
    //

/**
 * Closes video file or capturing device.
 *
 * The methods are automatically called by subsequent "VideoCapture.open" and
 * by VideoCapture destructor.
 *
 * The C function also deallocates memory and clears *capture
 * pointer.
 *
 * @see org.opencv.highgui.VideoCapture.release
 */
    public  void release()
    {

        release_0(nativeObj);

        return;
    }


    //
    // C++:  bool VideoCapture::retrieve(Mat& image, int channel = 0)
    //

/**
 * Decodes and returns the grabbed video frame.
 *
 * The methods/functions decode and return the just grabbed frame. If no frames
 * has been grabbed (camera has been disconnected, or there are no more frames
 * in video file), the methods return false and the functions return NULL
 * pointer.
 *
 * Note: OpenCV 1.x functions cvRetrieveFrame and cv.RetrieveFrame
 * return image stored inside the video capturing structure. It is not allowed
 * to modify or release the image! You can copy the frame using "cvCloneImage"
 * and then do whatever you want with the copy.
 *
 * @param image a image
 * @param channel a channel
 *
 * @see org.opencv.highgui.VideoCapture.retrieve
 */
    public  boolean retrieve(Mat image, int channel)
    {

        boolean retVal = retrieve_0(nativeObj, image.nativeObj, channel);

        return retVal;
    }

/**
 * Decodes and returns the grabbed video frame.
 *
 * The methods/functions decode and return the just grabbed frame. If no frames
 * has been grabbed (camera has been disconnected, or there are no more frames
 * in video file), the methods return false and the functions return NULL
 * pointer.
 *
 * Note: OpenCV 1.x functions cvRetrieveFrame and cv.RetrieveFrame
 * return image stored inside the video capturing structure. It is not allowed
 * to modify or release the image! You can copy the frame using "cvCloneImage"
 * and then do whatever you want with the copy.
 *
 * @param image a image
 *
 * @see org.opencv.highgui.VideoCapture.retrieve
 */
    public  boolean retrieve(Mat image)
    {

        boolean retVal = retrieve_1(nativeObj, image.nativeObj);

        return retVal;
    }


    //
    // C++:  bool VideoCapture::set(int propId, double value)
    //

/**
 * Sets a property in the VideoCapture.
 *
 * @param propId Property identifier. It can be one of the following:
 * 
 *    CV_CAP_PROP_POS_MSEC Current position of the video file in
 * milliseconds.
 *   
 CV_CAP_PROP_POS_FRAMES 0-based index of the frame to be
 * decoded/captured next.
 *   
 CV_CAP_PROP_POS_AVI_RATIO Relative position of the video file: 0 -
 * start of the film, 1 - end of the film.
 *   
 CV_CAP_PROP_FRAME_WIDTH Width of the frames in the video stream.
 *   
 CV_CAP_PROP_FRAME_HEIGHT Height of the frames in the video stream.
 *   
 CV_CAP_PROP_FPS Frame rate.
 *   
 CV_CAP_PROP_FOURCC 4-character code of codec.
 *   
 CV_CAP_PROP_FRAME_COUNT Number of frames in the video file.
 *   
 CV_CAP_PROP_FORMAT Format of the Mat objects returned by
 * retrieve().
 *   
 CV_CAP_PROP_MODE Backend-specific value indicating the current capture
 * mode.
 *   
 CV_CAP_PROP_BRIGHTNESS Brightness of the image (only for cameras).
 *   
 CV_CAP_PROP_CONTRAST Contrast of the image (only for cameras).
 *   
 CV_CAP_PROP_SATURATION Saturation of the image (only for cameras).
 *   
 CV_CAP_PROP_HUE Hue of the image (only for cameras).
 *   
 CV_CAP_PROP_GAIN Gain of the image (only for cameras).
 *   
 CV_CAP_PROP_EXPOSURE Exposure (only for cameras).
 *   
 CV_CAP_PROP_CONVERT_RGB Boolean flags indicating whether images should
 * be converted to RGB.
 *   
 CV_CAP_PROP_WHITE_BALANCE Currently unsupported
 *   
 CV_CAP_PROP_RECTIFICATION Rectification flag for stereo cameras (note:
 * only supported by DC1394 v 2.x backend currently)
 * 
 * @param value Value of the property.
 *
 * @see org.opencv.highgui.VideoCapture.set
 */
    public  boolean set(int propId, double value)
    {

        boolean retVal = set_0(nativeObj, propId, value);

        return retVal;
    }


    public java.util.List getSupportedPreviewSizes()
    {
        String[] sizes_str = getSupportedPreviewSizes_0(nativeObj).split(",");
        java.util.List sizes = new java.util.ArrayList(sizes_str.length);

        for (String str : sizes_str) {
            String[] wh = str.split("x");
            sizes.add(new org.opencv.core.Size(Double.parseDouble(wh[0]), Double.parseDouble(wh[1])));
        }

        return sizes;
    }


    @Override
    protected void finalize() throws Throwable {
        delete(nativeObj);
    }



    // C++:   VideoCapture::VideoCapture()
    private static native long VideoCapture_0();

    // C++:   VideoCapture::VideoCapture(string filename)
    private static native long VideoCapture_1(String filename);

    // C++:   VideoCapture::VideoCapture(int device)
    private static native long VideoCapture_2(int device);

    // C++:  double VideoCapture::get(int propId)
    private static native double get_0(long nativeObj, int propId);

    // C++:  bool VideoCapture::grab()
    private static native boolean grab_0(long nativeObj);

    // C++:  bool VideoCapture::isOpened()
    private static native boolean isOpened_0(long nativeObj);

    // C++:  bool VideoCapture::open(string filename)
    private static native boolean open_0(long nativeObj, String filename);

    // C++:  bool VideoCapture::open(int device)
    private static native boolean open_1(long nativeObj, int device);

    // C++:  bool VideoCapture::read(Mat& image)
    private static native boolean read_0(long nativeObj, long image_nativeObj);

    // C++:  void VideoCapture::release()
    private static native void release_0(long nativeObj);

    // C++:  bool VideoCapture::retrieve(Mat& image, int channel = 0)
    private static native boolean retrieve_0(long nativeObj, long image_nativeObj, int channel);
    private static native boolean retrieve_1(long nativeObj, long image_nativeObj);

    // C++:  bool VideoCapture::set(int propId, double value)
    private static native boolean set_0(long nativeObj, int propId, double value);

    private static native String getSupportedPreviewSizes_0(long nativeObj);

    // native support for java finalize()
    private static native void delete(long nativeObj);

}