well-log-toolkit 0.1.138__py3-none-any.whl → 0.1.140__py3-none-any.whl

well_log_toolkit/visualization.py

@@ -14,7 +14,7 @@ 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.colors import Normalize, LogNorm
 from matplotlib.patches import Rectangle, Patch
 
 if TYPE_CHECKING:
@@ -1120,17 +1120,18 @@ class WellView:
             )
 
         # Collect all tops data from all tops groups
-        all_tops_data = {}  # depth -> name mapping
+        all_tops_list = []
         for tops_group in self.tops:
-            tops_data = tops_group['tops']
-            all_tops_data.update(tops_data)
+            entries = tops_group.get('entries', [])
+            for entry in entries:
+                all_tops_list.append((entry['depth'], entry['name']))
 
         # Find depths for specified tops
         tops_depths = []
         not_found = []
         for top_name in tops_list:
             found = False
-            for depth, name in all_tops_data.items():
+            for depth, name in all_tops_list:
                 if name == top_name:
                     tops_depths.append(depth)
                     found = True
@@ -1140,7 +1141,7 @@ class WellView:
 
         # Only raise error if NONE of the tops were found
         if not tops_depths:
-            available_tops = list(set(all_tops_data.values()))
+            available_tops = list(set(name for _, name in all_tops_list))
             raise ValueError(
                 f"None of the specified formation tops were found: {tops_list}. "
                 f"Available tops: {available_tops}"
@@ -1338,11 +1339,8 @@ class WellView:
         if property_name is not None and tops_dict is not None:
             raise ValueError("Cannot specify both 'property_name' and 'tops_dict'")
 
-        # Get tops data
-        tops_data = {}  # depth -> formation name
-        color_data = {}  # depth -> color
-        style_data = {}  # depth -> line style
-        thickness_data = {}  # depth -> line thickness
+        # Get tops data as list of entries (supports multiple tops at same depth)
+        tops_entries = []  # List of {'depth': d, 'name': n, 'color': c, 'style': s, 'thickness': t}
 
         if property_name is not None:
             # Load from discrete property
@@ -1375,7 +1373,7 @@ class WellView:
                 if valid_values[i] != valid_values[i-1]:
                     boundaries.append(i)
 
-            # Build tops dictionary
+            # Build tops entries list
             for idx in boundaries:
                 depth = float(valid_depth[idx])
                 value = int(valid_values[idx])
@@ -1386,42 +1384,43 @@ class WellView:
                 else:
                     formation_name = f"Zone {value}"
 
-                tops_data[depth] = formation_name
+                entry = {'depth': depth, 'name': formation_name}
 
                 # Get color if available (colors parameter overrides property colors)
                 if colors is not None and value in colors:
-                    color_data[depth] = colors[value]
+                    entry['color'] = colors[value]
                 elif prop.colors and value in prop.colors:
-                    color_data[depth] = prop.colors[value]
+                    entry['color'] = prop.colors[value]
 
                 # Get style if available (styles parameter overrides property styles)
                 if styles is not None and value in styles:
-                    style_data[depth] = styles[value]
+                    entry['style'] = styles[value]
                 elif prop.styles and value in prop.styles:
-                    style_data[depth] = prop.styles[value]
+                    entry['style'] = prop.styles[value]
 
                 # Get thickness if available (thicknesses parameter overrides property thicknesses)
                 if thicknesses is not None and value in thicknesses:
-                    thickness_data[depth] = thicknesses[value]
+                    entry['thickness'] = thicknesses[value]
                 elif prop.thicknesses and value in prop.thicknesses:
-                    thickness_data[depth] = prop.thicknesses[value]
+                    entry['thickness'] = prop.thicknesses[value]
+
+                tops_entries.append(entry)
 
         else:
-            # Use provided dictionary
-            tops_data = tops_dict
-            if colors is not None:
-                color_data = colors
-            if styles is not None:
-                style_data = styles
-            if thicknesses is not None:
-                thickness_data = thicknesses
+            # Use provided dictionary - convert to list format
+            for depth, name in tops_dict.items():
+                entry = {'depth': depth, 'name': name}
+                if colors is not None and depth in colors:
+                    entry['color'] = colors[depth]
+                if styles is not None and depth in styles:
+                    entry['style'] = styles[depth]
+                if thicknesses is not None and depth in thicknesses:
+                    entry['thickness'] = thicknesses[depth]
+                tops_entries.append(entry)
 
         # Store tops for rendering
         self.tops.append({
-            'tops': tops_data,
-            'colors': color_data if color_data else None,
-            'styles': style_data if style_data else None,
-            'thicknesses': thickness_data if thickness_data else None
+            'entries': tops_entries
         })
 
     def _get_depth_mask(self, depth: np.ndarray) -> np.ndarray:
@@ -1451,34 +1450,21 @@ class WellView:
 
         # For each tops group
         for tops_group in self.tops:
-            tops_data = tops_group['tops']
-            colors_data = tops_group['colors']
-            styles_data = tops_group['styles']
-            thicknesses_data = tops_group['thicknesses']
+            entries = tops_group.get('entries', [])
 
             # Draw each top
-            for depth, formation_name in tops_data.items():
+            for entry in entries:
+                depth = entry['depth']
+                formation_name = entry['name']
+
                 # Skip tops outside depth range
                 if depth < self.depth_range[0] or depth > self.depth_range[1]:
                     continue
 
-                # Get color for this top
-                if colors_data and depth in colors_data:
-                    color = colors_data[depth]
-                else:
-                    color = 'black'  # Default color
-
-                # Get line style for this top
-                if styles_data and depth in styles_data:
-                    linestyle = styles_data[depth]
-                else:
-                    linestyle = 'solid'  # Default style
-
-                # Get line thickness for this top
-                if thicknesses_data and depth in thicknesses_data:
-                    linewidth = thicknesses_data[depth]
-                else:
-                    linewidth = 1.5  # Default thickness
+                # Get color, style, thickness from entry (with defaults)
+                color = entry.get('color', 'black')
+                linestyle = entry.get('style', 'solid')
+                linewidth = entry.get('thickness', 1.5)
 
                 # Draw line across all non-depth tracks
                 for ax in non_depth_axes:
@@ -2151,6 +2137,20 @@ class WellView:
         crossover_mask = left_values > right_values
         left_values = np.where(crossover_mask, right_values, left_values)
 
+        # Create valid mask - skip points where boundary values are NaN
+        boundary_valid_mask = ~(np.isnan(left_values) | np.isnan(right_values))
+
+        # Filter arrays to only valid points
+        if not np.all(boundary_valid_mask):
+            left_values = left_values[boundary_valid_mask]
+            right_values = right_values[boundary_valid_mask]
+            depth_for_fill = depth_for_fill[boundary_valid_mask]
+            n_points = len(depth_for_fill)
+
+            if n_points < 2:
+                # Not enough valid points to draw fill
+                return
+
         # Apply fill
         fill_color = fill.get("color", "lightblue")
         fill_alpha = fill.get("alpha", 0.3)
@@ -2185,6 +2185,10 @@ class WellView:
                     warnings.warn("Cannot determine colormap values (no curve specified for left or right)")
                     return
 
+            # Apply same boundary mask to colormap values
+            if not np.all(boundary_valid_mask):
+                colormap_values = colormap_values[boundary_valid_mask]
+
             # Get color range for normalization
             # Check if we have valid values
             valid_mask = ~np.isnan(colormap_values)
@@ -2193,7 +2197,17 @@ class WellView:
                 return
 
             color_range = fill.get("color_range", [np.nanmin(colormap_values), np.nanmax(colormap_values)])
-            norm = Normalize(vmin=color_range[0], vmax=color_range[1])
+            # Default color_log to track's log_scale setting
+            color_log = fill.get("color_log", track_log_scale)
+
+            # Use LogNorm for log scale colormap, Normalize for linear
+            if color_log:
+                # Ensure positive values for log scale
+                vmin = max(color_range[0], 1e-10)
+                vmax = max(color_range[1], vmin * 10)
+                norm = LogNorm(vmin=vmin, vmax=vmax)
+            else:
+                norm = Normalize(vmin=color_range[0], vmax=color_range[1])
             cmap = plt.get_cmap(cmap_name)
 
             # Create horizontal bands - each depth interval gets a color based on the curve value
@@ -2288,7 +2302,8 @@ class WellView:
         ax: plt.Axes,
         fill: dict,
         plotted_curves: dict,
-        depth: np.ndarray
+        depth: np.ndarray,
+        track_log_scale: bool = False
     ) -> None:
         """
         Add fill between curves or values.
@@ -2363,6 +2378,20 @@ class WellView:
         crossover_mask = left_values > right_values
         left_values = np.where(crossover_mask, right_values, left_values)
 
+        # Create valid mask - skip points where boundary values are NaN
+        boundary_valid_mask = ~(np.isnan(left_values) | np.isnan(right_values))
+
+        # Filter arrays to only valid points
+        depth_for_fill = depth  # Use local variable for consistency
+        if not np.all(boundary_valid_mask):
+            left_values = left_values[boundary_valid_mask]
+            right_values = right_values[boundary_valid_mask]
+            depth_for_fill = depth[boundary_valid_mask]
+
+            if len(depth_for_fill) < 2:
+                # Not enough valid points to draw fill
+                return
+
         # Apply fill
         fill_color = fill.get("color", "lightblue")
         fill_alpha = fill.get("alpha", 0.3)
@@ -2397,6 +2426,10 @@ class WellView:
                     warnings.warn("Cannot determine colormap values (no curve specified for left or right)")
                     return
 
+            # Apply same boundary mask to colormap values
+            if not np.all(boundary_valid_mask):
+                colormap_values = colormap_values[boundary_valid_mask]
+
             # Get color range for normalization
             # Check if we have valid values
             valid_mask = ~np.isnan(colormap_values)
@@ -2405,12 +2438,22 @@ class WellView:
                 return
 
             color_range = fill.get("color_range", [np.nanmin(colormap_values), np.nanmax(colormap_values)])
-            norm = Normalize(vmin=color_range[0], vmax=color_range[1])
+            # Default color_log to track's log_scale setting
+            color_log = fill.get("color_log", track_log_scale)
+
+            # Use LogNorm for log scale colormap, Normalize for linear
+            if color_log:
+                # Ensure positive values for log scale
+                vmin = max(color_range[0], 1e-10)
+                vmax = max(color_range[1], vmin * 10)
+                norm = LogNorm(vmin=vmin, vmax=vmax)
+            else:
+                norm = Normalize(vmin=color_range[0], vmax=color_range[1])
             cmap = plt.get_cmap(cmap_name)
 
             # Create horizontal bands - each depth interval gets a color based on the curve value
             # Use PolyCollection for performance (1000x faster than loop with fill_betweenx)
-            n_intervals = len(depth) - 1
+            n_intervals = len(depth_for_fill) - 1
 
             # Compute color values for each interval (average of adjacent points)
             color_values = (colormap_values[:-1] + colormap_values[1:]) / 2
@@ -2421,10 +2464,10 @@ class WellView:
             verts = []
             for i in range(n_intervals):
                 verts.append([
-                    (left_values[i], depth[i]),
-                    (right_values[i], depth[i]),
-                    (right_values[i+1], depth[i+1]),
-                    (left_values[i+1], depth[i+1])
+                    (left_values[i], depth_for_fill[i]),
+                    (right_values[i], depth_for_fill[i]),
+                    (right_values[i+1], depth_for_fill[i+1]),
+                    (left_values[i+1], depth_for_fill[i+1])
                 ])
 
             # Create PolyCollection with all polygons at once

{well_log_toolkit-0.1.138.dist-info → well_log_toolkit-0.1.140.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.138
+Version: 0.1.140
 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
@@ -463,7 +463,10 @@ template.add_track(track_type="continuous", logs=[...], title="Resistivity")
 template.add_track(track_type="discrete", logs=[...], title="Facies")
 template.add_track(track_type="depth", width=0.3, title="Depth")
 
-# Save for reuse
+# Add to project (saves with manager.save())
+manager.add_template(template)  # Uses template name "reservoir"
+
+# Or save standalone file
 template.save("reservoir_template.json")
 ```
 
@@ -811,8 +814,8 @@ view.show()
 
 **Option 2: Store in manager (recommended for multi-well projects)**
 ```python
-# Store template in manager
-manager.set_template("reservoir", template)
+# Store template in manager (uses template.name automatically)
+manager.add_template(template)
 
 # Use by name in any well
 view = well.WellView(depth_range=[2800, 3000], template="reservoir")
@@ -859,8 +862,8 @@ template.remove_track(2)
 template.add_track(track_type="continuous", logs=[{"name": "RT"}])
 
 # Save changes
-manager.set_template("reservoir", template)  # Update in manager
-template.save("updated_template.json")        # Save to file
+manager.add_template(template)          # Update in manager (uses template.name)
+template.save("updated_template.json")  # Save to file
 ```
 
 ### Customization
@@ -1006,8 +1009,8 @@ template.add_track(track_type="depth", width=0.3, title="MD (m)")
 # Add formation tops spanning all tracks
 template.add_tops(property_name='Zone')
 
-# Save and display
-manager.set_template("comprehensive", template)
+# Add to project and display
+manager.add_template(template)
 view = well.WellView(depth_range=[2800, 3200], template="comprehensive")
 view.save("comprehensive_log.png", dpi=300)
 ```
@@ -1886,7 +1889,8 @@ from well_log_toolkit import WellDataManager, Well, Property, LasFile
 - `remove_well(name)` - Remove well
 - `save(directory)` - Save project
 - `load(directory)` - Load project
-- `set_template(name, template)` - Store template
+- `add_template(template)` - Store template (uses template.name)
+- `set_template(name, template)` - Store template with custom name
 - `get_template(name)` - Retrieve template
 - `list_templates()` - List template names
 - `Crossplot(x, y, wells=None, shape="well", ...)` - Create multi-well crossplot
@@ -2053,7 +2057,7 @@ template.add_track(
     logs=[{"name": "GR", "x_range": [0, 150], "color": "green"}],
     title="Gamma Ray"
 )
-manager.set_template("custom", template)
+manager.add_template(template)  # Stored as "custom"
 view = well.WellView(template="custom")
 view.save("log.png", dpi=300)
 ```

{well_log_toolkit-0.1.138.dist-info → well_log_toolkit-0.1.140.dist-info}/RECORD

@@ -7,9 +7,9 @@ well_log_toolkit/property.py,sha256=ol_E4r31ButSnQEzAZjI00ofaRePPcJstRLOFFcgtp4,
 well_log_toolkit/regression.py,sha256=JDcRxaODJnFikAdPJyTq8eUV7iY0vCDmvnGufqlojxs,31625
 well_log_toolkit/statistics.py,sha256=_huPMbv2H3o9ezunjEM94mJknX5wPK8V4nDv2lIZZRw,16814
 well_log_toolkit/utils.py,sha256=O2KPq4htIoUlL74V2zKftdqqTjRfezU9M-568zPLme0,6866
-well_log_toolkit/visualization.py,sha256=HsTpd4UQCbu6pluVJ3AD9WWRg5mue8XGnlNhJUVIhF8,202585
+well_log_toolkit/visualization.py,sha256=nnpmFmbj44TbP0fsnLMR1GaKRkqKCEpI6Fd8Cp0oqBc,204716
 well_log_toolkit/well.py,sha256=Aav5Y-rui8YsJdvk7BFndNPUu1O9mcjwDApAGyqV9kw,104535
-well_log_toolkit-0.1.138.dist-info/METADATA,sha256=foX8i4aDHbERhEqZJOdE6E0rNT7yF4imIm8gKhudIqo,61149
-well_log_toolkit-0.1.138.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-well_log_toolkit-0.1.138.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.138.dist-info/RECORD,,
+well_log_toolkit-0.1.140.dist-info/METADATA,sha256=Mchq-GINJbLb3Bul25DQ_AI6FjRJWZtsQKra27L1TOk,61388
+well_log_toolkit-0.1.140.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+well_log_toolkit-0.1.140.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.140.dist-info/RECORD,,