• Den Formaten ist soweit ich bisher gekommen bin gemein, dass sie in unsigned char (8bit pro Kanal) speichern.
• IplImage (aus OpenCV) speichert in unsigned char und vertauschten blau und Rot Kanälen: BGR
• ausserdem allokiert es speicher mit malloc
• Möchte die Bilddaten aber gerne über einen boost::shared_ptr/array managen.
• IplImage wird wohl am meisten benutzt werden, also speichere ich intern in 8bit BGR
• Die verwendung von IplImage soll einfach sein. OpenCV arbeitet mit IplImage* d.h. es wird ständig ein dumb-ptr auf das ding rumgeschickt.
• zugriffe auf IplImage können lesend und schreibend sein.

So schauts bisher aus:

class ARGImage
{

public:
	enum ByteOrder {ARG_RGB, ARG_BGR};

	// Constructors:
	ARGImage(void);
	ARGImage(ARGImage& image);
	ARGImage(const unsigned char * data, unsigned int width, unsigned int height, ByteOrder order=ARG_RGB);
	virtual ~ARGImage(void);

	point2i size() {return size_;};
	IplImage* asIpl();
	boost::shared_array<unsigned char> asUCBGR();
	boost::shared_array<unsigned char> asUCRGB();

private:
	boost::shared_array<ClrComponent> pData_;
	point2i size_;
	IplImage* piplHeader_;

};
/// in der CPP:
ARGImage::ARGImage(const unsigned char * pData, unsigned int width, unsigned int height, ByteOrder order):
	pData_(new ClrComponent[width*height*sizeof(ClrComponent)])
{
	IplImage* pIpl;
	CvMat* pMat;

	if (pData_)
	{
		// just to be sure:
		assert(sizeof(ClrComponent) == sizeof(unsigned char));
		try
		{
			pMat = cvCreateMatHeader(height,width, CV_8UC3);
			cvSetData(pMat, (void*)pData, 3);
			pIpl = cvCreateImageHeader(cvSize(width, height), IPL_DEPTH_8U,3);
			cvSetData(pIpl, pData_.get(), 3);
			if (order==ARG_RGB)
			{
				cvCvtColor(pMat, pIpl, CV_RGB2BGR);
			}
			else
			{
				cvCopy(pMat, pIpl);
			}

		}
		catch(...)
		{
			std::cout << "ERROR: Exception occurred while trying to copy image data!" << std::endl;
			throw;
		}

		// reorder b and r channels if necessary:
	}
}

Ich habe es auch geschafft dem OpenCV über
cvCreateImageHeader per new allokierte und in einem boost::shared_ptr gemanagte Daten unterzuschieben.

Hier also meine Frage:
Mach ich hier grob was falsch?

Mach ich hier grob was falsch?

Schwer zu sagen. Was genau ist denn eigentlich das Problem?

Das Problem liegt darin, dass ich ständig dumme Pointer rausliefern muss,
und darauf hoffen muss, dass keiner damit Mist baut.

z.B. könnte sich einer das IplImage geben lassen,
und es gewissenhaft freigeben:

IplImage* ipl = argImage.asIpl();

...

cvReleaseImageHeader(ipl); // ok
cvReleaseImage(ipl);  // crash boom bang!!!! von mir intern gemanagter speicher wird freigegeben

z.B. kann ich einer OpenCV funktion (uchar*) ja keinen shared_ptr<uchar> reinschmeissen. Denn so schlau sind die smarten pointer dann auch nicht,
dass sie sich nahtlos einfügen.