diff options
Diffstat (limited to 'morphology-img/src')
| -rw-r--r-- | morphology-img/src/lib.rs | 107 | ||||
| -rw-r--r-- | morphology-img/src/render.rs | 224 |
2 files changed, 63 insertions, 268 deletions
diff --git a/morphology-img/src/lib.rs b/morphology-img/src/lib.rs index 386d8ac..ce33c34 100644 --- a/morphology-img/src/lib.rs +++ b/morphology-img/src/lib.rs @@ -34,25 +34,6 @@ pub use error::RenderError; pub use note::sequence_to_markup; use std::path::PathBuf; -use std::sync::Arc; - -/// Type alias for progress callback function. -/// -/// The callback receives: -/// - `current`: The number of sequences processed so far (1-indexed) -/// - `total`: The total number of sequences to process -/// -/// # Examples -/// -/// ```no_run -/// use morphology_img::ProgressCallback; -/// use std::sync::Arc; -/// -/// let callback: ProgressCallback = Arc::new(|current, total| { -/// println!("Progress: {}/{}", current, total); -/// }); -/// ``` -pub type ProgressCallback = Arc<dyn Fn(usize, usize) + Send + Sync>; /// Configuration for rendering sequences to SVGs. /// @@ -83,21 +64,11 @@ pub struct RenderConfig { /// Path to the LilyPond binary (default: "lilypond") pub lilypond_binary: PathBuf, - /// Optional callback for progress reporting during batch rendering - pub progress_callback: Option<ProgressCallback>, - /// Maximum number of sequences to process in a single batch /// /// If set, large batches will be split into smaller chunks to avoid /// filesystem issues. If None, all sequences are processed in one batch. pub max_batch_size: Option<usize>, - - /// Whether to use parallel processing for rendering SVGs - /// - /// When enabled, multiple LilyPond processes will run concurrently using rayon. - /// This can significantly improve performance for large batches on multi-core systems. - /// Default: false (conservative default to avoid overwhelming the system). - pub parallel: bool, } impl std::fmt::Debug for RenderConfig { @@ -106,9 +77,7 @@ impl std::fmt::Debug for RenderConfig { .field("output_dir", &self.output_dir) .field("keep_temp_files", &self.keep_temp_files) .field("lilypond_binary", &self.lilypond_binary) - .field("progress_callback", &self.progress_callback.as_ref().map(|_| "<callback>")) .field("max_batch_size", &self.max_batch_size) - .field("parallel", &self.parallel) .finish() } } @@ -119,9 +88,7 @@ impl Default for RenderConfig { output_dir: PathBuf::from("output"), keep_temp_files: false, lilypond_binary: PathBuf::from("lilypond"), - progress_callback: None, max_batch_size: None, - parallel: false, } } } @@ -188,27 +155,6 @@ impl RenderConfig { self } - /// Sets a progress callback for batch rendering. - /// - /// The callback will be called after each sequence is rendered, allowing - /// you to track progress for large batches. - /// - /// # Examples - /// - /// ``` - /// use morphology_img::RenderConfig; - /// use std::sync::Arc; - /// - /// let config = RenderConfig::new("output") - /// .progress_callback(Arc::new(|current, total| { - /// println!("Rendered {}/{} sequences", current, total); - /// })); - /// ``` - pub fn progress_callback(mut self, callback: ProgressCallback) -> Self { - self.progress_callback = Some(callback); - self - } - /// Sets the maximum batch size for processing sequences. /// /// When set, large batches of sequences will be split into smaller chunks @@ -229,37 +175,6 @@ impl RenderConfig { self.max_batch_size = Some(size); self } - - /// Enables or disables parallel processing for SVG rendering. - /// - /// When enabled, LilyPond will be invoked in parallel using rayon, - /// which can significantly improve performance for large batches on - /// multi-core systems. The default is false (sequential processing). - /// - /// # Performance Considerations - /// - /// Parallel processing is most beneficial when: - /// - Rendering many sequences (typically 10+) - /// - Running on a multi-core system - /// - LilyPond execution is the bottleneck (not file I/O) - /// - /// For small batches (< 10 sequences), sequential processing may be faster - /// due to the overhead of spawning parallel tasks. - /// - /// # Examples - /// - /// ``` - /// use morphology_img::RenderConfig; - /// - /// let config = RenderConfig::new("output") - /// .parallel(true); - /// - /// assert!(config.parallel); - /// ``` - pub fn parallel(mut self, parallel: bool) -> Self { - self.parallel = parallel; - self - } } /// Renders multiple sequences to SVG files. @@ -379,22 +294,12 @@ fn render_sequences_batch( total_count, )?; - // Render .ly files to SVGs (parallel or sequential based on config) - let svg_paths = if config.parallel { - render::render_ly_files_to_svg_parallel( - &ly_files, - &config.output_dir, - &config.lilypond_binary, - config.progress_callback.as_ref(), - )? - } else { - render::render_ly_files_to_svg( - &ly_files, - &config.output_dir, - &config.lilypond_binary, - config.progress_callback.as_ref(), - )? - }; + // Render .ly files to SVGs in a single batch + let svg_paths = render::render_all_ly_files_batch( + &ly_files, + &config.output_dir, + &config.lilypond_binary, + )?; // Handle temp directory cleanup if config.keep_temp_files { diff --git a/morphology-img/src/render.rs b/morphology-img/src/render.rs index a437a21..842f796 100644 --- a/morphology-img/src/render.rs +++ b/morphology-img/src/render.rs @@ -53,55 +53,69 @@ pub fn check_lilypond_available() -> Result<String, RenderError> { } } -/// Renders a single .ly file to SVG using LilyPond. +/// Renders multiple .ly files to SVGs by calling LilyPond once with all files. /// -/// This function invokes the LilyPond CLI to convert a LilyPond source file -/// into an SVG image. The SVG file will be created in the specified output directory. +/// This function invokes LilyPond with all .ly files as arguments in a single command, +/// which is significantly more efficient than calling LilyPond separately for each file. +/// It eliminates process startup overhead and allows the OS to handle scheduling optimally. /// /// # Arguments -/// - `ly_file`: Path to the .ly file to render -/// - `output_dir`: Directory where the SVG should be created +/// - `ly_files`: Paths to the .ly files to render +/// - `output_dir`: Directory where SVGs should be created /// - `lilypond_binary`: Path to the LilyPond binary (typically "lilypond") /// /// # Returns -/// Path to the generated SVG file +/// Vector of paths to generated SVG files, in the same order as input /// /// # Errors /// - `RenderError::FileIO` if the output directory cannot be created /// - `RenderError::LilyPondExecution` if LilyPond fails to execute or produce output -/// - `RenderError::Template` if the .ly filename is invalid +/// - `RenderError::Template` if any .ly filename is invalid /// /// # Examples /// ```no_run -/// use morphology_img::render::render_ly_to_svg; -/// use std::path::Path; +/// use morphology_img::render::render_all_ly_files_batch; +/// use std::path::{Path, PathBuf}; /// -/// let ly_file = Path::new("/tmp/sequence-0.ly"); +/// let ly_files = vec![ +/// PathBuf::from("/tmp/sequence-0.ly"), +/// PathBuf::from("/tmp/sequence-1.ly"), +/// ]; /// let output_dir = Path::new("output"); /// let lilypond = Path::new("lilypond"); /// -/// let svg_path = render_ly_to_svg(ly_file, output_dir, lilypond).unwrap(); -/// println!("Generated SVG: {}", svg_path.display()); +/// let svg_paths = render_all_ly_files_batch(&ly_files, output_dir, lilypond).unwrap(); +/// println!("Generated {} SVG files", svg_paths.len()); /// ``` /// -/// # Notes -/// - LilyPond creates `filename.svg` from `filename.ly` in the output directory -/// - The function verifies that the expected SVG file was actually created -/// - LilyPond must be installed and the binary must be accessible -pub fn render_ly_to_svg( - ly_file: &Path, +/// # Performance Notes +/// - All files are processed in a single LilyPond invocation +/// - Much faster than sequential individual file processing +/// - Optimal for batches of any size +pub fn render_all_ly_files_batch( + ly_files: &[PathBuf], output_dir: &Path, lilypond_binary: &Path, -) -> Result<PathBuf, RenderError> { +) -> Result<Vec<PathBuf>, RenderError> { + // Handle empty input + if ly_files.is_empty() { + return Ok(Vec::new()); + } + // Ensure output directory exists fs::create_dir_all(output_dir)?; - // Build the command: lilypond --svg -o output_dir ly_file + // Get the directory containing the .ly files (should all be in same temp dir) + let ly_dir = ly_files[0] + .parent() + .ok_or_else(|| RenderError::Template("Invalid .ly file path".to_string()))?; + + // Build command: lilypond --svg file1.ly file2.ly file3.ly ... + // WITHOUT -o flag, so SVGs are created next to .ly files with correct names let output = Command::new(lilypond_binary) .arg("--svg") - .arg("-o") - .arg(output_dir) - .arg(ly_file) + .args(ly_files) + .current_dir(ly_dir) // Run in the temp directory .output()?; if !output.status.success() { @@ -109,156 +123,32 @@ pub fn render_ly_to_svg( return Err(RenderError::LilyPondExecution(stderr.to_string())); } - // Determine the output SVG path - // LilyPond creates filename.svg from filename.ly - let svg_filename = ly_file - .file_stem() - .ok_or_else(|| RenderError::Template("Invalid .ly filename".to_string()))? - .to_string_lossy() - .to_string() + ".svg"; + // Copy SVG files from temp directory to output directory + let mut svg_paths = Vec::with_capacity(ly_files.len()); - let svg_path = output_dir.join(svg_filename); + for ly_file in ly_files.iter() { + let svg_filename = ly_file + .file_stem() + .ok_or_else(|| RenderError::Template("Invalid .ly filename".to_string()))? + .to_string_lossy() + .to_string() + ".svg"; - // Verify the SVG was created - if !svg_path.exists() { - return Err(RenderError::LilyPondExecution( - format!("Expected SVG not created: {}", svg_path.display()) - )); - } + // SVG was created next to the .ly file in temp directory + let temp_svg_path = ly_dir.join(&svg_filename); - Ok(svg_path) -} - -/// Renders multiple .ly files to SVGs using LilyPond. -/// -/// This function processes multiple LilyPond source files sequentially, -/// converting each to an SVG image in the specified output directory. -/// -/// # Arguments -/// - `ly_files`: Paths to the .ly files to render -/// - `output_dir`: Directory where SVGs should be created -/// - `lilypond_binary`: Path to the LilyPond binary -/// - `progress_callback`: Optional callback for progress reporting -/// -/// # Returns -/// Vector of paths to generated SVG files, in the same order as input -/// -/// # Errors -/// Returns an error if any file fails to render. Processing stops at the first error. -/// -/// # Examples -/// ```no_run -/// use morphology_img::render::render_ly_files_to_svg; -/// use std::path::{Path, PathBuf}; -/// -/// let ly_files = vec![ -/// PathBuf::from("/tmp/sequence-0.ly"), -/// PathBuf::from("/tmp/sequence-1.ly"), -/// ]; -/// let output_dir = Path::new("output"); -/// let lilypond = Path::new("lilypond"); -/// -/// let svg_paths = render_ly_files_to_svg(&ly_files, output_dir, lilypond, None).unwrap(); -/// println!("Generated {} SVG files", svg_paths.len()); -/// ``` -/// -/// # Notes -/// - Files are processed sequentially (not in parallel) -/// - All SVGs are created in the same output directory -/// - If any file fails, an error is returned immediately -/// - Progress callback is called after each file is rendered (if provided) -pub fn render_ly_files_to_svg( - ly_files: &[PathBuf], - output_dir: &Path, - lilypond_binary: &Path, - progress_callback: Option<&crate::ProgressCallback>, -) -> Result<Vec<PathBuf>, RenderError> { - let total_count = ly_files.len(); - let mut svg_paths = Vec::with_capacity(total_count); + // Verify the SVG was created + if !temp_svg_path.exists() { + return Err(RenderError::LilyPondExecution( + format!("Expected SVG not created: {}", temp_svg_path.display()) + )); + } - for (index, ly_file) in ly_files.iter().enumerate() { - let svg_path = render_ly_to_svg(ly_file, output_dir, lilypond_binary)?; - svg_paths.push(svg_path); + // Copy to output directory (can't use rename - may be different filesystem) + let final_svg_path = output_dir.join(&svg_filename); + fs::copy(&temp_svg_path, &final_svg_path)?; - // Call progress callback if provided - if let Some(callback) = progress_callback { - callback(index + 1, total_count); - } + svg_paths.push(final_svg_path); } Ok(svg_paths) } - -/// Renders multiple .ly files to SVGs using LilyPond in parallel. -/// -/// This function processes multiple LilyPond source files concurrently using rayon, -/// converting each to an SVG image in the specified output directory. This can -/// significantly improve performance for large batches on multi-core systems. -/// -/// # Arguments -/// - `ly_files`: Paths to the .ly files to render -/// - `output_dir`: Directory where SVGs should be created -/// - `lilypond_binary`: Path to the LilyPond binary -/// - `progress_callback`: Optional callback for progress reporting -/// -/// # Returns -/// Vector of paths to generated SVG files, in the same order as input -/// -/// # Errors -/// Returns an error if any file fails to render. Processing stops at the first error. -/// -/// # Performance Notes -/// - Files are processed in parallel using rayon -/// - Progress callbacks may be invoked out of order (but still track correct indices) -/// - Best for batches of 10+ files on multi-core systems -/// - May be slower than sequential for very small batches due to overhead -/// -/// # Examples -/// ```no_run -/// use morphology_img::render::render_ly_files_to_svg_parallel; -/// use std::path::{Path, PathBuf}; -/// -/// let ly_files = vec![ -/// PathBuf::from("/tmp/sequence-0.ly"), -/// PathBuf::from("/tmp/sequence-1.ly"), -/// ]; -/// let output_dir = Path::new("output"); -/// let lilypond = Path::new("lilypond"); -/// -/// let svg_paths = render_ly_files_to_svg_parallel(&ly_files, output_dir, lilypond, None).unwrap(); -/// println!("Generated {} SVG files", svg_paths.len()); -/// ``` -pub fn render_ly_files_to_svg_parallel( - ly_files: &[PathBuf], - output_dir: &Path, - lilypond_binary: &Path, - progress_callback: Option<&crate::ProgressCallback>, -) -> Result<Vec<PathBuf>, RenderError> { - use rayon::prelude::*; - use std::sync::atomic::{AtomicUsize, Ordering}; - use std::sync::Arc; - - let total_count = ly_files.len(); - - // Use atomic counter for progress tracking - let completed = Arc::new(AtomicUsize::new(0)); - - // Process files in parallel - let results: Vec<Result<PathBuf, RenderError>> = ly_files - .par_iter() - .map(|ly_file| { - let svg_path = render_ly_to_svg(ly_file, output_dir, lilypond_binary)?; - - // Update progress if callback is provided - if let Some(callback) = progress_callback { - let current = completed.fetch_add(1, Ordering::SeqCst) + 1; - callback(current, total_count); - } - - Ok(svg_path) - }) - .collect(); - - // Collect results, returning early on first error - results.into_iter().collect() -} |