Download modules/imgproc/src/color_hsv.dispatch.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 13.2 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/imgproc/src/color_hsv.dispatch.cpp
- Command line
-
hf download hf://tgollogly/test/modules/imgproc/src/color_hsv.dispatch.cpp
-
curl -L -o color_hsv.dispatch.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/imgproc/src/color_hsv.dispatch.cpp
13.2 kB
| // This file is part of OpenCV project. | |
| // It is subject to the license terms in the LICENSE file found in the top-level directory | |
| // of this distribution and at http://opencv.org/license.html | |
| namespace cv { | |
| // | |
| // IPP functions | |
| // | |
| static ippiGeneralFunc ippiRGB2HSVTab[] = | |
| { | |
| (ippiGeneralFunc)ippiRGBToHSV_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToHSV_16u_C3R, 0, | |
| 0, 0, 0, 0 | |
| }; | |
| static ippiGeneralFunc ippiHSV2RGBTab[] = | |
| { | |
| (ippiGeneralFunc)ippiHSVToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiHSVToRGB_16u_C3R, 0, | |
| 0, 0, 0, 0 | |
| }; | |
| static ippiGeneralFunc ippiRGB2HLSTab[] = | |
| { | |
| (ippiGeneralFunc)ippiRGBToHLS_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToHLS_16u_C3R, 0, | |
| 0, (ippiGeneralFunc)ippiRGBToHLS_32f_C3R, 0, 0 | |
| }; | |
| static ippiGeneralFunc ippiHLS2RGBTab[] = | |
| { | |
| (ippiGeneralFunc)ippiHLSToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiHLSToRGB_16u_C3R, 0, | |
| 0, (ippiGeneralFunc)ippiHLSToRGB_32f_C3R, 0, 0 | |
| }; | |
| // | |
| // HAL functions | |
| // | |
| namespace hal | |
| { | |
| // 8u, 32f | |
| void cvtBGRtoHSV(const uchar * src_data, size_t src_step, | |
| uchar * dst_data, size_t dst_step, | |
| int width, int height, | |
| int depth, int scn, bool swapBlue, bool isFullRange, bool isHSV) | |
| { | |
| CV_INSTRUMENT_REGION(); | |
| CALL_HAL(cvtBGRtoHSV, cv_hal_cvtBGRtoHSV, src_data, src_step, dst_data, dst_step, width, height, depth, scn, swapBlue, isFullRange, isHSV); | |
| CV_IPP_CHECK() | |
| { | |
| if(depth == CV_8U && isFullRange) | |
| { | |
| if (isHSV) | |
| { | |
| if(scn == 3 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoopCopy(src_data, src_step, CV_MAKE_TYPE(depth, scn), dst_data, dst_step, width, height, | |
| IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(scn == 4 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(scn == 4 && swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 0, 1, 2, depth)) ) | |
| return; | |
| } | |
| } | |
| else | |
| { | |
| if(scn == 3 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoopCopy(src_data, src_step, CV_MAKE_TYPE(depth, scn), dst_data, dst_step, width, height, | |
| IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(scn == 4 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(scn == 3 && swapBlue) | |
| { | |
| if( CvtColorIPPLoopCopy(src_data, src_step, CV_MAKE_TYPE(depth, scn), dst_data, dst_step, width, height, | |
| IPPGeneralFunctor(ippiRGB2HLSTab[depth])) ) | |
| return; | |
| } | |
| else if(scn == 4 && swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 0, 1, 2, depth)) ) | |
| return; | |
| } | |
| } | |
| } | |
| } | |
| CV_CPU_DISPATCH(cvtBGRtoHSV, (src_data, src_step, dst_data, dst_step, width, height, depth, scn, swapBlue, isFullRange, isHSV), | |
| CV_CPU_DISPATCH_MODES_ALL); | |
| } | |
| // 8u, 32f | |
| void cvtHSVtoBGR(const uchar * src_data, size_t src_step, | |
| uchar * dst_data, size_t dst_step, | |
| int width, int height, | |
| int depth, int dcn, bool swapBlue, bool isFullRange, bool isHSV) | |
| { | |
| CV_INSTRUMENT_REGION(); | |
| CALL_HAL(cvtHSVtoBGR, cv_hal_cvtHSVtoBGR, src_data, src_step, dst_data, dst_step, width, height, depth, dcn, swapBlue, isFullRange, isHSV); | |
| CV_IPP_CHECK() | |
| { | |
| if (depth == CV_8U && isFullRange) | |
| { | |
| if (isHSV) | |
| { | |
| if(dcn == 3 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoopCopy(src_data, src_step, CV_MAKETYPE(depth, 3), dst_data, dst_step, width, height, | |
| IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(dcn == 4 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(dcn == 3 && swapBlue) | |
| { | |
| if( CvtColorIPPLoopCopy(src_data, src_step, CV_MAKETYPE(depth, 3), dst_data, dst_step, width, height, | |
| IPPGeneralFunctor(ippiHSV2RGBTab[depth])) ) | |
| return; | |
| } | |
| else if(dcn == 4 && swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) | |
| return; | |
| } | |
| } | |
| else | |
| { | |
| if(dcn == 3 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoopCopy(src_data, src_step, CV_MAKETYPE(depth, 3), dst_data, dst_step, width, height, | |
| IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(dcn == 4 && !swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) | |
| return; | |
| } | |
| else if(dcn == 3 && swapBlue) | |
| { | |
| if( CvtColorIPPLoopCopy(src_data, src_step, CV_MAKETYPE(depth, 3), dst_data, dst_step, width, height, | |
| IPPGeneralFunctor(ippiHLS2RGBTab[depth])) ) | |
| return; | |
| } | |
| else if(dcn == 4 && swapBlue) | |
| { | |
| if( CvtColorIPPLoop(src_data, src_step, dst_data, dst_step, width, height, | |
| IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) | |
| return; | |
| } | |
| } | |
| } | |
| } | |
| CV_CPU_DISPATCH(cvtHSVtoBGR, (src_data, src_step, dst_data, dst_step, width, height, depth, dcn, swapBlue, isFullRange, isHSV), | |
| CV_CPU_DISPATCH_MODES_ALL); | |
| } | |
| } // namespace hal | |
| // | |
| // OCL calls | |
| // | |
| bool oclCvtColorHSV2BGR( InputArray _src, OutputArray _dst, int dcn, int bidx, bool full ) | |
| { | |
| OclHelper< Set<3>, Set<3, 4>, Set<CV_8U, CV_32F> > h(_src, _dst, dcn); | |
| int hrange = _src.depth() == CV_32F ? 360 : (!full ? 180 : 255); | |
| if(!h.createKernel("HSV2RGB", ocl::imgproc::color_hsv_oclsrc, | |
| format("-D DCN=%d -D BIDX=%d -D HRANGE=%d -D HSCALE=%ff", dcn, bidx, hrange, 6.f/hrange))) | |
| { | |
| return false; | |
| } | |
| return h.run(); | |
| } | |
| bool oclCvtColorHLS2BGR( InputArray _src, OutputArray _dst, int dcn, int bidx, bool full ) | |
| { | |
| OclHelper< Set<3>, Set<3, 4>, Set<CV_8U, CV_32F> > h(_src, _dst, dcn); | |
| int hrange = _src.depth() == CV_32F ? 360 : (!full ? 180 : 255); | |
| if(!h.createKernel("HLS2RGB", ocl::imgproc::color_hsv_oclsrc, | |
| format("-D DCN=%d -D BIDX=%d -D HRANGE=%d -D HSCALE=%ff", dcn, bidx, hrange, 6.f/hrange))) | |
| { | |
| return false; | |
| } | |
| return h.run(); | |
| } | |
| bool oclCvtColorBGR2HLS( InputArray _src, OutputArray _dst, int bidx, bool full ) | |
| { | |
| OclHelper< Set<3, 4>, Set<3>, Set<CV_8U, CV_32F> > h(_src, _dst, 3); | |
| float hscale = (_src.depth() == CV_32F ? 360.f : (!full ? 180.f : 256.f))/360.f; | |
| if(!h.createKernel("RGB2HLS", ocl::imgproc::color_hsv_oclsrc, | |
| format("-D HSCALE=%ff -D BIDX=%d -D DCN=3", hscale, bidx))) | |
| { | |
| return false; | |
| } | |
| return h.run(); | |
| } | |
| bool oclCvtColorBGR2HSV( InputArray _src, OutputArray _dst, int bidx, bool full ) | |
| { | |
| OclHelper< Set<3, 4>, Set<3>, Set<CV_8U, CV_32F> > h(_src, _dst, 3); | |
| int hrange = _src.depth() == CV_32F ? 360 : (!full ? 180 : 256); | |
| cv::String options = (_src.depth() == CV_8U ? | |
| format("-D HRANGE=%d -D BIDX=%d -D DCN=3", hrange, bidx) : | |
| format("-D HSCALE=%ff -D BIDX=%d -D DCN=3", hrange*(1.f/360.f), bidx)); | |
| if(!h.createKernel("RGB2HSV", ocl::imgproc::color_hsv_oclsrc, options)) | |
| { | |
| return false; | |
| } | |
| if(_src.depth() == CV_8U) | |
| { | |
| static UMat sdiv_data; | |
| static UMat hdiv_data180; | |
| static UMat hdiv_data256; | |
| static int sdiv_table[256]; | |
| static int hdiv_table180[256]; | |
| static int hdiv_table256[256]; | |
| static volatile bool initialized180 = false, initialized256 = false; | |
| volatile bool & initialized = hrange == 180 ? initialized180 : initialized256; | |
| if (!initialized) | |
| { | |
| int * const hdiv_table = hrange == 180 ? hdiv_table180 : hdiv_table256, hsv_shift = 12; | |
| UMat & hdiv_data = hrange == 180 ? hdiv_data180 : hdiv_data256; | |
| sdiv_table[0] = hdiv_table180[0] = hdiv_table256[0] = 0; | |
| int v = 255 << hsv_shift; | |
| if (!initialized180 && !initialized256) | |
| { | |
| for(int i = 1; i < 256; i++ ) | |
| sdiv_table[i] = saturate_cast<int>(v/(1.*i)); | |
| Mat(1, 256, CV_32SC1, sdiv_table).copyTo(sdiv_data); | |
| } | |
| v = hrange << hsv_shift; | |
| for (int i = 1; i < 256; i++ ) | |
| hdiv_table[i] = saturate_cast<int>(v/(6.*i)); | |
| Mat(1, 256, CV_32SC1, hdiv_table).copyTo(hdiv_data); | |
| initialized = true; | |
| } | |
| h.setArg(ocl::KernelArg::PtrReadOnly(sdiv_data)); | |
| h.setArg(hrange == 256 ? ocl::KernelArg::PtrReadOnly(hdiv_data256) : | |
| ocl::KernelArg::PtrReadOnly(hdiv_data180)); | |
| } | |
| return h.run(); | |
| } | |
| // | |
| // HAL calls | |
| // | |
| void cvtColorBGR2HLS( InputArray _src, OutputArray _dst, bool swapb, bool fullRange ) | |
| { | |
| CvtHelper< Set<3, 4>, Set<3>, Set<CV_8U, CV_32F> > h(_src, _dst, 3); | |
| hal::cvtBGRtoHSV(h.src.data, h.src.step, h.dst.data, h.dst.step, h.src.cols, h.src.rows, | |
| h.depth, h.scn, swapb, fullRange, false); | |
| } | |
| void cvtColorBGR2HSV( InputArray _src, OutputArray _dst, bool swapb, bool fullRange ) | |
| { | |
| CvtHelper< Set<3, 4>, Set<3>, Set<CV_8U, CV_32F> > h(_src, _dst, 3); | |
| hal::cvtBGRtoHSV(h.src.data, h.src.step, h.dst.data, h.dst.step, h.src.cols, h.src.rows, | |
| h.depth, h.scn, swapb, fullRange, true); | |
| } | |
| void cvtColorHLS2BGR( InputArray _src, OutputArray _dst, int dcn, bool swapb, bool fullRange) | |
| { | |
| if(dcn <= 0) dcn = 3; | |
| CvtHelper< Set<3>, Set<3, 4>, Set<CV_8U, CV_32F> > h(_src, _dst, dcn); | |
| hal::cvtHSVtoBGR(h.src.data, h.src.step, h.dst.data, h.dst.step, h.src.cols, h.src.rows, | |
| h.depth, dcn, swapb, fullRange, false); | |
| } | |
| void cvtColorHSV2BGR( InputArray _src, OutputArray _dst, int dcn, bool swapb, bool fullRange) | |
| { | |
| if(dcn <= 0) dcn = 3; | |
| CvtHelper< Set<3>, Set<3, 4>, Set<CV_8U, CV_32F> > h(_src, _dst, dcn); | |
| hal::cvtHSVtoBGR(h.src.data, h.src.step, h.dst.data, h.dst.step, h.src.cols, h.src.rows, | |
| h.depth, dcn, swapb, fullRange, true); | |
| } | |
| } // namespace cv | |