Struct SimulationParams 

pub struct SimulationParams {
    pub scale_factor: f64,
    pub target_width: u32,
    pub target_height: u32,
    pub adjusted_ppd: f64,
    pub requires_upscale: bool,
    pub requires_downscale: bool,
}

Parameters for viewing simulation.

Describes how to transform an image and adjust metrics for a viewing condition.

Fields

scale_factor: f64

Scale factor to apply to the image (1.0 = no scaling).

target_width: u32

Target width after scaling.

target_height: u32

Target height after scaling.

adjusted_ppd: f64

Adjusted PPD for metric thresholds.

In downsample-only mode, this may differ from effective_ppd() to compensate for skipped upscaling.

requires_upscale: bool

Whether the simulation requires upscaling.

In downsample-only mode, this is always false.

requires_downscale: bool

Whether the simulation requires downscaling.

Implementations

impl SimulationParams

pub fn requires_scaling(&self) -> bool

Check if any scaling is required.

pub fn downscale_only_factor(&self) -> f64

Get the scale factor clamped to downscale-only (max 1.0).

pub fn threshold_multiplier(&self) -> f64

Compute threshold multiplier for metric values.

This accounts for how viewing conditions affect artifact visibility. Higher PPD = smaller angular size = artifacts less visible = more lenient thresholds.

The multiplier is relative to REFERENCE_PPD (40, desktop viewing).

Returns

• 1.0 at reference PPD (40)

• 1.0 for higher PPD (more lenient, e.g., 1.75 at 70 PPD)

• < 1.0 for lower PPD (stricter, e.g., 0.5 at 20 PPD)

Example

use codec_eval::viewing::{ViewingCondition, SimulationMode, REFERENCE_PPD};

// Desktop at reference PPD
let condition = ViewingCondition::new(40.0);
let params = condition.simulation_params(1000, 800, SimulationMode::Accurate);
assert!((params.threshold_multiplier() - 1.0).abs() < 0.01);

// Laptop at 70 PPD - more lenient
let condition = ViewingCondition::new(70.0);
let params = condition.simulation_params(1000, 800, SimulationMode::Accurate);
assert!(params.threshold_multiplier() > 1.5);

pub fn adjust_dssim_threshold(&self, base_threshold: f64) -> f64

Adjust a DSSIM threshold for this viewing condition.

Higher PPD allows higher DSSIM values (artifacts less visible).

Arguments

• base_threshold - Threshold at reference PPD (e.g., 0.0003 for imperceptible)

Example

use codec_eval::viewing::{ViewingCondition, SimulationMode};

let condition = ViewingCondition::new(70.0); // laptop
let params = condition.simulation_params(1000, 800, SimulationMode::Accurate);

// Imperceptible threshold at reference is 0.0003
let adjusted = params.adjust_dssim_threshold(0.0003);
assert!(adjusted > 0.0003); // More lenient at higher PPD

pub fn adjust_butteraugli_threshold(&self, base_threshold: f64) -> f64

Adjust a Butteraugli threshold for this viewing condition.

Higher PPD allows higher Butteraugli values (artifacts less visible).

Arguments

• base_threshold - Threshold at reference PPD (e.g., 1.0 for imperceptible)

pub fn adjust_ssimulacra2_threshold(&self, base_threshold: f64) -> f64

Adjust a SSIMULACRA2 threshold for this viewing condition.

Higher PPD allows lower SSIMULACRA2 scores (artifacts less visible). Note: SSIMULACRA2 is inverted (higher = better), so we divide.

Arguments

• base_threshold - Threshold at reference PPD (e.g., 90.0 for imperceptible)

pub fn dssim_acceptable(&self, dssim: f64, base_threshold: f64) -> bool

Check if a DSSIM value is acceptable for this viewing condition.

Arguments

• dssim - Measured DSSIM value
• base_threshold - Threshold at reference PPD

pub fn butteraugli_acceptable( &self, butteraugli: f64, base_threshold: f64, ) -> bool

Check if a Butteraugli value is acceptable for this viewing condition.

pub fn ssimulacra2_acceptable( &self, ssimulacra2: f64, base_threshold: f64, ) -> bool

Check if a SSIMULACRA2 value is acceptable for this viewing condition.

Trait Implementations

impl Clone for SimulationParams

fn clone(&self) -> SimulationParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimulationParams

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

Formats the value using the given formatter.

impl PartialEq for SimulationParams

fn eq(&self, other: &SimulationParams) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SimulationParams

impl StructuralPartialEq for SimulationParams