pycerr 2.2.2__tar.gz → 2.2.3__tar.gz

{pycerr-2.2.2 → pycerr-2.2.3}/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.2.3] - 2026-09-28
+
+### Changed
+
+- **Faster GLRLM and GLSZM.** `calcRLM` walks all runs of every grey level
+  together along flat-index strides, visiting each voxel once per direction
+  instead of once per level. `calcSZM` labels the zones of all levels in a
+  single `skimage.measure.label` pass, and `szmToScalarFeatures` drops empty
+  zone-size columns before building its temporaries. Both matrices are
+  identical to 2.2.2; about 10x faster on the IBSI 1 phantom.
+
 ## [2.2.2] - 2026-09-28
 
 ### Fixed

{pycerr-2.2.2/pycerr.egg-info → pycerr-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycerr
-Version: 2.2.2
+Version: 2.2.3
 Summary: A Computational Environment for Radiological Research
 Author-email: "Aditya P. Apte" <aptea@mskcc.org>, Aditi Iyer <iyera@mskcc.org>, Eve LoCastro <locastre@mskcc.org>, "Joseph O. Deasy" <deasyj@mskcc.org>
 Project-URL: Homepage, https://github.com/cerr/pyCERR

{pycerr-2.2.2 → pycerr-2.2.3}/cerr/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.2'
-__version_tuple__ = version_tuple = (2, 2, 2)
+__version__ = version = '2.2.3'
+__version_tuple__ = version_tuple = (2, 2, 3)
 
-__commit_id__ = commit_id = 'gf85644a5a'
+__commit_id__ = commit_id = 'gc53f0b806'

{pycerr-2.2.2 → pycerr-2.2.3}/cerr/radiomics/run_length.py

@@ -27,74 +27,50 @@ def calcRLM(quantizedM, offsetsM, nL, rlmType=1):
 
     """
 
-    if rlmType != 1:
-        rlmOut = []
-
-    pad_width = [(1, 1)] * quantizedM.ndim
-    quantizedM = np.pad(quantizedM, pad_width, mode='constant', constant_values=0)
-
-    numRowsPad, numColsPad, numSlcsPad = 1, 1, 1
-    q = np.pad(quantizedM, ((numRowsPad, numRowsPad), (numColsPad, numColsPad), (numSlcsPad, numSlcsPad)),
-               mode='constant', constant_values=0)
+    # Zero-pad so every step from a ROI voxel lands inside the array. 0 marks
+    # voxels outside the ROI, so runs always end in the padding.
+    maxRunLen = int(np.ceil((np.max(quantizedM.shape) + 2) * 2))
+    pad = max(2, int(np.max(np.abs(offsetsM))) + 1)
+    q = np.pad(quantizedM, pad, mode='constant', constant_values=0)
     q[np.isnan(q)] = 0
     q = q.astype(np.uint16)
+    flatV = q.ravel()
+    stridesV = np.array(q.strides) // q.itemsize
 
-    numOffsets = offsetsM.shape[0]
-    maxRunLen = int(np.ceil(np.max(quantizedM.shape)*2))
-    #maxRunLen = 1000
-    #print('Max Run Length = ' + str(maxRunLen))
+    # All ROI voxels (flat indices)
+    roiIndV = np.flatnonzero(flatV)
 
+    numOffsets = offsetsM.shape[0]
     rlmM = np.zeros((nL, maxRunLen))
-    if rlmType == 2:
-        rlmOut = [np.zeros((nL, maxRunLen)) for i in range(numOffsets)]
-
-    siz = np.array(q.shape)
-    rowV = np.arange(siz[0],dtype = np.uint16)[:,None]
-    colV = np.arange(siz[1],dtype = np.uint16)[None,:]
-
-    rowIndM = np.repeat(rowV,siz[1], axis = 1)[:,:,None]
-    colIndM = np.repeat(colV,siz[0], axis = 0)[:,:,None]
-    rowIndM = np.repeat(rowIndM, siz[2], axis = 2)
-    colIndM = np.repeat(colIndM, siz[2], axis = 2)
-    slcIndM = np.zeros(siz,dtype = np.uint16)
-    for slc in range(siz[2]):
-        slcIndM[:,:,slc] = slc
-
-
+    rlmOut = []
     for off in range(numOffsets):
         if rlmType == 2:
-            rlmM = rlmOut[off]
-
-        offset = offsetsM[off]
-        rolled_q = np.roll(q, offset, axis=(0, 1, 2))
-        for level in range(1, nL + 1):
-            #t = time.time()
-            prevM = (q == level).astype(int)
-            # diffM = prevM - np.roll(prevM, offset, axis=(0, 1, 2))
-            diffM = prevM - (rolled_q == level).astype(int)
-            startM = diffM == 1
-            #startIndV = np.where(startM)
-            #convergedV = np.full(len(startIndV[0]),False,dtype=bool)
-            rowStartV = rowIndM[startM]
-            colStartV = colIndM[startM]
-            slcStartV = slcIndM[startM]
-            startIndV = (rowStartV, colStartV, slcStartV)
-            stopM = diffM == -1
-            convergedV = np.full(len(rowStartV),False,dtype=bool)
-            count = 0
-            while not np.all(convergedV):
-                count += 1
-                nextIndV = startIndV + count * offset[:,None]
-                nextIndV[nextIndV < 0] = 0
-                nextIndV[nextIndV >= siz[:,None]] = 0 # assign 0 as it will have value of 0
-                newConvergedV = stopM[nextIndV[0,:],nextIndV[1,:],nextIndV[2,:]]
-                numConverged = (~convergedV[newConvergedV]).sum()
-                convergedV[newConvergedV] = True
-                rlmM[level - 1, count-1] += numConverged
+            rlmM = np.zeros((nL, maxRunLen))
+
+        # A step along this offset is a fixed stride in the flattened array
+        step = int(np.dot(offsetsM[off], stridesV))
+
+        # Run starts: ROI voxels whose predecessor along -offset has a different level
+        startIndV = roiIndV[flatV[roiIndV - step] != flatV[roiIndV]]
+        levelV = flatV[startIndV].astype(np.int64)
+
+        # Advance all open runs together, one step at a time. A run ends at the
+        # first voxel with a different level; count it and drop it from the active set.
+        # Each voxel is visited once per offset, independent of the number of levels.
+        curIndV = startIndV.copy()
+        lenV = np.ones(len(startIndV), dtype=np.int64)
+        activeV = np.arange(len(startIndV))
+        while activeV.size:
+            nextIndV = curIndV[activeV] + step
+            continuesV = flatV[nextIndV] == levelV[activeV]
+            endedV = activeV[~continuesV]
+            np.add.at(rlmM, (levelV[endedV] - 1, lenV[endedV] - 1), 1)
+            activeV = activeV[continuesV]
+            curIndV[activeV] = nextIndV[continuesV]
+            lenV[activeV] += 1
 
         if rlmType == 2:
-            #rlmOut.append(rlmM)
-            rlmOut[off] = rlmM
+            rlmOut.append(rlmM)
 
     if rlmType == 1:
         rlmOut = rlmM

{pycerr-2.2.2 → pycerr-2.2.3}/cerr/radiomics/size_zone.py

@@ -3,7 +3,7 @@ This module contains routines for claculation of Size Zone texture features
 """
 
 import numpy as np
-from scipy.ndimage import label
+from skimage.measure import label
 
 def calcSZM(quantized3M, nL, szmType):
     """
@@ -24,35 +24,41 @@ def calcSZM(quantized3M, nL, szmType):
 
     """
 
+    # Zones are connected regions of equal grey level. skimage's label connects
+    # neighbours with EQUAL values, so one pass labels the zones of every level
+    # (connectivity 3 = 26-connected in 3D, 2 = 8-connected in 2D). 0 is outside the ROI.
+    q = np.nan_to_num(np.asarray(quantized3M, dtype=float), nan=0).astype(np.int32)
+
     if szmType == 1:
-        s = np.ones((3,3,3))
+        zoneSizeV, zoneLevelV = _zoneSizesAndLevels(q, connectivity=3)
     else:
-        s = np.ones((3,3))
-
-    sizeV = quantized3M.shape
-    szmM = np.zeros((nL, quantized3M.size), dtype=int)
-    maxSiz = 0
-    for level in range(1, nL+1):
-        if szmType == 1:
-            connM, num_features = label(quantized3M == level, structure=s)
-        else:
-            connM = np.zeros(sizeV, dtype=int)
-            featOffset = 0
-            for slc in range(sizeV[2]):
-                connSlcM, num_features = label(quantized3M[:,:,slc] == level, structure=s)
-                indNoZero = connSlcM > 0
-                connSlcM[indNoZero] += featOffset
-                connM[:,:,slc] = connSlcM
-                featOffset += num_features
-        regionSizV = np.bincount(connM[connM > 0])
-        if len(regionSizV) > 0:
-            maxSiz = max(maxSiz, max(regionSizV))
-        counts = np.bincount(regionSizV)[1:]
-        szmM[level - 1, :len(counts)] = counts
-    szmM = szmM[:, :maxSiz]
+        sizeL, levelL = [], []
+        for slc in range(q.shape[2]):
+            sizV, levV = _zoneSizesAndLevels(q[:, :, slc], connectivity=2)
+            sizeL.append(sizV)
+            levelL.append(levV)
+        zoneSizeV = np.concatenate(sizeL)
+        zoneLevelV = np.concatenate(levelL)
+
+    maxSiz = int(zoneSizeV.max()) if zoneSizeV.size else 0
+    szmM = np.zeros((nL, maxSiz), dtype=int)
+    np.add.at(szmM, (zoneLevelV - 1, zoneSizeV - 1), 1)
     return szmM
 
 
+def _zoneSizesAndLevels(q, connectivity):
+    """Size and grey level of every zone (connected region of equal non-zero level) in q."""
+    labelM = label(q, background=0, connectivity=connectivity)
+    labelV = labelM.ravel()
+    zoneSizeV = np.bincount(labelV)[1:]
+    # Grey level of each zone, read from any one of its voxels
+    roiIndV = np.flatnonzero(labelV)
+    voxelOfZoneV = np.zeros(zoneSizeV.size + 1, dtype=np.int64)
+    voxelOfZoneV[labelV[roiIndV]] = roiIndV
+    zoneLevelV = q.ravel()[voxelOfZoneV[1:]].astype(np.int64)
+    return zoneSizeV, zoneLevelV
+
+
 def szmToScalarFeatures(szmM, numVoxels):
     """
 
@@ -72,8 +78,13 @@ def szmToScalarFeatures(szmM, numVoxels):
 
     featureS = {}
 
-    nL, maxLength = szmM.shape
-    lenV = np.arange(1, maxLength + 1, dtype = np.uint64)
+    # Keep only zone sizes that occur. Empty columns add nothing to any feature,
+    # and a single large zone would otherwise make every (nL x maxSize) temporary
+    # below hundreds of MB.
+    sizeIndV = np.flatnonzero(np.sum(szmM, axis=0))
+    szmM = szmM[:, sizeIndV]
+    nL = szmM.shape[0]
+    lenV = (sizeIndV + 1).astype(np.uint64)
     levV = np.arange(1, nL + 1, dtype = np.uint64)
     lenV = lenV[None,:]
     levV = levV[None,:]

{pycerr-2.2.2 → pycerr-2.2.3/pycerr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycerr
-Version: 2.2.2
+Version: 2.2.3
 Summary: A Computational Environment for Radiological Research
 Author-email: "Aditya P. Apte" <aptea@mskcc.org>, Aditi Iyer <iyera@mskcc.org>, Eve LoCastro <locastre@mskcc.org>, "Joseph O. Deasy" <deasyj@mskcc.org>
 Project-URL: Homepage, https://github.com/cerr/pyCERR

{pycerr-2.2.2 → pycerr-2.2.3}/pycerr.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "2.2.2",
+  "tag": "2.2.3",
   "distance": 0,
-  "node": "gf85644a5ac131d6d64abcc0b4153e55632377685",
+  "node": "gc53f0b806910d6e5ea6db88e4bd22ec4d7a6d7ad",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-28"