Struct GeneratedImage 

pub struct GeneratedImage {
    pub data: Vec<u8>,
    pub format: ImageFormat,
    pub provider: ImageProviderKind,
    pub metadata: GenerationMetadata,
}

A generated image with its data and metadata.

Fields

data: Vec<u8>

Raw image bytes.

format: ImageFormat

Image format.

provider: ImageProviderKind

Provider that generated this image.

metadata: GenerationMetadata

Generation metadata.

Implementations

impl GeneratedImage

pub fn new( data: Vec<u8>, format: ImageFormat, provider: ImageProviderKind, metadata: GenerationMetadata, ) -> Self

Creates a new generated image.

pub fn from_bytes( data: Vec<u8>, provider: ImageProviderKind, metadata: GenerationMetadata, ) -> Result<Self>

Creates a new generated image, detecting format from magic bytes.

pub fn validate_format(&self) -> bool

Validates that the image data matches the claimed format.

pub fn detected_format(&self) -> Option<ImageFormat>

Returns the actual format detected from magic bytes.

pub fn size(&self) -> usize

Returns the size of the image data in bytes.

Examples found in repository

examples/generate_image.rs (line 19)

async fn main() -> genviz::Result<()> {
    let provider = GeminiProvider::builder().build()?;

    let request = GenerationRequest::new("A golden retriever puppy playing in snow");
    let image = provider.generate(&request).await?;

    image.save("output.png")?;
    println!(
        "Generated image: {} bytes, format: {:?}",
        image.size(),
        image.format
    );

    Ok(())
}

examples/edit_image.rs (line 24)

async fn main() -> genviz::Result<()> {
    let input_path = std::env::args()
        .nth(1)
        .expect("Usage: edit_image <input_image.png>");

    let input_bytes = std::fs::read(&input_path)?;

    let provider = GeminiProvider::builder().build()?;

    let request = GenerationRequest::new("Make the colors more vibrant and add a warm sunset glow")
        .with_input_image(input_bytes);

    let image = provider.generate(&request).await?;
    image.save("edited.png")?;
    println!("Edited image saved to edited.png ({} bytes)", image.size());

    Ok(())
}

examples/multi_provider.rs (line 37)

async fn main() -> genviz::Result<()> {
    // Try to build whichever provider has a key available
    let provider: Box<dyn ImageProvider> = if std::env::var("GOOGLE_API_KEY").is_ok() {
        println!("Using Gemini provider");
        Box::new(genviz::GeminiProvider::builder().build()?)
    } else if std::env::var("BFL_API_KEY").is_ok() {
        println!("Using Flux provider");
        Box::new(genviz::FluxProvider::builder().build()?)
    } else if std::env::var("XAI_API_KEY").is_ok() {
        println!("Using Grok provider");
        Box::new(genviz::GrokProvider::builder().build()?)
    } else if std::env::var("OPENAI_API_KEY").is_ok() {
        println!("Using OpenAI provider");
        Box::new(genviz::OpenAiImageProvider::builder().build()?)
    } else {
        eprintln!("Set at least one API key environment variable.");
        std::process::exit(1);
    };

    println!("Provider: {} ({:?})", provider.name(), provider.kind());

    let request = GenerationRequest::new("A serene mountain lake at dawn");
    let image = provider.generate(&request).await?;

    let filename = format!("{:?}_output.png", provider.kind());
    image.save(&filename)?;
    println!("Saved to {} ({} bytes)", filename, image.size());

    Ok(())
}

pub fn save(&self, path: impl AsRef<Path>) -> Result<()>

Saves the image to the specified path.

Examples found in repository

examples/generate_image.rs (line 16)

async fn main() -> genviz::Result<()> {
    let provider = GeminiProvider::builder().build()?;

    let request = GenerationRequest::new("A golden retriever puppy playing in snow");
    let image = provider.generate(&request).await?;

    image.save("output.png")?;
    println!(
        "Generated image: {} bytes, format: {:?}",
        image.size(),
        image.format
    );

    Ok(())
}

examples/edit_image.rs (line 23)

async fn main() -> genviz::Result<()> {
    let input_path = std::env::args()
        .nth(1)
        .expect("Usage: edit_image <input_image.png>");

    let input_bytes = std::fs::read(&input_path)?;

    let provider = GeminiProvider::builder().build()?;

    let request = GenerationRequest::new("Make the colors more vibrant and add a warm sunset glow")
        .with_input_image(input_bytes);

    let image = provider.generate(&request).await?;
    image.save("edited.png")?;
    println!("Edited image saved to edited.png ({} bytes)", image.size());

    Ok(())
}

examples/multi_provider.rs (line 36)

async fn main() -> genviz::Result<()> {
    // Try to build whichever provider has a key available
    let provider: Box<dyn ImageProvider> = if std::env::var("GOOGLE_API_KEY").is_ok() {
        println!("Using Gemini provider");
        Box::new(genviz::GeminiProvider::builder().build()?)
    } else if std::env::var("BFL_API_KEY").is_ok() {
        println!("Using Flux provider");
        Box::new(genviz::FluxProvider::builder().build()?)
    } else if std::env::var("XAI_API_KEY").is_ok() {
        println!("Using Grok provider");
        Box::new(genviz::GrokProvider::builder().build()?)
    } else if std::env::var("OPENAI_API_KEY").is_ok() {
        println!("Using OpenAI provider");
        Box::new(genviz::OpenAiImageProvider::builder().build()?)
    } else {
        eprintln!("Set at least one API key environment variable.");
        std::process::exit(1);
    };

    println!("Provider: {} ({:?})", provider.name(), provider.kind());

    let request = GenerationRequest::new("A serene mountain lake at dawn");
    let image = provider.generate(&request).await?;

    let filename = format!("{:?}_output.png", provider.kind());
    image.save(&filename)?;
    println!("Saved to {} ({} bytes)", filename, image.size());

    Ok(())
}

pub fn to_base64(&self) -> String

Encodes the image data as base64.

pub fn to_data_url(&self) -> String

Returns the image as a data URL.

Trait Implementations

impl Clone for GeneratedImage

fn clone(&self) -> GeneratedImage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GeneratedImage

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

Formats the value using the given formatter.