Struct ImageProcessor 

pub struct ImageProcessor {
    pub cpu: Option<CPUProcessor>,
    pub g2d: Option<G2DProcessor>,
    pub opengl: Option<GLProcessorThreaded>,
    /* private fields */
}

Image converter that uses available hardware acceleration or CPU as a fallback.

Fields

cpu: Option<CPUProcessor>

CPU-based image converter as a fallback. This is only None if the EDGEFIRST_DISABLE_CPU environment variable is set.

g2d: Option<G2DProcessor>

G2D-based image converter for Linux systems. This is only available if the EDGEFIRST_DISABLE_G2D environment variable is not set and libg2d.so is available.

opengl: Option<GLProcessorThreaded>

OpenGL-based image converter for Linux systems. This is only available if the EDGEFIRST_DISABLE_GL environment variable is not set and OpenGL ES is available.

Implementations

impl ImageProcessor

pub fn new() -> Result<Self>

Creates a new ImageProcessor instance, initializing available hardware converters based on the system capabilities and environment variables.

Examples

let image = include_bytes!("../../../testdata/zidane.jpg");
let img = TensorImage::load(image, Some(RGBA), None)?;
let mut converter = ImageProcessor::new()?;
let mut dst = TensorImage::new(640, 480, RGB, None)?;
converter.convert(&img, &mut dst, Rotation::None, Flip::None, Crop::default())?;

pub fn with_config(config: ImageProcessorConfig) -> Result<Self>

Creates a new ImageProcessor with the given configuration.

This allows overriding the EGL display type used for OpenGL acceleration. The EDGEFIRST_DISABLE_GL=1 environment variable still takes precedence over any override.

pub fn set_int8_interpolation_mode( &mut self, mode: Int8InterpolationMode, ) -> Result<()>

Sets the interpolation mode for int8 proto textures on the OpenGL backend. No-op if OpenGL is not available.

pub fn create_image( &self, width: usize, height: usize, fourcc: FourCharCode, ) -> Result<TensorImage>

Create a TensorImage with the best available memory backend.

Priority: DMA-buf → PBO → system memory.

Arguments

• width - Image width in pixels
• height - Image height in pixels
• fourcc - Pixel format as a FourCC code

Returns

A TensorImage backed by the highest-performance memory type available on this system.

Errors

Returns an error if all allocation strategies fail.

Trait Implementations

impl Debug for ImageProcessor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ImageProcessorTrait for ImageProcessor

fn convert( &mut self, src: &TensorImage, dst: &mut TensorImage, rotation: Rotation, flip: Flip, crop: Crop, ) -> Result<()>

Converts the source image to the destination image format and size. The image is cropped first, then flipped, then rotated

Prefer hardware accelerators when available, falling back to CPU if necessary.

fn convert_ref( &mut self, src: &TensorImage, dst: &mut TensorImageRef<'_>, rotation: Rotation, flip: Flip, crop: Crop, ) -> Result<()>

Converts the source image to a borrowed destination tensor for zero-copy preprocessing.

fn draw_masks( &mut self, dst: &mut TensorImage, detect: &[DetectBox], segmentation: &[Segmentation], ) -> Result<()>

Draw pre-decoded detection boxes and segmentation masks onto dst.

fn draw_masks_proto( &mut self, dst: &mut TensorImage, detect: &[DetectBox], proto_data: &ProtoData, ) -> Result<()>

Draw masks from proto data onto image (fused decode+draw).

fn set_class_colors(&mut self, colors: &[[u8; 4]]) -> Result<()>

Sets the colors used for rendering segmentation masks. Up to 17 colors can be set.

fn decode_masks_atlas( &mut self, detect: &[DetectBox], proto_data: ProtoData, output_width: usize, output_height: usize, ) -> Result<(Vec<u8>, Vec<MaskRegion>)>

Decode masks into a compact atlas buffer.

impl Send for ImageProcessor

impl Sync for ImageProcessor