VL_EXPORT COMPARISONFUNCTION3_TYPE
VL_XCAT(vl_get_vector_3_comparison_function_, SFX)(VlVectorComparisonType type)
{
COMPARISONFUNCTION3_TYPE function = 0 ;
switch (type) {
case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_, SFX) ; break ;
default: abort() ;
}
#ifndef VL_DISABLE_SSE2
/* if a SSE2 implementation is available, use it */
if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
switch (type) {
case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX) ; break ;
default: break ;
}
}
#endif
#ifndef VL_DISABLE_AVX
/* if an AVX implementation is available, use it */
if (vl_cpu_has_avx() && vl_get_simd_enabled()) {
switch (type) {
case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_avx_, SFX) ; break ;
default: break ;
}
}
#endif
return function ;
}
VL_EXPORT COMPARISONFUNCTION_TYPE
VL_XCAT(vl_get_vector_comparison_function_, SFX)(VlVectorComparisonType type)
{
COMPARISONFUNCTION_TYPE function = 0 ;
switch (type) {
case VlDistanceL2 : function = VL_XCAT(_vl_distance_l2_, SFX) ; break ;
case VlDistanceL1 : function = VL_XCAT(_vl_distance_l1_, SFX) ; break ;
case VlDistanceChi2 : function = VL_XCAT(_vl_distance_chi2_, SFX) ; break ;
case VlDistanceHellinger : function = VL_XCAT(_vl_distance_hellinger_, SFX) ; break ;
case VlDistanceJS : function = VL_XCAT(_vl_distance_js_, SFX) ; break ;
case VlKernelL2 : function = VL_XCAT(_vl_kernel_l2_, SFX) ; break ;
case VlKernelL1 : function = VL_XCAT(_vl_kernel_l1_, SFX) ; break ;
case VlKernelChi2 : function = VL_XCAT(_vl_kernel_chi2_, SFX) ; break ;
case VlKernelHellinger : function = VL_XCAT(_vl_kernel_hellinger_, SFX) ; break ;
case VlKernelJS : function = VL_XCAT(_vl_kernel_js_, SFX) ; break ;
default: abort() ;
}
#ifndef VL_DISABLE_SSE2
/* if a SSE2 implementation is available, use it */
if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
switch (type) {
case VlDistanceL2 : function = VL_XCAT(_vl_distance_l2_sse2_, SFX) ; break ;
case VlDistanceL1 : function = VL_XCAT(_vl_distance_l1_sse2_, SFX) ; break ;
case VlDistanceChi2 : function = VL_XCAT(_vl_distance_chi2_sse2_, SFX) ; break ;
case VlKernelL2 : function = VL_XCAT(_vl_kernel_l2_sse2_, SFX) ; break ;
case VlKernelL1 : function = VL_XCAT(_vl_kernel_l1_sse2_, SFX) ; break ;
case VlKernelChi2 : function = VL_XCAT(_vl_kernel_chi2_sse2_, SFX) ; break ;
default: break ;
}
}
#endif
return function ;
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum {IN_ENABLED = 0} ;
enum {OUT_ENABLED = 0} ;
vl_bool wasEnabled = vl_get_simd_enabled() ;
if (nout > 1) {
vlmxError(vlmxErrInvalidArgument,
"at most one output argument") ;
}
OUT(ENABLED) = vlmxCreatePlainScalar (wasEnabled) ;
if (nin == 0) {
return ;
}
if (nin > 1) {
vlmxError(vlmxErrInvalidArgument,
"At most one argument") ;
}
if (!vlmxIsScalar(IN(ENABLED))) {
vlmxError(vlmxErrInvalidArgument,
"ENABLED must be a scalar") ;
}
vl_set_simd_enabled ((vl_bool) mxGetScalar(IN(ENABLED))) ;
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
int verbose = 0 ;
char buffer [1024] ;
int unsigned const bufferSize = sizeof(buffer)/sizeof(buffer[0]) ;
int opt ;
int next = 0 ;
mxArray const *optarg ;
VL_USE_MATLAB_ENV ;
if (nout > 1) {
vlmxError(vlmxErrTooManyOutputArguments, NULL) ;
}
while ((opt = vlmxNextOption (in, nin, options, &next, &optarg)) >= 0) {
switch (opt) {
case opt_verbose :
++ verbose ;
break ;
default:
abort() ;
}
}
if (verbose) {
int offset = 0 ;
char * string = vl_configuration_to_string_copy() ;
offset = vl_string_copy(buffer, bufferSize, string) ;
snprintf(buffer + offset, bufferSize - offset,
" SIMD enabled: %s\n", VL_YESNO(vl_get_simd_enabled())) ;
if(string) vl_free(string) ;
} else {
snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]),
"%s", VL_VERSION_STRING) ;
}
if (nout == 0) {
mexPrintf("%s\n", buffer) ;
} else {
out[0] = mxCreateString(buffer) ;
}
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum {IN_I = 0, IN_S, IN_END} ;
enum {OUT_J = 0} ;
int opt ;
int next = IN_END ;
mxArray const *optarg ;
int padding = VL_PAD_BY_CONTINUITY ;
int kernel = GAUSSIAN ;
int flags ;
vl_size step = 1 ;
int verb = 0 ;
double sigma ;
mxClassID classid ;
mwSize M, N, K, M_, N_, ndims ;
mwSize dims_ [3] ;
mwSize const * dims ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (nin < 2) {
mexErrMsgTxt("At least two input arguments required.");
} else if (nout > 1) {
mexErrMsgTxt("Too many output arguments.");
}
while ((opt = vlmxNextOption (in, nin, options, &next, &optarg)) >= 0) {
switch (opt) {
case opt_padding :
{
enum {buflen = 32} ;
char buf [buflen] ;
if (!vlmxIsString(optarg, -1)) {
vlmxError(vlmxErrInvalidArgument,
"PADDING argument must be a string.") ;
}
mxGetString(optarg, buf, buflen) ;
buf [buflen - 1] = 0 ;
if (vlmxCompareStringsI("zero", buf) == 0) {
padding = VL_PAD_BY_ZERO ;
} else if (vlmxCompareStringsI("continuity", buf) == 0) {
padding = VL_PAD_BY_CONTINUITY ;
} else {
vlmxError(vlmxErrInvalidArgument,
"PADDING must be either ZERO or CONTINUITY, was '%s'.",
buf) ;
}
break ;
}
case opt_subsample :
if (!vlmxIsPlainScalar(optarg)) {
vlmxError(vlmxErrInvalidArgument,
"SUBSAMPLE must be a scalar.") ;
}
step = *mxGetPr(optarg) ;
if (step < 1) {
vlmxError(vlmxErrInvalidArgument,
"SUBSAMPLE must be not less than one.") ;
}
break ;
case opt_kernel :
{
enum {buflen = 32} ;
char buf [buflen] ;
if (!vlmxIsString(optarg, -1)) {
vlmxError(vlmxErrInvalidArgument,
"KERNEL argument must be a string.") ;
}
mxGetString(optarg, buf, buflen) ;
buf [buflen - 1] = 0 ;
if (vlmxCompareStringsI("gaussian", buf) == 0) {
kernel = GAUSSIAN ;
} else if (vlmxCompareStringsI("triangular", buf) == 0) {
kernel = TRIANGULAR ;
} else {
vlmxError(vlmxErrInvalidArgument,
"Unknown kernel type '%s'.",
buf) ;
}
break ;
}
case opt_verbose :
++ verb ;
break ;
default:
abort() ;
}
}
if (! vlmxIsPlainScalar(IN(S))) {
vlmxError(vlmxErrInvalidArgument,
"S must be a real scalar.") ;
}
classid = mxGetClassID(IN(I)) ;
if (classid != mxDOUBLE_CLASS &&
classid != mxSINGLE_CLASS) {
vlmxError(vlmxErrInvalidArgument,
"I must be either DOUBLE or SINGLE.") ;
}
if (mxGetNumberOfDimensions(IN(I)) > 3) {
vlmxError(vlmxErrInvalidArgument,
"I must be either a two or three dimensional array.") ;
}
ndims = mxGetNumberOfDimensions(IN(I)) ;
dims = mxGetDimensions(IN(I)) ;
M = dims[0] ;
N = dims[1] ;
K = (ndims > 2) ? dims[2] : 1 ;
sigma = * mxGetPr(IN(S)) ;
if ((sigma < 0.01) && (step == 1)) {
OUT(J) = mxDuplicateArray(IN(I)) ;
return ;
}
M_ = (M - 1) / step + 1 ;
N_ = (N - 1) / step + 1 ;
dims_ [0] = M_ ;
dims_ [1] = N_ ;
if (ndims > 2) dims_ [2] = K ;
OUT(J) = mxCreateNumericArray(ndims, dims_, classid, mxREAL) ;
if (verb) {
char const *classid_str = 0, *kernel_str = 0, *padding_str = 0 ;
switch (padding) {
case VL_PAD_BY_ZERO : padding_str = "with zeroes" ; break ;
case VL_PAD_BY_CONTINUITY : padding_str = "by continuity" ; break ;
default: abort() ;
}
switch (classid) {
case mxDOUBLE_CLASS: classid_str = "DOUBLE" ; break ;
case mxSINGLE_CLASS: classid_str = "SINGLE" ; break ;
default: abort() ;
}
switch (kernel) {
case GAUSSIAN: kernel_str = "Gaussian" ; break ;
case TRIANGULAR: kernel_str = "triangular" ; break ;
default: abort() ;
}
mexPrintf("vl_imsmooth: [%dx%dx%d] -> [%dx%dx%d] (%s, subsampling step %d)\n",
N, M, K, N_, M_, K, classid_str, step) ;
mexPrintf("vl_imsmooth: padding: %s\n", padding_str) ;
mexPrintf("vl_imsmooth: kernel: %s\n", kernel_str) ;
mexPrintf("vl_imsmooth: sigma: %g\n", sigma) ;
mexPrintf("vl_imsmooth: SIMD enabled: %s\n",
vl_get_simd_enabled() ? "yes" : "no") ;
}
/* -----------------------------------------------------------------
* Do the job
* -------------------------------------------------------------- */
flags = padding ;
flags |= VL_TRANSPOSE ;
switch (classid) {
case mxSINGLE_CLASS:
_vl_imsmooth_smooth_f ((float*) mxGetPr(OUT(J)),
M_, N_,
(float const*) mxGetPr(IN(I)),
M, N, K,
kernel, sigma, step, flags) ;
break ;
case mxDOUBLE_CLASS:
_vl_imsmooth_smooth_d ((double*) mxGetPr(OUT(J)),
M_, N_,
(double const*) mxGetPr(IN(I)),
M, N, K,
kernel, sigma, step, flags) ;
break ;
default:
abort() ;
}
}
VL_EXPORT void
VL_XCAT(vl_imconvcol_v, SFX)
(T* dst, vl_size dst_stride,
T const* src,
vl_size src_width, vl_size src_height, vl_size src_stride,
T const* filt, vl_index filt_begin, vl_index filt_end,
int step, unsigned int flags)
{
vl_index x = 0 ;
vl_index y ;
vl_index dheight = (src_height - 1) / step + 1 ;
vl_bool transp = flags & VL_TRANSPOSE ;
vl_bool zeropad = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
/* dispatch to accelerated version */
#ifndef VL_DISABLE_SSE2
if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
VL_XCAT3(_vl_imconvcol_v,SFX,_sse2)
(dst,dst_stride,
src,src_width,src_height,src_stride,
filt,filt_begin,filt_end,
step,flags) ;
return ;
}
#endif
/* let filt point to the last sample of the filter */
filt += filt_end - filt_begin ;
while (x < (signed)src_width) {
/* Calculate dest[x,y] = sum_p image[x,p] filt[y - p]
* where supp(filt) = [filt_begin, filt_end] = [fb,fe].
*
* CHUNK_A: y - fe <= p < 0
* completes VL_MAX(fe - y, 0) samples
* CHUNK_B: VL_MAX(y - fe, 0) <= p < VL_MIN(y - fb, height - 1)
* completes fe - VL_MAX(fb, height - y) + 1 samples
* CHUNK_C: completes all samples
*/
T const *filti ;
vl_index stop ;
for (y = 0 ; y < (signed)src_height ; y += step) {
T acc = 0 ;
T v = 0, c ;
T const* srci ;
filti = filt ;
stop = filt_end - y ;
srci = src + x - stop * src_stride ;
if (stop > 0) {
if (zeropad) {
v = 0 ;
} else {
v = *(src + x) ;
}
while (filti > filt - stop) {
c = *filti-- ;
acc += v * c ;
srci += src_stride ;
}
}
stop = filt_end - VL_MAX(filt_begin, y - (signed)src_height + 1) + 1 ;
while (filti > filt - stop) {
v = *srci ;
c = *filti-- ;
acc += v * c ;
srci += src_stride ;
}
if (zeropad) v = 0 ;
stop = filt_end - filt_begin + 1 ;
while (filti > filt - stop) {
c = *filti-- ;
acc += v * c ;
}
if (transp) {
*dst = acc ; dst += 1 ;
} else {
*dst = acc ; dst += dst_stride ;
}
} /* next y */
if (transp) {
dst += 1 * dst_stride - dheight * 1 ;
} else {
dst += 1 * 1 - dheight * dst_stride ;
}
x += 1 ;
} /* next x */
}
void vl_print_host_info ()
{
char const *arch = 0, *endian = 0, *comp = 0, *dm = 0 ;
int compver ;
#ifdef VL_ARCH_IA6
arch = "IA64" ;
#endif
#ifdef VL_ARCH_IX86
arch = "IX86" ;
#endif
#ifdef VL_ARCH_PPC
arch = "PPC" ;
#endif
#ifdef VL_ARCH_BIN_ENDIAN
endian = "big endian" ;
#endif
#ifdef VL_ARCH_LITTLE_ENDIAN
endian = "little endian" ;
#endif
#ifdef VL_COMPILER_MSC
comp = "Microsoft Visual C++" ;
compver = VL_COMPILER_MSC ;
#endif
#ifdef VL_COMPILER_GNUC
comp = "GNU C" ;
compver = VL_COMPILER_GNUC ;
#endif
#ifdef VL_COMPILER_LP64
dm = "LP64" ;
#endif
#ifdef VL_COMPILER_LLP64
dm = "LP64" ;
#endif
#ifdef VL_COMPILER_ILP32
dm = "ILP32" ;
#endif
#define YESNO(x) ((x)?"yes":"no")
VL_PRINTF("Host: Compiler: %s %d\n", comp, compver) ;
VL_PRINTF(" Compiler data model: %s\n", dm) ;
VL_PRINTF(" CPU architecture: %s\n", arch) ;
VL_PRINTF(" CPU endianness: %s\n", endian) ;
#ifdef HAS_CPUID
{
struct x86cpu_ const* c = _vl_x86cpu_get() ;
VL_PRINTF(" CPU vendor string: %s\n", c->vendor_string) ;
VL_PRINTF(" CPU has MMX: %s\n", YESNO(c->has_mmx)) ;
VL_PRINTF(" CPU has SSE: %s\n", YESNO(c->has_sse)) ;
VL_PRINTF(" CPU has SSE2: %s\n", YESNO(c->has_sse2)) ;
VL_PRINTF(" CPU has SSE3: %s\n", YESNO(c->has_sse3)) ;
VL_PRINTF(" CPU has SSE4.1: %s\n", YESNO(c->has_sse41)) ;
VL_PRINTF(" CPU has SSE4.2: %s\n", YESNO(c->has_sse42)) ;
VL_PRINTF("VLFeat uses SIMD: %s\n", YESNO(vl_get_simd_enabled())) ;
}
#endif
}
