{

#ifdef __cplusplus_winrt

return std::wstring(Windows::Storage::ApplicationData::Current->TemporaryFolder->Path->Data());

#else

Microsoft::WRL::ComPtr<ABI::Windows::Storage::IApplicationDataStatics> appdataFactory;

Microsoft::WRL::ComPtr<ABI::Windows::Storage::IApplicationData> appdataRef;

Microsoft::WRL::ComPtr<ABI::Windows::Storage::IStorageFolder> storagefolderRef;

Microsoft::WRL::ComPtr<ABI::Windows::Storage::IStorageItem> storageitemRef;

HSTRING str;

HSTRING_HEADER hstrHead;

std::wstring wstr;

if (FAILED(WindowsCreateStringReference(RuntimeClass_Windows_Storage_ApplicationData,

(UINT32)wcslen(RuntimeClass_Windows_Storage_ApplicationData), &hstrHead, &str)))

return wstr;

if (FAILED(RoGetActivationFactory(str, IID_PPV_ARGS(appdataFactory.ReleaseAndGetAddressOf()))))

return wstr;

if (FAILED(appdataFactory->get_Current(appdataRef.ReleaseAndGetAddressOf())))

return wstr;

if (FAILED(appdataRef->get_TemporaryFolder(storagefolderRef.ReleaseAndGetAddressOf())))

return wstr;

if (FAILED(storagefolderRef.As(&storageitemRef)))

return wstr;

str = NULL;

if (FAILED(storageitemRef->get_Path(&str)))

return wstr;

wstr = WindowsGetStringRawBuffer(str, NULL);

WindowsDeleteString(str);

return wstr;

#endif

{

wchar_t guidStr[40];

GUID g;

CoCreateGuid(&g);

wchar_t* mask = L"%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x";

swprintf(&guidStr[0], sizeof(guidStr)/sizeof(wchar_t), mask,

g.Data1, g.Data2, g.Data3, UINT(g.Data4[0]), UINT(g.Data4[1]),

UINT(g.Data4[2]), UINT(g.Data4[3]), UINT(g.Data4[4]),

UINT(g.Data4[5]), UINT(g.Data4[6]), UINT(g.Data4[7]));

return prefix.append(std::wstring(guidStr));

: code(_code), err(_err), func(_func), file(_file), line(_line)

{

formatMessage();

{

if( func.size() > 0 )

msg = format("%s:%d: error: (%d) %s in function %s\n", file.c_str(), line, code, err.c_str(), func.c_str());

else

msg = format("%s:%d: error: (%d) %s\n", file.c_str(), line, code, err.c_str());

{

enum { MAX_FEATURE = CV_HARDWARE_MAX_FEATURE };

HWFeatures(bool run_initialize = false)

{

memset( have, 0, sizeof(have[0]) * MAX_FEATURE );

if (run_initialize)

initialize();

}

static void initializeNames()

{

for (int i = 0; i < CV_HARDWARE_MAX_FEATURE; i++)

{

g_hwFeatureNames[i] = 0;

}

g_hwFeatureNames[CPU_MMX] = "MMX";

g_hwFeatureNames[CPU_SSE] = "SSE";

g_hwFeatureNames[CPU_SSE2] = "SSE2";

g_hwFeatureNames[CPU_SSE3] = "SSE3";

g_hwFeatureNames[CPU_SSSE3] = "SSSE3";

g_hwFeatureNames[CPU_SSE4_1] = "SSE4.1";

g_hwFeatureNames[CPU_SSE4_2] = "SSE4.2";

g_hwFeatureNames[CPU_POPCNT] = "POPCNT";

g_hwFeatureNames[CPU_FP16] = "FP16";

g_hwFeatureNames[CPU_AVX] = "AVX";

g_hwFeatureNames[CPU_AVX2] = "AVX2";

g_hwFeatureNames[CPU_FMA3] = "FMA3";

g_hwFeatureNames[CPU_AVX_512F] = "AVX512F";

g_hwFeatureNames[CPU_AVX_512BW] = "AVX512BW";

g_hwFeatureNames[CPU_AVX_512CD] = "AVX512CD";

g_hwFeatureNames[CPU_AVX_512DQ] = "AVX512DQ";

g_hwFeatureNames[CPU_AVX_512ER] = "AVX512ER";

g_hwFeatureNames[CPU_AVX_512IFMA] = "AVX512IFMA";

g_hwFeatureNames[CPU_AVX_512PF] = "AVX512PF";

g_hwFeatureNames[CPU_AVX_512VBMI] = "AVX512VBMI";

g_hwFeatureNames[CPU_AVX_512VL] = "AVX512VL";

g_hwFeatureNames[CPU_NEON] = "NEON";

g_hwFeatureNames[CPU_VSX] = "VSX";

g_hwFeatureNames[CPU_AVX512_SKX] = "AVX512-SKX";

}

void initialize(void)

{

#ifndef WINRT

if (getenv("OPENCV_DUMP_CONFIG"))

{

fprintf(stderr, "\nOpenCV build configuration is:\n%s\n",

cv::getBuildInformation().c_str());

}

#endif

initializeNames();

int cpuid_data[4] = { 0, 0, 0, 0 };

int cpuid_data_ex[4] = { 0, 0, 0, 0 };

#if defined _MSC_VER && (defined _M_IX86 || defined _M_X64)

#define OPENCV_HAVE_X86_CPUID 1

__cpuid(cpuid_data, 1);

#elif defined __GNUC__ && (defined __i386__ || defined __x86_64__)

#define OPENCV_HAVE_X86_CPUID 1

#ifdef __x86_64__

asm __volatile__

(

"movl $1, %%eax\n\t"

"cpuid\n\t"

:[eax]"=a"(cpuid_data[0]),[ebx]"=b"(cpuid_data[1]),[ecx]"=c"(cpuid_data[2]),[edx]"=d"(cpuid_data[3])

:

: "cc"

);

#else

asm volatile

(

"pushl %%ebx\n\t"

"movl $1,%%eax\n\t"

"cpuid\n\t"

"popl %%ebx\n\t"

: "=a"(cpuid_data[0]), "=c"(cpuid_data[2]), "=d"(cpuid_data[3])

:

: "cc"

);

#endif

#endif

#ifdef OPENCV_HAVE_X86_CPUID

int x86_family = (cpuid_data[0] >> 8) & 15;

if( x86_family >= 6 )

{

have[CV_CPU_MMX] = (cpuid_data[3] & (1<<23)) != 0;

have[CV_CPU_SSE] = (cpuid_data[3] & (1<<25)) != 0;

have[CV_CPU_SSE2] = (cpuid_data[3] & (1<<26)) != 0;

have[CV_CPU_SSE3] = (cpuid_data[2] & (1<<0)) != 0;

have[CV_CPU_SSSE3] = (cpuid_data[2] & (1<<9)) != 0;

have[CV_CPU_FMA3] = (cpuid_data[2] & (1<<12)) != 0;

have[CV_CPU_SSE4_1] = (cpuid_data[2] & (1<<19)) != 0;

have[CV_CPU_SSE4_2] = (cpuid_data[2] & (1<<20)) != 0;

have[CV_CPU_POPCNT] = (cpuid_data[2] & (1<<23)) != 0;

have[CV_CPU_AVX] = (cpuid_data[2] & (1<<28)) != 0;

have[CV_CPU_FP16] = (cpuid_data[2] & (1<<29)) != 0;

// make the second call to the cpuid command in order to get

// information about extended features like AVX2

#if defined _MSC_VER && (defined _M_IX86 || defined _M_X64)

#define OPENCV_HAVE_X86_CPUID_EX 1

__cpuidex(cpuid_data_ex, 7, 0);

#elif defined __GNUC__ && (defined __i386__ || defined __x86_64__)

#define OPENCV_HAVE_X86_CPUID_EX 1

#ifdef __x86_64__

asm __volatile__

(

"movl $7, %%eax\n\t"

"movl $0, %%ecx\n\t"

"cpuid\n\t"

:[eax]"=a"(cpuid_data_ex[0]),[ebx]"=b"(cpuid_data_ex[1]),[ecx]"=c"(cpuid_data_ex[2]),[edx]"=d"(cpuid_data_ex[3])

:

: "cc"

);

#else

asm volatile

(

"pushl %%ebx\n\t"

"movl $7,%%eax\n\t"

"movl $0,%%ecx\n\t"

"cpuid\n\t"

"movl %%ebx, %0\n\t"

"popl %%ebx\n\t"

: "=r"(cpuid_data_ex[1]), "=c"(cpuid_data_ex[2])

:

: "cc"

);

#endif

#endif

#ifdef OPENCV_HAVE_X86_CPUID_EX

have[CV_CPU_AVX2] = (cpuid_data_ex[1] & (1<<5)) != 0;

have[CV_CPU_AVX_512F] = (cpuid_data_ex[1] & (1<<16)) != 0;

have[CV_CPU_AVX_512DQ] = (cpuid_data_ex[1] & (1<<17)) != 0;

have[CV_CPU_AVX_512IFMA512] = (cpuid_data_ex[1] & (1<<21)) != 0;

have[CV_CPU_AVX_512PF] = (cpuid_data_ex[1] & (1<<26)) != 0;

have[CV_CPU_AVX_512ER] = (cpuid_data_ex[1] & (1<<27)) != 0;

have[CV_CPU_AVX_512CD] = (cpuid_data_ex[1] & (1<<28)) != 0;

have[CV_CPU_AVX_512BW] = (cpuid_data_ex[1] & (1<<30)) != 0;

have[CV_CPU_AVX_512VL] = (cpuid_data_ex[1] & (1<<31)) != 0;

have[CV_CPU_AVX_512VBMI] = (cpuid_data_ex[2] & (1<<1)) != 0;

#else

CV_UNUSED(cpuid_data_ex);

#endif

bool have_AVX_OS_support = true;

bool have_AVX512_OS_support = true;

if (!(cpuid_data[2] & (1<<27)))

have_AVX_OS_support = false; // OS uses XSAVE_XRSTORE and CPU support AVX

else

{

int xcr0 = 0;

#ifdef _XCR_XFEATURE_ENABLED_MASK // requires immintrin.h

xcr0 = (int)_xgetbv(_XCR_XFEATURE_ENABLED_MASK);

#elif defined __GNUC__ && (defined __i386__ || defined __x86_64__)

__asm__ ("xgetbv" : "=a" (xcr0) : "c" (0) : "%edx" );

#endif

if ((xcr0 & 0x6) != 0x6)

have_AVX_OS_support = false; // YMM registers

if ((xcr0 & 0xe6) != 0xe6)

have_AVX512_OS_support = false; // ZMM registers

}

if (!have_AVX_OS_support)

{

have[CV_CPU_AVX] = false;

have[CV_CPU_FP16] = false;

have[CV_CPU_AVX2] = false;

have[CV_CPU_FMA3] = false;

}

if (!have_AVX_OS_support || !have_AVX512_OS_support)

{

have[CV_CPU_AVX_512F] = false;

have[CV_CPU_AVX_512BW] = false;

have[CV_CPU_AVX_512CD] = false;

have[CV_CPU_AVX_512DQ] = false;

have[CV_CPU_AVX_512ER] = false;

have[CV_CPU_AVX_512IFMA512] = false;

have[CV_CPU_AVX_512PF] = false;

have[CV_CPU_AVX_512VBMI] = false;

have[CV_CPU_AVX_512VL] = false;

}

if (have[CV_CPU_AVX_512F])

{

have[CV_CPU_AVX512_SKX] = have[CV_CPU_AVX_512F] & have[CV_CPU_AVX_512CD] & have[CV_CPU_AVX_512BW] & have[CV_CPU_AVX_512DQ] & have[CV_CPU_AVX_512VL];

}

}

#else

CV_UNUSED(cpuid_data);

CV_UNUSED(cpuid_data_ex);

#endif // OPENCV_HAVE_X86_CPUID

#if defined __ANDROID__ || defined __linux__

#ifdef __aarch64__

have[CV_CPU_NEON] = true;

have[CV_CPU_FP16] = true;

#elif defined __arm__ && defined __ANDROID__

#if defined HAVE_CPUFEATURES

__android_log_print(ANDROID_LOG_INFO, "OpenCV", "calling android_getCpuFeatures() ...");

uint64_t features = android_getCpuFeatures();

__android_log_print(ANDROID_LOG_INFO, "OpenCV", "calling android_getCpuFeatures() ... Done (%llx)", features);

have[CV_CPU_NEON] = (features & ANDROID_CPU_ARM_FEATURE_NEON) != 0;

have[CV_CPU_FP16] = (features & ANDROID_CPU_ARM_FEATURE_VFP_FP16) != 0;

#else

__android_log_print(ANDROID_LOG_INFO, "OpenCV", "cpufeatures library is not avaialble for CPU detection");

#if CV_NEON

__android_log_print(ANDROID_LOG_INFO, "OpenCV", "- NEON instructions is enabled via build flags");

have[CV_CPU_NEON] = true;

#else

__android_log_print(ANDROID_LOG_INFO, "OpenCV", "- NEON instructions is NOT enabled via build flags");

#endif

#if CV_FP16

__android_log_print(ANDROID_LOG_INFO, "OpenCV", "- FP16 instructions is enabled via build flags");

have[CV_CPU_FP16] = true;

#else

__android_log_print(ANDROID_LOG_INFO, "OpenCV", "- FP16 instructions is NOT enabled via build flags");

#endif

#endif

#elif defined __arm__

int cpufile = open("/proc/self/auxv", O_RDONLY);

if (cpufile >= 0)

{

Elf32_auxv_t auxv;

const size_t size_auxv_t = sizeof(auxv);

while ((size_t)read(cpufile, &auxv, size_auxv_t) == size_auxv_t)

{

if (auxv.a_type == AT_HWCAP)

{

have[CV_CPU_NEON] = (auxv.a_un.a_val & 4096) != 0;

have[CV_CPU_FP16] = (auxv.a_un.a_val & 2) != 0;

break;

}

}

close(cpufile);

}

#endif

#elif (defined __clang__ || defined __APPLE__)

#if (defined __ARM_NEON__ || (defined __ARM_NEON && defined __aarch64__))

have[CV_CPU_NEON] = true;

#endif

#if (defined __ARM_FP && (((__ARM_FP & 0x2) != 0) && defined __ARM_NEON__))

have[CV_CPU_FP16] = true;

#endif

#endif

#ifdef __VSX__

have[CV_CPU_VSX] = true;

#elif (defined __PPC64__ && defined __linux__)

uint64 hwcaps = getauxval(AT_HWCAP);

uint64 hwcap2 = getauxval(AT_HWCAP2);

have[CV_CPU_VSX] = (hwcaps & PPC_FEATURE_PPC_LE && hwcaps & PPC_FEATURE_HAS_VSX && hwcap2 & PPC_FEATURE2_ARCH_2_07);

#else

have[CV_CPU_VSX] = false;

#endif

int baseline_features[] = { CV_CPU_BASELINE_FEATURES };

if (!checkFeatures(baseline_features, sizeof(baseline_features) / sizeof(baseline_features[0])))

{

fprintf(stderr, "\n"

"******************************************************************\n"

"* FATAL ERROR: *\n"

"* This OpenCV build doesn't support current CPU/HW configuration *\n"

"* *\n"

"* Use OPENCV_DUMP_CONFIG=1 environment variable for details *\n"

"******************************************************************\n");

fprintf(stderr, "\nRequired baseline features:\n");

checkFeatures(baseline_features, sizeof(baseline_features) / sizeof(baseline_features[0]), true);

CV_ErrorNoReturn(cv::Error::StsAssert, "Missing support for required CPU baseline features. Check OpenCV build configuration and required CPU/HW setup.");

}

readSettings(baseline_features, sizeof(baseline_features) / sizeof(baseline_features[0]));

}

bool checkFeatures(const int* features, int count, bool dump = false)

{

bool result = true;

for (int i = 0; i < count; i++)

{

int feature = features[i];

if (feature)

{

if (have[feature])

{

if (dump) fprintf(stderr, "%s - OK\n", getHWFeatureNameSafe(feature));

}

else

{

result = false;

if (dump) fprintf(stderr, "%s - NOT AVAILABLE\n", getHWFeatureNameSafe(feature));

}

}

}

return result;

}

static inline bool isSymbolSeparator(char c)

{

return c == ',' || c == ';' || c == '-';

}

void readSettings(const int* baseline_features, int baseline_count)

{

bool dump = true;

const char* disabled_features =

#ifndef WINRT

getenv("OPENCV_CPU_DISABLE");

#else

NULL;

#endif

if (disabled_features && disabled_features[0] != 0)

{

const char* start = disabled_features;

for (;;)

{

while (start[0] != 0 && isSymbolSeparator(start[0]))

{

start++;

}

if (start[0] == 0)

break;

const char* end = start;

while (end[0] != 0 && !isSymbolSeparator(end[0]))

{

end++;

}

if (end == start)

continue;

cv::String feature(start, end);

start = end;

CV_Assert(feature.size() > 0);

bool found = false;

for (int i = 0; i < CV_HARDWARE_MAX_FEATURE; i++)

{

if (!g_hwFeatureNames[i]) continue;

size_t len = strlen(g_hwFeatureNames[i]);

if (len != feature.size()) continue;

if (feature.compare(g_hwFeatureNames[i]) == 0)

{

bool isBaseline = false;

for (int k = 0; k < baseline_count; k++)

{

if (baseline_features[k] == i)

{

isBaseline = true;

break;

}

}

if (isBaseline)

{

if (dump) fprintf(stderr, "OPENCV: Trying to disable baseline CPU feature: '%s'. This has very limited effect, because code optimizations for this feature are executed unconditionally in the most cases.\n", getHWFeatureNameSafe(i));

}

if (!have[i])

{

if (dump) fprintf(stderr, "OPENCV: Trying to disable unavailable CPU feature on the current platform: '%s'.\n", getHWFeatureNameSafe(i));

}

have[i] = false;

found = true;

break;

}

}

if (!found)

{

if (dump) fprintf(stderr, "OPENCV: Trying to disable unknown CPU feature: '%s'.\n", feature.c_str());

}

}

}

}

bool have[MAX_FEATURE+1];

{

CV_DbgAssert( 0 <= feature && feature <= CV_HARDWARE_MAX_FEATURE );

return currentFeatures->have[feature];

{

useOptimizedFlag = flag;

currentFeatures = flag ? &featuresEnabled : &featuresDisabled;

ipp::setUseIPP(flag);

#ifdef HAVE_OPENCL

ocl::setUseOpenCL(flag);

#endif

#ifdef HAVE_TEGRA_OPTIMIZATION

::tegra::setUseTegra(flag);

#endif

{

#if defined _WIN32 || defined WINCE

LARGE_INTEGER counter;

QueryPerformanceCounter( &counter );

return (int64)counter.QuadPart;

#elif defined __linux || defined __linux__

struct timespec tp;

clock_gettime(CLOCK_MONOTONIC, &tp);

return (int64)tp.tv_sec*1000000000 + tp.tv_nsec;

#elif defined __MACH__ && defined __APPLE__

return (int64)mach_absolute_time();

#else

struct timeval tv;

struct timezone tz;

gettimeofday( &tv, &tz );

return (int64)tv.tv_sec*1000000 + tv.tv_usec;

#endif

{

#if defined _WIN32 || defined WINCE

LARGE_INTEGER freq;

QueryPerformanceFrequency(&freq);

return (double)freq.QuadPart;

#elif defined __linux || defined __linux__

return 1e9;

#elif defined __MACH__ && defined __APPLE__

static double freq = 0;

if( freq == 0 )

{

mach_timebase_info_data_t sTimebaseInfo;

mach_timebase_info(&sTimebaseInfo);

freq = sTimebaseInfo.denom*1e9/sTimebaseInfo.numer;

}

return freq;

#else

return 1e6;

#endif

{

int64 x;

__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));

return x;

{

unsigned hi, lo;

__asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));

return (int64)lo | ((int64)hi << 32);

{

int64 result = 0;

unsigned upper, lower, tmp;

__asm__ volatile(

"0: \n"

"\tmftbu %0 \n"

"\tmftb %1 \n"

"\tmftbu %2 \n"

"\tcmpw %2,%0 \n"

"\tbne 0b \n"

: "=r"(upper),"=r"(lower),"=r"(tmp)

);

return lower | ((int64)upper << 32);

{

__asm _emit 0x0f;

__asm _emit 0x31;

{

AutoBuffer<char, 1024> buf;

for ( ; ; )

{

va_list va;

va_start(va, fmt);

int bsize = static_cast<int>(buf.size());

int len = cv_vsnprintf((char *)buf, bsize, fmt, va);

va_end(va);

CV_Assert(len >= 0 && "Check format string for errors");

if (len >= bsize)

{

buf.resize(len + 1);

continue;

}

buf[bsize - 1] = 0;

return String((char *)buf, len);

}

{

String fname;

#ifndef WINRT

const char *temp_dir = getenv("OPENCV_TEMP_PATH");

#endif

#if defined _WIN32

#ifdef WINRT

RoInitialize(RO_INIT_MULTITHREADED);

std::wstring temp_dir = GetTempPathWinRT();

std::wstring temp_file = GetTempFileNameWinRT(L"ocv");

if (temp_file.empty())

return String();

temp_file = temp_dir.append(std::wstring(L"\\")).append(temp_file);

DeleteFileW(temp_file.c_str());

char aname[MAX_PATH];

size_t copied = wcstombs(aname, temp_file.c_str(), MAX_PATH);

CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));

fname = String(aname);

RoUninitialize();

#else

char temp_dir2[MAX_PATH] = { 0 };

char temp_file[MAX_PATH] = { 0 };

if (temp_dir == 0 || temp_dir[0] == 0)

{

::GetTempPathA(sizeof(temp_dir2), temp_dir2);

temp_dir = temp_dir2;

}

if(0 == ::GetTempFileNameA(temp_dir, "ocv", 0, temp_file))

return String();

DeleteFileA(temp_file);

fname = temp_file;

#endif

# else

# ifdef __ANDROID__

//char defaultTemplate[] = "/mnt/sdcard/__opencv_temp.XXXXXX";

char defaultTemplate[] = "/data/local/tmp/__opencv_temp.XXXXXX";

# else

char defaultTemplate[] = "/tmp/__opencv_temp.XXXXXX";

# endif

if (temp_dir == 0 || temp_dir[0] == 0)

fname = defaultTemplate;

else

{

fname = temp_dir;

char ech = fname[fname.size() - 1];

if(ech != '/' && ech != '\\')

fname = fname + "/";

fname = fname + "__opencv_temp.XXXXXX";

}

const int fd = mkstemp((char*)fname.c_str());

if (fd == -1) return String();

close(fd);

remove(fname.c_str());

# endif

if (suffix)

{

if (suffix[0] != '.')

return fname + "." + suffix;

else

return fname + suffix;

}

return fname;

{

bool prevVal = breakOnError;

breakOnError = value;

return prevVal;

{

va_list va;

va_start(va, fmt);

int res = cv_vsnprintf(buf, len, fmt, va);

va_end(va);

return res;

{

#if defined _MSC_VER

if (len <= 0) return len == 0 ? 1024 : -1;

int res = _vsnprintf_s(buf, len, _TRUNCATE, fmt, args);

// ensure null terminating on VS

if (res >= 0 && res < len)

{

buf[res] = 0;

return res;

}

else

{

buf[len - 1] = 0; // truncate happened

return res >= len ? res : (len * 2);

}

#else

return vsnprintf(buf, len, fmt, args);

#endif

{

if (customErrorCallback != 0)

customErrorCallback(exc.code, exc.func.c_str(), exc.err.c_str(),

exc.file.c_str(), exc.line, customErrorCallbackData);

else

{

const char* errorStr = cvErrorStr(exc.code);

char buf[1 << 12];

cv_snprintf(buf, sizeof(buf),

"OpenCV Error: %s (%s) in %s, file %s, line %d",

errorStr, exc.err.c_str(), exc.func.size() > 0 ?

exc.func.c_str() : "unknown function", exc.file.c_str(), exc.line);

fprintf( stderr, "%s\n", buf );

fflush( stderr );

# ifdef __ANDROID__

__android_log_print(ANDROID_LOG_ERROR, "cv::error()", "%s", buf);

# endif

}

if(breakOnError)

{

static volatile int* p = 0;

*p = 0;

}

CV_THROW(exc);

{

if( prevUserdata )

*prevUserdata = customErrorCallbackData;

ErrorCallback prevCallback = customErrorCallback;

customErrorCallback = errCallback;

customErrorCallbackData = userdata;

return prevCallback;

{

CV_DbgAssert( 0 <= feature && feature <= CV_HARDWARE_MAX_FEATURE );

return cv::currentFeatures->have[feature];