| /*M/////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. |
| // |
| // By downloading, copying, installing or using the software you agree to this license. |
| // If you do not agree to this license, do not download, install, |
| // copy or use the software. |
| // |
| // Intel License Agreement |
| // For Open Source Computer Vision Library |
| // |
| // Copyright (C) 2000, Intel Corporation, all rights reserved. |
| // Third party copyrights are property of their respective owners. |
| // |
| // Redistribution and use in source and binary forms, with or without modification, |
| // are permitted provided that the following conditions are met: |
| // |
| // * Redistribution's of source code must retain the above copyright notice, |
| // this list of conditions and the following disclaimer. |
| // |
| // * Redistribution's in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // * The name of Intel Corporation may not be used to endorse or promote products |
| // derived from this software without specific prior written permission. |
| // |
| // This software is provided by the copyright holders and contributors "as is" and |
| // any express or implied warranties, including, but not limited to, the implied |
| // warranties of merchantability and fitness for a particular purpose are disclaimed. |
| // In no event shall the Intel Corporation or contributors be liable for any direct, |
| // indirect, incidental, special, exemplary, or consequential damages |
| // (including, but not limited to, procurement of substitute goods or services; |
| // loss of use, data, or profits; or business interruption) however caused |
| // and on any theory of liability, whether in contract, strict liability, |
| // or tort (including negligence or otherwise) arising in any way out of |
| // the use of this software, even if advised of the possibility of such damage. |
| // |
| //M*/ |
| |
| /********************************* COPYRIGHT NOTICE *******************************\ |
| The function for RGB to Lab conversion is based on the MATLAB script |
| RGB2Lab.m translated by Mark Ruzon from C code by Yossi Rubner, 23 September 1997. |
| See the page [http://vision.stanford.edu/~ruzon/software/rgblab.html] |
| \**********************************************************************************/ |
| |
| /********************************* COPYRIGHT NOTICE *******************************\ |
| Original code for Bayer->BGR/RGB conversion is provided by Dirk Schaefer |
| from MD-Mathematische Dienste GmbH. Below is the copyright notice: |
| |
| IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. |
| By downloading, copying, installing or using the software you agree |
| to this license. If you do not agree to this license, do not download, |
| install, copy or use the software. |
| |
| Contributors License Agreement: |
| |
| Copyright (c) 2002, |
| MD-Mathematische Dienste GmbH |
| Im Defdahl 5-10 |
| 44141 Dortmund |
| Germany |
| www.md-it.de |
| |
| Redistribution and use in source and binary forms, |
| with or without modification, are permitted provided |
| that the following conditions are met: |
| |
| Redistributions of source code must retain |
| the above copyright notice, this list of conditions and the following disclaimer. |
| Redistributions in binary form must reproduce the above copyright notice, |
| this list of conditions and the following disclaimer in the documentation |
| and/or other materials provided with the distribution. |
| The name of Contributor may not be used to endorse or promote products |
| derived from this software without specific prior written permission. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE |
| FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| THE POSSIBILITY OF SUCH DAMAGE. |
| \**********************************************************************************/ |
| |
| #include "_cv.h" |
| |
| typedef CvStatus (CV_STDCALL * CvColorCvtFunc0)( |
| const void* src, int srcstep, void* dst, int dststep, CvSize size ); |
| |
| typedef CvStatus (CV_STDCALL * CvColorCvtFunc1)( |
| const void* src, int srcstep, void* dst, int dststep, |
| CvSize size, int param0 ); |
| |
| typedef CvStatus (CV_STDCALL * CvColorCvtFunc2)( |
| const void* src, int srcstep, void* dst, int dststep, |
| CvSize size, int param0, int param1 ); |
| |
| typedef CvStatus (CV_STDCALL * CvColorCvtFunc3)( |
| const void* src, int srcstep, void* dst, int dststep, |
| CvSize size, int param0, int param1, int param2 ); |
| |
| /****************************************************************************************\ |
| * Various 3/4-channel to 3/4-channel RGB transformations * |
| \****************************************************************************************/ |
| |
| #define CV_IMPL_BGRX2BGR( flavor, arrtype ) \ |
| static CvStatus CV_STDCALL \ |
| icvBGRx2BGR_##flavor##_CnC3R( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, \ |
| CvSize size, int src_cn, int blue_idx ) \ |
| { \ |
| int i; \ |
| \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(dst[0]); \ |
| srcstep -= size.width*src_cn; \ |
| size.width *= 3; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| for( i = 0; i < size.width; i += 3, src += src_cn ) \ |
| { \ |
| arrtype t0=src[blue_idx], t1=src[1], t2=src[blue_idx^2]; \ |
| dst[i] = t0; \ |
| dst[i+1] = t1; \ |
| dst[i+2] = t2; \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| |
| #define CV_IMPL_BGR2BGRX( flavor, arrtype ) \ |
| static CvStatus CV_STDCALL \ |
| icvBGR2BGRx_##flavor##_C3C4R( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, \ |
| CvSize size, int blue_idx ) \ |
| { \ |
| int i; \ |
| \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(dst[0]); \ |
| srcstep -= size.width*3; \ |
| size.width *= 4; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| for( i = 0; i < size.width; i += 4, src += 3 ) \ |
| { \ |
| arrtype t0=src[blue_idx], t1=src[1], t2=src[blue_idx^2]; \ |
| dst[i] = t0; \ |
| dst[i+1] = t1; \ |
| dst[i+2] = t2; \ |
| dst[i+3] = 0; \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| |
| #define CV_IMPL_BGRA2RGBA( flavor, arrtype ) \ |
| static CvStatus CV_STDCALL \ |
| icvBGRA2RGBA_##flavor##_C4R( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, CvSize size ) \ |
| { \ |
| int i; \ |
| \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(dst[0]); \ |
| size.width *= 4; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| for( i = 0; i < size.width; i += 4 ) \ |
| { \ |
| arrtype t0 = src[2], t1 = src[1], t2 = src[0], t3 = src[3]; \ |
| dst[i] = t0; \ |
| dst[i+1] = t1; \ |
| dst[i+2] = t2; \ |
| dst[i+3] = t3; \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| |
| CV_IMPL_BGRX2BGR( 8u, uchar ) |
| CV_IMPL_BGRX2BGR( 16u, ushort ) |
| CV_IMPL_BGRX2BGR( 32f, int ) |
| CV_IMPL_BGR2BGRX( 8u, uchar ) |
| CV_IMPL_BGR2BGRX( 16u, ushort ) |
| CV_IMPL_BGR2BGRX( 32f, int ) |
| CV_IMPL_BGRA2RGBA( 8u, uchar ) |
| CV_IMPL_BGRA2RGBA( 16u, ushort ) |
| CV_IMPL_BGRA2RGBA( 32f, int ) |
| |
| |
| /****************************************************************************************\ |
| * Transforming 16-bit (565 or 555) RGB to/from 24/32-bit (888[8]) RGB * |
| \****************************************************************************************/ |
| |
| static CvStatus CV_STDCALL |
| icvBGR5x52BGRx_8u_C2CnR( const uchar* src, int srcstep, |
| uchar* dst, int dststep, |
| CvSize size, int dst_cn, |
| int blue_idx, int green_bits ) |
| { |
| int i; |
| assert( green_bits == 5 || green_bits == 6 ); |
| dststep -= size.width*dst_cn; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| if( green_bits == 6 ) |
| for( i = 0; i < size.width; i++, dst += dst_cn ) |
| { |
| unsigned t = ((const ushort*)src)[i]; |
| dst[blue_idx] = (uchar)(t << 3); |
| dst[1] = (uchar)((t >> 3) & ~3); |
| dst[blue_idx ^ 2] = (uchar)((t >> 8) & ~7); |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| else |
| for( i = 0; i < size.width; i++, dst += dst_cn ) |
| { |
| unsigned t = ((const ushort*)src)[i]; |
| dst[blue_idx] = (uchar)(t << 3); |
| dst[1] = (uchar)((t >> 2) & ~7); |
| dst[blue_idx ^ 2] = (uchar)((t >> 7) & ~7); |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2BGR5x5_8u_CnC2R( const uchar* src, int srcstep, |
| uchar* dst, int dststep, |
| CvSize size, int src_cn, |
| int blue_idx, int green_bits ) |
| { |
| int i; |
| srcstep -= size.width*src_cn; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| if( green_bits == 6 ) |
| for( i = 0; i < size.width; i++, src += src_cn ) |
| { |
| int t = (src[blue_idx] >> 3)|((src[1]&~3) << 3)|((src[blue_idx^2]&~7) << 8); |
| ((ushort*)dst)[i] = (ushort)t; |
| } |
| else |
| for( i = 0; i < size.width; i++, src += src_cn ) |
| { |
| int t = (src[blue_idx] >> 3)|((src[1]&~7) << 2)|((src[blue_idx^2]&~7) << 7); |
| ((ushort*)dst)[i] = (ushort)t; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| |
| /////////////////////////// IPP Color Conversion Functions ////////////////////////////// |
| |
| icvRGB2XYZ_8u_C3R_t icvRGB2XYZ_8u_C3R_p = 0; |
| icvRGB2XYZ_16u_C3R_t icvRGB2XYZ_16u_C3R_p = 0; |
| icvRGB2XYZ_32f_C3R_t icvRGB2XYZ_32f_C3R_p = 0; |
| icvXYZ2RGB_8u_C3R_t icvXYZ2RGB_8u_C3R_p = 0; |
| icvXYZ2RGB_16u_C3R_t icvXYZ2RGB_16u_C3R_p = 0; |
| icvXYZ2RGB_32f_C3R_t icvXYZ2RGB_32f_C3R_p = 0; |
| |
| icvRGB2HSV_8u_C3R_t icvRGB2HSV_8u_C3R_p = 0; |
| icvHSV2RGB_8u_C3R_t icvHSV2RGB_8u_C3R_p = 0; |
| |
| icvBGR2Lab_8u_C3R_t icvBGR2Lab_8u_C3R_p = 0; |
| icvLab2BGR_8u_C3R_t icvLab2BGR_8u_C3R_p = 0; |
| |
| icvRGB2HLS_8u_C3R_t icvRGB2HLS_8u_C3R_p = 0; |
| icvRGB2HLS_32f_C3R_t icvRGB2HLS_32f_C3R_p = 0; |
| icvHLS2RGB_8u_C3R_t icvHLS2RGB_8u_C3R_p = 0; |
| icvHLS2RGB_32f_C3R_t icvHLS2RGB_32f_C3R_p = 0; |
| |
| icvRGB2Luv_8u_C3R_t icvRGB2Luv_8u_C3R_p = 0; |
| icvLuv2RGB_8u_C3R_t icvLuv2RGB_8u_C3R_p = 0; |
| |
| //icvRGB2Luv_32f_C3R_t icvRGB2Luv_32f_C3R_p = 0; |
| //icvLuv2RGB_32f_C3R_t icvLuv2RGB_32f_C3R_p = 0; |
| //icvRGB2Luv_32f_C3R_t icvRGB2Luv_32f_C3R_p = 0; |
| //icvLuv2RGB_32f_C3R_t icvLuv2RGB_32f_C3R_p = 0; |
| |
| |
| #define CV_IMPL_BGRx2ABC_IPP( flavor, arrtype ) \ |
| static CvStatus CV_STDCALL \ |
| icvBGRx2ABC_IPP_##flavor##_CnC3R( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, CvSize size, int src_cn, \ |
| int blue_idx, CvColorCvtFunc0 ipp_func ) \ |
| { \ |
| int block_size = MIN(1 << 14, size.width); \ |
| arrtype* buffer; \ |
| int i, di, k; \ |
| int do_copy = src_cn > 3 || blue_idx != 2 || src == dst; \ |
| CvStatus status = CV_OK; \ |
| \ |
| if( !do_copy ) \ |
| return ipp_func( src, srcstep, dst, dststep, size ); \ |
| \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(dst[0]); \ |
| \ |
| buffer = (arrtype*)cvStackAlloc( block_size*3*sizeof(buffer[0]) ); \ |
| srcstep -= size.width*src_cn; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| for( i = 0; i < size.width; i += block_size ) \ |
| { \ |
| arrtype* dst1 = dst + i*3; \ |
| di = MIN(block_size, size.width - i); \ |
| \ |
| for( k = 0; k < di*3; k += 3, src += src_cn ) \ |
| { \ |
| arrtype b = src[blue_idx]; \ |
| arrtype g = src[1]; \ |
| arrtype r = src[blue_idx^2]; \ |
| buffer[k] = r; \ |
| buffer[k+1] = g; \ |
| buffer[k+2] = b; \ |
| } \ |
| \ |
| status = ipp_func( buffer, CV_STUB_STEP, \ |
| dst1, CV_STUB_STEP, cvSize(di,1) ); \ |
| if( status < 0 ) \ |
| return status; \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2ABC_IPP_8u_CnC3R( const uchar* src, int srcstep, |
| uchar* dst, int dststep, CvSize size, int src_cn, |
| int blue_idx, CvColorCvtFunc0 ipp_func ) |
| { |
| int block_size = MIN(1 << 14, size.width); |
| uchar* buffer; |
| int i, di, k; |
| int do_copy = src_cn > 3 || blue_idx != 2 || src == dst; |
| CvStatus status = CV_OK; |
| |
| if( !do_copy ) |
| return ipp_func( src, srcstep, dst, dststep, size ); |
| |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| |
| buffer = (uchar*)cvStackAlloc( block_size*3*sizeof(buffer[0]) ); |
| 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); |
| |
| for( k = 0; k < di*3; k += 3, src += src_cn ) |
| { |
| uchar b = src[blue_idx]; |
| uchar g = src[1]; |
| uchar r = src[blue_idx^2]; |
| buffer[k] = r; |
| buffer[k+1] = g; |
| buffer[k+2] = b; |
| } |
| |
| status = ipp_func( buffer, CV_STUB_STEP, |
| dst1, CV_STUB_STEP, cvSize(di,1) ); |
| if( status < 0 ) |
| return status; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| |
| //CV_IMPL_BGRx2ABC_IPP( 8u, uchar ) |
| CV_IMPL_BGRx2ABC_IPP( 16u, ushort ) |
| CV_IMPL_BGRx2ABC_IPP( 32f, float ) |
| |
| #define CV_IMPL_ABC2BGRx_IPP( flavor, arrtype ) \ |
| static CvStatus CV_STDCALL \ |
| icvABC2BGRx_IPP_##flavor##_C3CnR( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, CvSize size, int dst_cn, \ |
| int blue_idx, CvColorCvtFunc0 ipp_func ) \ |
| { \ |
| int block_size = MIN(1 << 10, size.width); \ |
| arrtype* buffer; \ |
| int i, di, k; \ |
| int do_copy = dst_cn > 3 || blue_idx != 2 || src == dst; \ |
| CvStatus status = CV_OK; \ |
| \ |
| if( !do_copy ) \ |
| return ipp_func( src, srcstep, dst, dststep, size ); \ |
| \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(dst[0]); \ |
| \ |
| buffer = (arrtype*)cvStackAlloc( block_size*3*sizeof(buffer[0]) ); \ |
| dststep -= size.width*dst_cn; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| for( i = 0; i < size.width; i += block_size ) \ |
| { \ |
| const arrtype* src1 = src + i*3; \ |
| di = MIN(block_size, size.width - i); \ |
| \ |
| status = ipp_func( src1, CV_STUB_STEP, \ |
| buffer, CV_STUB_STEP, cvSize(di,1) ); \ |
| if( status < 0 ) \ |
| return status; \ |
| \ |
| for( k = 0; k < di*3; k += 3, dst += dst_cn ) \ |
| { \ |
| arrtype r = buffer[k]; \ |
| arrtype g = buffer[k+1]; \ |
| arrtype b = buffer[k+2]; \ |
| dst[blue_idx] = b; \ |
| dst[1] = g; \ |
| dst[blue_idx^2] = r; \ |
| if( dst_cn == 4 ) \ |
| dst[3] = 0; \ |
| } \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| CV_IMPL_ABC2BGRx_IPP( 8u, uchar ) |
| CV_IMPL_ABC2BGRx_IPP( 16u, ushort ) |
| CV_IMPL_ABC2BGRx_IPP( 32f, float ) |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////////////// |
| |
| |
| /****************************************************************************************\ |
| * Color to/from Grayscale * |
| \****************************************************************************************/ |
| |
| #define fix(x,n) (int)((x)*(1 << (n)) + 0.5) |
| #define descale CV_DESCALE |
| |
| #define cscGr_32f 0.299f |
| #define cscGg_32f 0.587f |
| #define cscGb_32f 0.114f |
| |
| /* BGR/RGB -> Gray */ |
| #define csc_shift 14 |
| #define cscGr fix(cscGr_32f,csc_shift) |
| #define cscGg fix(cscGg_32f,csc_shift) |
| #define cscGb /*fix(cscGb_32f,csc_shift)*/ ((1 << csc_shift) - cscGr - cscGg) |
| |
| #define CV_IMPL_GRAY2BGRX( flavor, arrtype ) \ |
| static CvStatus CV_STDCALL \ |
| icvGray2BGRx_##flavor##_C1CnR( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, CvSize size, \ |
| int dst_cn ) \ |
| { \ |
| int i; \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(src[0]); \ |
| dststep -= size.width*dst_cn; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| if( dst_cn == 3 ) \ |
| for( i = 0; i < size.width; i++, dst += 3 ) \ |
| dst[0] = dst[1] = dst[2] = src[i]; \ |
| else \ |
| for( i = 0; i < size.width; i++, dst += 4 ) \ |
| { \ |
| dst[0] = dst[1] = dst[2] = src[i]; \ |
| dst[3] = 0; \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| |
| CV_IMPL_GRAY2BGRX( 8u, uchar ) |
| CV_IMPL_GRAY2BGRX( 16u, ushort ) |
| CV_IMPL_GRAY2BGRX( 32f, float ) |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGR5x52Gray_8u_C2C1R( const uchar* src, int srcstep, |
| uchar* dst, int dststep, |
| CvSize size, int green_bits ) |
| { |
| int i; |
| assert( green_bits == 5 || green_bits == 6 ); |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| if( green_bits == 6 ) |
| for( i = 0; i < size.width; i++ ) |
| { |
| int t = ((ushort*)src)[i]; |
| t = ((t << 3) & 0xf8)*cscGb + ((t >> 3) & 0xfc)*cscGg + |
| ((t >> 8) & 0xf8)*cscGr; |
| dst[i] = (uchar)CV_DESCALE(t,csc_shift); |
| } |
| else |
| for( i = 0; i < size.width; i++ ) |
| { |
| int t = ((ushort*)src)[i]; |
| t = ((t << 3) & 0xf8)*cscGb + ((t >> 2) & 0xf8)*cscGg + |
| ((t >> 7) & 0xf8)*cscGr; |
| dst[i] = (uchar)CV_DESCALE(t,csc_shift); |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvGray2BGR5x5_8u_C1C2R( const uchar* src, int srcstep, |
| uchar* dst, int dststep, |
| CvSize size, int green_bits ) |
| { |
| int i; |
| assert( green_bits == 5 || green_bits == 6 ); |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| if( green_bits == 6 ) |
| for( i = 0; i < size.width; i++ ) |
| { |
| int t = src[i]; |
| ((ushort*)dst)[i] = (ushort)((t >> 3)|((t & ~3) << 3)|((t & ~7) << 8)); |
| } |
| else |
| for( i = 0; i < size.width; i++ ) |
| { |
| int t = src[i] >> 3; |
| ((ushort*)dst)[i] = (ushort)(t|(t << 5)|(t << 10)); |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2Gray_8u_CnC1R( const uchar* src, int srcstep, |
| uchar* dst, int dststep, CvSize size, |
| int src_cn, int blue_idx ) |
| { |
| int i; |
| srcstep -= size.width*src_cn; |
| |
| if( size.width*size.height >= 1024 ) |
| { |
| int* tab = (int*)cvStackAlloc( 256*3*sizeof(tab[0]) ); |
| int r = 0, g = 0, b = (1 << (csc_shift-1)); |
| |
| for( i = 0; i < 256; i++ ) |
| { |
| tab[i] = b; |
| tab[i+256] = g; |
| tab[i+512] = r; |
| g += cscGg; |
| if( !blue_idx ) |
| b += cscGb, r += cscGr; |
| else |
| b += cscGr, r += cscGb; |
| } |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i++, src += src_cn ) |
| { |
| int t0 = tab[src[0]] + tab[src[1] + 256] + tab[src[2] + 512]; |
| dst[i] = (uchar)(t0 >> csc_shift); |
| } |
| } |
| } |
| else |
| { |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i++, src += src_cn ) |
| { |
| int t0 = src[blue_idx]*cscGb + src[1]*cscGg + src[blue_idx^2]*cscGr; |
| dst[i] = (uchar)CV_DESCALE(t0, csc_shift); |
| } |
| } |
| } |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2Gray_16u_CnC1R( const ushort* src, int srcstep, |
| ushort* dst, int dststep, CvSize size, |
| int src_cn, int blue_idx ) |
| { |
| int i; |
| int cb = cscGb, cr = cscGr; |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| srcstep -= size.width*src_cn; |
| |
| if( blue_idx ) |
| cb = cscGr, cr = cscGb; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| for( i = 0; i < size.width; i++, src += src_cn ) |
| dst[i] = (ushort)CV_DESCALE((unsigned)(src[0]*cb + |
| src[1]*cscGg + src[2]*cr), csc_shift); |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2Gray_32f_CnC1R( const float* src, int srcstep, |
| float* dst, int dststep, CvSize size, |
| int src_cn, int blue_idx ) |
| { |
| int i; |
| float cb = cscGb_32f, cr = cscGr_32f; |
| if( blue_idx ) |
| cb = cscGr_32f, cr = cscGb_32f; |
| |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| srcstep -= size.width*src_cn; |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| for( i = 0; i < size.width; i++, src += src_cn ) |
| dst[i] = src[0]*cb + src[1]*cscGg_32f + src[2]*cr; |
| |
| return CV_OK; |
| } |
| |
| |
| /****************************************************************************************\ |
| * RGB <-> YCrCb * |
| \****************************************************************************************/ |
| |
| /* BGR/RGB -> YCrCb */ |
| #define yuvYr_32f cscGr_32f |
| #define yuvYg_32f cscGg_32f |
| #define yuvYb_32f cscGb_32f |
| #define yuvCr_32f 0.713f |
| #define yuvCb_32f 0.564f |
| |
| #define yuv_shift 14 |
| #define yuvYr fix(yuvYr_32f,yuv_shift) |
| #define yuvYg fix(yuvYg_32f,yuv_shift) |
| #define yuvYb fix(yuvYb_32f,yuv_shift) |
| #define yuvCr fix(yuvCr_32f,yuv_shift) |
| #define yuvCb fix(yuvCb_32f,yuv_shift) |
| |
| #define yuv_descale(x) CV_DESCALE((x), yuv_shift) |
| #define yuv_prescale(x) ((x) << yuv_shift) |
| |
| #define yuvRCr_32f 1.403f |
| #define yuvGCr_32f (-0.714f) |
| #define yuvGCb_32f (-0.344f) |
| #define yuvBCb_32f 1.773f |
| |
| #define yuvRCr fix(yuvRCr_32f,yuv_shift) |
| #define yuvGCr (-fix(-yuvGCr_32f,yuv_shift)) |
| #define yuvGCb (-fix(-yuvGCb_32f,yuv_shift)) |
| #define yuvBCb fix(yuvBCb_32f,yuv_shift) |
| |
| #define CV_IMPL_BGRx2YCrCb( flavor, arrtype, worktype, scale_macro, cast_macro, \ |
| YUV_YB, YUV_YG, YUV_YR, YUV_CR, YUV_CB, YUV_Cx_BIAS ) \ |
| static CvStatus CV_STDCALL \ |
| icvBGRx2YCrCb_##flavor##_CnC3R( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, CvSize size, int src_cn, int blue_idx ) \ |
| { \ |
| int i; \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(src[0]); \ |
| srcstep -= size.width*src_cn; \ |
| size.width *= 3; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| for( i = 0; i < size.width; i += 3, src += src_cn ) \ |
| { \ |
| worktype b = src[blue_idx], r = src[2^blue_idx], y; \ |
| y = scale_macro(b*YUV_YB + src[1]*YUV_YG + r*YUV_YR); \ |
| r = scale_macro((r - y)*YUV_CR) + YUV_Cx_BIAS; \ |
| b = scale_macro((b - y)*YUV_CB) + YUV_Cx_BIAS; \ |
| dst[i] = cast_macro(y); \ |
| dst[i+1] = cast_macro(r); \ |
| dst[i+2] = cast_macro(b); \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| |
| CV_IMPL_BGRx2YCrCb( 8u, uchar, int, yuv_descale, CV_CAST_8U, |
| yuvYb, yuvYg, yuvYr, yuvCr, yuvCb, 128 ) |
| |
| CV_IMPL_BGRx2YCrCb( 16u, ushort, int, yuv_descale, CV_CAST_16U, |
| yuvYb, yuvYg, yuvYr, yuvCr, yuvCb, 32768 ) |
| |
| CV_IMPL_BGRx2YCrCb( 32f, float, float, CV_NOP, CV_NOP, |
| yuvYb_32f, yuvYg_32f, yuvYr_32f, yuvCr_32f, yuvCb_32f, 0.5f ) |
| |
| |
| #define CV_IMPL_YCrCb2BGRx( flavor, arrtype, worktype, prescale_macro, \ |
| scale_macro, cast_macro, YUV_BCb, YUV_GCr, YUV_GCb, YUV_RCr, YUV_Cx_BIAS)\ |
| static CvStatus CV_STDCALL \ |
| icvYCrCb2BGRx_##flavor##_C3CnR( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, CvSize size, \ |
| int dst_cn, int blue_idx ) \ |
| { \ |
| int i; \ |
| srcstep /= sizeof(src[0]); \ |
| dststep /= sizeof(src[0]); \ |
| dststep -= size.width*dst_cn; \ |
| size.width *= 3; \ |
| \ |
| for( ; size.height--; src += srcstep, dst += dststep ) \ |
| { \ |
| for( i = 0; i < size.width; i += 3, dst += dst_cn ) \ |
| { \ |
| worktype Y = prescale_macro(src[i]), \ |
| Cr = src[i+1] - YUV_Cx_BIAS, \ |
| Cb = src[i+2] - YUV_Cx_BIAS; \ |
| worktype b, g, r; \ |
| b = scale_macro( Y + YUV_BCb*Cb ); \ |
| g = scale_macro( Y + YUV_GCr*Cr + YUV_GCb*Cb ); \ |
| r = scale_macro( Y + YUV_RCr*Cr ); \ |
| \ |
| dst[blue_idx] = cast_macro(b); \ |
| dst[1] = cast_macro(g); \ |
| dst[blue_idx^2] = cast_macro(r); \ |
| if( dst_cn == 4 ) \ |
| dst[3] = 0; \ |
| } \ |
| } \ |
| \ |
| return CV_OK; \ |
| } |
| |
| |
| CV_IMPL_YCrCb2BGRx( 8u, uchar, int, yuv_prescale, yuv_descale, CV_CAST_8U, |
| yuvBCb, yuvGCr, yuvGCb, yuvRCr, 128 ) |
| |
| CV_IMPL_YCrCb2BGRx( 16u, ushort, int, yuv_prescale, yuv_descale, CV_CAST_16U, |
| yuvBCb, yuvGCr, yuvGCb, yuvRCr, 32768 ) |
| |
| CV_IMPL_YCrCb2BGRx( 32f, float, float, CV_NOP, CV_NOP, CV_NOP, |
| yuvBCb_32f, yuvGCr_32f, yuvGCb_32f, yuvRCr_32f, 0.5f ) |
| |
| |
| /****************************************************************************************\ |
| * RGB <-> XYZ * |
| \****************************************************************************************/ |
| |
| #define xyzXr_32f 0.412453f |
| #define xyzXg_32f 0.357580f |
| #define xyzXb_32f 0.180423f |
| |
| #define xyzYr_32f 0.212671f |
| #define xyzYg_32f 0.715160f |
| #define xyzYb_32f 0.072169f |
| |
| #define xyzZr_32f 0.019334f |
| #define xyzZg_32f 0.119193f |
| #define xyzZb_32f 0.950227f |
| |
| #define xyzRx_32f 3.240479f |
| #define xyzRy_32f (-1.53715f) |
| #define xyzRz_32f (-0.498535f) |
| |
| #define xyzGx_32f (-0.969256f) |
| #define xyzGy_32f 1.875991f |
| #define xyzGz_32f 0.041556f |
| |
| #define xyzBx_32f 0.055648f |
| #define xyzBy_32f (-0.204043f) |
| #define xyzBz_32f 1.057311f |
| |
| #define xyz_shift 10 |
| #define xyzXr_32s fix(xyzXr_32f, xyz_shift ) |
| #define xyzXg_32s fix(xyzXg_32f, xyz_shift ) |
| #define xyzXb_32s fix(xyzXb_32f, xyz_shift ) |
| |
| #define xyzYr_32s fix(xyzYr_32f, xyz_shift ) |
| #define xyzYg_32s fix(xyzYg_32f, xyz_shift ) |
| #define xyzYb_32s fix(xyzYb_32f, xyz_shift ) |
| |
| #define xyzZr_32s fix(xyzZr_32f, xyz_shift ) |
| #define xyzZg_32s fix(xyzZg_32f, xyz_shift ) |
| #define xyzZb_32s fix(xyzZb_32f, xyz_shift ) |
| |
| #define xyzRx_32s fix(3.240479f, xyz_shift ) |
| #define xyzRy_32s -fix(1.53715f, xyz_shift ) |
| #define xyzRz_32s -fix(0.498535f, xyz_shift ) |
| |
| #define xyzGx_32s -fix(0.969256f, xyz_shift ) |
| #define xyzGy_32s fix(1.875991f, xyz_shift ) |
| #define xyzGz_32s fix(0.041556f, xyz_shift ) |
| |
| #define xyzBx_32s fix(0.055648f, xyz_shift ) |
| #define xyzBy_32s -fix(0.204043f, xyz_shift ) |
| #define xyzBz_32s fix(1.057311f, xyz_shift ) |
| |
| #define xyz_descale(x) CV_DESCALE((x),xyz_shift) |
| |
| #define CV_IMPL_BGRx2XYZ( flavor, arrtype, worktype, \ |
| scale_macro, cast_macro, suffix ) \ |
| static CvStatus CV_STDCALL \ |
| icvBGRx2XYZ_##flavor##_CnC3R( const arrtype* src, int srcstep, \ |
| arrtype* dst, int dststep, CvSize size, \ |
| int src_cn, int blue_idx ) \ |
| { \ |
| int i; \ |
| worktype t, matrix[] = \ |
| { \ |
| 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, |
| 113, 115, 116, 118, 119, 120, 122, 123, 125, 126, 128, 129, 130, 132, 133, 135, |
| 136, 137, 139, 140, 142, 143, 145, 146, 147, 149, 150, 152, 153, 154, 156, 157, |
| 159, 160, 162, 163, 164, 166, 167, 169, 170, 171, 173, 174, 176, 177, 179, 180, |
| 181, 183, 184, 186, 187, 188, 190, 191, 193, 194, 196, 197, 198, 200, 201, 203, |
| 204, 205, 207, 208, 210, 211, 213, 214, 215, 217, 218, 220, 221, 222, 224, 225, |
| 227, 228, 230, 231, 232, 234, 235, 237, 238, 239, 241, 242, 244, 245, 247, 248, |
| 249, 251, 252, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
| 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
| 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
| 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
| 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
| }; |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2HSV_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| const int hsv_shift = 12; |
| |
| static const int div_table[] = { |
| 0, 1044480, 522240, 348160, 261120, 208896, 174080, 149211, |
| 130560, 116053, 104448, 94953, 87040, 80345, 74606, 69632, |
| 65280, 61440, 58027, 54973, 52224, 49737, 47476, 45412, |
| 43520, 41779, 40172, 38684, 37303, 36017, 34816, 33693, |
| 32640, 31651, 30720, 29842, 29013, 28229, 27486, 26782, |
| 26112, 25475, 24869, 24290, 23738, 23211, 22706, 22223, |
| 21760, 21316, 20890, 20480, 20086, 19707, 19342, 18991, |
| 18651, 18324, 18008, 17703, 17408, 17123, 16846, 16579, |
| 16320, 16069, 15825, 15589, 15360, 15137, 14921, 14711, |
| 14507, 14308, 14115, 13926, 13743, 13565, 13391, 13221, |
| 13056, 12895, 12738, 12584, 12434, 12288, 12145, 12006, |
| 11869, 11736, 11605, 11478, 11353, 11231, 11111, 10995, |
| 10880, 10768, 10658, 10550, 10445, 10341, 10240, 10141, |
| 10043, 9947, 9854, 9761, 9671, 9582, 9495, 9410, |
| 9326, 9243, 9162, 9082, 9004, 8927, 8852, 8777, |
| 8704, 8632, 8561, 8492, 8423, 8356, 8290, 8224, |
| 8160, 8097, 8034, 7973, 7913, 7853, 7795, 7737, |
| 7680, 7624, 7569, 7514, 7461, 7408, 7355, 7304, |
| 7253, 7203, 7154, 7105, 7057, 7010, 6963, 6917, |
| 6872, 6827, 6782, 6739, 6695, 6653, 6611, 6569, |
| 6528, 6487, 6447, 6408, 6369, 6330, 6292, 6254, |
| 6217, 6180, 6144, 6108, 6073, 6037, 6003, 5968, |
| 5935, 5901, 5868, 5835, 5803, 5771, 5739, 5708, |
| 5677, 5646, 5615, 5585, 5556, 5526, 5497, 5468, |
| 5440, 5412, 5384, 5356, 5329, 5302, 5275, 5249, |
| 5222, 5196, 5171, 5145, 5120, 5095, 5070, 5046, |
| 5022, 4998, 4974, 4950, 4927, 4904, 4881, 4858, |
| 4836, 4813, 4791, 4769, 4748, 4726, 4705, 4684, |
| 4663, 4642, 4622, 4601, 4581, 4561, 4541, 4522, |
| 4502, 4483, 4464, 4445, 4426, 4407, 4389, 4370, |
| 4352, 4334, 4316, 4298, 4281, 4263, 4246, 4229, |
| 4212, 4195, 4178, 4161, 4145, 4128, 4112, 4096 |
| }; |
| |
| int i; |
| if( icvRGB2HSV_8u_C3R_p ) |
| { |
| CvStatus status = icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size, |
| src_cn, blue_idx, icvRGB2HSV_8u_C3R_p ); |
| if( status >= 0 ) |
| { |
| size.width *= 3; |
| for( ; size.height--; dst += dststep ) |
| { |
| for( i = 0; i <= size.width - 12; i += 12 ) |
| { |
| uchar t0 = icvHue255To180[dst[i]], t1 = icvHue255To180[dst[i+3]]; |
| dst[i] = t0; dst[i+3] = t1; |
| t0 = icvHue255To180[dst[i+6]]; t1 = icvHue255To180[dst[i+9]]; |
| dst[i+6] = t0; dst[i+9] = t1; |
| } |
| for( ; i < size.width; i += 3 ) |
| dst[i] = icvHue255To180[dst[i]]; |
| } |
| } |
| return status; |
| } |
| |
| srcstep -= size.width*src_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, src += src_cn ) |
| { |
| int b = (src)[blue_idx], g = (src)[1], r = (src)[2^blue_idx]; |
| int h, s, v = b; |
| int vmin = b, diff; |
| int vr, vg; |
| |
| CV_CALC_MAX_8U( v, g ); |
| CV_CALC_MAX_8U( v, r ); |
| CV_CALC_MIN_8U( vmin, g ); |
| CV_CALC_MIN_8U( vmin, r ); |
| |
| diff = v - vmin; |
| vr = v == r ? -1 : 0; |
| vg = v == g ? -1 : 0; |
| |
| s = diff * div_table[v] >> hsv_shift; |
| h = (vr & (g - b)) + |
| (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff)))); |
| h = ((h * div_table[diff] * 15 + (1 << (hsv_shift + 6))) >> (7 + hsv_shift))\ |
| + (h < 0 ? 30*6 : 0); |
| |
| dst[i] = (uchar)h; |
| dst[i+1] = (uchar)s; |
| dst[i+2] = (uchar)v; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2HSV_32f_CnC3R( const float* src, int srcstep, |
| float* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| int i; |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| srcstep -= size.width*src_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, src += src_cn ) |
| { |
| float b = src[blue_idx], g = src[1], r = src[2^blue_idx]; |
| float h, s, v; |
| |
| float vmin, diff; |
| |
| v = vmin = r; |
| if( v < g ) v = g; |
| if( v < b ) v = b; |
| if( vmin > g ) vmin = g; |
| if( vmin > b ) vmin = b; |
| |
| diff = v - vmin; |
| s = diff/(float)(fabs(v) + FLT_EPSILON); |
| diff = (float)(60./(diff + FLT_EPSILON)); |
| if( v == r ) |
| h = (g - b)*diff; |
| else if( v == g ) |
| h = (b - r)*diff + 120.f; |
| else |
| h = (r - g)*diff + 240.f; |
| |
| if( h < 0 ) h += 360.f; |
| |
| dst[i] = h; |
| dst[i+1] = s; |
| dst[i+2] = v; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvHSV2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst, |
| int dststep, CvSize size, int dst_cn, int blue_idx ) |
| { |
| int i; |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| dststep -= size.width*dst_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, dst += dst_cn ) |
| { |
| float h = src[i], s = src[i+1], v = src[i+2]; |
| float b, g, r; |
| |
| if( s == 0 ) |
| b = g = r = v; |
| else |
| { |
| static const int sector_data[][3]= |
| {{1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0}}; |
| float tab[4]; |
| int sector; |
| h *= 0.016666666666666666f; // h /= 60; |
| if( h < 0 ) |
| do h += 6; while( h < 0 ); |
| else if( h >= 6 ) |
| do h -= 6; while( h >= 6 ); |
| sector = cvFloor(h); |
| h -= sector; |
| |
| tab[0] = v; |
| tab[1] = v*(1.f - s); |
| tab[2] = v*(1.f - s*h); |
| tab[3] = v*(1.f - s*(1.f - h)); |
| |
| b = tab[sector_data[sector][0]]; |
| g = tab[sector_data[sector][1]]; |
| r = tab[sector_data[sector][2]]; |
| } |
| |
| dst[blue_idx] = b; |
| dst[1] = g; |
| dst[blue_idx^2] = r; |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvHSV2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int dst_cn, int blue_idx ) |
| { |
| static const float pre_coeffs[] = { 2.f, 0.f, 0.0039215686274509803f, 0.f, 1.f, 0.f }; |
| |
| if( icvHSV2RGB_8u_C3R_p ) |
| { |
| int block_size = MIN(1 << 14, size.width); |
| uchar* buffer; |
| int i, di, k; |
| CvStatus status = CV_OK; |
| |
| buffer = (uchar*)cvStackAlloc( block_size*3*sizeof(buffer[0]) ); |
| 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 ) |
| { |
| uchar h = icvHue180To255[src1[k]]; |
| uchar s = src1[k+1]; |
| uchar v = src1[k+2]; |
| buffer[k] = h; |
| buffer[k+1] = s; |
| buffer[k+2] = v; |
| } |
| |
| status = icvHSV2RGB_8u_C3R_p( buffer, di*3, |
| buffer, di*3, cvSize(di,1) ); |
| if( status < 0 ) |
| return status; |
| |
| for( k = 0; k < di*3; k += 3, dst += dst_cn ) |
| { |
| uchar r = buffer[k]; |
| uchar g = buffer[k+1]; |
| uchar b = buffer[k+2]; |
| dst[blue_idx] = b; |
| dst[1] = g; |
| dst[blue_idx^2] = r; |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx, |
| (CvColorCvtFunc2)icvHSV2BGRx_32f_C3CnR, pre_coeffs, 0 ); |
| } |
| |
| |
| /****************************************************************************************\ |
| * RGB <-> HLS * |
| \****************************************************************************************/ |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2HLS_32f_CnC3R( const float* src, int srcstep, float* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| int i; |
| |
| if( icvRGB2HLS_32f_C3R_p ) |
| { |
| CvStatus status = icvBGRx2ABC_IPP_32f_CnC3R( src, srcstep, dst, dststep, size, |
| src_cn, blue_idx, icvRGB2HLS_32f_C3R_p ); |
| if( status >= 0 ) |
| { |
| size.width *= 3; |
| dststep /= sizeof(dst[0]); |
| |
| for( ; size.height--; dst += dststep ) |
| { |
| for( i = 0; i <= size.width - 12; i += 12 ) |
| { |
| float t0 = dst[i]*360.f, t1 = dst[i+3]*360.f; |
| dst[i] = t0; dst[i+3] = t1; |
| t0 = dst[i+6]*360.f; t1 = dst[i+9]*360.f; |
| dst[i+6] = t0; dst[i+9] = t1; |
| } |
| for( ; i < size.width; i += 3 ) |
| dst[i] = dst[i]*360.f; |
| } |
| } |
| return status; |
| } |
| |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| srcstep -= size.width*src_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, src += src_cn ) |
| { |
| float b = src[blue_idx], g = src[1], r = src[2^blue_idx]; |
| float h = 0.f, s = 0.f, l; |
| float vmin, vmax, diff; |
| |
| vmax = vmin = r; |
| if( vmax < g ) vmax = g; |
| if( vmax < b ) vmax = b; |
| if( vmin > g ) vmin = g; |
| if( vmin > b ) vmin = b; |
| |
| diff = vmax - vmin; |
| l = (vmax + vmin)*0.5f; |
| |
| if( diff > FLT_EPSILON ) |
| { |
| s = l < 0.5f ? diff/(vmax + vmin) : diff/(2 - vmax - vmin); |
| diff = 60.f/diff; |
| |
| if( vmax == r ) |
| h = (g - b)*diff; |
| else if( vmax == g ) |
| h = (b - r)*diff + 120.f; |
| else |
| h = (r - g)*diff + 240.f; |
| |
| if( h < 0.f ) h += 360.f; |
| } |
| |
| dst[i] = h; |
| dst[i+1] = l; |
| dst[i+2] = s; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvHLS2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst, int dststep, |
| CvSize size, int dst_cn, int blue_idx ) |
| { |
| int i; |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| |
| if( icvHLS2RGB_32f_C3R_p ) |
| { |
| int block_size = MIN(1 << 10, size.width); |
| float* buffer; |
| int di, k; |
| CvStatus status = CV_OK; |
| |
| buffer = (float*)cvStackAlloc( block_size*3*sizeof(buffer[0]) ); |
| dststep -= size.width*dst_cn; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += block_size ) |
| { |
| const float* src1 = src + i*3; |
| di = MIN(block_size, size.width - i); |
| for( k = 0; k < di*3; k += 3 ) |
| { |
| float h = src1[k]*0.0027777777777777779f; // /360. |
| float s = src1[k+1], v = src1[k+2]; |
| buffer[k] = h; buffer[k+1] = s; buffer[k+2] = v; |
| } |
| |
| status = icvHLS2RGB_32f_C3R_p( buffer, di*3*sizeof(dst[0]), |
| buffer, di*3*sizeof(dst[0]), cvSize(di,1) ); |
| if( status < 0 ) |
| return status; |
| |
| for( k = 0; k < di*3; k += 3, dst += dst_cn ) |
| { |
| float r = buffer[k], g = buffer[k+1], b = buffer[k+2]; |
| dst[blue_idx] = b; dst[1] = g; dst[blue_idx^2] = r; |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| dststep -= size.width*dst_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, dst += dst_cn ) |
| { |
| float h = src[i], l = src[i+1], s = src[i+2]; |
| float b, g, r; |
| |
| if( s == 0 ) |
| b = g = r = l; |
| else |
| { |
| static const int sector_data[][3]= |
| {{1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0}}; |
| float tab[4]; |
| int sector; |
| |
| float p2 = l <= 0.5f ? l*(1 + s) : l + s - l*s; |
| float p1 = 2*l - p2; |
| |
| h *= 0.016666666666666666f; // h /= 60; |
| if( h < 0 ) |
| do h += 6; while( h < 0 ); |
| else if( h >= 6 ) |
| do h -= 6; while( h >= 6 ); |
| |
| assert( 0 <= h && h < 6 ); |
| sector = cvFloor(h); |
| h -= sector; |
| |
| tab[0] = p2; |
| tab[1] = p1; |
| tab[2] = p1 + (p2 - p1)*(1-h); |
| tab[3] = p1 + (p2 - p1)*h; |
| |
| b = tab[sector_data[sector][0]]; |
| g = tab[sector_data[sector][1]]; |
| r = tab[sector_data[sector][2]]; |
| } |
| |
| dst[blue_idx] = b; |
| dst[1] = g; |
| dst[blue_idx^2] = r; |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2HLS_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| static const float post_coeffs[] = { 0.5f, 0.f, 255.f, 0.f, 255.f, 0.f }; |
| |
| if( icvRGB2HLS_8u_C3R_p ) |
| { |
| CvStatus status = icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size, |
| src_cn, blue_idx, icvRGB2HLS_8u_C3R_p ); |
| if( status >= 0 ) |
| { |
| size.width *= 3; |
| for( ; size.height--; dst += dststep ) |
| { |
| int i; |
| for( i = 0; i <= size.width - 12; i += 12 ) |
| { |
| uchar t0 = icvHue255To180[dst[i]], t1 = icvHue255To180[dst[i+3]]; |
| dst[i] = t0; dst[i+3] = t1; |
| t0 = icvHue255To180[dst[i+6]]; t1 = icvHue255To180[dst[i+9]]; |
| dst[i+6] = t0; dst[i+9] = t1; |
| } |
| for( ; i < size.width; i += 3 ) |
| dst[i] = icvHue255To180[dst[i]]; |
| } |
| } |
| return status; |
| } |
| |
| return icvBGRx2ABC_8u_CnC3R( src, srcstep, dst, dststep, size, src_cn, blue_idx, |
| (CvColorCvtFunc2)icvBGRx2HLS_32f_CnC3R, 1, post_coeffs ); |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvHLS2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int dst_cn, int blue_idx ) |
| { |
| static const float pre_coeffs[] = { 2.f, 0.f, 0.0039215686274509803f, 0.f, |
| 0.0039215686274509803f, 0.f }; |
| |
| if( icvHLS2RGB_8u_C3R_p ) |
| { |
| int block_size = MIN(1 << 14, size.width); |
| uchar* buffer; |
| int i, di, k; |
| CvStatus status = CV_OK; |
| |
| buffer = (uchar*)cvStackAlloc( block_size*3*sizeof(buffer[0]) ); |
| 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 ) |
| { |
| uchar h = icvHue180To255[src1[k]]; |
| uchar l = src1[k+1]; |
| uchar s = src1[k+2]; |
| buffer[k] = h; |
| buffer[k+1] = l; |
| buffer[k+2] = s; |
| } |
| |
| status = icvHLS2RGB_8u_C3R_p( buffer, di*3, |
| buffer, di*3, cvSize(di,1) ); |
| if( status < 0 ) |
| return status; |
| |
| for( k = 0; k < di*3; k += 3, dst += dst_cn ) |
| { |
| uchar r = buffer[k]; |
| uchar g = buffer[k+1]; |
| uchar b = buffer[k+2]; |
| dst[blue_idx] = b; |
| dst[1] = g; |
| dst[blue_idx^2] = r; |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx, |
| (CvColorCvtFunc2)icvHLS2BGRx_32f_C3CnR, pre_coeffs, 1 ); |
| } |
| |
| |
| /****************************************************************************************\ |
| * RGB <-> L*a*b* * |
| \****************************************************************************************/ |
| |
| #define labXr_32f 0.433953f /* = xyzXr_32f / 0.950456 */ |
| #define labXg_32f 0.376219f /* = xyzXg_32f / 0.950456 */ |
| #define labXb_32f 0.189828f /* = xyzXb_32f / 0.950456 */ |
| |
| #define labYr_32f 0.212671f /* = xyzYr_32f */ |
| #define labYg_32f 0.715160f /* = xyzYg_32f */ |
| #define labYb_32f 0.072169f /* = xyzYb_32f */ |
| |
| #define labZr_32f 0.017758f /* = xyzZr_32f / 1.088754 */ |
| #define labZg_32f 0.109477f /* = xyzZg_32f / 1.088754 */ |
| #define labZb_32f 0.872766f /* = xyzZb_32f / 1.088754 */ |
| |
| #define labRx_32f 3.0799327f /* = xyzRx_32f * 0.950456 */ |
| #define labRy_32f (-1.53715f) /* = xyzRy_32f */ |
| #define labRz_32f (-0.542782f)/* = xyzRz_32f * 1.088754 */ |
| |
| #define labGx_32f (-0.921235f)/* = xyzGx_32f * 0.950456 */ |
| #define labGy_32f 1.875991f /* = xyzGy_32f */ |
| #define labGz_32f 0.04524426f /* = xyzGz_32f * 1.088754 */ |
| |
| #define labBx_32f 0.0528909755f /* = xyzBx_32f * 0.950456 */ |
| #define labBy_32f (-0.204043f) /* = xyzBy_32f */ |
| #define labBz_32f 1.15115158f /* = xyzBz_32f * 1.088754 */ |
| |
| #define labT_32f 0.008856f |
| |
| #define labT fix(labT_32f*255,lab_shift) |
| |
| #undef lab_shift |
| #define lab_shift 10 |
| #define labXr fix(labXr_32f,lab_shift) |
| #define labXg fix(labXg_32f,lab_shift) |
| #define labXb fix(labXb_32f,lab_shift) |
| |
| #define labYr fix(labYr_32f,lab_shift) |
| #define labYg fix(labYg_32f,lab_shift) |
| #define labYb fix(labYb_32f,lab_shift) |
| |
| #define labZr fix(labZr_32f,lab_shift) |
| #define labZg fix(labZg_32f,lab_shift) |
| #define labZb fix(labZb_32f,lab_shift) |
| |
| #define labSmallScale_32f 7.787f |
| #define labSmallShift_32f 0.13793103448275862f /* 16/116 */ |
| #define labLScale_32f 116.f |
| #define labLShift_32f 16.f |
| #define labLScale2_32f 903.3f |
| |
| #define labSmallScale fix(31.27 /* labSmallScale_32f*(1<<lab_shift)/255 */,lab_shift) |
| #define labSmallShift fix(141.24138 /* labSmallScale_32f*(1<<lab) */,lab_shift) |
| #define labLScale fix(295.8 /* labLScale_32f*255/100 */,lab_shift) |
| #define labLShift fix(41779.2 /* labLShift_32f*1024*255/100 */,lab_shift) |
| #define labLScale2 fix(labLScale2_32f*0.01,lab_shift) |
| |
| /* 1024*(([0..511]./255)**(1./3)) */ |
| static ushort icvLabCubeRootTab[] = { |
| 0, 161, 203, 232, 256, 276, 293, 308, 322, 335, 347, 359, 369, 379, 389, 398, |
| 406, 415, 423, 430, 438, 445, 452, 459, 465, 472, 478, 484, 490, 496, 501, 507, |
| 512, 517, 523, 528, 533, 538, 542, 547, 552, 556, 561, 565, 570, 574, 578, 582, |
| 586, 590, 594, 598, 602, 606, 610, 614, 617, 621, 625, 628, 632, 635, 639, 642, |
| 645, 649, 652, 655, 659, 662, 665, 668, 671, 674, 677, 680, 684, 686, 689, 692, |
| 695, 698, 701, 704, 707, 710, 712, 715, 718, 720, 723, 726, 728, 731, 734, 736, |
| 739, 741, 744, 747, 749, 752, 754, 756, 759, 761, 764, 766, 769, 771, 773, 776, |
| 778, 780, 782, 785, 787, 789, 792, 794, 796, 798, 800, 803, 805, 807, 809, 811, |
| 813, 815, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, |
| 846, 848, 850, 852, 854, 856, 857, 859, 861, 863, 865, 867, 869, 871, 872, 874, |
| 876, 878, 880, 882, 883, 885, 887, 889, 891, 892, 894, 896, 898, 899, 901, 903, |
| 904, 906, 908, 910, 911, 913, 915, 916, 918, 920, 921, 923, 925, 926, 928, 929, |
| 931, 933, 934, 936, 938, 939, 941, 942, 944, 945, 947, 949, 950, 952, 953, 955, |
| 956, 958, 959, 961, 962, 964, 965, 967, 968, 970, 971, 973, 974, 976, 977, 979, |
| 980, 982, 983, 985, 986, 987, 989, 990, 992, 993, 995, 996, 997, 999, 1000, 1002, |
| 1003, 1004, 1006, 1007, 1009, 1010, 1011, 1013, 1014, 1015, 1017, 1018, 1019, 1021, 1022, 1024, |
| 1025, 1026, 1028, 1029, 1030, 1031, 1033, 1034, 1035, 1037, 1038, 1039, 1041, 1042, 1043, 1044, |
| 1046, 1047, 1048, 1050, 1051, 1052, 1053, 1055, 1056, 1057, 1058, 1060, 1061, 1062, 1063, 1065, |
| 1066, 1067, 1068, 1070, 1071, 1072, 1073, 1074, 1076, 1077, 1078, 1079, 1081, 1082, 1083, 1084, |
| 1085, 1086, 1088, 1089, 1090, 1091, 1092, 1094, 1095, 1096, 1097, 1098, 1099, 1101, 1102, 1103, |
| 1104, 1105, 1106, 1107, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1117, 1118, 1119, 1120, 1121, |
| 1122, 1123, 1124, 1125, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1138, 1139, |
| 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1154, 1155, 1156, |
| 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, |
| 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, |
| 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, |
| 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1215, 1216, 1217, 1218, 1219, |
| 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1230, 1231, 1232, 1233, 1234, |
| 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, |
| 1250, 1251, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1259, 1260, 1261, 1262, 1263, |
| 1264, 1265, 1266, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1273, 1274, 1275, 1276, 1277, |
| 1278, 1279, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1285, 1286, 1287, 1288, 1289, 1290, 1291 |
| }; |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2Lab_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| int i; |
| |
| /*if( icvBGR2Lab_8u_C3R_p ) |
| return icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size, |
| src_cn, blue_idx^2, icvBGR2Lab_8u_C3R_p );*/ |
| |
| srcstep -= size.width*src_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, src += src_cn ) |
| { |
| int b = src[blue_idx], g = src[1], r = src[2^blue_idx]; |
| int x, y, z, f; |
| int L, a; |
| |
| x = b*labXb + g*labXg + r*labXr; |
| y = b*labYb + g*labYg + r*labYr; |
| z = b*labZb + g*labZg + r*labZr; |
| |
| f = x > labT; |
| x = CV_DESCALE( x, lab_shift ); |
| |
| if( f ) |
| assert( (unsigned)x < 512 ), x = icvLabCubeRootTab[x]; |
| else |
| x = CV_DESCALE(x*labSmallScale + labSmallShift,lab_shift); |
| |
| f = z > labT; |
| z = CV_DESCALE( z, lab_shift ); |
| |
| if( f ) |
| assert( (unsigned)z < 512 ), z = icvLabCubeRootTab[z]; |
| else |
| z = CV_DESCALE(z*labSmallScale + labSmallShift,lab_shift); |
| |
| f = y > labT; |
| y = CV_DESCALE( y, lab_shift ); |
| |
| if( f ) |
| { |
| assert( (unsigned)y < 512 ), y = icvLabCubeRootTab[y]; |
| L = CV_DESCALE(y*labLScale - labLShift, 2*lab_shift ); |
| } |
| else |
| { |
| L = CV_DESCALE(y*labLScale2,lab_shift); |
| y = CV_DESCALE(y*labSmallScale + labSmallShift,lab_shift); |
| } |
| |
| a = CV_DESCALE( 500*(x - y), lab_shift ) + 128; |
| b = CV_DESCALE( 200*(y - z), lab_shift ) + 128; |
| |
| dst[i] = CV_CAST_8U(L); |
| dst[i+1] = CV_CAST_8U(a); |
| dst[i+2] = CV_CAST_8U(b); |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2Lab_32f_CnC3R( const float* src, int srcstep, float* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| int i; |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| srcstep -= size.width*src_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, src += src_cn ) |
| { |
| float b = src[blue_idx], g = src[1], r = src[2^blue_idx]; |
| float x, y, z; |
| float L, a; |
| |
| x = b*labXb_32f + g*labXg_32f + r*labXr_32f; |
| y = b*labYb_32f + g*labYg_32f + r*labYr_32f; |
| z = b*labZb_32f + g*labZg_32f + r*labZr_32f; |
| |
| if( x > labT_32f ) |
| x = cvCbrt(x); |
| else |
| x = x*labSmallScale_32f + labSmallShift_32f; |
| |
| if( z > labT_32f ) |
| z = cvCbrt(z); |
| else |
| z = z*labSmallScale_32f + labSmallShift_32f; |
| |
| if( y > labT_32f ) |
| { |
| y = cvCbrt(y); |
| L = y*labLScale_32f - labLShift_32f; |
| } |
| else |
| { |
| L = y*labLScale2_32f; |
| y = y*labSmallScale_32f + labSmallShift_32f; |
| } |
| |
| a = 500.f*(x - y); |
| b = 200.f*(y - z); |
| |
| dst[i] = L; |
| dst[i+1] = a; |
| dst[i+2] = b; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvLab2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst, int dststep, |
| CvSize size, int dst_cn, int blue_idx ) |
| { |
| int i; |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| dststep -= size.width*dst_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, dst += dst_cn ) |
| { |
| float L = src[i], a = src[i+1], b = src[i+2]; |
| float x, y, z; |
| float g, r; |
| |
| L = (L + labLShift_32f)*(1.f/labLScale_32f); |
| x = (L + a*0.002f); |
| z = (L - b*0.005f); |
| y = L*L*L; |
| x = x*x*x; |
| z = z*z*z; |
| |
| b = x*labBx_32f + y*labBy_32f + z*labBz_32f; |
| g = x*labGx_32f + y*labGy_32f + z*labGz_32f; |
| r = x*labRx_32f + y*labRy_32f + z*labRz_32f; |
| |
| dst[blue_idx] = b; |
| dst[1] = g; |
| dst[blue_idx^2] = r; |
| if( dst_cn == 4 ) |
| dst[3] = 0; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvLab2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int dst_cn, int blue_idx ) |
| { |
| // L: [0..255] -> [0..100] |
| // a: [0..255] -> [-128..127] |
| // b: [0..255] -> [-128..127] |
| static const float pre_coeffs[] = { 0.39215686274509809f, 0.f, 1.f, -128.f, 1.f, -128.f }; |
| |
| if( icvLab2BGR_8u_C3R_p ) |
| return icvABC2BGRx_IPP_8u_C3CnR( src, srcstep, dst, dststep, size, |
| dst_cn, blue_idx^2, icvLab2BGR_8u_C3R_p ); |
| |
| return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx, |
| (CvColorCvtFunc2)icvLab2BGRx_32f_C3CnR, pre_coeffs, 1 ); |
| } |
| |
| |
| /****************************************************************************************\ |
| * RGB <-> L*u*v* * |
| \****************************************************************************************/ |
| |
| #define luvUn_32f 0.19793943f |
| #define luvVn_32f 0.46831096f |
| #define luvYmin_32f 0.05882353f /* 15/255 */ |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2Luv_32f_CnC3R( const float* src, int srcstep, float* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| int i; |
| |
| /*if( icvRGB2Luv_32f_C3R_p ) |
| return icvBGRx2ABC_IPP_32f_CnC3R( src, srcstep, dst, dststep, size, |
| src_cn, blue_idx, icvRGB2Luv_32f_C3R_p );*/ |
| |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| srcstep -= size.width*src_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, src += src_cn ) |
| { |
| float b = src[blue_idx], g = src[1], r = src[2^blue_idx]; |
| float x, y, z; |
| float L, u, v, t; |
| |
| x = b*xyzXb_32f + g*xyzXg_32f + r*xyzXr_32f; |
| y = b*xyzYb_32f + g*xyzYg_32f + r*xyzYr_32f; |
| z = b*xyzZb_32f + g*xyzZg_32f + r*xyzZr_32f; |
| |
| if( !x && !y && !z ) |
| L = u = v = 0.f; |
| else |
| { |
| if( y > labT_32f ) |
| L = labLScale_32f * cvCbrt(y) - labLShift_32f; |
| else |
| L = labLScale2_32f * y; |
| |
| t = 1.f / (x + 15 * y + 3 * z); |
| u = 4.0f * x * t; |
| v = 9.0f * y * t; |
| |
| u = 13*L*(u - luvUn_32f); |
| v = 13*L*(v - luvVn_32f); |
| } |
| |
| dst[i] = L; |
| dst[i+1] = u; |
| dst[i+2] = v; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvLuv2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst, int dststep, |
| CvSize size, int dst_cn, int blue_idx ) |
| { |
| int i; |
| |
| /*if( icvLuv2RGB_32f_C3R_p ) |
| return icvABC2BGRx_IPP_32f_C3CnR( src, srcstep, dst, dststep, size, |
| dst_cn, blue_idx, icvLuv2RGB_32f_C3R_p );*/ |
| |
| srcstep /= sizeof(src[0]); |
| dststep /= sizeof(dst[0]); |
| dststep -= size.width*dst_cn; |
| size.width *= 3; |
| |
| for( ; size.height--; src += srcstep, dst += dststep ) |
| { |
| for( i = 0; i < size.width; i += 3, dst += dst_cn ) |
| { |
| float L = src[i], u = src[i+1], v = src[i+2]; |
| float x, y, z, t, u1, v1, b, g, r; |
| |
| if( L >= 8 ) |
| { |
| t = (L + labLShift_32f) * (1.f/labLScale_32f); |
| y = t*t*t; |
| } |
| else |
| { |
| y = L * (1.f/labLScale2_32f); |
| L = MAX( L, 0.001f ); |
| } |
| |
| t = 1.f/(13.f * L); |
| u1 = u*t + luvUn_32f; |
| v1 = v*t + luvVn_32f; |
| x = 2.25f * u1 * y / v1 ; |
| z = (12 - 3 * u1 - 20 * v1) * y / (4 * v1); |
| |
| b = xyzBx_32f*x + xyzBy_32f*y + xyzBz_32f*z; |
| g = xyzGx_32f*x + xyzGy_32f*y + xyzGz_32f*z; |
| r = xyzRx_32f*x + xyzRy_32f*y + xyzRz_32f*z; |
| |
| dst[blue_idx] = b; |
| dst[1] = g; |
| dst[blue_idx^2] = r; |
| if( dst_cn == 4 ) |
| dst[3] = 0.f; |
| } |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvBGRx2Luv_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int src_cn, int blue_idx ) |
| { |
| // L: [0..100] -> [0..255] |
| // u: [-134..220] -> [0..255] |
| // v: [-140..122] -> [0..255] |
| //static const float post_coeffs[] = { 2.55f, 0.f, 1.f, 83.f, 1.f, 140.f }; |
| static const float post_coeffs[] = { 2.55f, 0.f, 0.72033898305084743f, 96.525423728813564f, |
| 0.99609375f, 139.453125f }; |
| |
| if( icvRGB2Luv_8u_C3R_p ) |
| return icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size, |
| src_cn, blue_idx, icvRGB2Luv_8u_C3R_p ); |
| |
| return icvBGRx2ABC_8u_CnC3R( src, srcstep, dst, dststep, size, src_cn, blue_idx, |
| (CvColorCvtFunc2)icvBGRx2Luv_32f_CnC3R, 1, post_coeffs ); |
| } |
| |
| |
| static CvStatus CV_STDCALL |
| icvLuv2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep, |
| CvSize size, int dst_cn, int blue_idx ) |
| { |
| // L: [0..255] -> [0..100] |
| // u: [0..255] -> [-134..220] |
| // v: [0..255] -> [-140..122] |
| static const float pre_coeffs[] = { 0.39215686274509809f, 0.f, 1.388235294117647f, -134.f, |
| 1.003921568627451f, -140.f }; |
| |
| if( icvLuv2RGB_8u_C3R_p ) |
| return icvABC2BGRx_IPP_8u_C3CnR( src, srcstep, dst, dststep, size, |
| dst_cn, blue_idx, icvLuv2RGB_8u_C3R_p ); |
| |
| return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx, |
| (CvColorCvtFunc2)icvLuv2BGRx_32f_C3CnR, pre_coeffs, 1 ); |
| } |
| |
| /****************************************************************************************\ |
| * Bayer Pattern -> RGB conversion * |
| \****************************************************************************************/ |
| |
| static CvStatus CV_STDCALL |
| icvBayer2BGR_8u_C1C3R( const uchar* bayer0, int bayer_step, |
| uchar *dst0, int dst_step, |
| CvSize size, int code ) |
| { |
| int blue = code == CV_BayerBG2BGR || code == CV_BayerGB2BGR ? -1 : 1; |
| int start_with_green = code == CV_BayerGB2BGR || code == CV_BayerGR2BGR; |
| |
| memset( dst0, 0, size.width*3*sizeof(dst0[0]) ); |
| memset( dst0 + (size.height - 1)*dst_step, 0, size.width*3*sizeof(dst0[0]) ); |
| dst0 += dst_step + 3 + 1; |
| size.height -= 2; |
| size.width -= 2; |
| |
| for( ; size.height-- > 0; bayer0 += bayer_step, dst0 += dst_step ) |
| { |
| int t0, t1; |
| const uchar* bayer = bayer0; |
| uchar* dst = dst0; |
| const uchar* bayer_end = bayer + size.width; |
| |
| dst[-4] = dst[-3] = dst[-2] = dst[size.width*3-1] = |
| dst[size.width*3] = dst[size.width*3+1] = 0; |
| |
| if( size.width <= 0 ) |
| continue; |
| |
| if( start_with_green ) |
| { |
| t0 = (bayer[1] + bayer[bayer_step*2+1] + 1) >> 1; |
| t1 = (bayer[bayer_step] + bayer[bayer_step+2] + 1) >> 1; |
| dst[-blue] = (uchar)t0; |
| dst[0] = bayer[bayer_step+1]; |
| dst[blue] = (uchar)t1; |
| bayer++; |
| dst += 3; |
| } |
| |
| if( blue > 0 ) |
| { |
| for( ; bayer <= bayer_end - 2; bayer += 2, dst += 6 ) |
| { |
| t0 = (bayer[0] + bayer[2] + bayer[bayer_step*2] + |
| bayer[bayer_step*2+2] + 2) >> 2; |
| t1 = (bayer[1] + bayer[bayer_step] + |
| bayer[bayer_step+2] + bayer[bayer_step*2+1]+2) >> 2; |
| dst[-1] = (uchar)t0; |
| dst[0] = (uchar)t1; |
| dst[1] = bayer[bayer_step+1]; |
| |
| t0 = (bayer[2] + bayer[bayer_step*2+2] + 1) >> 1; |
| t1 = (bayer[bayer_step+1] + bayer[bayer_step+3] + 1) >> 1; |
| dst[2] = (uchar)t0; |
| dst[3] = bayer[bayer_step+2]; |
| dst[4] = (uchar)t1; |
| } |
| } |
| else |
| { |
| for( ; bayer <= bayer_end - 2; bayer += 2, dst += 6 ) |
| { |
| t0 = (bayer[0] + bayer[2] + bayer[bayer_step*2] + |
| bayer[bayer_step*2+2] + 2) >> 2; |
| t1 = (bayer[1] + bayer[bayer_step] + |
| bayer[bayer_step+2] + bayer[bayer_step*2+1]+2) >> 2; |
| dst[1] = (uchar)t0; |
| dst[0] = (uchar)t1; |
| dst[-1] = bayer[bayer_step+1]; |
| |
| t0 = (bayer[2] + bayer[bayer_step*2+2] + 1) >> 1; |
| t1 = (bayer[bayer_step+1] + bayer[bayer_step+3] + 1) >> 1; |
| dst[4] = (uchar)t0; |
| dst[3] = bayer[bayer_step+2]; |
| dst[2] = (uchar)t1; |
| } |
| } |
| |
| if( bayer < bayer_end ) |
| { |
| t0 = (bayer[0] + bayer[2] + bayer[bayer_step*2] + |
| bayer[bayer_step*2+2] + 2) >> 2; |
| t1 = (bayer[1] + bayer[bayer_step] + |
| bayer[bayer_step+2] + bayer[bayer_step*2+1]+2) >> 2; |
| dst[-blue] = (uchar)t0; |
| dst[0] = (uchar)t1; |
| dst[blue] = bayer[bayer_step+1]; |
| bayer++; |
| dst += 3; |
| } |
| |
| blue = -blue; |
| start_with_green = !start_with_green; |
| } |
| |
| return CV_OK; |
| } |
| |
| |
| /****************************************************************************************\ |
| * The main function * |
| \****************************************************************************************/ |
| |
| CV_IMPL void |
| cvCvtColor( const CvArr* srcarr, CvArr* dstarr, int code ) |
| { |
| CV_FUNCNAME( "cvCvtColor" ); |
| |
| __BEGIN__; |
| |
| CvMat srcstub, *src = (CvMat*)srcarr; |
| CvMat dststub, *dst = (CvMat*)dstarr; |
| CvSize size; |
| int src_step, dst_step; |
| int src_cn, dst_cn, depth; |
| CvColorCvtFunc0 func0 = 0; |
| CvColorCvtFunc1 func1 = 0; |
| CvColorCvtFunc2 func2 = 0; |
| CvColorCvtFunc3 func3 = 0; |
| int param[] = { 0, 0, 0, 0 }; |
| |
| CV_CALL( src = cvGetMat( srcarr, &srcstub )); |
| CV_CALL( dst = cvGetMat( dstarr, &dststub )); |
| |
| if( !CV_ARE_SIZES_EQ( src, dst )) |
| CV_ERROR( CV_StsUnmatchedSizes, "" ); |
| |
| if( !CV_ARE_DEPTHS_EQ( src, dst )) |
| CV_ERROR( CV_StsUnmatchedFormats, "" ); |
| |
| depth = CV_MAT_DEPTH(src->type); |
| if( depth != CV_8U && depth != CV_16U && depth != CV_32F ) |
| CV_ERROR( CV_StsUnsupportedFormat, "" ); |
| |
| src_cn = CV_MAT_CN( src->type ); |
| dst_cn = CV_MAT_CN( dst->type ); |
| size = cvGetMatSize( src ); |
| src_step = src->step; |
| dst_step = dst->step; |
| |
| if( CV_IS_MAT_CONT(src->type & dst->type) && |
| code != CV_BayerBG2BGR && code != CV_BayerGB2BGR && |
| code != CV_BayerRG2BGR && code != CV_BayerGR2BGR ) |
| { |
| size.width *= size.height; |
| size.height = 1; |
| src_step = dst_step = CV_STUB_STEP; |
| } |
| |
| switch( code ) |
| { |
| case CV_BGR2BGRA: |
| case CV_RGB2BGRA: |
| if( src_cn != 3 || dst_cn != 4 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| func1 = depth == CV_8U ? (CvColorCvtFunc1)icvBGR2BGRx_8u_C3C4R : |
| depth == CV_16U ? (CvColorCvtFunc1)icvBGR2BGRx_16u_C3C4R : |
| depth == CV_32F ? (CvColorCvtFunc1)icvBGR2BGRx_32f_C3C4R : 0; |
| param[0] = code == CV_BGR2BGRA ? 0 : 2; // blue_idx |
| break; |
| |
| case CV_BGRA2BGR: |
| case CV_RGBA2BGR: |
| case CV_RGB2BGR: |
| if( (src_cn != 3 && src_cn != 4) || dst_cn != 3 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| func2 = depth == CV_8U ? (CvColorCvtFunc2)icvBGRx2BGR_8u_CnC3R : |
| depth == CV_16U ? (CvColorCvtFunc2)icvBGRx2BGR_16u_CnC3R : |
| depth == CV_32F ? (CvColorCvtFunc2)icvBGRx2BGR_32f_CnC3R : 0; |
| param[0] = src_cn; |
| param[1] = code == CV_BGRA2BGR ? 0 : 2; // blue_idx |
| break; |
| |
| case CV_BGRA2RGBA: |
| if( src_cn != 4 || dst_cn != 4 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| func0 = depth == CV_8U ? (CvColorCvtFunc0)icvBGRA2RGBA_8u_C4R : |
| depth == CV_16U ? (CvColorCvtFunc0)icvBGRA2RGBA_16u_C4R : |
| depth == CV_32F ? (CvColorCvtFunc0)icvBGRA2RGBA_32f_C4R : 0; |
| break; |
| |
| case CV_BGR2BGR565: |
| case CV_BGR2BGR555: |
| case CV_RGB2BGR565: |
| case CV_RGB2BGR555: |
| case CV_BGRA2BGR565: |
| case CV_BGRA2BGR555: |
| case CV_RGBA2BGR565: |
| case CV_RGBA2BGR555: |
| if( (src_cn != 3 && src_cn != 4) || dst_cn != 2 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| if( depth != CV_8U ) |
| CV_ERROR( CV_BadDepth, |
| "Conversion to/from 16-bit packed RGB format " |
| "is only possible for 8-bit images (8-bit grayscale, 888 BGR/RGB or 8888 BGRA/RGBA)" ); |
| |
| func3 = (CvColorCvtFunc3)icvBGRx2BGR5x5_8u_CnC2R; |
| param[0] = src_cn; |
| param[1] = code == CV_BGR2BGR565 || code == CV_BGR2BGR555 || |
| code == CV_BGRA2BGR565 || code == CV_BGRA2BGR555 ? 0 : 2; // blue_idx |
| param[2] = code == CV_BGR2BGR565 || code == CV_RGB2BGR565 || |
| code == CV_BGRA2BGR565 || code == CV_RGBA2BGR565 ? 6 : 5; // green_bits |
| break; |
| |
| case CV_BGR5652BGR: |
| case CV_BGR5552BGR: |
| case CV_BGR5652RGB: |
| case CV_BGR5552RGB: |
| case CV_BGR5652BGRA: |
| case CV_BGR5552BGRA: |
| case CV_BGR5652RGBA: |
| case CV_BGR5552RGBA: |
| if( src_cn != 2 || (dst_cn != 3 && dst_cn != 4)) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| if( depth != CV_8U ) |
| CV_ERROR( CV_BadDepth, |
| "Conversion to/from 16-bit packed BGR format " |
| "is only possible for 8-bit images (8-bit grayscale, 888 BGR/BGR or 8888 BGRA/BGRA)" ); |
| |
| func3 = (CvColorCvtFunc3)icvBGR5x52BGRx_8u_C2CnR; |
| param[0] = dst_cn; |
| param[1] = code == CV_BGR5652BGR || code == CV_BGR5552BGR || |
| code == CV_BGR5652BGRA || code == CV_BGR5552BGRA ? 0 : 2; // blue_idx |
| param[2] = code == CV_BGR5652BGR || code == CV_BGR5652RGB || |
| code == CV_BGR5652BGRA || code == CV_BGR5652RGBA ? 6 : 5; // green_bits |
| break; |
| |
| case CV_BGR2GRAY: |
| case CV_BGRA2GRAY: |
| case CV_RGB2GRAY: |
| case CV_RGBA2GRAY: |
| if( (src_cn != 3 && src_cn != 4) || dst_cn != 1 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| func2 = depth == CV_8U ? (CvColorCvtFunc2)icvBGRx2Gray_8u_CnC1R : |
| depth == CV_16U ? (CvColorCvtFunc2)icvBGRx2Gray_16u_CnC1R : |
| depth == CV_32F ? (CvColorCvtFunc2)icvBGRx2Gray_32f_CnC1R : 0; |
| |
| param[0] = src_cn; |
| param[1] = code == CV_BGR2GRAY || code == CV_BGRA2GRAY ? 0 : 2; |
| break; |
| |
| case CV_BGR5652GRAY: |
| case CV_BGR5552GRAY: |
| if( src_cn != 2 || dst_cn != 1 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| if( depth != CV_8U ) |
| CV_ERROR( CV_BadDepth, |
| "Conversion to/from 16-bit packed BGR format " |
| "is only possible for 8-bit images (888 BGR/BGR or 8888 BGRA/BGRA)" ); |
| |
| func2 = (CvColorCvtFunc2)icvBGR5x52Gray_8u_C2C1R; |
| |
| param[0] = code == CV_BGR5652GRAY ? 6 : 5; // green_bits |
| break; |
| |
| case CV_GRAY2BGR: |
| case CV_GRAY2BGRA: |
| if( src_cn != 1 || (dst_cn != 3 && dst_cn != 4)) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| func1 = depth == CV_8U ? (CvColorCvtFunc1)icvGray2BGRx_8u_C1CnR : |
| depth == CV_16U ? (CvColorCvtFunc1)icvGray2BGRx_16u_C1CnR : |
| depth == CV_32F ? (CvColorCvtFunc1)icvGray2BGRx_32f_C1CnR : 0; |
| |
| param[0] = dst_cn; |
| break; |
| |
| case CV_GRAY2BGR565: |
| case CV_GRAY2BGR555: |
| if( src_cn != 1 || dst_cn != 2 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| if( depth != CV_8U ) |
| CV_ERROR( CV_BadDepth, |
| "Conversion to/from 16-bit packed BGR format " |
| "is only possible for 8-bit images (888 BGR/BGR or 8888 BGRA/BGRA)" ); |
| |
| func2 = (CvColorCvtFunc2)icvGray2BGR5x5_8u_C1C2R; |
| param[0] = code == CV_GRAY2BGR565 ? 6 : 5; // green_bits |
| break; |
| |
| case CV_BGR2YCrCb: |
| case CV_RGB2YCrCb: |
| case CV_BGR2XYZ: |
| case CV_RGB2XYZ: |
| case CV_BGR2HSV: |
| case CV_RGB2HSV: |
| case CV_BGR2Lab: |
| case CV_RGB2Lab: |
| case CV_BGR2Luv: |
| case CV_RGB2Luv: |
| case CV_BGR2HLS: |
| case CV_RGB2HLS: |
| if( (src_cn != 3 && src_cn != 4) || dst_cn != 3 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| if( depth == CV_8U ) |
| func2 = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? (CvColorCvtFunc2)icvBGRx2YCrCb_8u_CnC3R : |
| code == CV_BGR2XYZ || code == CV_RGB2XYZ ? (CvColorCvtFunc2)icvBGRx2XYZ_8u_CnC3R : |
| code == CV_BGR2HSV || code == CV_RGB2HSV ? (CvColorCvtFunc2)icvBGRx2HSV_8u_CnC3R : |
| code == CV_BGR2Lab || code == CV_RGB2Lab ? (CvColorCvtFunc2)icvBGRx2Lab_8u_CnC3R : |
| code == CV_BGR2Luv || code == CV_RGB2Luv ? (CvColorCvtFunc2)icvBGRx2Luv_8u_CnC3R : |
| code == CV_BGR2HLS || code == CV_RGB2HLS ? (CvColorCvtFunc2)icvBGRx2HLS_8u_CnC3R : 0; |
| else if( depth == CV_16U ) |
| func2 = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? (CvColorCvtFunc2)icvBGRx2YCrCb_16u_CnC3R : |
| code == CV_BGR2XYZ || code == CV_RGB2XYZ ? (CvColorCvtFunc2)icvBGRx2XYZ_16u_CnC3R : 0; |
| else if( depth == CV_32F ) |
| func2 = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? (CvColorCvtFunc2)icvBGRx2YCrCb_32f_CnC3R : |
| code == CV_BGR2XYZ || code == CV_RGB2XYZ ? (CvColorCvtFunc2)icvBGRx2XYZ_32f_CnC3R : |
| code == CV_BGR2HSV || code == CV_RGB2HSV ? (CvColorCvtFunc2)icvBGRx2HSV_32f_CnC3R : |
| code == CV_BGR2Lab || code == CV_RGB2Lab ? (CvColorCvtFunc2)icvBGRx2Lab_32f_CnC3R : |
| code == CV_BGR2Luv || code == CV_RGB2Luv ? (CvColorCvtFunc2)icvBGRx2Luv_32f_CnC3R : |
| code == CV_BGR2HLS || code == CV_RGB2HLS ? (CvColorCvtFunc2)icvBGRx2HLS_32f_CnC3R : 0; |
| |
| param[0] = src_cn; |
| param[1] = code == CV_BGR2XYZ || code == CV_BGR2YCrCb || code == CV_BGR2HSV || |
| code == CV_BGR2Lab || code == CV_BGR2Luv || code == CV_BGR2HLS ? 0 : 2; |
| break; |
| |
| case CV_YCrCb2BGR: |
| case CV_YCrCb2RGB: |
| case CV_XYZ2BGR: |
| case CV_XYZ2RGB: |
| case CV_HSV2BGR: |
| case CV_HSV2RGB: |
| case CV_Lab2BGR: |
| case CV_Lab2RGB: |
| case CV_Luv2BGR: |
| case CV_Luv2RGB: |
| case CV_HLS2BGR: |
| case CV_HLS2RGB: |
| if( src_cn != 3 || (dst_cn != 3 && dst_cn != 4) ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| if( depth == CV_8U ) |
| func2 = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? (CvColorCvtFunc2)icvYCrCb2BGRx_8u_C3CnR : |
| code == CV_XYZ2BGR || code == CV_XYZ2RGB ? (CvColorCvtFunc2)icvXYZ2BGRx_8u_C3CnR : |
| code == CV_HSV2BGR || code == CV_HSV2RGB ? (CvColorCvtFunc2)icvHSV2BGRx_8u_C3CnR : |
| code == CV_HLS2BGR || code == CV_HLS2RGB ? (CvColorCvtFunc2)icvHLS2BGRx_8u_C3CnR : |
| code == CV_Lab2BGR || code == CV_Lab2RGB ? (CvColorCvtFunc2)icvLab2BGRx_8u_C3CnR : |
| code == CV_Luv2BGR || code == CV_Luv2RGB ? (CvColorCvtFunc2)icvLuv2BGRx_8u_C3CnR : 0; |
| else if( depth == CV_16U ) |
| func2 = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? (CvColorCvtFunc2)icvYCrCb2BGRx_16u_C3CnR : |
| code == CV_XYZ2BGR || code == CV_XYZ2RGB ? (CvColorCvtFunc2)icvXYZ2BGRx_16u_C3CnR : 0; |
| else if( depth == CV_32F ) |
| func2 = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? (CvColorCvtFunc2)icvYCrCb2BGRx_32f_C3CnR : |
| code == CV_XYZ2BGR || code == CV_XYZ2RGB ? (CvColorCvtFunc2)icvXYZ2BGRx_32f_C3CnR : |
| code == CV_HSV2BGR || code == CV_HSV2RGB ? (CvColorCvtFunc2)icvHSV2BGRx_32f_C3CnR : |
| code == CV_HLS2BGR || code == CV_HLS2RGB ? (CvColorCvtFunc2)icvHLS2BGRx_32f_C3CnR : |
| code == CV_Lab2BGR || code == CV_Lab2RGB ? (CvColorCvtFunc2)icvLab2BGRx_32f_C3CnR : |
| code == CV_Luv2BGR || code == CV_Luv2RGB ? (CvColorCvtFunc2)icvLuv2BGRx_32f_C3CnR : 0; |
| |
| param[0] = dst_cn; |
| param[1] = code == CV_XYZ2BGR || code == CV_YCrCb2BGR || code == CV_HSV2BGR || |
| code == CV_Lab2BGR || code == CV_Luv2BGR || code == CV_HLS2BGR ? 0 : 2; |
| break; |
| |
| case CV_BayerBG2BGR: |
| case CV_BayerGB2BGR: |
| case CV_BayerRG2BGR: |
| case CV_BayerGR2BGR: |
| if( src_cn != 1 || dst_cn != 3 ) |
| CV_ERROR( CV_BadNumChannels, |
| "Incorrect number of channels for this conversion code" ); |
| |
| if( depth != CV_8U ) |
| CV_ERROR( CV_BadDepth, |
| "Bayer pattern can be converted only to 8-bit 3-channel BGR/RGB image" ); |
| |
| func1 = (CvColorCvtFunc1)icvBayer2BGR_8u_C1C3R; |
| param[0] = code; // conversion code |
| break; |
| default: |
| CV_ERROR( CV_StsBadFlag, "Unknown/unsupported color conversion code" ); |
| } |
| |
| if( func0 ) |
| { |
| IPPI_CALL( func0( src->data.ptr, src_step, dst->data.ptr, dst_step, size )); |
| } |
| else if( func1 ) |
| { |
| IPPI_CALL( func1( src->data.ptr, src_step, |
| dst->data.ptr, dst_step, size, param[0] )); |
| } |
| else if( func2 ) |
| { |
| IPPI_CALL( func2( src->data.ptr, src_step, |
| dst->data.ptr, dst_step, size, param[0], param[1] )); |
| } |
| else if( func3 ) |
| { |
| IPPI_CALL( func3( src->data.ptr, src_step, |
| dst->data.ptr, dst_step, size, param[0], param[1], param[2] )); |
| } |
| else |
| CV_ERROR( CV_StsUnsupportedFormat, "The image format is not supported" ); |
| |
| __END__; |
| } |
| |
| /* End of file. */ |
| |
| |