#include <opencv2/core/ocl.hpp>
|  | 
| enum | { TYPE_DEFAULT = (1 << 0),
 TYPE_CPU = (1 << 1),
 TYPE_GPU = (1 << 2),
 TYPE_ACCELERATOR = (1 << 3),
 TYPE_DGPU = TYPE_GPU + (1 << 16),
 TYPE_IGPU = TYPE_GPU + (1 << 17),
 TYPE_ALL = 0xFFFFFFFF
 }
 | 
|  | 
| enum | { FP_DENORM =(1 << 0),
 FP_INF_NAN =(1 << 1),
 FP_ROUND_TO_NEAREST =(1 << 2),
 FP_ROUND_TO_ZERO =(1 << 3),
 FP_ROUND_TO_INF =(1 << 4),
 FP_FMA =(1 << 5),
 FP_SOFT_FLOAT =(1 << 6),
 FP_CORRECTLY_ROUNDED_DIVIDE_SQRT =(1 << 7)
 }
 | 
|  | 
| enum | { EXEC_KERNEL =(1 << 0),
 EXEC_NATIVE_KERNEL =(1 << 1)
 }
 | 
|  | 
| enum | { NO_CACHE =0,
 READ_ONLY_CACHE =1,
 READ_WRITE_CACHE =2
 }
 | 
|  | 
| enum | { NO_LOCAL_MEM =0,
 LOCAL_IS_LOCAL =1,
 LOCAL_IS_GLOBAL =2
 }
 | 
|  | 
| enum | { UNKNOWN_VENDOR =0,
 VENDOR_AMD =1,
 VENDOR_INTEL =2,
 VENDOR_NVIDIA =3
 }
 | 
|  | 
◆ anonymous enum
| Enumerator | 
|---|
| TYPE_DEFAULT |  | 
| TYPE_CPU |  | 
| TYPE_GPU |  | 
| TYPE_ACCELERATOR |  | 
| TYPE_DGPU |  | 
| TYPE_IGPU |  | 
| TYPE_ALL |  | 
 
 
◆ anonymous enum
| Enumerator | 
|---|
| FP_DENORM |  | 
| FP_INF_NAN |  | 
| FP_ROUND_TO_NEAREST |  | 
| FP_ROUND_TO_ZERO |  | 
| FP_ROUND_TO_INF |  | 
| FP_FMA |  | 
| FP_SOFT_FLOAT |  | 
| FP_CORRECTLY_ROUNDED_DIVIDE_SQRT |  | 
 
 
◆ anonymous enum
| Enumerator | 
|---|
| EXEC_KERNEL |  | 
| EXEC_NATIVE_KERNEL |  | 
 
 
◆ anonymous enum
| Enumerator | 
|---|
| NO_CACHE |  | 
| READ_ONLY_CACHE |  | 
| READ_WRITE_CACHE |  | 
 
 
◆ anonymous enum
| Enumerator | 
|---|
| NO_LOCAL_MEM |  | 
| LOCAL_IS_LOCAL |  | 
| LOCAL_IS_GLOBAL |  | 
 
 
◆ anonymous enum
| Enumerator | 
|---|
| UNKNOWN_VENDOR |  | 
| VENDOR_AMD |  | 
| VENDOR_INTEL |  | 
| VENDOR_NVIDIA |  | 
 
 
◆ Device() [1/3]
      
        
          | cv::ocl::Device::Device | ( |  | ) |  | 
      
| Python: | 
|---|
|  | <ocl_Device object> | = | cv.ocl_Device( |  | ) | 
 
 
◆ Device() [2/3]
  
  | 
        
          | cv::ocl::Device::Device | ( | void * | d | ) |  |  | explicit | 
| Python: | 
|---|
|  | <ocl_Device object> | = | cv.ocl_Device( |  | ) | 
 
 
◆ Device() [3/3]
      
        
          | cv::ocl::Device::Device | ( | const Device & | d | ) |  | 
      
| Python: | 
|---|
|  | <ocl_Device object> | = | cv.ocl_Device( |  | ) | 
 
 
◆ ~Device()
      
        
          | cv::ocl::Device::~Device | ( |  | ) |  | 
      
 
 
◆ addressBits()
      
        
          | int cv::ocl::Device::addressBits | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.addressBits( |  | ) | 
 
 
◆ available()
      
        
          | bool cv::ocl::Device::available | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.available( |  | ) | 
 
 
◆ compilerAvailable()
      
        
          | bool cv::ocl::Device::compilerAvailable | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.compilerAvailable( |  | ) | 
 
 
◆ deviceVersionMajor()
      
        
          | int cv::ocl::Device::deviceVersionMajor | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.deviceVersionMajor( |  | ) | 
 
 
◆ deviceVersionMinor()
      
        
          | int cv::ocl::Device::deviceVersionMinor | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.deviceVersionMinor( |  | ) | 
 
 
◆ doubleFPConfig()
      
        
          | int cv::ocl::Device::doubleFPConfig | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.doubleFPConfig( |  | ) | 
 
 
◆ driverVersion()
      
        
          | String cv::ocl::Device::driverVersion | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.driverVersion( |  | ) | 
 
 
◆ endianLittle()
      
        
          | bool cv::ocl::Device::endianLittle | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.endianLittle( |  | ) | 
 
 
◆ errorCorrectionSupport()
      
        
          | bool cv::ocl::Device::errorCorrectionSupport | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.errorCorrectionSupport( |  | ) | 
 
 
◆ executionCapabilities()
      
        
          | int cv::ocl::Device::executionCapabilities | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.executionCapabilities( |  | ) | 
 
 
◆ extensions()
      
        
          | String cv::ocl::Device::extensions | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.extensions( |  | ) | 
 
 
◆ getDefault()
  
  | 
        
          | static const Device& cv::ocl::Device::getDefault | ( |  | ) |  |  | static | 
| Python: | 
|---|
|  | retval | = | cv.ocl.Device_getDefault( |  | ) | 
 
 
◆ globalMemCacheLineSize()
      
        
          | int cv::ocl::Device::globalMemCacheLineSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.globalMemCacheLineSize( |  | ) | 
 
 
◆ globalMemCacheSize()
      
        
          | size_t cv::ocl::Device::globalMemCacheSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.globalMemCacheSize( |  | ) | 
 
 
◆ globalMemCacheType()
      
        
          | int cv::ocl::Device::globalMemCacheType | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.globalMemCacheType( |  | ) | 
 
 
◆ globalMemSize()
      
        
          | size_t cv::ocl::Device::globalMemSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.globalMemSize( |  | ) | 
 
 
◆ halfFPConfig()
      
        
          | int cv::ocl::Device::halfFPConfig | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.halfFPConfig( |  | ) | 
 
 
◆ hostUnifiedMemory()
      
        
          | bool cv::ocl::Device::hostUnifiedMemory | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.hostUnifiedMemory( |  | ) | 
 
 
◆ image2DMaxHeight()
      
        
          | size_t cv::ocl::Device::image2DMaxHeight | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.image2DMaxHeight( |  | ) | 
 
 
◆ image2DMaxWidth()
      
        
          | size_t cv::ocl::Device::image2DMaxWidth | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.image2DMaxWidth( |  | ) | 
 
 
◆ image3DMaxDepth()
      
        
          | size_t cv::ocl::Device::image3DMaxDepth | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.image3DMaxDepth( |  | ) | 
 
 
◆ image3DMaxHeight()
      
        
          | size_t cv::ocl::Device::image3DMaxHeight | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.image3DMaxHeight( |  | ) | 
 
 
◆ image3DMaxWidth()
      
        
          | size_t cv::ocl::Device::image3DMaxWidth | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.image3DMaxWidth( |  | ) | 
 
 
◆ imageBaseAddressAlignment()
      
        
          | uint cv::ocl::Device::imageBaseAddressAlignment | ( |  | ) | const | 
      
 
 
◆ imageFromBufferSupport()
      
        
          | bool cv::ocl::Device::imageFromBufferSupport | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.imageFromBufferSupport( |  | ) | 
 
 
◆ imageMaxArraySize()
      
        
          | size_t cv::ocl::Device::imageMaxArraySize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.imageMaxArraySize( |  | ) | 
 
 
◆ imageMaxBufferSize()
      
        
          | size_t cv::ocl::Device::imageMaxBufferSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.imageMaxBufferSize( |  | ) | 
 
 
◆ imagePitchAlignment()
      
        
          | uint cv::ocl::Device::imagePitchAlignment | ( |  | ) | const | 
      
 
 
◆ imageSupport()
      
        
          | bool cv::ocl::Device::imageSupport | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.imageSupport( |  | ) | 
 
 
◆ intelSubgroupsSupport()
      
        
          | bool cv::ocl::Device::intelSubgroupsSupport | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.intelSubgroupsSupport( |  | ) | 
 
 
◆ isAMD()
  
  | 
        
          | bool cv::ocl::Device::isAMD | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.isAMD( |  | ) | 
 
 
◆ isExtensionSupported()
      
        
          | bool cv::ocl::Device::isExtensionSupported | ( | const String & | extensionName | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.isExtensionSupported( | extensionName | ) | 
 
 
◆ isIntel()
  
  | 
        
          | bool cv::ocl::Device::isIntel | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.isIntel( |  | ) | 
 
 
◆ isNVidia()
  
  | 
        
          | bool cv::ocl::Device::isNVidia | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.isNVidia( |  | ) | 
 
 
◆ linkerAvailable()
      
        
          | bool cv::ocl::Device::linkerAvailable | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.linkerAvailable( |  | ) | 
 
 
◆ localMemSize()
      
        
          | size_t cv::ocl::Device::localMemSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.localMemSize( |  | ) | 
 
 
◆ localMemType()
      
        
          | int cv::ocl::Device::localMemType | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.localMemType( |  | ) | 
 
 
◆ maxClockFrequency()
      
        
          | int cv::ocl::Device::maxClockFrequency | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxClockFrequency( |  | ) | 
 
 
◆ maxComputeUnits()
      
        
          | int cv::ocl::Device::maxComputeUnits | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxComputeUnits( |  | ) | 
 
 
◆ maxConstantArgs()
      
        
          | int cv::ocl::Device::maxConstantArgs | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxConstantArgs( |  | ) | 
 
 
◆ maxConstantBufferSize()
      
        
          | size_t cv::ocl::Device::maxConstantBufferSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxConstantBufferSize( |  | ) | 
 
 
◆ maxMemAllocSize()
      
        
          | size_t cv::ocl::Device::maxMemAllocSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxMemAllocSize( |  | ) | 
 
 
◆ maxParameterSize()
      
        
          | size_t cv::ocl::Device::maxParameterSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxParameterSize( |  | ) | 
 
 
◆ maxReadImageArgs()
      
        
          | int cv::ocl::Device::maxReadImageArgs | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxReadImageArgs( |  | ) | 
 
 
◆ maxSamplers()
      
        
          | int cv::ocl::Device::maxSamplers | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxSamplers( |  | ) | 
 
 
◆ maxWorkGroupSize()
      
        
          | size_t cv::ocl::Device::maxWorkGroupSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxWorkGroupSize( |  | ) | 
 
 
◆ maxWorkItemDims()
      
        
          | int cv::ocl::Device::maxWorkItemDims | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxWorkItemDims( |  | ) | 
 
 
◆ maxWorkItemSizes()
      
        
          | void cv::ocl::Device::maxWorkItemSizes | ( | size_t * |  | ) | const | 
      
 
 
◆ maxWriteImageArgs()
      
        
          | int cv::ocl::Device::maxWriteImageArgs | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.maxWriteImageArgs( |  | ) | 
 
 
◆ memBaseAddrAlign()
      
        
          | int cv::ocl::Device::memBaseAddrAlign | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.memBaseAddrAlign( |  | ) | 
 
 
◆ name()
      
        
          | String cv::ocl::Device::name | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.name( |  | ) | 
 
 
◆ nativeVectorWidthChar()
      
        
          | int cv::ocl::Device::nativeVectorWidthChar | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.nativeVectorWidthChar( |  | ) | 
 
 
◆ nativeVectorWidthDouble()
      
        
          | int cv::ocl::Device::nativeVectorWidthDouble | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.nativeVectorWidthDouble( |  | ) | 
 
 
◆ nativeVectorWidthFloat()
      
        
          | int cv::ocl::Device::nativeVectorWidthFloat | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.nativeVectorWidthFloat( |  | ) | 
 
 
◆ nativeVectorWidthHalf()
      
        
          | int cv::ocl::Device::nativeVectorWidthHalf | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.nativeVectorWidthHalf( |  | ) | 
 
 
◆ nativeVectorWidthInt()
      
        
          | int cv::ocl::Device::nativeVectorWidthInt | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.nativeVectorWidthInt( |  | ) | 
 
 
◆ nativeVectorWidthLong()
      
        
          | int cv::ocl::Device::nativeVectorWidthLong | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.nativeVectorWidthLong( |  | ) | 
 
 
◆ nativeVectorWidthShort()
      
        
          | int cv::ocl::Device::nativeVectorWidthShort | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.nativeVectorWidthShort( |  | ) | 
 
 
◆ OpenCL_C_Version()
      
        
          | String cv::ocl::Device::OpenCL_C_Version | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.OpenCL_C_Version( |  | ) | 
 
 
◆ OpenCLVersion()
      
        
          | String cv::ocl::Device::OpenCLVersion | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.OpenCLVersion( |  | ) | 
 
 
◆ operator=()
◆ preferredVectorWidthChar()
      
        
          | int cv::ocl::Device::preferredVectorWidthChar | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.preferredVectorWidthChar( |  | ) | 
 
 
◆ preferredVectorWidthDouble()
      
        
          | int cv::ocl::Device::preferredVectorWidthDouble | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.preferredVectorWidthDouble( |  | ) | 
 
 
◆ preferredVectorWidthFloat()
      
        
          | int cv::ocl::Device::preferredVectorWidthFloat | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.preferredVectorWidthFloat( |  | ) | 
 
 
◆ preferredVectorWidthHalf()
      
        
          | int cv::ocl::Device::preferredVectorWidthHalf | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.preferredVectorWidthHalf( |  | ) | 
 
 
◆ preferredVectorWidthInt()
      
        
          | int cv::ocl::Device::preferredVectorWidthInt | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.preferredVectorWidthInt( |  | ) | 
 
 
◆ preferredVectorWidthLong()
      
        
          | int cv::ocl::Device::preferredVectorWidthLong | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.preferredVectorWidthLong( |  | ) | 
 
 
◆ preferredVectorWidthShort()
      
        
          | int cv::ocl::Device::preferredVectorWidthShort | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.preferredVectorWidthShort( |  | ) | 
 
 
◆ printfBufferSize()
      
        
          | size_t cv::ocl::Device::printfBufferSize | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.printfBufferSize( |  | ) | 
 
 
◆ profilingTimerResolution()
      
        
          | size_t cv::ocl::Device::profilingTimerResolution | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.profilingTimerResolution( |  | ) | 
 
 
◆ ptr()
      
        
          | void* cv::ocl::Device::ptr | ( |  | ) | const | 
      
 
 
◆ set()
      
        
          | void cv::ocl::Device::set | ( | void * | d | ) |  | 
      
 
 
◆ singleFPConfig()
      
        
          | int cv::ocl::Device::singleFPConfig | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.singleFPConfig( |  | ) | 
 
 
◆ type()
      
        
          | int cv::ocl::Device::type | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.type( |  | ) | 
 
 
◆ vendorID()
      
        
          | int cv::ocl::Device::vendorID | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.vendorID( |  | ) | 
 
 
◆ vendorName()
      
        
          | String cv::ocl::Device::vendorName | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.vendorName( |  | ) | 
 
 
◆ version()
      
        
          | String cv::ocl::Device::version | ( |  | ) | const | 
      
| Python: | 
|---|
|  | retval | = | cv.ocl_Device.version( |  | ) | 
 
 
The documentation for this class was generated from the following file: