fieldview 0.1.0__py3-none-any.whl

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/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

fieldview/layers/heatmap_layer.py

@@ -0,0 +1,332 @@
+import numpy as np
+import time
+from scipy.interpolate import RBFInterpolator, LinearNDInterpolator
+from scipy.spatial import cKDTree
+from PySide6.QtGui import QImage, QPainter, QColor, QPolygonF, QPainterPath
+from PySide6.QtCore import Qt, QTimer, QRectF, QPointF, Signal
+
+from fieldview.layers.data_layer import DataLayer
+
+from fieldview.rendering.colormaps import get_colormap
+
+class HeatmapLayer(DataLayer):
+    """
+    Layer for rendering a heatmap from data points.
+    Implements hybrid interpolation (Linear for speed, RBF for quality)
+    and dynamic quality adjustment.
+    Supports arbitrary polygon boundaries.
+    """
+    renderingFinished = Signal(float, int) # Duration in ms, Grid Size
+
+    def __init__(self, data_container, parent=None):
+        super().__init__(data_container, parent)
+        
+        # Configuration
+        self._boundary_shape = QPolygonF() # Default empty
+        self._auto_boundary = True # Default to auto-fit data
+        self._grid_size = 50 # Start low for fast initial render
+        self._neighbors = 30
+        self._target_render_time = 100 # Default High (100ms)
+        self._hq_delay = 300 # ms
+        self._colormap = get_colormap("viridis")
+        
+        # Initialize with empty shape, will be set by on_data_changed if data exists
+        # or user can set it manually.
+        
+        # State
+        self._cached_image = None
+        self._heatmap_rect = QRectF()
+        self._is_hq_pending = False
+        
+        # Timer for High Quality update
+        self._hq_timer = QTimer()
+        self._hq_timer.setSingleShot(True)
+        self._hq_timer.setInterval(self._hq_delay)
+        self._hq_timer.timeout.connect(self._perform_hq_update)
+        
+        # Initial update
+        self.on_data_changed()
+
+    @property
+    def colormap(self):
+        return self._colormap.name
+
+    @colormap.setter
+    def colormap(self, name):
+        self._colormap = get_colormap(name)
+        self.update_layer()
+
+    @property
+    def target_render_time(self):
+        return self._target_render_time
+
+    @target_render_time.setter
+    def target_render_time(self, ms):
+        self._target_render_time = float(ms)
+        # Trigger update to adapt immediately
+        self.on_data_changed()
+
+    @property
+    def quality(self):
+        # Backward compatibility / UI helper
+        if self._target_render_time <= 20: return 'low'
+        if self._target_render_time <= 50: return 'medium'
+        return 'high'
+
+    @quality.setter
+    def quality(self, value):
+        if isinstance(value, str):
+            value = value.lower()
+        
+        if value in ['low', 0]:
+            self.target_render_time = 20
+        elif value in ['medium', 1]:
+            self.target_render_time = 50
+        elif value in ['high', 2]:
+            self.target_render_time = 100
+        else:
+            print(f"Warning: Invalid quality '{value}'. Ignoring.")
+
+    def set_boundary_shape(self, shape):
+        """
+        Sets the boundary polygon for the heatmap.
+        Accepts QPolygonF, QRectF, or QPainterPath.
+        Disables auto-boundary mode.
+        """
+        self._auto_boundary = False
+        
+        if isinstance(shape, QRectF):
+            self._boundary_shape = QPolygonF(shape)
+        elif isinstance(shape, QPainterPath):
+            self._boundary_shape = shape.toFillPolygon()
+        elif isinstance(shape, QPolygonF):
+            self._boundary_shape = shape
+        else:
+            raise TypeError("Shape must be QPolygonF, QRectF, or QPainterPath")
+
+        self.set_bounding_rect(self._boundary_shape.boundingRect())
+        # Trigger update to regenerate heatmap with new boundary
+        self.on_data_changed()
+
+    def on_data_changed(self):
+        """
+        Override to trigger fast update and schedule HQ update.
+        """
+        # Check if initialized
+        if not hasattr(self, '_grid_size'):
+            return
+
+        # Auto-boundary logic
+        if self._auto_boundary:
+            points, _, _ = self.get_valid_data()
+            if len(points) > 0:
+                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 some padding (e.g. 10%)
+                width = max_x - min_x
+                height = max_y - min_y
+                padding_x = max(10, width * 0.1)
+                padding_y = max(10, height * 0.1)
+                
+                rect = QRectF(min_x - padding_x, min_y - padding_y, 
+                              width + 2*padding_x, height + 2*padding_y)
+                self._boundary_shape = QPolygonF(rect)
+                self.set_bounding_rect(rect)
+            else:
+                self._boundary_shape = QPolygonF()
+                self.set_bounding_rect(QRectF())
+
+        # 1. Cancel any pending HQ update
+        if hasattr(self, '_hq_timer'):
+            self._hq_timer.stop()
+        
+        # 2. Perform Fast Update (Low-Res RBF)
+        # Use 1/10th of the grid size for speed (e.g., 30x30 instead of 300x300)
+        low_res_size = max(10, int(self._grid_size / 1.6))
+        self._generate_heatmap(method='rbf', neighbors=self._neighbors, grid_size=low_res_size)
+        self.update()
+        
+        # 3. Schedule High Quality Update
+        if hasattr(self, '_hq_timer'):
+            self._hq_timer.start()
+
+    def _perform_hq_update(self):
+        """
+        Slot for HQ timer timeout. Performs RBF interpolation.
+        """
+        self._generate_heatmap(method='rbf', neighbors=self._neighbors, grid_size=self._grid_size)
+        self.update()
+
+    def _generate_heatmap(self, method='rbf', neighbors=30, grid_size=None):
+        """
+        Generates the heatmap image.
+        """
+        start_time = time.perf_counter()
+
+        if grid_size is None:
+            grid_size = self._grid_size
+
+        points, values, _ = self.get_valid_data()
+        
+        if len(points) < 3 or self._boundary_shape.isEmpty():
+            self._cached_image = None
+            return
+
+        # print(f"Total: {duration_ms:.1f}ms | Boundary: {(t1-t0)*1000:.1f}ms | Interp: {(t3-t2)*1000:.1f}ms | Image: {(t4-t3)*1000:.1f}ms")
+        
+        self.renderingFinished.emit(duration_ms, grid_size)
+
+        # 7. Adaptive Quality Adjustment
+        if self._target_render_time > 0 and duration_ms > 0:
+            # Calculate target grid size
+            # Time is roughly proportional to grid_size^2 (number of evaluation points)
+            # target_time / current_time = target_grid^2 / current_grid^2
+            # target_grid = current_grid * sqrt(target_time / current_time)
+            
+            ratio = self._target_render_time / duration_ms
+            # Clamp ratio to prevent wild swings (e.g., 0.5x to 2.0x)
+            ratio = max(0.5, min(2.0, ratio))
+            
+            new_grid_size = int(grid_size * np.sqrt(ratio))
+            
+            # Clamp grid size
+            new_grid_size = max(30, min(500, new_grid_size))
+            
+            # Apply smoothing (EMA)
+            alpha = 0.3
+            self._grid_size = int(alpha * new_grid_size + (1 - alpha) * self._grid_size)
+            
+
+            print(f"Render: {duration_ms:.1f}ms, Target: {self._target_render_time}ms, Ratio {ratio:.2f} New Grid: {self._grid_size}")
+
+    def _generate_boundary_points(self, points, values):
+        """
+        Generates ghost points on the boundary using adaptive sampling and IDW.
+        """
+        if len(points) < 2:
+            return np.empty((0, 2)), np.empty((0,))
+
+        # Adaptive Sampling
+        tree = cKDTree(points)
+        distances, _ = tree.query(points, k=2)
+        avg_dist = np.mean(distances[:, 1])
+        target_segment_length = avg_dist * 1.2
+        if target_segment_length <= 0: target_segment_length = 10.0
+        
+        boundary_points_list = []
+        
+        # Iterate through polygon edges
+        poly_points = [self._boundary_shape.at(i) for i in range(self._boundary_shape.count())]
+        if self._boundary_shape.isClosed():
+             # QPolygonF might be closed or not depending on creation. 
+             # If last point != first point, close it effectively for iteration
+             if poly_points[0] != poly_points[-1]:
+                 poly_points.append(poly_points[0])
+        else:
+             poly_points.append(poly_points[0]) # Close the loop
+             
+        for i in range(len(poly_points) - 1):
+            p1 = np.array([poly_points[i].x(), poly_points[i].y()])
+            p2 = np.array([poly_points[i+1].x(), poly_points[i+1].y()])
+            
+            segment_len = np.linalg.norm(p2 - p1)
+            n_segments = int(np.ceil(segment_len / target_segment_length))
+            n_segments = max(1, n_segments)
+            
+            for j in range(n_segments):
+                t = j / n_segments
+                pt = p1 + t * (p2 - p1)
+                boundary_points_list.append(pt)
+                
+        boundary_points = np.array(boundary_points_list)
+        
+        if len(boundary_points) == 0:
+             return np.empty((0, 2)), np.empty((0,))
+
+        # IDW for Values
+        dists, indices = tree.query(boundary_points, k=2)
+        boundary_values = []
+        
+        for i in range(len(boundary_points)):
+            d1, d2 = dists[i]
+            idx1, idx2 = indices[i]
+            v1, v2 = values[idx1], values[idx2]
+            
+            if d1 < 1e-9: val = v1
+            elif d2 < 1e-9: val = v2
+            else:
+                w1 = 1.0 / d1
+                w2 = 1.0 / d2
+                val = (w1 * v1 + w2 * v2) / (w1 + w2)
+            boundary_values.append(val)
+            
+        return boundary_points, np.array(boundary_values)
+
+    def _array_to_qimage(self, Z):
+        """
+        Converts 2D array Z to QImage using vectorized operations.
+        """
+        height, width = Z.shape
+        
+        # 1. Normalize Z to 0-255 indices
+        Z_norm = np.nan_to_num(Z, nan=-1)
+        max_val = np.nanmax(Z_norm)
+        if max_val == 0: max_val = 1
+        
+        # Create indices array
+        # Values < 0 (NaNs) will be handled separately or mapped to 0
+        # We want -1 to stay -1 or be handled. 
+        # Let's map valid values to 0-255.
+        
+        # Mask for transparent pixels
+        mask = (Z_norm == -1)
+        
+        # Normalize valid values to 0.0-1.0
+        normalized = np.clip(Z_norm / max_val, 0.0, 1.0)
+        
+        # Map to 0-255 indices
+        indices = (normalized * 255).astype(np.uint8)
+        
+        # 2. Get LUT
+        lut = self._colormap.get_lut(256)
+        
+        # 3. Map indices to ARGB values
+        # lut is (256,) uint32
+        # buffer will be (height, width) uint32
+        buffer = lut[indices]
+        
+        # 4. Apply Transparency
+        # Set alpha to 0 for masked pixels
+        # 0x00FFFFFF mask clears Alpha channel, but we want 0x00000000 for full transparency
+        buffer[mask] = 0x00000000
+        
+        # 5. Create QImage from buffer
+        # We need to ensure the buffer is contiguous and kept alive
+        # QImage(uchar *data, int width, int height, Format format)
+        # We can use memoryview
+        
+        # Make sure buffer is C-contiguous
+        if not buffer.flags['C_CONTIGUOUS']:
+            buffer = np.ascontiguousarray(buffer)
+            
+        image = QImage(buffer.data, width, height, width * 4, QImage.Format.Format_ARGB32)
+        
+        # We must copy the image data because QImage doesn't own the buffer
+        # and 'buffer' might be garbage collected after this function returns.
+        return image.copy()
+
+    def paint(self, painter, option, widget):
+        if self._cached_image:
+            # Clip to polygon
+            path = QPainterPath()
+            path.addPolygon(self._boundary_shape)
+            painter.setClipPath(path)
+            
+            # Draw the expanded heatmap
+            # Enable smooth transformation for upscaling low-res images
+            painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
+            painter.drawImage(self._heatmap_rect, self._cached_image)
+

fieldview/layers/layer.py

@@ -0,0 +1,31 @@
+from PySide6.QtWidgets import QGraphicsObject
+from PySide6.QtCore import QRectF
+
+class Layer(QGraphicsObject):
+    """
+    Abstract base class for all visual layers in FieldView.
+    Inherits from QGraphicsObject to support signals and integration with QGraphicsScene.
+    """
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._bounding_rect = QRectF(0, 0, 300, 300) # Default size, should be updated by subclasses
+
+    def boundingRect(self):
+        return self._bounding_rect
+
+    def set_bounding_rect(self, rect):
+        self._bounding_rect = rect
+        self.prepareGeometryChange()
+        self.update()
+
+    def paint(self, painter, option, widget):
+        """
+        Default paint implementation. Subclasses should override this.
+        """
+        pass
+
+    def update_layer(self):
+        """
+        Triggers a layer update. Can be overridden to perform calculation before repaint.
+        """
+        self.update()

fieldview/layers/pin_layer.py

@@ -0,0 +1,37 @@
+from PySide6.QtGui import QPixmap, QPainter
+from PySide6.QtCore import QPointF, Qt, QRectF
+from fieldview.layers.data_layer import DataLayer
+
+class PinLayer(DataLayer):
+    """
+    Layer for rendering icons (pins) at data points.
+    """
+    def __init__(self, data_container, parent=None):
+        super().__init__(data_container, parent)
+        self._icon = None
+        self._icon_size = 24 # Default size
+
+    @property
+    def icon(self):
+        return self._icon
+
+    def set_icon(self, icon: QPixmap):
+        self._icon = icon
+        self.update_layer()
+
+    def paint(self, painter, option, widget):
+        points, _, _ = self.get_valid_data()
+        
+        if self._icon:
+            w = self._icon.width()
+            h = self._icon.height()
+            for x, y in points:
+                target_rect = QRectF(x - w/2, y - h/2, w, h)
+                painter.drawPixmap(target_rect.toRect(), self._icon)
+        else:
+            # Default: Black dot
+            painter.setBrush(Qt.GlobalColor.black)
+            painter.setPen(Qt.NoPen)
+            r = 3 # Radius
+            for x, y in points:
+                painter.drawEllipse(QPointF(x, y), r, r)

fieldview/layers/svg_layer.py

@@ -0,0 +1,33 @@
+from PySide6.QtSvg import QSvgRenderer
+from PySide6.QtGui import QPainter
+from PySide6.QtCore import QRectF
+from fieldview.layers.layer import Layer
+
+class SvgLayer(Layer):
+    """
+    Layer for rendering an SVG file.
+    """
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._renderer = QSvgRenderer()
+        self._svg_path = ""
+
+    @property
+    def svg_path(self):
+        return self._svg_path
+
+    def load_svg(self, path):
+        """
+        Loads an SVG file from the given path.
+        """
+        self._svg_path = path
+        if self._renderer.load(path):
+            self.set_bounding_rect(self._renderer.viewBoxF())
+            self.update_layer()
+        else:
+            print(f"Failed to load SVG: {path}")
+
+    def paint(self, painter, option, widget):
+        if self._renderer.isValid():
+            # Render SVG to fit the bounding rect
+            self._renderer.render(painter, self.boundingRect())

fieldview/layers/text_layer.py

@@ -0,0 +1,224 @@
+from PySide6.QtGui import QFont, QColor, QFontDatabase
+from PySide6.QtCore import Qt, QRectF, QPointF
+import os
+from fieldview.layers.data_layer import DataLayer
+
+class TextLayer(DataLayer):
+    """
+    Abstract base class for text-based layers.
+    Handles font, opacity, and highlighting.
+    """
+    def __init__(self, data_container, parent=None):
+        super().__init__(data_container, parent)
+        
+        # Load embedded font
+        font_path = os.path.join(os.path.dirname(__file__), '..', 'resources', 'fonts', 'JetBrainsMono-Regular.ttf')
+        font_path = os.path.abspath(font_path)
+        
+        font_id = QFontDatabase.addApplicationFont(font_path)
+        if font_id != -1:
+            font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
+            self._font = QFont(font_family)
+        else:
+            # Fallback
+            self._font = QFont("JetBrains Mono")
+            if not QFontDatabase.families(QFontDatabase.WritingSystem.Latin).count("JetBrains Mono"):
+                 self._font.setStyleHint(QFont.StyleHint.Monospace)
+        
+        self._font.setPixelSize(12)
+        
+        self._text_color = QColor(Qt.GlobalColor.white)
+        self._bg_color = QColor(0, 0, 0, 180) # Semi-transparent black
+        self._highlight_color = QColor(Qt.GlobalColor.yellow)
+        self._highlighted_indices = set()
+        
+        self._collision_avoidance_enabled = True
+        self._collision_offset_factor = 0.6 # Default 60%
+        self._cached_layout = None
+
+    @property
+    def font(self):
+        return self._font
+
+    @font.setter
+    def font(self, value):
+        self._font = value
+        self.update_layer()
+
+    @property
+    def highlighted_indices(self):
+        return self._highlighted_indices
+
+    def set_highlighted_indices(self, indices):
+        self._highlighted_indices = set(indices)
+        self.update_layer()
+
+    @property
+    def collision_avoidance_enabled(self):
+        return self._collision_avoidance_enabled
+
+    @collision_avoidance_enabled.setter
+    def collision_avoidance_enabled(self, enabled):
+        self._collision_avoidance_enabled = enabled
+        self.update_layer()
+
+    @property
+    def collision_offset_factor(self):
+        return self._collision_offset_factor
+
+    @collision_offset_factor.setter
+    def collision_offset_factor(self, factor):
+        self._collision_offset_factor = factor
+        self.update_layer()
+
+    def update_layer(self):
+        self._cached_layout = None
+        super().update_layer()
+
+    def paint(self, painter, option, widget):
+        points, values, labels = self.get_valid_data()
+        
+        painter.setFont(self._font)
+        metrics = painter.fontMetrics()
+        
+        if self._cached_layout is None:
+            self._cached_layout = self._calculate_layout(points, values, labels, metrics)
+            
+        for i, rect in self._cached_layout.items():
+            text = self._get_text(i, values[i], labels[i])
+            if not text: continue
+            
+            # Determine background color
+            bg_color = self._highlight_color if i in self._highlighted_indices else self._bg_color
+            
+            # Draw background
+            painter.fillRect(rect, bg_color)
+            
+            # Draw text
+            painter.setPen(self._text_color if i not in self._highlighted_indices else Qt.GlobalColor.black)
+            painter.drawText(rect, Qt.AlignmentFlag.AlignCenter, text)
+
+    def _calculate_layout(self, points, values, labels, metrics):
+        layout = {} # index -> QRectF
+        placed_rects = []
+        
+        for i, (x, y) in enumerate(points):
+            text = self._get_text(i, values[i], labels[i])
+            if not text: continue
+            
+            rect = metrics.boundingRect(text)
+            # Add padding
+            rect.adjust(-2, -2, 2, 2)
+            w, h = rect.width(), rect.height()
+            
+            # Calculate offset distance based on factor
+            # Factor 0.6 means move 60% of dimension.
+            # Center is 0 offset.
+            # Top: y - h * factor
+            # Bottom: y + h * factor
+            # Left: x - w * factor
+            # Right: x + w * factor
+            
+            factor = self._collision_offset_factor
+            
+            candidates = [
+                QPointF(x, y), # Center
+                QPointF(x, y - h * factor), # Top
+                QPointF(x, y + h * factor), # Bottom
+                QPointF(x - w * factor, y), # Left
+                QPointF(x + w * factor, y)  # Right
+            ]
+            
+            chosen_rect = None
+            
+            if self._collision_avoidance_enabled:
+                best_rect = None
+                min_cost = float('inf')
+                
+                for center in candidates:
+                    candidate_rect = QRectF(rect)
+                    candidate_rect.moveCenter(center)
+                    
+                    # Calculate cost (total intersection area)
+                    cost = 0.0
+                    for placed in placed_rects:
+                        intersection = candidate_rect.intersected(placed)
+                        if not intersection.isEmpty():
+                            cost += intersection.width() * intersection.height()
+                    
+                    # If perfect placement found, take it immediately
+                    if cost == 0:
+                        best_rect = candidate_rect
+                        break
+                    
+                    # Otherwise keep track of the best so far
+                    if cost < min_cost:
+                        min_cost = cost
+                        best_rect = candidate_rect
+                
+                chosen_rect = best_rect
+            else:
+                # Just Center
+                chosen_rect = QRectF(rect)
+                chosen_rect.moveCenter(QPointF(x, y))
+                
+            layout[i] = chosen_rect
+            placed_rects.append(chosen_rect)
+            
+        return layout
+
+    def _get_text(self, index, value, label):
+        """
+        Abstract method to get text for a point.
+        """
+        raise NotImplementedError
+
+class ValueLayer(TextLayer):
+    """
+    Renders numerical values.
+    """
+    def __init__(self, data_container, parent=None):
+        super().__init__(data_container, parent)
+        self._decimal_places = 2
+        self._suffix = ""
+        self._postfix = "" # Same as suffix? antigravity.md says both. Let's assume prefix/suffix or just suffix.
+        # antigravity.md says "Can add suffix, postfix". Maybe prefix/suffix? 
+        # Let's implement prefix and suffix.
+        self._prefix = ""
+
+    @property
+    def decimal_places(self):
+        return self._decimal_places
+
+    @decimal_places.setter
+    def decimal_places(self, value):
+        self._decimal_places = value
+        self.update_layer()
+
+    @property
+    def suffix(self):
+        return self._suffix
+
+    @suffix.setter
+    def suffix(self, value):
+        self._suffix = value
+        self.update_layer()
+        
+    @property
+    def prefix(self):
+        return self._prefix
+
+    @prefix.setter
+    def prefix(self, value):
+        self._prefix = value
+        self.update_layer()
+
+    def _get_text(self, index, value, label):
+        return f"{self._prefix}{value:.{self._decimal_places}f}{self._suffix}"
+
+class LabelLayer(TextLayer):
+    """
+    Renders text labels.
+    """
+    def _get_text(self, index, value, label):
+        return str(label)

fieldview/rendering/colormaps.py

@@ -0,0 +1,97 @@
+from PySide6.QtGui import QColor
+import numpy as np
+
+class Colormap:
+    """
+    Simple colormap implementation using linear interpolation of stops.
+    """
+    def __init__(self, name, stops):
+        """
+        Args:
+            name (str): Name of the colormap.
+            stops (list): List of (position, color_hex) tuples. 
+                          Position is 0.0 to 1.0.
+        """
+        self.name = name
+        self.stops = sorted(stops, key=lambda x: x[0])
+        
+    def map(self, value):
+        """
+        Maps a value (0.0 to 1.0) to a QColor.
+        """
+        value = max(0.0, min(1.0, value))
+        
+        # Find segment
+        for i in range(len(self.stops) - 1):
+            p1, c1_hex = self.stops[i]
+            p2, c2_hex = self.stops[i+1]
+            
+            if p1 <= value <= p2:
+                t = (value - p1) / (p2 - p1) if p2 > p1 else 0
+                c1 = QColor(c1_hex)
+                c2 = QColor(c2_hex)
+                
+                r = int(c1.red() * (1-t) + c2.red() * t)
+                g = int(c1.green() * (1-t) + c2.green() * t)
+                b = int(c1.blue() * (1-t) + c2.blue() * t)
+                
+                return QColor(r, g, b)
+                
+        # Fallback (should cover 0.0 to 1.0 if stops are correct)
+        return QColor(self.stops[-1][1])
+
+    def get_lut(self, size=256):
+        """
+        Returns a numpy array of shape (size,) containing uint32 ARGB values.
+        """
+        if hasattr(self, '_lut') and len(self._lut) == size:
+            return self._lut
+            
+        lut = np.zeros(size, dtype=np.uint32)
+        
+        for i in range(size):
+            val = i / (size - 1)
+            color = self.map(val)
+            # ARGB32 format: 0xAARRGGBB
+            # QColor.rgba() returns 0xAARRGGBB (unsigned int)
+            lut[i] = color.rgba()
+            
+        self._lut = lut
+        return lut
+
+# Standard Colormaps (Approximations)
+VIRIDIS = Colormap("viridis", [
+    (0.0, "#440154"), (0.25, "#3b528b"), (0.5, "#21918c"), (0.75, "#5ec962"), (1.0, "#fde725")
+])
+
+PLASMA = Colormap("plasma", [
+    (0.0, "#0d0887"), (0.25, "#7e03a8"), (0.5, "#cc4778"), (0.75, "#f89540"), (1.0, "#f0f921")
+])
+
+INFERNO = Colormap("inferno", [
+    (0.0, "#000004"), (0.25, "#57106e"), (0.5, "#bb3754"), (0.75, "#f98e09"), (1.0, "#fcffa4")
+])
+
+MAGMA = Colormap("magma", [
+    (0.0, "#000004"), (0.25, "#51127c"), (0.5, "#b73779"), (0.75, "#fc8961"), (1.0, "#fcfdbf")
+])
+
+COOLWARM = Colormap("coolwarm", [
+    (0.0, "#3b4cc0"), (0.5, "#dddddd"), (1.0, "#b40426")
+])
+
+JET = Colormap("jet", [
+    (0.0, "#000080"), (0.125, "#0000ff"), (0.375, "#00ffff"), (0.625, "#ffff00"), (0.875, "#ff0000"), (1.0, "#800000")
+])
+
+COLORMAPS = {
+    "viridis": VIRIDIS,
+    "plasma": PLASMA,
+    "inferno": INFERNO,
+    "magma": MAGMA,
+    "coolwarm": COOLWARM,
+    "jet": JET
+}
+
+def get_colormap(name):
+    return COLORMAPS.get(name.lower(), VIRIDIS)

fieldview-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,18 @@
+fieldview/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fieldview/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fieldview/core/data_container.py,sha256=yS3FAD7dd7kFhhwYwm_UM7q4ACAuNLvJryVOXjV8eIA,4856
+fieldview/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fieldview/layers/data_layer.py,sha256=UAF0xGAhfK0ajOkI0c6h7BSC50tctqTWkBx4MMgQyvE,2781
+fieldview/layers/heatmap_layer.py,sha256=JqMpzNqm4qcJUCrNmrF-mdi-2889FuGi-A_nar5Lpos,12177
+fieldview/layers/layer.py,sha256=nf8n4wwu7OZ-jlGvBUv4p2Ve1CG8ydDIMcABv9UdRFQ,966
+fieldview/layers/pin_layer.py,sha256=OzVaaTNAa2-U9HbW81f0-Z2dJQ3FIUf-pLx46r6eBZU,1173
+fieldview/layers/svg_layer.py,sha256=k8TmHtsNpc91f5XJThwv8yiz8Q6CKXQvLuu0FHtqp3g,958
+fieldview/layers/text_layer.py,sha256=kcElddy_4ptg3C78FKne7SXdz_oidJbpVRcic3X0M3g,7531
+fieldview/rendering/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fieldview/rendering/colormaps.py,sha256=sAMTrIaPduDbo3J4CHGgzkyrj7P9l12RJ7CQrlSzz-c,2936
+fieldview/resources/fonts/JetBrainsMono-Regular.ttf,sha256=5v0NfpFVCz7StzXUMSR0NixHFu3E_AV3oPYe14LVrtE,270224
+fieldview/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fieldview-0.1.0.dist-info/METADATA,sha256=AYq0l90iQ2US8MyBTz-NkealoWoLcW1YRGIy3OzAYpk,3417
+fieldview-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fieldview-0.1.0.dist-info/licenses/LICENSE,sha256=_dBWGupPPCAjQesnfC8ptV_FibraRiMR04MCJlpQFDw,1071
+fieldview-0.1.0.dist-info/RECORD,,

fieldview-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fieldview-0.1.0.dist-info/licenses/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.