### Create and Manipulate FScript and FSPoint (Rust)

Source: https://context7.com/jptomorrow/funscript-rs/llms.txt

Illustrates the creation and manipulation of the `FScript` and `FSPoint` structures. It shows how to initialize a new script, set its properties, manually create action points, and iterate through them to access their timestamp and position data.

```rust
use funscript::{FScript, FSPoint};

fn main() {
    // Create a new script with default values
    let mut script = FScript::default();

    // Set basic properties
    script.version = "1.0".to_string();
    script.inverted = false;
    script.range = 100;

    // Create action points manually
    // pos: position (0-100), at: timestamp in milliseconds
    let actions = vec![
        FSPoint { at: 0, pos: 0 },
        FSPoint { at: 500, pos: 100 },
        FSPoint { at: 1000, pos: 0 },
        FSPoint { at: 1500, pos: 50 },
        FSPoint { at: 2000, pos: 100 },
    ];

    script.actions = actions;

    // Access action fields
    for (i, action) in script.actions.iter().enumerate() {
        println!("Action {}: {}ms -> {}%", i, action.at, action.pos);
    }
}
```

--------------------------------

### Print Funscript Contents to JSON (Rust)

Source: https://context7.com/jptomorrow/funscript-rs/llms.txt

Demonstrates how to load a Funscript file and print its entire structure as formatted JSON to standard output using the `print_script` function. This is useful for debugging and inspecting script data.

```rust
use funscript::{load_funscript, print_script, FunscriptError};

fn main() -> Result<(), FunscriptError> {
    let script = load_funscript("./my_video.funscript")?;

    // Print the entire script as pretty-printed JSON
    print_script(&script);

    Ok(())
}
```

--------------------------------

### Load Funscript File

Source: https://context7.com/jptomorrow/funscript-rs/llms.txt

Reads a .funscript file from disk and deserializes it into an FScript struct. This allows access to script versioning, metadata, and individual action points.

```rust
use funscript::{load_funscript, FScript, FunscriptError};

fn main() -> Result<(), FunscriptError> {
    let script: FScript = load_funscript("./my_video.funscript")?;
    println!("Version: {}", script.version);
    println!("Number of action points: {}", script.actions.len());
    Ok(())
}
```

--------------------------------

### Save Funscript File

Source: https://context7.com/jptomorrow/funscript-rs/llms.txt

Serializes an FScript struct and writes it to a file. It requires the target path to have a .funscript extension and produces pretty-printed JSON.

```rust
use funscript::{load_funscript, save_funscript, FScript, FSPoint, FunscriptError};

fn main() -> Result<(), FunscriptError> {
    let mut script = load_funscript("./input.funscript")?;
    script.actions.push(FSPoint { at: 1000, pos: 0 });
    save_funscript("./output.funscript", &script)?;
    Ok(()) 
}
```

--------------------------------

### Handle Funscript Errors (Rust)

Source: https://context7.com/jptomorrow/funscript-rs/llms.txt

Demonstrates robust error handling for common operations using the `FunscriptError` enum. It covers handling file read errors, JSON parsing errors, and invalid file extensions during script loading and saving.

```rust
use funscript::{load_funscript, save_funscript, get_pt, FunscriptError};

fn main() {
    // Handle file read errors
    match load_funscript("./nonexistent.funscript") {
        Ok(script) => println!("Loaded {} actions", script.actions.len()),
        Err(FunscriptError::FileReadError(e)) => {
            println!("File error: {}", e);
        }
        Err(FunscriptError::JsonError(e)) => {
            println!("JSON parsing error: {}", e);
        }
        Err(e) => println!("Other error: {}", e),
    }

    // Handle invalid file extension
    let script = FScript::default();
    match save_funscript("./output.txt", &script) {
        Ok(_) => println!("Saved"),
        Err(FunscriptError::FileReadError(e)) => {
            println!("Invalid extension: {}", e);
        }
        Err(e) => println!("Error: {}", e),
    }
}
```

--------------------------------

### Apply Ramer-Douglas-Peucker Reduction

Source: https://context7.com/jptomorrow/funscript-rs/llms.txt

Reduces the number of action points in a script while preserving its shape. Higher epsilon values lead to more aggressive point reduction.

```rust
use funscript::{load_funscript, apply_rdp, save_funscript, FunscriptError};

fn main() -> Result<(), FunscriptError> {
    let mut script = load_funscript("./detailed_script.funscript")?;
    apply_rdp(&mut script, 5.0);
    save_funscript("./simplified_script.funscript", &script)?;
    Ok(())
}
```

--------------------------------

### Modify Action Points

Source: https://context7.com/jptomorrow/funscript-rs/llms.txt

Accesses and modifies specific action points within a script using the get_pt function. It provides mutable access to position and timing values while handling potential index errors.

```rust
use funscript::{load_funscript, get_pt, FunscriptError};

fn main() -> Result<(), FunscriptError> {
    let mut script = load_funscript("./my_video.funscript")?;
    let point = get_pt(&mut script, 0)?;
    point.at = 5000;
    point.pos = 75;
    Ok(())
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.