Reads an image from a buffer in memory.
Mat imdecode
(InputArray buf, int flags)¶
Mat imdecode
(InputArray buf, int flags, Mat* dst)¶
IplImage* cvDecodeImage
(const CvMat* buf, int iscolor=CV_LOAD_IMAGE_COLOR)¶
CvMat* cvDecodeImageM
(const CvMat* buf, int iscolor=CV_LOAD_IMAGE_COLOR)¶
cv2.
imdecode
(buf, flags) → retval¶Parameters: |
|
---|
The function reads an image from the specified buffer in the memory. If the buffer is too short or contains invalid data, the empty matrix/image is returned.
See
imread()
for the list of supported formats and flags description.
Note
In the case of color images, the decoded images will have the channels stored in B G R
order.
Encodes an image into a memory buffer.
bool imencode
(const string& ext, InputArray img, vector<uchar>& buf, const vector<int>& params=vector<int>())¶
CvMat* cvEncodeImage
(const char* ext, const CvArr* image, const int* params=0 )¶
cv2.
imencode
(ext, img[, params]) → retval, buf¶Parameters: |
|
---|
The function compresses the image and stores it in the memory buffer that is resized to fit the result.
See
imwrite()
for the list of supported formats and flags description.
Note
cvEncodeImage
returns single-row matrix of type CV_8UC1
that contains encoded image as array of bytes.
Loads an image from a file.
Mat imread
(const string& filename, int flags=1 )¶
cv2.
imread
(filename[, flags]) → retval¶
IplImage* cvLoadImage
(const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )¶
CvMat* cvLoadImageM
(const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )¶
cv.
LoadImage
(filename, iscolor=CV_LOAD_IMAGE_COLOR) → None¶
cv.
LoadImageM
(filename, iscolor=CV_LOAD_IMAGE_COLOR) → None¶Parameters: |
|
---|
The function imread
loads an image from the specified file and returns it. If the image cannot be read (because of missing file, improper permissions, unsupported or invalid format), the function returns an empty matrix ( Mat::data==NULL
). Currently, the following file formats are supported:
- Windows bitmaps -
*.bmp, *.dib
(always supported)- JPEG files -
*.jpeg, *.jpg, *.jpe
(see the Notes section)- JPEG 2000 files -
*.jp2
(see the Notes section)- Portable Network Graphics -
*.png
(see the Notes section)- Portable image format -
*.pbm, *.pgm, *.ppm
(always supported)- Sun rasters -
*.sr, *.ras
(always supported)- TIFF files -
*.tiff, *.tif
(see the Notes section)
Note
OPENCV_BUILD_3RDPARTY_LIBS
flag in CMake.Note
In the case of color images, the decoded images will have the channels stored in B G R
order.
Saves an image to a specified file.
bool imwrite
(const string& filename, InputArray img, const vector<int>& params=vector<int>() )¶
cv2.
imwrite
(filename, img[, params]) → retval¶
int cvSaveImage
(const char* filename, const CvArr* image, const int* params=0 )¶
cv.
SaveImage
(filename, image) → None¶Parameters: |
|
---|
The function imwrite
saves the image to the specified file. The image format is chosen based on the filename
extension (see
imread()
for the list of extensions). Only 8-bit (or 16-bit unsigned (CV_16U
) in case of PNG, JPEG 2000, and TIFF) single-channel or 3-channel (with ‘BGR’ channel order) images can be saved using this function. If the format, depth or channel order is different, use
Mat::convertTo()
, and
cvtColor()
to convert it before saving. Or, use the universal FileStorage
I/O functions to save the image to XML or YAML format.
It is possible to store PNG images with an alpha channel using this function. To do this, create 8-bit (or 16-bit) 4-channel image BGRA, where the alpha channel goes last. Fully transparent pixels should have alpha set to 0, fully opaque pixels should have alpha set to 255/65535. The sample below shows how to create such a BGRA image and store to PNG file. It also demonstrates how to set custom compression parameters
#include <vector>
#include <stdio.h>
#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;
void createAlphaMat(Mat &mat)
{
CV_Assert(mat.channels() == 4);
for (int i = 0; i < mat.rows; ++i) {
for (int j = 0; j < mat.cols; ++j) {
Vec4b& bgra = mat.at<Vec4b>(i, j);
bgra[0] = UCHAR_MAX; // Blue
bgra[1] = saturate_cast<uchar>((float (mat.cols - j)) / ((float)mat.cols) * UCHAR_MAX); // Green
bgra[2] = saturate_cast<uchar>((float (mat.rows - i)) / ((float)mat.rows) * UCHAR_MAX); // Red
bgra[3] = saturate_cast<uchar>(0.5 * (bgra[1] + bgra[2])); // Alpha
}
}
}
int main(int argv, char **argc)
{
// Create mat with alpha channel
Mat mat(480, 640, CV_8UC4);
createAlphaMat(mat);
vector<int> compression_params;
compression_params.push_back(CV_IMWRITE_PNG_COMPRESSION);
compression_params.push_back(9);
try {
imwrite("alpha.png", mat, compression_params);
}
catch (runtime_error& ex) {
fprintf(stderr, "Exception converting image to PNG format: %s\n", ex.what());
return 1;
}
fprintf(stdout, "Saved PNG file with alpha data.\n");
return 0;
}
VideoCapture
¶Class for video capturing from video files, image sequences or cameras. The class provides C++ API for capturing video from cameras or for reading video files and image sequences. Here is how the class can be used:
#include "opencv2/opencv.hpp"
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
VideoCapture constructors.
VideoCapture::
VideoCapture
()¶
VideoCapture::
VideoCapture
(const string& filename)¶
VideoCapture::
VideoCapture
(int device)¶
cv2.
VideoCapture
() → <VideoCapture object>¶
cv2.
VideoCapture
(filename) → <VideoCapture object>
cv2.
VideoCapture
(device) → <VideoCapture object>
CvCapture* cvCaptureFromCAM
(int device)¶
cv.
CaptureFromCAM
(index) → CvCapture¶
CvCapture* cvCaptureFromFile
(const char* filename)¶
cv.
CaptureFromFile
(filename) → CvCapture¶Parameters: |
|
---|
Note
In C API, when you finished working with video, release CvCapture
structure with cvReleaseCapture()
, or use Ptr<CvCapture>
that calls cvReleaseCapture()
automatically in the destructor.
Open video file or a capturing device for video capturing
bool VideoCapture::
open
(const string& filename)¶
bool VideoCapture::
open
(int device)¶
cv2.VideoCapture.
open
(filename) → retval¶
cv2.VideoCapture.
open
(device) → retvalParameters: |
|
---|
The methods first call VideoCapture::release()
to close the already opened file or camera.
Returns true if video capturing has been initialized already.
bool VideoCapture::
isOpened
()¶
cv2.VideoCapture.
isOpened
() → retval¶If the previous call to VideoCapture
constructor or VideoCapture::open
succeeded, the method returns true.
Closes video file or capturing device.
void VideoCapture::
release
()¶
cv2.VideoCapture.
release
() → None¶
void cvReleaseCapture
(CvCapture** capture)¶The methods are automatically called by subsequent VideoCapture::open()
and by VideoCapture
destructor.
The C function also deallocates memory and clears *capture
pointer.
Grabs the next frame from video file or capturing device.
bool VideoCapture::
grab
()¶
cv2.VideoCapture.
grab
() → retval¶
int cvGrabFrame
(CvCapture* capture)¶
cv.
GrabFrame
(capture) → int¶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/opencv/opencv/tree/master/samples/cpp/openni_capture.cpp
Decodes and returns the grabbed video frame.
bool VideoCapture::
retrieve
(Mat& image, int channel=0)¶
cv2.VideoCapture.
retrieve
([image[, channel]]) → retval, image¶
IplImage* cvRetrieveFrame
(CvCapture* capture, int streamIdx=0 )¶
cv.
RetrieveFrame
(capture[, index]) → image¶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.
Grabs, decodes and returns the next video frame.
VideoCapture& VideoCapture::
operator>>
(Mat& image)¶
bool VideoCapture::
read
(Mat& image)¶
cv2.VideoCapture.
read
([image]) → retval, image¶
IplImage* cvQueryFrame
(CvCapture* capture)¶
cv.
QueryFrame
(capture) → image¶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.
Returns the specified VideoCapture
property
double VideoCapture::
get
(int propId)¶
cv2.VideoCapture.
get
(propId) → retval¶
double cvGetCaptureProperty
(CvCapture* capture, int property_id)¶
cv.
GetCaptureProperty
(capture, property_id) → float¶Parameters: | propId – Property identifier. It can be one of the following:
|
---|
Note: When querying a property that is not supported by the backend used by the VideoCapture
class, value 0 is returned.
Sets a property in the VideoCapture
.
bool VideoCapture::
set
(int propId, double value)¶
cv2.VideoCapture.
set
(propId, value) → retval¶
int cvSetCaptureProperty
(CvCapture* capture, int property_id, double value)¶
cv.
SetCaptureProperty
(capture, property_id, value) → retval¶Parameters: |
|
---|
VideoWriter constructors
VideoWriter::
VideoWriter
()¶
VideoWriter::
VideoWriter
(const string& filename, int fourcc, double fps, Size frameSize, bool isColor=true)¶
cv2.
VideoWriter
([filename, fourcc, fps, frameSize[, isColor]]) → <VideoWriter object>¶
CvVideoWriter* cvCreateVideoWriter
(const char* filename, int fourcc, double fps, CvSize frame_size, int is_color=1 )¶
cv.
CreateVideoWriter
(filename, fourcc, fps, frame_size, is_color=true) → CvVideoWriter¶
cv2.VideoWriter.
isOpened
() → retval¶
cv2.VideoWriter.
open
(filename, fourcc, fps, frameSize[, isColor]) → retval¶
cv2.VideoWriter.
write
(image) → None¶Parameters: |
|
---|
The constructors/functions initialize video writers. On Linux FFMPEG is used to write videos; on Windows FFMPEG or VFW is used; on MacOSX QTKit is used.
Releases the AVI writer.
void cvReleaseVideoWriter
(CvVideoWriter** writer)¶The function should be called after you finished using CvVideoWriter
opened with CreateVideoWriter()
.
Initializes or reinitializes video writer.
bool VideoWriter::
open
(const string& filename, int fourcc, double fps, Size frameSize, bool isColor=true)¶
cv2.VideoWriter.
open
(filename, fourcc, fps, frameSize[, isColor]) → retvalThe method opens video writer. Parameters are the same as in the constructor VideoWriter::VideoWriter()
.
Returns true if video writer has been successfully initialized.
bool VideoWriter::
isOpened
()¶
cv2.VideoWriter.
isOpened
() → retvalWrites the next video frame
VideoWriter& VideoWriter::
operator<<
(const Mat& image)¶
void VideoWriter::
write
(const Mat& image)¶
cv2.VideoWriter.
write
(image) → None
int cvWriteFrame
(CvVideoWriter* writer, const IplImage* image)¶
cv.
WriteFrame
(writer, image) → int¶Parameters: |
|
---|
The functions/methods write the specified image to video file. It must have the same size as has been specified when opening the video writer.