yarpimage.cpp

来自「一个语言识别引擎」· C++ 代码 · 共 1,110 行 · 第 1/3 页

{
    int result = 0;
    switch (pixel_type)
        {
        case YARP_PIXEL_MONO:
            result = sizeof(YarpPixelMono);
            break;
        case YARP_PIXEL_RGB:
            result = sizeof(YarpPixelRGB);
            break;
        case YARP_PIXEL_HSV:
            result = sizeof(YarpPixelHSV);
            break;
        case YARP_PIXEL_BGR:
            result = sizeof(YarpPixelBGR);
            break;
        case YARP_PIXEL_MONO_SIGNED:
            result = sizeof(YarpPixelMonoSigned);
            break;
        case YARP_PIXEL_RGB_SIGNED:
            result = sizeof(YarpPixelRGBSigned);
            break;
        case YARP_PIXEL_MONO_FLOAT:
            result = sizeof(YarpPixelFloat);
            break;
        case YARP_PIXEL_RGB_FLOAT:
            result = sizeof(YarpPixelRGBFloat);
            break;
        case YARP_PIXEL_HSV_FLOAT:
            result = sizeof(YarpPixelHSVFloat);
            break;
        default:
            // only other acceptable possibility is that the size is being supplied
            // for an unknown type
            //ACE_ASSERT (pixel_type<0);
            result = -pixel_type;
            break;
        }
    //printf("Getting pixel size for %d (%d)\n", pixel_type, result);
    return result;
}

int YARPGenericImage::GetPixelSize() const
{
	return _GetPixelSize(type_id);
}

// need alternate definitions of the following functions if the IPL
// library is being used

YARPGenericImage::YARPGenericImage()
{ 
	type_id = YARP_PIXEL_INVALID;
	pImage = NULL;
	Data = NULL;
	buffer_references = NULL;
	is_owner = 1;
}

YARPGenericImage::YARPGenericImage (const YARPGenericImage &i)
{
	type_id = YARP_PIXEL_INVALID;
	pImage = NULL;
	Data = NULL;
	buffer_references = NULL;
	is_owner = 1;

	YARPGenericImage::CastCopy (i);
}

YARPGenericImage::~YARPGenericImage()
{
	_free_complete();
}

void YARPGenericImage::operator= (const YARPGenericImage &i)
{
	YARPGenericImage::CastCopy (i);
}

// these are needed to allow easy manipulation of some logpolar stuff.
// note the padding stuff.
void YARPGenericImage::Crop (YARPGenericImage& id, int startX, int startY)
{
	ACE_ASSERT (id.GetID() == GetID());
	ACE_ASSERT (pImage != NULL && id.pImage != NULL);
	ACE_ASSERT ((startX + id.GetWidth()) <= pImage->width && (startY + id.GetHeight()) <= pImage->height);
			
	int sAlignLineSize = pImage->widthStep;
	int dAlignLineSize = id.pImage->widthStep;

	unsigned char *dst = (unsigned char *)id.GetAllocatedArray();
	unsigned char *src = (unsigned char *)pImage->imageData;
	
	src += ((startY * sAlignLineSize) + startX * pImage->nChannels);

	const int nrows = id.GetHeight();
	for (int i = 0; i < nrows; i++)
        {
            memcpy (dst, src, dAlignLineSize);
            dst += dAlignLineSize;
            src += sAlignLineSize;
        }
}

void YARPGenericImage::Paste (YARPGenericImage& is, int startX, int startY)
{
	ACE_ASSERT (is.GetID() == GetID());
	ACE_ASSERT (pImage != NULL && is.pImage != NULL);
	ACE_ASSERT ((startX + is.GetWidth()) <= pImage->width && (startY + is.GetHeight()) <= pImage->height);
		
	int dAlignLineSize = pImage->widthStep;
	int sAlignLineSize = is.pImage->widthStep;

	unsigned char *src = (unsigned char *)is.GetAllocatedArray();
	unsigned char *dst = (unsigned char *) pImage->imageData;

	dst += ((startY * dAlignLineSize) + startX * pImage->nChannels);

	const int nrows = is.GetHeight();
	for (int i = 0; i < nrows; i++)
        {
            memcpy (dst, src, sAlignLineSize);
            dst += dAlignLineSize;
            src += sAlignLineSize;
        }
}

// allocates an empty image.
void YARPGenericImage::_alloc (void)
{
	ACE_ASSERT (pImage != NULL);

	if (pImage != NULL)
		if (pImage->imageData != NULL)
			_free(); // was iplDeallocateImage(pImage); but that won't work with refs
	
	if ( (type_id == YARP_PIXEL_MONO_FLOAT) || (type_id == YARP_PIXEL_RGB_FLOAT) ||
         (type_id == YARP_PIXEL_HSV_FLOAT) )
		iplAllocateImageFP(pImage, 0, 0);
	else
		iplAllocateImage (pImage, 0, 0);

	iplSetBorderMode (pImage, IPL_BORDER_CONSTANT, IPL_SIDE_ALL, 0);
}

// installs an external buffer as the image data
void YARPGenericImage::_alloc_extern (void *buf)
{
	ACE_ASSERT (pImage != NULL);
	ACE_ASSERT(Data==NULL);

	if (pImage != NULL)
		if (pImage->imageData != NULL)
			iplDeallocateImage (pImage);

	//iplAllocateImage (pImage, 0, 0);
	pImage->imageData = (char*)buf;
	// HIT probably need to do more for real IPL
  
	//iplSetBorderMode (pImage, IPL_BORDER_CONSTANT, IPL_SIDE_ALL, 0);
}

// allocates the Data pointer.
void YARPGenericImage::_alloc_data (void)
{
	DBGPF1 ACE_OS::printf("alloc_data1\n"), fflush(stdout);
	ACE_ASSERT (pImage != NULL);

	ACE_ASSERT(Data==NULL);
	/*
      if (Data != NULL)
      {
	  DBGPF1 printf("HIT Deleting Data\n"), fflush(stdout);
	  //delete[] Data; //HIT2
	  free(Data);
	  Data = NULL;
      }
	*/

	DBGPF1 ACE_OS::printf("alloc_data1b\n"), fflush(stdout);
	DBGPF1 YARPTime::DelayInSeconds(0.1);

	int hh = pImage->height * sizeof(char *);
	DBGPF1 ACE_OS::printf("height is %d (%d)\n", pImage->height, hh);

	DBGPF1 ACE_OS::printf("alloc_data1c\n"), fflush(stdout);
	DBGPF1 YARPTime::DelayInSeconds(0.1);

	char **ptr = new char *[pImage->height];

	DBGPF1 ACE_OS::printf("alloc_data2\n"), fflush(stdout);
	DBGPF1 YARPTime::DelayInSeconds(0.1);
	Data = ptr;

	ACE_ASSERT (Data != NULL);

	ACE_ASSERT (pImage->imageData != NULL);

	int nPlanes = pImage->nChannels;
	int width = pImage->width;
    int height = pImage->height;
	DBGPF1 ACE_OS::printf("alloc_data3\n");

    char * DataArea = pImage->imageData;
    
	for (int r = 0; r < height; r++)
        {
            Data[r] = DataArea;
            DataArea += pImage->widthStep;
        }
	DBGPF1 ACE_OS::printf("alloc_data4\n");
}

void YARPGenericImage::_free (void)
{
	//	ACE_ASSERT (pImage != NULL);
	if (pImage != NULL)
		if (pImage->imageData != NULL)
            {
                int zero_count = 1;
                if (buffer_references != NULL)
                    {
                        DBGPF1 if (buffer_references!=NULL) cout << "HIT B Buffer references " << buffer_references->GetReferenceCount() << endl;
                        buffer_references->RemoveRef();
                        int ref = buffer_references->GetReferenceCount();
                        DBGPF1 if (buffer_references!=NULL) cout << "HIT C Buffer references " << buffer_references->GetReferenceCount() << endl;
                        if (ref<=0)
                            {
                                DBGPF1 cout << "HIT deleting buffer_references" << endl;
                                delete buffer_references;
                            }
                        else
                            {
                                zero_count = 0;
                            }
                        buffer_references = NULL;
                    }

                if (zero_count)
                    {
                        //cout << "HIT maybe deleting ipl image" << endl;
                        if (is_owner)
                            {
                                DBGPF1 cout << "HIT really truly deleting ipl image" << endl;
                                iplDeallocateImage (pImage);
                                if (Data!=NULL)
                                    {
                                        delete[] Data;
                                    }
                            }
                        else
                            {
                                if (Data!=NULL)
                                    {
                                        delete[] Data;
                                    }
                            }
                    }

                is_owner = 1;
                Data = NULL;
                pImage->imageData = NULL;
            }
}

void YARPGenericImage::_free_data (void)
{
	ACE_ASSERT(Data==NULL); // Now always free Data at same time
    // as image buffer, for correct refcounting
	/*
      if (Data != NULL)
      {
      delete[] Data;
      }
      Data = NULL;
	*/
}

// LATER: implement for LINUX.
int YARPGenericImage::_pad_bytes (int linesize, int align) const
{
	return PAD_BYTES (linesize, align);
}

void YARPGenericImage::_set_ipl_header(int x, int y, int pixel_type)
{
	// used to allocate the ipl header.
	switch (pixel_type)
        {
        case YARP_PIXEL_MONO:
            pImage = iplCreateImageHeader(
                                          1,
                                          0,
                                          IPL_DEPTH_8U,			
                                          "GRAY",
                                          "GRAY",
                                          IPL_DATA_ORDER_PIXEL,	 
                                          IPL_ORIGIN_BL,			
                                          IPL_ALIGN_QWORD,		
                                          x,
                                          y,
                                          NULL,
                                          NULL,
                                          NULL,
                                          NULL);
            DBGPF1 ACE_OS::printf("Set pImage to %ld\n", (long int) pImage);
            DBGPF1 ACE_OS::printf("Set init h to %d\n", (long int) pImage->height);
            break;

        case YARP_PIXEL_RGB:
            pImage = iplCreateImageHeader(
                                          3,
                                          0,
                                          IPL_DEPTH_8U,			
                                          "RGB",
                                          "RGB",
                                          IPL_DATA_ORDER_PIXEL,	 
                                          IPL_ORIGIN_BL,			
                                          IPL_ALIGN_QWORD,		
                                          x,
                                          y,
                                          NULL,
                                          NULL,
                                          NULL,
                                          NULL);
            break;

        case YARP_PIXEL_HSV:
            pImage = iplCreateImageHeader(
                                          3,
                                          0,
                                          IPL_DEPTH_8U,			
                                          "HSV",
                                          "HSV",
                                          IPL_DATA_ORDER_PIXEL,	 
                                          IPL_ORIGIN_BL,			
                                          IPL_ALIGN_QWORD,		
                                          x,
                                          y,
                                          NULL,
                                          NULL,
                                          NULL,
                                          NULL);
            break;

        case YARP_PIXEL_BGR:
            pImage = iplCreateImageHeader(
                                          3,
                                          0,
                                          IPL_DEPTH_8U,			
                                          "RGB",
                                          "BGR",
                                          IPL_DATA_ORDER_PIXEL,	 
                                          IPL_ORIGIN_BL,			
                                          IPL_ALIGN_QWORD,		
                                          x,
                                          y,
                                          NULL,
                                          NULL,
                                          NULL,
                                          NULL);
            break;

        case YARP_PIXEL_MONO_SIGNED:
            pImage = iplCreateImageHeader(
                                          1,
                                          0,
                                          IPL_DEPTH_8S,			
                                          "GRAY",