Skip to content

Namespace vl#

Namespace List > vl

Classes#

Type Name
class Buffer <class T>
class ColorRgb
class CudaMemoryResource
class EncodedImage
class EncodingSettings
class Frame
class GPIO
class HostMemoryResource
class ICamera
class IFrameObserver
class Image
class ImageBuf
class ImageGray
class ImagePlane
class ImageRgb
struct ImageSettings
class IntParameters <typename ParType>
class MemoryResource
struct NoParameters
class PixelFormat

Public Types#

Type Name
enum AutoExposureMode
enum AwbMode
enum BinningMode
enum CameraStatus
enum CaptureStatus
enum Depth
enum FlashOutputMode
enum ImageEncoding
enum ImageFormat
enum JpgParameters
typedef boost::container::pmr::memory_resource MemoryResourceType
enum MemoryType
enum PngParameters
typedef boost::container::pmr::polymorphic_allocator< T > PolymorphicAllocator
typedef size_t StreamId
enum TriggerMode
enum VcCameraApi

Public Functions#

Type Name
CudaMemoryResource * defaultCudaMemoryResource ()
HostMemoryResource * defaultHostMemoryResource ()
MemoryResource * defaultMemoryResource (MemoryType memoryType)
vl::Buffer< uint8_t > encodeJpeg (const Image & img, int32_t quality)
std::vector< uint8_t > encodePng (const Image & img)
std::unique_ptr< ICamera > makeAlviumCamera (size_t idx=0)
std::unique_ptr< ICamera > makeArgusCamera (size_t idx=0)
std::unique_ptr< ICamera > makeCamera (size_t idx=0)
ImageBuf makeImageBuf (size_t width, size_t height, ImageFormat format, MemoryResource * memoryResource)
ImageBuf makeImageBufGray8 (size_t width, size_t height, MemoryResource * memoryResource)
ImageBuf makeImageBufRgb888 (size_t width, size_t height, MemoryResource * memoryResource)
ImageBuf makeImageBufYuv420 (size_t width, size_t height, MemoryResource * memoryResource)
std::unique_ptr< ICamera > makeVcCamera (size_t idx=0, VcCameraApi api=VcCameraApi::Auto)
void saveImage (const std::string & path, const vl::Image & img)
void saveImage (const std::string & path, const vl::ImageRgb & img)
void saveImage (const std::string & path, const vl::ImageGray & img)
void saveImage (const std::string & path, const vl::EncodedImage & img)
size_t valueSize ()
size_t valueSize (Depth depth)

Public Types Documentation#

enum AutoExposureMode#

enum vl::AutoExposureMode {
    Off,
    Continuous
};

enum AwbMode#

enum vl::AwbMode {
    AwbModeOff,
    AwbModeAuto
};

enum BinningMode#

enum vl::BinningMode {
    Off,
    Binning2x2,
    Binning4x4,
    Invalid
};

enum CameraStatus#

enum vl::CameraStatus {
    Success,
    UnknownError
};

enum CaptureStatus#

enum vl::CaptureStatus {
    Success,
    UnknownError,
    Uninitialized,
    Timeout
};

enum Depth#

enum vl::Depth {
    UInt8,
    UInt16,
    UInt32,
    UInt64,
    Int8,
    Int16,
    Int32,
    Int64,
    Float,
    Double
};

enum FlashOutputMode#

enum vl::FlashOutputMode {
    Off,
    ExposureActiveHigh,
    ExposureActiveLow
};

enum ImageEncoding#

enum vl::ImageEncoding {
    None,
    Jpg,
    Png
};

enum ImageFormat#

enum vl::ImageFormat {
    Invalid,
    Gray8,
    RGB888,
    NV12,
    YUV420
};

enum JpgParameters#

enum vl::JpgParameters {
    JpgQuality
};

typedef MemoryResourceType#

using vl::MemoryResourceType = typedef boost::container::pmr::memory_resource;

enum MemoryType#

enum vl::MemoryType {
    Invalid,
    Host,
    Cuda
};

enum PngParameters#

enum vl::PngParameters;

typedef PolymorphicAllocator#

using vl::PolymorphicAllocator = typedef boost::container::pmr::polymorphic_allocator<T>;

typedef StreamId#

using vl::StreamId = typedef size_t;

enum TriggerMode#

enum vl::TriggerMode {
    Off,
    Software,
    Hardware
};

enum VcCameraApi#

enum vl::VcCameraApi {
    Auto,
    Argus,
    V4L
};

Public Functions Documentation#

function defaultCudaMemoryResource#

CudaMemoryResource * vl::defaultCudaMemoryResource ()

function defaultHostMemoryResource#

HostMemoryResource * vl::defaultHostMemoryResource ()

function defaultMemoryResource#

MemoryResource * vl::defaultMemoryResource (
    MemoryType memoryType
)

function encodeJpeg#

vl::Buffer < uint8_t > vl::encodeJpeg (
    const Image & img,
    int32_t quality
)

function encodePng#

std::vector< uint8_t > vl::encodePng (
    const Image & img
)

function makeAlviumCamera#

std::unique_ptr< ICamera > vl::makeAlviumCamera (
    size_t idx=0
)

function makeArgusCamera#

std::unique_ptr< ICamera > vl::makeArgusCamera (
    size_t idx=0
)

function makeCamera#

std::unique_ptr< ICamera > vl::makeCamera (
    size_t idx=0
)

function makeImageBuf#

ImageBuf vl::makeImageBuf (
    size_t width,
    size_t height,
    ImageFormat format,
    MemoryResource * memoryResource
)

function makeImageBufGray8#

ImageBuf vl::makeImageBufGray8 (
    size_t width,
    size_t height,
    MemoryResource * memoryResource
)

function makeImageBufRgb888#

ImageBuf vl::makeImageBufRgb888 (
    size_t width,
    size_t height,
    MemoryResource * memoryResource
)

function makeImageBufYuv420#

ImageBuf vl::makeImageBufYuv420 (
    size_t width,
    size_t height,
    MemoryResource * memoryResource
)

function makeVcCamera#

std::unique_ptr< ICamera > vl::makeVcCamera (
    size_t idx=0,
    VcCameraApi api=VcCameraApi::Auto
)

function saveImage#

void vl::saveImage (
    const std::string & path,
    const vl::Image & img
)

function saveImage#

void vl::saveImage (
    const std::string & path,
    const vl::ImageRgb & img
)

function saveImage#

void vl::saveImage (
    const std::string & path,
    const vl::ImageGray & img
)

function saveImage#

void vl::saveImage (
    const std::string & path,
    const vl::EncodedImage & img
)

function valueSize#

template<Depth depth>
size_t vl::valueSize ()

function valueSize#

size_t vl::valueSize (
    Depth depth
)

The documentation for this class was generated from the following file docs/libvl/build/1.2.5/doxygen/source/vl/buffer.h