Struct SolveResult 

pub struct SolveResult<S> {

    pub placements: Vec<Placement<S>>,
    pub boundaries_used: usize,
    pub utilization: f64,
    pub unplaced: Vec<GeometryId>,
    pub computation_time_ms: u64,
    pub generations: Option<u32>,
    pub iterations: Option<u64>,
    pub best_fitness: Option<f64>,
    pub fitness_history: Option<Vec<f64>>,
    pub strategy: Option<String>,
    pub cancelled: bool,
    pub target_reached: bool,
    pub strip_stats: Vec<StripStats>,
    pub total_piece_area: f64,
    pub total_material_used: f64,
    pub total_requested: usize,
}

Result of a nesting or packing solve operation.

Fields

placements: Vec<Placement<S>>

List of placements for all successfully placed geometry instances.

boundaries_used: usize

Number of boundaries (bins) used.

utilization: f64

Utilization ratio (0.0 - 1.0). Calculated as: total_geometry_measure / total_boundary_measure

unplaced: Vec<GeometryId>

IDs of geometries that could not be placed.

computation_time_ms: u64

Computation time in milliseconds.

generations: Option<u32>

Number of generations (for GA-based solvers).

iterations: Option<u64>

Number of iterations (for SA-based solvers).

best_fitness: Option<f64>

Best fitness value achieved (for GA/SA-based solvers).

fitness_history: Option<Vec<f64>>

Fitness history over generations (for analysis).

strategy: Option<String>

Strategy used for solving.

cancelled: bool

Whether the solve was cancelled early.

target_reached: bool

Whether the target utilization was reached.

strip_stats: Vec<StripStats>

Per-strip statistics for multi-strip packing. Contains used_length, piece_area, piece_count for each strip.

total_piece_area: f64

Total area of all placed pieces.

total_material_used: f64

Total material area consumed (sum of strip_width × used_length for each strip).

total_requested: usize

Total number of geometry instances requested (Σ of every geometry’s quantity). This is the instance-level denominator: the count of unplaced instances is total_requested - placements.len(), since placements is instance-level while unplaced is deduplicated to unique geometry IDs. Set once at the top-level solve/solve_with_progress entry point.

Implementations

impl<S> SolveResult<S>

pub fn new() -> Self

Creates a new empty result.

pub fn all_placed(&self) -> bool

Returns true if all geometries were placed.

pub fn placed_count(&self) -> usize

Returns the number of placed geometry instances.

pub fn unplaced_count(&self) -> usize

Returns the number of unplaced geometry types.

pub fn is_successful(&self) -> bool

Returns true if the solve was successful (at least one placement).

pub fn completed_normally(&self) -> bool

Returns true if the solve completed within the time limit.

pub fn with_strategy(self, strategy: impl Into<String>) -> Self

Sets the strategy name.

pub fn with_generations(self, generations: u32) -> Self

Sets the generations count.

pub fn with_best_fitness(self, fitness: f64) -> Self

Sets the best fitness.

pub fn with_fitness_history(self, history: Vec<f64>) -> Self

Sets the fitness history.

pub fn deduplicate_unplaced(&mut self)

Removes duplicate entries from the unplaced list. This is useful when multiple instances of the same geometry failed to place.

pub fn placement_stats(&self) -> PlacementStats

Computes placement statistics.

pub fn utilization_percent(&self) -> String

Returns utilization as a percentage string.

pub fn merge(&mut self, other: SolveResult<S>, boundary_offset: usize)

Merges placements from another result (for multi-bin scenarios).

pub fn with_strip_stats(self, stats: Vec<StripStats>) -> Self

Sets strip statistics.

pub fn calculate_utilization(&mut self)

Calculates and sets utilization from strip stats. This is the accurate utilization based on actual material consumed.

impl SolveResult<f64>

pub fn to_boundary_local(&mut self, extent: f64)

Rewrites placement x-coordinates from the global multi-strip frame (sheets laid side-by-side: x ≈ boundary_index * extent) into the per-boundary local frame, so each placement’s x is relative to the origin of its own sheet (boundary_index selects the sheet).

solve_multi_strip emits global strip coordinates (the strip-packing representation its benchmark callers rely on). Binding/wire consumers that render per-sheet panels want sheet-local coordinates instead; this is the single shared transform they apply at the response boundary.

extent is the boundary’s x-axis extent (b_max[0] - b_min[0]), identical to the strip_width used during solving. After this call every placement’s x lies in [0, extent) (modulo spacing/margin) within its sheet.

Trait Implementations

impl<S: Clone> Clone for SolveResult<S>

fn clone(&self) -> SolveResult<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for SolveResult<S>

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

Formats the value using the given formatter.

impl<S> Default for SolveResult<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S> From<&SolveResult<S>> for SolveSummary

fn from(result: &SolveResult<S>) -> Self

Converts to this type from the input type.