cropro 0.1.2__py3-none-any.whl

cropro/__init__.py

@@ -0,0 +1,6 @@
+"""Public package API for CROPro."""
+
+from .config import CropConfig
+from .core import CROPro, run
+
+__all__ = ["CROPro", "CropConfig", "run"]

cropro/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

cropro/cli.py

@@ -0,0 +1,78 @@
+"""Command-line interface for CROPro."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+from pathlib import Path
+
+from .config import CropConfig
+from .core import CROPro
+
+
+def _boolean(value: str) -> bool:
+    normalized = value.strip().lower()
+    if normalized in {"1", "true", "t", "yes", "y", "on"}:
+        return True
+    if normalized in {"0", "false", "f", "no", "n", "off"}:
+        return False
+    raise argparse.ArgumentTypeError(f"Expected a boolean value, got {value!r}.")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="cropro",
+        description="Crop prostate MR images using center, random, or stride strategies.",
+    )
+    parser.add_argument("--crop_method", default="center", choices=["center", "random", "stride"])
+    parser.add_argument("--orig_img_path_t2w", type=Path)
+    parser.add_argument("--orig_img_path_adc", type=Path)
+    parser.add_argument("--orig_img_path_hbv", type=Path)
+    parser.add_argument("--seg_img_path", type=Path)
+    parser.add_argument("--seg_img_path_lesion", type=Path)
+    parser.add_argument("--prostate_gland_seg_contains_lesion", type=_boolean, default=False)
+    parser.add_argument("--tumor_label_level", type=int, default=2)
+    parser.add_argument(
+        "--patient_status", default="negative", choices=["negative", "positive", "unknown"]
+    )
+    parser.add_argument("--pixel_spacing", type=float, default=0.5)
+    parser.add_argument("--crop_image_size", type=int, default=128)
+    parser.add_argument("--sample_number", type=int, default=12)
+    parser.add_argument("--crop_stride", type=int, default=32)
+    parser.add_argument("--sequence_type", default="T2W", choices=["T2W", "bpMRI"])
+    parser.add_argument("--normalized_image", type=_boolean, default=True)
+    parser.add_argument("--normalized_vmaxNumber", type=int, default=242)
+    parser.add_argument("--do_normalization", type=_boolean, default=False)
+    parser.add_argument("--min_percentile", type=float, default=0)
+    parser.add_argument("--max_percentile", type=float, default=99.5)
+    parser.add_argument(
+        "--saved_image_type",
+        default="tiff",
+        choices=["npy", "jpg", "jpeg", "png", "tiff", "tif", "nmp", "npm"],
+        help="Output format (nmp/npm are accepted aliases of npy for backward compatibility).",
+    )
+    parser.add_argument("--path_to_save", type=Path, default=Path("save_crop"))
+    parser.add_argument("--c_min_positive", type=float, default=0.2)
+    parser.add_argument("--c_min_negative", type=float, default=1)
+    parser.add_argument(
+        "--percentage_of_allowed_overlapping_betweeing_gland_lesions_mask",
+        type=float,
+        default=50.0,
+    )
+    parser.add_argument("--number_of_slices_to_exclude_from_mask_gland", type=int, default=1)
+    parser.add_argument("--keep_all_slice", type=_boolean, default=True)
+    parser.add_argument("--random_seed", type=int)
+    return parser
+
+
+def parse_args(argv: Sequence[str] | None = None) -> CropConfig:
+    parser = build_parser()
+    namespace = parser.parse_args(argv)
+    try:
+        return CropConfig.from_mapping(vars(namespace))
+    except ValueError as exc:
+        parser.error(str(exc))
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    CROPro(parse_args(argv)).run()

cropro/config.py

@@ -0,0 +1,147 @@
+"""Configuration objects for CROPro."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+CropMethod = Literal["center", "random", "stride"]
+PatientStatus = Literal["negative", "positive", "unknown"]
+SequenceType = Literal["T2W", "bpMRI"]
+SavedImageType = Literal["npy", "jpg", "jpeg", "png", "tiff", "tif"]
+
+VALID_CROP_METHODS = {"center", "random", "stride"}
+VALID_PATIENT_STATUSES = {"negative", "positive", "unknown"}
+VALID_SEQUENCE_TYPES = {"T2W", "bpMRI"}
+VALID_SAVED_IMAGE_TYPES = {"npy", "jpg", "jpeg", "png", "tiff", "tif"}
+SAVED_IMAGE_TYPE_ALIASES = {
+    "nmp": "npy",
+    "npm": "npy",
+}
+
+
+@dataclass(slots=True)
+class CropConfig:
+    """User-facing crop configuration.
+
+    The legacy implementation expects an argparse-like object with attributes.
+    This dataclass keeps that contract while making Python usage explicit,
+    typed, and independent from command-line parsing.
+    """
+
+    crop_method: CropMethod = "center"
+    orig_img_path_t2w: str | Path | None = None
+    orig_img_path_adc: str | Path | None = None
+    orig_img_path_hbv: str | Path | None = None
+    seg_img_path: str | Path | None = None
+    seg_img_path_lesion: str | Path | None = None
+    prostate_gland_seg_contains_lesion: bool = False
+    tumor_label_level: int = 2
+    patient_status: PatientStatus = "negative"
+    pixel_spacing: float = 0.5
+    crop_image_size: int = 128
+    sample_number: int = 12
+    crop_stride: int = 32
+    sequence_type: SequenceType = "T2W"
+    normalized_image: bool = True
+    normalized_vmaxNumber: int = 242
+    do_normalization: bool = False
+    min_percentile: float = 0
+    max_percentile: float = 99.5
+    saved_image_type: SavedImageType = "tiff"
+    path_to_save: str | Path = "save_crop"
+    c_min_positive: float = 0.2
+    c_min_negative: float = 1
+    percentage_of_allowed_overlapping_betweeing_gland_lesions_mask: float = 50.0
+    number_of_slices_to_exclude_from_mask_gland: int = 1
+    keep_all_slice: bool = True
+    random_seed: int | None = None
+
+    def __post_init__(self) -> None:
+        self.saved_image_type = SAVED_IMAGE_TYPE_ALIASES.get(
+            self.saved_image_type, self.saved_image_type
+        )
+        self._validate()
+
+    def _validate(self) -> None:
+        if self.crop_method not in VALID_CROP_METHODS:
+            raise ValueError(f"Invalid crop_method {self.crop_method!r}.")
+
+        if self.patient_status not in VALID_PATIENT_STATUSES:
+            raise ValueError(f"Invalid patient_status {self.patient_status!r}.")
+
+        if self.sequence_type not in VALID_SEQUENCE_TYPES:
+            raise ValueError(f"Invalid sequence_type {self.sequence_type!r}.")
+
+        if self.saved_image_type not in VALID_SAVED_IMAGE_TYPES:
+            raise ValueError(
+                f"Invalid saved_image_type {self.saved_image_type!r}. "
+                f"Expected one of {sorted(VALID_SAVED_IMAGE_TYPES)}."
+            )
+
+        if self.pixel_spacing <= 0:
+            raise ValueError("pixel_spacing must be greater than 0.")
+
+        if self.crop_image_size <= 0:
+            raise ValueError("crop_image_size must be greater than 0.")
+
+        if self.crop_stride <= 0:
+            raise ValueError("crop_stride must be greater than 0.")
+
+        if self.sample_number <= 0:
+            raise ValueError("sample_number must be greater than 0.")
+
+        if self.min_percentile < 0 or self.max_percentile > 100:
+            raise ValueError("Percentiles must be in [0, 100].")
+
+        if self.min_percentile >= self.max_percentile:
+            raise ValueError("min_percentile must be less than max_percentile.")
+
+        if not (0 <= self.c_min_positive):
+            raise ValueError("c_min_positive must be greater than or equal to 0.")
+
+        if not (0 <= self.c_min_negative):
+            raise ValueError("c_min_negative must be greater than or equal to 0.")
+
+        if not (0 <= self.percentage_of_allowed_overlapping_betweeing_gland_lesions_mask <= 100):
+            raise ValueError(
+                "percentage_of_allowed_overlapping_betweeing_gland_lesions_mask must be in [0, 100]."
+            )
+
+        if self.number_of_slices_to_exclude_from_mask_gland < 0:
+            raise ValueError("number_of_slices_to_exclude_from_mask_gland must be >= 0.")
+
+        if self.random_seed is not None and self.random_seed < 0:
+            raise ValueError("random_seed must be >= 0 when provided.")
+
+        if self.orig_img_path_t2w is None:
+            raise ValueError("orig_img_path_t2w is required.")
+
+        if self.seg_img_path is None:
+            raise ValueError("seg_img_path is required.")
+
+        if self.sequence_type == "bpMRI":
+            if self.orig_img_path_adc is None:
+                raise ValueError("orig_img_path_adc is required for bpMRI.")
+            if self.orig_img_path_hbv is None:
+                raise ValueError("orig_img_path_hbv is required for bpMRI.")
+
+        if self.patient_status == "positive" and self.seg_img_path_lesion is None:
+            raise ValueError("seg_img_path_lesion is required for positive patient_status.")
+
+    @classmethod
+    def from_mapping(cls, values: dict[str, Any]) -> CropConfig:
+        valid_keys = cls.__dataclass_fields__.keys()
+        clean_values = {key: value for key, value in values.items() if key in valid_keys}
+
+        saved_image_type = clean_values.get("saved_image_type")
+        if saved_image_type is not None:
+            clean_values["saved_image_type"] = SAVED_IMAGE_TYPE_ALIASES.get(
+                saved_image_type, saved_image_type
+            )
+
+        return cls(**clean_values)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)

cropro/core.py

@@ -0,0 +1,49 @@
+"""Library entry points for CROPro."""
+
+from __future__ import annotations
+
+import random
+from typing import Any
+
+import numpy as np
+
+from .config import CropConfig
+
+
+class CROPro:
+    """Run CROPro cropping from Python code.
+
+    Parameters may be provided either as a :class:`CropConfig` or as keyword
+    arguments matching ``CropConfig`` fields.
+    """
+
+    def __init__(self, config: CropConfig | None = None, **overrides: Any) -> None:
+        if config is not None and overrides:
+            values = config.to_dict()
+            values.update({key: value for key, value in overrides.items() if value is not None})
+            self.config = CropConfig.from_mapping(values)
+        elif config is not None:
+            self.config = config
+        else:
+            self.config = CropConfig.from_mapping(
+                {key: value for key, value in overrides.items() if value is not None}
+            )
+
+        self.arg = self.config
+
+        if self.config.random_seed is not None:
+            random.seed(self.config.random_seed)
+            np.random.seed(self.config.random_seed)
+
+    def cropro(self) -> None:
+        self.run()
+
+    def run(self) -> None:
+        from cropro.cropping.patientCropC import patientCropC
+
+        patient_crop = patientCropC(self.arg)
+        patient_crop.patientCrop()
+
+
+def run(config: CropConfig | None = None, **overrides: Any) -> None:
+    CROPro(config=config, **overrides).run()

cropro/cropping/__init__.py

@@ -0,0 +1 @@
+

cropro/cropping/croppingCrontrollerClass.py

@@ -0,0 +1,304 @@
+from pathlib import Path
+
+import cv2
+import numpy as np
+import SimpleITK as sitk
+
+from .negativeCenterC import negativeCenterC
+from .negativeRandomC import negativeRandomC
+from .negativeStrideC import negativeStrideC
+from .positiveCenterC import positiveCenterC
+from .positiveRandomC import positiveRandomC
+from .positiveStrideC import positiveStrideC
+
+
+class croppingCrontrollerClass:
+    """
+    This class controls the cropping.
+
+    Methods
+    -------
+    load_resample_itk(self, filename, is_mask))
+    sample_size_calculation(self,number_of_voxel)
+    cropTechniqueControler(self)
+    crop_and_save(self, orig_img_path_t2w, slice_number_correct, slice_name, name_file, pathToSave_same_as_dataset_structure , prostate_gland_arr_slice, prostate_lesion_arr_slice,patient_name, caseHealthyBoolean, seg_path=None):
+
+    """
+
+    def __init__(self, arg):
+        self.arg = arg
+
+    def _study_token(self):
+        study_id = getattr(self, "study_id", None)
+        if study_id in (None, ""):
+            return "unknown"
+        return str(study_id)
+
+    def log_crop_event(self, event, area_voxels=None, overlap_percentage=None):
+        message = f"{event} | study={self._study_token()}"
+        if area_voxels is not None:
+            message = f"{message} | area_voxels={int(area_voxels)}"
+        if overlap_percentage is not None:
+            message = f"{message} | overlap_pct={float(overlap_percentage):.1f}"
+        print(message)
+
+    def calculate_boundRect(self):
+        """
+        This fuction finds an approximate rectangle around the binary image. This is used only for center cropping
+        """
+        for i, curve_contours in enumerate(self.biggestAreaContour_array):
+            self.i = i
+            self.curve_contours = curve_contours
+            epsilon = 3  # approximation accuracy parameter. This is the maximum distance between the original curve and its approximation.
+            closed = True  # For true the approximated curve is closed, first and last vertices are connected.
+            # approxPolyDP: aims to approximate a contour (shape) to a different shape with less number of vertices.
+            self.contours_poly[self.i] = cv2.approxPolyDP(self.curve_contours, epsilon, closed)
+            # boundingRect: aims to daw an approximate rectangle around the binary image.
+            self.boundRect[self.i] = cv2.boundingRect(self.contours_poly[self.i])
+
+    def load_resample_itk(self, filename, is_mask=False):
+        """
+        This fuction is used to load a 3D itk image or segmentation(prostate gland/lesions)
+        and resample with a new pixel spacing
+
+        Parameters
+        ----------
+        filename : str
+            The filename is the path to the segmentation.
+        is_mask = Boolean
+            If the file is segmentation or normal 3D image
+
+        Returns
+        -------
+
+        GetArrayFromImage
+            The resampled images (array) for each slice
+
+        """
+        filename = Path(filename)
+        itk_image = sitk.ReadImage(str(filename))
+        original_spacing = itk_image.GetSpacing()
+        original_size = itk_image.GetSize()
+        out_spacing = [self.arg.pixel_spacing, self.arg.pixel_spacing, original_spacing[2]]
+
+        out_size = [
+            int(np.round(original_size[0] * (original_spacing[0] / out_spacing[0]))),
+            int(np.round(original_size[1] * (original_spacing[1] / out_spacing[1]))),
+            int(np.round(original_size[2] * (original_spacing[2] / original_spacing[2]))),
+        ]
+
+        resample = sitk.ResampleImageFilter()
+        resample.SetOutputSpacing(out_spacing)
+        resample.SetSize(out_size)
+        resample.SetOutputDirection(itk_image.GetDirection())
+        resample.SetOutputOrigin(itk_image.GetOrigin())
+        resample.SetTransform(sitk.Transform())
+        resample.SetDefaultPixelValue(itk_image.GetPixelIDValue())
+
+        if is_mask:
+            resample.SetInterpolator(sitk.sitkNearestNeighbor)
+        else:
+            resample.SetInterpolator(sitk.sitkBSpline)
+        resampled_sitk_img = resample.Execute(itk_image)
+        return sitk.GetArrayFromImage(resampled_sitk_img)
+
+    def sample_size_calculation(self, number_of_voxel):
+        """
+        This fuction is used to calculate the size of random selected images to be cropped. This is when the random
+        technique is used.
+
+        Parameters
+        ----------
+        number_of_voxel : int
+            The number of voxels for a specific slice.
+        Returns
+        -------
+        sample_size: int
+            The sample size
+
+        """
+        sample_size = int(
+            np.divide(number_of_voxel, self.arg.crop_image_size**2) * float(self.arg.sample_number)
+        )
+        if sample_size < 1:
+            sample_size = 1
+            return sample_size
+        else:
+            return sample_size
+
+    def cropping_technique_selection(self):
+        """
+        This fuction is used to calculate the biggest area of contour.
+
+        Returns
+        -------
+        biggestAreaContour: numpy.ndarray
+
+        """
+        # if there is an area
+        if len(self.biggestAreaContour_array) == 1:
+            # choose the crop method and call the class related to it.
+            if self.arg.crop_method == "random":
+                if self.arg.patient_status == "negative" or self.arg.patient_status == "unknown":
+                    negativeRandomC.negativeRandom(self)
+
+                elif self.arg.patient_status == "positive":
+                    positiveRandomC.positiveRandom(self)
+
+            elif self.arg.crop_method == "stride":
+                if self.arg.patient_status == "negative" or self.arg.patient_status == "unknown":
+                    negativeStrideC.negativeStride(self)
+
+                elif self.arg.patient_status == "positive":
+                    positiveStrideC.positiveStride(self)
+
+            elif self.arg.crop_method == "center":
+                if self.arg.patient_status == "negative" or self.arg.patient_status == "unknown":
+                    negativeCenterC.negativeCenter(self)
+                else:
+                    positiveCenterC.positiveCenter(self)
+
+    def calculate_biggest_area_of_contour(self):
+        """
+        This fuction is used to calculate the biggest area of contour.
+
+        Returns
+        -------
+        biggestAreaContour: numpy.ndarray
+
+        """
+        self.canny_output = cv2.Canny(self.src_gray_blurred_whole_prostate, 100, 100 * 2)
+        self.contours, _ = cv2.findContours(
+            self.canny_output, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
+        )
+        self.contours_poly = [None] * len(self.contours)
+        self.boundRect = [None] * len(self.contours)
+        self.biggestAreaContour = max(self.contours, key=cv2.contourArea)
+        biggestAreaContour_array = np.array([self.biggestAreaContour])
+        return biggestAreaContour_array
+
+    def cropTechniqueControler(self):
+        """
+        This fuction is used to calculate the size of random selected images to be cropped. This is when the random
+        technique is used.
+        """
+        self.biggestAreaContour_array = self.calculate_biggest_area_of_contour()
+        self.drawing = np.zeros(
+            (self.canny_output.shape[0], self.canny_output.shape[1]), dtype=np.uint8
+        )
+
+        self.cropping_technique_selection()
+
+    def crop_and_save(
+        self,
+        orig_img_path_t2w,
+        slice_number_correct,
+        slice_name,
+        name_file,
+        pathToSave_same_as_dataset_structure,
+        prostate_gland_arr_slice,
+        prostate_lesion_arr_slice,
+        patient_id,
+        study_id,
+        caseHealthyBoolean,
+        seg_path=None,
+    ):
+        self.orig_img_path_t2w = orig_img_path_t2w
+        self.slice_number = slice_number_correct
+        self.slice_name = slice_name
+        self.name_file = name_file
+        self.pathToSave_same_as_dataset_structure = pathToSave_same_as_dataset_structure
+        self.prostate_gland_arr_slice = prostate_gland_arr_slice
+        self.prostate_lesion_arr_slice = prostate_lesion_arr_slice
+        self.patient_id = patient_id
+        self.study_id = study_id
+        self.caseHealthyBoolean = caseHealthyBoolean
+        self.seg_path = seg_path
+
+        def threshold_check(self, labels, IncludesWholeProstateBoolean):
+            thresh_number_of_voxels = round(1 / ((self.arg.pixel_spacing / 10) ** 2))
+            number_of_voxel = labels[0].size
+            if IncludesWholeProstateBoolean:
+                minimum_newthresh_number_of_voxel = int(
+                    self.arg.c_min_negative * thresh_number_of_voxels
+                )
+            else:
+                minimum_newthresh_number_of_voxel = int(
+                    self.arg.c_min_positive * thresh_number_of_voxels
+                )
+            if number_of_voxel >= minimum_newthresh_number_of_voxel:
+                return True, number_of_voxel, minimum_newthresh_number_of_voxel
+            else:
+                return False, number_of_voxel, minimum_newthresh_number_of_voxel
+
+        if caseHealthyBoolean:
+            self.labels = np.where(self.prostate_gland_arr_slice)
+            (
+                self.threshold_checkBoolean,
+                self.number_of_voxel,
+                self.minimum_newthresh_number_of_voxel,
+            ) = threshold_check(self, self.labels, caseHealthyBoolean)
+            if self.threshold_checkBoolean:
+                self.prostate_gland_arr_slice = np.array(
+                    self.prostate_gland_arr_slice * 255, dtype=np.uint8
+                )
+                self.src_gray_blurred_whole_prostate = cv2.blur(
+                    self.prostate_gland_arr_slice, (3, 3)
+                )
+                self.canny_output = cv2.Canny(self.src_gray_blurred_whole_prostate, 100, 100 * 2)
+                contours, _hierarchy = cv2.findContours(
+                    self.canny_output, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
+                )
+                if len(contours) > 0:
+                    self.cropTechniqueControler()
+        else:
+            if self.arg.prostate_gland_seg_contains_lesion:
+                self.labels_tumor_area = np.where(
+                    self.prostate_gland_arr_slice >= self.arg.tumor_label_level
+                )
+            else:
+                self.labels_tumor_area = np.where(
+                    self.prostate_lesion_arr_slice >= self.arg.tumor_label_level
+                )
+
+            self.labels_whole_prostate = np.where(self.prostate_gland_arr_slice)
+            (
+                self.threshold_checkBoolean_tumour_area,
+                self.number_of_voxel,
+                self.minimum_newthresh_number_of_voxel,
+            ) = threshold_check(
+                self, self.labels_tumor_area, IncludesWholeProstateBoolean=caseHealthyBoolean
+            )
+
+            if self.threshold_checkBoolean_tumour_area:
+                if self.arg.prostate_gland_seg_contains_lesion:
+                    _, self.image_source_original_tumour = cv2.threshold(
+                        self.prostate_gland_arr_slice,
+                        int(self.arg.tumor_label_level - 1),
+                        10,
+                        cv2.THRESH_BINARY,
+                    )
+                    _, self.image_source_original_whole_prostate = cv2.threshold(
+                        self.prostate_gland_arr_slice, 0, 1, cv2.THRESH_BINARY
+                    )
+                else:
+                    self.image_source_original_tumour = self.prostate_lesion_arr_slice
+                    self.image_source_original_whole_prostate = self.prostate_gland_arr_slice
+
+                self.image_source_original_whole_prostate = np.array(
+                    self.image_source_original_whole_prostate * 255, dtype=np.uint8
+                )
+                self.image_source_original_tumour = np.array(
+                    self.image_source_original_tumour * 255, dtype=np.uint8
+                )
+                self.src_gray_blurred_whole_prostate = cv2.blur(
+                    self.image_source_original_whole_prostate, (3, 3)
+                )
+                self.canny_output = cv2.Canny(self.src_gray_blurred_whole_prostate, 100, 100 * 2)
+                self.contours, _rethierarchy = cv2.findContours(
+                    self.canny_output, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
+                )
+                if len(self.contours) > 0:
+                    self.cropTechniqueControler()
+            else:
+                self.log_crop_event("Crop skipped: lesion threshold not met", self.number_of_voxel)