objscale 0.1.2__tar.gz → 0.1.4__tar.gz

{objscale-0.1.2 → objscale-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: objscale
-Version: 0.1.2
+Version: 0.1.4
 Summary: Object-based analysis functions for fractal dimensions and size distributions
 Author-email: Thomas DeWitt <thomas.dewitt@utah.edu>
 License: MIT

{objscale-0.1.2 → objscale-0.1.4}/objscale/__init__.py

@@ -50,7 +50,7 @@ __all__ = [
     'encase_in_value',
 ]
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 __author__ = "Thomas DeWitt"
 __email__ = "thomas.dewitt@utah.edu"
 __description__ = "Object-based analysis functions for fractal dimensions and size distributions"

{objscale-0.1.2 → objscale-0.1.4}/objscale/_fractal_dimensions.py

@@ -8,7 +8,7 @@ from ._object_analysis import remove_structures_touching_border_nan, remove_stru
 from ._utils import linear_regression, encase_in_value
 
 
-def ensemble_correlation_dimension(arrays, x_sizes=None, y_sizes=None, middle_ninth=True, return_C_l=False, bins=None, point_reduction_factor=1, nbins=50):
+def ensemble_correlation_dimension(arrays, x_sizes=None, y_sizes=None, minlength='auto', maxlength='auto', interior_circles_only=True, return_C_l=False, bins=None, point_reduction_factor=1, nbins=50):
     """
     Calculate the correlation dimension D where C_l ∝ l^D for binary arrays.
 
@@ -24,9 +24,16 @@ def ensemble_correlation_dimension(arrays, x_sizes=None, y_sizes=None, middle_ni
         Pixel sizes in the y direction. If None, assume all pixel dimensions are 1.
         If np.ndarray, use these for each array in 'arrays'. If list, assume
         y_sizes[i] corresponds to arrays[i].
-    middle_ninth : bool, default=True
-        For each pixel, only use distances between that pixel and pixels within
-        the central 9th section of the array. This reduces boundary effects.
+    minlength : str or float, default='auto'
+        Minimum length scale for correlation calculation. If 'auto', uses 3 times
+        the minimum pixel size.
+    maxlength : str or float, default='auto'
+        Maximum length scale for correlation calculation. If 'auto', uses 0.1 times
+        the minimum array dimension.
+    interior_circles_only : bool, default=True
+        If True, only use circle centers that are at least maxlength distance from
+        all array edges to avoid boundary effects. In other words, only use circles
+        that are fully contained within the array. Recommended!
     return_C_l : bool, default=False
         If True, return dimension, error, bins, C_l. Otherwise, return dimension, error.
     bins : None, int, or array-like, optional
@@ -63,22 +70,34 @@ def ensemble_correlation_dimension(arrays, x_sizes=None, y_sizes=None, middle_ni
     h = x_sizes.shape[0]
     w = x_sizes.shape[1]
 
-    if middle_ninth: 
-        # For the most conservative estimate, the maximum radius should be 
-        # the minimum distance from the middle ninth boundary to the array edge
-        # This should be 1/3 of the array shape
-        # This ensures no circle extends outside the domain
-        # Note this assumes rectangular domain
-        maxlength = min(h/3, w/3)
-    else:   # min(width, height) of entire array, where width, height are calculated in the center
-        maxlength = np.sqrt((locations_x[int(h/2), 0]-locations_x[int(h/2), w-1])**2 + (locations_y[0, int(w/2)]-locations_y[h-1, int(w/2)])**2)
-
-    minlength = 3*min(np.nanmin(x_sizes), np.nanmin(y_sizes))
+    if maxlength == 'auto': 
+          # One tenth of min(width, height) of entire array, where width, height are calculated in the center
+        maxlength =  0.1 * min((locations_x[int(h/2), w-1]-locations_x[int(h/2), 0]), (locations_y[h-1, int(w/2)]-locations_y[0, int(w/2)]))
+
+    if minlength == 'auto': minlength = 3*min(np.nanmin(x_sizes), np.nanmin(y_sizes))
+
+    # Basic validation checks
+    if np.any(np.isnan(x_sizes)) or np.any(np.isnan(y_sizes)):
+        raise ValueError("x_sizes and y_sizes cannot contain NaN values")
+
+    if np.any(x_sizes <= 0) or np.any(y_sizes <= 0):
+        raise ValueError("x_sizes and y_sizes must be positive")
+
     if bins is None: 
         bins = np.geomspace(minlength, maxlength, nbins)
     elif isinstance(bins, int):
         bins = np.geomspace(minlength, maxlength, bins)
 
+    # range of scale checks
+    # check these with the actual calculated bins for greatest relevance
+    if bins[-1] <= bins[0]:
+        raise ValueError(f"bin maximum length ({bins[-1]:.3f}) must be greater than bin minimum length ({bins[0]:.3f}); or if bins are passed, they must be increasing. Did you pass invalid values for minlength/maxlength?")
+
+    if bins[-1] / bins[0] < 10:
+        raise ValueError(f"Available scale ratio ({maxlength/minlength:.2f}) is less than 10. "
+                        f"Need at least one order of magnitude separation for reliable dimension estimation.")
+
+
     C_l = np.zeros(bins.shape)
 
     for array in arrays:
@@ -88,14 +107,38 @@ def ensemble_correlation_dimension(arrays, x_sizes=None, y_sizes=None, middle_ni
 
         all_boundary_coordinates = get_coords_of_boundaries(array)
 
-        if middle_ninth:
-            middle_coordinates = all_boundary_coordinates[np.argwhere((all_boundary_coordinates[:,0]<int(2*h/3)) & (all_boundary_coordinates[:,0]>int(h/3))).flatten()]
-            middle_coordinates = middle_coordinates[np.argwhere((middle_coordinates[:,1]<int(2*w/3)) & (middle_coordinates[:,1]>int(w/3))).flatten()]
+        if interior_circles_only:
+            # Calculate distance from each boundary coordinate to all array edges
+            coord_locations_x = locations_x[all_boundary_coordinates[:,0], all_boundary_coordinates[:,1]]
+            coord_locations_y = locations_y[all_boundary_coordinates[:,0], all_boundary_coordinates[:,1]]
+            
+            # Distance to each edge for all coordinates
+            dist_to_left = coord_locations_x - locations_x[int(h/2), 0]
+            dist_to_right = locations_x[int(h/2), w-1] - coord_locations_x
+            dist_to_top = coord_locations_y - locations_y[0, int(w/2)]
+            dist_to_bottom = locations_y[h-1, int(w/2)] - coord_locations_y
+            
+            # Find coordinates that are at least maxlength from ALL edges
+            min_dist_to_any_edge = np.minimum.reduce([dist_to_left, dist_to_right, dist_to_top, dist_to_bottom])
+            interior_mask = min_dist_to_any_edge >= maxlength
+            
+            circle_centers = all_boundary_coordinates[interior_mask]
 
-            circle_centers = middle_coordinates
+            if len(circle_centers) == 0:
+                raise ValueError(f"No circle centers remain after interior filtering. "
+                                f"Decrease maxlength (currently {maxlength:.3f}) or consider whether interior_circles_only=True is appropriate.")
+            
+                # Check if sufficient circle centers remain
+            elif len(circle_centers)//point_reduction_factor < 10:
+                warn(f"Only {len(circle_centers)} circle centers remain after interior filtering. "
+                    f"Consider decreasing maxlength or reducing point_reduction_factor for better statistics.")
+                
         else:
             circle_centers = all_boundary_coordinates
 
+        if len(circle_centers)//point_reduction_factor<1:
+            raise ValueError(f'uh oh no circle center locations! is point_reduction_factor={point_reduction_factor} too high?')
+
         if point_reduction_factor>1:
             circle_centers = circle_centers[np.random.choice(np.arange(len(circle_centers)), int(len(circle_centers)/point_reduction_factor), replace=False)]
         elif point_reduction_factor<1: raise ValueError('point_reduction_factor must be >= 1')
@@ -692,7 +735,7 @@ def _label_size_helper(labelled_array, separated_structure_indices, labelled_wit
             elif j == labelled_array.shape[1]-1 and labelled_array[i, 0] == 0: perimeter += y_sizes[i,j]
 
             if j != 0 and labelled_array[i, j-1] == 0: perimeter += y_sizes[i,j]
-            elif j == 0 and labelled_array[i, 0] == 0: perimeter += y_sizes[i,j]
+            elif j == 0 and labelled_array[i, labelled_array.shape[1]-1] == 0: perimeter += y_sizes[i,j]
 
             # Area:
             area += y_sizes[i,j] * x_sizes[i,j]

{objscale-0.1.2 → objscale-0.1.4}/objscale/_object_analysis.py

@@ -1,6 +1,6 @@
 import numpy as np
 from scipy.ndimage import label
-from numba import njit
+from numba import njit, prange
 from numba.typed import List
 from warnings import warn
 from skimage.segmentation import clear_border
@@ -90,24 +90,33 @@ def get_structure_props(array, x_sizes, y_sizes, structure = np.array([[0, 1, 0]
     return p,a,h,w
 
 
-@njit()
+@njit(parallel=True)
 def _get_structure_props_helper(labelled_array, separated_structure_indices, x_sizes, y_sizes):
-    
-    p, a, = [],[]
-    h, w = [],[]
 
-    for indices in separated_structure_indices:
+
+    # Preallocate arrays
+    n_structures = len(separated_structure_indices)
+    p = np.empty(n_structures, dtype=np.float32)
+    a = np.empty(n_structures, dtype=np.float32)
+    h = np.empty(n_structures, dtype=np.float32)
+    w = np.empty(n_structures, dtype=np.float32)
+
+
+    for iteration in prange(len(separated_structure_indices)):
+        iteration = np.int64(iteration) 
+        structure_coords = separated_structure_indices[iteration]
         perimeter = 0
         area = 0
 
-        y_coords_structure = np.array([c[0] for c in indices])
-        x_coords_structure = np.array([c[1] for c in indices])
+        y_coords_structure = np.array([c[0] for c in structure_coords])
+        x_coords_structure = np.array([c[1] for c in structure_coords])
         unique_y_coords = []
         unique_x_coords = []
         height = 0
         width = 0
 
-        for (i,j) in indices:
+        for i,j in structure_coords:
+
             # Height, Width
             if i not in unique_y_coords:
                 unique_y_coords.append(i)
@@ -143,14 +152,16 @@ def _get_structure_props_helper(labelled_array, separated_structure_indices, x_s
             area += y_sizes[i,j] * x_sizes[i,j]
 
 
-        if area != 0: 
-            p.append(perimeter)
-            a.append(area)
-            h.append(height)
-            w.append(width)
-
-
-    return p, a, h, w
+        if area != 0:
+            p[iteration] = perimeter
+            a[iteration] = area
+            h[iteration] = height
+            w[iteration] = width
+            # valid_count += 1
+    
+    # Return only the valid entries
+    valid_mask = (a>0)
+    return p[valid_mask], a[valid_mask], h[valid_mask], w[valid_mask]
 
 
 def label_periodic_boundaries(labelled_array, wrap):

{objscale-0.1.2 → objscale-0.1.4}/objscale.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: objscale
-Version: 0.1.2
+Version: 0.1.4
 Summary: Object-based analysis functions for fractal dimensions and size distributions
 Author-email: Thomas DeWitt <thomas.dewitt@utah.edu>
 License: MIT

{objscale-0.1.2 → objscale-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "objscale"
-version = "0.1.2"
+version = "0.1.4"
 description = "Object-based analysis functions for fractal dimensions and size distributions"
 readme = "README.md"
 authors = [

{objscale-0.1.2 → objscale-0.1.4}/tests/test_objscale.py

@@ -7,6 +7,7 @@ Creates 4 percolation lattices and calculates all parameters
 import numpy as np
 import matplotlib.pyplot as plt
 import sys
+import time
 sys.path.insert(0, '..')
 import objscale
 
@@ -36,6 +37,7 @@ def main():
     print("\n=== CALCULATING PARAMETERS ===")
     
     # Calculate power-law exponents and get distribution data
+    s = time.time()
     print("Calculating area power-law exponent and distribution...")
     (area_exponent, area_error), (area_sizes, area_counts) = objscale.finite_array_powerlaw_exponent(
         arrays, 'area', bins=50, min_threshold=10, return_counts=True
@@ -46,13 +48,14 @@ def main():
         arrays, 'perimeter', bins=50, min_threshold=10, return_counts=True
     )
     
-    print(f"Area exponent: {area_exponent:.3f} ± {area_error:.3f}")
-    print(f"Perimeter exponent: {perim_exponent:.3f} ± {perim_error:.3f}")
+    print(f'Power law exponents took {time.time()-s:.02f} seconds')
+    print(f"    Area exponent: {area_exponent:.3f} ± {area_error:.3f}")
+    print(f"    Perimeter exponent: {perim_exponent:.3f} ± {perim_error:.3f}")
     
     # Calculate correlation dimension
     print("Calculating correlation dimension...")
     corr_dim, corr_error, corr_lengths, corr_integrals = objscale.ensemble_correlation_dimension(
-        arrays, return_C_l=True, point_reduction_factor=1000
+        arrays, return_C_l=True, point_reduction_factor=1000, maxlength='auto', interior_circles_only=False
     )
     print(f"Correlation dimension: {corr_dim:.3f} ± {corr_error:.3f}")