> For the complete documentation index, see [llms.txt](https://wiki.hanzheteng.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wiki.hanzheteng.com/development/opencv/modules.md).

# Modules

## cv::Mat

* With C++ interface in OpenCV 2.0, Mat supports automatic memory management.
* Mat has two data parts: the matrix header (constant size) and a pointer to the matrix containing the pixel values (varying size).
* For computational efficiency, OpenCV uses a reference counting system. 
  * Each Mat object has its own header, however the matrix may be shared.
  * The copy operators will only copy the headers and the pointer to the large matrix, not the data itself.
  * Making a modification using any of them will affect all the other ones as well.
* To copy the matrix itself, use `cv::Mat::clone()` and `cv::Mat::copyTo()`
* Color space options
  * RGB is the most common one (however OpenCV uses BGR instead)
  * The HSV and HLS decompose colors into their hue, saturation and value/luminance components (more natural way for us to describe colors)
  * YCrCb is used by the popular JPEG image format
  * CIE L\*a\*b\* is a perceptually uniform color space

```cpp
// cv::Mat::Mat Constructor
Mat M(2, 2, CV_8UC3, Scalar(0,0,255));

// Use C/C++ arrays and initialize via constructor
int sz[3] = {2,2,2};
Mat L(3, sz, CV_8UC(1), Scalar::all(0));

// MATLAB style initializer
Mat E = Mat::eye(4, 4, CV_64F);
Mat O = Mat::ones(2, 2, CV_32F);
Mat Z = Mat::zeros(3, 3, CV_8UC1);

// For small matrices you may use comma separated initializers
Mat C = (Mat_<double>(3,3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);

// Create a new header for an existing Mat object
Mat RowClone = C.row(1).clone();

// You can fill out a matrix with random values
Mat R = Mat(3, 2, CV_8UC3);
randu(R, Scalar::all(0), Scalar::all(255));

// Other common OpenCV data structures
Point2f P(5, 1);
Point3f P3f(2, 6, 7);
std::vector<float> v(20);  Mat(v);
std::vector<Point2f> vPoints(20);

// Typedefs in CV Core module
// typedef Mat_< Vec3f > 	cv::Mat3f
// typedef Matx< double, 3, 3 > 	cv::Matx33d
```

## cv::ORB

```cpp
cv::Mat image1 = cv::imread("../data/1.png", cv::IMREAD_COLOR);
cv::Mat image2 = cv::imread("../data/2.png", cv::IMREAD_COLOR);

cv::Ptr<cv::ORB> orb = cv::ORB::create();
std::vector<cv::KeyPoint> keypoints1, keypoints2;
orb->detect(image1, keypoints1);
orb->detect(image2, keypoints2);

cv::Mat descriptors1, descriptors2;
orb->compute(image1, keypoints1, descriptors1);
orb->compute(image2, keypoints2, descriptors2);

std::vector<cv::DMatch> matches;
cv::Ptr<cv::DescriptorMatcher> matcher = cv::DescriptorMatcher::create("BruteForce-Hamming");
matcher->match(descriptors1, descriptors2, matches, cv::Mat());

cv::Mat output_image;
cv::drawMatches(image1, keypoints1, image2, keypoints2, matches, output_image);
cv::namedWindow("Display window", cv::WINDOW_AUTOSIZE);
cv::imshow("Display window", output_image);
cv::waitKey(0);
```

## cv::FileStorage

```cpp
// XML/YAML File Open and Close
string filename = "I.xml";
FileStorage fs(filename, FileStorage::WRITE);

fs.open(filename, FileStorage::READ);

// Input and Output of text and numbers
fs << "iterationNr" << 100;

int itNr;
fs["iterationNr"] >> itNr;
itNr = (int) fs["iterationNr"];

// Input/Output of OpenCV Data structures
Mat R = Mat_<uchar >::eye  (3, 3),
    T = Mat_<double>::zeros(3, 1);
fs << "R" << R;    // Write cv::Mat
fs << "T" << T;
fs["R"] >> R;      // Read cv::Mat
fs["T"] >> T;

// Input/Output of vectors (arrays) and associative maps
// use cv::FileNode and cv::FileNodeIterator data structures

// Read and write your own data structures
// ...
```

## Line Features

* OpenCV contrib modules [Line Features Tutorial](https://docs.opencv.org/3.1.0/df/dfa/tutorial_line_descriptor_main.html)
* [cv::LineSegmentDetector](https://docs.opencv.org/3.1.0/db/d73/classcv_1_1LineSegmentDetector.html) implements the LSD detector.
* [cv::line\_descriptor](https://docs.opencv.org/3.1.0/dc/ddd/group__line__descriptor.html) provides the line descriptors as one of the contrib modules. Not sure if this implements the Line Band Descriptors (LBD) that is commonly used for line matching.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://wiki.hanzheteng.com/development/opencv/modules.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.