well-log-toolkit 0.1.115__py3-none-any.whl → 0.1.117__py3-none-any.whl

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,14 +2537,21 @@ 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.
             Default: None
         regression_by_color : str or dict, optional
-            Regression type to apply separately for each color group. Creates separate
-            regression lines for each unique color value. Accepts string or dict format.
-            Default: None
+            Regression type to apply separately for each color group in the plot. Creates
+            separate regression lines based on what determines colors in the visualization:
+            explicit color mapping if specified, otherwise shape groups (e.g., wells when
+            shape='well'). Accepts string or dict format. Default: None
         regression_by_group : str or dict, optional
             Regression type to apply separately for each well. Creates separate
             regression lines for each well. Accepts string or dict format.
@@ -2623,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/visualization.py

@@ -2822,14 +2822,21 @@ 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.
         Default: None
     regression_by_color : str or dict, optional
-        Regression type to apply separately for each color group. Creates separate
-        regression lines for each unique color value. Accepts string or dict format.
-        Default: None
+        Regression type to apply separately for each color group in the plot. Creates
+        separate regression lines based on what determines colors in the visualization:
+        explicit color mapping if specified, otherwise shape groups (e.g., wells when
+        shape='well'). Accepts string or dict format. Default: None
     regression_by_group : str or dict, optional
         Regression type to apply separately for each group (well or shape). Creates
         separate regression lines for each well or shape category. Accepts string or dict.
@@ -2911,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):
@@ -2947,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
@@ -2960,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 = []
@@ -3125,6 +3139,121 @@ class Crossplot:
             self._regressions[reg_type] = {}
         self._regressions[reg_type][identifier] = regression_obj
 
+    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
+
+        # Start with name
+        parts = [name]
+
+        # Add equation and R² on same line if both shown, more compact
+        metrics = []
+        if include_equation:
+            eq = reg.equation()
+            # Shorten equation format for compactness
+            eq = eq.replace(' ', '')  # Remove spaces
+            metrics.append(eq)
+
+        if include_r2:
+            # Use superscript 2 for R²
+            metrics.append(f"R²={reg.r_squared:.3f}")
+
+        if metrics:
+            # Join equation and R² with pipe separator for clarity
+            parts.append(" | ".join(metrics))
+
+        return "\n".join(parts)
+
+    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:
+            # Smart placement: try these locations in priority order
+            # Prefer corners away from main legend and colorbar
+            locations = [
+                'lower right',   # Primary choice
+                'upper right',   # If lower right conflicts with data
+                'lower left',    # If right side has colorbar/main legend
+                'center right',  # Fallback
+            ]
+
+            # If main legend is shown, it's likely in upper left
+            # If colorbar is shown, it's on the right side
+            # Adjust preferences based on what's visible
+            if self.show_legend and self.show_colorbar:
+                # Both legend and colorbar present - lower left might be better
+                locations = ['lower left', 'lower right', 'upper right', 'center left']
+            elif self.show_colorbar:
+                # Colorbar on right - prefer left side
+                locations = ['lower left', 'upper left', 'lower right', 'center left']
+
+            # Try to create legend with best location
+            # Use 'best' as fallback - matplotlib will find optimal position
+            try:
+                self.regression_legend = self.ax.legend(
+                    regression_handles,
+                    regression_labels,
+                    loc=locations[0],  # Try first preference
+                    frameon=True,
+                    framealpha=0.95,
+                    edgecolor='#cccccc',
+                    fancybox=False,
+                    shadow=False,
+                    fontsize=9,
+                    title='Regressions',
+                    title_fontsize=10
+                )
+            except Exception:
+                # Fallback to 'best' if specific location fails
+                self.regression_legend = self.ax.legend(
+                    regression_handles,
+                    regression_labels,
+                    loc='best',
+                    frameon=True,
+                    framealpha=0.95,
+                    edgecolor='#cccccc',
+                    fancybox=False,
+                    shadow=False,
+                    fontsize=9,
+                    title='Regressions',
+                    title_fontsize=10
+                )
+
+            # Modern styling
+            self.regression_legend.get_frame().set_linewidth(0.8)
+            self.regression_legend.get_title().set_fontweight('600')
+
     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]):
@@ -3162,53 +3291,70 @@ class Crossplot:
             config = self._parse_regression_config(self.regression_by_color)
             reg_type = config['type']
 
-            if not self.color:
-                warnings.warn("regression_by_color specified but no color mapping defined, skipping")
+            # Determine grouping column based on what's being used for colors in the plot
+            group_column = None
+            group_label = None
+
+            if self.color and 'color_val' in data.columns:
+                # User specified explicit color mapping
+                group_column = 'color_val'
+                group_label = self.color
+            elif self.shape == "well" and 'well' in data.columns:
+                # When shape="well", each well gets a different color in the plot
+                group_column = 'well'
+                group_label = 'well'
+            elif self.shape and self.shape != "well" and 'shape_val' in data.columns:
+                # When shape is a property, each shape group gets a different color
+                group_column = 'shape_val'
+                group_label = self.shape
+
+            if group_column is None:
+                warnings.warn(
+                    "regression_by_color specified but no color grouping detected in plot. "
+                    "Use color=<property>, shape='well', or shape=<property> parameter."
+                )
             else:
-                # Get unique color groups
-                if 'color_val' in data.columns:
-                    # For continuous color values, we need to bin them or use unique values
-                    # Check if color is categorical (well, shape) or continuous
-                    if self.color == 'depth' or pd.api.types.is_numeric_dtype(data['color_val']):
-                        # For continuous values, we can't create separate regressions
-                        warnings.warn(
-                            f"regression_by_color requires categorical color mapping, "
-                            f"but '{self.color}' is continuous. Use regression_by_group instead."
+                # Check if color is categorical (not continuous like depth)
+                if group_column == 'color_val' and (self.color == 'depth' or pd.api.types.is_numeric_dtype(data[group_column])):
+                    # For continuous values, we can't create separate regressions
+                    warnings.warn(
+                        f"regression_by_color requires categorical color mapping, "
+                        f"but '{self.color}' is continuous. Use regression_by_group instead."
+                    )
+                else:
+                    # Categorical values - group and create regressions
+                    color_groups = data.groupby(group_column)
+                    n_groups = len(color_groups)
+
+                    # Validate regression count
+                    if regression_count + n_groups > total_points / 2:
+                        raise ValueError(
+                            f"Too many regression lines requested: {regression_count + n_groups} lines "
+                            f"for {total_points} data points (average < 2 points per line). "
+                            f"Reduce the number of groups or use a different regression strategy."
                         )
-                    else:
-                        # Categorical color values
-                        color_groups = data.groupby('color_val')
-                        n_groups = len(color_groups)
-
-                        # Validate regression count
-                        if regression_count + n_groups > total_points / 2:
-                            raise ValueError(
-                                f"Too many regression lines requested: {regression_count + n_groups} lines "
-                                f"for {total_points} data points (average < 2 points per line). "
-                                f"Reduce the number of groups or use a different regression strategy."
-                            )
 
-                        for idx, (group_name, group_data) in enumerate(color_groups):
-                            x_vals = group_data['x'].values
-                            y_vals = group_data['y'].values
-                            mask = np.isfinite(x_vals) & np.isfinite(y_vals)
-                            if np.sum(mask) >= 2:
-                                # Copy config and set default line color if not specified
-                                group_config = config.copy()
-                                if 'line_color' not in group_config:
-                                    group_config['line_color'] = regression_colors[color_idx % len(regression_colors)]
-
-                                # Skip legend update for all but last regression
-                                is_last = (idx == n_groups - 1)
-                                self._add_group_regression(
-                                    x_vals[mask], y_vals[mask],
-                                    reg_type,
-                                    name=f"{self.color}={group_name}",
-                                    config=group_config,
-                                    update_legend=is_last
-                                )
-                                regression_count += 1
-                                color_idx += 1
+                    for idx, (group_name, group_data) in enumerate(color_groups):
+                        x_vals = group_data['x'].values
+                        y_vals = group_data['y'].values
+                        mask = np.isfinite(x_vals) & np.isfinite(y_vals)
+                        if np.sum(mask) >= 2:
+                            # Copy config and set default line color if not specified
+                            group_config = config.copy()
+                            if 'line_color' not in group_config:
+                                group_config['line_color'] = regression_colors[color_idx % len(regression_colors)]
+
+                            # Skip legend update for all but last regression
+                            is_last = (idx == n_groups - 1)
+                            self._add_group_regression(
+                                x_vals[mask], y_vals[mask],
+                                reg_type,
+                                name=f"{group_label}={group_name}",
+                                config=group_config,
+                                update_legend=is_last
+                            )
+                            regression_count += 1
+                            color_idx += 1
 
         # Add regression by groups (well or shape)
         if self.regression_by_group:
@@ -3295,8 +3441,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(
@@ -3310,9 +3456,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."""
@@ -3376,13 +3522,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(
@@ -3396,9 +3541,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 = []
@@ -3632,13 +3777,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(
@@ -3652,8 +3796,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.115.dist-info → well_log_toolkit-0.1.117.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.115
+Version: 0.1.117
 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.115.dist-info → well_log_toolkit-0.1.117.dist-info}/RECORD

@@ -1,15 +1,15 @@
 well_log_toolkit/__init__.py,sha256=ilJAIIhh68pYfD9I3V53juTEJpoMN8oHpcpEFNpuXAQ,3793
 well_log_toolkit/exceptions.py,sha256=X_fzC7d4yaBFO9Vx74dEIB6xmI9Agi6_bTU3MPxn6ko,985
 well_log_toolkit/las_file.py,sha256=yRCIiVbdoqFzoXKRKfx7Lt11INmwB_bXdpHpwVaNpjk,52156
-well_log_toolkit/manager.py,sha256=gajHbQc1zI7L0gSmcZOUg1_aSje4SZoqSff3uu3C7Hg,101585
+well_log_toolkit/manager.py,sha256=Mc_zgC9pgbYq82msiAc0KMVmPFbCX90SZK5JfwGY4H4,102422
 well_log_toolkit/operations.py,sha256=z8j8fGBOwoJGUQFy-Vawjq9nm3OD_dUt0oaNh8yuG7o,18515
 well_log_toolkit/property.py,sha256=WOzoNQcmHCQ8moIKsnSyLgVC8s4LBu2x5IBXtFzmMe8,76236
 well_log_toolkit/regression.py,sha256=19wpiQQdGxuyIbjfzIY_yLzUUGT_ampWE_km1bg3o3c,24527
 well_log_toolkit/statistics.py,sha256=_huPMbv2H3o9ezunjEM94mJknX5wPK8V4nDv2lIZZRw,16814
 well_log_toolkit/utils.py,sha256=O2KPq4htIoUlL74V2zKftdqqTjRfezU9M-568zPLme0,6866
-well_log_toolkit/visualization.py,sha256=GlSR8KeYQED21bn2SmhHUj9zfnDb1ePgFIJBD-1XF5Q,147956
+well_log_toolkit/visualization.py,sha256=22-JGXCPF1OpPiIQ_tgZCpDrnZYMnv75db6fP02rCtU,153801
 well_log_toolkit/well.py,sha256=jv8xPQi-y5dLRQ7WIyBsr8DIMIAiFt4UJ9Rum7xTx7o,90170
-well_log_toolkit-0.1.115.dist-info/METADATA,sha256=22pPqzD7QtvbX526X79rCUM7tkTvv3jYvSOv4YjG-xc,59737
-well_log_toolkit-0.1.115.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-well_log_toolkit-0.1.115.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.115.dist-info/RECORD,,
+well_log_toolkit-0.1.117.dist-info/METADATA,sha256=k9moLAwhtg53LkAv1q0gk-OlLDAFOykG2uT1hnXqDvg,59737
+well_log_toolkit-0.1.117.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+well_log_toolkit-0.1.117.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.117.dist-info/RECORD,,