Command Line Interface

def main(argv=None):
    """
    Entry point for meshio command-line interface.
    
    Parameters:
    - argv: List[str] | None - Command line arguments
        If None, uses sys.argv. Primarily for testing and programmatic use.
        
    Returns:
    - int - Exit code (0 for success, non-zero for errors)
    
    Available Commands:
    - convert (c): Convert between mesh formats
    - info (i): Display mesh information and validate consistency
    - compress: Compress mesh files to reduce size
    - decompress: Decompress compressed mesh files  
    - ascii (a): Convert mesh files to ASCII format
    - binary (b): Convert mesh files to binary format
    
    Global Options:
    - --version, -v: Display version information
    - --help, -h: Show help message
    
    Examples:
    $ meshio convert input.msh output.vtk
    $ meshio info mesh.stl
    $ meshio compress large_file.vtu --max
    """

# meshio convert / meshio c
"""
Convert between different mesh file formats.

Usage:
  meshio convert [options] <input_file> <output_file>
  meshio c [options] <input_file> <output_file>

Arguments:
  input_file                    Source mesh file to read
  output_file                   Target mesh file to write

Options:
  --input-format, -i FORMAT     Explicit input format specification
                                Choices: {all_reader_formats}
  --output-format, -o FORMAT    Explicit output format specification
                                Choices: {all_writer_formats}
  --ascii, -a                   Write in ASCII format variant (default: binary)
  --float-format, -f FORMAT     Float format for ASCII output (default: .16e)
  --sets-to-int-data, -s        Convert sets to integer data arrays
                                Useful when output format doesn't support sets
  --int-data-to-sets, -d        Convert integer data to sets
                                Useful when output format doesn't support int data

Examples:
  meshio convert mesh.msh result.vtk
  meshio convert --ascii model.stl output.ply
  meshio convert -i gmsh -o vtk data.dat result.vtk
  meshio convert --sets-to-int-data mesh.msh output.stl
"""

# meshio info / meshio i  
"""
Display detailed information about mesh files and validate consistency.

Usage:
  meshio info [options] <input_file>
  meshio i [options] <input_file>

Arguments:
  input_file                    Mesh file to analyze

Options:
  --input-format, -i FORMAT     Explicit input format specification
                                Choices: {all_reader_formats}

Output Information:
  - Number of points and cells by type
  - Point data, cell data, and field data names
  - Point sets and cell sets
  - Mesh consistency validation
  - Warnings for unused points or invalid cell references

Examples:
  meshio info model.vtk
  meshio info --input-format gmsh data.dat
"""

# meshio compress
"""
Compress mesh files to reduce file size using format-specific compression.

Usage:
  meshio compress [options] <input_file>

Arguments:
  input_file                    Mesh file to compress

Options:
  --input-format, -i FORMAT     Explicit input format specification
  --max                         Use maximum compression level

Supported Formats:
  - VTU: Uses zlib or lzma compression
  - XDMF: Compresses HDF5 data arrays
  - Other formats: Converts to compressed variant if available

Examples:
  meshio compress large_mesh.vtu
  meshio compress --max simulation_data.xdmf
"""

# meshio decompress
"""
Decompress compressed mesh files.

Usage:  
  meshio decompress [options] <input_file>

Arguments:
  input_file                    Compressed mesh file to decompress

Options:
  --input-format, -i FORMAT     Explicit input format specification

Examples:
  meshio decompress compressed_mesh.vtu.gz
  meshio decompress data.xdmf
"""

# meshio ascii / meshio a
"""
Convert mesh files to ASCII/text format variants.

Usage:
  meshio ascii [options] <input_file>
  meshio a [options] <input_file>

Arguments:
  input_file                    Mesh file to convert to ASCII

Options:
  --input-format, -i FORMAT     Explicit input format specification

Behavior:
  - Creates ASCII version with same base name
  - Useful for debugging and human-readable output
  - Shows file size before and after conversion

Examples:
  meshio ascii binary_mesh.stl    # Creates ASCII version
  meshio ascii model.vtk          # Converts to ASCII VTK
"""

# meshio binary / meshio b  
"""
Convert mesh files to binary format variants.

Usage:
  meshio binary [options] <input_file>
  meshio b [options] <input_file>

Arguments:
  input_file                    Mesh file to convert to binary

Options:
  --input-format, -i FORMAT     Explicit input format specification

Behavior:
  - Creates binary version with same base name
  - Significantly reduces file size for large meshes
  - Faster I/O performance
  - Shows file size before and after conversion

Examples:
  meshio binary ascii_mesh.stl    # Creates binary version
  meshio binary large_model.vtk   # Converts to binary VTK
"""

# Convert GMSH file to VTK format
meshio convert mesh.msh output.vtk

# Convert with explicit format specification
meshio convert --input-format gmsh --output-format vtk data.dat result.vtk

# Short form using aliases
meshio c input.stl output.ply

# Force ASCII output
meshio convert --ascii binary_mesh.stl text_mesh.obj

# Specify float precision for ASCII output
meshio convert --ascii --float-format .8e precise.vtk output.ply

# Display basic mesh information
meshio info model.vtk
# Output:
# <meshio mesh object>
#   Number of points: 1000
#   Number of cells:
#     triangle: 1800
#     quad: 200
#   Point data: temperature, velocity
#   Cell data: material_id
#   Field data: simulation_time

# Check mesh with explicit format
meshio info --input-format stl surface.dat

# Short form
meshio i complex_mesh.msh

# Convert sets to integer data (useful for formats that don't support sets)
meshio convert --sets-to-int-data mesh_with_sets.msh output.stl

# Convert integer data to sets (useful for formats that support sets)
meshio convert --int-data-to-sets data_with_ids.vtk output.msh

# Compress large mesh files
meshio compress large_simulation.vtu
# Shows size reduction and creates compressed version

# Maximum compression
meshio compress --max huge_dataset.xdmf

# Decompress files
meshio decompress compressed_mesh.vtu.gz

# Convert to binary for better performance
meshio binary slow_ascii.vtk
# Output: File size before: 25.3 MB
#         File size after: 8.7 MB

# Convert to ASCII for debugging
meshio ascii binary_mesh.stl
# Creates human-readable version for inspection

# Alternative short forms
meshio a binary_file.ply    # Convert to ASCII
meshio b ascii_file.obj     # Convert to binary

# Convert multiple files (shell scripting)
for file in *.msh; do
    meshio convert "$file" "${file%.msh}.vtk"
done

# Compress all VTU files in directory
find . -name "*.vtu" -exec meshio compress {} \;

# Check all mesh files for consistency
for mesh in *.vtk *.msh *.stl; do
    echo "Checking $mesh:"
    meshio info "$mesh"
    echo "---"
done

# Handle formats without standard extensions
meshio convert --input-format nastran model.dat --output-format vtk result.vtk

# Convert with data type optimization
meshio convert --sets-to-int-data --ascii fem_model.msh cad_export.obj

# Chain operations using shell pipes and temporary files
meshio convert input.msh temp.vtk && meshio compress temp.vtk && rm temp.vtk

# Use with ParaView (VTK formats)
meshio convert simulation.msh visualization.vtu
paraview visualization.vtu

# Prepare for 3D printing (STL format)
meshio convert cad_model.obj print_ready.stl
meshio info print_ready.stl  # Verify mesh is manifold

# Export for web visualization
meshio convert --ascii model.vtk web_display.obj

# Prepare for finite element analysis
meshio convert --int-data-to-sets geometry.stl analysis.msh

# Check file before conversion
meshio info problematic_file.msh
if [ $? -eq 0 ]; then
    meshio convert problematic_file.msh fixed_file.vtk
else
    echo "Mesh file has issues"
fi

# Verbose conversion with format specification
meshio convert --input-format vtk --output-format stl data.bin surface.stl

# Handle unknown extensions explicitly
meshio convert --input-format gmsh data.mesh --output-format ply output.ply

# Convert all source meshes to VTK for visualization
%.vtk: %.msh
	meshio convert $< $@

# Create ASCII versions for version control
%.ascii.vtk: %.vtk
	meshio ascii $<

# Compress final results
%.compressed: %
	meshio compress $<

# Batch target
convert_all: $(patsubst %.msh,%.vtk,$(wildcard *.msh))

check_all:
	@for mesh in *.msh *.vtk; do \
		echo "Checking $$mesh:"; \
		meshio info "$$mesh"; \
	done

#!/bin/bash
# mesh_pipeline.sh - Automated mesh processing pipeline

INPUT_DIR="input_meshes"
OUTPUT_DIR="processed_meshes"
TEMP_DIR="temp"

mkdir -p "$OUTPUT_DIR" "$TEMP_DIR"

for input_file in "$INPUT_DIR"/*.msh; do
    basename=$(basename "$input_file" .msh)
    temp_file="$TEMP_DIR/${basename}.vtk"
    output_file="$OUTPUT_DIR/${basename}_processed.vtu"
    
    echo "Processing $basename..."
    
    # Convert to VTK first
    if meshio convert "$input_file" "$temp_file"; then
        echo "  Converted to VTK"
        
        # Validate mesh
        if meshio info "$temp_file" > /dev/null 2>&1; then
            echo "  Mesh validation passed"
            
            # Convert to compressed VTU
            meshio convert --sets-to-int-data "$temp_file" "$output_file"
            meshio compress "$output_file"
            echo "  Final output: $output_file"
        else
            echo "  WARNING: Mesh validation failed for $basename"
        fi
    else
        echo "  ERROR: Conversion failed for $basename"
    fi
done

# Cleanup
rm -rf "$TEMP_DIR"
echo "Pipeline complete!"

#!/usr/bin/env python3
import subprocess
import sys
import os

def run_meshio_command(cmd, *args):
    """Run meshio command and return success status."""
    try:
        result = subprocess.run(['meshio'] + [cmd] + list(args), 
                              capture_output=True, text=True)
        if result.returncode == 0:
            return True, result.stdout
        else:
            return False, result.stderr
    except Exception as e:
        return False, str(e)

def convert_mesh(input_file, output_file, **options):
    """Convert mesh with options."""
    cmd_args = ['convert']
    
    if 'input_format' in options:
        cmd_args.extend(['--input-format', options['input_format']])
    if 'output_format' in options:
        cmd_args.extend(['--output-format', options['output_format']])
    if options.get('ascii', False):
        cmd_args.append('--ascii')
    if options.get('sets_to_int_data', False):
        cmd_args.append('--sets-to-int-data')
        
    cmd_args.extend([input_file, output_file])
    
    success, output = run_meshio_command(*cmd_args)
    return success, output

# Usage example
if __name__ == "__main__":
    input_mesh = "model.msh"
    output_mesh = "model.vtk"
    
    success, message = convert_mesh(
        input_mesh, output_mesh,
        ascii=True,
        sets_to_int_data=True
    )
    
    if success:
        print(f"Successfully converted {input_mesh} to {output_mesh}")
    else:
        print(f"Conversion failed: {message}")
        sys.exit(1)

# For large files, binary formats are much smaller and faster
meshio convert large_mesh.msh large_mesh.vtu  # Binary VTU
meshio binary large_mesh.vtk                  # Convert to binary

# Compression for long-term storage
meshio compress simulation_results.vtu --max  # Maximum compression

# Always validate before and after conversion
meshio info input.msh && meshio convert input.msh output.vtk && meshio info output.vtk

# Use explicit format specification for ambiguous extensions
meshio convert --input-format gmsh --output-format vtk data.dat result.vtk