cv::Mat memory ownership during legacy IplImage migration

Answer to the core questions

Does the cv::Mat wrapper assume ownership of the IplImage data buffer?

No. When you create a cv::Mat from an IplImage using cv::cvarrToMat, the operator= overload, or cv::Mat::operator=(IplImage const*), the Mat header simply points to the same data buffer. The reference counter in Mat does not track the lifetime of the underlying IplImage. Therefore the original IplImage must remain valid for as long as any cv::Mat that references its data exists.

Must the developer manually call cvReleaseImage?

Yes, the developer is responsible for freeing the IplImage when it is no longer needed. The cv::Mat will not free that memory for you; calling Mat::release() only frees memory that Mat itself owns.

Recommended pattern for a safe deep copy

1. Convert the legacy image:

   IplImage* oldImg = cvLoadImage(\"file.jpg\", CV_LOAD_IMAGE_COLOR);
   cv::Mat matFromIpl = cv::cvarrToMat(oldImg, false); // share data
   

2. Immediately make an owning copy if you plan to modify or outlive the IplImage:

   cv::Mat matCopy = matFromIpl.clone(); // allocates new buffer and copies data
   

3. Release the legacy structure as soon as the copy is ready:

   cvReleaseImage(&oldImg);
   

4. Use matCopy for all subsequent processing. It owns its data and is safe to use in multi‑threaded contexts.

If you know the IplImage is contiguous and you do not need to modify the data, you can skip the clone and keep the IplImage alive for the lifetime of the cv::Mat. However, in most migration scenarios, the clone step eliminates accidental side‑effects and avoids hard‑to‑debug crashes.

When to ask for more detail

If the image data is not contiguous or you plan to modify it in place, the clone step may incur a performance penalty. In that case, you might want to know:

• Is the original IplImage guaranteed to be continuous?
• Will the IplImage be destroyed before the cv::Mat is used?

Providing those details would let you decide whether a shallow share or a deep copy is the most efficient approach.