iplimage.cpp

一个语言识别引擎

                            tmp = 0;
                        if (tmp > 255)
                            tmp = 255;
                        *dst++ = char(tmp);
                    }
            }
            break;

        case IPL_DEPTH_8S:
            {
                const int size = srcImageA->imageSize;
                char * src1 = srcImageA->imageData;
                char * src2 = srcImageB->imageData;
                char * dst = dstImage->imageData;
			
                short tmp;

                for (int i = 0; i < size; i++)
                    {
                        tmp = *src1++ - *src2++;
                        if (tmp < -128) 
                            tmp = -128;
                        else
                            if (tmp > 127)
                                tmp = 127;
                        *dst++ = char(tmp);
                    }
            }
            break;

        case IPL_DEPTH_32F:
            {
                const int size = srcImageA->imageSize / sizeof(float);
                float * src1 = (float *)srcImageA->imageData;
                float * src2 = (float *)srcImageB->imageData;
                float * dst = (float *)dstImage->imageData;
			
                for (int i = 0; i < size; i++)
                    {
                        *dst++ = *src1++ - *src2++;
                    }
            }
            break;

        default:
            assert (1 == 0);
            // NOT IMPLEMENTED.
            break;
        }
}

IPLAPIIMPL(void, iplSubtractS,(IplImage* srcImage, IplImage* dstImage, int value,
                               bool flip))
{
	// assume images have the same size and 8 bits/pixel/planes.
	switch (srcImage->depth)
        {
        case IPL_DEPTH_8U:
            {
                const int size = srcImage->imageSize;
                unsigned char * src = (unsigned char *)srcImage->imageData;
                unsigned char * dst = (unsigned char *)dstImage->imageData;
			
                short tmp;

                for (int i = 0; i < size; i++)
                    {
                        if (flip)
                            tmp = value - *src++;
                        else
                            tmp = *src++ - value;

                        if (tmp < 0) 
                            tmp = 0;
                        else
                            if (tmp > 255)
                                tmp = 255;
                        *dst++ = char(tmp);
                    }
            }
            break;

        case IPL_DEPTH_8S:
            {
                const int size = srcImage->imageSize;
                char * src = srcImage->imageData;
                char * dst = dstImage->imageData;
			
                short tmp;

                for (int i = 0; i < size; i++)
                    {
                        if (flip)
                            tmp = value - *src++;
                        else
                            tmp = *src++ - value;

                        if (tmp < -128) 
                            tmp = -128;
                        else
                            if (tmp > 127)
                                tmp = 127;
                        *dst++ = char(tmp);
                    }
            }
            break;

        default:
            assert (1 == 0);
            // NOT IMPLEMENTED.
            break;
        }
}

IPLAPIIMPL(void, iplMultiplySFP,(IplImage* srcImage, IplImage* dstImage,
                                 float value))
{
	assert (compareHeader (srcImage, dstImage));
	assert (srcImage->depth == IPL_DEPTH_32F);

	const int size = srcImage->imageSize / sizeof(float);
	float * src1 = (float *)srcImage->imageData;
	float * dst = (float *)dstImage->imageData;
	
	for (int i = 0; i < size; i++)
        {
            *dst++ = *src1++ * value;
        }
}

IPLAPIIMPL(void, iplAbs,(IplImage* srcImage, IplImage* dstImage))
{
	switch (srcImage->depth)
        {
        case IPL_DEPTH_8U:
            {
                memcpy (dstImage->imageData, srcImage->imageData, dstImage->imageSize);
            }
            break;

        case IPL_DEPTH_8S:
            {
                const int size = srcImage->imageSize;
                char * src = srcImage->imageData;
                char * dst = dstImage->imageData;
			
                for (int i = 0; i < size; i++)
                    {
                        if (*src < 0)
                            *dst++ = -*src++;
                        else
                            *dst++ = *src++;
                    }
            }
            break;

        default:
            assert (1 == 0);
            // NOT IMPLEMENTED.
            break;
        }
}

IPLAPIIMPL(void, iplThreshold, (IplImage* srcImage, IplImage* dstImage, int threshold))
{
	switch (srcImage->depth)
        {
        case IPL_DEPTH_8U:
            {
                const int size = srcImage->imageSize;
                unsigned char * src = (unsigned char *)srcImage->imageData;
                unsigned char * dst = (unsigned char *)dstImage->imageData;

                for (int i = 0; i < size; i++)
                    {
                        if (*src++ < threshold)
                            *dst++ = 0;
                        else
                            *dst++ = 255;
                    }
            }
            break;

        case IPL_DEPTH_8S:
            {
                const int size = srcImage->imageSize;
                char * src = srcImage->imageData;
                char * dst = dstImage->imageData;
			
                for (int i = 0; i < size; i++)
                    {
                        if (*src++ < threshold)
                            *dst++ = -128;
                        else
                            *dst++ = 127;
                    }
            }
            break;

        default:
            assert (1 == 0);
            // NOT IMPLEMENTED.
            break;
        }
}

// TODO: HSV to Gray!
IPLAPIIMPL(void, iplColorToGray,(IplImage* srcImage, IplImage* dstImage))
{
	assert (srcImage->width == dstImage->width);
	assert (srcImage->height == dstImage->height);
	assert (srcImage->depth == dstImage->depth);
	assert (srcImage->depth != IPL_DEPTH_32F);

	char *sdata = srcImage->imageData;	// color
	char *dst = dstImage->imageData;	// BW

	const int h = dstImage->height;
	const int w = dstImage->width;
	const int size = w * h;
	for (int i = 0; i < size; i++)
        {
            short tmp = *sdata++;
            tmp += *sdata++;
            tmp += *sdata++;
            tmp /= 3;

            *dst++ = char(tmp);
        }
}

IPLAPIIMPL(IplROI *,iplCreateROI,(int coi,    int xOffset, int   yOffset,
                                  int width, int height ))
{
	// NOT IMPLEMENTED YET.
	assert (implemented_yet == 0);
	return NULL;
}

IPLAPIIMPL(void, iplSetROI,(IplROI*   roi,      int coi,
                            int       xOffset,  int yOffset,
                            int width,          int height))
{
	assert (implemented_yet == 0);
}

// LATER: image types are not checked.
// It should be RGB not signed.
IPLAPIIMPL(void, iplRGB2HSV,(IplImage* rgbImage, IplImage* hsvImage))
{
	// Image types should be checked.
	//const int planesize = rgbImage->widthStep * rgbImage->height;
	unsigned char *sdata = (unsigned char *)rgbImage->imageData; // bgr
	unsigned char *ddata0 = (unsigned char *)hsvImage->imageData;		// Hue.
	unsigned char *ddata1 = ddata0 + 1;		// Saturation.
	unsigned char *ddata2 = ddata1 + 1;		// Value.

	double max,min;
	double red,green,blue;
	double hue,sat;

	const int width = rgbImage->width;
	const int height = rgbImage->height;
	const int size = width * height; // # of pixels.

	for (int i = 0; i < size; i++)
        {
            blue = *sdata++ / 255.0;
            green = *sdata++ / 255.0;
            red = *sdata++ / 255.0;

            if (red > green && red > blue) 
                {
                    max = red;
                    if (green > blue)
                        min = blue;
                    else
                        min = green;
                }
            else
                if (green > red && green > blue)
                    {
                        max = green;
                        if (red > blue)
                            min = blue;
                        else
                            min = red;
                    }
                else
                    {
                        max = blue;
                        if (red > green)
                            min = green;
                        else
                            min = red;
                    }

            // value
            *ddata2 = (unsigned char)(255.0 * max);
            ddata2 += 3;

            // saturation
            if (max != 0.0)
                {
                    sat = *ddata1 = (unsigned char)(255 * (max - min) / max);
                }
            else
                sat = *ddata1 = 0;
            ddata1 += 3;

            // hue
            if (sat == 0)
                *ddata0 = 0;
            else
                {
                    double rc = (max - red) / (max - min);
                    double gc = (max - green) / (max - min);
                    double bc = (max - blue) / (max - min);
                    if (red == max)
                        hue = bc - gc;
                    else
                        if (green == max)
                            hue = 2 + rc - bc;
                        else
                            if (blue == max)
                                hue = 4 + gc - rc;

                    hue *= 60.0;
                    if (hue < 0.0)
                        hue += 360.0;
		
                    assert (hue >= 0.0 && hue < 360.0);
                    // IPL 2.5 compatibility. Scaling to 0-255
                    // there's a little chance that the value rounds to 256.0!
                    // need clipping rather than truncation.
                    hue = (hue / 360.0 * 256.0);
                    if (hue == 256.0)
                        hue = 255.0;

                    *ddata0 = (unsigned char)(hue);
                }

            ddata0 += 3;
        }
}

IPLAPIIMPL(void, iplHSV2RGB,(IplImage* hsvImage, IplImage* rgbImage))
{
	// NOT IMPLEMENTED YET.
	assert (implemented_yet == 0);
}

IPLAPIIMPL(void, iplXorS,(IplImage* srcImage, IplImage* dstImage,
                          unsigned int value))
{
	// NOT IMPLEMENTED YET.s
	assert (1 == 0);
}

// computes the number of pad bytes (end of line) give the line len and 
// the requested alignment in byte 
inline int _iplCalcPadding (int lineSize, int align)
{
	return PAD_BYTES (lineSize, align);
}

// not used outside this file.
#undef IPLAPIIMPL