pivtools 0.1.3__cp311-cp311-win_amd64.whl

pivtools_gui/image_handling/readers/lavision_reader.py

@@ -0,0 +1,190 @@
+import os
+from typing import Optional
+from loguru import logger
+import numpy as np
+
+from . import register_reader
+
+
+def read_lavision_im7(
+    file_path: str, camera_no: int = 1, frames: int = 2
+) -> np.ndarray:
+    """Read LaVision .im7 files.
+    
+    LaVision .im7 files store all cameras in a single file per time instance.
+    Each file contains frame pairs (A and B) for all cameras.
+    
+    Structure: For N cameras, the file contains 2*N frames in sequence:
+    - Frames 0,1: Camera 1, frames A and B
+    - Frames 2,3: Camera 2, frames A and B
+    - etc.
+    
+    Args:
+        file_path: Path to the .im7 file
+        camera_no: Camera number (1-based indexing)
+        frames: Number of frames to read (typically 2 for PIV)
+        
+    Returns:
+        np.ndarray: Array of shape (frames, H, W) containing the image data
+    """
+    import sys
+    if sys.platform == "darwin":
+        raise ImportError(
+            "lvpyio is not shipped or supported on macOS (darwin). Please use a supported platform for LaVision .im7 reading."
+        )
+    try:
+        import lvpyio as lv
+    except ImportError:
+        raise ImportError(
+            "LaVision library not available. Please install."
+        )
+
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Image file not found: {file_path}")
+    
+    # Read the buffer as a generator
+    buffer = lv.read_buffer(file_path)
+    
+    # Calculate which frames we need for this camera
+    start_frame = (camera_no - 1) * 2
+    end_frame = start_frame + frames
+    
+    # Iterate through the generator, only processing the frames we need
+    data = None
+    for idx, img in enumerate(buffer):
+        if idx < start_frame:
+            # Skip frames before our camera
+            continue
+        elif idx < end_frame:
+            # This is one of our frames
+            if data is None:
+                # Initialize array on first needed frame
+                height, width = img.components["PIXEL"].planes[0].shape
+                data = np.zeros((frames, height, width), dtype=np.float64)
+            
+            i_scale = img.scales.i.slope
+            i_offset = img.scales.i.offset
+            u_arr = img.components["PIXEL"].planes[0] * i_scale + i_offset
+            data[idx - start_frame, :, :] = u_arr
+        else:
+            # We've got all our frames, stop iterating
+            break
+    
+    if data is None:
+        raise ValueError(f"Camera {camera_no} not found in file {file_path}")
+    
+    return data.astype(np.float32)
+
+
+def read_lavision_pair(file_path: str, camera_no: int = 1) -> np.ndarray:
+    """Read LaVision .im7 file and return as frame pair.
+    
+    Args:
+        file_path: Path to the .im7 file (contains all cameras for one time instance)
+        camera_no: Camera number (1-based) to extract from the file
+        
+    Returns:
+        np.ndarray: Array of shape (2, H, W) containing frame A and B for the specified camera
+    """
+    return read_lavision_im7(file_path, camera_no, frames=2)
+
+
+def read_lavision_ims(file_path: str, camera_no: Optional[int] = None, im_no: Optional[int] = None) -> np.ndarray:
+    """Read LaVision images from a .set file.
+    
+    LaVision .set files contain all cameras and frames in a single container.
+    This function reads the set file and extracts the appropriate frames for the
+    specified camera and image number.
+    
+    Args:
+        file_path: Path to the .set file
+        camera_no: Camera number (1-based). If None, extracted from file_path (legacy)
+        im_no: Image number (1-based). If None, extracted from file_path (legacy)
+        
+    Returns:
+        np.ndarray: Array of shape (2, H, W) containing frame A and B
+    """
+    import sys
+    from pathlib import Path
+    
+    if sys.platform == "darwin":
+        raise ImportError(
+            "LaVision libraries are not supported on macOS (darwin). Please use a supported platform."
+        )
+    
+    try:
+        import lvpyio as lv
+    except ImportError:
+        raise ImportError(
+            "LaVision library not available. Please install lvpyio."
+        )
+    
+    path = Path(file_path)
+    
+    # For .set files, camera_no and im_no must be provided
+    if path.suffix.lower() == '.set' or (camera_no is not None and im_no is not None):
+        # Modern format: file_path is the .set file
+        set_file_path = file_path
+        if camera_no is None or im_no is None:
+            raise ValueError("camera_no and im_no must be provided for .set files")
+    else:
+        # Legacy path parsing for backward compatibility
+        # Extract camera number from path (e.g., "Cam1" -> 1)
+        if camera_no is None:
+            camera_match = None
+            for part in path.parts:
+                if part.startswith("Cam") and part[3:].isdigit():
+                    camera_match = int(part[3:])
+                    break
+            if camera_match is None:
+                raise ValueError(f"Could not extract camera number from path: {file_path}")
+            camera_no = camera_match
+        
+        # Extract image number from filename
+        if im_no is None:
+            stem = path.stem
+            if stem.isdigit():
+                im_no = int(stem)
+            else:
+                raise ValueError(f"Could not extract image number from filename: {path.name}")
+        
+        # Source directory is typically the parent of the CamX directory
+        source_dir = path.parent.parent
+        set_file_path = str(source_dir)
+    
+    if not Path(set_file_path).exists():
+        raise FileNotFoundError(f"Set file path not found: {set_file_path}")
+    
+    # Read the set file
+    try:
+        set_file = lv.read_set(set_file_path)
+        im = set_file[im_no - 1]  # 0-based indexing in Python
+    except Exception as e:
+        raise RuntimeError(f"Failed to read set file from {set_file_path}: {e}")
+    
+    # Extract frames for this camera
+    data = np.zeros((2, *im.frames[0].components["PIXEL"].planes[0].shape), dtype=np.float64)
+    
+    for j in range(2):
+        # Frame indexing: 2*cameraNo-(2-j)
+        frame_idx = 2 * camera_no - (2 - j)
+        frame = im.frames[frame_idx]
+        
+        # Apply scaling
+        i_scale = frame.scales.i.slope
+        i_offset = frame.scales.i.offset
+        u_arr = frame.components["PIXEL"].planes[0] * i_scale + i_offset
+        
+        data[j, :, :] = u_arr
+    
+    set_file.close()
+    return data.astype(np.float32)
+
+
+def read_lavision_ims_pair(file_path: str, **kwargs) -> np.ndarray:
+    """Read LaVision .set file and return as frame pair."""
+    return read_lavision_ims(file_path, **kwargs)
+
+
+register_reader([".im7"], read_lavision_pair)
+register_reader([".set"], read_lavision_ims_pair)

pivtools_gui/image_handling/readers/registry.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import Callable, Dict, List
+
+# Registry for image readers
+_reader_registry: Dict[str, Callable] = {}
+
+
+def register_reader(extensions: List[str], reader_func: Callable):
+    """Register an image reader for specific file extensions."""
+    for ext in extensions:
+        _reader_registry[ext.lower()] = reader_func
+
+
+def get_reader(file_path: str) -> Callable:
+    """Get appropriate reader for a file based on its extension."""
+    ext = Path(file_path).suffix.lower()
+    if ext not in _reader_registry:
+        raise ValueError(f"No reader registered for file type: {ext}")
+    return _reader_registry[ext]
+
+
+def list_supported_formats() -> List[str]:
+    """List all supported file formats."""
+    return list(_reader_registry.keys())

pivtools_gui/masking/app/views.py

@@ -0,0 +1,123 @@
+from pathlib import Path
+
+import numpy as np
+from flask import Blueprint, jsonify, request
+
+from ...config import get_config
+from ...utils import camera_folder, camera_number
+from ...vector_loading import read_mask_from_mat, save_mask_to_mat
+
+masking_bp = Blueprint("masking", __name__)
+
+
+def _cfg():
+    return get_config()
+
+
+@masking_bp.route("/save_mask_array", methods=["POST"])
+def upload_mask():
+    """
+    Expects JSON with: meta (basePathIdx, camera, index, frame), width, height, data (flat mask), polygons (optional).
+    Saves mask as .mat file.
+    """
+    payload = request.get_json(silent=True) or {}
+    width, height, flat = (
+        payload.get("width"),
+        payload.get("height"),
+        payload.get("data"),
+    )
+    meta = payload.get("meta", {})
+    polygons = payload.get("polygons", None)
+
+    # Validate input
+    if not (
+        isinstance(width, int) and isinstance(height, int) and width > 0 and height > 0
+    ):
+        return jsonify({"error": "width and height must be positive integers"}), 400
+    if not (isinstance(flat, list) and len(flat) == width * height):
+        return jsonify({"error": "data must be a list of length width*height"}), 400
+
+    try:
+        mask = np.asarray(flat, dtype=bool).reshape((height, width))
+    except Exception as e:
+        return jsonify({"error": f"invalid mask data: {e}"}), 400
+
+    try:
+        basePathIdx = meta["basePathIdx"]
+        camera = meta["camera"]
+        cfg = _cfg()
+        source_paths = cfg.source_paths
+        try:
+            camera_num = camera_number(camera)
+        except Exception:
+            camera_num = camera
+        mask_path = source_paths[basePathIdx] / f"mask_{camera_folder(camera_num)}.mat"
+        save_mask_to_mat(mask_path, mask, np.asarray(polygons))
+    except Exception:
+        return jsonify({"error": "invalid or missing meta fields"}), 400
+
+    true_count = int(mask.sum())
+    return jsonify(
+        {
+            "status": "ok",
+            "shape": [height, width],
+            "true_count": true_count,
+            "fraction_true": true_count / (width * height),
+            "meta": meta,
+        }
+    )
+
+
+@masking_bp.route("/load_mask", methods=["GET"])
+def load_mask():
+    """
+    Loads a mask and polygon data from a .mat file.
+    Query params:
+      - path: full path to mask .mat file (preferred)
+      - basepath_idx, camera: optional, used to construct path if 'path' not given
+    Returns: { mask: [0|1,...], width, height, polygons: [...] }
+    """
+    cfg = _cfg()
+    path = request.args.get("path", default=None, type=str)
+    # Optionally reconstruct path if not provided
+    if not path or not Path(path).exists():
+        try:
+            basepath_idx = int(request.args.get("basepath_idx", 0))
+            camera = request.args.get("camera")
+            base_paths = cfg.source_paths
+            if basepath_idx < 0 or basepath_idx >= len(base_paths):
+                return jsonify({"error": "basepath_idx out of range"}), 400
+            camera = camera_number(camera)
+            mask_filename = f"mask_{camera_folder(camera)}.mat"
+            path = str(base_paths[basepath_idx] / mask_filename)
+        except Exception as e:
+            return jsonify({"error": f"Could not resolve mask path: {e}"}), 400
+
+    if not Path(path).exists():
+        return jsonify({"error": f"Mask file not found: {path}"}), 404
+
+    try:
+        mask, polygons = read_mask_from_mat(path)
+
+        def serialize_polygon(poly):
+            return {
+                "index": int(poly["index"]),
+                "name": str(poly["name"]),
+                "points": [list(map(float, pt)) for pt in poly["points"]],
+            }
+
+        polygons_serializable = [serialize_polygon(p) for p in polygons]
+        mask_arr = np.asarray(mask)
+        mask_flat = mask_arr.astype(np.uint8).flatten().tolist()
+        height, width = mask_arr.shape
+        return jsonify(
+            {
+                "mask": mask_flat,
+                "width": width,
+                "height": height,
+                "polygons": polygons_serializable,
+            }
+        )
+    except Exception as e:
+        print("Exception in load_mask:", e)
+        return jsonify({"error": f"Failed to load mask: {e}"}), 500

pivtools_gui/paths.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+
+
+def get_data_paths(
+    base_dir,
+    num_images,
+    cam,
+    type_name,
+    endpoint="",
+    use_merged=False,
+    use_uncalibrated=False,
+    calibration=False,  # New argument
+):
+    """
+    Construct directories for data, statistics, and videos.
+    endpoint: optional subfolder ('' ignored).
+    use_uncalibrated: if True, return paths for uncalibrated data
+    calibration: if True, return calibration directory
+    """
+    base_dir = Path(base_dir)
+    cam = f"Cam{cam}"
+    # Calibration data
+    if calibration:
+        calib_dir = base_dir / "calibration" / cam
+        if endpoint:
+            calib_dir = calib_dir / endpoint
+        return dict(calib_dir=calib_dir)
+    # Uncalibrated data
+    if use_uncalibrated:
+        data_dir = base_dir / "uncalibrated_piv" / str(num_images) / cam / type_name
+        stats_dir = (
+            base_dir / "statistics" / "uncalibrated" / str(num_images) / cam / type_name
+        )
+        video_dir = base_dir / "videos" / "uncalibrated" / str(num_images) / cam
+    # Merged data
+    elif use_merged:
+        data_dir = base_dir / "merged" / str(num_images) / cam / type_name
+        stats_dir = base_dir / "statistics" / "merged" / cam / type_name
+        video_dir = base_dir / "videos" / "merged" / cam / type_name
+    # Regular calibrated data
+    else:
+        data_dir = base_dir / "calibrated_piv" / str(num_images) / cam / type_name
+        stats_dir = base_dir / "statistics" / str(num_images) / cam / type_name
+        video_dir = base_dir / "videos" / str(num_images) / cam
+    if endpoint:
+        data_dir = data_dir / endpoint
+        stats_dir = stats_dir / endpoint
+        video_dir = video_dir / endpoint
+    return dict(data_dir=data_dir, stats_dir=stats_dir, video_dir=video_dir)

pivtools_gui/piv_runner.py

@@ -0,0 +1,261 @@
+"""
+PIV Runner: Subprocess-based execution for full computational performance.
+
+This module allows Flask to spawn PIV computations as separate subprocesses,
+avoiding GIL limitations and keeping the server responsive while maintaining
+full access to computational resources.
+"""
+import json
+import subprocess
+import sys
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger
+
+
+class PIVProcess:
+    """Manages a single PIV computation subprocess."""
+
+    def __init__(self, process: subprocess.Popen, job_id: str, log_file: Path):
+        self.process = process
+        self.job_id = job_id
+        self.log_file = log_file
+        self.start_time = datetime.now()
+        self.end_time: Optional[datetime] = None
+        self.return_code: Optional[int] = None
+        self._monitor_thread: Optional[threading.Thread] = None
+
+    def is_running(self) -> bool:
+        """Check if the process is still running."""
+        if self.process.poll() is None:
+            return True
+        # Process has terminated
+        if self.return_code is None:
+            self.return_code = self.process.returncode
+            self.end_time = datetime.now()
+        return False
+
+    def cancel(self) -> bool:
+        """Attempt to terminate the PIV process."""
+        if self.is_running():
+            try:
+                self.process.terminate()
+                # Give it 5 seconds to terminate gracefully
+                try:
+                    self.process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    # Force kill if it doesn't terminate
+                    self.process.kill()
+                    self.process.wait()
+                self.return_code = self.process.returncode
+                self.end_time = datetime.now()
+                logger.info(f"PIV job {self.job_id} cancelled")
+                return True
+            except Exception as e:
+                logger.error(f"Error cancelling PIV job {self.job_id}: {e}")
+                return False
+        return False
+
+    def get_status(self) -> dict:
+        """Get current status information."""
+        is_running = self.is_running()
+        elapsed = (
+            (self.end_time or datetime.now()) - self.start_time
+        ).total_seconds()
+
+        # Try to read recent log lines
+        log_tail = []
+        if self.log_file.exists():
+            try:
+                with open(self.log_file, "r") as f:
+                    log_tail = f.readlines()[-20:]  # Last 20 lines
+            except Exception as e:
+                logger.warning(f"Could not read log file: {e}")
+
+        return {
+            "job_id": self.job_id,
+            "running": is_running,
+            "start_time": self.start_time.isoformat(),
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "elapsed_seconds": elapsed,
+            "return_code": self.return_code,
+            "log_file": str(self.log_file),
+            "log_tail": log_tail,
+        }
+
+
+class PIVRunner:
+    """Manages PIV subprocess execution and tracking."""
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self.log_dir = project_root / "logs" / "piv_runs"
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        self.active_jobs: dict[str, PIVProcess] = {}
+        self._lock = threading.Lock()
+
+    def _generate_job_id(self) -> str:
+        """Generate a unique job ID."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        return f"piv_{timestamp}"
+
+    def _get_python_executable(self) -> str:
+        """Get the Python executable from the virtual environment."""
+        import platform
+        
+        # Check for virtual environment
+        if platform.system() == "Windows":
+            venv_python = self.project_root / "env" / "Scripts" / "python.exe"
+        else:
+            venv_python = self.project_root / "env" / "bin" / "python"
+        
+        if venv_python.exists():
+            return str(venv_python)
+        
+        # Also check for "piv" environment (legacy)
+        if platform.system() == "Windows":
+            venv_python = self.project_root / "piv" / "Scripts" / "python.exe"
+        else:
+            venv_python = self.project_root / "piv" / "bin" / "python"
+        
+        if venv_python.exists():
+            return str(venv_python)
+        
+        # Fallback to current Python
+        return sys.executable
+
+    def start_piv_job(
+        self,
+        cameras: Optional[list[int]] = None,
+        source_path_idx: int = 0,
+        base_path_idx: int = 0,
+        config_overrides: Optional[dict] = None,
+    ) -> dict:
+        """
+        Start a new PIV computation job as a subprocess.
+        
+        Note: Currently runs example.py which reads all settings from config.yaml.
+        The parameters are accepted for API compatibility but not yet used.
+        Future enhancement: Pass parameters via CLI args or environment variables.
+
+        Parameters
+        ----------
+        cameras : list[int], optional
+            List of camera numbers to process (future feature).
+        source_path_idx : int
+            Index of source path to use from config (future feature).
+        base_path_idx : int
+            Index of base path to use from config (future feature).
+        config_overrides : dict, optional
+            Configuration overrides to apply before running (future feature).
+
+        Returns
+        -------
+        dict
+            Job information including job_id and status.
+        """
+        job_id = self._generate_job_id()
+        log_file = self.log_dir / f"{job_id}.log"
+
+        # Build command - runs example.py which uses config.yaml
+        python_exe = self._get_python_executable()
+        script_path = self.project_root / "pypivtools" / "example.py"
+        cmd = [python_exe, str(script_path)]
+
+        # Open log file
+        log_handle = open(log_file, "w", buffering=1)  # Line buffered
+
+        try:
+            # Start subprocess
+            process = subprocess.Popen(
+                cmd,
+                stdout=log_handle,
+                stderr=subprocess.STDOUT,
+                cwd=str(self.project_root),
+                env=None,  # Inherit environment
+            )
+
+            piv_process = PIVProcess(process, job_id, log_file)
+
+            with self._lock:
+                self.active_jobs[job_id] = piv_process
+
+            logger.info(f"Started PIV job {job_id} with PID {process.pid}")
+
+            # Start a monitoring thread to clean up when done
+            def monitor():
+                process.wait()
+                log_handle.close()
+                logger.info(
+                    f"PIV job {job_id} completed with return code {process.returncode}"
+                )
+
+            monitor_thread = threading.Thread(target=monitor, daemon=True)
+            monitor_thread.start()
+            piv_process._monitor_thread = monitor_thread
+
+            return {
+                "status": "started",
+                "job_id": job_id,
+                "pid": process.pid,
+                "log_file": str(log_file),
+            }
+
+        except Exception as e:
+            log_handle.close()
+            logger.error(f"Failed to start PIV job: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def get_job_status(self, job_id: str) -> Optional[dict]:
+        """Get status of a specific job."""
+        with self._lock:
+            piv_process = self.active_jobs.get(job_id)
+            if piv_process:
+                return piv_process.get_status()
+        return None
+
+    def cancel_job(self, job_id: str) -> bool:
+        """Cancel a running job."""
+        with self._lock:
+            piv_process = self.active_jobs.get(job_id)
+            if piv_process:
+                return piv_process.cancel()
+        return False
+
+    def list_jobs(self) -> list[dict]:
+        """List all tracked jobs."""
+        with self._lock:
+            return [p.get_status() for p in self.active_jobs.values()]
+
+    def cleanup_finished_jobs(self, keep_recent: int = 10):
+        """Remove finished jobs from tracking, keeping only recent ones."""
+        with self._lock:
+            finished = [
+                (jid, p)
+                for jid, p in self.active_jobs.items()
+                if not p.is_running()
+            ]
+            # Sort by end time
+            finished.sort(key=lambda x: x[1].end_time or datetime.min, reverse=True)
+            # Remove all but the most recent
+            for jid, _ in finished[keep_recent:]:
+                del self.active_jobs[jid]
+
+
+# Global runner instance
+_runner: Optional[PIVRunner] = None
+
+
+def get_runner(project_root: Optional[Path] = None) -> PIVRunner:
+    """Get or create the global PIV runner instance."""
+    global _runner
+    if _runner is None:
+        if project_root is None:
+            # Try to infer from current file location
+            project_root = Path(__file__).parent.parent
+        _runner = PIVRunner(project_root)
+    return _runner