The common data structures used for image processing in OpenCV are `Mat`, `CvMat`, and `IplImage`. These types can represent and display images, but they each serve different purposes. The `Mat` type is optimized for mathematical operations and calculations, making it more efficient for numerical computations. In contrast, `CvMat` and `IplImage` are more focused on image handling, with OpenCV providing optimized functions for tasks like scaling, thresholding, and channel extraction.
Before OpenCV 2.0, the library was entirely written in C. The relationship between `IplImage` and `CvMat` resembles an inheritance structure in object-oriented programming. However, there is also a more abstract base class called `CvArr`, which is commonly used in the source code.
### IplImage
The `IplImage` structure is the image header in OpenCV, defined as:
```c
typedef struct _IplImage {
int nSize; /* Size of the IplImage structure */
int ID; /* Version (usually 0) */
int nChannels; /* Number of channels (1, 2, 3, or 4) */
int alphaChannel; /* Ignored by OpenCV */
int depth; /* Pixel depth (e.g., IPL_DEPTH_8U, IPL_DEPTH_32F) */
char colorModel[4]; /* Ignored by OpenCV */
char channelSeq[4]; /* Ignored by OpenCV */
int dataOrder; /* 0 = interleaved, 1 = separate */
int origin; /* 0 = top-left, 1 = bottom-left */
int align; /* Image line alignment (4 or 8) */
int width; /* Width in pixels */
int height; /* Height in pixels */
struct _IplROI *roi; /* Region of Interest */
struct _IplImage *maskROI; /* Must be NULL in OpenCV */
void *imageId; /* Same as above */
struct _IplTileInfo *tileInfo; /* Same as above */
int imageSize; /* Size of image data in bytes */
char *imageData; /* Pointer to aligned image data */
int widthStep; /* Line size in bytes */
int borderMode[4]; /* Border mode (ignored by OpenCV) */
int borderConst[4]; /* Same as above */
char *imageDataOrigin; /* Pointer to a different data structure */
} IplImage;
```
The `dataOrder` field determines how color channels are stored: `interleaved` stores data as BGRBGR..., while `separate` stores each channel in its own plane. The `roi` field defines the region of interest, allowing only a portion of the image to be processed.
To access pixel values, you can use indirect methods such as `cvGet2D()` or macro-based access using `CV_IMAGE_ELEM()`. For direct access, you can cast the `imageData` pointer to a suitable type and index into it based on row and column positions.
### CvMat
OpenCV does not have a built-in vector structure. Instead, it uses matrices where vectors are represented as single-column or single-row matrices. The `CvMat` structure is more abstract than standard linear algebra matrices, as it supports multi-channel data.
The structure of `CvMat` includes fields for type, step (in bytes), reference count, and a union that allows access to data as different types (e.g., `uchar*`, `float*`, etc.).
To create a matrix, you can use functions like `cvCreateMat()` or `cvInitMatHeader()`. Accessing elements can be done via indirect methods like `cvmSet()` and `cvmGet()`, or directly by accessing the `data` union.
For multi-channel matrices, macros like `CV_MAT_ELEM()` are useful to access specific channels. Copying matrices can be done with `cvCloneMat()`.
### Mat
Introduced in OpenCV 2.0, `Mat` is a more modern and flexible data structure designed to replace `CvMat` and `IplImage`. It simplifies memory management by automatically handling allocation and deallocation, reducing the need for manual memory management.
A `Mat` object contains information about the number of dimensions (`dims`), rows (`rows`), columns (`cols`), and a pointer to the actual data (`data`). It also includes a reference counter (`refcount`) for shared memory management.
You can initialize a `Mat` object using constructors or the `create()` method. For example:
```cpp
Mat M(7, 7, CV_32FC2, Scalar(1, 3)); // Complex matrix
Mat img(Size(320, 240), CV_8UC3); // 3-channel 8-bit image
```
Accessing elements in a `Mat` can be done using `at<>()` or by iterating through rows and columns using `ptr<>()`.
### Conversion Between Structures
- **IplImage → CvMat**: Use `cvGetMat()` or `cvConvert()`.
- **IplImage → Mat**: Use `Mat(iplImg)` or `Mat mtx = iplImg;`.
- **Mat → IplImage**: Assign `IplImage iplimg = M;`.
- **CvMat → Mat**: Use `Mat(cvmat)`.
- **Mat → CvMat**: Use `CvMat cvmat = mat;`.
These conversions allow seamless integration between older and newer OpenCV structures, ensuring compatibility across different versions of the library.
Mono Solar Panel,Poly Solar Panel,HJT, BIPV, Double Glass,Small Solar Panel,Solar Cell Panel
Wuxi Sunket New Energy Technology Co.,Ltd , https://www.sunketsolar.com