fieldview 0.1.0__tar.gz

fieldview-0.1.0/.gitignore

@@ -0,0 +1,158 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   with no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary dependencies to ensure reproducible builds.
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+
+# MacOS
+.DS_Store
+
+# Generated demo files
+dummy_data.csv

fieldview-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FieldView Team
+
+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.

fieldview-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: fieldview
+Version: 0.1.0
+Summary: Python + Qt based 2D data visualization solution for irregular data points
+Author-email: FieldView Team <dev@fieldview.org>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24.1
+Requires-Dist: pyside6>=6.6.0
+Requires-Dist: scipy>=1.10.0
+Description-Content-Type: text/markdown
+
+# FieldView
+
+**FieldView** is a high-performance Python + Qt (PySide6) library for 2D data visualization, specifically designed for handling irregular data points. It provides a robust rendering engine for heatmaps, markers, and text labels with minimal external dependencies.
+
+<img src="assets/quick_start.png" alt="Quick Start" width="480">
+
+## Key Features
+
+*   **Fast Heatmap Rendering**: Hybrid RBF (Radial Basis Function) interpolation for high-quality visualization with real-time performance optimization.
+*   **Irregular Data Support**: Native handling of non-grid data points.
+*   **Polygon Masking**: Support for arbitrary boundary shapes (Polygon, Circle, Rectangle) to clip heatmaps.
+*   **Layer System**: Modular architecture with support for:
+    *   **HeatmapLayer**: Color-based data visualization.
+    *   **ValueLayer/LabelLayer**: Text rendering with collision avoidance.
+    *   **PinLayer**: Marker placement.
+    *   **SvgLayer**: Background floor plans or overlays.
+*   **Minimal Dependencies**: Built on `numpy`, `scipy`, and `PySide6`.
+
+## Installation
+
+```bash
+pip install fieldview
+```
+
+*Note: Requires Python 3.10+*
+
+## Quick Start
+
+Here is a minimal example to get a heatmap up and running:
+
+```python
+import sys
+import os
+import numpy as np
+from PySide6.QtWidgets import QApplication, QGraphicsView, QGraphicsScene
+from PySide6.QtCore import Qt
+from fieldview.core.data_container import DataContainer
+from fieldview.layers.heatmap_layer import HeatmapLayer
+from fieldview.layers.text_layer import ValueLayer
+from fieldview.layers.svg_layer import SvgLayer
+from fieldview.layers.pin_layer import PinLayer
+
+app = QApplication(sys.argv)
+
+# 1. Setup Data
+data = DataContainer()
+np.random.seed(44)
+points = (np.random.rand(20, 2) - 0.5) * 300
+values = np.random.rand(20) * 100
+data.set_data(points, values)
+
+# 2. Create Scene & Layers
+scene = QGraphicsScene()
+
+# SVG Layer (Background)
+# Assuming floorplan.svg exists in current dir or provide path
+svg_layer = SvgLayer()
+svg_layer.load_svg("examples/floorplan.svg")
+svg_layer.setZValue(0)
+scene.addItem(svg_layer)
+
+# Heatmap Layer
+heatmap = HeatmapLayer(data)
+heatmap.setOpacity(0.6)
+heatmap.setZValue(1)
+heatmap.set_boundary_shape(svg_layer._bounding_rect)
+scene.addItem(heatmap)
+
+# Pin Layer
+pin_layer = PinLayer(data)
+pin_layer.setZValue(2)
+scene.addItem(pin_layer)
+
+# Value Layer
+values_layer = ValueLayer(data)
+values_layer.setZValue(3)
+scene.addItem(values_layer)
+
+# 3. Setup View
+view = QGraphicsView(scene)
+view.resize(800, 600)
+view.show()
+
+# Ensure content is visible
+scene.setSceneRect(scene.itemsBoundingRect())
+view.fitInView(scene.sceneRect(), Qt.AspectRatioMode.KeepAspectRatio)
+
+sys.exit(app.exec())
+```
+≈
+
+## Running the Demo
+
+To see all features in action, including the property editor and real-time interaction:
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/fieldview.git
+cd fieldview
+
+# Run the demo using uv (recommended)
+uv run examples/demo.py
+```
+
+<img src="assets/demo.gif" alt="Demo" width="800">
+
+## License
+
+MIT License

fieldview-0.1.0/README.md

@@ -0,0 +1,109 @@
+# FieldView
+
+**FieldView** is a high-performance Python + Qt (PySide6) library for 2D data visualization, specifically designed for handling irregular data points. It provides a robust rendering engine for heatmaps, markers, and text labels with minimal external dependencies.
+
+<img src="assets/quick_start.png" alt="Quick Start" width="480">
+
+## Key Features
+
+*   **Fast Heatmap Rendering**: Hybrid RBF (Radial Basis Function) interpolation for high-quality visualization with real-time performance optimization.
+*   **Irregular Data Support**: Native handling of non-grid data points.
+*   **Polygon Masking**: Support for arbitrary boundary shapes (Polygon, Circle, Rectangle) to clip heatmaps.
+*   **Layer System**: Modular architecture with support for:
+    *   **HeatmapLayer**: Color-based data visualization.
+    *   **ValueLayer/LabelLayer**: Text rendering with collision avoidance.
+    *   **PinLayer**: Marker placement.
+    *   **SvgLayer**: Background floor plans or overlays.
+*   **Minimal Dependencies**: Built on `numpy`, `scipy`, and `PySide6`.
+
+## Installation
+
+```bash
+pip install fieldview
+```
+
+*Note: Requires Python 3.10+*
+
+## Quick Start
+
+Here is a minimal example to get a heatmap up and running:
+
+```python
+import sys
+import os
+import numpy as np
+from PySide6.QtWidgets import QApplication, QGraphicsView, QGraphicsScene
+from PySide6.QtCore import Qt
+from fieldview.core.data_container import DataContainer
+from fieldview.layers.heatmap_layer import HeatmapLayer
+from fieldview.layers.text_layer import ValueLayer
+from fieldview.layers.svg_layer import SvgLayer
+from fieldview.layers.pin_layer import PinLayer
+
+app = QApplication(sys.argv)
+
+# 1. Setup Data
+data = DataContainer()
+np.random.seed(44)
+points = (np.random.rand(20, 2) - 0.5) * 300
+values = np.random.rand(20) * 100
+data.set_data(points, values)
+
+# 2. Create Scene & Layers
+scene = QGraphicsScene()
+
+# SVG Layer (Background)
+# Assuming floorplan.svg exists in current dir or provide path
+svg_layer = SvgLayer()
+svg_layer.load_svg("examples/floorplan.svg")
+svg_layer.setZValue(0)
+scene.addItem(svg_layer)
+
+# Heatmap Layer
+heatmap = HeatmapLayer(data)
+heatmap.setOpacity(0.6)
+heatmap.setZValue(1)
+heatmap.set_boundary_shape(svg_layer._bounding_rect)
+scene.addItem(heatmap)
+
+# Pin Layer
+pin_layer = PinLayer(data)
+pin_layer.setZValue(2)
+scene.addItem(pin_layer)
+
+# Value Layer
+values_layer = ValueLayer(data)
+values_layer.setZValue(3)
+scene.addItem(values_layer)
+
+# 3. Setup View
+view = QGraphicsView(scene)
+view.resize(800, 600)
+view.show()
+
+# Ensure content is visible
+scene.setSceneRect(scene.itemsBoundingRect())
+view.fitInView(scene.sceneRect(), Qt.AspectRatioMode.KeepAspectRatio)
+
+sys.exit(app.exec())
+```
+≈
+
+## Running the Demo
+
+To see all features in action, including the property editor and real-time interaction:
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/fieldview.git
+cd fieldview
+
+# Run the demo using uv (recommended)
+uv run examples/demo.py
+```
+
+<img src="assets/demo.gif" alt="Demo" width="800">
+
+## License
+
+MIT License

fieldview-0.1.0/fieldview/core/data_container.py

@@ -0,0 +1,158 @@
+import numpy as np
+from PySide6.QtCore import QObject, Signal
+
+class DataContainer(QObject):
+    """
+    Manages the core data (points and values) for the FieldView library.
+    Emits signals when data changes.
+    """
+    dataChanged = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self._points = np.empty((0, 2), dtype=float)
+        self._values = np.empty((0,), dtype=float)
+        self._labels = []
+
+    @property
+    def points(self):
+        return self._points
+
+    @property
+    def values(self):
+        return self._values
+
+    @property
+    def labels(self):
+        return self._labels
+
+    def set_data(self, points, values, labels=None):
+        """
+        Sets the data points, values, and optional labels.
+        
+        Args:
+            points (np.ndarray): Nx2 array of (x, y) coordinates.
+            values (np.ndarray): N array of values.
+            labels (list): Optional list of N strings.
+        """
+        points = np.array(points)
+        values = np.array(values)
+
+        if points.ndim != 2 or points.shape[1] != 2:
+            raise ValueError("Points must be an Nx2 array.")
+        if values.ndim != 1:
+            raise ValueError("Values must be a 1D array.")
+        if len(points) != len(values):
+            raise ValueError("Points and values must have the same length.")
+            
+        if labels is None:
+            labels = [""] * len(points)
+        elif len(labels) != len(points):
+            raise ValueError("Labels must have the same length as points.")
+
+        self._points = points
+        self._values = values
+        self._labels = list(labels)
+        self.dataChanged.emit()
+
+    def add_points(self, points, values, labels=None):
+        """
+        Adds new points, values, and optional labels.
+        """
+        points = np.array(points)
+        values = np.array(values)
+        
+        if len(points) == 0:
+            return
+            
+        if labels is None:
+            labels = [""] * len(points)
+        elif len(labels) != len(points):
+            raise ValueError("Labels must have the same length as points.")
+
+        if self._points.shape[0] == 0:
+            self.set_data(points, values, labels)
+        else:
+            self._points = np.vstack((self._points, points))
+            self._values = np.concatenate((self._values, values))
+            self._labels.extend(labels)
+            self.dataChanged.emit()
+
+    def update_point(self, index, value=None, point=None, label=None):
+        """
+        Updates the value, coordinate, or label of a specific point.
+        """
+        if index < 0 or index >= len(self._points):
+            raise IndexError("Point index out of range.")
+        
+        changed = False
+        if value is not None:
+            self._values[index] = value
+            changed = True
+        
+        if point is not None:
+            self._points[index] = point
+            changed = True
+            
+        if label is not None:
+            self._labels[index] = label
+            changed = True
+            
+        if changed:
+            self.dataChanged.emit()
+
+    def remove_points(self, indices):
+        """
+        Removes points at the specified indices.
+        """
+        if len(indices) == 0:
+            return
+            
+        # Sort indices in descending order to avoid shifting issues if we were popping,
+        # but numpy delete handles it. For list, we need to be careful.
+        # It's better to create a mask or rebuild the list.
+        
+        mask = np.ones(len(self._points), dtype=bool)
+        mask[indices] = False
+        
+        self._points = self._points[mask]
+        self._values = self._values[mask]
+        self._labels = [self._labels[i] for i in range(len(self._labels)) if mask[i]]
+        
+        self.dataChanged.emit()
+
+    def clear(self):
+        """
+        Removes all data.
+        """
+        self._points = np.empty((0, 2), dtype=float)
+        self._values = np.empty((0,), dtype=float)
+        self._labels = []
+        self.dataChanged.emit()
+
+    def get_closest_point(self, x, y, threshold=None):
+        """
+        Finds the index of the closest point to (x, y).
+        
+        Args:
+            x, y: Coordinates.
+            threshold: Optional maximum distance. If closest point is further, returns None.
+            
+        Returns:
+            int: Index of the closest point, or None.
+        """
+        if len(self._points) == 0:
+            return None
+
+        # Calculate squared distances
+        diff = self._points - np.array([x, y])
+        dist_sq = np.sum(diff**2, axis=1)
+        
+        min_idx = np.argmin(dist_sq)
+        min_dist_sq = dist_sq[min_idx]
+        
+        if threshold is not None:
+            if min_dist_sq > threshold**2:
+                return None
+                
+        return min_idx

fieldview-0.1.0/fieldview/layers/data_layer.py

@@ -0,0 +1,89 @@
+from PySide6.QtCore import QRectF
+import numpy as np
+from fieldview.layers.layer import Layer
+from fieldview.core.data_container import DataContainer
+
+class DataLayer(Layer):
+    """
+    Base class for layers that visualize data from a DataContainer.
+    Handles data change signals and excluded indices.
+    """
+    def __init__(self, data_container: DataContainer, parent=None):
+        super().__init__(parent)
+        self._data_container = data_container
+        self._excluded_indices = set()
+        
+        # Connect signal
+        self._data_container.dataChanged.connect(self.on_data_changed)
+        # Initial update
+        self.on_data_changed()
+
+    @property
+    def data_container(self):
+        return self._data_container
+
+    @property
+    def excluded_indices(self):
+        return self._excluded_indices
+
+    def set_excluded_indices(self, indices):
+        """
+        Sets the set of indices to exclude from visualization.
+        """
+        self._excluded_indices = set(indices)
+        self.update_layer()
+
+    def add_excluded_index(self, index):
+        self._excluded_indices.add(index)
+        self.update_layer()
+
+    def remove_excluded_index(self, index):
+        if index in self._excluded_indices:
+            self._excluded_indices.remove(index)
+            self.update_layer()
+
+    def clear_excluded_indices(self):
+        self._excluded_indices.clear()
+        self.update_layer()
+
+    def on_data_changed(self):
+        """
+        Slot called when DataContainer data changes.
+        """
+        self._update_bounding_rect()
+        self.update_layer()
+
+    def _update_bounding_rect(self):
+        points = self._data_container.points
+        if len(points) == 0:
+            return
+            
+        min_x = np.min(points[:, 0])
+        max_x = np.max(points[:, 0])
+        min_y = np.min(points[:, 1])
+        max_y = np.max(points[:, 1])
+        
+        # Add padding (e.g., for icons or text)
+        padding = 50
+        rect = QRectF(min_x - padding, min_y - padding, 
+                      max_x - min_x + 2*padding, max_y - min_y + 2*padding)
+        self.set_bounding_rect(rect)
+
+    def get_valid_data(self):
+        """
+        Returns points, values, and labels excluding the excluded indices.
+        """
+        points = self._data_container.points
+        values = self._data_container.values
+        labels = self._data_container.labels
+        
+        if not self._excluded_indices:
+            return points, values, labels
+            
+        # Create a mask for valid indices
+        mask = [i for i in range(len(points)) if i not in self._excluded_indices]
+        
+        # Filter labels (list)
+        valid_labels = [labels[i] for i in mask]
+        
+        return points[mask], values[mask], valid_labels