summaryrefslogtreecommitdiff
path: root/morphology-img/src
diff options
context:
space:
mode:
Diffstat (limited to 'morphology-img/src')
-rw-r--r--morphology-img/src/lib.rs107
-rw-r--r--morphology-img/src/render.rs224
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()
-}