Struct Analysis 

pub struct Analysis<H> {
    pub metadata: GifMetadata,
    pub frames: Vec<AnalyzedFrame<H>>,
    pub segments: Vec<Segment>,
}

Result of GIF analysis containing frames and segments.

Fields

metadata: GifMetadata

Metadata about the original GIF.

frames: Vec<AnalyzedFrame<H>>

Analyzed frames with hashes and segment assignments.

segments: Vec<Segment>

Detected segments.

Implementations

impl<H: Clone + Sync + Send> Analysis<H>

pub fn frame_count(&self) -> usize

Get the number of frames.

pub fn segment_count(&self) -> usize

Get the number of segments.

pub fn total_duration_ms(&self) -> u64

Get the total duration in milliseconds.

pub fn static_segments(&self) -> Vec<&Segment>

Get segments that are marked as static.

pub fn apply_operations(&self, ops: &SegmentOps) -> Vec<EncodableFrame>

Apply segment operations and get encodable frames.

Operations not in the map default to Keep.

pub fn export<E: GifEncoder>( &self, encoder: &E, ops: &SegmentOps, config: &EncodeConfig, ) -> Result<Vec<u8>>

Apply operations and export using the specified encoder.

pub fn export_to_file<E: GifEncoder>( &self, encoder: &E, ops: &SegmentOps, path: impl AsRef<Path>, config: &EncodeConfig, ) -> Result<()>

Apply operations and export to a file.

pub fn apply_all_operations( &self, segment_ops: &SegmentOps, frame_ops: &FrameOps, ) -> Vec<EncodableFrame>

Apply both segment and frame operations and get encodable frames.

This is the enhanced version that handles frame-level operations like individual frame removal and segment splitting.

Operations not in the maps default to Keep.

pub fn calculate_impact( &self, segment_ops: &SegmentOps, frame_ops: &FrameOps, ) -> (usize, u64)

Calculate the resulting frame count and duration without cloning images.

Returns (total_frames, total_duration_ms).

pub fn export_with_frame_ops<E: GifEncoder>( &self, encoder: &E, segment_ops: &SegmentOps, frame_ops: &FrameOps, config: &EncodeConfig, ) -> Result<Vec<u8>>

Apply both segment and frame operations and export using the specified encoder.

pub fn export_to_file_with_frame_ops<E: GifEncoder>( &self, encoder: &E, segment_ops: &SegmentOps, frame_ops: &FrameOps, path: impl AsRef<Path>, config: &EncodeConfig, ) -> Result<()>

Apply both segment and frame operations and export to a file.

pub fn split_segments(&self, frame_ops: &FrameOps) -> Analysis<H>

Logically split segments at frames marked with FrameOp::SplitAfter.

This returns a new Analysis where segments have been partitioned based on the split points. This allows applying different segment-level operations to the newly created parts.

pub fn as_encodable(&self) -> Vec<EncodableFrame>

Get frames as encodable without any operations applied.

pub fn pauses(&self) -> SegmentSelector<'_>

Select all static segments (pauses/duplicate frames).

Returns a [SegmentSelector] that can be filtered and operated on.

Example

// Cap all pauses to 300ms
let ops = analysis.pauses().cap(300);

// Collapse only long pauses
let ops = analysis.pauses()
    .longer_than(500)
    .collapse(200);

pub fn motion(&self) -> SegmentSelector<'_>

Select all motion segments (non-static, actually changing content).

Example

// Speed up all motion by 1.5x
let ops = analysis.motion().speed_up(1.5);

pub fn all(&self) -> SegmentSelector<'_>

Select all segments.

Example

// Speed up everything by 2x
let ops = analysis.all().speed_up(2.0);

pub fn segment(&self, id: usize) -> SegmentSelector<'_>

Select a single segment by ID.

Example

// Remove segment 5
let ops = analysis.segment(5).remove();

pub fn segments_by_id(&self, ids: &[usize]) -> SegmentSelector<'_>

Select multiple segments by ID.

Example

// Collapse specific segments
let ops = analysis.segments_by_id(&[1, 3, 5]).collapse(100);

pub fn frames_range(&self, range: Range<usize>) -> SegmentSelector<'_>

Select segments by frame index range.

Selects any segment that overlaps with the given frame range.

Example

// Speed up the first 100 frames
let ops = analysis.frames_range(0..100).speed_up(2.0);

pub fn cap_pauses(&self, max_ms: u32) -> SegmentOps

Cap all static segments (pause points) to a maximum duration.

Static segments longer than max_ms will be collapsed to a single frame with that duration. Shorter segments are unchanged.

Example

// Make all pauses last at most 300ms
let ops = analysis.cap_pauses(300);
let frames = analysis.apply_operations(&ops);

pub fn collapse_all_pauses(&self, duration_ms: u32) -> SegmentOps

Collapse all static segments to a fixed duration.

Every static segment becomes a single frame with the specified delay, regardless of its original length.

Example

// Make all pauses exactly 200ms
let ops = analysis.collapse_all_pauses(200);

pub fn remove_long_pauses(&self, min_ms: u32) -> SegmentOps

Remove all static segments longer than the specified duration.

Example

// Remove any pause longer than 2 seconds
let ops = analysis.remove_long_pauses(2000);

pub fn speed_up_pauses(&self, factor: f64) -> SegmentOps

Speed up all static segments by a factor.

A factor of 2.0 makes pauses twice as fast (half duration). A factor of 0.5 makes them half as fast (double duration).

Example

// Make all pauses 3x faster
let ops = analysis.speed_up_pauses(3.0);

pub fn speed_up_all(&self, factor: f64) -> SegmentOps

Speed up the entire GIF by a factor.

Affects all segments, not just static ones.

Example

// Make everything 1.5x faster
let ops = analysis.speed_up_all(1.5);

pub fn target_duration(&self, target_ms: u64) -> Option<SegmentOps>

Create operations that optimize the GIF for a target duration.

This will collapse/remove static segments as needed to try to reach the target duration. Non-static segments are preserved.

Returns None if the target is not achievable (non-static content already exceeds the target).

Example

// Try to get the GIF under 30 seconds
if let Some(ops) = analysis.target_duration(30_000) {
    let frames = analysis.apply_operations(&ops);
}

pub fn merge_ops(op_sets: &[SegmentOps]) -> SegmentOps

Merge multiple operation sets, with later ops overriding earlier ones.

Example

let base = analysis.cap_pauses(500);
let extra = analysis.speed_up_all(1.2);
let combined = Analysis::<H>::merge_ops(&[base, extra]);

Trait Implementations

impl<H: Clone> Clone for Analysis<H>

fn clone(&self) -> Analysis<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: Debug> Debug for Analysis<H>

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

Formats the value using the given formatter.