📄 cvcolor.c
字号:
xyzXb##suffix, xyzXg##suffix, xyzXr##suffix, \
xyzYb##suffix, xyzYg##suffix, xyzYr##suffix, \
xyzZb##suffix, xyzZg##suffix, xyzZr##suffix \
}; \
\
if( icvRGB2XYZ_##flavor##_C3R_p ) \
return icvBGRx2ABC_IPP_##flavor##_CnC3R( src, srcstep, \
dst, dststep, size, src_cn, blue_idx, \
icvRGB2XYZ_##flavor##_C3R_p ); \
\
srcstep /= sizeof(src[0]); \
dststep /= sizeof(dst[0]); \
srcstep -= size.width*src_cn; \
size.width *= 3; \
\
if( blue_idx ) \
{ \
CV_SWAP( matrix[0], matrix[2], t ); \
CV_SWAP( matrix[3], matrix[5], t ); \
CV_SWAP( matrix[6], matrix[8], t ); \
} \
\
for( ; size.height--; src += srcstep, dst += dststep ) \
{ \
for( i = 0; i < size.width; i += 3, src += src_cn ) \
{ \
worktype x = scale_macro(src[0]*matrix[0] + \
src[1]*matrix[1] + src[2]*matrix[2]); \
worktype y = scale_macro(src[0]*matrix[3] + \
src[1]*matrix[4] + src[2]*matrix[5]); \
worktype z = scale_macro(src[0]*matrix[6] + \
src[1]*matrix[7] + src[2]*matrix[8]); \
\
dst[i] = (arrtype)(x); \
dst[i+1] = (arrtype)(y); \
dst[i+2] = cast_macro(z); /*sum of weights for z > 1*/ \
} \
} \
\
return CV_OK; \
}
CV_IMPL_BGRx2XYZ( 8u, uchar, int, xyz_descale, CV_CAST_8U, _32s )
CV_IMPL_BGRx2XYZ( 16u, ushort, int, xyz_descale, CV_CAST_16U, _32s )
CV_IMPL_BGRx2XYZ( 32f, float, float, CV_NOP, CV_NOP, _32f )
#define CV_IMPL_XYZ2BGRx( flavor, arrtype, worktype, scale_macro, \
cast_macro, suffix ) \
static CvStatus CV_STDCALL \
icvXYZ2BGRx_##flavor##_C3CnR( const arrtype* src, int srcstep, \
arrtype* dst, int dststep, CvSize size, \
int dst_cn, int blue_idx ) \
{ \
int i; \
worktype t, matrix[] = \
{ \
xyzBx##suffix, xyzBy##suffix, xyzBz##suffix, \
xyzGx##suffix, xyzGy##suffix, xyzGz##suffix, \
xyzRx##suffix, xyzRy##suffix, xyzRz##suffix \
}; \
\
if( icvXYZ2RGB_##flavor##_C3R_p ) \
return icvABC2BGRx_IPP_##flavor##_C3CnR( src, srcstep, \
dst, dststep, size, dst_cn, blue_idx, \
icvXYZ2RGB_##flavor##_C3R_p ); \
\
srcstep /= sizeof(src[0]); \
dststep /= sizeof(dst[0]); \
dststep -= size.width*dst_cn; \
size.width *= 3; \
\
if( blue_idx ) \
{ \
CV_SWAP( matrix[0], matrix[6], t ); \
CV_SWAP( matrix[1], matrix[7], t ); \
CV_SWAP( matrix[2], matrix[8], t ); \
} \
\
for( ; size.height--; src += srcstep, dst += dststep ) \
{ \
for( i = 0; i < size.width; i += 3, dst += dst_cn ) \
{ \
worktype b = scale_macro(src[i]*matrix[0] + \
src[i+1]*matrix[1] + src[i+2]*matrix[2]); \
worktype g = scale_macro(src[i]*matrix[3] + \
src[i+1]*matrix[4] + src[i+2]*matrix[5]); \
worktype r = scale_macro(src[i]*matrix[6] + \
src[i+1]*matrix[7] + src[i+2]*matrix[8]); \
\
dst[0] = cast_macro(b); \
dst[1] = cast_macro(g); \
dst[2] = cast_macro(r); \
\
if( dst_cn == 4 ) \
dst[3] = 0; \
} \
} \
\
return CV_OK; \
}
CV_IMPL_XYZ2BGRx( 8u, uchar, int, xyz_descale, CV_CAST_8U, _32s )
CV_IMPL_XYZ2BGRx( 16u, ushort, int, xyz_descale, CV_CAST_16U, _32s )
CV_IMPL_XYZ2BGRx( 32f, float, float, CV_NOP, CV_NOP, _32f )
/****************************************************************************************\
* Non-linear Color Space Transformations *
\****************************************************************************************/
// driver color space conversion function for 8u arrays that uses 32f function
// with appropriate pre- and post-scaling.
static CvStatus CV_STDCALL
icvABC2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
CvSize size, int dst_cn, int blue_idx, CvColorCvtFunc2 cvtfunc_32f,
const float* pre_coeffs, int postscale )
{
int block_size = MIN(1 << 8, size.width);
float* buffer = (float*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
int i, di, k;
CvStatus status = CV_OK;
dststep -= size.width*dst_cn;
for( ; size.height--; src += srcstep, dst += dststep )
{
for( i = 0; i < size.width; i += block_size )
{
const uchar* src1 = src + i*3;
di = MIN(block_size, size.width - i);
for( k = 0; k < di*3; k += 3 )
{
float a = CV_8TO32F(src1[k])*pre_coeffs[0] + pre_coeffs[1];
float b = CV_8TO32F(src1[k+1])*pre_coeffs[2] + pre_coeffs[3];
float c = CV_8TO32F(src1[k+2])*pre_coeffs[4] + pre_coeffs[5];
buffer[k] = a;
buffer[k+1] = b;
buffer[k+2] = c;
}
status = cvtfunc_32f( buffer, 0, buffer, 0, cvSize(di,1), 3, blue_idx );
if( status < 0 )
return status;
if( postscale )
{
for( k = 0; k < di*3; k += 3, dst += dst_cn )
{
int b = cvRound(buffer[k]*255.);
int g = cvRound(buffer[k+1]*255.);
int r = cvRound(buffer[k+2]*255.);
dst[0] = CV_CAST_8U(b);
dst[1] = CV_CAST_8U(g);
dst[2] = CV_CAST_8U(r);
if( dst_cn == 4 )
dst[3] = 0;
}
}
else
{
for( k = 0; k < di*3; k += 3, dst += dst_cn )
{
int b = cvRound(buffer[k]);
int g = cvRound(buffer[k+1]);
int r = cvRound(buffer[k+2]);
dst[0] = CV_CAST_8U(b);
dst[1] = CV_CAST_8U(g);
dst[2] = CV_CAST_8U(r);
if( dst_cn == 4 )
dst[3] = 0;
}
}
}
}
return CV_OK;
}
// driver color space conversion function for 8u arrays that uses 32f function
// with appropriate pre- and post-scaling.
static CvStatus CV_STDCALL
icvBGRx2ABC_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep,
CvSize size, int src_cn, int blue_idx, CvColorCvtFunc2 cvtfunc_32f,
int prescale, const float* post_coeffs )
{
int block_size = MIN(1 << 8, size.width);
float* buffer = (float*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
int i, di, k;
CvStatus status = CV_OK;
srcstep -= size.width*src_cn;
for( ; size.height--; src += srcstep, dst += dststep )
{
for( i = 0; i < size.width; i += block_size )
{
uchar* dst1 = dst + i*3;
di = MIN(block_size, size.width - i);
if( prescale )
{
for( k = 0; k < di*3; k += 3, src += src_cn )
{
float b = CV_8TO32F(src[0])*0.0039215686274509803f;
float g = CV_8TO32F(src[1])*0.0039215686274509803f;
float r = CV_8TO32F(src[2])*0.0039215686274509803f;
buffer[k] = b;
buffer[k+1] = g;
buffer[k+2] = r;
}
}
else
{
for( k = 0; k < di*3; k += 3, src += src_cn )
{
float b = CV_8TO32F(src[0]);
float g = CV_8TO32F(src[1]);
float r = CV_8TO32F(src[2]);
buffer[k] = b;
buffer[k+1] = g;
buffer[k+2] = r;
}
}
status = cvtfunc_32f( buffer, 0, buffer, 0, cvSize(di,1), 3, blue_idx );
if( status < 0 )
return status;
for( k = 0; k < di*3; k += 3 )
{
int a = cvRound( buffer[k]*post_coeffs[0] + post_coeffs[1] );
int b = cvRound( buffer[k+1]*post_coeffs[2] + post_coeffs[3] );
int c = cvRound( buffer[k+2]*post_coeffs[4] + post_coeffs[5] );
dst1[k] = CV_CAST_8U(a);
dst1[k+1] = CV_CAST_8U(b);
dst1[k+2] = CV_CAST_8U(c);
}
}
}
return CV_OK;
}
/****************************************************************************************\
* RGB <-> HSV *
\****************************************************************************************/
static const uchar icvHue255To180[] =
{
0, 1, 1, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11,
11, 12, 13, 13, 14, 15, 16, 16, 17, 18, 18, 19, 20, 20, 21, 22,
23, 23, 24, 25, 25, 26, 27, 28, 28, 29, 30, 30, 31, 32, 32, 33,
34, 35, 35, 36, 37, 37, 38, 39, 40, 40, 41, 42, 42, 43, 44, 44,
45, 46, 47, 47, 48, 49, 49, 50, 51, 52, 52, 53, 54, 54, 55, 56,
56, 57, 58, 59, 59, 60, 61, 61, 62, 63, 64, 64, 65, 66, 66, 67,
68, 68, 69, 70, 71, 71, 72, 73, 73, 74, 75, 76, 76, 77, 78, 78,
79, 80, 80, 81, 82, 83, 83, 84, 85, 85, 86, 87, 88, 88, 89, 90,
90, 91, 92, 92, 93, 94, 95, 95, 96, 97, 97, 98, 99, 100, 100, 101,
102, 102, 103, 104, 104, 105, 106, 107, 107, 108, 109, 109, 110, 111, 112, 112,
113, 114, 114, 115, 116, 116, 117, 118, 119, 119, 120, 121, 121, 122, 123, 124,
124, 125, 126, 126, 127, 128, 128, 129, 130, 131, 131, 132, 133, 133, 134, 135,
136, 136, 137, 138, 138, 139, 140, 140, 141, 142, 143, 143, 144, 145, 145, 146,
147, 148, 148, 149, 150, 150, 151, 152, 152, 153, 154, 155, 155, 156, 157, 157,
158, 159, 160, 160, 161, 162, 162, 163, 164, 164, 165, 166, 167, 167, 168, 169,
169, 170, 171, 172, 172, 173, 174, 174, 175, 176, 176, 177, 178, 179, 179, 180
};
static const uchar icvHue180To255[] =
{
0, 1, 3, 4, 6, 7, 9, 10, 11, 13, 14, 16, 17, 18, 20, 21,
23, 24, 26, 27, 28, 30, 31, 33, 34, 35, 37, 38, 40, 41, 43, 44,
45, 47, 48, 50, 51, 52, 54, 55, 57, 58, 60, 61, 62, 64, 65, 67,
68, 69, 71, 72, 74, 75, 77, 78, 79, 81, 82, 84, 85, 86, 88, 89,
91, 92, 94, 95, 96, 98, 99, 101, 102, 103, 105, 106, 108, 109, 111, 112,
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -