Struct SymbolArtDrawer 

pub struct SymbolArtDrawer { /* private fields */ }

A drawer that renders SymbolArt compositions into images

The SymbolArtDrawer is responsible for converting SymbolArt compositions into raster images. It handles the rendering of individual layers, applying transformations, and compositing them into a final image.

Examples

use sar_core::{SymbolArtDrawer, parse};
use sar_core::renderer::draw::Drawer;

// Parse a SAR file into a SymbolArt instance
let bytes = include_bytes!("../../../fixture/sa0a1d081b8a108bb8c9847c4cd83db662.sar");
let symbol_art = parse(Vec::from(*bytes)).unwrap();

// Create a drawer and render the SymbolArt
let drawer = SymbolArtDrawer::new();
let image = drawer.draw(&symbol_art).unwrap();

Configuration

The drawer can be configured with various options:

• with_raise_error: Controls whether rendering errors should be raised or suppressed
• Canvas size: Default is 256x256 pixels
• with_chunk_size: Controls parallel processing of layers (default: 10)

Performance

The drawer uses parallel processing to render layers efficiently. The chunk size can be adjusted to balance between parallelization overhead and throughput.

Error Handling

By default, the drawer suppresses rendering errors and continues processing. This can be changed using with_raise_error(true) to make errors fatal.

Resource Management

The drawer maintains a cache of symbol resources to improve rendering performance. These resources are loaded when the drawer is created and shared across all rendering operations.

Implementations

impl SymbolArtDrawer

pub fn new() -> Self

Examples found in repository

examples/parse.rs (line 10)

fn main() {
    let current_dir = std::env::current_dir().unwrap();
    let examples_dir = current_dir.join("fixture");
    let target_dir = current_dir.join("sar-core").join("examples").join("result");

    let files = std::fs::read_dir(&examples_dir).unwrap();
    let drawer = sar_core::SymbolArtDrawer::new();
    files.par_bridge().for_each(|file| {
        let file = match file {
            Ok(file) => file,
            Err(_) => return,
        };
        if file.path().is_dir() || file.path().extension().unwrap() != "sar" {
            return;
        }

        let buff = std::fs::read(file.path()).unwrap();
        let sar = match sar_core::parse(buff) {
            Ok(sar) => sar,
            Err(e) => {
                println!(
                    "Error parsing {}: {}",
                    file.file_name().to_str().unwrap(),
                    e
                );
                return;
            }
        };

        let image = match drawer.draw(&sar) {
            Ok(image) => image,
            Err(e) => {
                println!("Error drawing {}: {}", file.path().display(), e);
                return;
            }
        };
        image
            .save(target_dir.join(format!("{}.png", file.file_name().to_str().unwrap())))
            .unwrap();
        println!(
            "Saved to {}",
            target_dir
                .join(format!("{}.png", file.file_name().to_str().unwrap()))
                .display()
        );
    })
}

pub fn with_raise_error(self, raise_error: bool) -> Self

pub fn with_chunk_size(self, chunk_size: usize) -> Self

Trait Implementations

impl Default for SymbolArtDrawer

fn default() -> Self

Returns the “default value” for a type.

impl<S, L> Drawer<S, L> for SymbolArtDrawer

where S: SymbolArt<Layer = L>, L: SymbolArtLayer + Sync,

fn draw(&self, sa: &S) -> Result<ImageBuffer<Rgba<u8>, Vec<u8>>>

fn draw_with_scale( &self, sa: &S, scale: f32, ) -> Result<ImageBuffer<Rgba<u8>, Vec<u8>>>