Download modules/core/src/opencl/minmaxloc.cl from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 9.67 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/core/src/opencl/minmaxloc.cl
- Command line
-
hf download hf://tgollogly/test/modules/core/src/opencl/minmaxloc.cl
-
curl -L -o minmaxloc.cl https://huggingface.co/tgollogly/test/resolve/main/modules/core/src/opencl/minmaxloc.cl
9.67 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. | |
| // Copyright (C) 2014, Itseez, Inc., all rights reserved. | |
| // Third party copyrights are property of their respective owners. | |
| static inline int align(int pos) | |
| { | |
| return (pos + (MINMAX_STRUCT_ALIGNMENT - 1)) & (~(MINMAX_STRUCT_ALIGNMENT - 1)); | |
| } | |
| __kernel void minmaxloc(__global const uchar * srcptr, int src_step, int src_offset, int cols, | |
| int total, int groupnum, __global uchar * dstptr | |
| #ifdef HAVE_MASK | |
| , __global const uchar * mask, int mask_step, int mask_offset | |
| #endif | |
| #ifdef HAVE_SRC2 | |
| , __global const uchar * src2ptr, int src2_step, int src2_offset | |
| #endif | |
| ) | |
| { | |
| int lid = get_local_id(0); | |
| int gid = get_group_id(0); | |
| int id = get_global_id(0) | |
| * kercn; | |
| ; | |
| srcptr += src_offset; | |
| mask += mask_offset; | |
| src2ptr += src2_offset; | |
| __local dstT1 localmem_min[WGS2_ALIGNED]; | |
| dstT1 minval = MAX_VAL; | |
| __local uint localmem_minloc[WGS2_ALIGNED]; | |
| uint minloc = INDEX_MAX; | |
| dstT1 maxval = MIN_VAL; | |
| __local dstT1 localmem_max[WGS2_ALIGNED]; | |
| __local uint localmem_maxloc[WGS2_ALIGNED]; | |
| uint maxloc = INDEX_MAX; | |
| __local dstT1 localmem_max2[WGS2_ALIGNED]; | |
| dstT1 maxval2 = MIN_VAL; | |
| int src_index; | |
| int mask_index; | |
| int src2_index; | |
| dstT temp; | |
| dstT temp2; | |
| for (int grain = groupnum * WGS | |
| * kercn | |
| ; id < total; id += grain) | |
| { | |
| mask_index = id; | |
| mask_index = mad24(id / cols, mask_step, id % cols); | |
| if (mask[mask_index]) | |
| { | |
| src_index = id * srcTSIZE;//mul24(id, srcTSIZE); | |
| src_index = mad24(id / cols, src_step, mul24(id % cols, srcTSIZE)); | |
| temp = convertToDT(loadpix(srcptr + src_index)); | |
| temp = MIN_ABS(temp); | |
| src2_index = id * srcTSIZE; //mul24(id, srcTSIZE); | |
| src2_index = mad24(id / cols, src2_step, mul24(id % cols, srcTSIZE)); | |
| temp2 = convertToDT(loadpix(src2ptr + src2_index)); | |
| temp = MIN_ABS2(temp, temp2); | |
| temp2 = MIN_ABS(temp2); | |
| if (minval > temp) | |
| { | |
| minval = temp; | |
| minloc = id; | |
| } | |
| minval = MIN(minval, temp); | |
| if (maxval < temp) | |
| { | |
| maxval = temp; | |
| maxloc = id; | |
| } | |
| maxval = MAX(maxval, temp); | |
| maxval2 = MAX(maxval2, temp2); | |
| CALC_P(s0, 0) | |
| CALC_P(s1, 1) | |
| CALC_P(s2, 2) | |
| CALC_P(s3, 3) | |
| CALC_P(s4, 4) | |
| CALC_P(s5, 5) | |
| CALC_P(s6, 6) | |
| CALC_P(s7, 7) | |
| CALC_P(s8, 8) | |
| CALC_P(s9, 9) | |
| CALC_P(sA, 10) | |
| CALC_P(sB, 11) | |
| CALC_P(sC, 12) | |
| CALC_P(sD, 13) | |
| CALC_P(sE, 14) | |
| CALC_P(sF, 15) | |
| } | |
| } | |
| if (lid < WGS2_ALIGNED) | |
| { | |
| localmem_min[lid] = minval; | |
| localmem_max[lid] = maxval; | |
| localmem_minloc[lid] = minloc; | |
| localmem_maxloc[lid] = maxloc; | |
| localmem_max2[lid] = maxval2; | |
| } | |
| barrier(CLK_LOCAL_MEM_FENCE); | |
| if (lid >= WGS2_ALIGNED && total >= WGS2_ALIGNED) | |
| { | |
| int lid3 = lid - WGS2_ALIGNED; | |
| if (localmem_min[lid3] >= minval) | |
| { | |
| if (localmem_min[lid3] == minval) | |
| localmem_minloc[lid3] = min(localmem_minloc[lid3], minloc); | |
| else | |
| localmem_minloc[lid3] = minloc, | |
| localmem_min[lid3] = minval; | |
| } | |
| localmem_min[lid3] = MIN(localmem_min[lid3], minval); | |
| if (localmem_max[lid3] <= maxval) | |
| { | |
| if (localmem_max[lid3] == maxval) | |
| localmem_maxloc[lid3] = min(localmem_maxloc[lid3], maxloc); | |
| else | |
| localmem_maxloc[lid3] = maxloc, | |
| localmem_max[lid3] = maxval; | |
| } | |
| localmem_max[lid3] = MAX(localmem_max[lid3], maxval); | |
| localmem_max2[lid3] = MAX(localmem_max2[lid3], maxval2); | |
| } | |
| barrier(CLK_LOCAL_MEM_FENCE); | |
| for (int lsize = WGS2_ALIGNED >> 1; lsize > 0; lsize >>= 1) | |
| { | |
| if (lid < lsize) | |
| { | |
| int lid2 = lsize + lid; | |
| if (localmem_min[lid] >= localmem_min[lid2]) | |
| { | |
| if (localmem_min[lid] == localmem_min[lid2]) | |
| localmem_minloc[lid] = min(localmem_minloc[lid2], localmem_minloc[lid]); | |
| else | |
| localmem_minloc[lid] = localmem_minloc[lid2], | |
| localmem_min[lid] = localmem_min[lid2]; | |
| } | |
| localmem_min[lid] = MIN(localmem_min[lid], localmem_min[lid2]); | |
| if (localmem_max[lid] <= localmem_max[lid2]) | |
| { | |
| if (localmem_max[lid] == localmem_max[lid2]) | |
| localmem_maxloc[lid] = min(localmem_maxloc[lid2], localmem_maxloc[lid]); | |
| else | |
| localmem_maxloc[lid] = localmem_maxloc[lid2], | |
| localmem_max[lid] = localmem_max[lid2]; | |
| } | |
| localmem_max[lid] = MAX(localmem_max[lid], localmem_max[lid2]); | |
| localmem_max2[lid] = MAX(localmem_max2[lid], localmem_max2[lid2]); | |
| } | |
| barrier(CLK_LOCAL_MEM_FENCE); | |
| } | |
| if (lid == 0) | |
| { | |
| int pos = 0; | |
| *(__global dstT1 *)(dstptr + mad24(gid, (int)sizeof(dstT1), pos)) = localmem_min[0]; | |
| pos = mad24(groupnum, (int)sizeof(dstT1), pos); | |
| pos = align(pos); | |
| *(__global dstT1 *)(dstptr + mad24(gid, (int)sizeof(dstT1), pos)) = localmem_max[0]; | |
| pos = mad24(groupnum, (int)sizeof(dstT1), pos); | |
| pos = align(pos); | |
| *(__global uint *)(dstptr + mad24(gid, (int)sizeof(uint), pos)) = localmem_minloc[0]; | |
| pos = mad24(groupnum, (int)sizeof(uint), pos); | |
| pos = align(pos); | |
| *(__global uint *)(dstptr + mad24(gid, (int)sizeof(uint), pos)) = localmem_maxloc[0]; | |
| pos = mad24(groupnum, (int)sizeof(uint), pos); | |
| pos = align(pos); | |
| *(__global dstT1 *)(dstptr + mad24(gid, (int)sizeof(dstT1), pos)) = localmem_max2[0]; | |
| } | |
| } | |