Pymeshit 0.2.4__tar.gz

pymeshit-0.2.4/LICENSE

@@ -0,0 +1,26 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+This is the GNU General Public License version 3 (GPLv3).
+
+You can find the full text of GPLv3 at: https://www.gnu.org/licenses/gpl-3.0.html
+
+The GNU General Public License is a free, copyleft license for software and other kinds of works.
+
+Key points:
+- Freedom to run the program as you wish, for any purpose
+- Freedom to study how the program works, and change it so it does your computing as you wish
+- Freedom to redistribute copies so you can help your neighbor
+- Freedom to distribute copies of your modified versions to others
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.

pymeshit-0.2.4/MANIFEST.in

@@ -0,0 +1,30 @@
+include README.md
+include main.py
+include Pymeshit_workflow_gui.py
+recursive-include resources *
+recursive-include Pymeshit *.py
+
+exclude bin/*
+exclude debug_plc/*
+exclude doc/*
+exclude github/*
+exclude include/*
+exclude release/*
+exclude src/*
+exclude *.pyd
+exclude *.so
+exclude *.dll
+exclude *.exe
+exclude *.o
+exclude *.obj
+exclude *.lib
+exclude *.exp
+exclude *.cpp
+exclude *.c
+exclude *.h
+exclude *.cxx
+exclude *.rc
+exclude *.qrc
+exclude *.stl
+exclude _skipped.*
+exclude tetgen-tmpfile*

pymeshit-0.2.4/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: Pymeshit
+Version: 0.2.4
+Summary: Complete mesh generation and manipulation package with GUI
+Author-email: Waqas Hussain <waqas.hussain117@gmail.com>
+License: GPL-3.0
+Project-URL: Homepage, https://github.com/waqashussain117/PyMeshit
+Project-URL: Bug Tracker, https://github.com/waqashussain117/PyMeshit/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: triangle
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: PySide6>=6.0.0
+Requires-Dist: pyvista>=0.30.0
+Requires-Dist: tetgen>=0.6.0
+Dynamic: license-file
+
+# PyMeshIt
+
+PyMeshIt is a complete Python package for mesh generation and manipulation with a full-featured Qt-based GUI. It provides a comprehensive workflow to process point clouds and polylines into conforming surface meshes and tetrahedral meshes.
+
+**Note:** This version runs entirely in Python without C++ dependencies, making it easier to install and deploy.
+
+## Highlights (GUI-driven workflow)
+
+The included GUI (main.py) implements a full MeshIt workflow with the following main tabs:
+
+- 1. Load Data — load points, wells (polylines) or VTU/Poly formats; manage multiple datasets and colors.
+- 2. Convex Hull — compute dataset boundaries (convex or rim for/quasi-planar sheets) with corner detection.
+- 3. Segmentation — refine hulls by target feature size and per-surface length tables (RefineByLength).
+- 4. Triangulation — generate surface triangulations with gradient, min-angle, interpolation and uniform options.
+- 5. Intersections — compute & visualize global surface–surface and polyline–surface intersections; triple point detection.
+- 6. Refine & Mesh — refine intersection/hull lines, generate conforming surface meshes, constraint selection UI, per-surface mesh density table.
+- 7. Pre‑Tetramesh — select conforming surfaces, validate for TetGen, manage selection tree for tetrahedralization.
+- 8. Tetra Mesh — generate and visualize tetrahedral meshes, assign materials, export results.
+
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pip install triangle
+pip install pymeshit # Needs to be fixed
+```
+
+### From Source
+
+If you want to install from source:
+
+```bash
+git clone https://github.com/waqashussain/meshit.git
+cd meshit
+pip install -e .
+```
+
+### Requirements
+
+The package will automatically install all required dependencies:
+- numpy
+- scipy
+- matplotlib
+- PySide6
+- pyvista
+- tetgen
+- triangle (optional)
+
+
+## Quick start (GUI)
+
+After installation, run the GUI:
+
+```bash
+meshit-gui
+```
+
+Or from Python:
+
+```python
+import Pymeshit
+Pymeshit.main_wrapper()
+```
+
+Typical workflow:
+1. Load one or more point or VTU files (File → Load).
+2. Compute hulls (Convex Hull tab).
+3. Compute segmentation (Segmentation tab) — set "Target Feature Size" or per-surface values.
+4. Run triangulation (Triangulation tab), choose interpolation and quality settings.
+5. Compute intersections (Intersections tab) to extract shared constraints and triple points.
+6. Refine intersection lines and generate conforming meshes (Refine & Mesh tab).
+7. Select conforming surfaces and validate for TetGen (Pre‑Tetramesh tab).
+8. Generate and visualize tetrahedral mesh (Tetra Mesh tab) and export.
+
+## Programmatic Usage
+
+```python
+import pymeshit
+from pymeshit.intersection_utils import align_intersections_to_convex_hull
+
+# Use pymeshit functions programmatically
+# ...
+```
+
+## Contributing
+
+Contributions are welcome. Please open an issue for discussion and submit PRs for fixes and features. Keep GUI behavior consistent with the tab-based workflow.
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.

pymeshit-0.2.4/Pymeshit/__init__.py

@@ -0,0 +1,228 @@
+"""
+PyMeshit - Complete mesh generation and manipulation package with GUI
+
+This package provides a comprehensive solution for mesh generation and manipulation,
+including a graphical user interface for the complete workflow.
+"""
+
+import sys  # Import sys for error handling
+
+# Define main_wrapper early to ensure it's always available
+def main_wrapper():
+    from PySide6.QtWidgets import QApplication
+    from PySide6.QtGui import QIcon
+    from PySide6.QtWidgets import QSplashScreen
+    from PySide6.QtGui import QPixmap
+    from PySide6.QtCore import Qt
+    import os, sys
+
+    app = QApplication(sys.argv)  # MUST be first
+
+    from Pymeshit_workflow_gui import MeshItWorkflowGUI  # import GUI after app
+
+    # optional: icon/splash
+    icon_path = os.path.join(os.path.dirname(__file__), '..', 'resources', 'images', 'app_logo_small.png')
+    if os.path.exists(icon_path):
+        app.setWindowIcon(QIcon(icon_path))
+
+    splash_path = os.path.join(os.path.dirname(__file__), '..', 'resources', 'images', 'app_logo.png')
+    pixmap = QPixmap(splash_path) if os.path.exists(splash_path) else QPixmap(400, 300)
+    splash = QSplashScreen(pixmap, Qt.WindowStaysOnTopHint)
+    splash.show(); app.processEvents()
+
+    window = MeshItWorkflowGUI()
+    window.show()
+    splash.finish(window)
+    sys.exit(app.exec())
+
+# Import core components with fallback
+try:
+    from .core import (
+        MeshItModel,
+        Vector3D,
+        Surface,
+        Polyline,
+        create_surface,
+        create_polyline,
+        Triangle,
+        Intersection,
+        TriplePoint,
+        GradientControl,
+    )
+except ImportError as e:
+    print(f"Warning: Could not import core components: {e}", file=sys.stderr)
+    print("Using Python fallback implementations", file=sys.stderr)
+
+    # Minimal fallback classes
+    class MeshItModel:
+        def __init__(self):
+            self.surfaces = []
+            self.model_polylines = []
+        def __str__(self):
+            return "MeshItModel(fallback)"
+
+    class Vector3D:
+        def __init__(self, x=0, y=0, z=0):
+            self.x, self.y, self.z = x, y, z
+
+    class Surface:
+        def __init__(self, points=None, edges=None, name="Surface", stype="Scattered"):
+            self.vertices = points or []
+            self.triangles = []
+            self.name = name
+
+    class Polyline:
+        def __init__(self, points=None, name="Polyline"):
+            self.vertices = points or []
+            self.segments = []
+            self.name = name
+
+    def create_surface(points, edges, name="Surface", stype="Scattered"):
+        return Surface(points, edges, name, stype)
+
+    def create_polyline(points, name="Polyline"):
+        return Polyline(points, name)
+
+    class Triangle:
+        def __init__(self, v1, v2, v3):
+            self.v1, self.v2, self.v3 = v1, v2, v3
+
+    class Intersection:
+        def __init__(self, id1, id2, is_polyline_mesh=False):
+            self.id1, self.id2 = id1, id2
+            self.is_polyline_mesh = is_polyline_mesh
+            self.points = []
+
+    class TriplePoint:
+        def __init__(self, point):
+            self.point = point
+            self.intersection_ids = []
+
+    class GradientControl:
+        _instance = None
+        def __new__(cls):
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+            return cls._instance
+
+# Try to import our direct Triangle wrapper (Python-only)
+try:
+    from . import triangle_direct
+    HAS_DIRECT_TRIANGLE = True
+except ImportError:
+    HAS_DIRECT_TRIANGLE = False
+
+# Define version
+__version__ = '0.2.0'
+
+# Helper functions for adding geometries to a model
+def add_surface_to_model(model, surface):
+    """Add a surface to a MeshItModel instance.
+    
+    Args:
+        model: A MeshItModel instance
+        surface: A Surface instance to add
+    """
+    try:
+        model.surfaces = list(model.surfaces) + [surface]
+    except Exception as e:
+        print(f"Warning: Failed to add surface to model: {e}", file=sys.stderr)
+    
+def add_polyline_to_model(model, polyline):
+    """Add a polyline to a MeshItModel instance.
+    
+    Args:
+        model: A MeshItModel instance
+        polyline: A Polyline instance to add
+    """
+    try:
+        model.model_polylines = list(model.model_polylines) + [polyline]
+    except Exception as e:
+        print(f"Warning: Failed to add polyline to model: {e}", file=sys.stderr)
+
+# Helper functions for accessing model results
+def get_intersections(model):
+    """Get the intersections from a MeshItModel instance.
+    
+    Args:
+        model: A MeshItModel instance
+    
+    Returns:
+        A list of Intersection objects or an empty list if not available
+    """
+    try:
+        return model.intersections
+    except AttributeError:
+        return []
+
+def get_triple_points(model):
+    """Get the triple points from a MeshItModel instance.
+    
+    Args:
+        model: A MeshItModel instance
+    
+    Returns:
+        A list of TriplePoint objects or an empty list if not available
+    """
+    try:
+        return model.triple_points
+    except AttributeError:
+        return []
+
+def compute_convex_hull(points):
+    """Compute the convex hull of a set of 3D points.
+    
+    Args:
+        points: A list of 3D points, where each point is a list of 3 coordinates [x, y, z]
+    
+    Returns:
+        A list of 3D points representing the convex hull
+    """
+    try:
+        # Create a surface from the points
+        surface = create_surface(points, [], "TempSurface", "Scattered")
+        
+        # Calculate the convex hull
+        surface.calculate_convex_hull()
+        
+        # Convert the convex hull points to a list of lists
+        hull_points = []
+        for point in surface.convex_hull:
+            hull_points.append([point.x, point.y, point.z])
+        
+        return hull_points
+    except Exception as e:
+        print(f"Warning: Failed to compute convex hull: {e}", file=sys.stderr)
+        
+        # Fall back to scipy for convex hull if available
+        try:
+            import numpy as np
+            from scipy.spatial import ConvexHull
+            
+            points_array = np.array(points)
+            if points_array.shape[1] == 3:  # 3D points
+                hull = ConvexHull(points_array)
+                return points_array[hull.vertices].tolist()
+            return []
+        except ImportError:
+            return []
+
+# Duplicate main_wrapper function removed
+
+__all__ = [
+    'MeshItModel',
+    'Vector3D',
+    'Surface',
+    'Polyline',
+    'create_surface',
+    'create_polyline',
+    'Triangle',
+    'Intersection',
+    'TriplePoint',
+    'add_surface_to_model',
+    'add_polyline_to_model',
+    'get_intersections',
+    'get_triple_points',
+    'compute_convex_hull',
+    'main_wrapper'
+]

pymeshit-0.2.4/Pymeshit/core/__init__.py

@@ -0,0 +1,93 @@
+# This file is intentionally empty to make the directory a Python package
+
+"""
+Core C++ bindings for MeshIt
+"""
+
+try:
+    from ._meshit import (
+        MeshItModel,
+        Vector3D,
+        Surface,
+        Polyline,
+        create_surface,
+        create_polyline,
+        Triangle,
+        Intersection,
+        TriplePoint,
+        GradientControl
+    )
+except ImportError as e:
+    import sys
+    print(f"Warning: C++ extensions not available: {e}", file=sys.stderr)
+    print("Using Python fallback implementations", file=sys.stderr)
+
+    # Provide dummy classes when C++ extensions are not available
+    class Vector3D:
+        def __init__(self, x=0, y=0, z=0):
+            self.x, self.y, self.z = x, y, z
+
+        def __repr__(self):
+            return f"Vector3D({self.x}, {self.y}, {self.z})"
+
+    class Surface:
+        def __init__(self, points=None, edges=None, name="Surface", stype="Scattered"):
+            self.points = points or []
+            self.edges = edges or []
+            self.name = name
+            self.stype = stype
+            self.convex_hull = []
+
+        def calculate_convex_hull(self):
+            # Dummy implementation
+            self.convex_hull = [Vector3D(*p) for p in self.points[:min(10, len(self.points))]]
+
+    class GradientControl:
+        def __init__(self):
+            pass
+
+    class Polyline:
+        def __init__(self, points=None, name="Polyline"):
+            self.points = points or []
+            self.name = name
+
+    class Triangle:
+        def __init__(self, v1=None, v2=None, v3=None):
+            self.v1, self.v2, self.v3 = v1, v2, v3
+
+    class Intersection:
+        def __init__(self):
+            self.points = []
+
+    class TriplePoint:
+        def __init__(self):
+            self.position = Vector3D()
+
+    class MeshItModel:
+        def __init__(self):
+            self.surfaces = []
+            self.model_polylines = []
+            self.intersections = []
+            self.triple_points = []
+
+        def __str__(self):
+            return f"MeshItModel(surfaces: {len(self.surfaces)}, polylines: {len(self.model_polylines)})"
+
+    def create_surface(points, edges=None, name="Surface", stype="Scattered"):
+        return Surface(points, edges, name, stype)
+
+    def create_polyline(points, name="Polyline"):
+        return Polyline(points, name)
+
+__all__ = [
+    'MeshItModel',
+    'Vector3D',
+    'Surface',
+    'Polyline',
+    'create_surface',
+    'create_polyline',
+    'Triangle',
+    'Intersection',
+    'TriplePoint',
+    'GradientControl'
+]