Frage: memory Management: Wrapper um IplImage(ansi C), OpenGL Texture, D3d8Texture, ARImage

krxlprnft

Hallöchen.
Folgendes Problemchen stellt sich mir:
Ich habe 4 Bibliotheken die mit Bilddaten arbeiten und die ich gerne mit einem Wrapper über Bilddaten bedient hätte.
Mir ist aber noch schleierhaft wie ich das gescheit bewerkstelligen soll.
Folgende Punkte sind zu beachten:

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?

Registrierter Troll

krxlprnft schrieb:

Mach ich hier grob was falsch?

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

krxlprnft

Nunja, ich möcht mich möglichst an standards halten. Wenn jetzt einer die Klasse benutzt solls so Barrierefrei wie möglich sein.
Seitdem ich aber Scott Meyer gelesen hab, hab ich Angst, dass das
dem Nächsten gleich um die Rübe fliegt

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.