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

well_log_toolkit/manager.py

@@ -2598,7 +2598,7 @@ class WellDataManager:
         y: Optional[str] = None,
         wells: Optional[list[str]] = None,
         layers: Optional[dict[str, list[str]]] = None,
-        shape: str = "well",
+        shape: Optional[str] = None,
         color: Optional[str] = None,
         size: Optional[str] = None,
         colortemplate: str = "viridis",
@@ -2761,6 +2761,14 @@ class WellDataManager:
         if not well_objects:
             raise ValueError("No wells available for crossplot")
 
+        # Set default shape: "well" when no layers, "label" when layers provided
+        if shape is None and layers is None:
+            shape = "well"
+
+        # Set default color: "well" when shape defaults to "label" (i.e., when layers provided)
+        if color is None and layers is not None and shape is None:
+            color = "well"
+
         return CrossplotClass(
             wells=well_objects,
             x=x,

well_log_toolkit/visualization.py

@@ -12,9 +12,10 @@ import warnings
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
+import matplotlib.cm as cm
 from matplotlib.collections import PolyCollection
 from matplotlib.colors import Normalize
-from matplotlib.patches import Rectangle
+from matplotlib.patches import Rectangle, Patch
 
 if TYPE_CHECKING:
     from .well import Well
@@ -2776,16 +2777,16 @@ class Crossplot:
         Dictionary mapping layer labels to [x_property, y_property] lists.
         Use this to combine multiple property pairs in a single plot.
         Example: {"Core": ["CorePor", "CorePerm"], "Sidewall": ["SWPor", "SWPerm"]}
-        When using layers, you can use "label" for color/shape/size to differentiate
-        between layer types. Default: None
+        When using layers, shape defaults to "label" and color defaults to "well" for
+        easy visualization of both layer types and wells. Default: None
     shape : str, optional
         Property name for shape mapping. Use "well" to map shapes by well name,
         or "label" (when using layers) to map shapes by layer type.
-        Default: None (single shape)
+        Default: "well" for multi-well plots, "label" when layers provided, None otherwise
     color : str, optional
         Property name for color mapping. Use "depth" to color by depth,
-        or "label" (when using layers) to color by layer type.
-        Default: None (single color)
+        "well" to color by well, or "label" (when using layers) to color by layer type.
+        Default: "well" when layers provided, None otherwise
     size : str, optional
         Property name for size mapping, or "label" (when using layers) to
         size by layer type.
@@ -2901,8 +2902,9 @@ class Crossplot:
     ...         "Core": ["CorePor_obds", "CorePerm_obds"],
     ...         "Sidewall": ["SidewallPor_ob", "SidewallPerm_ob"]
     ...     },
-    ...     shape="label",  # Different shapes for Core vs Sidewall
     ...     y_log=True
+    ...     # shape defaults to "label" - different shapes for Core vs Sidewall
+    ...     # color defaults to "well" - different colors for each well
     ... )
     >>> plot.show()
 
@@ -2912,6 +2914,7 @@ class Crossplot:
     ...     .add_layer("CorePor_obds", "CorePerm_obds", label="Core") \\
     ...     .add_layer("SidewallPor_ob", "SidewallPerm_ob", label="Sidewall") \\
     ...     .show()
+    ...     # Automatically uses shape="label" and color="well"
 
     Layers with regression by color (single trend per well):
 
@@ -2920,9 +2923,8 @@ class Crossplot:
     ...         "Core": ["CorePor_obds", "CorePerm_obds"],
     ...         "Sidewall": ["SidewallPor_ob", "SidewallPerm_ob"]
     ...     },
-    ...     shape="label",  # Different shapes for data types
-    ...     color="well",   # Color by well
     ...     regression_by_color="linear"  # One trend per well (combining both data types)
+    ...     # Defaults: shape="label" (different shapes), color="well" (different colors)
     ... )
     >>> plot.show()
 
@@ -3003,8 +3005,16 @@ class Crossplot:
         # Store parameters
         self.x = x
         self.y = y
-        self.shape = shape
-        self.color = color
+        # Default shape to "label" when layers are provided
+        if shape is None and layers is not None:
+            self.shape = "label"
+        else:
+            self.shape = shape
+        # Default color to "well" when layers are provided (for multi-well visualization)
+        if color is None and layers is not None and len(self.wells) > 1:
+            self.color = "well"
+        else:
+            self.color = color
         self.size = size
         self.colortemplate = colortemplate
         self.color_range = color_range
@@ -3160,6 +3170,9 @@ class Crossplot:
                     if self.color == "label":
                         # Use layer label for color
                         df['color_val'] = layer_label
+                    elif self.color == "well":
+                        # Use well name for color (categorical)
+                        df['color_val'] = well.name
                     elif self.color and self.color != "depth":
                         try:
                             color_prop = well.get_property(self.color)
@@ -3679,6 +3692,36 @@ class Crossplot:
         if update_legend and self.ax is not None:
             self._update_regression_legend()
 
+    def _is_categorical_color(self, color_values: np.ndarray) -> bool:
+        """
+        Determine if color values should be treated as categorical vs continuous.
+
+        Returns True if:
+        - Less than 50 unique values
+
+        This helps distinguish between:
+        - Categorical: well names, facies, zones, labels
+        - Continuous: depth, porosity, saturation
+        """
+        # Remove NaN values for analysis
+        valid_values = color_values[~pd.isna(color_values)]
+
+        if len(valid_values) == 0:
+            return False
+
+        unique_values = np.unique(valid_values)
+        n_unique = len(unique_values)
+
+        # Check if values are numeric - if not, it's categorical
+        try:
+            # Try to convert to float - if this fails, it's categorical (strings)
+            _ = unique_values.astype(float)
+        except (ValueError, TypeError):
+            return True
+
+        # Apply the criteria
+        return n_unique < 50
+
     def plot(self) -> 'Crossplot':
         """Generate the crossplot figure."""
         # Prepare data
@@ -3778,13 +3821,41 @@ class Crossplot:
         y_vals = data['y'].values
 
         # Determine colors
+        is_categorical = False
         if self.color:
-            c_vals = data['color_val'].values
-            cmap = self.colortemplate
-            if self.color_range:
-                vmin, vmax = self.color_range
+            c_vals_raw = data['color_val'].values
+
+            # Check if color data is categorical
+            is_categorical = self._is_categorical_color(c_vals_raw)
+
+            if is_categorical:
+                # Handle categorical colors with discrete palette
+                unique_categories = pd.Series(c_vals_raw).dropna().unique()
+                n_categories = len(unique_categories)
+
+                # Create color map for categories
+                if n_categories <= len(DEFAULT_COLORS):
+                    color_palette = DEFAULT_COLORS
+                else:
+                    # Use colormap for many categories
+                    cmap_obj = cm.get_cmap(self.colortemplate, n_categories)
+                    color_palette = [cmap_obj(i) for i in range(n_categories)]
+
+                category_colors = {cat: color_palette[i % len(color_palette)]
+                                 for i, cat in enumerate(unique_categories)}
+
+                # Map each value to its color
+                c_vals = [category_colors.get(val, DEFAULT_COLORS[0]) for val in c_vals_raw]
+                cmap = None
+                vmin = vmax = None
             else:
-                vmin, vmax = np.nanmin(c_vals), np.nanmax(c_vals)
+                # Handle continuous colors
+                c_vals = c_vals_raw
+                cmap = self.colortemplate
+                if self.color_range:
+                    vmin, vmax = self.color_range
+                else:
+                    vmin, vmax = np.nanmin(c_vals), np.nanmax(c_vals)
         else:
             c_vals = DEFAULT_COLORS[0]
             cmap = None
@@ -3817,11 +3888,33 @@ class Crossplot:
             marker=self.marker
         )
 
-        # Add colorbar if using color mapping
-        if self.color and self.show_colorbar:
-            self.colorbar = self.fig.colorbar(self.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 or legend based on color type
+        if self.color:
+            if is_categorical and self.show_legend:
+                # Create legend for categorical colors
+                c_vals_raw = data['color_val'].values
+                unique_categories = pd.Series(c_vals_raw).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"
+                legend = self.ax.legend(handles=legend_elements,
+                                      title=colorbar_label,
+                                      loc='best',
+                                      frameon=True,
+                                      framealpha=0.9,
+                                      edgecolor='black')
+                legend.get_title().set_fontweight('bold')
+                self.ax.add_artist(legend)
+            elif not is_categorical and self.show_colorbar:
+                # Add colorbar for continuous colors
+                self.colorbar = self.fig.colorbar(self.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 _plot_by_groups(self, data: pd.DataFrame) -> None:
         """Plot data grouped by shape/well."""
@@ -3836,6 +3929,27 @@ class Crossplot:
         # Define markers for different groups
         markers = ['o', 's', '^', 'D', 'v', '<', '>', 'p', '*', 'h']
 
+        # Check if colors are categorical (check once for all data)
+        is_categorical = False
+        category_colors = {}
+        if self.color:
+            c_vals_all = data['color_val'].values
+            is_categorical = self._is_categorical_color(c_vals_all)
+
+            if is_categorical:
+                # Prepare color mapping for categorical values
+                unique_categories = pd.Series(c_vals_all).dropna().unique()
+                n_categories = len(unique_categories)
+
+                if n_categories <= len(DEFAULT_COLORS):
+                    color_palette = DEFAULT_COLORS
+                else:
+                    cmap_obj = cm.get_cmap(self.colortemplate, n_categories)
+                    color_palette = [cmap_obj(i) for i in range(n_categories)]
+
+                category_colors = {cat: color_palette[i % len(color_palette)]
+                                 for i, cat in enumerate(unique_categories)}
+
         # Track for colorbar (use first scatter)
         first_scatter = None
 
@@ -3848,13 +3962,22 @@ class Crossplot:
 
             # Determine colors
             if self.color:
-                c_vals = group_data['color_val'].values
-                cmap = self.colortemplate
-                if self.color_range:
-                    vmin, vmax = self.color_range
+                c_vals_raw = group_data['color_val'].values
+
+                if is_categorical:
+                    # Map categorical values to colors
+                    c_vals = [category_colors.get(val, DEFAULT_COLORS[0]) for val in c_vals_raw]
+                    cmap = None
+                    vmin = vmax = None
                 else:
-                    # Use global range from all data
-                    vmin, vmax = np.nanmin(data['color_val']), np.nanmax(data['color_val'])
+                    # Use continuous color mapping
+                    c_vals = c_vals_raw
+                    cmap = self.colortemplate
+                    if self.color_range:
+                        vmin, vmax = self.color_range
+                    else:
+                        # Use global range from all data
+                        vmin, vmax = np.nanmin(data['color_val']), np.nanmax(data['color_val'])
             else:
                 c_vals = DEFAULT_COLORS[idx % len(DEFAULT_COLORS)]
                 cmap = None
@@ -3888,7 +4011,7 @@ class Crossplot:
                 label=str(group_name)
             )
 
-            if first_scatter is None and self.color:
+            if first_scatter is None and self.color and not is_categorical:
                 first_scatter = scatter
 
         # Add legend with smart placement
@@ -3911,11 +4034,39 @@ class Crossplot:
             # 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)
-            colorbar_label = self.color if self.color != "depth" else "Depth"
-            self.colorbar.set_label(colorbar_label, fontsize=11, fontweight='bold')
+        # 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')
 
     def add_regression(
         self,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.129
+Version: 0.1.131
 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.129.dist-info → well_log_toolkit-0.1.131.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=Tj0mRfX1aX2s6uug7BBlY1m_mu3G50EGxHGzD0eEedE,53876
-well_log_toolkit/manager.py,sha256=gRgHJlNrB-JONc4gIxT_LvwDW2ZUO4tHRopzDd2x7WI,109423
+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/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=oyjENj3milpJ7O0Wc0Kraucu8HmklHbw--s7Z4_r-Ig,162865
+well_log_toolkit/visualization.py,sha256=MqMK5J3LGCXc2YDT1tlmLC6oMWA-F-YBuLBh5rbrPpI,169985
 well_log_toolkit/well.py,sha256=Aav5Y-rui8YsJdvk7BFndNPUu1O9mcjwDApAGyqV9kw,104535
-well_log_toolkit-0.1.129.dist-info/METADATA,sha256=SWxynEaltIqmkiwd-Ws5XKZnbVXMD_j_JEzhgUlsuFk,59810
-well_log_toolkit-0.1.129.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-well_log_toolkit-0.1.129.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.129.dist-info/RECORD,,
+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,,