Struct PreProcessorConfig 

pub struct PreProcessorConfig {

    pub image_processor_type: Option<String>,
    pub do_convert_rgb: Option<bool>,
    pub do_normalize: Option<bool>,
    pub do_pad: Option<bool>,
    pub do_rescale: Option<bool>,
    pub do_resize: Option<bool>,
    pub do_center_crop: Option<bool>,
    pub image_mean: Option<Vec<f64>>,
    pub image_std: Option<Vec<f64>>,
    pub rescale_factor: Option<f64>,
    pub resampling: Option<usize>,
    pub size: Option<HashMap<String, u32>>,
    pub crop_size: Option<HashMap<String, u32>>,
    pub patch_size: Option<PatchSize>,
    pub merge_size: Option<usize>,
    pub min_pixels: Option<usize>,
    pub max_pixels: Option<usize>,
    pub temporal_patch_size: Option<usize>,
    pub num_crops: Option<usize>,
    pub dynamic_hd: Option<usize>,
    pub max_image_tiles: Option<usize>,
    pub num_img_tokens: Option<usize>,
    pub im_start_token: Option<String>,
    pub im_end_token: Option<String>,
    pub slice_start_token: Option<String>,
    pub slice_end_token: Option<String>,
    pub vision_start_token: Option<String>,
    pub vision_end_token: Option<String>,
    pub extra: HashMap<String, Value>,
}

HuggingFace preprocessor_config.json structure.

This struct captures the common fields across different vision model processors. Model-specific fields are accessed via the flexible extra field.

Fields

image_processor_type: Option<String>

Processor class name (e.g., “CLIPImageProcessor”, “Qwen2VLImageProcessor”)

do_convert_rgb: Option<bool>

Whether to convert to RGB

do_normalize: Option<bool>

Whether to normalize with mean/std

do_pad: Option<bool>

Whether to pad images

do_rescale: Option<bool>

Whether to rescale pixel values (typically by 1/255)

do_resize: Option<bool>

Whether to resize images

do_center_crop: Option<bool>

Whether to center crop after resizing

image_mean: Option<Vec<f64>>

Per-channel normalization mean

image_std: Option<Vec<f64>>

Per-channel normalization std

rescale_factor: Option<f64>

Rescale factor (typically 1/255 = 0.00392156862745098)

resampling: Option<usize>

PIL resampling filter enum (0=Nearest, 1=Lanczos, 2=Bilinear, 3=Bicubic)

size: Option<HashMap<String, u32>>

Target size for resizing Can be {“height”: H, “width”: W} or {“shortest_edge”: S}

crop_size: Option<HashMap<String, u32>>

Target size for center cropping

patch_size: Option<PatchSize>

Vision encoder patch size (typically 14 or 16) Can be an integer or a dict {“height”: x, “width”: y}

merge_size: Option<usize>

Qwen-VL: merge size for token reduction

min_pixels: Option<usize>

Qwen-VL: minimum total pixels

max_pixels: Option<usize>

Qwen-VL: maximum total pixels

temporal_patch_size: Option<usize>

Qwen-VL: temporal patch size for video

num_crops: Option<usize>

Phi3-Vision: number of image crops

dynamic_hd: Option<usize>

Phi4-Vision: dynamic HD max crops

max_image_tiles: Option<usize>

LLaMA-Vision: maximum image tiles

num_img_tokens: Option<usize>

Fixed number of image tokens (some models use this)

im_start_token: Option<String>

Image start token

im_end_token: Option<String>

Image end token

slice_start_token: Option<String>

Slice start token (for multi-crop)

slice_end_token: Option<String>

Slice end token

vision_start_token: Option<String>

Vision start token (alternative naming)

vision_end_token: Option<String>

Vision end token

extra: HashMap<String, Value>

Catch-all for model-specific fields not explicitly defined

Implementations

impl PreProcessorConfig

pub const CLIP_MEAN: [f64; 3]

pub const CLIP_STD: [f64; 3]

pub const IMAGENET_MEAN: [f64; 3]

pub const IMAGENET_STD: [f64; 3]

pub const SIGLIP_MEAN: [f64; 3]

pub const SIGLIP_STD: [f64; 3]

pub fn from_json(json: &str) -> Result<Self, Error>

Parse from JSON string.

Handles both standard HuggingFace format (top-level fields) and Kimi-K2.5’s nested format where values are under media_proc_cfg.

pub fn from_value(value: Value) -> Result<Self, Error>

Parse from JSON value.

Handles both standard HuggingFace format (top-level fields) and Kimi-K2.5’s nested format where values are under media_proc_cfg.

pub fn get_patch_size(&self, default: usize) -> usize

Get patch size as a simple usize.

Returns the height value from PatchSize if available, falling back to provided default.

pub fn get_image_mean(&self) -> [f64; 3]

Get image mean as fixed array, with fallback to CLIP defaults.

pub fn get_image_std(&self) -> [f64; 3]

Get image std as fixed array, with fallback to CLIP defaults.

pub fn get_target_size(&self) -> Option<(u32, u32)>

Get target size from various config formats.

Handles both {"height": H, "width": W} and {"shortest_edge": S} formats. Returns (height, width).

pub fn get_crop_size(&self) -> Option<(u32, u32)>

Get crop size.

Returns (height, width).

pub fn get_filter(&self) -> FilterType

Get the interpolation filter for resizing.

pub fn should_normalize(&self) -> bool

Check if normalization should be applied.

pub fn should_rescale(&self) -> bool

Check if rescaling should be applied.

pub fn should_resize(&self) -> bool

Check if resizing should be applied.

pub fn should_center_crop(&self) -> bool

Check if center cropping should be applied.

pub fn get_rescale_factor(&self) -> f64

Get rescale factor with default.

pub fn get_extra<T: DeserializeOwned>(&self, key: &str) -> Option<T>

Get a typed extra field.

Trait Implementations

impl Clone for PreProcessorConfig

fn clone(&self) -> PreProcessorConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PreProcessorConfig

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

Formats the value using the given formatter.

impl Default for PreProcessorConfig

fn default() -> PreProcessorConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PreProcessorConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.