diff --git a/.codeboarding/Core_Data_Structures.json b/.codeboarding/Core_Data_Structures.json new file mode 100644 index 00000000..c1ca9d54 --- /dev/null +++ b/.codeboarding/Core_Data_Structures.json @@ -0,0 +1,91 @@ +{ + "description": "The `starfish` core image processing pipeline is centered around the `ImageStack` component, which serves as the primary in-memory representation for multi-dimensional image data. Data ingestion into the `ImageStack` is handled by `ImageStack Parsers`, which are responsible for converting various external data formats into the standardized `ImageStack` structure. Once loaded, the `ImageStack` can be manipulated by components like `ImageStack Cropping` for spatial transformations. The `Codebook` component plays a crucial role in interpreting the raw intensity data within the `ImageStack`, mapping observed fluorescent signals to biological targets, thereby providing biological meaning to the image data. This architecture ensures a clear separation of concerns, with dedicated components for data representation, ingestion, transformation, and biological interpretation, facilitating a modular and extensible image processing workflow.", + "components": [ + { + "name": "ImageStack", + "description": "Serves as the fundamental in-memory representation for multi-dimensional image data within the Starfish pipeline. It provides a unified interface for accessing, manipulating, and transforming image data, managing associated metadata and coordinates. This component is central to any image processing library.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/imagestack/imagestack.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/imagestack.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Codebook", + "description": "Defines the crucial mapping between observed fluorescent signals (channels, imaging rounds) and specific biological targets (e.g., genes). It is essential for interpreting raw intensity data into meaningful biological information, supporting loading, validation, and decoding operations. This is a core data structure for biological interpretation.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/codebook/codebook.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/codebook/codebook.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "ImageStack Parsers", + "description": "These components are responsible for reading and parsing various external data formats (e.g., tilesets, raw NumPy arrays) into the internal `ImageStack` representation. They handle the specifics of data layout, metadata extraction, and efficient data loading, acting as the data ingestion layer for `ImageStack`.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/imagestack/parser/tileset/_parser.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/parser/tileset/_parser.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/imagestack/parser/tilefetcher/_parser.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/parser/tilefetcher/_parser.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/imagestack/parser/numpy/__init__.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/parser/numpy/__init__.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "ImageStack Cropping", + "description": "Manages the process of cropping `ImageStack` data. This includes determining the appropriate crop regions, applying the cropping operation to the image data, and adjusting associated metadata and coordinates. It represents a fundamental data transformation utility directly operating on the core `ImageStack` data.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/imagestack/parser/crop.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/parser/crop.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + } + ], + "components_relations": [ + { + "relation": "utilizes", + "src_name": "ImageStack", + "dst_name": "ImageStack Cropping" + }, + { + "relation": "interprets data from", + "src_name": "Codebook", + "dst_name": "ImageStack" + }, + { + "relation": "produces data for", + "src_name": "ImageStack Parsers", + "dst_name": "ImageStack" + }, + { + "relation": "produces data for", + "src_name": "ImageStack Cropping", + "dst_name": "ImageStack" + } + ] +} \ No newline at end of file diff --git a/.codeboarding/Core_Data_Structures.md b/.codeboarding/Core_Data_Structures.md new file mode 100644 index 00000000..7150a6f8 --- /dev/null +++ b/.codeboarding/Core_Data_Structures.md @@ -0,0 +1,59 @@ +```mermaid +graph LR + ImageStack["ImageStack"] + Codebook["Codebook"] + ImageStack_Parsers["ImageStack Parsers"] + ImageStack_Cropping["ImageStack Cropping"] + ImageStack -- "utilizes" --> ImageStack_Cropping + Codebook -- "interprets data from" --> ImageStack + ImageStack_Parsers -- "produces data for" --> ImageStack + ImageStack_Cropping -- "produces data for" --> ImageStack +``` + +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Details + +The `starfish` core image processing pipeline is centered around the `ImageStack` component, which serves as the primary in-memory representation for multi-dimensional image data. Data ingestion into the `ImageStack` is handled by `ImageStack Parsers`, which are responsible for converting various external data formats into the standardized `ImageStack` structure. Once loaded, the `ImageStack` can be manipulated by components like `ImageStack Cropping` for spatial transformations. The `Codebook` component plays a crucial role in interpreting the raw intensity data within the `ImageStack`, mapping observed fluorescent signals to biological targets, thereby providing biological meaning to the image data. This architecture ensures a clear separation of concerns, with dedicated components for data representation, ingestion, transformation, and biological interpretation, facilitating a modular and extensible image processing workflow. + +### ImageStack +Serves as the fundamental in-memory representation for multi-dimensional image data within the Starfish pipeline. It provides a unified interface for accessing, manipulating, and transforming image data, managing associated metadata and coordinates. This component is central to any image processing library. + + +**Related Classes/Methods**: + +- `starfish/core/imagestack/imagestack.py` + + +### Codebook +Defines the crucial mapping between observed fluorescent signals (channels, imaging rounds) and specific biological targets (e.g., genes). It is essential for interpreting raw intensity data into meaningful biological information, supporting loading, validation, and decoding operations. This is a core data structure for biological interpretation. + + +**Related Classes/Methods**: + +- `starfish/core/codebook/codebook.py` + + +### ImageStack Parsers +These components are responsible for reading and parsing various external data formats (e.g., tilesets, raw NumPy arrays) into the internal `ImageStack` representation. They handle the specifics of data layout, metadata extraction, and efficient data loading, acting as the data ingestion layer for `ImageStack`. + + +**Related Classes/Methods**: + +- `starfish/core/imagestack/parser/tileset/_parser.py` +- `starfish/core/imagestack/parser/tilefetcher/_parser.py` +- `starfish/core/imagestack/parser/numpy/__init__.py` + + +### ImageStack Cropping +Manages the process of cropping `ImageStack` data. This includes determining the appropriate crop regions, applying the cropping operation to the image data, and adjusting associated metadata and coordinates. It represents a fundamental data transformation utility directly operating on the core `ImageStack` data. + + +**Related Classes/Methods**: + +- `starfish/core/imagestack/parser/crop.py` + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Data_Input_Validation_Layer.json b/.codeboarding/Data_Input_Validation_Layer.json new file mode 100644 index 00000000..9e91532d --- /dev/null +++ b/.codeboarding/Data_Input_Validation_Layer.json @@ -0,0 +1,79 @@ +{ + "description": "This subsystem is the initial entry point for all data processing pipelines within starfish, responsible for loading raw experimental data and metadata and ensuring its conformity to the SpaceTx format. It embodies the \"Extract\" and initial \"Validate\" stages of an ETL pipeline, crucial for maintaining data integrity throughout the scientific analysis workflow.", + "components": [ + { + "name": "Experiment Data Model", + "description": "Represents the in-memory, structured form of the experimental data and metadata after loading. It serves as the canonical data structure that all subsequent processing components operate on.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.experiment.experiment:Experiment", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/experiment/experiment.py", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + }, + { + "name": "Experiment Builder", + "description": "Responsible for parsing raw experimental data (e.g., image files, JSON metadata) from various sources and constructing the Experiment Data Model (Experiment object) in memory. It acts as the primary \"Data Loader/Reader.\"", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.experiment.builder.builder", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/experiment/builder/builder.py", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + }, + { + "name": "SpaceTx Validator", + "description": "Provides the main entry point for validating an Experiment Data Model or its constituent parts against the SpaceTx schema. It ensures data integrity and adherence to the defined format, acting as a \"Validation Tool\" and a gatekeeper for data quality.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.spacetx_format.validate_sptx", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spacetx_format/validate_sptx.py", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + }, + { + "name": "Schema Utilities", + "description": "Encapsulates the core logic for SpaceTx schema validation, including loading the SpaceTx JSON schemas, performing structural and data type validation, and enforcing constraints. It supports the SpaceTx Validator.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.spacetx_format.util", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spacetx_format/util.py", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + } + ], + "components_relations": [ + { + "relation": "provides data to", + "src_name": "Experiment Builder", + "dst_name": "SpaceTx Validator" + }, + { + "relation": "creates/populates", + "src_name": "Experiment Builder", + "dst_name": "Experiment Data Model" + }, + { + "relation": "validates", + "src_name": "SpaceTx Validator", + "dst_name": "Experiment Data Model" + }, + { + "relation": "delegates validation to", + "src_name": "SpaceTx Validator", + "dst_name": "Schema Utilities" + } + ] +} \ No newline at end of file diff --git a/.codeboarding/Data_Input_Validation_Layer.md b/.codeboarding/Data_Input_Validation_Layer.md new file mode 100644 index 00000000..e7ec508e --- /dev/null +++ b/.codeboarding/Data_Input_Validation_Layer.md @@ -0,0 +1,57 @@ +```mermaid +graph LR + Experiment_Data_Model["Experiment Data Model"] + Experiment_Builder["Experiment Builder"] + SpaceTx_Validator["SpaceTx Validator"] + Schema_Utilities["Schema Utilities"] + Experiment_Builder -- "provides data to" --> SpaceTx_Validator + Experiment_Builder -- "creates/populates" --> Experiment_Data_Model + SpaceTx_Validator -- "validates" --> Experiment_Data_Model + SpaceTx_Validator -- "delegates validation to" --> Schema_Utilities +``` + +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Details + +This subsystem is the initial entry point for all data processing pipelines within starfish, responsible for loading raw experimental data and metadata and ensuring its conformity to the SpaceTx format. It embodies the "Extract" and initial "Validate" stages of an ETL pipeline, crucial for maintaining data integrity throughout the scientific analysis workflow. + +### Experiment Data Model +Represents the in-memory, structured form of the experimental data and metadata after loading. It serves as the canonical data structure that all subsequent processing components operate on. + + +**Related Classes/Methods**: + +- `starfish.core.experiment.experiment:Experiment` + + +### Experiment Builder +Responsible for parsing raw experimental data (e.g., image files, JSON metadata) from various sources and constructing the Experiment Data Model (Experiment object) in memory. It acts as the primary "Data Loader/Reader." + + +**Related Classes/Methods**: + +- `starfish.core.experiment.builder.builder` + + +### SpaceTx Validator +Provides the main entry point for validating an Experiment Data Model or its constituent parts against the SpaceTx schema. It ensures data integrity and adherence to the defined format, acting as a "Validation Tool" and a gatekeeper for data quality. + + +**Related Classes/Methods**: + +- `starfish.core.spacetx_format.validate_sptx` + + +### Schema Utilities +Encapsulates the core logic for SpaceTx schema validation, including loading the SpaceTx JSON schemas, performing structural and data type validation, and enforcing constraints. It supports the SpaceTx Validator. + + +**Related Classes/Methods**: + +- `starfish.core.spacetx_format.util` + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Image_Processing_Engine.json b/.codeboarding/Image_Processing_Engine.json new file mode 100644 index 00000000..e1bbfa16 --- /dev/null +++ b/.codeboarding/Image_Processing_Engine.json @@ -0,0 +1,156 @@ +{ + "description": "The `Image Processing Engine` subsystem is primarily defined by the `starfish.core.image` and `starfish.core.morphology` packages, specifically focusing on `Filter`, `_registration`, `Segment`, `Binarize`, and `label_image` modules. It operates as a pipeline, where raw or pre-processed images are fed into various transformation and analysis steps. This modular and pipeline-driven structure aligns with the project's \"Data Pipeline / ETL\" and \"Modular Design\" architectural patterns, allowing for flexible construction of image analysis workflows.", + "components": [ + { + "name": "Image Filtering", + "description": "Responsible for applying various image enhancement and noise reduction algorithms to raw or pre-processed image data.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.image.Filter", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/image/Filter/__init__.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Image Registration", + "description": "Manages the application of geometric transformations to align and register images, correcting for spatial distortions between different acquisitions or time points.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.image._registration.ApplyTransform", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/image/_registration/ApplyTransform", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Transformation Parameters", + "description": "Provides a standardized mechanism for defining, serializing, and deserializing parameters required for various image transformations.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.image._registration.transforms_list", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/image/_registration/transforms_list.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": false + }, + { + "name": "Image Segmentation", + "description": "Implements the watershed algorithm to segment images into distinct regions, typically used for separating touching objects or identifying individual structures.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.image.Segment.watershed", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/image/Segment/watershed.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Image Binarization", + "description": "Performs image binarization by applying a threshold, converting grayscale images into binary (black and white) masks based on pixel intensity.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.morphology.Binarize.threshold", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/Binarize/threshold.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": false + }, + { + "name": "Labeled Image Representation", + "description": "Encapsulates and manages image data where pixels are assigned integer labels corresponding to distinct regions or objects identified through segmentation.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.morphology.label_image.label_image", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/label_image/label_image.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": false + }, + { + "name": "Binary Mask Collection", + "description": "Manages collections of binary masks, providing an organized structure for handling multiple mask datasets, often derived from binarization or segmentation.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.morphology.binary_mask.binary_mask", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/binary_mask/binary_mask.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Mask Persistence", + "description": "Handles the reading and writing of binary mask data to and from persistent storage, ensuring data integrity and reusability.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.morphology.binary_mask._io", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/binary_mask/_io.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": false + } + ], + "components_relations": [ + { + "relation": "provides processed images to", + "src_name": "Image Filtering", + "dst_name": "Image Segmentation" + }, + { + "relation": "provides processed images to", + "src_name": "Image Filtering", + "dst_name": "Image Binarization" + }, + { + "relation": "utilizes", + "src_name": "Image Registration", + "dst_name": "Transformation Parameters" + }, + { + "relation": "provides transformation parameters to", + "src_name": "Transformation Parameters", + "dst_name": "Image Registration" + }, + { + "relation": "outputs segmented regions, which are represented by", + "src_name": "Image Segmentation", + "dst_name": "Labeled Image Representation" + }, + { + "relation": "generates binary output, which is managed by", + "src_name": "Image Binarization", + "dst_name": "Binary Mask Collection" + }, + { + "relation": "contributes to the creation or population of", + "src_name": "Labeled Image Representation", + "dst_name": "Binary Mask Collection" + }, + { + "relation": "uses", + "src_name": "Binary Mask Collection", + "dst_name": "Mask Persistence" + }, + { + "relation": "provides persistence services for", + "src_name": "Mask Persistence", + "dst_name": "Binary Mask Collection" + } + ] +} \ No newline at end of file diff --git a/.codeboarding/Image_Processing_Engine.md b/.codeboarding/Image_Processing_Engine.md new file mode 100644 index 00000000..f635937c --- /dev/null +++ b/.codeboarding/Image_Processing_Engine.md @@ -0,0 +1,102 @@ +```mermaid +graph LR + Image_Filtering["Image Filtering"] + Image_Registration["Image Registration"] + Transformation_Parameters["Transformation Parameters"] + Image_Segmentation["Image Segmentation"] + Image_Binarization["Image Binarization"] + Labeled_Image_Representation["Labeled Image Representation"] + Binary_Mask_Collection["Binary Mask Collection"] + Mask_Persistence["Mask Persistence"] + Image_Filtering -- "provides processed images to" --> Image_Segmentation + Image_Filtering -- "provides processed images to" --> Image_Binarization + Image_Registration -- "utilizes" --> Transformation_Parameters + Transformation_Parameters -- "provides transformation parameters to" --> Image_Registration + Image_Segmentation -- "outputs segmented regions, which are represented by" --> Labeled_Image_Representation + Image_Binarization -- "generates binary output, which is managed by" --> Binary_Mask_Collection + Labeled_Image_Representation -- "contributes to the creation or population of" --> Binary_Mask_Collection + Binary_Mask_Collection -- "uses" --> Mask_Persistence + Mask_Persistence -- "provides persistence services for" --> Binary_Mask_Collection +``` + +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Details + +The `Image Processing Engine` subsystem is primarily defined by the `starfish.core.image` and `starfish.core.morphology` packages, specifically focusing on `Filter`, `_registration`, `Segment`, `Binarize`, and `label_image` modules. It operates as a pipeline, where raw or pre-processed images are fed into various transformation and analysis steps. This modular and pipeline-driven structure aligns with the project's "Data Pipeline / ETL" and "Modular Design" architectural patterns, allowing for flexible construction of image analysis workflows. + +### Image Filtering +Responsible for applying various image enhancement and noise reduction algorithms to raw or pre-processed image data. + + +**Related Classes/Methods**: + +- `starfish.core.image.Filter` + + +### Image Registration +Manages the application of geometric transformations to align and register images, correcting for spatial distortions between different acquisitions or time points. + + +**Related Classes/Methods**: + +- `starfish.core.image._registration.ApplyTransform` + + +### Transformation Parameters +Provides a standardized mechanism for defining, serializing, and deserializing parameters required for various image transformations. + + +**Related Classes/Methods**: + +- `starfish.core.image._registration.transforms_list` + + +### Image Segmentation +Implements the watershed algorithm to segment images into distinct regions, typically used for separating touching objects or identifying individual structures. + + +**Related Classes/Methods**: + +- `starfish.core.image.Segment.watershed` + + +### Image Binarization +Performs image binarization by applying a threshold, converting grayscale images into binary (black and white) masks based on pixel intensity. + + +**Related Classes/Methods**: + +- `starfish.core.morphology.Binarize.threshold` + + +### Labeled Image Representation +Encapsulates and manages image data where pixels are assigned integer labels corresponding to distinct regions or objects identified through segmentation. + + +**Related Classes/Methods**: + +- `starfish.core.morphology.label_image.label_image` + + +### Binary Mask Collection +Manages collections of binary masks, providing an organized structure for handling multiple mask datasets, often derived from binarization or segmentation. + + +**Related Classes/Methods**: + +- `starfish.core.morphology.binary_mask.binary_mask` + + +### Mask Persistence +Handles the reading and writing of binary mask data to and from persistent storage, ensuring data integrity and reusability. + + +**Related Classes/Methods**: + +- `starfish.core.morphology.binary_mask._io` + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Output_Export_Layer.json b/.codeboarding/Output_Export_Layer.json new file mode 100644 index 00000000..7ea3bad1 --- /dev/null +++ b/.codeboarding/Output_Export_Layer.json @@ -0,0 +1,88 @@ +{ + "description": "The `starfish` core data persistence layer is responsible for serializing and exporting processed biological data, ensuring data integrity and accessibility for downstream analysis. Key components include `ImageStack` for managing and exporting multi-dimensional image data into formats like multi-page TIFF, `DecodedSpots` for persisting decoded biological spot information into tabular formats such as CSV, and `BinaryMaskIO` which handles the specialized, versioned storage of binary mask data. These components primarily interact by taking processed in-memory data structures and writing them to disk in standardized formats, facilitating data sharing and reproducibility in scientific workflows.", + "components": [ + { + "name": "ImageStack", + "description": "This component represents and manages multi-dimensional image data. Its primary responsibility within this layer is to provide methods for serializing and exporting processed image stacks into standard persistent formats, specifically multi-page TIFF files, which are crucial for scientific image data.", + "referenced_source_code": [ + { + "qualified_name": "ImageStack:to_multipage_tiff", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/imagestack.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "ImageStack:export", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/imagestack.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": false + }, + { + "name": "DecodedSpots", + "description": "This component encapsulates the results of the decoding process, holding information about identified biological spots (e.g., coordinates, intensities, gene assignments). Its core responsibility in this layer is to facilitate the persistence of this structured data, typically by saving it into tabular formats like CSV, enabling easy access and analysis.", + "referenced_source_code": [ + { + "qualified_name": "DecodedSpots:save_csv", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/types/_decoded_spots.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": false + }, + { + "name": "BinaryMaskIO", + "description": "This component is responsible for the specialized handling and persistence of binary mask data. It provides both low-level writing capabilities and a higher-level interface that ensures proper versioning of mask files, aligning with data integrity and reproducibility requirements in scientific workflows. This component abstracts the direct file writing operations for masks by delegating to specific versioned implementations.", + "referenced_source_code": [ + { + "qualified_name": "write_binary_mask", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/binary_mask/_io.py", + "reference_start_line": 136, + "reference_end_line": 162 + }, + { + "qualified_name": "write_versioned_binary_mask", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/binary_mask/_io.py", + "reference_start_line": 58, + "reference_end_line": 74 + } + ], + "can_expand": true + } + ], + "components_relations": [ + { + "relation": "exports", + "src_name": "ImageStack", + "dst_name": "Multi-page TIFF files" + }, + { + "relation": "serializes", + "src_name": "ImageStack", + "dst_name": "Image data" + }, + { + "relation": "saves to", + "src_name": "DecodedSpots", + "dst_name": "CSV files" + }, + { + "relation": "persists", + "src_name": "DecodedSpots", + "dst_name": "Decoded spot data" + }, + { + "relation": "delegates writing to", + "src_name": "BinaryMaskIO", + "dst_name": "Versioned Binary Mask Writers" + }, + { + "relation": "manages versioning for", + "src_name": "BinaryMaskIO", + "dst_name": "Binary Mask Data" + } + ] +} \ No newline at end of file diff --git a/.codeboarding/Output_Export_Layer.md b/.codeboarding/Output_Export_Layer.md new file mode 100644 index 00000000..ee16b526 --- /dev/null +++ b/.codeboarding/Output_Export_Layer.md @@ -0,0 +1,51 @@ +```mermaid +graph LR + ImageStack["ImageStack"] + DecodedSpots["DecodedSpots"] + BinaryMaskIO["BinaryMaskIO"] + ImageStack -- "exports" --> Multi_page_TIFF_files + ImageStack -- "serializes" --> Image_data + DecodedSpots -- "saves to" --> CSV_files + DecodedSpots -- "persists" --> Decoded_spot_data + BinaryMaskIO -- "delegates writing to" --> Versioned_Binary_Mask_Writers + BinaryMaskIO -- "manages versioning for" --> Binary_Mask_Data +``` + +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Details + +The `starfish` core data persistence layer is responsible for serializing and exporting processed biological data, ensuring data integrity and accessibility for downstream analysis. Key components include `ImageStack` for managing and exporting multi-dimensional image data into formats like multi-page TIFF, `DecodedSpots` for persisting decoded biological spot information into tabular formats such as CSV, and `BinaryMaskIO` which handles the specialized, versioned storage of binary mask data. These components primarily interact by taking processed in-memory data structures and writing them to disk in standardized formats, facilitating data sharing and reproducibility in scientific workflows. + +### ImageStack +This component represents and manages multi-dimensional image data. Its primary responsibility within this layer is to provide methods for serializing and exporting processed image stacks into standard persistent formats, specifically multi-page TIFF files, which are crucial for scientific image data. + + +**Related Classes/Methods**: + +- `ImageStack:to_multipage_tiff` +- `ImageStack:export` + + +### DecodedSpots +This component encapsulates the results of the decoding process, holding information about identified biological spots (e.g., coordinates, intensities, gene assignments). Its core responsibility in this layer is to facilitate the persistence of this structured data, typically by saving it into tabular formats like CSV, enabling easy access and analysis. + + +**Related Classes/Methods**: + +- `DecodedSpots:save_csv` + + +### BinaryMaskIO +This component is responsible for the specialized handling and persistence of binary mask data. It provides both low-level writing capabilities and a higher-level interface that ensures proper versioning of mask files, aligning with data integrity and reproducibility requirements in scientific workflows. This component abstracts the direct file writing operations for masks by delegating to specific versioned implementations. + + +**Related Classes/Methods**: + +- `write_binary_mask`:136-162 +- `write_versioned_binary_mask`:58-74 + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Spot_Analysis_Engine.json b/.codeboarding/Spot_Analysis_Engine.json new file mode 100644 index 00000000..2a7c1773 --- /dev/null +++ b/.codeboarding/Spot_Analysis_Engine.json @@ -0,0 +1,120 @@ +{ + "description": "The `Spot Analysis Engine` subsystem is dedicated to identifying, quantifying, and decoding biological spots within processed image data. It encompasses the entire pipeline from initial spot detection and intensity measurement to genetic decoding and target assignment.", + "components": [ + { + "name": "Spot Detection Initializer", + "description": "Initiates the spot analysis by detecting preliminary spot candidates from raw image data. This component represents the \"Extract\" phase for initial spot identification, preparing the raw image for further processing.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.spots.FindSpots", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/FindSpots/", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + }, + { + "name": "Pixel-Level Spot Refiner", + "description": "Refines spot detection at a pixel level, grouping adjacent features and contributing to the detailed attributes of spots. It's part of the \"Transform\" phase, enhancing raw detection data for greater accuracy.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.spots.DetectPixels", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/DetectPixels/", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": false + }, + { + "name": "Intensity Data Manager", + "description": "This is the central data structure of the subsystem. It manages and stores all quantitative intensity data for detected spots across various imaging rounds and channels. It serves as the primary data hub, embodying the \"Data-Centric Architecture\" principle.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.intensity_table.intensity_table", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/intensity_table/intensity_table.py", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + }, + { + "name": "Intensity Overlap Resolver", + "description": "A supporting component for the `Intensity Data Manager`, responsible for resolving spatial overlaps between intensity regions, ensuring accurate quantification and preventing data redundancy or misinterpretation.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.intensity_table.overlap", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/intensity_table/overlap.py", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + }, + { + "name": "Spot Decoder", + "description": "This component is responsible for the genetic decoding process, assigning genetic identities to spots based on their intensity profiles. This is a crucial \"Transform\" stage, converting raw intensity data into meaningful biological information.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.spots.DecodeSpots", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/DecodeSpots/", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": true + }, + { + "name": "Target Assignment Processor", + "description": "This component assigns detected and decoded spots to specific biological targets (e.g., cells, nuclei), providing biological context and completing the analysis by associating spots with higher-level entities. This can be seen as the \"Load\" or contextualization phase.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core.spots.AssignTargets.label", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/AssignTargets/label.py", + "reference_start_line": 1, + "reference_end_line": 1 + } + ], + "can_expand": false + } + ], + "components_relations": [ + { + "relation": "produces data for", + "src_name": "Spot Detection Initializer", + "dst_name": "Intensity Data Manager" + }, + { + "relation": "refines data in", + "src_name": "Pixel-Level Spot Refiner", + "dst_name": "Intensity Data Manager" + }, + { + "relation": "provides data to", + "src_name": "Intensity Data Manager", + "dst_name": "Spot Decoder" + }, + { + "relation": "provides data to", + "src_name": "Intensity Data Manager", + "dst_name": "Target Assignment Processor" + }, + { + "relation": "relies on", + "src_name": "Intensity Data Manager", + "dst_name": "Intensity Overlap Resolver" + }, + { + "relation": "supports", + "src_name": "Intensity Overlap Resolver", + "dst_name": "Intensity Data Manager" + }, + { + "relation": "updates data in", + "src_name": "Spot Decoder", + "dst_name": "Intensity Data Manager" + } + ] +} \ No newline at end of file diff --git a/.codeboarding/Spot_Analysis_Engine.md b/.codeboarding/Spot_Analysis_Engine.md new file mode 100644 index 00000000..b9be22ae --- /dev/null +++ b/.codeboarding/Spot_Analysis_Engine.md @@ -0,0 +1,80 @@ +```mermaid +graph LR + Spot_Detection_Initializer["Spot Detection Initializer"] + Pixel_Level_Spot_Refiner["Pixel-Level Spot Refiner"] + Intensity_Data_Manager["Intensity Data Manager"] + Intensity_Overlap_Resolver["Intensity Overlap Resolver"] + Spot_Decoder["Spot Decoder"] + Target_Assignment_Processor["Target Assignment Processor"] + Spot_Detection_Initializer -- "produces data for" --> Intensity_Data_Manager + Pixel_Level_Spot_Refiner -- "refines data in" --> Intensity_Data_Manager + Intensity_Data_Manager -- "provides data to" --> Spot_Decoder + Intensity_Data_Manager -- "provides data to" --> Target_Assignment_Processor + Intensity_Data_Manager -- "relies on" --> Intensity_Overlap_Resolver + Intensity_Overlap_Resolver -- "supports" --> Intensity_Data_Manager + Spot_Decoder -- "updates data in" --> Intensity_Data_Manager +``` + +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Details + +The `Spot Analysis Engine` subsystem is dedicated to identifying, quantifying, and decoding biological spots within processed image data. It encompasses the entire pipeline from initial spot detection and intensity measurement to genetic decoding and target assignment. + +### Spot Detection Initializer +Initiates the spot analysis by detecting preliminary spot candidates from raw image data. This component represents the "Extract" phase for initial spot identification, preparing the raw image for further processing. + + +**Related Classes/Methods**: + +- `starfish.core.spots.FindSpots` + + +### Pixel-Level Spot Refiner +Refines spot detection at a pixel level, grouping adjacent features and contributing to the detailed attributes of spots. It's part of the "Transform" phase, enhancing raw detection data for greater accuracy. + + +**Related Classes/Methods**: + +- `starfish.core.spots.DetectPixels` + + +### Intensity Data Manager +This is the central data structure of the subsystem. It manages and stores all quantitative intensity data for detected spots across various imaging rounds and channels. It serves as the primary data hub, embodying the "Data-Centric Architecture" principle. + + +**Related Classes/Methods**: + +- `starfish.core.intensity_table.intensity_table` + + +### Intensity Overlap Resolver +A supporting component for the `Intensity Data Manager`, responsible for resolving spatial overlaps between intensity regions, ensuring accurate quantification and preventing data redundancy or misinterpretation. + + +**Related Classes/Methods**: + +- `starfish.core.intensity_table.overlap` + + +### Spot Decoder +This component is responsible for the genetic decoding process, assigning genetic identities to spots based on their intensity profiles. This is a crucial "Transform" stage, converting raw intensity data into meaningful biological information. + + +**Related Classes/Methods**: + +- `starfish.core.spots.DecodeSpots` + + +### Target Assignment Processor +This component assigns detected and decoded spots to specific biological targets (e.g., cells, nuclei), providing biological context and completing the analysis by associating spots with higher-level entities. This can be seen as the "Load" or contextualization phase. + + +**Related Classes/Methods**: + +- `starfish.core.spots.AssignTargets.label` + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Visualization_Utilities.json b/.codeboarding/Visualization_Utilities.json new file mode 100644 index 00000000..73aab24a --- /dev/null +++ b/.codeboarding/Visualization_Utilities.json @@ -0,0 +1,165 @@ +{ + "description": "This subsystem provides a comprehensive set of tools for generating visual representations of intermediate and final analysis results, crucial for quality control, debugging, and interpretation within the `starfish` project. It adheres to the `Data Processing Library / Scientific Toolkit` patterns by offering modular and specialized visualization capabilities.", + "components": [ + { + "name": "starfish.core._display.display", + "description": "The primary orchestrator for high-level data visualization. It acts as a facade, coordinating various data preparation steps before rendering complex visual outputs. This component is fundamental as it provides the main entry point for users to visualize processed data.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core._display._mask_low_intensity_spots", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 70, + "reference_end_line": 83 + }, + { + "qualified_name": "starfish.core._display._spots_to_markers", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 86, + "reference_end_line": 118 + }, + { + "qualified_name": "starfish.core._display._max_intensity_table_maintain_dims", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 39, + "reference_end_line": 67 + } + ], + "can_expand": true + }, + { + "name": "starfish.util.plot.imshow_plane", + "description": "A foundational utility for displaying single image planes. It serves as a low-level building block for more complex plotting functions, providing the basic image rendering capability.", + "referenced_source_code": [ + { + "qualified_name": "starfish.util.plot.overlay_spot_calls", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/util/plot.py", + "reference_start_line": 102, + "reference_end_line": 165 + }, + { + "qualified_name": "starfish.util.plot.diagnose_registration", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/util/plot.py", + "reference_start_line": 175, + "reference_end_line": 223 + } + ], + "can_expand": false + }, + { + "name": "starfish.util.plot.overlay_spot_calls", + "description": "A specialized function for visualizing detected spots by overlaying them onto an image. This component is crucial for interpreting spot detection results.", + "referenced_source_code": [ + { + "qualified_name": "starfish.util.plot.imshow_plane", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/util/plot.py", + "reference_start_line": 15, + "reference_end_line": 61 + } + ], + "can_expand": false + }, + { + "name": "starfish.util.plot.diagnose_registration", + "description": "Provides visual diagnostics to assess the quality of image registration. This component is vital for quality control in image processing pipelines.", + "referenced_source_code": [ + { + "qualified_name": "starfish.util.plot.imshow_plane", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/util/plot.py", + "reference_start_line": 15, + "reference_end_line": 61 + } + ], + "can_expand": false + }, + { + "name": "starfish.core._display._mask_low_intensity_spots", + "description": "A utility function for pre-processing spot data by filtering out entries below a certain intensity threshold, ensuring cleaner visualizations.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core._display.display", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 121, + "reference_end_line": 296 + } + ], + "can_expand": false + }, + { + "name": "starfish.core._display._spots_to_markers", + "description": "Responsible for transforming raw spot data into a format suitable for graphical markers, often used in scatter plots or overlays. This is a key data preparation step for visualization.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core._display.display", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 121, + "reference_end_line": 296 + } + ], + "can_expand": false + }, + { + "name": "starfish.core._display._max_intensity_table_maintain_dims", + "description": "Handles the preparation of intensity data tables for display, ensuring that dimensional consistency is maintained across different data views. This is critical for accurate and consistent data representation.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core._display.display", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 121, + "reference_end_line": 296 + }, + { + "qualified_name": "starfish.core._display._normalize_axes", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 25, + "reference_end_line": 36 + } + ], + "can_expand": false + }, + { + "name": "starfish.core._display._normalize_axes", + "description": "A utility function that normalizes image axes to ensure consistent display scaling, regardless of the original data dimensions. This ensures visual comparability across different datasets.", + "referenced_source_code": [ + { + "qualified_name": "starfish.core._display._max_intensity_table_maintain_dims", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 39, + "reference_end_line": 67 + } + ], + "can_expand": false + } + ], + "components_relations": [ + { + "relation": "calls", + "src_name": "starfish.core._display.display", + "dst_name": "starfish.core._display._mask_low_intensity_spots" + }, + { + "relation": "calls", + "src_name": "starfish.core._display.display", + "dst_name": "starfish.core._display._spots_to_markers" + }, + { + "relation": "calls", + "src_name": "starfish.core._display.display", + "dst_name": "starfish.core._display._max_intensity_table_maintain_dims" + }, + { + "relation": "calls", + "src_name": "starfish.util.plot.overlay_spot_calls", + "dst_name": "starfish.util.plot.imshow_plane" + }, + { + "relation": "calls", + "src_name": "starfish.util.plot.diagnose_registration", + "dst_name": "starfish.util.plot.imshow_plane" + }, + { + "relation": "calls", + "src_name": "starfish.core._display._max_intensity_table_maintain_dims", + "dst_name": "starfish.core._display._normalize_axes" + } + ] +} \ No newline at end of file diff --git a/.codeboarding/Visualization_Utilities.md b/.codeboarding/Visualization_Utilities.md new file mode 100644 index 00000000..bb034d83 --- /dev/null +++ b/.codeboarding/Visualization_Utilities.md @@ -0,0 +1,103 @@ +```mermaid +graph LR + starfish_core__display_display["starfish.core._display.display"] + starfish_util_plot_imshow_plane["starfish.util.plot.imshow_plane"] + starfish_util_plot_overlay_spot_calls["starfish.util.plot.overlay_spot_calls"] + starfish_util_plot_diagnose_registration["starfish.util.plot.diagnose_registration"] + starfish_core__display__mask_low_intensity_spots["starfish.core._display._mask_low_intensity_spots"] + starfish_core__display__spots_to_markers["starfish.core._display._spots_to_markers"] + starfish_core__display__max_intensity_table_maintain_dims["starfish.core._display._max_intensity_table_maintain_dims"] + starfish_core__display__normalize_axes["starfish.core._display._normalize_axes"] + starfish_core__display_display -- "calls" --> starfish_core__display__mask_low_intensity_spots + starfish_core__display_display -- "calls" --> starfish_core__display__spots_to_markers + starfish_core__display_display -- "calls" --> starfish_core__display__max_intensity_table_maintain_dims + starfish_util_plot_overlay_spot_calls -- "calls" --> starfish_util_plot_imshow_plane + starfish_util_plot_diagnose_registration -- "calls" --> starfish_util_plot_imshow_plane + starfish_core__display__max_intensity_table_maintain_dims -- "calls" --> starfish_core__display__normalize_axes +``` + +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Details + +This subsystem provides a comprehensive set of tools for generating visual representations of intermediate and final analysis results, crucial for quality control, debugging, and interpretation within the `starfish` project. It adheres to the `Data Processing Library / Scientific Toolkit` patterns by offering modular and specialized visualization capabilities. + +### starfish.core._display.display +The primary orchestrator for high-level data visualization. It acts as a facade, coordinating various data preparation steps before rendering complex visual outputs. This component is fundamental as it provides the main entry point for users to visualize processed data. + + +**Related Classes/Methods**: + +- `starfish.core._display._mask_low_intensity_spots`:70-83 +- `starfish.core._display._spots_to_markers`:86-118 +- `starfish.core._display._max_intensity_table_maintain_dims`:39-67 + + +### starfish.util.plot.imshow_plane +A foundational utility for displaying single image planes. It serves as a low-level building block for more complex plotting functions, providing the basic image rendering capability. + + +**Related Classes/Methods**: + +- `starfish.util.plot.overlay_spot_calls`:102-165 +- `starfish.util.plot.diagnose_registration`:175-223 + + +### starfish.util.plot.overlay_spot_calls +A specialized function for visualizing detected spots by overlaying them onto an image. This component is crucial for interpreting spot detection results. + + +**Related Classes/Methods**: + +- `starfish.util.plot.imshow_plane`:15-61 + + +### starfish.util.plot.diagnose_registration +Provides visual diagnostics to assess the quality of image registration. This component is vital for quality control in image processing pipelines. + + +**Related Classes/Methods**: + +- `starfish.util.plot.imshow_plane`:15-61 + + +### starfish.core._display._mask_low_intensity_spots +A utility function for pre-processing spot data by filtering out entries below a certain intensity threshold, ensuring cleaner visualizations. + + +**Related Classes/Methods**: + +- `starfish.core._display.display`:121-296 + + +### starfish.core._display._spots_to_markers +Responsible for transforming raw spot data into a format suitable for graphical markers, often used in scatter plots or overlays. This is a key data preparation step for visualization. + + +**Related Classes/Methods**: + +- `starfish.core._display.display`:121-296 + + +### starfish.core._display._max_intensity_table_maintain_dims +Handles the preparation of intensity data tables for display, ensuring that dimensional consistency is maintained across different data views. This is critical for accurate and consistent data representation. + + +**Related Classes/Methods**: + +- `starfish.core._display.display`:121-296 +- `starfish.core._display._normalize_axes`:25-36 + + +### starfish.core._display._normalize_axes +A utility function that normalizes image axes to ensure consistent display scaling, regardless of the original data dimensions. This ensures visual comparability across different datasets. + + +**Related Classes/Methods**: + +- `starfish.core._display._max_intensity_table_maintain_dims`:39-67 + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/analysis.json b/.codeboarding/analysis.json new file mode 100644 index 00000000..77983ca1 --- /dev/null +++ b/.codeboarding/analysis.json @@ -0,0 +1,220 @@ +{ + "description": "The Starfish project is structured around a robust data processing pipeline for spatial transcriptomics. It begins with a `Data Input & Validation Layer` responsible for ingesting and validating raw experimental data against the SpaceTx format. This validated data is then transformed into `Core Data Structures`, primarily multi-dimensional image stacks and codebooks, which serve as the central in-memory representation. The `Image Processing Engine` operates on these image stacks, applying various algorithms for enhancement and transformation. Concurrently, the `Spot Analysis Engine` identifies, quantifies, and decodes biological spots using both the processed images and the codebook. Finally, the `Output & Export Layer` handles the serialization and persistence of all processed data, while `Visualization Utilities` provide crucial tools for inspecting intermediate and final results. This modular design ensures clear separation of concerns and facilitates a streamlined data flow from raw input to interpretable biological insights.", + "components": [ + { + "name": "Data Input & Validation Layer", + "description": "Responsible for loading raw experimental data and metadata, ensuring it conforms to the SpaceTx format. It acts as the initial entry point for all data processing pipelines.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/experiment/experiment.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/experiment/experiment.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/experiment/builder/builder.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/experiment/builder/builder.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/spacetx_format/validate_sptx.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spacetx_format/validate_sptx.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Core Data Structures", + "description": "Defines and manages the fundamental in-memory data structures used throughout the Starfish pipeline, primarily multi-dimensional image stacks and codebooks.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/imagestack/imagestack.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/imagestack.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/imagestack/parser/", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/parser/", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/codebook/codebook.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/codebook/codebook.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Image Processing Engine", + "description": "Applies various algorithms to transform and enhance image data, including filtering, registration, and basic segmentation operations.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/image/Filter/", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/image/Filter/", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/image/_registration/", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/image/_registration/", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/image/Segment/watershed.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/image/Segment/watershed.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/morphology/Binarize/threshold.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/Binarize/threshold.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/morphology/label_image/label_image.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/label_image/label_image.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Spot Analysis Engine", + "description": "Dedicated to identifying, quantifying, and decoding biological spots within processed image data. It integrates spot detection, intensity measurement, and genetic decoding.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/spots/FindSpots/", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/FindSpots/", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/intensity_table/intensity_table.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/intensity_table/intensity_table.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/spots/DecodeSpots/", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/DecodeSpots/", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/spots/AssignTargets/label.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/AssignTargets/label.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/spots/DetectPixels/", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/spots/DetectPixels/", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Output & Export Layer", + "description": "Handles the serialization and export of all processed data, including transformed image stacks, decoded spot information, and generated masks, into various persistent formats.", + "referenced_source_code": [ + { + "qualified_name": "starfish/core/imagestack/imagestack.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/imagestack/imagestack.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/types/_decoded_spots.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/types/_decoded_spots.py", + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/morphology/binary_mask/_io.py", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/morphology/binary_mask/_io.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + }, + { + "name": "Visualization Utilities", + "description": "Provides tools and functions for generating visual representations of intermediate and final analysis results, aiding in quality control, debugging, and interpretation.", + "referenced_source_code": [ + { + "qualified_name": "starfish/util/plot/", + "reference_file": null, + "reference_start_line": 0, + "reference_end_line": 0 + }, + { + "qualified_name": "starfish/core/_display/", + "reference_file": "/home/ivan/StartUp/CodeBoarding/repos/starfish/starfish/core/_display.py", + "reference_start_line": 0, + "reference_end_line": 0 + } + ], + "can_expand": true + } + ], + "components_relations": [ + { + "relation": "provides SpaceTx Experiment Data to", + "src_name": "Data Input & Validation Layer", + "dst_name": "Core Data Structures" + }, + { + "relation": "supplies Image Stacks to", + "src_name": "Core Data Structures", + "dst_name": "Image Processing Engine" + }, + { + "relation": "provides Codebook to", + "src_name": "Core Data Structures", + "dst_name": "Spot Analysis Engine" + }, + { + "relation": "outputs Processed Image Stacks to", + "src_name": "Image Processing Engine", + "dst_name": "Core Data Structures" + }, + { + "relation": "feeds Processed Images to", + "src_name": "Image Processing Engine", + "dst_name": "Spot Analysis Engine" + }, + { + "relation": "generates Binary Masks for", + "src_name": "Image Processing Engine", + "dst_name": "Output & Export Layer" + }, + { + "relation": "outputs Decoded Spot Data & Intensity Tables to", + "src_name": "Spot Analysis Engine", + "dst_name": "Output & Export Layer" + }, + { + "relation": "provides Data for Visualization to", + "src_name": "Core Data Structures", + "dst_name": "Visualization Utilities" + }, + { + "relation": "provides Decoded Spots for Plotting to", + "src_name": "Spot Analysis Engine", + "dst_name": "Visualization Utilities" + } + ] +} \ No newline at end of file diff --git a/.codeboarding/codeboarding_version.json b/.codeboarding/codeboarding_version.json new file mode 100644 index 00000000..34f4c526 --- /dev/null +++ b/.codeboarding/codeboarding_version.json @@ -0,0 +1,4 @@ +{ + "commit_hash": "43762625fe9ef2497f5aa5ff9e6d7c33b88290fd", + "code_boarding_version": "0.1.0" +} \ No newline at end of file diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md new file mode 100644 index 00000000..f5e601bb --- /dev/null +++ b/.codeboarding/on_boarding.md @@ -0,0 +1,102 @@ +```mermaid +graph LR + Data_Input_Validation_Layer["Data Input & Validation Layer"] + Core_Data_Structures["Core Data Structures"] + Image_Processing_Engine["Image Processing Engine"] + Spot_Analysis_Engine["Spot Analysis Engine"] + Output_Export_Layer["Output & Export Layer"] + Visualization_Utilities["Visualization Utilities"] + Data_Input_Validation_Layer -- "provides SpaceTx Experiment Data to" --> Core_Data_Structures + Core_Data_Structures -- "supplies Image Stacks to" --> Image_Processing_Engine + Core_Data_Structures -- "provides Codebook to" --> Spot_Analysis_Engine + Image_Processing_Engine -- "outputs Processed Image Stacks to" --> Core_Data_Structures + Image_Processing_Engine -- "feeds Processed Images to" --> Spot_Analysis_Engine + Image_Processing_Engine -- "generates Binary Masks for" --> Output_Export_Layer + Spot_Analysis_Engine -- "outputs Decoded Spot Data & Intensity Tables to" --> Output_Export_Layer + Core_Data_Structures -- "provides Data for Visualization to" --> Visualization_Utilities + Spot_Analysis_Engine -- "provides Decoded Spots for Plotting to" --> Visualization_Utilities + click Data_Input_Validation_Layer href "https://github.com/spacetx/starfish/blob/main/starfish/Data_Input_Validation_Layer.md" "Details" + click Core_Data_Structures href "https://github.com/spacetx/starfish/blob/main/starfish/Core_Data_Structures.md" "Details" + click Image_Processing_Engine href "https://github.com/spacetx/starfish/blob/main/starfish/Image_Processing_Engine.md" "Details" + click Spot_Analysis_Engine href "https://github.com/spacetx/starfish/blob/main/starfish/Spot_Analysis_Engine.md" "Details" + click Output_Export_Layer href "https://github.com/spacetx/starfish/blob/main/starfish/Output_Export_Layer.md" "Details" + click Visualization_Utilities href "https://github.com/spacetx/starfish/blob/main/starfish/Visualization_Utilities.md" "Details" +``` + +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Details + +The Starfish project is structured around a robust data processing pipeline for spatial transcriptomics. It begins with a `Data Input & Validation Layer` responsible for ingesting and validating raw experimental data against the SpaceTx format. This validated data is then transformed into `Core Data Structures`, primarily multi-dimensional image stacks and codebooks, which serve as the central in-memory representation. The `Image Processing Engine` operates on these image stacks, applying various algorithms for enhancement and transformation. Concurrently, the `Spot Analysis Engine` identifies, quantifies, and decodes biological spots using both the processed images and the codebook. Finally, the `Output & Export Layer` handles the serialization and persistence of all processed data, while `Visualization Utilities` provide crucial tools for inspecting intermediate and final results. This modular design ensures clear separation of concerns and facilitates a streamlined data flow from raw input to interpretable biological insights. + +### Data Input & Validation Layer [[Expand]](./Data_Input_Validation_Layer.md) +Responsible for loading raw experimental data and metadata, ensuring it conforms to the SpaceTx format. It acts as the initial entry point for all data processing pipelines. + + +**Related Classes/Methods**: + +- `starfish/core/experiment/experiment.py` +- `starfish/core/experiment/builder/builder.py` +- `starfish/core/spacetx_format/validate_sptx.py` + + +### Core Data Structures [[Expand]](./Core_Data_Structures.md) +Defines and manages the fundamental in-memory data structures used throughout the Starfish pipeline, primarily multi-dimensional image stacks and codebooks. + + +**Related Classes/Methods**: + +- `starfish/core/imagestack/imagestack.py` +- `starfish/core/imagestack/parser/` +- `starfish/core/codebook/codebook.py` + + +### Image Processing Engine [[Expand]](./Image_Processing_Engine.md) +Applies various algorithms to transform and enhance image data, including filtering, registration, and basic segmentation operations. + + +**Related Classes/Methods**: + +- `starfish/core/image/Filter/` +- `starfish/core/image/_registration/` +- `starfish/core/image/Segment/watershed.py` +- `starfish/core/morphology/Binarize/threshold.py` +- `starfish/core/morphology/label_image/label_image.py` + + +### Spot Analysis Engine [[Expand]](./Spot_Analysis_Engine.md) +Dedicated to identifying, quantifying, and decoding biological spots within processed image data. It integrates spot detection, intensity measurement, and genetic decoding. + + +**Related Classes/Methods**: + +- `starfish/core/spots/FindSpots/` +- `starfish/core/intensity_table/intensity_table.py` +- `starfish/core/spots/DecodeSpots/` +- `starfish/core/spots/AssignTargets/label.py` +- `starfish/core/spots/DetectPixels/` + + +### Output & Export Layer [[Expand]](./Output_Export_Layer.md) +Handles the serialization and export of all processed data, including transformed image stacks, decoded spot information, and generated masks, into various persistent formats. + + +**Related Classes/Methods**: + +- `starfish/core/imagestack/imagestack.py` +- `starfish/core/types/_decoded_spots.py` +- `starfish/core/morphology/binary_mask/_io.py` + + +### Visualization Utilities [[Expand]](./Visualization_Utilities.md) +Provides tools and functions for generating visual representations of intermediate and final analysis results, aiding in quality control, debugging, and interpretation. + + +**Related Classes/Methods**: + +- `starfish/core/_display/` + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file