well-log-toolkit 0.1.116__tar.gz → 0.1.118__tar.gz

{well_log_toolkit-0.1.116 → well_log_toolkit-0.1.118}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.116
+Version: 0.1.118
 Summary: Fast LAS file processing with lazy loading and filtering for well log analysis
 Author-email: Kristian dF Kollsgård <kkollsg@gmail.com>
 License: MIT

{well_log_toolkit-0.1.116 → well_log_toolkit-0.1.118}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "well-log-toolkit"
-version = "0.1.116"
+version = "0.1.118"
 description = "Fast LAS file processing with lazy loading and filtering for well log analysis"
 readme = "README.md"
 requires-python = ">=3.9"

{well_log_toolkit-0.1.116 → well_log_toolkit-0.1.118}/well_log_toolkit/manager.py

@@ -2466,6 +2466,9 @@ class WellDataManager:
         depth_range: Optional[tuple[float, float]] = None,
         show_colorbar: bool = True,
         show_legend: bool = True,
+        show_regression_legend: bool = True,
+        show_regression_equation: bool = True,
+        show_regression_r2: bool = True,
         regression: Optional[Union[str, dict]] = None,
         regression_by_color: Optional[Union[str, dict]] = None,
         regression_by_group: Optional[Union[str, dict]] = None,
@@ -2534,6 +2537,12 @@ class WellDataManager:
             Show colorbar when using color mapping. Default: True
         show_legend : bool, optional
             Show legend. Default: True
+        show_regression_legend : bool, optional
+            Show separate legend for regression lines in lower right corner. Default: True
+        show_regression_equation : bool, optional
+            Include regression equation in regression legend labels. Default: True
+        show_regression_r2 : bool, optional
+            Include R² value in regression legend labels. Default: True
         regression : str or dict, optional
             Regression type to apply to all data points. Can be a string (e.g., "linear") or
             dict with keys: type, line_color, line_width, line_style, line_alpha, x_range.
@@ -2624,6 +2633,9 @@ class WellDataManager:
             depth_range=depth_range,
             show_colorbar=show_colorbar,
             show_legend=show_legend,
+            show_regression_legend=show_regression_legend,
+            show_regression_equation=show_regression_equation,
+            show_regression_r2=show_regression_r2,
             regression=regression,
             regression_by_color=regression_by_color,
             regression_by_group=regression_by_group,

{well_log_toolkit-0.1.116 → well_log_toolkit-0.1.118}/well_log_toolkit/visualization.py

@@ -2822,6 +2822,12 @@ class Crossplot:
         Show colorbar when using color mapping. Default: True
     show_legend : bool, optional
         Show legend when using shape/well mapping. Default: True
+    show_regression_legend : bool, optional
+        Show separate legend for regression lines in lower right. Default: True
+    show_regression_equation : bool, optional
+        Show equations in regression legend. Default: True
+    show_regression_r2 : bool, optional
+        Show R² values in regression legend. Default: True
     regression : str or dict, optional
         Regression type to apply to all data points. Can be a string (e.g., "linear") or
         dict with keys: type, line_color, line_width, line_style, line_alpha, x_range.
@@ -2912,9 +2918,12 @@ class Crossplot:
         depth_range: Optional[tuple[float, float]] = None,
         show_colorbar: bool = True,
         show_legend: bool = True,
-        regression: Optional[str] = None,
-        regression_by_color: Optional[str] = None,
-        regression_by_group: Optional[str] = None,
+        show_regression_legend: bool = True,
+        show_regression_equation: bool = True,
+        show_regression_r2: bool = True,
+        regression: Optional[Union[str, dict]] = None,
+        regression_by_color: Optional[Union[str, dict]] = None,
+        regression_by_group: Optional[Union[str, dict]] = None,
     ):
         # Store wells as list
         if not isinstance(wells, list):
@@ -2948,6 +2957,9 @@ class Crossplot:
         self.depth_range = depth_range
         self.show_colorbar = show_colorbar
         self.show_legend = show_legend
+        self.show_regression_legend = show_regression_legend
+        self.show_regression_equation = show_regression_equation
+        self.show_regression_r2 = show_regression_r2
         self.regression = regression
         self.regression_by_color = regression_by_color
         self.regression_by_group = regression_by_group
@@ -2961,6 +2973,7 @@ class Crossplot:
         # Regression storage - nested structure: {type: {identifier: regression_obj}}
         self._regressions = {}
         self.regression_lines = {}
+        self.regression_legend = None  # Separate legend for regressions
 
         # Pending regressions (added before plot() is called)
         self._pending_regressions = []
@@ -3126,6 +3139,158 @@ class Crossplot:
             self._regressions[reg_type] = {}
         self._regressions[reg_type][identifier] = regression_obj
 
+    def _find_best_legend_locations(self, data: pd.DataFrame) -> tuple[str, str]:
+        """Find the two best locations for legends based on data density.
+
+        Divides the plot into a 3x3 grid and finds the two squares with the least data points.
+
+        Args:
+            data: DataFrame with 'x' and 'y' columns
+
+        Returns:
+            Tuple of (primary_location, secondary_location) as matplotlib location strings
+        """
+        # Get x and y bounds
+        x_vals = data['x'].values
+        y_vals = data['y'].values
+
+        # Handle log scales for binning
+        if self.x_log:
+            x_vals = np.log10(x_vals[x_vals > 0])
+        if self.y_log:
+            y_vals = np.log10(y_vals[y_vals > 0])
+
+        x_min, x_max = np.nanmin(x_vals), np.nanmax(x_vals)
+        y_min, y_max = np.nanmin(y_vals), np.nanmax(y_vals)
+
+        # Create 3x3 grid and count points in each square
+        x_bins = np.linspace(x_min, x_max, 4)
+        y_bins = np.linspace(y_min, y_max, 4)
+
+        # Count points in each of 9 squares
+        counts = {}
+        for i in range(3):
+            for j in range(3):
+                x_mask = (x_vals >= x_bins[i]) & (x_vals < x_bins[i+1])
+                y_mask = (y_vals >= y_bins[j]) & (y_vals < y_bins[j+1])
+                counts[(i, j)] = np.sum(x_mask & y_mask)
+
+        # Map grid positions to matplotlib location strings
+        # Grid: (0,2) (1,2) (2,2)  ->  upper left, upper center, upper right
+        #       (0,1) (1,1) (2,1)  ->  center left, center, center right
+        #       (0,0) (1,0) (2,0)  ->  lower left, lower center, lower right
+        position_map = {
+            (0, 2): 'upper left',
+            (1, 2): 'upper center',
+            (2, 2): 'upper right',
+            (0, 1): 'center left',
+            (1, 1): 'center',
+            (2, 1): 'center right',
+            (0, 0): 'lower left',
+            (1, 0): 'lower center',
+            (2, 0): 'lower right',
+        }
+
+        # Sort squares by count (ascending)
+        sorted_squares = sorted(counts.items(), key=lambda x: x[1])
+
+        # Get two best locations
+        best_pos = position_map[sorted_squares[0][0]]
+        second_best_pos = position_map[sorted_squares[1][0]]
+
+        return best_pos, second_best_pos
+
+    def _format_regression_label(self, name: str, reg, include_equation: bool = None, include_r2: bool = None) -> str:
+        """Format a modern, compact regression label.
+
+        Args:
+            name: Name of the regression
+            reg: Regression object
+            include_equation: Whether to include equation (uses self.show_regression_equation if None)
+            include_r2: Whether to include R² (uses self.show_regression_r2 if None)
+
+        Returns:
+            Formatted label string
+        """
+        if include_equation is None:
+            include_equation = self.show_regression_equation
+        if include_r2 is None:
+            include_r2 = self.show_regression_r2
+
+        # Format: "Name (equation)" with R² on second line
+        # Equation and R² will be colored grey in the legend update method
+        first_line = name
+        if include_equation:
+            eq = reg.equation()
+            eq = eq.replace(' ', '')  # Remove spaces for compactness
+            # Add equation in parentheses (will be styled grey later)
+            first_line = f"{name} ({eq})"
+
+        # Add R² on second line if requested (will be styled grey later)
+        if include_r2:
+            return f"{first_line}\nR² = {reg.r_squared:.3f}"
+        else:
+            return first_line
+
+    def _update_regression_legend(self) -> None:
+        """Create or update the separate regression legend with smart placement."""
+        if not self.show_regression_legend or not self.regression_lines:
+            return
+
+        if self.ax is None:
+            return
+
+        # Remove old regression legend if it exists
+        if self.regression_legend is not None:
+            self.regression_legend.remove()
+            self.regression_legend = None
+
+        # Create new regression legend with only regression lines
+        regression_handles = []
+        regression_labels = []
+
+        for line in self.regression_lines.values():
+            regression_handles.append(line)
+            regression_labels.append(line.get_label())
+
+        if regression_handles:
+            # Get smart placement based on data density
+            if self._data is not None:
+                _, secondary_loc = self._find_best_legend_locations(self._data)
+            else:
+                # Fallback if data not available
+                secondary_loc = 'lower right'
+
+            # Import legend from matplotlib
+            from matplotlib.legend import Legend
+
+            # Create regression legend at secondary location
+            self.regression_legend = Legend(
+                self.ax,
+                regression_handles,
+                regression_labels,
+                loc=secondary_loc,
+                frameon=True,
+                framealpha=0.95,
+                edgecolor='#cccccc',
+                fancybox=False,
+                shadow=False,
+                fontsize=9,
+                title='Regressions',
+                title_fontsize=10
+            )
+
+            # Modern styling with grey text for equation and R²
+            self.regression_legend.get_frame().set_linewidth(0.8)
+            self.regression_legend.get_title().set_fontweight('600')
+
+            # Set text color to grey for all labels
+            for text in self.regression_legend.get_texts():
+                text.set_color('#555555')
+
+            # Add as artist to avoid replacing the primary legend
+            self.ax.add_artist(self.regression_legend)
+
     def _add_automatic_regressions(self, data: pd.DataFrame) -> None:
         """Add automatic regressions based on initialization parameters."""
         if not any([self.regression, self.regression_by_color, self.regression_by_group]):
@@ -3313,8 +3478,8 @@ class Crossplot:
             warnings.warn(f"Could not generate plot data for {name} regression: {e}")
             return
 
-        # Create label with equation and R²
-        label = f"{name}\n{reg.equation()}\nR² = {reg.r_squared:.4f}"
+        # Create label using formatter
+        label = self._format_regression_label(name, reg)
 
         # Plot line with config parameters
         line = self.ax.plot(
@@ -3328,9 +3493,9 @@ class Crossplot:
 
         self.regression_lines[name] = line
 
-        # Update legend if requested (skipped during batch operations for performance)
+        # Update regression legend if requested (skipped during batch operations for performance)
         if update_legend and self.ax is not None:
-            self.ax.legend(loc='best', frameon=True, framealpha=0.9, edgecolor='black')
+            self._update_regression_legend()
 
     def plot(self) -> 'Crossplot':
         """Generate the crossplot figure."""
@@ -3394,13 +3559,12 @@ class Crossplot:
                         warnings.warn(f"Could not generate plot data for {reg_type} regression: {e}")
                         continue
 
-                    # Create label
-                    label_parts = [reg_name]
-                    if pending['show_equation']:
-                        label_parts.append(reg.equation())
-                    if pending['show_r2']:
-                        label_parts.append(f"R² = {reg.r_squared:.4f}")
-                    label = "\n".join(label_parts)
+                    # Create label using formatter
+                    label = self._format_regression_label(
+                        reg_name, reg,
+                        include_equation=pending['show_equation'],
+                        include_r2=pending['show_r2']
+                    )
 
                     # Plot line
                     line = self.ax.plot(
@@ -3414,9 +3578,9 @@ class Crossplot:
 
                     self.regression_lines[reg_name] = line
 
-            # Update legend once after all pending regressions
+            # Update regression legend once after all pending regressions
             if self.ax is not None:
-                self.ax.legend(loc='best', frameon=True, framealpha=0.9, edgecolor='black')
+                self._update_regression_legend()
 
             # Clear pending list
             self._pending_regressions = []
@@ -3545,17 +3709,26 @@ class Crossplot:
             if first_scatter is None and self.color:
                 first_scatter = scatter
 
-        # Add legend
+        # Add legend with smart placement
         if self.show_legend:
+            # Get best location based on data density
+            if self._data is not None:
+                primary_loc, _ = self._find_best_legend_locations(self._data)
+            else:
+                primary_loc = 'best'
+
             legend = self.ax.legend(
                 title=group_label,
-                loc='best',
+                loc=primary_loc,
                 frameon=True,
                 framealpha=0.9,
                 edgecolor='black'
             )
             legend.get_title().set_fontweight('bold')
 
+            # Store the primary legend so it persists when regression legend is added
+            self.ax.add_artist(legend)
+
         # Add colorbar if using color mapping
         if self.color and self.show_colorbar and first_scatter:
             self.colorbar = self.fig.colorbar(first_scatter, ax=self.ax)
@@ -3650,13 +3823,12 @@ class Crossplot:
                 warnings.warn(f"Could not generate plot data for {regression_type} regression: {e}")
                 return self
 
-            # Create label
-            label_parts = [reg_name]
-            if show_equation:
-                label_parts.append(reg.equation())
-            if show_r2:
-                label_parts.append(f"R² = {reg.r_squared:.4f}")
-            label = "\n".join(label_parts)
+            # Create label using formatter
+            label = self._format_regression_label(
+                reg_name, reg,
+                include_equation=show_equation,
+                include_r2=show_r2
+            )
 
             # Plot line
             line = self.ax.plot(
@@ -3670,8 +3842,8 @@ class Crossplot:
 
             self.regression_lines[reg_name] = line
 
-            # Update legend
-            self.ax.legend(loc='best', frameon=True, framealpha=0.9, edgecolor='black')
+            # Update regression legend
+            self._update_regression_legend()
         else:
             # Store for later when plot() is called
             self._pending_regressions.append({

{well_log_toolkit-0.1.116 → well_log_toolkit-0.1.118}/well_log_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.116
+Version: 0.1.118
 Summary: Fast LAS file processing with lazy loading and filtering for well log analysis
 Author-email: Kristian dF Kollsgård <kkollsg@gmail.com>
 License: MIT