mirror of https://github.com/opencv/opencv.git
Nghia Ho
11 years ago
commit
cc15898353
899 changed files with 11768 additions and 11055 deletions
@ -0,0 +1 @@ |
|||||||
|
* -whitespace |
||||||
@ -0,0 +1,22 @@ |
|||||||
|
diff --git a/3rdparty/libpng/pngpriv.h b/3rdparty/libpng/pngpriv.h
|
||||||
|
index 07b2b0b..e7824b8 100644
|
||||||
|
--- a/3rdparty/libpng/pngpriv.h
|
||||||
|
+++ b/3rdparty/libpng/pngpriv.h
|
||||||
|
@@ -360,7 +360,7 @@ typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp;
|
||||||
|
|
||||||
|
/* Memory model/platform independent fns */
|
||||||
|
#ifndef PNG_ABORT
|
||||||
|
-# ifdef _WINDOWS_
|
||||||
|
+# if defined(_WINDOWS_) && !defined(HAVE_WINRT)
|
||||||
|
# define PNG_ABORT() ExitProcess(0)
|
||||||
|
# else
|
||||||
|
# define PNG_ABORT() abort()
|
||||||
|
@@ -378,7 +378,7 @@ typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp;
|
||||||
|
# define png_memcpy _fmemcpy
|
||||||
|
# define png_memset _fmemset
|
||||||
|
#else
|
||||||
|
-# ifdef _WINDOWS_ /* Favor Windows over C runtime fns */
|
||||||
|
+# if defined(_WINDOWS_) && !defined(HAVE_WINRT) /* Favor Windows over C runtime fns */
|
||||||
|
# define CVT_PTR(ptr) (ptr)
|
||||||
|
# define CVT_PTR_NOCHECK(ptr) (ptr)
|
||||||
|
# define png_strlen lstrlenA
|
||||||
@ -0,0 +1,4 @@ |
|||||||
|
if(IOS) |
||||||
|
configure_file("${OpenCV_SOURCE_DIR}/platforms/ios/Info.plist.in" |
||||||
|
"${CMAKE_BINARY_DIR}/ios/Info.plist") |
||||||
|
endif() |
||||||
@ -1 +1,3 @@ |
|||||||
set(MIN_VER_CMAKE 2.8.7) |
set(MIN_VER_CMAKE 2.8.7) |
||||||
|
set(MIN_VER_PYTHON 2.6) |
||||||
|
set(MIN_VER_ZLIB 1.2.3) |
||||||
|
|||||||
|
Before Width: | Height: | Size: 31 KiB After Width: | Height: | Size: 24 KiB |
@ -1,2 +1,2 @@ |
|||||||
set(the_description "Biologically inspired algorithms") |
set(the_description "Biologically inspired algorithms") |
||||||
ocv_define_module(bioinspired opencv_core OPTIONAL opencv_highgui) |
ocv_define_module(bioinspired opencv_core OPTIONAL opencv_highgui opencv_ocl) |
||||||
|
|||||||
@ -0,0 +1,753 @@ |
|||||||
|
/*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. |
||||||
|
// |
||||||
|
// |
||||||
|
// License Agreement |
||||||
|
// For Open Source Computer Vision Library |
||||||
|
// |
||||||
|
// Copyright (C) 2010-2013, Multicoreware, Inc., all rights reserved. |
||||||
|
// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved. |
||||||
|
// Third party copyrights are property of their respective owners. |
||||||
|
// |
||||||
|
// @Authors |
||||||
|
// Peng Xiao, pengxiao@multicorewareinc.com |
||||||
|
// |
||||||
|
// 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 oclMaterials provided with the distribution. |
||||||
|
// |
||||||
|
// * The name of the copyright holders 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*/ |
||||||
|
|
||||||
|
///////////////////////////////////////////////////////// |
||||||
|
//******************************************************* |
||||||
|
// basicretinafilter |
||||||
|
//////////////// _spatiotemporalLPfilter //////////////// |
||||||
|
//_horizontalCausalFilter_addInput |
||||||
|
kernel void horizontalCausalFilter_addInput( |
||||||
|
global const float * input, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int in_offset, |
||||||
|
const int out_offset, |
||||||
|
const float _tau, |
||||||
|
const float _a |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
global const float * iptr = |
||||||
|
input + mad24(gid, elements_per_row, in_offset / 4); |
||||||
|
global float * optr = |
||||||
|
output + mad24(gid, elements_per_row, out_offset / 4); |
||||||
|
|
||||||
|
float res; |
||||||
|
float4 in_v4, out_v4, res_v4 = (float4)(0); |
||||||
|
//vectorize to increase throughput |
||||||
|
for(int i = 0; i < cols / 4; ++i, iptr += 4, optr += 4) |
||||||
|
{ |
||||||
|
in_v4 = vload4(0, iptr); |
||||||
|
out_v4 = vload4(0, optr); |
||||||
|
|
||||||
|
res_v4.x = in_v4.x + _tau * out_v4.x + _a * res_v4.w; |
||||||
|
res_v4.y = in_v4.y + _tau * out_v4.y + _a * res_v4.x; |
||||||
|
res_v4.z = in_v4.z + _tau * out_v4.z + _a * res_v4.y; |
||||||
|
res_v4.w = in_v4.w + _tau * out_v4.w + _a * res_v4.z; |
||||||
|
|
||||||
|
vstore4(res_v4, 0, optr); |
||||||
|
} |
||||||
|
res = res_v4.w; |
||||||
|
// there may be left some |
||||||
|
for(int i = 0; i < cols % 4; ++i, ++iptr, ++optr) |
||||||
|
{ |
||||||
|
res = *iptr + _tau * *optr + _a * res; |
||||||
|
*optr = res; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//_horizontalAnticausalFilter |
||||||
|
kernel void horizontalAnticausalFilter( |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int out_offset, |
||||||
|
const float _a |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
global float * optr = output + |
||||||
|
mad24(gid + 1, elements_per_row, - 1 + out_offset / 4); |
||||||
|
|
||||||
|
float4 result = (float4)(0), out_v4; |
||||||
|
// we assume elements_per_row is multple of 4 |
||||||
|
for(int i = 0; i < elements_per_row / 4; ++i, optr -= 4) |
||||||
|
{ |
||||||
|
// shift left, `offset` is type `size_t` so it cannot be negative |
||||||
|
out_v4 = vload4(0, optr - 3); |
||||||
|
|
||||||
|
result.w = out_v4.w + _a * result.x; |
||||||
|
result.z = out_v4.z + _a * result.w; |
||||||
|
result.y = out_v4.y + _a * result.z; |
||||||
|
result.x = out_v4.x + _a * result.y; |
||||||
|
|
||||||
|
vstore4(result, 0, optr - 3); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//_verticalCausalFilter |
||||||
|
kernel void verticalCausalFilter( |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int out_offset, |
||||||
|
const float _a |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= cols) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
global float * optr = output + gid + out_offset / 4; |
||||||
|
float result = 0; |
||||||
|
for(int i = 0; i < rows; ++i, optr += elements_per_row) |
||||||
|
{ |
||||||
|
result = *optr + _a * result; |
||||||
|
*optr = result; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//_verticalCausalFilter |
||||||
|
kernel void verticalAnticausalFilter_multGain( |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int out_offset, |
||||||
|
const float _a, |
||||||
|
const float _gain |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= cols) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
global float * optr = output + (rows - 1) * elements_per_row + gid + out_offset / 4; |
||||||
|
float result = 0; |
||||||
|
for(int i = 0; i < rows; ++i, optr -= elements_per_row) |
||||||
|
{ |
||||||
|
result = *optr + _a * result; |
||||||
|
*optr = _gain * result; |
||||||
|
} |
||||||
|
} |
||||||
|
// |
||||||
|
// end of _spatiotemporalLPfilter |
||||||
|
///////////////////////////////////////////////////////////////////// |
||||||
|
|
||||||
|
//////////////// horizontalAnticausalFilter_Irregular //////////////// |
||||||
|
kernel void horizontalAnticausalFilter_Irregular( |
||||||
|
global float * output, |
||||||
|
global float * buffer, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int out_offset, |
||||||
|
const int buffer_offset |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
global float * optr = |
||||||
|
output + mad24(rows - gid, elements_per_row, -1 + out_offset / 4); |
||||||
|
global float * bptr = |
||||||
|
buffer + mad24(rows - gid, elements_per_row, -1 + buffer_offset / 4); |
||||||
|
|
||||||
|
float4 buf_v4, out_v4, res_v4 = (float4)(0); |
||||||
|
|
||||||
|
for(int i = 0; i < elements_per_row / 4; ++i, optr -= 4, bptr -= 4) |
||||||
|
{ |
||||||
|
buf_v4 = vload4(0, bptr - 3); |
||||||
|
out_v4 = vload4(0, optr - 3); |
||||||
|
|
||||||
|
res_v4.w = out_v4.w + buf_v4.w * res_v4.x; |
||||||
|
res_v4.z = out_v4.z + buf_v4.z * res_v4.w; |
||||||
|
res_v4.y = out_v4.y + buf_v4.y * res_v4.z; |
||||||
|
res_v4.x = out_v4.x + buf_v4.x * res_v4.y; |
||||||
|
|
||||||
|
vstore4(res_v4, 0, optr - 3); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//////////////// verticalCausalFilter_Irregular //////////////// |
||||||
|
kernel void verticalCausalFilter_Irregular( |
||||||
|
global float * output, |
||||||
|
global float * buffer, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int out_offset, |
||||||
|
const int buffer_offset |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= cols) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
global float * optr = output + gid + out_offset / 4; |
||||||
|
global float * bptr = buffer + gid + buffer_offset / 4; |
||||||
|
float result = 0; |
||||||
|
for(int i = 0; i < rows; ++i, optr += elements_per_row, bptr += elements_per_row) |
||||||
|
{ |
||||||
|
result = *optr + *bptr * result; |
||||||
|
*optr = result; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//////////////// _adaptiveHorizontalCausalFilter_addInput //////////////// |
||||||
|
kernel void adaptiveHorizontalCausalFilter_addInput( |
||||||
|
global const float * input, |
||||||
|
global const float * gradient, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int in_offset, |
||||||
|
const int grad_offset, |
||||||
|
const int out_offset |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
global const float * iptr = |
||||||
|
input + mad24(gid, elements_per_row, in_offset / 4); |
||||||
|
global const float * gptr = |
||||||
|
gradient + mad24(gid, elements_per_row, grad_offset / 4); |
||||||
|
global float * optr = |
||||||
|
output + mad24(gid, elements_per_row, out_offset / 4); |
||||||
|
|
||||||
|
float4 in_v4, grad_v4, out_v4, res_v4 = (float4)(0); |
||||||
|
for(int i = 0; i < cols / 4; ++i, iptr += 4, gptr += 4, optr += 4) |
||||||
|
{ |
||||||
|
in_v4 = vload4(0, iptr); |
||||||
|
grad_v4 = vload4(0, gptr); |
||||||
|
|
||||||
|
res_v4.x = in_v4.x + grad_v4.x * res_v4.w; |
||||||
|
res_v4.y = in_v4.y + grad_v4.y * res_v4.x; |
||||||
|
res_v4.z = in_v4.z + grad_v4.z * res_v4.y; |
||||||
|
res_v4.w = in_v4.w + grad_v4.w * res_v4.z; |
||||||
|
|
||||||
|
vstore4(res_v4, 0, optr); |
||||||
|
} |
||||||
|
for(int i = 0; i < cols % 4; ++i, ++iptr, ++gptr, ++optr) |
||||||
|
{ |
||||||
|
res_v4.w = *iptr + *gptr * res_v4.w; |
||||||
|
*optr = res_v4.w; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//////////////// _adaptiveVerticalAnticausalFilter_multGain //////////////// |
||||||
|
kernel void adaptiveVerticalAnticausalFilter_multGain( |
||||||
|
global const float * gradient, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const int grad_offset, |
||||||
|
const int out_offset, |
||||||
|
const float gain |
||||||
|
) |
||||||
|
{ |
||||||
|
int gid = get_global_id(0); |
||||||
|
if(gid >= cols) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
int start_idx = mad24(rows - 1, elements_per_row, gid); |
||||||
|
|
||||||
|
global const float * gptr = gradient + start_idx + grad_offset / 4; |
||||||
|
global float * optr = output + start_idx + out_offset / 4; |
||||||
|
|
||||||
|
float result = 0; |
||||||
|
for(int i = 0; i < rows; ++i, gptr -= elements_per_row, optr -= elements_per_row) |
||||||
|
{ |
||||||
|
result = *optr + *gptr * result; |
||||||
|
*optr = gain * result; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//////////////// _localLuminanceAdaptation //////////////// |
||||||
|
// FIXME: |
||||||
|
// This kernel seems to have precision problem on GPU |
||||||
|
kernel void localLuminanceAdaptation( |
||||||
|
global const float * luma, |
||||||
|
global const float * input, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float _localLuminanceAddon, |
||||||
|
const float _localLuminanceFactor, |
||||||
|
const float _maxInputValue |
||||||
|
) |
||||||
|
{ |
||||||
|
int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
|
||||||
|
float X0 = luma[offset] * _localLuminanceFactor + _localLuminanceAddon; |
||||||
|
float input_val = input[offset]; |
||||||
|
// output of the following line may be different between GPU and CPU |
||||||
|
output[offset] = (_maxInputValue + X0) * input_val / (input_val + X0 + 0.00000000001f); |
||||||
|
} |
||||||
|
// end of basicretinafilter |
||||||
|
//******************************************************* |
||||||
|
///////////////////////////////////////////////////////// |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////// |
||||||
|
//****************************************************** |
||||||
|
// magno |
||||||
|
// TODO: this kernel has too many buffer accesses, better to make it |
||||||
|
// vector read/write for fetch efficiency |
||||||
|
kernel void amacrineCellsComputing( |
||||||
|
global const float * opl_on, |
||||||
|
global const float * opl_off, |
||||||
|
global float * prev_in_on, |
||||||
|
global float * prev_in_off, |
||||||
|
global float * out_on, |
||||||
|
global float * out_off, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float coeff |
||||||
|
) |
||||||
|
{ |
||||||
|
int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
opl_on += offset; |
||||||
|
opl_off += offset; |
||||||
|
prev_in_on += offset; |
||||||
|
prev_in_off += offset; |
||||||
|
out_on += offset; |
||||||
|
out_off += offset; |
||||||
|
|
||||||
|
float magnoXonPixelResult = coeff * (*out_on + *opl_on - *prev_in_on); |
||||||
|
*out_on = fmax(magnoXonPixelResult, 0); |
||||||
|
float magnoXoffPixelResult = coeff * (*out_off + *opl_off - *prev_in_off); |
||||||
|
*out_off = fmax(magnoXoffPixelResult, 0); |
||||||
|
|
||||||
|
*prev_in_on = *opl_on; |
||||||
|
*prev_in_off = *opl_off; |
||||||
|
} |
||||||
|
|
||||||
|
///////////////////////////////////////////////////////// |
||||||
|
//****************************************************** |
||||||
|
// parvo |
||||||
|
// TODO: this kernel has too many buffer accesses, needs optimization |
||||||
|
kernel void OPL_OnOffWaysComputing( |
||||||
|
global float4 * photo_out, |
||||||
|
global float4 * horiz_out, |
||||||
|
global float4 * bipol_on, |
||||||
|
global float4 * bipol_off, |
||||||
|
global float4 * parvo_on, |
||||||
|
global float4 * parvo_off, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row |
||||||
|
) |
||||||
|
{ |
||||||
|
int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx * 4 >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
// we assume elements_per_row must be multiples of 4 |
||||||
|
int offset = mad24(gidy, elements_per_row >> 2, gidx); |
||||||
|
photo_out += offset; |
||||||
|
horiz_out += offset; |
||||||
|
bipol_on += offset; |
||||||
|
bipol_off += offset; |
||||||
|
parvo_on += offset; |
||||||
|
parvo_off += offset; |
||||||
|
|
||||||
|
float4 diff = *photo_out - *horiz_out; |
||||||
|
float4 isPositive;// = convert_float4(diff > (float4)(0.0f, 0.0f, 0.0f, 0.0f)); |
||||||
|
isPositive.x = diff.x > 0.0f; |
||||||
|
isPositive.y = diff.y > 0.0f; |
||||||
|
isPositive.z = diff.z > 0.0f; |
||||||
|
isPositive.w = diff.w > 0.0f; |
||||||
|
float4 res_on = isPositive * diff; |
||||||
|
float4 res_off = (isPositive - (float4)(1.0f)) * diff; |
||||||
|
|
||||||
|
*bipol_on = res_on; |
||||||
|
*parvo_on = res_on; |
||||||
|
|
||||||
|
*bipol_off = res_off; |
||||||
|
*parvo_off = res_off; |
||||||
|
} |
||||||
|
|
||||||
|
///////////////////////////////////////////////////////// |
||||||
|
//****************************************************** |
||||||
|
// retinacolor |
||||||
|
inline int bayerSampleOffset(int step, int rows, int x, int y) |
||||||
|
{ |
||||||
|
return mad24(y, step, x) + |
||||||
|
((y % 2) + (x % 2)) * rows * step; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/////// colorMultiplexing ////// |
||||||
|
kernel void runColorMultiplexingBayer( |
||||||
|
global const float * input, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row |
||||||
|
) |
||||||
|
{ |
||||||
|
int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
output[offset] = input[bayerSampleOffset(elements_per_row, rows, gidx, gidy)]; |
||||||
|
} |
||||||
|
|
||||||
|
kernel void runColorDemultiplexingBayer( |
||||||
|
global const float * input, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row |
||||||
|
) |
||||||
|
{ |
||||||
|
int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
output[bayerSampleOffset(elements_per_row, rows, gidx, gidy)] = input[offset]; |
||||||
|
} |
||||||
|
|
||||||
|
kernel void demultiplexAssign( |
||||||
|
global const float * input, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row |
||||||
|
) |
||||||
|
{ |
||||||
|
int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
int offset = bayerSampleOffset(elements_per_row, rows, gidx, gidy); |
||||||
|
output[offset] = input[offset]; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
//// normalizeGrayOutputCentredSigmoide |
||||||
|
kernel void normalizeGrayOutputCentredSigmoide( |
||||||
|
global const float * input, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float meanval, |
||||||
|
const float X0 |
||||||
|
) |
||||||
|
|
||||||
|
{ |
||||||
|
int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
|
||||||
|
float input_val = input[offset]; |
||||||
|
output[offset] = meanval + |
||||||
|
(meanval + X0) * (input_val - meanval) / (fabs(input_val - meanval) + X0); |
||||||
|
} |
||||||
|
|
||||||
|
//// normalize by photoreceptors density |
||||||
|
kernel void normalizePhotoDensity( |
||||||
|
global const float * chroma, |
||||||
|
global const float * colorDensity, |
||||||
|
global const float * multiplex, |
||||||
|
global float * luma, |
||||||
|
global float * demultiplex, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float pG |
||||||
|
) |
||||||
|
{ |
||||||
|
const int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
const int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
int index = offset; |
||||||
|
|
||||||
|
float Cr = chroma[index] * colorDensity[index]; |
||||||
|
index += elements_per_row * rows; |
||||||
|
float Cg = chroma[index] * colorDensity[index]; |
||||||
|
index += elements_per_row * rows; |
||||||
|
float Cb = chroma[index] * colorDensity[index]; |
||||||
|
|
||||||
|
const float luma_res = (Cr + Cg + Cb) * pG; |
||||||
|
luma[offset] = luma_res; |
||||||
|
demultiplex[bayerSampleOffset(elements_per_row, rows, gidx, gidy)] = |
||||||
|
multiplex[offset] - luma_res; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
//////// computeGradient /////// |
||||||
|
// TODO: |
||||||
|
// this function maybe accelerated by image2d_t or lds |
||||||
|
kernel void computeGradient( |
||||||
|
global const float * luma, |
||||||
|
global float * gradient, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row |
||||||
|
) |
||||||
|
{ |
||||||
|
int gidx = get_global_id(0) + 2, gidy = get_global_id(1) + 2; |
||||||
|
if(gidx >= cols - 2 || gidy >= rows - 2) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
luma += offset; |
||||||
|
|
||||||
|
// horizontal and vertical local gradients |
||||||
|
const float v_grad = fabs(luma[elements_per_row] - luma[- elements_per_row]); |
||||||
|
const float h_grad = fabs(luma[1] - luma[-1]); |
||||||
|
|
||||||
|
// neighborhood horizontal and vertical gradients |
||||||
|
const float cur_val = luma[0]; |
||||||
|
const float v_grad_p = fabs(cur_val - luma[- 2 * elements_per_row]); |
||||||
|
const float h_grad_p = fabs(cur_val - luma[- 2]); |
||||||
|
const float v_grad_n = fabs(cur_val - luma[2 * elements_per_row]); |
||||||
|
const float h_grad_n = fabs(cur_val - luma[2]); |
||||||
|
|
||||||
|
const float horiz_grad = 0.5f * h_grad + 0.25f * (h_grad_p + h_grad_n); |
||||||
|
const float verti_grad = 0.5f * v_grad + 0.25f * (v_grad_p + v_grad_n); |
||||||
|
const bool is_vertical_greater = horiz_grad < verti_grad; |
||||||
|
|
||||||
|
gradient[offset + elements_per_row * rows] = is_vertical_greater ? 0.06f : 0.57f; |
||||||
|
gradient[offset ] = is_vertical_greater ? 0.57f : 0.06f; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/////// substractResidual /////// |
||||||
|
kernel void substractResidual( |
||||||
|
global float * input, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float pR, |
||||||
|
const float pG, |
||||||
|
const float pB |
||||||
|
) |
||||||
|
{ |
||||||
|
const int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
int indices [3] = |
||||||
|
{ |
||||||
|
mad24(gidy, elements_per_row, gidx), |
||||||
|
mad24(gidy + rows, elements_per_row, gidx), |
||||||
|
mad24(gidy + 2 * rows, elements_per_row, gidx) |
||||||
|
}; |
||||||
|
float vals[3] = {input[indices[0]], input[indices[1]], input[indices[2]]}; |
||||||
|
float residu = pR * vals[0] + pG * vals[1] + pB * vals[2]; |
||||||
|
|
||||||
|
input[indices[0]] = vals[0] - residu; |
||||||
|
input[indices[1]] = vals[1] - residu; |
||||||
|
input[indices[2]] = vals[2] - residu; |
||||||
|
} |
||||||
|
|
||||||
|
///// clipRGBOutput_0_maxInputValue ///// |
||||||
|
kernel void clipRGBOutput_0_maxInputValue( |
||||||
|
global float * input, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float maxVal |
||||||
|
) |
||||||
|
{ |
||||||
|
const int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
const int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
float val = input[offset]; |
||||||
|
val = clamp(val, 0.0f, maxVal); |
||||||
|
input[offset] = val; |
||||||
|
} |
||||||
|
|
||||||
|
//// normalizeGrayOutputNearZeroCentreredSigmoide //// |
||||||
|
kernel void normalizeGrayOutputNearZeroCentreredSigmoide( |
||||||
|
global float * input, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float maxVal, |
||||||
|
const float X0cube |
||||||
|
) |
||||||
|
{ |
||||||
|
const int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
const int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
float currentCubeLuminance = input[offset]; |
||||||
|
currentCubeLuminance = currentCubeLuminance * currentCubeLuminance * currentCubeLuminance; |
||||||
|
output[offset] = currentCubeLuminance * X0cube / (X0cube + currentCubeLuminance); |
||||||
|
} |
||||||
|
|
||||||
|
//// centerReductImageLuminance //// |
||||||
|
kernel void centerReductImageLuminance( |
||||||
|
global float * input, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row, |
||||||
|
const float mean, |
||||||
|
const float std_dev |
||||||
|
) |
||||||
|
{ |
||||||
|
const int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
const int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
|
||||||
|
float val = input[offset]; |
||||||
|
input[offset] = (val - mean) / std_dev; |
||||||
|
} |
||||||
|
|
||||||
|
//// inverseValue //// |
||||||
|
kernel void inverseValue( |
||||||
|
global float * input, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int elements_per_row |
||||||
|
) |
||||||
|
{ |
||||||
|
const int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
const int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
input[offset] = 1.f / input[offset]; |
||||||
|
} |
||||||
|
|
||||||
|
#define CV_PI 3.1415926535897932384626433832795 |
||||||
|
|
||||||
|
//// _processRetinaParvoMagnoMapping //// |
||||||
|
kernel void processRetinaParvoMagnoMapping( |
||||||
|
global float * parvo, |
||||||
|
global float * magno, |
||||||
|
global float * output, |
||||||
|
const int cols, |
||||||
|
const int rows, |
||||||
|
const int halfCols, |
||||||
|
const int halfRows, |
||||||
|
const int elements_per_row, |
||||||
|
const float minDistance |
||||||
|
) |
||||||
|
{ |
||||||
|
const int gidx = get_global_id(0), gidy = get_global_id(1); |
||||||
|
if(gidx >= cols || gidy >= rows) |
||||||
|
{ |
||||||
|
return; |
||||||
|
} |
||||||
|
const int offset = mad24(gidy, elements_per_row, gidx); |
||||||
|
|
||||||
|
float distanceToCenter = |
||||||
|
sqrt(((float)(gidy - halfRows) * (gidy - halfRows) + (gidx - halfCols) * (gidx - halfCols))); |
||||||
|
|
||||||
|
float a = distanceToCenter < minDistance ? |
||||||
|
(0.5f + 0.5f * (float)cos(CV_PI * distanceToCenter / minDistance)) : 0; |
||||||
|
float b = 1.f - a; |
||||||
|
|
||||||
|
output[offset] = parvo[offset] * a + magno[offset] * b; |
||||||
|
} |
||||||
@ -1,44 +0,0 @@ |
|||||||
/*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*/
|
|
||||||
|
|
||||||
#include "precomp.hpp" |
|
||||||
|
|
||||||
/* End of file. */ |
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue