VTKio 0.1.0.dev8__tar.gz → 0.1.0.dev9__tar.gz

{vtkio-0.1.0.dev8 → vtkio-0.1.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: VTKio
-Version: 0.1.0.dev8
+Version: 0.1.0.dev9
 Summary: A simple package for converting data between VTK files (XML and HDF5) and NumPy arrays.
 Project-URL: Homepage, https://jpmorr.gitlab.io/vtkio
 Project-URL: Documentation, https://jpmorr.gitlab.io/vtkio

{vtkio-0.1.0.dev8 → vtkio-0.1.0.dev9}/examples/ImageData.py

@@ -76,7 +76,7 @@ field_data = {'TimeValue': 0.122654987}
 
 ## new version
 # --8<-- [start:write_imagedata_writer_ascii]
-from vtkio.writer.xml import XMLImageDataWriter
+from vtkio.writer.xml_writer import XMLImageDataWriter
 
 
 file = XMLImageDataWriter('test_uniform_image_data.vti',

{vtkio-0.1.0.dev8 → vtkio-0.1.0.dev9}/examples/PolyData.py

@@ -83,7 +83,7 @@ offsets = np.arange(start=1, stop=npoints + 1, dtype="int32")  # index of last n
 
 #%% write with xml base writer
 # --8<-- [start:write_points_data_ascii]
-from vtkio.writer.xml import XMLPolyDataWriter
+from vtkio.writer.xml_writer import XMLPolyDataWriter
 
 # Write the file using the xml writer class
 file = XMLPolyDataWriter('test_points_polydata.vtp',
@@ -212,8 +212,6 @@ poly_verts_data = read_vtkxml_data('../TestData/vtp/polytest.vtp')
 lines_data = read_vtkxml_data('../TestData/vtp/ibm_with_data.vtp')
 cow_data = read_vtkxml_data('../TestData/vtp/cow.vtp')
 
-map_data_base_64 = read_vtkxml_data('map_base64_ref.vtp')
-
 write_vtp('plate_vectors', points=plate_data.points,
           polys=(plate_data.polys.connectivity, plate_data.polys.offsets),
           point_data={"vectors": plate_data.point_data}, field_data=fielddata)
@@ -225,17 +223,7 @@ write_vtp('cow2', points=cow_data.points,
 write_vtp('map', points=map_data.points,
           lines=(map_data.lines.connectivity, map_data.lines.offsets),
           cell_data={"vectors": map_data.cell_data},
-          field_data=fielddata, encoding='ascii')
-
-write_vtp('map_base64', points=map_data.points,
-          lines=(map_data.lines.connectivity, map_data.lines.offsets),
-          cell_data={"vectors": map_data.cell_data},
-          field_data=fielddata, encoding='binary')
-
-write_vtp('map_appended', points=map_data.points,
-          lines=(map_data.lines.connectivity, map_data.lines.offsets),
-          cell_data={"vectors": map_data.cell_data},
-          field_data=fielddata, encoding='appended')
+          field_data=fielddata)
 
 write_vtp('polytest', points=poly_verts_data.points,
           verts=(poly_verts_data.verts.connectivity, poly_verts_data.verts.offsets),
@@ -287,14 +275,11 @@ points[9, :] = 2.0, 0.0, 3.0
 # Some point variables
 pressure = np.random.rand(npoints)
 temp = np.random.rand(npoints)
-scales = np.random.rand(5)
-point_scales = np.array([scales,scales]).T.flatten()
 
 # some line variables (cell data)
 vel = np.arange(5) + 1
 
-point_data = {"temp": temp, "pressure": pressure, "point_scales": point_scales}
-cell_data = {"velocity": vel, "cell_scales": scales}
+point_data = {"temp": temp, "pressure": pressure}
 
 # --8<-- [end:create_lines_dataset]
 
@@ -311,7 +296,7 @@ offsets = (np.arange(num_lines) + 1) * 2
 write_vtp('test_lines_polydata_appended_encoded',
           points=points, lines=(connectivity, offsets),
           point_data=point_data,
-          cell_data=cell_data,
+          cell_data={'velocity': vel},
           field_data=None,
           encoding='appended')
 
@@ -322,15 +307,15 @@ write_vtp('test_lines_polydata_appended_encoded',
 from vtkio.simplified import lines_to_poly
 
 lines_to_poly('line_test', points,
-              point_data=point_data,
-              cell_data=cell_data,
+              point_data={"1_temp": temp, "2_pressure": pressure},
+              cell_data={'velocity': vel},
               fieldData=None, encoding='ascii')
 
-lines_to_poly('line_test_binary', points, point_data=point_data,
-                cell_data=cell_data, fieldData=None, encoding='binary')
+lines_to_poly('line_test_binary', points, point_data={"1_temp": temp, "2_pressure": pressure},
+                cell_data={'velocity': vel}, fieldData=None, encoding='binary')
 
-lines_to_poly('line_test_base64', points, point_data=point_data,
-                cell_data=cell_data, fieldData=None, encoding='appended')
+lines_to_poly('line_test_base64', points, point_data={"1_temp": temp, "2_pressure": pressure},
+                cell_data={'velocity': vel}, fieldData=None, encoding='appended')
 
 # --8<-- [end:write_lines_dataset_hl]
 
@@ -410,7 +395,7 @@ polylines_to_poly('polyline_test_base64', points, pointsPerLine,
 #%% test writing multiblock files
 
 # --8<-- [start:write_poly_multiblock_xml]
-from vtkio.writer.xml import xml_multiblock_writer
+from vtkio.writer.xml_writer import xml_multiblock_writer
 
 xml_multiblock_writer('new_vtk_multiblock_file', {
     'Base': {'files': ['edem_cube_base_t_0.vtp']},
@@ -426,7 +411,7 @@ xml_multiblock_writer('new_vtk_multiblock_file', {
 # --8<-- [start:write_poly_multiblock_vtkhdf]
 from vtkio.writer.vtkhdf import VTKHDFMultiBlockWriter
 
-blocks = {'block1': plate_data, 'block2': map_data, 'block3': cow_data, 'block4': lines_data}
+blocks = {'block1': plate_data, 'block3': cow_data, 'block4': lines_data}
 writer = VTKHDFMultiBlockWriter('hdf_multiblock_test', blocks)
 writer.write_vtkhdf_file()
 

{vtkio-0.1.0.dev8 → vtkio-0.1.0.dev9}/examples/RectilinearData.py

@@ -81,7 +81,7 @@ field_data = {'TimeValue': 0.122654987}
 
 
 # --8<-- [start:write_rectilineargriddata_writer_ascii]
-from vtkio.writer.xml import XMLRectilinearGridWriter
+from vtkio.writer.xml_writer import XMLRectilinearGridWriter
 
 
 file = XMLRectilinearGridWriter('test_rectilinear_grid_data.vtr',

{vtkio-0.1.0.dev8 → vtkio-0.1.0.dev9}/examples/StructuredGrid.py

@@ -105,7 +105,7 @@ field_data = {'TimeValue': 0.122654987}
 # --8<-- [end:create_grid_data]
 
 # --8<-- [start:write_structuredgrid_data_writer_ascii]
-from vtkio.writer.xml import XMLStructuredGridWriter
+from vtkio.writer.xml_writer import XMLStructuredGridWriter
 
 
 file = XMLStructuredGridWriter('test_distorted_grid',

{vtkio-0.1.0.dev8 → vtkio-0.1.0.dev9}/examples/UnstructuredGrid.py

@@ -103,7 +103,7 @@ offsets = np.cumsum(num_cell_nodes)
 
 # --8<-- [start:write_multicell_vtu]
 # Write the unstructured grid to a vtu file with multiple cell types
-from vtkio.writer.xml import XMLUnstructuredGridWriter
+from vtkio.writer.xml_writer import XMLUnstructuredGridWriter
 
 # Write the file using the xml writer class
 file = XMLUnstructuredGridWriter('multi_cell_type_example',

vtkio-0.1.0.dev9/examples/new_reader_testing.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+"""
+Module documentation goes here.
+
+Created at 20:22, 26 Apr, 2022
+"""
+
+__author__ = 'J.P. Morrissey'
+__copyright__ = 'Copyright 2022-2025'
+__maintainer__ = 'J.P. Morrissey'
+__email__ = 'morrissey.jp@gmail.com'
+__status__ = 'Development'
+
+# Standard Library
+
+
+# Imports
+import numpy as np
+
+# Local Sources
+from vtkio.reader import read_vtkxml_data
+
+
+from ..src.vtkio.reader.readers import UnifiedXMLReader, UnifiedHDF5Reader
+
+#%% test xml polydata reading
+plate_data = read_vtkxml_data('../TestData/vtp/plate_vectors.vtp')
+map_data = read_vtkxml_data('../TestData/vtp/map.vtp')
+poly_verts_data = read_vtkxml_data('../TestData/vtp/polytest.vtp')
+lines_data = read_vtkxml_data('../TestData/vtp/ibm_with_data.vtp')
+cow_data = read_vtkxml_data('../TestData/vtp/cow.vtp')
+
+#%%text new xml polydata reader
+xml_reader = UnifiedXMLReader('../TestData/vtp/plate_vectors.vtp')
+xml_reader.read()
+print(xml_reader)
+print(xml_reader.data)
+print(xml_reader.data.point_data.keys())
+print(xml_reader.data.cell_data.keys())
+print(xml_reader.data.field_data.keys())

{vtkio-0.1.0.dev8 → vtkio-0.1.0.dev9}/pyproject.toml

@@ -101,14 +101,6 @@ include = [
 ]
 exclude = [
   "/examples/example_data",
-  "/examples/*.vti",
-  "/examples/*.vtp",
-  "/examples/*.vtu",
-  "/examples/*.vtr",
-  "/examples/*.vts",
-  "/examples/*.vtm",
-  "/examples/*.vtkhdf",
-  "/examples/*.pvd",
   "/TestData"
 ]
 

vtkio-0.1.0.dev9/src/vtkio/config.py

@@ -0,0 +1,374 @@
+# !/usr/bin/env python
+"""
+Configuration settings for the VTKio package.
+
+This centralises all magic strings, type mappings, and configuration
+to make the system more maintainable.
+"""
+
+__author__ = 'J.P. Morrissey'
+__copyright__ = 'Copyright 2022-2025'
+__maintainer__ = 'J.P. Morrissey'
+__email__ = 'morrissey.jp@gmail.com'
+__status__ = 'Development'
+
+import numpy as np
+from typing import Dict, Set, Any
+from pathlib import Path
+import logging
+
+
+class VTKConfig:
+    """Central configuration for VTK readers."""
+
+    # File format support
+    SUPPORTED_XML_EXTENSIONS: Set[str] = {'.vti', '.vtr', '.vts', '.vtu', '.vtp'}
+    SUPPORTED_HDF5_EXTENSIONS: Set[str] = {'.h5', '.hdf5', 'vtkhdf', '.hdf'}
+
+    # VTK data types
+    SUPPORTED_VTK_TYPES: Set[str] = {
+        'ImageData', 'PolyData', 'UnstructuredGrid',
+        'StructuredGrid', 'RectilinearGrid'
+    }
+
+    # File format defaults
+    DEFAULT_ENCODING: str = 'utf-8'
+    DEFAULT_BYTE_ORDER: str = 'little_endian'
+
+    # Data type mappings for XML parsing
+    XML_TYPE_MAPPING: Dict[str, Any] = {
+        'int': np.int64,
+        'float': np.float32,
+        'double': np.float64,
+        'float16': np.float16,
+        'float32': np.float32,
+        'float64': np.float64,
+        'int8': np.int8,
+        'int16': np.int16,
+        'int32': np.int32,
+        'int64': np.int64,
+        'uint8': np.uint8,
+        'uint16': np.uint16,
+        'uint32': np.uint32,
+        'uint64': np.uint64,
+        'string': 's'
+    }
+
+    # Required data sections for each VTK type
+    REQUIRED_DATA_SECTIONS: Dict[str, Set[str]] = {
+        'UnstructuredGrid': {'Points', 'Cells'},
+        'PolyData': {'Points'},
+        'ImageData': set(),  # Grid info comes from attributes
+        'StructuredGrid': {'Points'},
+        'RectilinearGrid': {'Coordinates'}
+    }
+
+    # Optional data sections (always try to read these)
+    OPTIONAL_DATA_SECTIONS: Set[str] = {'PointData', 'CellData', 'FieldData'}
+
+    # XML specific constants
+    XML_ARRAY_KEYS: Set[str] = {'DataArray', 'Array'}
+    XML_DATA_FORMATS: Set[str] = {'ascii', 'binary', 'appended'}
+
+    # HDF5 specific constants
+    HDF5_VTKHDF_GROUP: str = 'VTKHDF'
+    HDF5_REQUIRED_ATTRIBUTES: Set[str] = {'Type'}
+
+    # Polydata topology sections
+    POLYDATA_TOPOLOGY_SECTIONS: Dict[str, str] = {
+        'Vertices': 'verts',
+        'Lines': 'lines',
+        'Strips': 'strips',
+        'Polygons': 'polys',
+        'Polys': 'polys'  # Handle both naming conventions
+    }
+
+    # Grid attributes for ImageData
+    IMAGE_DATA_ATTRIBUTES: Set[str] = {
+        'WholeExtent', 'Origin', 'Spacing', 'Direction'
+    }
+
+    # Coordinate names for RectilinearGrid
+    RECTILINEAR_COORDINATES: Set[str] = {'XCoordinates', 'YCoordinates', 'ZCoordinates'}
+
+    # Point array common names (in order of preference)
+    POINT_ARRAY_NAMES: list = ['Points', 'Coordinates', 'points', 'coordinates']
+
+    # Connectivity array names
+    CONNECTIVITY_ARRAY_NAMES: Dict[str, str] = {
+        'connectivity': 'connectivity',
+        'offsets': 'offsets',
+        'types': 'types'
+    }
+
+    # Compression type mapping - centralizes compression constants
+    SUPPORTED_COMPRESSION_TYPES = {
+        'none': 'none',
+        'zlib': 'zlib',
+        'gzip': 'zlib',  # HDF5 gzip maps to zlib
+        'lzma': 'lzma',
+        'xz': 'lzma',  # XZ maps to lzma
+        'lz4': 'lz4'
+    }
+
+    # Default compression settings
+    DEFAULT_COMPRESSION_TYPE = 'zlib'
+    MAX_DECOMPRESSION_MEMORY_MB = 1024  # 1GB default limit
+
+    # VTK-specific compression block size (typical default)
+    DEFAULT_COMPRESSION_BLOCK_SIZE = 32768
+
+    # Logging configuration
+    DEFAULT_LOG_LEVEL: int = logging.INFO
+    LOG_FORMAT: str = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+
+    # Performance settings
+    CHUNK_SIZE: int = 8192  # For reading large files in chunks
+    MAX_MEMORY_USAGE_MB: int = 1024  # Maximum memory usage before warnings
+
+    # Validation settings
+    VALIDATE_TOPOLOGY: bool = True
+    VALIDATE_DATA_CONSISTENCY: bool = True
+
+    # Error handling settings
+    STRICT_VALIDATION: bool = False  # If True, fail on any validation errors
+    CONTINUE_ON_DATA_ERRORS: bool = True  # Continue reading even if some data arrays fail
+
+    @classmethod
+    def get_reader_class_for_extension(cls, file_path: Path) -> str:
+        """
+        Get the appropriate reader class name for a file extension.
+
+        Parameters
+        ----------
+        file_path : Path
+            Path to the file
+
+        Returns
+        -------
+        str
+            Name of the reader class to use
+
+        Raises
+        ------
+        ValueError
+            If file extension is not supported
+        """
+        suffix = file_path.suffix.lower()
+
+        if suffix in cls.SUPPORTED_XML_EXTENSIONS:
+            return 'UnifiedXMLReader'
+        elif suffix in cls.SUPPORTED_HDF5_EXTENSIONS:
+            return 'UnifiedHDF5Reader'
+        else:
+            raise ValueError(f"Unsupported file extension: {suffix}")
+
+    @classmethod
+    def get_vtk_type_from_extension(cls, file_path: Path) -> str:
+        """
+        Guess VTK type from file extension.
+
+        This is a fallback when type cannot be read from file.
+        """
+        extension_to_type = {
+            '.vti': 'ImageData',
+            '.vtr': 'RectilinearGrid',
+            '.vts': 'StructuredGrid',
+            '.vtu': 'UnstructuredGrid',
+            '.vtp': 'PolyData'
+        }
+
+        return extension_to_type.get(file_path.suffix.lower(), 'Unknown')
+
+    @classmethod
+    def validate_vtk_type(cls, vtk_type: str) -> bool:
+        """Check if VTK type is supported."""
+        return vtk_type in cls.SUPPORTED_VTK_TYPES
+
+    @classmethod
+    def get_numpy_dtype(cls, xml_type_string: str) -> Any:
+        """Convert XML type string to numpy dtype."""
+        return cls.XML_TYPE_MAPPING.get(xml_type_string.lower(), None)
+
+    @classmethod
+    def validate_compression_type(cls, compression_type: str) -> bool:
+        """Validate if compression type is supported."""
+        return compression_type.lower() in cls.SUPPORTED_COMPRESSION_TYPES
+
+    @classmethod
+    def normalize_compression_type(cls, compression_type: str) -> str:
+        """Normalize compression type name to standard form."""
+        normalized = compression_type.lower()
+        return cls.SUPPORTED_COMPRESSION_TYPES.get(normalized, 'none')
+
+    @classmethod
+    def get_supported_extensions_for_compression(cls) -> set:
+        """Get all file extensions that may contain compressed data."""
+        return cls.SUPPORTED_HDF5_EXTENSIONS | cls.SUPPORTED_XML_EXTENSIONS
+
+    @classmethod
+    def setup_logging(cls, level: int = None, format_str: str = None) -> logging.Logger:
+        """Set up logging with standard configuration."""
+        level = level or cls.DEFAULT_LOG_LEVEL
+        format_str = format_str or cls.LOG_FORMAT
+
+        logging.basicConfig(level=level, format=format_str)
+        logger = logging.getLogger('vtk_reader')
+        return logger
+
+    @classmethod
+    def get_supported_data_types(cls) -> Dict[str, Dict[str, Any]]:
+        """
+        Get supported VTK data types with their parser information.
+
+        Returns
+        -------
+        Dict[str, Dict[str, Any]]
+            Dictionary mapping VTK type names to parser information
+        """
+        return {
+            'UnstructuredGrid': {
+                'required_sections': cls.REQUIRED_DATA_SECTIONS['UnstructuredGrid'],
+                'parser_method': '_parse_unstructured_grid',
+                'description': 'Unstructured grid with arbitrary connectivity'
+            },
+            'PolyData': {
+                'required_sections': cls.REQUIRED_DATA_SECTIONS['PolyData'],
+                'parser_method': '_parse_polydata',
+                'description': 'Polygonal data (vertices, lines, polygons, triangle strips)'
+            },
+            'ImageData': {
+                'required_sections': cls.REQUIRED_DATA_SECTIONS['ImageData'],
+                'parser_method': '_parse_image_data',
+                'description': 'Regular grid with uniform spacing'
+            },
+            'StructuredGrid': {
+                'required_sections': cls.REQUIRED_DATA_SECTIONS['StructuredGrid'],
+                'parser_method': '_parse_structured_grid',
+                'description': 'Structured grid with arbitrary point positions'
+            },
+            'RectilinearGrid': {
+                'required_sections': cls.REQUIRED_DATA_SECTIONS['RectilinearGrid'],
+                'parser_method': '_parse_rectilinear_grid',
+                'description': 'Grid with separate coordinate arrays'
+            }
+        }
+
+    @classmethod
+    def get_required_sections_for_type(cls, vtk_type: str) -> Set[str]:
+        """
+        Get required data sections for a specific VTK type.
+
+        Parameters
+        ----------
+        vtk_type : str
+            VTK data type name
+
+        Returns
+        -------
+        Set[str]
+            Set of required section names
+        """
+        return cls.REQUIRED_DATA_SECTIONS.get(vtk_type, set())
+
+    @classmethod
+    def get_parser_method_for_type(cls, vtk_type: str) -> str:
+        """
+        Get the parser method name for a VTK type.
+
+        Parameters
+        ----------
+        vtk_type : str
+            VTK data type name
+
+        Returns
+        -------
+        str
+            Name of the parser method
+
+        Raises
+        ------
+        ValueError
+            If VTK type is not supported
+        """
+        supported_types = cls.get_supported_data_types()
+        if vtk_type not in supported_types:
+            raise ValueError(f"Unsupported VTK type: {vtk_type}")
+
+        return supported_types[vtk_type]['parser_method']
+
+    @classmethod
+    def is_xml_extension(cls, extension: str) -> bool:
+        """Check if extension is a supported XML format."""
+        return extension.lower() in cls.SUPPORTED_XML_EXTENSIONS
+
+    @classmethod
+    def is_hdf5_extension(cls, extension: str) -> bool:
+        """Check if extension is a supported HDF5 format."""
+        return extension.lower() in cls.SUPPORTED_HDF5_EXTENSIONS
+
+    @classmethod
+    def get_all_supported_extensions(cls) -> Set[str]:
+        """Get all supported file extensions."""
+        return cls.SUPPORTED_XML_EXTENSIONS | cls.SUPPORTED_HDF5_EXTENSIONS
+
+
+class ReaderSettings:
+    """Runtime settings for VTK readers that can be customized per read operation."""
+
+    def __init__(self,
+                 validate_topology: bool = None,
+                 validate_data_consistency: bool = None,
+                 strict_validation: bool = None,
+                 continue_on_data_errors: bool = None,
+                 max_memory_usage_mb: int = None,
+                 chunk_size: int = None):
+        """
+        Initialize reader settings.
+
+        Parameters that are None will use the defaults from VTKConfig.
+        """
+        self.validate_topology = validate_topology if validate_topology is not None else VTKConfig.VALIDATE_TOPOLOGY
+        self.validate_data_consistency = validate_data_consistency if validate_data_consistency is not None else VTKConfig.VALIDATE_DATA_CONSISTENCY
+        self.strict_validation = strict_validation if strict_validation is not None else VTKConfig.STRICT_VALIDATION
+        self.continue_on_data_errors = continue_on_data_errors if continue_on_data_errors is not None else VTKConfig.CONTINUE_ON_DATA_ERRORS
+        self.max_memory_usage_mb = max_memory_usage_mb if max_memory_usage_mb is not None else VTKConfig.MAX_MEMORY_USAGE_MB
+        self.chunk_size = chunk_size if chunk_size is not None else VTKConfig.CHUNK_SIZE
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert settings to dictionary for logging/debugging."""
+        return {
+            'validate_topology': self.validate_topology,
+            'validate_data_consistency': self.validate_data_consistency,
+            'strict_validation': self.strict_validation,
+            'continue_on_data_errors': self.continue_on_data_errors,
+            'max_memory_usage_mb': self.max_memory_usage_mb,
+            'chunk_size': self.chunk_size
+        }
+
+
+# Convenience functions for common configurations
+def create_performance_settings() -> ReaderSettings:
+    """Create settings optimised for performance (less validation)."""
+    return ReaderSettings(
+        validate_topology=False,
+        validate_data_consistency=False,
+        strict_validation=False,
+        continue_on_data_errors=True,
+        chunk_size=16384  # Larger chunks
+    )
+
+
+def create_strict_settings() -> ReaderSettings:
+    """Create settings optimised for data integrity (more validation)."""
+    return ReaderSettings(
+        validate_topology=True,
+        validate_data_consistency=True,
+        strict_validation=True,
+        continue_on_data_errors=False
+    )
+
+
+def create_default_settings() -> ReaderSettings:
+    """Create default balanced settings."""
+    return ReaderSettings()  # Uses all defaults from VTKConfig