return (x >= 0 && x < width) ? saturate_cast<D>(data[x]) : val;
}
- const int width;
- const D val;
+ int width;
+ D val;
};
template <typename D> struct BrdColConstant
return (y >= 0 && y < height) ? saturate_cast<D>(*(const T*)((const char*)data + y * step)) : val;
}
- const int height;
- const D val;
+ int height;
+ D val;
};
template <typename D> struct BrdConstant
return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(src(y, x)) : val;
}
- const int height;
- const int width;
- const D val;
+ int height;
+ int width;
+ D val;
};
//////////////////////////////////////////////////////////////
return saturate_cast<D>(data[idx_col(x)]);
}
- const int last_col;
+ int last_col;
};
template <typename D> struct BrdColReplicate
return saturate_cast<D>(*(const T*)((const char*)data + idx_row(y) * step));
}
- const int last_row;
+ int last_row;
};
template <typename D> struct BrdReplicate
return saturate_cast<D>(src(idx_row(y), idx_col(x)));
}
- const int last_row;
- const int last_col;
+ int last_row;
+ int last_col;
};
//////////////////////////////////////////////////////////////
return saturate_cast<D>(data[idx_col(x)]);
}
- const int last_col;
+ int last_col;
};
template <typename D> struct BrdColReflect101
return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
}
- const int last_row;
+ int last_row;
};
template <typename D> struct BrdReflect101
return saturate_cast<D>(src(idx_row(y), idx_col(x)));
}
- const int last_row;
- const int last_col;
+ int last_row;
+ int last_col;
};
//////////////////////////////////////////////////////////////
return saturate_cast<D>(data[idx_col(x)]);
}
- const int last_col;
+ int last_col;
};
template <typename D> struct BrdColReflect
return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
}
- const int last_row;
+ int last_row;
};
template <typename D> struct BrdReflect
return saturate_cast<D>(src(idx_row(y), idx_col(x)));
}
- const int last_row;
- const int last_col;
+ int last_row;
+ int last_col;
};
//////////////////////////////////////////////////////////////
return saturate_cast<D>(data[idx_col(x)]);
}
- const int width;
+ int width;
};
template <typename D> struct BrdColWrap
return saturate_cast<D>(*(const D*)((const char*)data + idx_row(y) * step));
}
- const int height;
+ int height;
};
template <typename D> struct BrdWrap
return saturate_cast<D>(src(idx_row(y), idx_col(x)));
}
- const int height;
- const int width;
+ int height;
+ int width;
};
//////////////////////////////////////////////////////////////
return b.at(y, x, ptr);
}
- const Ptr2D ptr;
- const B b;
+ Ptr2D ptr;
+ B b;
};
// under win32 there is some bug with templated types that passed as kernel parameters
return (x >= 0 && x < width && y >= 0 && y < height) ? saturate_cast<D>(src(y, x)) : val;
}
- const Ptr2D src;
- const int height;
- const int width;
- const D val;
+ Ptr2D src;
+ int height;
+ int width;
+ D val;
};
}}} // namespace cv { namespace gpu { namespace cudev
return src(__float2int_rz(y), __float2int_rz(x));
}
- const Ptr2D src;
+ Ptr2D src;
};
template <typename Ptr2D> struct LinearFilter
return saturate_cast<elem_type>(out);
}
- const Ptr2D src;
+ Ptr2D src;
};
template <typename Ptr2D> struct CubicFilter
return saturate_cast<elem_type>(res);
}
- const Ptr2D src;
+ Ptr2D src;
};
// for integer scaling
template <typename Ptr2D> struct IntegerAreaFilter
return saturate_cast<elem_type>(out);
}
- const Ptr2D src;
+ Ptr2D src;
float scale_x, scale_y ,scale;
};
return saturate_cast<elem_type>(out);
}
- const Ptr2D src;
+ Ptr2D src;
float scale_x, scale_y;
int width, haight;
};
__device__ __forceinline__ thresh_binary_func():unary_function<T, T>(){}
- const T thresh;
- const T maxVal;
+ T thresh;
+ T maxVal;
};
template <typename T> struct thresh_binary_inv_func : unary_function<T, T>
__device__ __forceinline__ thresh_binary_inv_func():unary_function<T, T>(){}
- const T thresh;
- const T maxVal;
+ T thresh;
+ T maxVal;
};
template <typename T> struct thresh_trunc_func : unary_function<T, T>
__device__ __forceinline__ thresh_trunc_func():unary_function<T, T>(){}
- const T thresh;
+ T thresh;
};
template <typename T> struct thresh_to_zero_func : unary_function<T, T>
__device__ __forceinline__ thresh_to_zero_func():unary_function<T, T>(){}
- const T thresh;
+ T thresh;
};
template <typename T> struct thresh_to_zero_inv_func : unary_function<T, T>
__device__ __forceinline__ thresh_to_zero_inv_func():unary_function<T, T>(){}
- const T thresh;
+ T thresh;
};
//bound!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ============>
// Function Object Adaptors
__device__ __forceinline__ unary_negate(const unary_negate& other) : unary_function<typename Predicate::argument_type, bool>(){}
__device__ __forceinline__ unary_negate() : unary_function<typename Predicate::argument_type, bool>(){}
- const Predicate pred;
+ Predicate pred;
};
template <typename Predicate> __host__ __device__ __forceinline__ unary_negate<Predicate> not1(const Predicate& pred)
__device__ __forceinline__ binary_negate() :
binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>(){}
- const Predicate pred;
+ Predicate pred;
};
template <typename BinaryPredicate> __host__ __device__ __forceinline__ binary_negate<BinaryPredicate> not2(const BinaryPredicate& pred)
__device__ __forceinline__ binder1st(const binder1st& other) :
unary_function<typename Op::second_argument_type, typename Op::result_type>(){}
- const Op op;
- const typename Op::first_argument_type arg1;
+ Op op;
+ typename Op::first_argument_type arg1;
};
template <typename Op, typename T> __host__ __device__ __forceinline__ binder1st<Op> bind1st(const Op& op, const T& x)
__device__ __forceinline__ binder2nd(const binder2nd& other) :
unary_function<typename Op::first_argument_type, typename Op::result_type>(), op(other.op), arg2(other.arg2){}
- const Op op;
- const typename Op::second_argument_type arg2;
+ Op op;
+ typename Op::second_argument_type arg2;
};
template <typename Op, typename T> __host__ __device__ __forceinline__ binder2nd<Op> bind2nd(const Op& op, const T& x)
template <class Op, typename T>
struct CmpScalar<Op, T, 1> : unary_function<T, uchar>
{
- const T val;
+ T val;
__host__ explicit CmpScalar(T val_) : val(val_) {}
template <class Op, typename T>
struct CmpScalar<Op, T, 2> : unary_function<TYPE_VEC(T, 2), TYPE_VEC(uchar, 2)>
{
- const TYPE_VEC(T, 2) val;
+ TYPE_VEC(T, 2) val;
__host__ explicit CmpScalar(TYPE_VEC(T, 2) val_) : val(val_) {}
template <class Op, typename T>
struct CmpScalar<Op, T, 3> : unary_function<TYPE_VEC(T, 3), TYPE_VEC(uchar, 3)>
{
- const TYPE_VEC(T, 3) val;
+ TYPE_VEC(T, 3) val;
__host__ explicit CmpScalar(TYPE_VEC(T, 3) val_) : val(val_) {}
template <class Op, typename T>
struct CmpScalar<Op, T, 4> : unary_function<TYPE_VEC(T, 4), TYPE_VEC(uchar, 4)>
{
- const TYPE_VEC(T, 4) val;
+ TYPE_VEC(T, 4) val;
__host__ explicit CmpScalar(TYPE_VEC(T, 4) val_) : val(val_) {}
};
template<> struct PowOp<float> : unary_function<float, float>
{
- const float power;
+ float power;
PowOp(double power_) : power(static_cast<float>(power_)) {}
texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_src(false, cudaFilterModePoint, cudaAddressModeClamp);
struct SrcTex
{
- const int xoff;
- const int yoff;
+ int xoff;
+ int yoff;
__host__ SrcTex(int _xoff, int _yoff) : xoff(_xoff), yoff(_yoff) {}
__device__ __forceinline__ int operator ()(int y, int x) const