well-log-toolkit 0.1.131__py3-none-any.whl → 0.1.133__py3-none-any.whl

well_log_toolkit/property.py

@@ -642,7 +642,7 @@ class Property(PropertyOperationsMixin):
 
     def resample(self, target_depth: Union[np.ndarray, 'Property']) -> 'Property':
         """
-        Resample property to a new depth grid using linear interpolation.
+        Resample property to a new depth grid using appropriate interpolation.
 
         This method creates a new Property object with values interpolated to match
         the target depth grid. This is required when combining properties with
@@ -663,7 +663,10 @@ class Property(PropertyOperationsMixin):
         Notes
         -----
         - Uses linear interpolation for continuous data
-        - Uses nearest-neighbor interpolation for discrete data
+        - Uses forward-fill (previous) for discrete data - geological zones extend
+          from their top/boundary until the next boundary is encountered. For example,
+          "Cerisa West top" at 2929.93m remains active until "Cerisa West SST 1 top"
+          at 2955.10m is intercepted.
         - Values outside the original depth range are set to NaN
         - NaN values in original data are excluded from interpolation
 
@@ -728,7 +731,11 @@ class Property(PropertyOperationsMixin):
 
         # Choose interpolation method based on type
         if self.type == 'discrete':
-            kind = 'nearest'
+            # Use 'previous' (forward-fill) for discrete properties
+            # This ensures geological zones extend from their top/boundary
+            # until the next top is encountered (e.g., "Cerisa West top" at 2929.93
+            # remains active until "Cerisa West SST 1 top" at 2955.10)
+            kind = 'previous'
         else:
             kind = 'linear'
 

well_log_toolkit/visualization.py

@@ -2853,6 +2853,16 @@ class Crossplot:
         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.
         Default: None
+    regression_by_color_and_shape : str or dict, optional
+        Regression type to apply separately for each combination of color AND shape groups.
+        Creates separate regression lines for each (color, shape) combination. This is useful
+        for analyzing how the relationship changes across both dimensions simultaneously
+        (e.g., each well in each formation, each layer in each zone). Accepts string or dict.
+        Default: None
+    regression_by_shape_and_color : str or dict, optional
+        Alias for regression_by_color_and_shape. Provided for convenience - both parameters
+        do exactly the same thing. Use whichever order feels more natural.
+        Default: None
 
     Examples
     --------
@@ -2970,6 +2980,8 @@ class Crossplot:
         regression: Optional[Union[str, dict]] = None,
         regression_by_color: Optional[Union[str, dict]] = None,
         regression_by_group: Optional[Union[str, dict]] = None,
+        regression_by_color_and_shape: Optional[Union[str, dict]] = None,
+        regression_by_shape_and_color: Optional[Union[str, dict]] = None,
     ):
         # Store wells as list
         if not isinstance(wells, list):
@@ -3055,6 +3067,19 @@ class Crossplot:
         self.regression_by_color = regression_by_color
         self.regression_by_group = regression_by_group
 
+        # Handle regression_by_shape_and_color as alias for regression_by_color_and_shape
+        if regression_by_shape_and_color is not None and regression_by_color_and_shape is not None:
+            warnings.warn(
+                "Both regression_by_color_and_shape and regression_by_shape_and_color were specified. "
+                "These are aliases for the same feature. Using regression_by_color_and_shape."
+            )
+            self.regression_by_color_and_shape = regression_by_color_and_shape
+        elif regression_by_shape_and_color is not None:
+            # Use the alias
+            self.regression_by_color_and_shape = regression_by_shape_and_color
+        else:
+            self.regression_by_color_and_shape = regression_by_color_and_shape
+
         # Plot objects
         self.fig = None
         self.ax = None
@@ -3072,7 +3097,15 @@ class Crossplot:
         # Data cache
         self._data = None
 
-    def add_layer(self, x: str, y: str, label: str):
+        # Discrete property labels storage
+        # Maps property role ('shape', 'color', 'size') to labels dict {0: 'label0', 1: 'label1', ...}
+        self._discrete_labels = {}
+
+        # Legend placement tracking
+        # Maps segment numbers (1-9) to legend type placed there
+        self._occupied_segments = {}
+
+    def add_layer(self, x: str, y: str, label: str) -> 'Crossplot':
         """
         Add a new data layer to the crossplot.
 
@@ -3136,6 +3169,32 @@ class Crossplot:
             # Only do expensive allclose if needed
             return not np.allclose(prop_depth, ref_depth)
 
+        # Helper function to align property values to target depth grid
+        def align_property(prop, target_depth):
+            """
+            Align property values to target depth grid.
+
+            Uses appropriate interpolation based on property type:
+            - Discrete properties: forward-fill/previous (geological zones extend from
+              their top/boundary until the next boundary is encountered)
+            - Continuous properties: linear interpolation
+
+            Args:
+                prop: Property object to align
+                target_depth: Target depth array
+
+            Returns:
+                Aligned values array
+            """
+            if prop.type == 'discrete':
+                # Use Property's resample method which handles discrete properties correctly
+                # (forward-fill to preserve integer codes and geological zone logic)
+                resampled = prop.resample(target_depth)
+                return resampled.values
+            else:
+                # For continuous properties, use linear interpolation
+                return np.interp(target_depth, prop.depth, prop.values, left=np.nan, right=np.nan)
+
         # Loop through each layer
         for layer in self._layers:
             layer_x = layer['x']
@@ -3153,9 +3212,9 @@ class Crossplot:
                     x_values = x_prop.values
                     y_values = y_prop.values
 
-                    # Align y values to x depth grid if needed
+                    # Align y values to x depth grid if needed using appropriate method
                     if needs_alignment(y_prop.depth, depths):
-                        y_values = np.interp(depths, y_prop.depth, y_prop.values, left=np.nan, right=np.nan)
+                        y_values = align_property(y_prop, depths)
 
                     # Create dataframe for this well and layer
                     df = pd.DataFrame({
@@ -3176,10 +3235,14 @@ class Crossplot:
                     elif self.color and self.color != "depth":
                         try:
                             color_prop = well.get_property(self.color)
-                            color_values = color_prop.values
-                            # Align to x depth grid
+                            # Store labels if discrete property (only once)
+                            if 'color' not in self._discrete_labels:
+                                self._store_discrete_labels(color_prop, 'color')
+                            # Align to x depth grid using appropriate method for property type
                             if needs_alignment(color_prop.depth, depths):
-                                color_values = np.interp(depths, color_prop.depth, color_prop.values, left=np.nan, right=np.nan)
+                                color_values = align_property(color_prop, depths)
+                            else:
+                                color_values = color_prop.values
                             df['color_val'] = color_values
                         except (AttributeError, KeyError, PropertyNotFoundError):
                             # Silently use depth as fallback
@@ -3194,10 +3257,14 @@ class Crossplot:
                     elif self.size:
                         try:
                             size_prop = well.get_property(self.size)
-                            size_values = size_prop.values
-                            # Align to x depth grid
+                            # Store labels if discrete property (only once)
+                            if 'size' not in self._discrete_labels:
+                                self._store_discrete_labels(size_prop, 'size')
+                            # Align to x depth grid using appropriate method for property type
                             if needs_alignment(size_prop.depth, depths):
-                                size_values = np.interp(depths, size_prop.depth, size_prop.values, left=np.nan, right=np.nan)
+                                size_values = align_property(size_prop, depths)
+                            else:
+                                size_values = size_prop.values
                             df['size_val'] = size_values
                         except (AttributeError, KeyError, PropertyNotFoundError):
                             # Silently skip if size property not found
@@ -3210,10 +3277,14 @@ class Crossplot:
                     elif self.shape and self.shape != "well":
                         try:
                             shape_prop = well.get_property(self.shape)
-                            shape_values = shape_prop.values
-                            # Align to x depth grid
+                            # Store labels if discrete property (only once)
+                            if 'shape' not in self._discrete_labels:
+                                self._store_discrete_labels(shape_prop, 'shape')
+                            # Align to x depth grid using appropriate method for property type
                             if needs_alignment(shape_prop.depth, depths):
-                                shape_values = np.interp(depths, shape_prop.depth, shape_prop.values, left=np.nan, right=np.nan)
+                                shape_values = align_property(shape_prop, depths)
+                            else:
+                                shape_values = shape_prop.values
                             df['shape_val'] = shape_values
                         except (AttributeError, KeyError, PropertyNotFoundError):
                             # Silently skip if shape property not found
@@ -3377,6 +3448,316 @@ class Crossplot:
 
         return best_pos, second_best_pos
 
+    def _find_optimal_legend_segment(
+        self,
+        data: pd.DataFrame,
+        legend_type: str,
+        is_large: bool = False
+    ) -> tuple[int, str]:
+        """Find optimal segment for legend placement using priority-based algorithm.
+
+        Segments are numbered 1-9:
+            1  2  3     (upper left, upper center, upper right)
+            4  5  6     (center left, center, center right)
+            7  8  9     (lower left, lower center, lower right)
+
+        Checks segments in priority order: 1,9,4,6,3,7,2,8,5
+        A segment is eligible if:
+        - It has <10% of datapoints
+        - It doesn't have a previous legend, EXCEPT:
+          - Shape and color legends can share a segment if neither is very large
+
+        Args:
+            data: DataFrame with 'x' and 'y' columns
+            legend_type: Type of legend ('shape', 'color', 'size', 'regression', etc.)
+            is_large: Whether this legend is considered large (many items)
+
+        Returns:
+            Tuple of (segment_number, matplotlib_location_string)
+        """
+        # 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)
+
+        # Map segments 1-9 to grid positions (i, j)
+        # Segment numbering:
+        #   1  2  3
+        #   4  5  6
+        #   7  8  9
+        segment_to_grid = {
+            1: (0, 2),  # upper left
+            2: (1, 2),  # upper center
+            3: (2, 2),  # upper right
+            4: (0, 1),  # center left
+            5: (1, 1),  # center
+            6: (2, 1),  # center right
+            7: (0, 0),  # lower left
+            8: (1, 0),  # lower center
+            9: (2, 0),  # lower right
+        }
+
+        # Map segments to matplotlib location strings
+        segment_to_location = {
+            1: 'upper left',
+            2: 'upper center',
+            3: 'upper right',
+            4: 'center left',
+            5: 'center',
+            6: 'center right',
+            7: 'lower left',
+            8: 'lower center',
+            9: 'lower right',
+        }
+
+        # Count points in each segment
+        total_points = len(x_vals)
+        segment_counts = {}
+        for segment, (i, j) in segment_to_grid.items():
+            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])
+            count = np.sum(x_mask & y_mask)
+            segment_counts[segment] = count
+
+        # Priority order: 1,9,4,6,3,7,2,8,5
+        priority_order = [1, 9, 4, 6, 3, 7, 2, 8, 5]
+
+        # Check each segment in priority order
+        for segment in priority_order:
+            # Check datapoint percentage
+            if total_points > 0:
+                percentage = segment_counts[segment] / total_points
+                if percentage >= 0.10:  # 10% threshold
+                    continue
+
+            # Check if segment is occupied
+            if segment in self._occupied_segments:
+                existing_type = self._occupied_segments[segment]
+
+                # Allow shape and color to share if neither is very large
+                shareable = {'shape', 'color'}
+                if (legend_type in shareable and existing_type in shareable
+                    and not is_large
+                    and not self._occupied_segments.get(f'{segment}_large', False)):
+                    # Can share this segment
+                    pass
+                else:
+                    # Segment occupied, try next
+                    continue
+
+            # Found eligible segment
+            return segment, segment_to_location[segment]
+
+        # If no eligible segment found, use fallback (segment 1)
+        return 1, segment_to_location[1]
+
+    def _store_discrete_labels(self, prop, role: str) -> None:
+        """
+        Store labels from a discrete property for later use in legends.
+
+        Args:
+            prop: Property object (must have type and labels attributes)
+            role: Property role - 'shape', 'color', or 'size'
+        """
+        if hasattr(prop, 'type') and prop.type == 'discrete' and hasattr(prop, 'labels') and prop.labels:
+            self._discrete_labels[role] = prop.labels.copy()
+
+    def _get_display_label(self, value, role: str) -> str:
+        """
+        Get display label for a value, using stored labels for discrete properties.
+
+        For discrete properties with labels, converts integer codes to readable names.
+        For continuous properties or discrete without labels, returns string value.
+
+        Args:
+            value: The value to get label for (could be int, float, or string)
+            role: Property role - 'shape', 'color', or 'size'
+
+        Returns:
+            Display label string
+
+        Examples:
+            >>> # For discrete property with labels {0: 'Agat top', 1: 'Cerisa Main top'}
+            >>> self._get_display_label(0.0, 'shape')
+            'Agat top'
+
+            >>> # For continuous property or no labels
+            >>> self._get_display_label(2.5, 'color')
+            '2.5'
+        """
+        if role in self._discrete_labels:
+            # Try to convert to integer and look up label
+            try:
+                int_val = int(np.round(float(value)))
+                return self._discrete_labels[role].get(int_val, str(value))
+            except (ValueError, TypeError):
+                return str(value)
+        return str(value)
+
+    def _is_edge_location(self, location: str) -> bool:
+        """Check if a legend location is on the left or right edge.
+
+        Args:
+            location: Matplotlib location string
+
+        Returns:
+            True if on left or right edge (for vertical stacking)
+        """
+        edge_locations = ['upper left', 'center left', 'lower left',
+                         'upper right', 'center right', 'lower right']
+        return location in edge_locations
+
+    def _create_grouped_legends(self,
+                                shape_handles, shape_title: str,
+                                color_handles, color_title: str,
+                                location: str) -> None:
+        """Create grouped legends in the same region, stacked or side-by-side.
+
+        When both shape and color legends are needed, this groups them in the same
+        1/9th section without overlap. Stacks vertically on edges, side-by-side elsewhere.
+
+        Args:
+            shape_handles: List of handles for shape legend
+            shape_title: Title for shape legend
+            color_handles: List of handles for color legend
+            color_title: Title for color legend
+            location: Matplotlib location string for positioning
+        """
+        is_edge = self._is_edge_location(location)
+
+        # Determine base anchor point from location string
+        # Map location to (x, y) coordinates in figure space
+        anchor_map = {
+            'upper left': (0.02, 0.98),
+            'upper center': (0.5, 0.98),
+            'upper right': (0.98, 0.98),
+            'center left': (0.02, 0.5),
+            'center': (0.5, 0.5),
+            'center right': (0.98, 0.5),
+            'lower left': (0.02, 0.02),
+            'lower center': (0.5, 0.02),
+            'lower right': (0.98, 0.02),
+        }
+
+        base_x, base_y = anchor_map.get(location, (0.98, 0.98))
+
+        if is_edge:
+            # Stack vertically on edges
+            # Position shape legend at the top
+            shape_legend = self.ax.legend(
+                handles=shape_handles,
+                title=shape_title,
+                loc=location,
+                frameon=True,
+                framealpha=0.9,
+                edgecolor='black',
+                bbox_to_anchor=(base_x, base_y),
+                bbox_transform=self.fig.transFigure
+            )
+            shape_legend.get_title().set_fontweight('bold')
+            self.ax.add_artist(shape_legend)
+
+            # Calculate offset for color legend below shape legend
+            # Estimate shape legend height and add spacing
+            shape_height = len(shape_handles) * 0.025 + 0.05  # Rough estimate
+
+            # Adjust y position for color legend
+            if 'upper' in location:
+                color_y = base_y - shape_height - 0.02  # Stack below
+            elif 'lower' in location:
+                color_y = base_y + shape_height + 0.02  # Stack above
+            else:  # center
+                color_y = base_y - shape_height / 2 - 0.01  # Stack below
+
+            color_legend = self.ax.legend(
+                handles=color_handles,
+                title=color_title,
+                loc=location,
+                frameon=True,
+                framealpha=0.9,
+                edgecolor='black',
+                bbox_to_anchor=(base_x, color_y),
+                bbox_transform=self.fig.transFigure
+            )
+            color_legend.get_title().set_fontweight('bold')
+        else:
+            # Place side by side for non-edge locations (top, bottom, center)
+            # Estimate width of each legend
+            legend_width = 0.15
+
+            if 'center' in location and location != 'center left' and location != 'center right':
+                # For center positions, place them side by side
+                shape_x = base_x - legend_width / 2 - 0.01
+                color_x = base_x + legend_width / 2 + 0.01
+
+                shape_legend = self.ax.legend(
+                    handles=shape_handles,
+                    title=shape_title,
+                    loc='center',
+                    frameon=True,
+                    framealpha=0.9,
+                    edgecolor='black',
+                    bbox_to_anchor=(shape_x, base_y),
+                    bbox_transform=self.fig.transFigure
+                )
+                shape_legend.get_title().set_fontweight('bold')
+                self.ax.add_artist(shape_legend)
+
+                color_legend = self.ax.legend(
+                    handles=color_handles,
+                    title=color_title,
+                    loc='center',
+                    frameon=True,
+                    framealpha=0.9,
+                    edgecolor='black',
+                    bbox_to_anchor=(color_x, base_y),
+                    bbox_transform=self.fig.transFigure
+                )
+                color_legend.get_title().set_fontweight('bold')
+            else:
+                # For other positions, fall back to stacking
+                shape_legend = self.ax.legend(
+                    handles=shape_handles,
+                    title=shape_title,
+                    loc=location,
+                    frameon=True,
+                    framealpha=0.9,
+                    edgecolor='black'
+                )
+                shape_legend.get_title().set_fontweight('bold')
+                self.ax.add_artist(shape_legend)
+
+                # Estimate offset
+                shape_height = len(shape_handles) * 0.025 + 0.05
+                if 'upper' in location:
+                    color_y = base_y - shape_height - 0.02
+                else:
+                    color_y = base_y + shape_height + 0.02
+
+                color_legend = self.ax.legend(
+                    handles=color_handles,
+                    title=color_title,
+                    loc=location,
+                    frameon=True,
+                    framealpha=0.9,
+                    edgecolor='black',
+                    bbox_to_anchor=(base_x, color_y),
+                    bbox_transform=self.fig.transFigure
+                )
+                color_legend.get_title().set_fontweight('bold')
+
     def _format_regression_label(self, name: str, reg, include_equation: bool = None, include_r2: bool = None) -> str:
         """Format a modern, compact regression label.
 
@@ -3436,9 +3817,18 @@ class Crossplot:
             regression_labels.append(line.get_label())
 
         if regression_handles:
-            # Get smart placement based on data density
+            # Get smart placement based on data density using optimized segment algorithm
             if self._data is not None:
-                _, secondary_loc = self._find_best_legend_locations(self._data)
+                # Determine if regression legend is large
+                regression_is_large = len(regression_handles) > 5
+                segment, secondary_loc = self._find_optimal_legend_segment(
+                    self._data,
+                    legend_type='regression',
+                    is_large=regression_is_large
+                )
+                # Mark segment as occupied
+                self._occupied_segments[segment] = 'regression'
+                self._occupied_segments[f'{segment}_large'] = regression_is_large
             else:
                 # Fallback if data not available
                 secondary_loc = 'lower right'
@@ -3475,7 +3865,7 @@ class Crossplot:
 
     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]):
+        if not any([self.regression, self.regression_by_color, self.regression_by_group, self.regression_by_color_and_shape]):
             return
 
         total_points = len(data)
@@ -3534,12 +3924,54 @@ class Crossplot:
                 )
             else:
                 # 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."
-                    )
+                # Use _is_categorical_color() to properly handle discrete properties
+                if group_column == 'color_val':
+                    is_categorical = self._is_categorical_color(data[group_column].values)
+                    if not is_categorical:
+                        # 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."
+                        )
+                        # Skip this section
+                    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."
+                            )
+
+                        # Get the actual colors used for each group in the plot
+                        group_colors_map = self._get_group_colors(data, group_column)
+
+                        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 use the same color as the data group
+                                group_config = config.copy()
+                                if 'line_color' not in group_config:
+                                    # Use the same color as the data points for this group
+                                    group_config['line_color'] = group_colors_map.get(group_name, 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
                 else:
                     # Categorical values - group and create regressions
                     color_groups = data.groupby(group_column)
@@ -3629,6 +4061,95 @@ class Crossplot:
                     "Use shape='well' or set shape to a property name."
                 )
 
+        # Add regression by color AND shape combinations
+        if self.regression_by_color_and_shape:
+            config = self._parse_regression_config(self.regression_by_color_and_shape)
+            reg_type = config['type']
+
+            # Determine color and shape columns
+            color_col = None
+            shape_col = None
+            color_label = None
+            shape_label = None
+
+            # Identify color column
+            if self.color and 'color_val' in data.columns:
+                # Check if categorical
+                if self._is_categorical_color(data['color_val'].values):
+                    color_col = 'color_val'
+                    color_label = self.color
+            elif self.shape == "well" and 'well' in data.columns:
+                # When shape="well", wells provide colors
+                color_col = 'well'
+                color_label = 'well'
+
+            # Identify shape column
+            if self.shape == "well" and 'well' in data.columns:
+                shape_col = 'well'
+                shape_label = 'well'
+            elif self.shape and self.shape != "well" and 'shape_val' in data.columns:
+                shape_col = 'shape_val'
+                shape_label = self.shape
+
+            # Need both color and shape columns for this to work
+            if color_col is None or shape_col is None:
+                warnings.warn(
+                    "regression_by_color_and_shape requires both categorical color mapping AND shape/well grouping. "
+                    "Set both color and shape parameters, or use regression_by_color or regression_by_group instead."
+                )
+            elif color_col == shape_col:
+                warnings.warn(
+                    "regression_by_color_and_shape requires DIFFERENT color and shape mappings. "
+                    "Currently both are mapped to the same property. Use regression_by_color or regression_by_group instead."
+                )
+            else:
+                # Group by both color and shape
+                combined_groups = data.groupby([color_col, shape_col])
+                n_groups = len(combined_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 simpler regression strategy."
+                    )
+
+                # Get color maps for both dimensions
+                color_colors_map = self._get_group_colors(data, color_col)
+                shape_colors_map = self._get_group_colors(data, shape_col)
+
+                for idx, ((color_val, shape_val), group_data) in enumerate(combined_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 use appropriate color
+                        group_config = config.copy()
+                        if 'line_color' not in group_config:
+                            # Prefer color from color dimension, fallback to shape dimension
+                            group_config['line_color'] = color_colors_map.get(
+                                color_val,
+                                shape_colors_map.get(shape_val, regression_colors[color_idx % len(regression_colors)])
+                            )
+
+                        # Create descriptive name with both dimensions
+                        color_display = self._get_display_label(color_val, 'color')
+                        shape_display = self._get_display_label(shape_val, 'shape')
+                        name = f"{color_label}={color_display}, {shape_label}={shape_display}"
+
+                        # 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=name,
+                            config=group_config,
+                            update_legend=is_last
+                        )
+                        regression_count += 1
+                        color_idx += 1
+
     def _add_group_regression(
         self,
         x_vals: np.ndarray,
@@ -3724,6 +4245,9 @@ class Crossplot:
 
     def plot(self) -> 'Crossplot':
         """Generate the crossplot figure."""
+        # Reset legend placement tracking for new plot
+        self._occupied_segments = {}
+
         # Prepare data
         data = self._prepare_data()
 
@@ -3898,13 +4422,29 @@ class Crossplot:
                 # Create custom legend handles
                 legend_elements = [Patch(facecolor=category_colors[cat],
                                        edgecolor=self.edge_color,
-                                       label=str(cat))
+                                       label=self._get_display_label(cat, 'color'))
                                  for cat in unique_categories]
 
+                # Determine if legend is large
+                color_is_large = len(legend_elements) > 5
+
+                # Find optimal segment for color legend
+                if self._data is not None:
+                    segment, location = self._find_optimal_legend_segment(
+                        self._data,
+                        legend_type='color',
+                        is_large=color_is_large
+                    )
+                    # Mark segment as occupied
+                    self._occupied_segments[segment] = 'color'
+                    self._occupied_segments[f'{segment}_large'] = color_is_large
+                else:
+                    location = 'best'
+
                 colorbar_label = self.color if self.color != "depth" and self.color != "label" else "Category"
                 legend = self.ax.legend(handles=legend_elements,
                                       title=colorbar_label,
-                                      loc='best',
+                                      loc=location,
                                       frameon=True,
                                       framealpha=0.9,
                                       edgecolor='black')
@@ -4008,65 +4548,92 @@ class Crossplot:
                 edgecolors=self.edge_color,
                 linewidths=self.edge_width,
                 marker=marker,
-                label=str(group_name)
+                label=self._get_display_label(group_name, 'shape')
             )
 
             if first_scatter is None and self.color and not is_categorical:
                 first_scatter = scatter
 
-        # Add legend with smart placement
-        if self.show_legend:
-            # Get best location based on data density
+        # Check if we need both shape and color legends (grouped layout)
+        need_shape_legend = self.show_legend
+        need_color_legend = self.color and is_categorical and self.show_legend
+
+        if need_shape_legend and need_color_legend:
+            # Create grouped legends in the same region using optimized placement
+            # Prepare shape legend handles (from scatter plots)
+            shape_handles, _ = self.ax.get_legend_handles_labels()
+
+            # Prepare color legend handles
+            c_vals_all = data['color_val'].values
+            unique_categories = pd.Series(c_vals_all).dropna().unique()
+            color_handles = [Patch(facecolor=category_colors[cat],
+                                  edgecolor=self.edge_color,
+                                  label=self._get_display_label(cat, 'color'))
+                            for cat in unique_categories]
+
+            # Determine if legends are large (more than 5 items)
+            shape_is_large = len(shape_handles) > 5
+            color_is_large = len(color_handles) > 5
+
+            # Find optimal segment for the grouped legends
             if self._data is not None:
-                primary_loc, _ = self._find_best_legend_locations(self._data)
+                segment, location = self._find_optimal_legend_segment(
+                    self._data,
+                    legend_type='shape',
+                    is_large=shape_is_large or color_is_large
+                )
+                # Mark segment as occupied by both shape and color
+                self._occupied_segments[segment] = 'shape'
+                self._occupied_segments[f'{segment}_large'] = shape_is_large or color_is_large
             else:
-                primary_loc = 'best'
+                location = 'best'
+
+            colorbar_label = self.color if self.color != "depth" and self.color != "label" else "Category"
+
+            # Create grouped legends
+            self._create_grouped_legends(
+                shape_handles=shape_handles,
+                shape_title=group_label,
+                color_handles=color_handles,
+                color_title=colorbar_label,
+                location=location
+            )
+
+        elif need_shape_legend:
+            # Only shape legend needed
+            shape_handles, _ = self.ax.get_legend_handles_labels()
+            shape_is_large = len(shape_handles) > 5
+
+            # Find optimal segment
+            if self._data is not None:
+                segment, location = self._find_optimal_legend_segment(
+                    self._data,
+                    legend_type='shape',
+                    is_large=shape_is_large
+                )
+                # Mark segment as occupied
+                self._occupied_segments[segment] = 'shape'
+                self._occupied_segments[f'{segment}_large'] = shape_is_large
+            else:
+                location = 'best'
 
             legend = self.ax.legend(
                 title=group_label,
-                loc=primary_loc,
+                loc=location,
                 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 or color legend based on color type
-        if self.color:
-            if is_categorical and self.show_legend:
-                # Create separate legend for categorical colors
-                c_vals_all = data['color_val'].values
-                unique_categories = pd.Series(c_vals_all).dropna().unique()
-
-                # Create custom legend handles
-                legend_elements = [Patch(facecolor=category_colors[cat],
-                                       edgecolor=self.edge_color,
-                                       label=str(cat))
-                                 for cat in unique_categories]
-
-                colorbar_label = self.color if self.color != "depth" and self.color != "label" else "Category"
-
-                # Find a good location for the color legend (opposite corner from shape legend)
-                if self._data is not None:
-                    _, secondary_loc = self._find_best_legend_locations(self._data)
-                else:
-                    secondary_loc = 'upper right'
-
-                color_legend = self.ax.legend(handles=legend_elements,
-                                            title=colorbar_label,
-                                            loc=secondary_loc,
-                                            frameon=True,
-                                            framealpha=0.9,
-                                            edgecolor='black')
-                color_legend.get_title().set_fontweight('bold')
-            elif not is_categorical and self.show_colorbar and first_scatter:
-                # Add continuous colorbar
-                self.colorbar = self.fig.colorbar(first_scatter, ax=self.ax)
-                colorbar_label = self.color if self.color != "depth" else "Depth"
-                self.colorbar.set_label(colorbar_label, fontsize=11, fontweight='bold')
+        # Add colorbar for continuous color mapping
+        if self.color and not is_categorical and self.show_colorbar and first_scatter:
+            # Add continuous colorbar
+            self.colorbar = self.fig.colorbar(first_scatter, ax=self.ax)
+            colorbar_label = self.color if self.color != "depth" else "Depth"
+            self.colorbar.set_label(colorbar_label, fontsize=11, fontweight='bold')
 
     def add_regression(
         self,

{well_log_toolkit-0.1.131.dist-info → well_log_toolkit-0.1.133.dist-info}/METADATA

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

@@ -3,13 +3,13 @@ well_log_toolkit/exceptions.py,sha256=X_fzC7d4yaBFO9Vx74dEIB6xmI9Agi6_bTU3MPxn6k
 well_log_toolkit/las_file.py,sha256=Tj0mRfX1aX2s6uug7BBlY1m_mu3G50EGxHGzD0eEedE,53876
 well_log_toolkit/manager.py,sha256=PuHF8rqypirNIN77STHcvg8WneExikpq6ZvkcRbcQpg,109776
 well_log_toolkit/operations.py,sha256=z8j8fGBOwoJGUQFy-Vawjq9nm3OD_dUt0oaNh8yuG7o,18515
-well_log_toolkit/property.py,sha256=WOzoNQcmHCQ8moIKsnSyLgVC8s4LBu2x5IBXtFzmMe8,76236
+well_log_toolkit/property.py,sha256=B-3mXNJmvIqjjMdsu1kgVSwMgEwbJ36wn_n_oppdJFw,76769
 well_log_toolkit/regression.py,sha256=7D3oI-1XVlFb-mOoHTxTTtUHERFyvQSBAzJzAGVoZnk,25192
 well_log_toolkit/statistics.py,sha256=_huPMbv2H3o9ezunjEM94mJknX5wPK8V4nDv2lIZZRw,16814
 well_log_toolkit/utils.py,sha256=O2KPq4htIoUlL74V2zKftdqqTjRfezU9M-568zPLme0,6866
-well_log_toolkit/visualization.py,sha256=MqMK5J3LGCXc2YDT1tlmLC6oMWA-F-YBuLBh5rbrPpI,169985
+well_log_toolkit/visualization.py,sha256=rzwSkqUOEeSnnuvPvNMQ56-F316JBk0XSqAdqyoRjEc,195237
 well_log_toolkit/well.py,sha256=Aav5Y-rui8YsJdvk7BFndNPUu1O9mcjwDApAGyqV9kw,104535
-well_log_toolkit-0.1.131.dist-info/METADATA,sha256=XC_qlZ-SFO5rFspWuxMXfvl1viLa-GpKZXKxWvA-RBc,59810
-well_log_toolkit-0.1.131.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-well_log_toolkit-0.1.131.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.131.dist-info/RECORD,,
+well_log_toolkit-0.1.133.dist-info/METADATA,sha256=F10zbt2b4FNQY76xM0eWAhG_y_ZABGkmY1nvem8doUY,59810
+well_log_toolkit-0.1.133.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+well_log_toolkit-0.1.133.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.133.dist-info/RECORD,,