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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of opencv Show documentation
OpenCV packaged with native libraries and loader for multiple platforms.
There is a newer version: 2.4.9-7

//
// 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);

}