lvpyioTools 2.4.5__py3-none-any.whl

lvpyioTools/attribute.py

@@ -0,0 +1,105 @@
+from enum import StrEnum
+
+class FrameAttribute(StrEnum):
+    """
+    Enumeration of the different attributes of an ImageFrame object.
+    """
+    
+    ACQ_ATTRIBUTES_TRANSFORMED = "Acq.AttributesTransformed"
+    ACQ_CAMERA_ID = "Acq.Camera.ID"
+    """The ID of the camera used for the acquisition."""
+    ACQ_CAMERA_INDEX = "Acq.Camera.Index"
+    """Index of the camera used for the acquisition. This is an array."""
+    ACQ_CAMERA_LABEL = "Acq.Camera.Label"
+    """Label of the camera (i.e. Camera 1, Camera 2)."""
+    ACQ_TIME = "Acq.Time"
+    """Time of the acquisition of this frame. This is an array."""
+    ACQ_TIME_TO_TRIGGER = "Acq.TimeToTrigger"
+    """Time to trigger of the acquisition of this frame. This is an array."""
+    ACQ_TIME_SERIES = "AcqTimeSeries"
+    CCD_EXPOSURE_TIME = "CCDExposureTime"
+    """Exposure time of the camera. This is a string value with the unit."""
+    CAM_PIXEL_SIZE = "CamPixelSize"
+    """Pixel size of the camera. This is a string value with the unit."""
+    CAMERA_MAX_INTENSITY = "CameraMaxIntensity"
+    """Maximum intensity of the pixel values. This is a string value."""
+    CAMERA_MAX_NX = "CameraMaxNx"
+    """Maximum number of pixels in the x-direction. This is a string value."""
+    CAMERA_MAX_NY = "CameraMaxNy"
+    """Maximum number of pixels in the y-direction. This is a string value."""
+    CAMERA_NAME = "CameraName"
+    """Name of the camera."""
+    FRAME_PROCESSING = "FrameProcessing"
+    RGB_FRAME = "RGBFrame"
+    """Whenever this is a RGB frame or not. This is a string value of 0 or 1."""
+
+class BufferAttribute(StrEnum):
+    """
+    Enumeration of the different attributes of a Buffer object.
+    """
+    ACQ_INPUT_SPEED_SELECT = "Acq.Input.SpeedSelect"
+    ACQ_INPUT_START_TRIGGER = "Acq.Input.StartTrigger"
+    ACQ_STATUS_RECORD_POST = "Acq.Status.RecordPost"
+    ACQ_TIME_SERIES = "AcqTimeSeries"
+    CUSTOM_IMAGE_TAG_COUNT = "CustomImageTag_Count"
+    DEV_DATA_ALIAS0 = "DevDataAlias0"
+    DEV_DATA_ALIAS1 = "DevDataAlias1"
+    DEV_DATA_ALIAS2 = "DevDataAlias2"
+    DEV_DATA_ALIAS3 = "DevDataAlias3"
+    DEV_DATA_ALIAS4 = "DevDataAlias4"
+    DEV_DATA_CHANNEL0 = "DevDataChannel0"
+    DEV_DATA_CHANNEL1 = "DevDataChannel1"
+    DEV_DATA_CHANNEL2 = "DevDataChannel2"
+    DEV_DATA_CHANNEL3 = "DevDataChannel3"
+    DEV_DATA_CHANNEL4 = "DevDataChannel4"
+    DEV_DATA_CLASS0 = "DevDataClass0"
+    DEV_DATA_CLASS1 = "DevDataClass1"
+    DEV_DATA_CLASS2 = "DevDataClass2"
+    DEV_DATA_CLASS3 = "DevDataClass3"
+    DEV_DATA_CLASS4 = "DevDataClass4"
+    DEV_DATA_NAME0 = "DevDataName0"
+    DEV_DATA_NAME1 = "DevDataName1"
+    DEV_DATA_NAME2 = "DevDataName2"
+    DEV_DATA_NAME3 = "DevDataName3"
+    DEV_DATA_NAME4 = "DevDataName4"
+    DEV_DATA_SCALE0 = "DevDataScale0"
+    DEV_DATA_SCALE1 = "DevDataScale1"
+    DEV_DATA_SCALE2 = "DevDataScale2"
+    DEV_DATA_SCALE3 = "DevDataScale3"
+    DEV_DATA_SCALE4 = "DevDataScale4"
+    DEV_DATA_SCALE_I0 = "DevDataScaleI0"
+    DEV_DATA_SCALE_I1 = "DevDataScaleI1"
+    DEV_DATA_SCALE_I2 = "DevDataScaleI2"
+    DEV_DATA_SCALE_I3 = "DevDataScaleI3"
+    DEV_DATA_SCALE_I4 = "DevDataScaleI4"
+    DEV_DATA_X0 = "DevDataX0"
+    DEV_DATA_X1 = "DevDataX1"
+    DEV_DATA_X2 = "DevDataX2"
+    DEV_DATA_X3 = "DevDataX3"
+    DEV_DATA_X4 = "DevDataX4"
+    DEV_DATA_SOURCES = "DevDataSources"
+    DEV_DATA_TRACE0 = "DevDataTrace0"
+    DEV_DATA_TRACE1 = "DevDataTrace1"
+    DEV_DATA_TRACE2 = "DevDataTrace2"
+    DEV_DATA_TRACE3 = "DevDataTrace3"
+    DEV_DATA_TRACE4 = "DevDataTrace4"
+    EX_PATH_VALUE_F = "ExPathValue_f"
+    LOAD_FILE = "LoadFile"
+    """Source file of the buffer attributes and data. For `.im7` files this is the original `.im7` file for example."""
+    LOAD_SET = "LoadSet"
+    """Original set file from which this buffer was loaded. The extension (.set) is omitted."""
+    LOAD_SET_INDEX = "LoadSetIndex"
+    LOAD_SET_TYPE = "LoadSetType"
+    TIMESTAMP = "Timestamp"
+    """Timestamp in ISO format.
+    
+    See: https://en.wikipedia.org/wiki/ISO_8601
+    """
+    DAVIS_VERSION = "_DaVisVersion"
+    """DaVis version used to create the buffer."""
+    DATE = "_Date"
+    """Can be empty."""
+    HEADER_PACK_TYPE = "_Header_PackType"
+    TIME = "_Time"
+    """Can be empty. See Timestamp instead."""
+

lvpyioTools/calibration.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+from typing import Literal
+import xml.etree.ElementTree as ET
+
+from lvpyio.types.scale import Scale, Scales
+
+def _get_for_axis(scales, id: Literal['LinearScaleX', 'LinearScaleY', 'LinearScaleZ', 'LinearScaleI']):
+    linearScale = scales.find(id)
+    if linearScale is None:
+        raise ValueError(f"Could not find {id} in the calibration file.")
+
+    factor = linearScale.get("FactorMmPerPixel")
+    offset = linearScale.get("OffsetMm")
+    unit = linearScale.get("Unit")
+    description = linearScale.get("Description")
+    if factor is None or offset is None or unit is None:
+        raise ValueError(f"Could not find FactorMmPerPixel, OffsetMm, or Unit in the calibration file for {id}.")
+    
+    return Scale(slope=float(factor), offset=float(offset), unit=unit, description=description)
+
+
+def get_calibration(calibration_file: Path) -> Scales:
+    """
+    Get the calibration settings from the given calibration file which should be a XML file. Values are rounded to fit the calibration application of DaVis.
+
+    Args:
+        calibration_file (Path): Calibration file in XML format.
+
+    Returns:
+        Scales: A `Scales` object containing the calibration settings for x, y, z, and i axes.
+    """
+    # Read and parse the XML file
+    tree = ET.parse(calibration_file)
+    root = tree.getroot()
+    # Search for "Scales" in the XML file
+    scales = root.find(".//Scales")
+
+    x = _get_for_axis(scales, id='LinearScaleX')
+    y = _get_for_axis(scales, id='LinearScaleY')
+    z = _get_for_axis(scales, id='LinearScaleZ')
+    i = _get_for_axis(scales, id='LinearScaleI')
+
+    return Scales(x, y, z, i)

lvpyioTools/frame.py

@@ -0,0 +1,132 @@
+"""
+Helper class for working lvpyio frames retrieved from a set.
+"""
+
+from typing import TYPE_CHECKING
+from enum import StrEnum
+
+from lvpyio.types.frame import ImageFrame
+from lvpyio.types.scale import Scales
+
+from .attribute import FrameAttribute
+if TYPE_CHECKING:
+    from .set import LVSet
+
+class LVFrame():
+    """
+    Wrapper class for working with lvpyio frames retrieved from a set. This class provides a convenient interface to access frame attributes, image data, and scale information.
+    """
+    def __init__(self, frame: ImageFrame, set: 'LVSet'):
+        self.frame = frame
+        self.set = set
+
+    def replace_frame(self, new_frame: ImageFrame):
+        """
+        Update the current frame with a new frame. Notably used for performance reasons to not create a new LVFrame object for each frame in a set.
+
+        Args:
+            new_frame (ImageFrame): The new frame to update with.
+        """
+        self.frame = new_frame
+
+    def __len__(self):
+        return len(self.frame.images)
+
+    def __repr__(self):
+        return f"<LVFrame: {len(self.frame.images)} images, shape={self.frame.shape}>"
+
+    def shape(self):
+        """
+        Get the images and masks shapes.
+
+        Returns:
+            tuple: A tuple containing the shapes of the images and masks.
+        """
+        return self.frame.shape
+
+    def get(self, image_number: int = 0):
+        """
+        Read the image data from a specific frame and image number.
+
+        Args:
+            image_number (int, optional): The index of the image to retrieve. Defaults to 0.
+
+        Raises:
+            IndexError: If the image_number is out of range.
+
+        Returns:
+            numpy.ndarray: The image data as a NumPy array.
+        """
+        if image_number < 0 or image_number >= len(self.frame.images):
+            raise IndexError(f"Image number {image_number} is out of range. Available images: 0 to {len(self.frame.images)-1}.")
+        return self.frame.images[image_number]
+
+    def show(self, image_number: int = 0, 
+             vmin: float | None = None, vmax: float | None = None,
+             cmap: str = 'gray',
+             _show: bool = True):
+        """
+        Display the image data from a specific frame and image number using the default image viewer.
+
+        Args:
+            image_number (int, optional): The index of the image to display. Defaults to 0.
+        """
+        import matplotlib.pyplot as plt
+        image_data = self.get(image_number)
+        fig, ax = plt.subplots()
+        ax.imshow(image_data, cmap=cmap, vmin=vmin, vmax=vmax)
+        ax.axis('off')
+        plt.tight_layout()
+        if _show:
+            plt.show()
+        return fig, ax
+
+    def scale(self) -> Scales:
+        """
+        Read the scale information from the frame, that is a class containing the following attributes:
+        - `x`: The scale in the x-direction (in meters per pixel).
+        - `y`: The scale in the y-direction (in meters per pixel).
+        - `z`: The scale in the z-direction (in meters per pixel).
+        - `i`: The scale in the intensity direction (generally with a slope of 1).
+
+        Each attributes are `Scale` objects, which contain the following attributes:
+        - `slope`: The slope of the scale
+        - `offset`: The offset of the scale
+        - `unit`: The unit of the scale (mm, counts, etc.)
+        - `description`: Mostly just empty
+
+        Returns:
+            Scales: A `Scales` object containing the scale information for the frame.
+        """
+        return self.frame.scales
+
+    def get_attribute(self, attribute: FrameAttribute):
+        """
+        Get a specific attribute from the frame.
+
+        Args:
+            attribute (FrameAttribute): The attribute to retrieve.
+        
+        Returns:
+            Any: The value of the requested attribute, or `None` if the attribute is not found in the frame.
+        """
+        return self.frame.attributes.get(attribute.value, None)
+    
+    def get_max_intensity(self):
+        """
+        Get the maximum intensity of the pixel values from the frame.
+
+        Raises:
+            ValueError: If the CAMERA_MAX_INTENSITY attribute is not found or is invalid.
+
+        Returns:
+            float: The maximum intensity value of the pixel values from the frame.
+        """
+        max_intensity = self.get_attribute(FrameAttribute.CAMERA_MAX_INTENSITY)
+        if max_intensity is not None:
+            try:
+                return float(max_intensity)
+            except ValueError:
+                raise ValueError(f"Invalid CAMERA_MAX_INTENSITY value: {max_intensity}")
+        else:
+            raise ValueError("CAMERA_MAX_INTENSITY attribute not found in frame.")

lvpyioTools/set.py

@@ -0,0 +1,397 @@
+"""
+Helper class for working with lvpyio sets.
+"""
+from pathlib import Path
+from typing import Any
+import warnings
+
+from PIL import Image
+
+import lvpyio as lv
+# from lvpyio.types
+from lvpyio.types.frame import ImageFrame
+from lvpyio.types.buffer import Buffer
+from lvpyio.types.scale import Scales
+from lvpyio.io.set import Set
+
+from . import setParser, calibration
+from .frame import LVFrame
+
+
+
+
+class LVSet(): # numpydoc ignore=SA01
+    """
+    Helper class for working with DaVis sets. 
+    
+    Set files are simple text files that contain some generic information that were saved on creation. They don't give any information about the actual data, where it is stored, or how to read it but the folder placed in the same directory as the set file contains all the data.
+
+    This provides a simple interface to easily manipulate and read the set files.
+
+    A set of images is handled this way in DaVis:
+    1. buffer (set[buffer_frame])
+    2. frame (set[buffer_frame][frame_number])
+    3. image (set[buffer_frame][frame_number].images[image_number])
+
+    Parameters
+    ----------
+        file (Path): The path to the .set file.
+
+    Examples
+    --------
+
+    ```python
+        from lvpyioTools.sets import LVSet
+        from pathlib import Path
+
+        set_file = Path("example/example.set")
+        with LVSet(set_file) as set:
+            set.show()
+            print(f"Number of frames in the set: {len(set)}")
+    ```
+    """
+    set: Set | None = None
+    frames: tuple[LVFrame, ...] | None = None
+
+    def __init__(self, file: Path):
+        # verify provided file
+        if not file.exists():
+            raise FileNotFoundError(f"File {file} does not exist.")
+        if not file.is_file():
+            raise ValueError(f"Provided path {file} is not a file.")
+        if not file.suffix in [".set", ".exp"]:
+            raise ValueError(f"Provided file {file} is not a .set or .exp file.")
+
+        self.file = file
+        self.properties = self.get_properties()
+
+    def __repr__(self):
+        if self.is_experiment():
+            return f"<LVSet: {self.file.name}, experiment set, properties={len(self.properties)}>"
+        if self.is_open():
+            return f"<LVSet: {self.file.name}, {len(self)} frames, properties={len(self.properties)}>"
+        return f"<LVSet: {self.file.name}, closed, properties={len(self.properties)}>"
+
+
+## LOADER / SAVER
+
+    def __enter__(self):
+        """
+        Context manager entry point.
+
+        Returns:
+            LVSet: The current instance of LVSet.
+        """
+        self.open()
+        return self
+    
+    def __exit__(self, *args):
+        """
+        Safeguard to make sure the set gets closed.
+        """
+        self.close()
+
+    def __del__(self):
+        """
+        Safeguard to make sure the set gets closed.
+        """
+        self.close()
+
+    def is_open(self) -> bool:
+        """
+        Check if the set is currently open.
+
+        Returns:
+            bool: True if the set is open, False otherwise.
+        """
+        return self.set is not None
+
+    def open(self):
+        """
+        Load the set with lvpyio.
+        """
+        # safeguard to ensure we properly close the set
+        self.close()
+        if self.is_experiment():
+            raise ValueError(f"Cannot open an experiment set (`.exp`) directly.")
+        self.set = lv.read_set(self.file)
+
+    def close(self):
+        """
+        Close the currently opened set. If no set is open, this method does nothing.
+        """
+        if self.set is None:
+            return
+        self.set.close()
+        self.set = None
+
+
+## PARENTS / CHILDREN
+
+    def is_experiment(self) -> bool:
+        """
+        Check if the set is an experiment set (`.exp`).
+        """
+        return self.file.suffix == ".exp"
+
+    def get_parent(self) -> 'LVSet | None':
+        """
+        Retrieve parent set holding this current set if exists. If the current set is an experiment set, it has no parent and this method will return None.
+
+        Returns:
+            LVSet | None: The parent set if it exists, otherwise None.
+        """
+        isParent = self.is_experiment()
+        if isParent:
+            return None
+
+        # get parent theorical path
+        set_dir = self.file.parent
+        parent_dir = set_dir.parent
+
+        # find .set or .exp file if exists
+        for suffix in [".set", ".exp"]:
+            # try to access the set file
+            parent_set_file = parent_dir / (set_dir.name + suffix)
+            if parent_set_file.exists():
+                return LVSet(parent_set_file)
+
+        return None
+    
+    def get_experiment(self, max_iteration: int = 100) -> 'LVSet | None':
+        """
+        Retrieve the experiment set holding this current set if exists.
+
+        Args:
+            max_iteration (int, optional): Maximum number of iterations to search for the experiment set. Defaults to 100.
+
+        Returns:
+            LVSet | None: The experiment set if it exists, otherwise None.
+        """
+        current_set = self
+        iteration = 0
+        while current_set is not None:
+            if current_set.is_experiment():
+                return current_set
+            current_set = current_set.get_parent()
+
+            # stop after too many iterations to avoid infinite loops
+            iteration += 1
+            if iteration > max_iteration:
+                warnings.warn(f"Reached maximum iteration ({max_iteration}) while searching for experiment set. Stopping search.")
+                break
+        return None
+    
+    def get_children(self) -> list['LVSet']:
+        """
+        Retrieve all child sets of the current set.
+
+        Returns:
+            list[LVSet]: A list of child sets.
+        """
+        children = []
+        set_dir = self.file.parent
+        for child_dir in set_dir.iterdir():
+            if child_dir.is_dir():
+                for suffix in [".set", ".exp"]:
+                    child_set_file = child_dir / (child_dir.name + suffix)
+                    if child_set_file.exists():
+                        children.append(LVSet(child_set_file))
+        return children
+    
+    def get_calibration(self) -> 'Scales | None':
+        """
+        Retrieve the calibration settings from the experiment set if it exists.
+
+        Returns:
+            Scales | None: The calibration settings if they exist, otherwise None.
+        """
+        experiment = self.get_experiment()
+        if experiment is None:
+            warnings.warn(f"No experiment set found for {self.file}. Cannot retrieve calibration.")
+            return None
+
+        # get calibration file
+        calibration_file = experiment.file.with_suffix("") / "Properties" / "Calibration" / "Calibration.xml"
+        if not calibration_file.exists():
+            warnings.warn(f"Calibration file {calibration_file} does not exist. Cannot retrieve calibration.")
+            return None
+        
+        return calibration.get_calibration(calibration_file)
+
+
+## GENERIC INFORMATION ABOUT THE SET
+
+    def __len__(self):
+        """
+        Return the number of frames in the set.
+        
+        Returns:
+            int: The number of frames in the set.
+
+        Raises:
+            RuntimeError: Set is not open.
+        """
+        if self.set is None:
+            raise RuntimeError("Set is not open. Please call 'open()' before accessing the length.")
+        return len(self.set)
+
+    def read(self) -> str:
+        """
+        Read the set file and display its content.
+        """
+        with open(self.file, 'r') as f:
+            return f.read().strip()
+
+    def get_properties(self) -> dict[setParser.SetProperty, Any]:
+        """
+        Read the set file and return its properties as a dictionary.
+
+        Returns:
+            dict[SetProperty, Any]: A dictionary containing the set properties and their values.
+        """
+        return setParser.read(self.file)
+
+
+## READERS
+
+    def get_buffer(self, buffer_frame: int) -> Buffer:
+        """
+        Get a specific buffer from the set.
+
+        Args:
+            buffer_frame (int): The index of the buffer frame to retrieve.
+
+        Raises:
+            RuntimeError: Set is not open.
+            IndexError: Buffer frame index is out of range.
+
+        Returns:
+            Buffer: The requested buffer object.
+        """
+        # verify set is open
+        if self.set is None:
+            raise RuntimeError("Set is not open. Please call `open()` before accessing buffers.")
+        
+        size = len(self)
+        if buffer_frame < 0 or buffer_frame >= size:
+            raise IndexError(f"Buffer frame index {buffer_frame} is out of range. Valid range is 0 to {size - 1}.")
+        return self.set[buffer_frame]
+
+    def get_frames(self, buffer_frame: int) -> tuple[LVFrame, ...]:
+        buffer = self.get_buffer(buffer_frame)
+        
+        # init LVFrame instances for each frame in the buffer
+        if self.frames is None:
+            frames_count = len(buffer)
+            self.frames = tuple(LVFrame(buffer[i], self) for i in range(frames_count))
+
+        # if already exists, then simply replace the frames in the existing LVFrame instances
+        else:
+            for i in range(len(buffer)):
+                self.frames[i].replace_frame(buffer[i])
+
+        return self.frames
+
+    def get_frame(self, buffer_frame: int, frame_number: int = 0) -> LVFrame:
+        """
+        Get a specific frame from a buffer in the set.
+
+        Args:
+            buffer_frame (int): The index of the buffer frame to retrieve the frame from.
+            frame_number (int, optional): The index of the frame within the buffer. Defaults to 0.
+
+        Returns:
+            LVFrame: The requested frame object.
+        """
+        frames = self.get_frames(buffer_frame)
+        if frame_number < 0 or frame_number >= len(frames):
+            raise IndexError(f"Frame number {frame_number} is out of range. Valid range is 0 to {len(frames) - 1}.")
+        return frames[frame_number]
+
+    def get_image(self, buffer_frame: int, 
+                  frame_number: int = 0, 
+                  image_number: int = 0):
+        """
+        Get a specific image from a frame in a buffer in the set.
+
+        Args:
+            buffer_frame (int): The index of the buffer frame to retrieve the image from.
+            frame_number (int, optional): The index of the frame within the buffer. Defaults to 0.
+            image_number (int, optional): The index of the image within the frame. Defaults to 0.
+
+        Returns:
+            Image: The requested image object.
+        """
+        frame = self.get_frame(buffer_frame, frame_number)
+        return frame.get(image_number)
+
+
+## EXPORTS
+
+    def export(self, output_dir: Path, extension: str = ".tif"):
+        if not self.is_open():
+            raise RuntimeError("Set is not open. Please call `open()` before exporting.")
+        output_dir.mkdir(parents=True, exist_ok=True)
+        for buffer_frame in range(len(self)):
+            image = self.get_image(buffer_frame)
+            output_file = output_dir / f"buffer_{buffer_frame:05d}{extension}"
+            img = Image.fromarray(image)
+            img.save(output_file)
+
+
+## TEST SCRIPTS
+
+if __name__ == "__main__":
+    from pprint import pprint
+    # Example usage
+    set_file = Path("example/example.set")
+    print(set_file)
+    with LVSet(set_file) as set:
+        pprint(set.get_properties())
+        print(f"Number of frames in the set: {len(set)}")
+
+    print()
+
+    outside_set = Path("/media/scadet03/CADET_MAIN/Manips/2025-10/data.2025-10.piv/DaVis/Upstream/jonc_2/f=0.7, S0=0.05, d=0.06, N=5.0/1/1.set")
+    print(outside_set)
+    with LVSet(outside_set) as set:
+        pprint(set.get_properties())
+        print(f"Number of frames in the set: {len(set)}")
+
+        frame = set.get_frame(0)
+        print(frame)
+
+    print()
+
+    outside_set = Path("/media/scadet03/CADET_MAIN/Manips/2025-10/data.2025-10.piv/temporary_calibration_ref_data/jonc_1/f=0.8, S0=0.05, d=0.06, N=1.0/Scale.set")
+    print(outside_set)
+    with LVSet(outside_set) as set:
+        pprint(set.get_properties())
+        print(f"Number of frames in the set: {len(set)}")
+
+        buffer = set.get_buffer(0)
+        frame = set.get_frame(0)
+        print(frame)
+
+    print()
+
+    outside_set = Path("/media/scadet03/CADET_MAIN/Manips/2025-10/data.2025-10.piv/DaVis/Upstream/jonc_1/f=0.7, S0=0.05, d=0.06, N=1.0/1/1.set")
+    print(outside_set)
+    with LVSet(outside_set) as set:
+        print(set)
+        print(f"Number of frames in the set: {len(set)}")
+
+        buffer = set.get_buffer(0)
+        frame = set.get_frame(0)
+        print(frame)
+
+        parent = set.get_parent()
+        print(parent.file if parent is not None else "No parent set found.")
+
+        experiment = set.get_experiment()
+        print(experiment)
+        print(experiment.file if experiment is not None else "No experiment set found.")
+
+        calib = set.get_calibration()
+        print(calib)

lvpyioTools/setParser.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+from typing import Any
+import warnings
+
+from .setProperties import SetProperty, property_types
+
+
+_PROPERTY_PATTERN = r"(?P<property>\w+) = \"?(?P<value>[\S\s]*?)\"?;"
+
+
+def read_property(key: str, value: str):
+    """
+    Read a property from the set file and convert it to the appropriate type and property key.
+
+    Args:
+        key (str): The property key from the set file.
+        value (str): The property value from the set file.
+
+    Returns:
+        tuple[SetProperty | None, Any]: A tuple containing the property key as a `SetProperty` enum member (or `None` if unknown) and the converted property value (or `None` if conversion failed).
+    """
+    try:
+        prop = SetProperty(key)
+    except ValueError:
+        warnings.warn(f"Unknown property '{key}' found in the set file.")
+        return None, None
+
+    # convert to type
+    prop_type = property_types.get(prop, None)
+    if prop_type is None:
+        warnings.warn(f"Unknown property '{key}' found in the set file.")
+    else:
+        try:
+            value = prop_type(value)  # convert to the appropriate type
+        except Exception as e:
+            warnings.warn(f"Error converting property '{key}' with value '{value}': {e}")
+            return None, None
+
+    return prop, value
+
+def read(file: Path) -> dict[SetProperty, Any]:
+    """
+    Read the contents of a file.
+
+    Args:
+        file (Path): The path to the file to read.
+
+    Returns:
+        dict[SetProperty, Any]: A dictionary containing the set properties and their values.
+    """
+    with open(file, 'r') as f:
+        content = f.read().strip()
+    lines = content.splitlines()
+
+    # identify line with "#GROUP Sets"
+    group_line_index = None
+    for i, line in enumerate(lines):
+        if line.strip() == "#GROUP Sets":
+            group_line_index = i
+            break
+    
+    if group_line_index is None:
+        raise ValueError("The file does not contain a '#GROUP Sets' line.")
+    
+    # extract lines after "#GROUP Sets"
+    set_lines = lines[group_line_index + 1:]
+
+    import re
+    set_dict = {}
+    for line in set_lines:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue  # skip empty lines and comments
+        match = re.match(_PROPERTY_PATTERN, line)
+        if match:
+            key = match.group('property')
+            value = match.group('value')
+
+            prop, value = read_property(key, value)
+            if prop is None:
+                continue
+
+            set_dict[prop] = value
+    return set_dict
+
+
+
+if __name__ == "__main__":
+    from pprint import pprint
+    examples = Path("example")
+    
+    for set_file in examples.rglob("*.set"):
+        print(set_file)
+        set_dict = read(set_file)
+        pprint(set_dict)
+
+        if SetProperty.SetTime in set_dict:
+            print(f"SetTime: {set_dict[SetProperty.SetTime].isoformat()}")
+
+
+    outside_set = Path("/media/scadet03/CADET_MAIN/Manips/2025-10/data.2025-10.piv/temporary_calibration_ref_data/jonc_1/f=0.8, S0=0.05, d=0.06, N=1.0/Scale.set")
+    print(outside_set)
+    set_dict = read(outside_set)
+    pprint(set_dict)

lvpyioTools/setProperties.py

@@ -0,0 +1,113 @@
+from enum import Enum, StrEnum
+from datetime import datetime
+import locale, warnings
+
+def _read_date(value: str) -> datetime | None:
+    """
+    Read the .set file date format and convert into datetime object.
+    The date uses english format, e.g. "Fri Sep 26 11:25:26 2025",
+    so conversion to a specific locale is needed to ensure correct parsing regardless of the system locale.
+
+    See:
+    https://stackoverflow.com/questions/38303217/datetime-strptime-unexpected-behavior-locale-issue
+
+    Args:
+        value (str): The date string from the .set file.
+
+    Returns:
+        datetime | None: The corresponding datetime object, or `None` if parsing failed.
+    """
+    try:
+        # use 'C' locale to ensure parsing works regardless of system locale
+        old_locale = locale.setlocale(locale.LC_TIME)
+        try:
+            locale.setlocale(locale.LC_TIME, 'C')
+            return datetime.strptime(value, "%a %b %d %H:%M:%S %Y")
+        finally:
+            # restore original locale
+            try:
+                locale.setlocale(locale.LC_TIME, old_locale)
+            except locale.Error:
+                # restoration fails, just proceed
+                pass
+    except ValueError:
+        warnings.warn(f"Could not parse date from value '{value}'")
+        return None
+
+
+
+class SetType(Enum):
+    """
+    Classifications of the different values of the `SetType` property.
+    """
+    IMAGE = 256
+    """`.im7` images"""
+    VECTORS = 512
+    """`.vc7` files"""
+    CINE = 4352
+    """`.cine` file"""
+    PROPERTIES = 8192
+    """`Properties` folder"""
+    FOLDER = 16384
+    """Simple folder"""
+    CALIBRATION = 131072
+    """Calibration set"""
+
+def _read_set_type(value: str) -> SetType | None:
+    """
+    Convert a string value to a `SetType` enum member.
+
+    Args:
+        value (str): The string representation of the set type, which is expected to be an integer in string format.
+
+    Returns:
+        SetType: The corresponding `SetType` enum member.
+    """
+    # convert to int
+    try:
+        value_int = int(value)
+    except ValueError:
+        warnings.warn(f"Could not convert value '{value}' to int for SetType")
+        return None
+    
+    # try to convert to SetType
+    try:
+        return SetType(value_int)
+    except ValueError:
+        warnings.warn(f"Unknown SetType value '{value_int}'")
+        return None
+
+class SetProperty(StrEnum):
+    """
+    Definitions of the different properties that can be found in a set file.
+    """
+    SetType = "SetType"
+    SetGroups = "SetGroups"
+    SetTime = "SetTime"
+    SetComments = "SetComments"
+    SetStart = "SetStart"
+    SetInc = "SetInc"
+    SetSourceSet = "SetSourceSet"
+    SetViewCallback = "SetViewCallback"
+    SetLoadCallback = "SetLoadCallback"
+    bpInfoString = "bpInfoString"
+    SetIdentifier = "SetIdentifier"
+
+
+property_types = {
+    SetProperty.SetType: _read_set_type,
+    SetProperty.SetGroups: str,
+    SetProperty.SetTime: _read_date,
+    SetProperty.SetComments: str,
+    SetProperty.SetStart: int,
+    SetProperty.SetInc: int,
+    SetProperty.SetSourceSet: str,
+    SetProperty.SetViewCallback: str,
+    SetProperty.SetLoadCallback: str,
+    SetProperty.bpInfoString: str,
+    SetProperty.SetIdentifier: str,
+}
+"""Associate each SetProperty to a function or type for convertion to a specific type."""
+
+if __name__ == "__main__":
+    print(SetType(256))

lvpyioTools/viewer.py

@@ -0,0 +1,30 @@
+"""
+Show a specific image from a DaVis set file.
+"""
+from pathlib import Path
+
+from .set import LVSet
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="LVPyIO Tools Viewer")
+    parser.add_argument("set", type=str, help="Path to the DaVis set file")
+    parser.add_argument("--buffer", type=int, default=0, help="Buffer frame number to display (default: 0)")
+    parser.add_argument("--frame", type=int, default=0, help="Frame number to display (default: 0)")
+    parser.add_argument("--image", type=int, default=0, help="Image number to display (default: 0)")
+    parser.add_argument("--vmin", type=float, default=None, help="Minimum value for image display (default: None)")
+    parser.add_argument("--vmax", type=float, default=None, help="Maximum value for image display (default: None)")
+    parser.add_argument("--cmap", type=str, default='gray', help="Colormap for image display (default: 'gray')")
+    args = parser.parse_args()
+
+    with LVSet(Path(args.set)) as lv_set:
+        try:
+            frame = lv_set.get_frame(args.buffer, args.frame)
+            frame.show(image_number=args.image, 
+                       vmin=args.vmin, vmax=args.vmax, 
+                       cmap=args.cmap)
+        except IndexError as e:
+            print(f"Error: {e}")
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")

lvpyiotools-2.4.5.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: lvpyioTools
+Version: 2.4.5
+Summary: A set of tools to handle LabView files and data via the lvpyio library.
+Author-email: SimKDT <simon.cadet79+github@proton.me>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SimKDT/lvpyio-tools
+Project-URL: Issues, https://github.com/SimKDT/lvpyio-tools/issues
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12.3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: Pillow
+Requires-Dist: lvpyio>=1.4.0
+Dynamic: license-file
+
+# lvpyio-tools
+
+![License](https://img.shields.io/github/license/SimKDT/lvpyio-tools?label=License)
+![Downloads](https://img.shields.io/github/downloads/SimKDT/lvpyio-tools/total?label=Downloads)
+![Code Size](https://img.shields.io/github/languages/code-size/SimKDT/lvpyio-tools?label=Code%20Size)
+![PyPi Version](https://img.shields.io/pypi/v/lvpyio-tools)
+
+A collection of tools to manipulate lvpyio objects such as Sets.
+
+## Installation
+
+<details open>
+<summary>PyPi</summary>
+
+```bash
+pip install lvpyio-tools
+```
+</details>
+
+<details>
+<summary>Git</summary>
+
+```bash
+pip install git+https://github.com/SimKDT/lvpyio-tools.git
+```
+</details>
+
+<details>
+<summary>Local</summary>
+
+```bash
+pip install .
+```
+</details>
+
+## Usage
+
+```python
+from pathlib import Path
+from lvpyioTools.set import LVSet
+
+set_file = Path("path/to/your/set.set")
+with LVSet(set_file) as lv_set:
+    print(lv_set)
+    print(f"Number of frames: {len(lv_set)}")
+    print(f"Properties: {lv_set.properties}")
+```
+
+## Doc (build)
+```bash
+make html
+```
+
+Serving the documentation locally:
+```bash
+make serve
+```
+
+## License
+See [LICENSE](LICENSE) for details.

lvpyiotools-2.4.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+lvpyioTools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lvpyioTools/attribute.py,sha256=R8n-yJqGqVSJnCG4XadYZNfh4z_lq1aNQp4bm6oGzOc,4202
+lvpyioTools/calibration.py,sha256=rhSEuzR2_73upX2IIKKTDpifUTmx6DeHcopVkl-_QNo,1639
+lvpyioTools/frame.py,sha256=m408OXZmZ1PX5WiNT7UkNKY_KDSVGxCOvM28yk-vqDs,4685
+lvpyioTools/set.py,sha256=yoJGul3k07fJWyzF6jT5sRSj1I24KqqbiERWqGRX4MQ,12921
+lvpyioTools/setParser.py,sha256=saQDAoHePYUt6TbuWtwmYReK2CoT9iMYo1-gU3MV1hA,3140
+lvpyioTools/setProperties.py,sha256=FOLo9VHzzx4dGHzQ-agKJlB8WqOeEBa3AGB8wL5iQaw,3372
+lvpyioTools/viewer.py,sha256=gXaljfftPAX8SHmwSHVoCpdB2VvbGHgPv2SR0dNT-nc,1384
+lvpyiotools-2.4.5.dist-info/licenses/LICENSE,sha256=dXpnFFNJDdreUeL3TbqHT1ndbbeDjzwmQLslFgl6h84,1054
+lvpyiotools-2.4.5.dist-info/METADATA,sha256=GSwRfEzATFJcSt-WOWiCospmlqU3Lxzayo_0tYIxnbw,1736
+lvpyiotools-2.4.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lvpyiotools-2.4.5.dist-info/entry_points.txt,sha256=42n7kQJZeSkd2m7gvdhBdEnO-3-vqsNMS0J_kEW-spk,55
+lvpyiotools-2.4.5.dist-info/top_level.txt,sha256=OCJnQiLKSAfJbC1jdexsEZPnzZ-W9QTOS2LXHtyUG_8,12
+lvpyiotools-2.4.5.dist-info/RECORD,,

lvpyiotools-2.4.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lvpyiotools-2.4.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lvpyioShow = lvpyioTools.viewer:main

lvpyiotools-2.4.5.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Simon Cadet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

lvpyiotools-2.4.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+lvpyioTools