diff --git a/docs/cli.md b/docs/cli.md
index 9f59091ece6d02b91b407a556bae06faff6e3e60..c2f878cc1cb4058458f636be21f63d9ebe4510ab 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -11,6 +11,7 @@ This offers quick interactions, making it ideal for tasks that require efficienc
## Graphical User Interfaces
+The command line interface allows you to run graphical user interfaces directly from the terminal.
### `qim3d gui`
!!! quote "Reference"
@@ -38,7 +39,7 @@ This offers quick interactions, making it ideal for tasks that require efficienc
!!! Example
- Here's an example of how to open the [Data Explorer](gui.md#data_explorer)
+ Here's an example of how to open the [Data Explorer](gui.md#qim3d.gui.data_explorer)
``` title="Command"
qim3d gui --data-explorer
@@ -85,16 +86,6 @@ This offers quick interactions, making it ideal for tasks that require efficienc
-
-
-
-
-
-
-
-
-
-
## Data visualization
The command line interface also allows you to easily visualize data.
@@ -190,7 +181,8 @@ Or an specific path for destination can be used. We can also choose to not open
This writes to disk the `my_plot.html` file.
## File preview
-Command line interface, which allows users to preview 3D structers or 2D images directly in command line.
+File previewing can also be done directly from the command line interface to preview 3D structure or 2D images.
+
### `qim3d preview`
| Arguments | Description |
| --------- | ----------- |
diff --git a/docs/datahandling.md b/docs/datahandling.md
new file mode 100644
index 0000000000000000000000000000000000000000..894f8feda03baf30304efbf1d52dcbd01bf2e8f6
--- /dev/null
+++ b/docs/datahandling.md
@@ -0,0 +1,28 @@
+# Data handling
+Dealing with volumetric data can be done by `qim3d` for the most common image formats available. This includes loading, saving and file conversions.
+
+Currently, it is possible to directly load `tiff`, `h5`, `nii`,`txm`, `vol` and common `PIL` formats using one single function.
+
+Additionally, synthtetic volumetric data can be generated using the `generate` module.
+
+::: qim3d.io
+ options:
+ members:
+ - load
+ - save
+ - Downloader
+ - export_ome_zarr
+ - import_ome_zarr
+ - save_mesh
+ - load_mesh
+
+::: qim3d.mesh
+ options:
+ members:
+ - from_volume
+
+::: qim3d.generate
+ options:
+ members:
+ - noise_object
+ - noise_object_collection
diff --git a/docs/detection.md b/docs/detection.md
new file mode 100644
index 0000000000000000000000000000000000000000..8f22020ea3cff0adf6a17aafc897f732ecc48739
--- /dev/null
+++ b/docs/detection.md
@@ -0,0 +1,8 @@
+# Detection in volumetric data
+
+The `qim3d` library provides a set of detection methods for volumes.
+
+::: qim3d.detection
+ options:
+ members:
+ - blobs
\ No newline at end of file
diff --git a/docs/features.md b/docs/features.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f5b33ec025b8e952a0040df2d6e09cfccc34d45
--- /dev/null
+++ b/docs/features.md
@@ -0,0 +1,10 @@
+# Feature extraction
+
+The `qim3d` library provides a set of methods for feature extraction on volumetric data
+
+::: qim3d.features
+ options:
+ members:
+ - area
+ - volume
+ - sphericity
diff --git a/docs/filters.md b/docs/filters.md
new file mode 100644
index 0000000000000000000000000000000000000000..147aa5e8db9cb651d7f2ab6665cdf438bb32352f
--- /dev/null
+++ b/docs/filters.md
@@ -0,0 +1,17 @@
+# Filtering data
+
+The `qim3d` library provides a set of methods for filtering volumes.
+
+::: qim3d.filters
+ options:
+ members:
+ - gaussian
+ - median
+ - maximum
+ - minimum
+ - tophat
+
+::: qim3d.filters.Pipeline
+ options:
+ members:
+ - append
\ No newline at end of file
diff --git a/docs/generate.md b/docs/generate.md
deleted file mode 100644
index fef26fe50f0381bfffd871e32c2d564e298cb6d4..0000000000000000000000000000000000000000
--- a/docs/generate.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Generating synthetic data
-
-The `qim3d` library provides a set of methods for generating volumes consisting of a single synthetic blob or a collection of multiple synthetic blobs.
-
-::: qim3d.generate
- options:
- members:
- - blob
- - collection
diff --git a/docs/io.md b/docs/io.md
deleted file mode 100644
index cbb1eb20a06144d6125f615559db5b78f9d96eec..0000000000000000000000000000000000000000
--- a/docs/io.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Data input and output
-Dealing with volumetric data can be done by `qim3d` for the most common image formats available.
-
-Currently, it is possible to directly load `tiff`, `h5`, `nii`,`txm`, `vol` and common `PIL` formats using one single function.
-
-::: qim3d.io
- options:
- members:
- - load
- - load_mesh
- - save
- - save_mesh
- - Downloader
- - export_ome_zarr
- - import_ome_zarr
\ No newline at end of file
diff --git a/docs/models.md b/docs/models.md
index 17d5367551887b589cf1bdb837df019d1a65eeef..a3e0f8409ecd3d32a03b799e4ad1fe21c90f2114 100644
--- a/docs/models.md
+++ b/docs/models.md
@@ -2,4 +2,7 @@
The `qim3d` library aims to ease the creation of ML models for volumetric images
-::: qim3d.models.unet
\ No newline at end of file
+::: qim3d.ml.models
+ options:
+ members:
+ - UNet
\ No newline at end of file
diff --git a/docs/operations.md b/docs/operations.md
new file mode 100644
index 0000000000000000000000000000000000000000..8023f31d6a5e882a298bf7a478f9ee6fc9a46038
--- /dev/null
+++ b/docs/operations.md
@@ -0,0 +1,10 @@
+# Operations on volumetric data
+
+The `qim3d` library provides a set of methods for different operations on volumes.
+
+::: qim3d.operations
+ options:
+ members:
+ - remove_background
+ - fade_mask
+ - overlay_rgb_images
\ No newline at end of file
diff --git a/docs/processing.md b/docs/processing.md
index 759c981c8bb76130ac8a850fa72dfa8ece9a535b..93d0e9b5b9e36b972e5d4284d17350b66b5ae224 100644
--- a/docs/processing.md
+++ b/docs/processing.md
@@ -5,35 +5,7 @@ Here, we provide functionalities designed specifically for 3D image analysis and
::: qim3d.processing
options:
members:
- - blob_detection
- structure_tensor
- local_thickness
- - get_3d_cc
- - gaussian
- - median
- - maximum
- - minimum
- - tophat
- get_lines
- - segment_layers
- - create_mesh
-
-::: qim3d.processing.Pipeline
- options:
- members:
- - append
-
-::: qim3d.processing.operations
- options:
- members:
- - remove_background
- - watershed
- - fade_mask
- - overlay_rgb_images
-
-::: qim3d.processing.features
- options:
- members:
- - area
- - volume
- - sphericity
\ No newline at end of file
+ - segment_layers
\ No newline at end of file
diff --git a/docs/releases.md b/docs/releases.md
index cee2d6a410e228ecd75e4d9a1f1b4d84e26e146f..abbd81777bb6de085c81fa7689bb3cc879cc50fc 100644
--- a/docs/releases.md
+++ b/docs/releases.md
@@ -7,7 +7,7 @@ Below, you'll find details about the version history of `qim3d`.
As the library is still in its early development stages, **there may be breaking changes** before `v1.0` without prior deprecation warnings. Therefore, it's advisable to review the release history for more information if you encounter any issues.
-And remember to keep your pip installation [up to date](/qim3d/#get-the-latest-version) so that you have the latest features!
+And remember to keep your pip installation [up to date](index.md/#get-the-latest-version) so that you have the latest features!
### v0.4.5 (21/11/2024)
diff --git a/docs/segmentation.md b/docs/segmentation.md
new file mode 100644
index 0000000000000000000000000000000000000000..4ac23eba0e14d18df8ce8ad0aa988969e88e85f5
--- /dev/null
+++ b/docs/segmentation.md
@@ -0,0 +1,9 @@
+# Segmenting data
+
+The `qim3d` library provides a set of methods for data segmentation.
+
+::: qim3d.segmentation
+ options:
+ members:
+ - watershed
+ - get_3d_cc
diff --git a/docs/utils.md b/docs/utils.md
index ffb14315c328cf28df8160869353b3e18971f9d3..3becb903d07477d8b310bfb201aa842d47c17334 100644
--- a/docs/utils.md
+++ b/docs/utils.md
@@ -2,7 +2,7 @@
A set of tools to ease managment of the system, with the common needs for large data in mind.
-::: qim3d.utils.system
+::: qim3d.utils
options:
members:
- Memory
\ No newline at end of file
diff --git a/docs/viz.md b/docs/viz.md
index 8b6788b60610d4eee757505ca28bdac5b8691572..c538608987668f683db7b0a2f10db41bdf937836 100644
--- a/docs/viz.md
+++ b/docs/viz.md
@@ -5,21 +5,22 @@ The `qim3d` library aims to provide easy ways to explore and get insights from v
options:
members:
- histogram
- - slices
- slicer
- - orthogonal
- - vol
+ - slices_grid
+ - slicer_orthogonal
+ - circles
- chunks
- itk_vtk
+ - volumetric
- mesh
- local_thickness
- vectors
- plot_cc
- colormaps
- - interactive_fade_mask
+ - fade_mask
::: qim3d.viz.colormaps
options:
members:
- - objects
- - qim
+ - segmentation
+ - qim
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index 1867051945b60b313f66625102f6b6e31223d7a5..10c59f55d3dfb2a5ce75b8754e9fd98d48f7b347 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -7,14 +7,17 @@ repo_name: Gitlab
nav:
-
- qim3d: index.md
- - Input & Output: io.md
- - Data Generation: generate.md
- - Processing: processing.md
+ - Data handling: datahandling.md
- Visualization: viz.md
- - GUIs: gui.md
+ - Features: features.md
+ - Filters: filters.md
+ - Detection: detection.md
+ - Segmentation: segmentation.md
+ - Operations: operations.md
+ - Processing: processing.md
- ML Models: models.md
+ - GUIs: gui.md
- CLI: cli.md
- Release history: releases.md
diff --git a/qim3d/__init__.py b/qim3d/__init__.py
index b08fa27ce5a67cf3b378936b768110bf3467e7ae..ca2d9c599a464bfa745f78591119ab0112d89626 100644
--- a/qim3d/__init__.py
+++ b/qim3d/__init__.py
@@ -48,6 +48,7 @@ _submodules = [
'mesh',
'features',
'operations',
+ 'detection'
]
# Creating lazy loaders for each submodule
diff --git a/qim3d/cli/__init__.py b/qim3d/cli/__init__.py
index cec79d579f1cc01809c84efef10f97a42df74a7f..5ba85ad2cd0a31833cae9b2b9cf2e331933492d1 100644
--- a/qim3d/cli/__init__.py
+++ b/qim3d/cli/__init__.py
@@ -6,7 +6,15 @@ import qim3d
import os
QIM_TITLE = ouf.rainbow(
- f"\n _ _____ __ \n ____ _(_)___ ___ |__ /____/ / \n / __ `/ / __ `__ \ /_ </ __ / \n/ /_/ / / / / / / /__/ / /_/ / \n\__, /_/_/ /_/ /_/____/\__,_/ \n /_/ v{qim3d.__version__}\n\n",
+ rf"""
+ _ _____ __
+ ____ _(_)___ ___ |__ /____/ /
+ / __ `/ / __ `__ \ /_ </ __ /
+ / /_/ / / / / / / /__/ / /_/ /
+ \__, /_/_/ /_/ /_/____/\__,_/
+ /_/ v{qim3d.__version__}
+
+ """,
return_str=True,
cmap="hot",
)
diff --git a/qim3d/detection/_common_detection_methods.py b/qim3d/detection/_common_detection_methods.py
index 131ec1e45e40ebcd15c83de260938bcdbd360c59..71a4b348a417c4a13a74edd25615681c6c8a00ee 100644
--- a/qim3d/detection/_common_detection_methods.py
+++ b/qim3d/detection/_common_detection_methods.py
@@ -20,15 +20,15 @@ def blobs(
Extract blobs from a volume using Difference of Gaussian (DoG) method, and retrieve a binary volume with the blobs marked as True
Args:
- vol: The volume to detect blobs in
- background: 'dark' if background is darker than the blobs, 'bright' if background is lighter than the blobs
- min_sigma: The minimum standard deviation for Gaussian kernel
- max_sigma: The maximum standard deviation for Gaussian kernel
- sigma_ratio: The ratio between the standard deviation of Gaussian Kernels
- threshold: The absolute lower bound for scale space maxima. Reduce this to detect blobs with lower intensities
- overlap: The fraction of area of two blobs that overlap
- threshold_rel: The relative lower bound for scale space maxima
- exclude_border: If True, exclude blobs that are too close to the border of the image
+ vol (np.ndarray): The volume to detect blobs in.
+ background (str): 'dark' if background is darker than the blobs, 'bright' if background is lighter than the blobs. Defaults to 'dark'.
+ min_sigma (float): The minimum standard deviation for Gaussian kernel. Defaults to 1.
+ max_sigma (float): The maximum standard deviation for Gaussian kernel. Defaults to 50.
+ sigma_ratio (float): The ratio between the standard deviation of Gaussian Kernels. Defaults to 1.6.
+ threshold (float): The absolute lower bound for scale space maxima. Reduce this to detect blobs with lower intensities. Defaults to 0.5.
+ overlap (float): The fraction of area of two blobs that overlap. Defaults to 0.5.
+ threshold_rel (float or None): The relative lower bound for scale space maxima. Defaults to None.
+ exclude_border (bool): If True, exclude blobs that are too close to the border of the image. Defaults to False.
Returns:
blobs: The blobs found in the volume as (p, r, c, radius)
@@ -37,13 +37,14 @@ def blobs(
Example:
```python
import qim3d
+ import qim3d.detection
# Get data
vol = qim3d.examples.cement_128x128x128
- vol_blurred = qim3d.processing.gaussian(vol, sigma=2)
+ vol_blurred = qim3d.filters.gaussian(vol, sigma=2)
- # Detect blobs, and get binary mask
- blobs, mask = qim3d.processing.blob_detection(
+ # Detect blobs, and get binary_volume
+ blobs, binary_volume = qim3d.detection.blobs(
vol_blurred,
min_sigma=1,
max_sigma=8,
@@ -55,11 +56,11 @@ def blobs(
# Visualize detected blobs
qim3d.viz.circles(blobs, vol, alpha=0.8, color='blue')
```
- 
+ 
```python
- # Visualize binary mask
- qim3d.viz.slicer(mask)
+ # Visualize binary binary_volume
+ qim3d.viz.slicer(binary_volume)
```
"""
diff --git a/qim3d/features/_common_features_methods.py b/qim3d/features/_common_features_methods.py
index 63838ef17634d493fd5de0ec4e806d4568200918..b448b1d300b4985231262b0428eee158611cd453 100644
--- a/qim3d/features/_common_features_methods.py
+++ b/qim3d/features/_common_features_methods.py
@@ -12,11 +12,11 @@ def volume(obj: np.ndarray|trimesh.Trimesh,
Compute the volume of a 3D volume or mesh.
Args:
- obj: Either a np.ndarray volume or a mesh object of type trimesh.Trimesh.
- **mesh_kwargs: Additional arguments for mesh creation if the input is a volume.
+ obj (np.ndarray or trimesh.Trimesh): Either a np.ndarray volume or a mesh object of type trimesh.Trimesh.
+ **mesh_kwargs (Any): Additional arguments for mesh creation if the input is a volume.
Returns:
- volume: The volume of the object.
+ volume (float): The volume of the object.
Example:
Compute volume from a mesh:
@@ -27,8 +27,8 @@ def volume(obj: np.ndarray|trimesh.Trimesh,
mesh = qim3d.io.load_mesh('path/to/mesh.obj')
# Compute the volume of the mesh
- volume = qim3d.processing.volume(mesh)
- print('Volume:', volume)
+ vol = qim3d.features.volume(mesh)
+ print('Volume:', vol)
```
Compute volume from a np.ndarray:
@@ -36,10 +36,12 @@ def volume(obj: np.ndarray|trimesh.Trimesh,
import qim3d
# Generate a 3D blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
# Compute the volume of the blob
- volume = qim3d.processing.volume(synthetic_blob, level=0.5)
+ volume = qim3d.features.volume(synthetic_blob, level=0.5)
+ volume = qim3d.features.volume(synthetic_blob, level=0.5)
print('Volume:', volume)
```
@@ -58,11 +60,11 @@ def area(obj: np.ndarray|trimesh.Trimesh,
Compute the surface area of a 3D volume or mesh.
Args:
- obj: Either a np.ndarray volume or a mesh object of type trimesh.Trimesh.
- **mesh_kwargs: Additional arguments for mesh creation if the input is a volume.
+ obj (np.ndarray or trimesh.Trimesh): Either a np.ndarray volume or a mesh object of type trimesh.Trimesh.
+ **mesh_kwargs (Any): Additional arguments for mesh creation if the input is a volume.
Returns:
- area: The surface area of the object.
+ area (float): The surface area of the object.
Example:
Compute area from a mesh:
@@ -73,7 +75,8 @@ def area(obj: np.ndarray|trimesh.Trimesh,
mesh = qim3d.io.load_mesh('path/to/mesh.obj')
# Compute the surface area of the mesh
- area = qim3d.processing.area(mesh)
+ area = qim3d.features.area(mesh)
+ area = qim3d.features.area(mesh)
print(f"Area: {area}")
```
@@ -82,16 +85,19 @@ def area(obj: np.ndarray|trimesh.Trimesh,
import qim3d
# Generate a 3D blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
# Compute the surface area of the blob
- volume = qim3d.processing.area(synthetic_blob, level=0.5)
+ volume = qim3d.features.area(synthetic_blob, level=0.5)
+ volume = qim3d.features.area(synthetic_blob, level=0.5)
print('Area:', volume)
```
"""
if isinstance(obj, np.ndarray):
log.info("Converting volume to mesh.")
- obj = qim3d.processing.create_mesh(obj, **mesh_kwargs)
+ obj = qim3d.mesh.from_volume(obj, **mesh_kwargs)
+ obj = qim3d.mesh.from_volume(obj, **mesh_kwargs)
return obj.area
@@ -107,11 +113,11 @@ def sphericity(obj: np.ndarray|trimesh.Trimesh,
actual surface area.
Args:
- obj: Either a np.ndarray volume or a mesh object of type trimesh.Trimesh.
- **mesh_kwargs: Additional arguments for mesh creation if the input is a volume.
+ obj (np.ndarray or trimesh.Trimesh): Either a np.ndarray volume or a mesh object of type trimesh.Trimesh.
+ **mesh_kwargs (Any): Additional arguments for mesh creation if the input is a volume.
Returns:
- sphericity: A float value representing the sphericity of the object.
+ sphericity (float): A float value representing the sphericity of the object.
Example:
Compute sphericity from a mesh:
@@ -122,7 +128,8 @@ def sphericity(obj: np.ndarray|trimesh.Trimesh,
mesh = qim3d.io.load_mesh('path/to/mesh.obj')
# Compute the sphericity of the mesh
- sphericity = qim3d.processing.sphericity(mesh)
+ sphericity = qim3d.features.sphericity(mesh)
+ sphericity = qim3d.features.sphericity(mesh)
```
Compute sphericity from a np.ndarray:
@@ -130,10 +137,12 @@ def sphericity(obj: np.ndarray|trimesh.Trimesh,
import qim3d
# Generate a 3D blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
# Compute the sphericity of the blob
- sphericity = qim3d.processing.sphericity(synthetic_blob, level=0.5)
+ sphericity = qim3d.features.sphericity(synthetic_blob, level=0.5)
+ sphericity = qim3d.features.sphericity(synthetic_blob, level=0.5)
```
!!! info "Limitations due to pixelation"
@@ -143,10 +152,13 @@ def sphericity(obj: np.ndarray|trimesh.Trimesh,
"""
if isinstance(obj, np.ndarray):
log.info("Converting volume to mesh.")
- obj = qim3d.processing.create_mesh(obj, **mesh_kwargs)
+ obj = qim3d.mesh.from_volume(obj, **mesh_kwargs)
+ obj = qim3d.mesh.from_volume(obj, **mesh_kwargs)
- volume = qim3d.processing.volume(obj)
- area = qim3d.processing.area(obj)
+ volume = qim3d.features.volume(obj)
+ area = qim3d.features.area(obj)
+ volume = qim3d.features.volume(obj)
+ area = qim3d.features.area(obj)
if area == 0:
log.warning("Surface area is zero, sphericity is undefined.")
diff --git a/qim3d/filters/_common_filter_methods.py b/qim3d/filters/_common_filter_methods.py
index 1b43bae297380022120ad5c87c305124b700bf9c..bc4b02f0de5e94eb3e41a17786a04b950a36696d 100644
--- a/qim3d/filters/_common_filter_methods.py
+++ b/qim3d/filters/_common_filter_methods.py
@@ -110,7 +110,7 @@ class Tophat(FilterBase):
Returns:
The filtered image or volume.
"""
- return tophat(input, dask=self.dask, chunks=self.chunks, **self.kwargs)
+ return tophat(input, dask=self.dask, **self.kwargs)
class Pipeline:
@@ -118,13 +118,13 @@ class Pipeline:
Example:
```python
import qim3d
- from qim3d.processing import Pipeline, Median, Gaussian, Maximum, Minimum
+ from qim3d.filters import Pipeline, Median, Gaussian, Maximum, Minimum
# Get data
vol = qim3d.examples.fly_150x256x256
# Show original
- qim3d.viz.slices_grid(vol, axis=0, show=True)
+ fig1 = qim3d.viz.slices_grid(vol, num_slices=5, display_figure=True)
# Create filter pipeline
pipeline = Pipeline(
@@ -139,7 +139,7 @@ class Pipeline:
vol_filtered = pipeline(vol)
# Show filtered
- qim3d.viz.slices_grid(vol_filtered, axis=0)
+ fig2 = qim3d.viz.slices_grid(vol_filtered, num_slices=5, display_figure=True)
```
@@ -178,17 +178,17 @@ class Pipeline:
)
self.filters[name] = fn
- def append(self, fn: Type[FilterBase]):
+ def append(self, fn: FilterBase):
"""
Appends a filter to the end of the sequence.
Args:
- fn: An instance of a FilterBase subclass to be appended.
-
+ fn (FilterBase): An instance of a FilterBase subclass to be appended.
+
Example:
```python
import qim3d
- from qim3d.processing import Pipeline, Maximum, Median
+ from qim3d.filters import Pipeline, Maximum, Median
# Create filter pipeline
pipeline = Pipeline(
@@ -223,14 +223,14 @@ def gaussian(
Applies a Gaussian filter to the input volume using scipy.ndimage.gaussian_filter or dask_image.ndfilters.gaussian_filter.
Args:
- vol: The input image or volume.
- dask: Whether to use Dask for the Gaussian filter.
- chunks: Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
- *args: Additional positional arguments for the Gaussian filter.
- **kwargs: Additional keyword arguments for the Gaussian filter.
+ vol (np.ndarray): The input image or volume.
+ dask (bool, optional): Whether to use Dask for the Gaussian filter.
+ chunks (int or tuple or "'auto'", optional): Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
+ *args (Any): Additional positional arguments for the Gaussian filter.
+ **kwargs (Any): Additional keyword arguments for the Gaussian filter.
Returns:
- The filtered image or volume.
+ filtered_vol (np.ndarray): The filtered image or volume.
"""
if dask:
@@ -251,13 +251,13 @@ def median(
Applies a median filter to the input volume using scipy.ndimage.median_filter or dask_image.ndfilters.median_filter.
Args:
- vol: The input image or volume.
- dask: Whether to use Dask for the median filter.
- chunks: Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
- **kwargs: Additional keyword arguments for the median filter.
+ vol (np.ndarray): The input image or volume.
+ dask (bool, optional): Whether to use Dask for the median filter.
+ chunks (int or tuple or "'auto'", optional): Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
+ **kwargs (Any): Additional keyword arguments for the median filter.
Returns:
- The filtered image or volume.
+ filtered_vol (np.ndarray): The filtered image or volume.
"""
if dask:
if not isinstance(vol, da.Array):
@@ -277,13 +277,13 @@ def maximum(
Applies a maximum filter to the input volume using scipy.ndimage.maximum_filter or dask_image.ndfilters.maximum_filter.
Args:
- vol: The input image or volume.
- dask: Whether to use Dask for the maximum filter.
- chunks: Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
- **kwargs: Additional keyword arguments for the maximum filter.
+ vol (np.ndarray): The input image or volume.
+ dask (bool, optional): Whether to use Dask for the maximum filter.
+ chunks (int or tuple or "'auto'", optional): Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
+ **kwargs (Any): Additional keyword arguments for the maximum filter.
Returns:
- The filtered image or volume.
+ filtered_vol (np.ndarray): The filtered image or volume.
"""
if dask:
if not isinstance(vol, da.Array):
@@ -303,13 +303,13 @@ def minimum(
Applies a minimum filter to the input volume using scipy.ndimage.minimum_filter or dask_image.ndfilters.minimum_filter.
Args:
- vol: The input image or volume.
- dask: Whether to use Dask for the minimum filter.
- chunks: Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
- **kwargs: Additional keyword arguments for the minimum filter.
+ vol (np.ndarray): The input image or volume.
+ dask (bool, optional): Whether to use Dask for the minimum filter.
+ chunks (int or tuple or "'auto'", optional): Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
+ **kwargs (Any): Additional keyword arguments for the minimum filter.
Returns:
- The filtered image or volume.
+ filtered_vol (np.ndarray): The filtered image or volume.
"""
if dask:
if not isinstance(vol, da.Array):
@@ -321,23 +321,19 @@ def minimum(
res = ndimage.minimum_filter(vol, **kwargs)
return res
-
-def tophat(
- vol: np.ndarray, dask: bool = False, chunks: str = "auto", **kwargs
-) -> np.ndarray:
+def tophat(vol, dask=False, **kwargs):
"""
Remove background from the volume.
Args:
- vol: The volume to remove background from.
- radius: The radius of the structuring element (default: 3).
- background: Color of the background, 'dark' or 'bright' (default: 'dark'). If 'bright', volume will be inverted.
- dask: Whether to use Dask for the tophat filter (not supported, will default to SciPy).
- chunks: Defines how to divide the array into blocks when using Dask. Can be an integer, tuple, size in bytes, or "auto" for automatic sizing.
- **kwargs: Additional keyword arguments.
+ vol (np.ndarray): The volume to remove background from.
+ dask (bool, optional): Whether to use Dask for the tophat filter (not supported, will default to SciPy).
+ **kwargs (Any): Additional keyword arguments.
+ `radius` (float): The radius of the structuring element (default: 3).
+ `background` (str): Color of the background, 'dark' or 'bright' (default: 'dark'). If 'bright', volume will be inverted.
Returns:
- vol: The volume with background removed.
+ filtered_vol (np.ndarray): The volume with background removed.
"""
radius = kwargs["radius"] if "radius" in kwargs else 3
@@ -358,4 +354,4 @@ def tophat(
if background == "bright":
vol = np.invert(vol)
- return vol
+ return vol
\ No newline at end of file
diff --git a/qim3d/generate/_aggregators.py b/qim3d/generate/_aggregators.py
index 262b047ef703ef379432f4a18441617cf5475613..0eb09086de627446ea00279df2064167b2695d29 100644
--- a/qim3d/generate/_aggregators.py
+++ b/qim3d/generate/_aggregators.py
@@ -147,12 +147,12 @@ def noise_object_collection(
Generate a 3D volume of multiple synthetic objects using Perlin noise.
Args:
- collection_shape (tuple, optional): Shape of the final collection volume to generate. Defaults to (200, 200, 200).
+ collection_shape (tuple of ints, optional): Shape of the final collection volume to generate. Defaults to (200, 200, 200).
num_objects (int, optional): Number of synthetic objects to include in the collection. Defaults to 15.
positions (list[tuple], optional): List of specific positions as (z, y, x) coordinates for the objects. If not provided, they are placed randomly into the collection. Defaults to None.
- min_shape (tuple, optional): Minimum shape of the objects. Defaults to (40, 40, 40).
- max_shape (tuple, optional): Maximum shape of the objects. Defaults to (60, 60, 60).
- object_shape_zoom (tuple, optional): Scaling factors for each dimension of each object. Defaults to (1.0, 1.0, 1.0).
+ min_shape (tuple of ints, optional): Minimum shape of the objects. Defaults to (40, 40, 40).
+ max_shape (tuple of ints, optional): Maximum shape of the objects. Defaults to (60, 60, 60).
+ object_shape_zoom (tuple of floats, optional): Scaling factors for each dimension of each object. Defaults to (1.0, 1.0, 1.0).
min_object_noise (float, optional): Minimum scale factor for Perlin noise. Defaults to 0.02.
max_object_noise (float, optional): Maximum scale factor for Perlin noise. Defaults to 0.05.
min_rotation_degrees (int, optional): Minimum rotation angle in degrees. Defaults to 0.
@@ -165,7 +165,7 @@ def noise_object_collection(
min_threshold (float, optional): Minimum threshold value for clipping low intensity values. Defaults to 0.5.
max_threshold (float, optional): Maximum threshold value for clipping low intensity values. Defaults to 0.6.
smooth_borders (bool, optional): Flag for smoothing object borders to avoid straight edges in the objects. If True, the `min_threshold` and `max_threshold` parameters are ignored. Defaults to False.
- object_shape (str, optional): Shape of the object to generate, either "cylinder", or "tube". Defaults to None.
+ object_shape (str or None, optional): Shape of the object to generate, either "cylinder", or "tube". Defaults to None.
seed (int, optional): Seed for reproducibility. Defaults to 0.
verbose (bool, optional): Flag to enable verbose logging. Defaults to False.
@@ -189,10 +189,10 @@ def noise_object_collection(
# Generate synthetic collection of objects
num_objects = 15
- synthetic_collection, labels = qim3d.generate.collection(num_objects = num_objects)
+ vol, labels = qim3d.generate.noise_object_collection(num_objects = num_objects)
# Visualize synthetic collection
- qim3d.viz.vol(synthetic_collection)
+ qim3d.viz.volumetric(vol)
```
<iframe src="https://platform.qim.dk/k3d/synthetic_collection_default.html" width="100%" height="500" frameborder="0"></iframe>
@@ -203,8 +203,8 @@ def noise_object_collection(
```python
# Visualize labels
- cmap = qim3d.viz.colormaps.objects(nlabels=num_objects)
- qim3d.viz.slicer(labels, cmap=cmap, vmax=num_objects)
+ cmap = qim3d.viz.colormaps.segmentation(num_labels=num_objects)
+ qim3d.viz.slicer(labels, color_map=cmap, value_max=num_objects)
```
@@ -213,7 +213,7 @@ def noise_object_collection(
import qim3d
# Generate synthetic collection of dense objects
- synthetic_collection, labels = qim3d.generate.collection(
+ vol, labels = qim3d.generate.collection(
min_high_value = 255,
max_high_value = 255,
min_object_noise = 0.05,
@@ -224,7 +224,7 @@ def noise_object_collection(
max_gamma = 0.02)
# Visualize synthetic collection
- qim3d.viz.vol(synthetic_collection)
+ qim3d.viz.vol(vol)
```
<iframe src="https://platform.qim.dk/k3d/synthetic_collection_dense.html" width="100%" height="500" frameborder="0"></iframe>
@@ -233,7 +233,7 @@ def noise_object_collection(
import qim3d
# Generate synthetic collection of cylindrical structures
- vol, labels = qim3d.generate.collection(num_objects = 40,
+ vol, labels = qim3d.generate.noise_object_collection(num_objects = 40,
collection_shape = (300, 150, 150),
min_shape = (280, 10, 10),
max_shape = (290, 15, 15),
@@ -248,14 +248,14 @@ def noise_object_collection(
)
# Visualize synthetic collection
- qim3d.viz.vol(vol)
+ qim3d.viz.volumetric(vol)
```
<iframe src="https://platform.qim.dk/k3d/synthetic_collection_cylinder.html" width="100%" height="500" frameborder="0"></iframe>
```python
# Visualize slices
- qim3d.viz.slices_grid(vol, n_slices=15)
+ qim3d.viz.slices_grid(vol, num_slices=15)
```
@@ -264,7 +264,7 @@ def noise_object_collection(
import qim3d
# Generate synthetic collection of tubular (hollow) structures
- vol, labels = qim3d.generate.collection(num_objects = 10,
+ vol, labels = qim3d.generate.noise_object_collection(num_objects = 10,
collection_shape = (200, 200, 200),
min_shape = (180, 25, 25),
max_shape = (190, 35, 35),
@@ -279,13 +279,13 @@ def noise_object_collection(
)
# Visualize synthetic collection
- qim3d.viz.vol(vol)
+ qim3d.viz.volumetric(vol)
```
<iframe src="https://platform.qim.dk/k3d/synthetic_collection_tube.html" width="100%" height="500" frameborder="0"></iframe>
```python
# Visualize slices
- qim3d.viz.slices_grid(vol, n_slices=15, axis=1)
+ qim3d.viz.slices_grid(vol, num_slices=15, slice_axis=1)
```
"""
diff --git a/qim3d/generate/_generators.py b/qim3d/generate/_generators.py
index 78bf607bc5643a8b6570a29feac0f217059ff800..15578a67e341790a4433a6b0069d1273c87f007b 100644
--- a/qim3d/generate/_generators.py
+++ b/qim3d/generate/_generators.py
@@ -20,8 +20,8 @@ def noise_object(
Generate a 3D volume with Perlin noise, spherical gradient, and optional scaling and gamma correction.
Args:
- base_shape (tuple, optional): Shape of the initial volume to generate. Defaults to (128, 128, 128).
- final_shape (tuple, optional): Desired shape of the final volume. Defaults to (128, 128, 128).
+ base_shape (tuple of ints, optional): Shape of the initial volume to generate. Defaults to (128, 128, 128).
+ final_shape (tuple of ints, optional): Desired shape of the final volume. Defaults to (128, 128, 128).
noise_scale (float, optional): Scale factor for Perlin noise. Defaults to 0.05.
order (int, optional): Order of the spline interpolation used in resizing. Defaults to 1.
gamma (float, optional): Gamma correction factor. Defaults to 1.0.
@@ -29,7 +29,7 @@ def noise_object(
threshold (float, optional): Threshold value for clipping low intensity values. Defaults to 0.5.
smooth_borders (bool, optional): Flag for automatic computation of the threshold value to ensure a blob with no straight edges. If True, the `threshold` parameter is ignored. Defaults to False.
object_shape (str, optional): Shape of the object to generate, either "cylinder", or "tube". Defaults to None.
- dtype (str, optional): Desired data type of the output volume. Defaults to "uint8".
+ dtype (data-type, optional): Desired data type of the output volume. Defaults to "uint8".
Returns:
noise_object (numpy.ndarray): Generated 3D volume with specified parameters.
@@ -43,16 +43,16 @@ def noise_object(
import qim3d
# Generate synthetic blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ vol = qim3d.generate.noise_object(noise_scale = 0.015)
# Visualize 3D volume
- qim3d.viz.vol(synthetic_blob)
+ qim3d.viz.volumetric(vol)
```
<iframe src="https://platform.qim.dk/k3d/synthetic_blob.html" width="100%" height="500" frameborder="0"></iframe>
```python
# Visualize slices
- qim3d.viz.slices_grid(synthetic_blob, vmin = 0, vmax = 255, n_slices = 15)
+ qim3d.viz.slices_grid(vol, value_min = 0, value_max = 255, num_slices = 15)
```
@@ -61,7 +61,7 @@ def noise_object(
import qim3d
# Generate tubular synthetic blob
- vol = qim3d.generate.blob(base_shape = (10, 300, 300),
+ vol = qim3d.generate.noise_object(base_shape = (10, 300, 300),
final_shape = (100, 100, 100),
noise_scale = 0.3,
gamma = 2,
@@ -70,13 +70,13 @@ def noise_object(
)
# Visualize synthetic object
- qim3d.viz.vol(vol)
+ qim3d.viz.volumetric(vol)
```
<iframe src="https://platform.qim.dk/k3d/synthetic_blob_cylinder.html" width="100%" height="500" frameborder="0"></iframe>
```python
# Visualize slices
- qim3d.viz.slices_grid(vol, n_slices=15, axis=1)
+ qim3d.viz.slices_grid(vol, num_slices=15, slice_axis=1)
```
@@ -85,7 +85,7 @@ def noise_object(
import qim3d
# Generate tubular synthetic blob
- vol = qim3d.generate.blob(base_shape = (200, 100, 100),
+ vol = qim3d.generate.noise_object(base_shape = (200, 100, 100),
final_shape = (400, 100, 100),
noise_scale = 0.03,
gamma = 0.12,
@@ -94,13 +94,13 @@ def noise_object(
)
# Visualize synthetic blob
- qim3d.viz.vol(vol)
+ qim3d.viz.volumetric(vol)
```
<iframe src="https://platform.qim.dk/k3d/synthetic_blob_tube.html" width="100%" height="500" frameborder="0"></iframe>
```python
# Visualize
- qim3d.viz.slices_grid(vol, n_slices=15)
+ qim3d.viz.slices_grid(vol, num_slices=15)
```
"""
@@ -178,7 +178,7 @@ def noise_object(
axis = np.argmax(volume.shape) # Fade along the dimension where the object is the largest
target_max_normalized_distance = 1.4 # This value ensures that the object will become cylindrical
- volume = qim3d.processing.operations.fade_mask(volume,
+ volume = qim3d.operations.fade_mask(volume,
geometry = geometry,
axis = axis,
target_max_normalized_distance = target_max_normalized_distance
@@ -193,7 +193,7 @@ def noise_object(
target_max_normalized_distance = 1.4 # This value ensures that the object will become cylindrical
# Fade once for making the object cylindrical
- volume = qim3d.processing.operations.fade_mask(volume,
+ volume = qim3d.operations.fade_mask(volume,
geometry = geometry,
axis = axis,
decay_rate = decay_rate,
@@ -202,7 +202,7 @@ def noise_object(
)
# Fade again with invert = True for making the object a tube (i.e. with a hole in the middle)
- volume = qim3d.processing.operations.fade_mask(volume,
+ volume = qim3d.operations.fade_mask(volume,
geometry = geometry,
axis = axis,
decay_rate = decay_rate,
diff --git a/qim3d/gui/data_explorer.py b/qim3d/gui/data_explorer.py
index ee3ba16d5a90f3facbebc8580b906e52c745bc50..fb800ab225d4dbad88c48491b84145a2882fe01d 100644
--- a/qim3d/gui/data_explorer.py
+++ b/qim3d/gui/data_explorer.py
@@ -43,9 +43,9 @@ class Interface(BaseInterface):
"""
Parameters:
-----------
- show_header (bool, optional): If true, prints starting info into terminal. Default is False
verbose (bool, optional): If true, prints info during session into terminal. Defualt is False.
figsize (int, optional): Sets the size of plots displaying the slices. Default is 8.
+ display_saturation_percentile (int, optional): Sets the display saturation percentile. Defaults to 99.
"""
super().__init__(
title = "Data Explorer",
diff --git a/qim3d/io/_convert.py b/qim3d/io/_convert.py
index 55ab80cb14218ccae8184b2a95488a0de8801431..834e298c007f90d6350c731995d3bc235c144c5a 100644
--- a/qim3d/io/_convert.py
+++ b/qim3d/io/_convert.py
@@ -74,7 +74,6 @@ class Convert:
Args:
tif_path (str): path to the tiff file
zarr_path (str): path to the zarr file
- chunks (tuple, optional): chunk size for the zarr file. Defaults to (64, 64, 64).
Returns:
zarr.core.Array: zarr array containing the data from the tiff file
diff --git a/qim3d/io/_downloader.py b/qim3d/io/_downloader.py
index c77d61ccb016e3745c7a15736a179699a2c6cf9a..3d7724bb1ed0b3cdcccc841fdcf535a1f199cb83 100644
--- a/qim3d/io/_downloader.py
+++ b/qim3d/io/_downloader.py
@@ -16,7 +16,7 @@ class Downloader:
"""Class for downloading large data files available on the [QIM data repository](https://data.qim.dk/).
Attributes:
- folder_name (str): Folder class with the name of the folder in <https://data.qim.dk/>
+ folder_name (str or os.PathLike): Folder class with the name of the folder in <https://data.qim.dk/>
Syntax for downloading and loading a file is `qim3d.io.Downloader().{folder_name}.{file_name}(load_file=True)`
@@ -52,7 +52,7 @@ class Downloader:
downloader = qim3d.io.Downloader()
data = downloader.Cowry_Shell.Cowry_DOWNSAMPLED(load_file=True)
- qim3d.viz.orthogonal(data, cmap = "magma")
+ qim3d.viz.slicer_orthogonal(data, color_map="magma")
```
"""
diff --git a/qim3d/io/_loading.py b/qim3d/io/_loading.py
index b34ac1521daa4c3dee1fbd6f8efba0402ea62c38..df8320c9aefbeb25c9f02a3f176450bd58229747 100644
--- a/qim3d/io/_loading.py
+++ b/qim3d/io/_loading.py
@@ -570,6 +570,10 @@ class DataLoader:
Args:
path (str): Directory path
+
+ returns:
+ numpy.ndarray, numpy.memmap or tuple: The loaded volume.
+ If 'self.return_metadata' is True, returns a tuple (volume, metadata).
"""
import pydicom
@@ -795,8 +799,13 @@ def load(
force_load (bool, optional): If the file size exceeds available memory, a MemoryError is raised.
If force_load is True, the error is changed to warning and the loader tries to load it anyway. Default is False.
dim_order (tuple, optional): The order of the dimensions in the volume for .vol files. Default is (2,1,0) which corresponds to (z,y,x)
- **kwargs: Additional keyword arguments to be passed
- to the DataLoader constructor.
+ **kwargs (Any): Additional keyword arguments supported by `DataLoader`:
+ - `virtual_stack` (bool)
+ - `dataset_name` (str)
+ - `return_metadata` (bool)
+ - `contains` (str)
+ - `force_load` (bool)
+ - `dim_order` (tuple)
Returns:
vol (numpy.ndarray, numpy.memmap, h5py._hl.dataset.Dataset, nibabel.arrayproxy.ArrayProxy or tuple): The loaded volume
@@ -861,10 +870,10 @@ def load_mesh(filename: str) -> trimesh.Trimesh:
Load a mesh from an .obj file using trimesh.
Args:
- filename: The path to the .obj file.
+ filename (str or os.PathLike): The path to the .obj file.
Returns:
- mesh: A trimesh object containing the mesh data (vertices and faces).
+ mesh (trimesh.Trimesh): A trimesh object containing the mesh data (vertices and faces).
Example:
```python
diff --git a/qim3d/io/_ome_zarr.py b/qim3d/io/_ome_zarr.py
index 6573831a1e29bbb02607fab777145f2838c8b6d0..d2358cca6147483a480a41af86ec3c56232f13a8 100644
--- a/qim3d/io/_ome_zarr.py
+++ b/qim3d/io/_ome_zarr.py
@@ -70,10 +70,10 @@ class OMEScaler(
This method performs multi-scale downsampling on a 3D dataset, generating image pyramids. It processes the data in chunks using Dask.
Args:
- base (dask.array): The 3D array (volume) to be downsampled. Must be a Dask array for chunked processing.
+ base (dask.array.core.array): The 3D array (volume) to be downsampled. Must be a Dask array for chunked processing.
Returns:
- list of dask.array: A list of downsampled volumes, where each element represents a different scale. The first element corresponds to the original resolution, and subsequent elements represent progressively downsampled versions.
+ list of dask.array.core.Array: A list of downsampled volumes, where each element represents a different scale. The first element corresponds to the original resolution, and subsequent elements represent progressively downsampled versions.
The downsampling process occurs scale by scale, using the following steps:
- For each scale, the array is resized based on the downscale factor, computed as a function of the current scale level.
@@ -197,7 +197,7 @@ def export_ome_zarr(
This function generates a multi-scale OME-Zarr representation of the input data, which is commonly used for large imaging datasets. The downsampled scales are calculated such that the smallest scale fits within the specified `chunk_size`.
Args:
- path (str): The directory where the OME-Zarr data will be stored.
+ path (str or os.PathLike): The directory where the OME-Zarr data will be stored.
data (np.ndarray or dask.array): The 3D image data to be exported. Supports both NumPy and Dask arrays.
chunk_size (int, optional): The size of the chunks for storing data. This affects both the original data and the downsampled scales. Defaults to 256.
downsample_rate (int, optional): The factor by which to downsample the data for each scale. Must be greater than 1. Defaults to 2.
@@ -220,9 +220,6 @@ def export_ome_zarr(
qim3d.io.export_ome_zarr("Escargot.zarr", data, chunk_size=100, downsample_rate=2)
```
-
- Returns:
- None: This function writes the OME-Zarr data to the specified directory and does not return any value.
"""
# Check if directory exists
@@ -311,7 +308,7 @@ def import_ome_zarr(
The image data can be lazily loaded (as Dask arrays) or fully computed into memory.
Args:
- path (str): The file path to the OME-Zarr data.
+ path (str or os.PathLike): The file path to the OME-Zarr data.
scale (int or str, optional): The scale level to load.
If 'highest', loads the finest scale (scale 0).
If 'lowest', loads the coarsest scale (last available scale). Defaults to 0.
@@ -319,8 +316,7 @@ def import_ome_zarr(
If False, returns a lazy Dask array. Defaults to True.
Returns:
- np.ndarray or dask.array.Array: The requested image data, either as a NumPy array if `load=True`,
- or a Dask array if `load=False`.
+ vol (np.ndarray or dask.array.Array): The requested image data, either as a NumPy array if `load=True`, or a Dask array if `load=False`.
Raises:
ValueError: If the requested `scale` does not exist in the data.
diff --git a/qim3d/io/_saving.py b/qim3d/io/_saving.py
index 3ef6457f9ae26554cd810547b8a1911072492f7a..0a1fae81cbb4de7357b9b9c57d627ed183d04813 100644
--- a/qim3d/io/_saving.py
+++ b/qim3d/io/_saving.py
@@ -7,7 +7,7 @@ Example:
import qim3d
# Generate synthetic blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
qim3d.io.save("fly.tif", synthetic_blob)
```
@@ -17,7 +17,7 @@ Example:
import qim3d
# Generate synthetic blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ synthetic_blob = qim3d.generate.noise_object(noise_scale = 0.015)
qim3d.io.save("slices", synthetic_blob, basename="fly-slices", sliced_dim=0)
```
@@ -260,7 +260,7 @@ class DataSaver:
Args:
path (str): The path to the Zarr array on disk.
- data (dask.array): The Dask array to be saved to disk.
+ data (dask.array.core.Array): The Dask array to be saved to disk.
Returns:
zarr.core.Array: The Zarr array saved on disk.
@@ -413,7 +413,7 @@ def save(
"""Save data to a specified file path.
Args:
- path (str): The path to save file to. File format is chosen based on the extension.
+ path (str or os.PathLike): The path to save file to. File format is chosen based on the extension.
Supported extensions are: <em>'.tif', '.tiff', '.nii', '.nii.gz', '.h5', '.vol', '.vgi', '.dcm', '.DCM', '.zarr', '.jpeg', '.jpg', '.png'</em>
data (numpy.ndarray): The data to be saved
replace (bool, optional): Specifies if an existing file with identical path should be replaced.
@@ -424,23 +424,23 @@ def save(
(only relevant for TIFF stacks). Default is None
sliced_dim (int, optional): Specifies the dimension that is sliced in case a TIFF stack is saved
as several files (only relevant for TIFF stacks). Default is 0, i.e., the first dimension.
- **kwargs: Additional keyword arguments to be passed to the DataSaver constructor
+ **kwargs (Any): Additional keyword arguments to be passed to the DataSaver constructor
Raises:
ValueError: If the provided path is an existing directory and self.basename is not provided <strong>OR</strong>
- If the file format is not supported <strong>OR</strong>
- If the provided path does not exist and self.basename is not provided <strong>OR</strong>
- If a file extension is not provided <strong>OR</strong>
- if a file with the specified path already exists and replace=False.
+ If the file format is not supported <strong>OR</strong>
+ If the provided path does not exist and self.basename is not provided <strong>OR</strong>
+ If a file extension is not provided <strong>OR</strong>
+ if a file with the specified path already exists and replace=False.
Example:
```python
import qim3d
# Generate synthetic blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ vol = qim3d.generate.noise_object(noise_scale = 0.015)
- qim3d.io.save("blob.tif", synthetic_blob, replace=True)
+ qim3d.io.save("blob.tif", vol, replace=True)
```
Volumes can also be saved with one file per slice:
@@ -448,9 +448,9 @@ def save(
import qim3d
# Generate synthetic blob
- synthetic_blob = qim3d.generate.blob(noise_scale = 0.015)
+ vol = qim3d.generate.noise_object(noise_scale = 0.015)
- qim3d.io.save("slices", synthetic_blob, basename="blob-slices", sliced_dim=0)
+ qim3d.io.save("slices", vol, basename="blob-slices", sliced_dim=0)
```
"""
@@ -472,21 +472,21 @@ def save_mesh(
Save a trimesh object to an .obj file.
Args:
- filename: The name of the file to save the mesh.
- mesh: A trimesh.Trimesh object representing the mesh.
+ filename (str or os.PathLike): The name of the file to save the mesh.
+ mesh (trimesh.Trimesh): A trimesh.Trimesh object representing the mesh.
Example:
```python
import qim3d
- vol = qim3d.generate.blob(base_shape=(32, 32, 32),
+ vol = qim3d.generate.noise_object(base_shape=(32, 32, 32),
final_shape=(32, 32, 32),
noise_scale=0.05,
order=1,
gamma=1.0,
max_value=255,
threshold=0.5)
- mesh = qim3d.processing.create_mesh(vol)
+ mesh = qim3d.mesh.from_volume(vol)
qim3d.io.save_mesh("mesh.obj", mesh)
```
"""
diff --git a/qim3d/mesh/_common_mesh_methods.py b/qim3d/mesh/_common_mesh_methods.py
index 87cb9d8bfc792ca939d2e0afab00eff4510c2a91..a7e358ea7eed9bade283bd411f33da6f64ffa3a0 100644
--- a/qim3d/mesh/_common_mesh_methods.py
+++ b/qim3d/mesh/_common_mesh_methods.py
@@ -20,18 +20,17 @@ def from_volume(
volume (np.ndarray): The 3D numpy array representing the volume.
level (float, optional): The threshold value for Marching Cubes. If None, Otsu's method is used.
step_size (int, optional): The step size for the Marching Cubes algorithm.
- allow_degenerate (bool, optional): Whether to allow degenerate (i.e. zero-area) triangles in the end-result.
- If False, degenerate triangles are removed, at the cost of making the algorithm slower. Default False.
- padding (tuple of int, optional): Padding to add around the volume.
+ allow_degenerate (bool, optional): Whether to allow degenerate (i.e. zero-area) triangles in the end-result. If False, degenerate triangles are removed, at the cost of making the algorithm slower. Default False.
+ padding (tuple of ints, optional): Padding to add around the volume.
**kwargs: Additional keyword arguments to pass to `skimage.measure.marching_cubes`.
Returns:
- trimesh: The generated mesh.
+ mesh (trimesh.Trimesh): The generated mesh.
Example:
```python
import qim3d
- vol = qim3d.generate.blob(base_shape=(128,128,128),
+ vol = qim3d.generate.noise_object(base_shape=(128,128,128),
final_shape=(128,128,128),
noise_scale=0.03,
order=1,
@@ -40,7 +39,7 @@ def from_volume(
threshold=0.5,
dtype='uint8'
)
- mesh = qim3d.processing.create_mesh(vol, step_size=3)
+ mesh = qim3d.mesh.from_volume(vol, step_size=3)
qim3d.viz.mesh(mesh.vertices, mesh.faces)
```
<iframe src="https://platform.qim.dk/k3d/mesh_visualization.html" width="100%" height="500" frameborder="0"></iframe>
diff --git a/qim3d/ml/_ml_utils.py b/qim3d/ml/_ml_utils.py
index 98196f2dd5d30b63deda59b9a032a1af3c97a331..f268dc2556fb74de04acc836cec184875f42d80e 100644
--- a/qim3d/ml/_ml_utils.py
+++ b/qim3d/ml/_ml_utils.py
@@ -40,18 +40,21 @@ def train_model(
val_loss (dict): Dictionary with average losses and batch losses for validation loop.
Example:
+ import qim3d
+ from qim3d.ml import train_model
+
# defining the model.
- model = qim3d.utils.UNet()
+ model = qim3d.ml.UNet()
# choosing the hyperparameters
- hyperparameters = qim3d.utils.hyperparameters(model)
+ hyperparameters = qim3d.ml.models.Hyperparameters(model)
# DataLoaders
train_loader = MyTrainLoader()
val_loader = MyValLoader()
# training the model.
- train_loss,val_loss = train_model(model, hyperparameters, train_loader, val_loader)
+ train_loss,val_loss = qim3d.ml.train_model(model, hyperparameters, train_loader, val_loader)
"""
params_dict = hyperparameters()
n_epochs = params_dict["n_epochs"]
@@ -186,9 +189,10 @@ def inference(data: torch.utils.data.Dataset, model: torch.nn.Module) -> tuple[t
- The function does not assume the model is already in evaluation mode (model.eval()).
Example:
+ import qim3d
dataset = MySegmentationDataset()
model = MySegmentationModel()
- inference(data,model)
+ qim3d.ml.inference(data,model)
"""
# Get device
diff --git a/qim3d/ml/models/_unet.py b/qim3d/ml/models/_unet.py
index a396d88d38a5ff9809f6e2a0bd1139df1f48eb40..fa41c0214d3dedccc916f79812f08e06b1eb03a2 100644
--- a/qim3d/ml/models/_unet.py
+++ b/qim3d/ml/models/_unet.py
@@ -12,7 +12,7 @@ class UNet(nn.Module):
This class represents a 2D UNet model designed for imaging segmentation tasks.
Args:
- size (str, optional): Size of the UNet model. Must be one of 'small', 'medium', or 'large'. Defaults to 'medium'.
+ size ('small' or 'medium' or 'large', optional): Size of the UNet model. Must be one of 'small', 'medium', or 'large'. Defaults to 'medium'.
dropout (float, optional): Dropout rate between 0 and 1. Defaults to 0.
kernel_size (int, optional): Convolution kernel size. Defaults to 3.
up_kernel_size (int, optional): Up-convolution kernel size. Defaults to 3.
@@ -104,10 +104,10 @@ class Hyperparameters:
# This examples shows how to define a UNet model and its hyperparameters.
# Defining the model
- my_model = qim3d.models.UNet(size='medium')
+ my_model = qim3d.ml.UNet(size='medium')
# Choosing the hyperparameters
- hyperparams = qim3d.models.Hyperparameters(model=my_model, n_epochs=20, learning_rate=0.001)
+ hyperparams = qim3d.ml.Hyperparameters(model=my_model, n_epochs=20, learning_rate=0.001)
params_dict = hyperparams() # Get the hyperparameters
optimizer = params_dict['optimizer']
diff --git a/qim3d/operations/_common_operations_methods.py b/qim3d/operations/_common_operations_methods.py
index 26959254dfd8783f28ad560de6103e3c9f70ce7d..42932d5c292686903ccc4a3a3d23858e4d25612d 100644
--- a/qim3d/operations/_common_operations_methods.py
+++ b/qim3d/operations/_common_operations_methods.py
@@ -18,11 +18,11 @@ def remove_background(
vol (np.ndarray): The volume to remove background from.
median_filter_size (int, optional): The size of the median filter. Defaults to 2.
min_object_radius (int, optional): The radius of the structuring element for the tophat filter. Defaults to 3.
- background (str, optional): The background type. Can be 'dark' or 'bright'. Defaults to 'dark'.
- **median_kwargs: Additional keyword arguments for the Median filter.
+ background ('dark' or 'bright, optional): The background type. Can be 'dark' or 'bright'. Defaults to 'dark'.
+ **median_kwargs (Any): Additional keyword arguments for the Median filter.
Returns:
- np.ndarray: The volume with background removed.
+ filtered_vol (np.ndarray): The volume with background removed.
Example:
@@ -30,15 +30,15 @@ def remove_background(
import qim3d
vol = qim3d.examples.cement_128x128x128
- qim3d.viz.slices_grid(vol, vmin=0, vmax=255)
+ fig1 = qim3d.viz.slices_grid(vol, value_min=0, value_max=255, num_slices=5, display_figure=True)
```
```python
- vol_filtered = qim3d.processing.operations.remove_background(vol,
+ vol_filtered = qim3d.operations.remove_background(vol,
min_object_radius=3,
background="bright")
- qim3d.viz.slices_grid(vol_filtered, vmin=0, vmax=255)
+ fig2 = qim3d.viz.slices_grid(vol_filtered, value_min=0, value_max=255, num_slices=5, display_figure=True)
```
"""
@@ -70,26 +70,27 @@ def fade_mask(
vol (np.ndarray): The volume to apply edge fading to.
decay_rate (float, optional): The decay rate of the fading. Defaults to 10.
ratio (float, optional): The ratio of the volume to fade. Defaults to 0.5.
- geometry (str, optional): The geometric shape of the fading. Can be 'spherical' or 'cylindrical'. Defaults to 'spherical'.
+ geometry ('spherical' or 'cylindrical', optional): The geometric shape of the fading. Can be 'spherical' or 'cylindrical'. Defaults to 'spherical'.
invert (bool, optional): Flag for inverting the fading. Defaults to False.
axis (int, optional): The axis along which to apply the fading. Defaults to 0.
- **kwargs: Additional keyword arguments for the edge fading.
+ **kwargs (Any): Additional keyword arguments for the edge fading.
Returns:
- vol_faded (np.ndarray): The volume with edge fading applied.
+ faded_vol (np.ndarray): The volume with edge fading applied.
Example:
```python
import qim3d
- qim3d.viz.vol(vol)
+ vol = qim3d.io.load('heartScan.tif')
+ qim3d.viz.volumetric(vol)
```
Image before edge fading has visible artifacts from the support. Which obscures the object of interest.
```python
import qim3d
- vol_faded = qim3d.processing.operations.edge_fade(vol, decay_rate=4, ratio=0.45, geometric='cylindrical')
- qim3d.viz.vol(vol_faded)
+ vol_faded = qim3d.operations.fade_mask(vol, decay_rate=4, ratio=0.45, geometric='cylindrical')
+ qim3d.viz.volumetrics(vol_faded)
```
Afterwards the artifacts are faded out, making the object of interest more visible for visualization purposes.
diff --git a/qim3d/processing/_layers.py b/qim3d/processing/_layers.py
index 306a12844f8be1356ff1d48f4cd832532d6acb75..7e7ef93058cd58b678965cedbdb43d9924c01b22 100644
--- a/qim3d/processing/_layers.py
+++ b/qim3d/processing/_layers.py
@@ -16,16 +16,16 @@ def segment_layers(data: np.ndarray,
Now uses only MaxflowBuilder for solving.
Args:
- data: 2D or 3D array on which it will be computed
- inverted: if True, it will invert the brightness of the image
- n_layers: How many layers are we looking for (result in a layer and background)
- delta: Smoothness parameter
- min_margin: If we want more layers, we have to have a margin otherwise they are all going to be exactly the same
- max_margin: Maximum margin between layers
- wrap: If True, starting and ending point of the border between layers are at the same level
+ data (np.ndarray): 2D or 3D array on which it will be computed
+ inverted (bool): If True, it will invert the brightness of the image. Defaults to False
+ n_layers (int): Determines amount of layers to look for (result in a layer and background). Defaults to 1.
+ delta (float): Patameter determining smoothness. Defaults to 1.
+ min_margin (int or None): Parameter for minimum margin. If more layers are wanted, a margin is necessary to avoid layers being identical. Defaults to None.
+ max_margin (int or None): Parameter for maximum margin. If more layers are wanted, a margin is necessary to avoid layers being identical. Defaults to None.
+ wrap (bool): If True, starting and ending point of the border between layers are at the same level. Defaults to False.
Returns:
- segmentations: list of numpy arrays, even if n_layers == 1, each array is only 0s and 1s, 1s segmenting this specific layer
+ segmentations (list[np.ndarray]): list of numpy arrays, even if n_layers == 1, each array is only 0s and 1s, 1s segmenting this specific layer
Raises:
TypeError: If Data is not np.array, if n_layers is not integer.
@@ -40,7 +40,7 @@ def segment_layers(data: np.ndarray,
layers = qim3d.processing.segment_layers(layers_image, n_layers = 2)
layer_lines = qim3d.processing.get_lines(layers)
- from matplotlib import pyplot as plt
+ import matplotlib.pyplot as plt
plt.imshow(layers_image, cmap='gray')
plt.axis('off')
@@ -95,10 +95,10 @@ def get_lines(segmentations:list[np.ndarray]) -> list:
so it could be plotted. Used with qim3d.processing.segment_layers
Args:
- segmentations: list of arrays where each array is 2D segmentation with only 2 classes
+ segmentations (list of arrays): List of arrays where each array is 2D segmentation with only 2 classes
Returns:
- segmentation_lines: list of 1D numpy arrays
+ segmentation_lines (list): List of 1D numpy arrays
"""
segmentation_lines = [np.argmin(s, axis=0) - 0.5 for s in segmentations]
return segmentation_lines
\ No newline at end of file
diff --git a/qim3d/processing/_local_thickness.py b/qim3d/processing/_local_thickness.py
index eb02bb3e04dee57c63a1dabb4a4a8dda4634e991..a38e9423599d30370a4f02f1f3de97f8b222eb15 100644
--- a/qim3d/processing/_local_thickness.py
+++ b/qim3d/processing/_local_thickness.py
@@ -4,7 +4,7 @@ import numpy as np
from typing import Optional
from qim3d.utils import log
import qim3d
-
+from IPython.display import display
def local_thickness(
image: np.ndarray,
@@ -28,10 +28,10 @@ def local_thickness(
If grayscale, it will be binarized using Otsu's method.
scale (float, optional): Downscaling factor, e.g. 0.5 for halving each dim of the image.
Default is 1.
- mask (np.ndarray, optional): binary mask of the same size of the image defining parts of the
+ mask (np.ndarray or None, optional): Binary mask of the same size of the image defining parts of the
image to be included in the computation of the local thickness. Default is None.
visualize (bool, optional): Whether to visualize the local thickness. Default is False.
- **viz_kwargs: Additional keyword arguments passed to `qim3d.viz.local_thickness`. Only used if `visualize=True`.
+ **viz_kwargs (Any): Additional keyword arguments passed to `qim3d.viz.local_thickness`. Only used if `visualize=True`.
Returns:
local_thickness (np.ndarray): 2D or 3D NumPy array representing the local thickness of the input image/volume.
@@ -40,8 +40,8 @@ def local_thickness(
```python
import qim3d
- fly = qim3d.examples.fly_150x256x256 # 3D volume
- lt_fly = qim3d.processing.local_thickness(fly, visualize=True, axis=0)
+ vol = qim3d.examples.fly_150x256x256
+ lt_vol = qim3d.processing.local_thickness(vol, visualize=True, axis=0)
```
@@ -49,11 +49,10 @@ def local_thickness(
import qim3d
# Generate synthetic collection of blobs
- num_objects = 15
- synthetic_collection, labels = qim3d.generate.collection(num_objects = num_objects)
+ vol, labels = qim3d.generate.noise_object_collection(num_objects=15)
# Extract one slice to show that localthickness works on 2D slices too
- slice = synthetic_collection[:,:,50]
+ slice = vol[:,:,50]
lt_blobs = qim3d.processing.local_thickness(slice, visualize=True)
```
diff --git a/qim3d/processing/_structure_tensor.py b/qim3d/processing/_structure_tensor.py
index 08a6f20ec1cf96c3432831e2914017c58b6cd777..f4343c972118decd9aa37a2405f448f77233fc1f 100644
--- a/qim3d/processing/_structure_tensor.py
+++ b/qim3d/processing/_structure_tensor.py
@@ -3,8 +3,8 @@
from typing import Tuple
import logging
import numpy as np
-from qim3d.utils import log
-
+from qim3d.utils._logger import log
+from IPython.display import display
def structure_tensor(
vol: np.ndarray,
@@ -26,12 +26,12 @@ def structure_tensor(
Args:
vol (np.ndarray): 3D NumPy array representing the volume.
- sigma (float, optional): A noise scale, structures smaller than sigma will be removed by smoothing.
- rho (float, optional): An integration scale giving the size over the neighborhood in which the orientation is to be analysed.
+ sigma (float, optional): A noise scale, structures smaller than sigma will be removed by smoothing. Defaults to 1.0.
+ rho (float, optional): An integration scale giving the size over the neighborhood in which the orientation is to be analysed. Defaults to 6.0.
base_noise (bool, optional): A flag indicating whether to add a small noise to the volume. Default is True.
full (bool, optional): A flag indicating that all three eigenvalues should be returned. Default is False.
visualize (bool, optional): Whether to visualize the structure tensor. Default is False.
- **viz_kwargs: Additional keyword arguments for passed to `qim3d.viz.vectors`. Only used if `visualize=True`.
+ **viz_kwargs (Any): Additional keyword arguments for passed to `qim3d.viz.vectors`. Only used if `visualize=True`.
Raises:
ValueError: If the input volume is not 3D.
diff --git a/qim3d/segmentation/_common_segmentation_methods.py b/qim3d/segmentation/_common_segmentation_methods.py
index ba4f231d16a43b5718328e817905e8df28e7c551..6baff849b112504bef23936cf99111608b21ff3e 100644
--- a/qim3d/segmentation/_common_segmentation_methods.py
+++ b/qim3d/segmentation/_common_segmentation_methods.py
@@ -14,27 +14,25 @@ def watershed(bin_vol: np.ndarray, min_distance: int = 5) -> tuple[np.ndarray, i
too close will be merged, affecting the number of segmented objects. Default is 5.
Returns:
- tuple[np.ndarray, int]:
- - Labeled volume (np.ndarray): A 3D array of the same shape as the input `bin_vol`, where each segmented object
- is assigned a unique integer label.
- - num_labels (int): The total number of unique objects found in the labeled volume.
+ labeled_vol (np.ndarray): A 3D array of the same shape as the input `bin_vol`, where each segmented object is assigned a unique integer label.
+ num_labels (int): The total number of unique objects found in the labeled volume.
Example:
```python
import qim3d
vol = qim3d.examples.cement_128x128x128
- binary = qim3d.processing.filters.gaussian(vol, sigma = 2)<60
+ bin_vol = qim3d.filters.gaussian(vol, sigma = 2)<60
- qim3d.viz.slices_grid(binary, axis=1)
+ fig1 = qim3d.viz.slices_grid(bin_vol, slice_axis=1, display_figure=True)
```
```python
- labeled_volume, num_labels = qim3d.processing.operations.watershed(binary)
+ labeled_volume, num_labels = qim3d.segmentation.watershed(bin_vol)
- cmap = qim3d.viz.colormaps.objects(num_labels)
- qim3d.viz.slices_grid(labeled_volume, axis = 1, cmap = cmap)
+ cmap = qim3d.viz.colormaps.segmentation(num_labels)
+ fig2 = qim3d.viz.slices_grid(labeled_volume, slice_axis=1, color_map=cmap, display_figure=True)
```
diff --git a/qim3d/segmentation/_connected_components.py b/qim3d/segmentation/_connected_components.py
index 45725feec526e0a31de67a0737f99d6f955d2333..190266d4f6c39954e26f6f421dec893a69319a13 100644
--- a/qim3d/segmentation/_connected_components.py
+++ b/qim3d/segmentation/_connected_components.py
@@ -83,7 +83,7 @@ def get_3d_cc(image: np.ndarray) -> CC:
```python
import qim3d
vol = qim3d.examples.cement_128x128x128[50:150]<60
- cc = qim3d.processing.get_3d_cc(vol)
+ cc = qim3d.segmentation.get_3d_cc(vol)
```
"""
connected_components, num_connected_components = label(image)
diff --git a/qim3d/utils/__init__.py b/qim3d/utils/__init__.py
index fab0c339cfa63a4fd86f5420cc0f90e4a2738597..bf4ca1fa152d07189d26525d856970063f1dbaad 100644
--- a/qim3d/utils/__init__.py
+++ b/qim3d/utils/__init__.py
@@ -1,4 +1,4 @@
-from . import _doi
+from ._doi import *
from ._system import Memory
from ._logger import log
diff --git a/qim3d/utils/_doi.py b/qim3d/utils/_doi.py
index 02095f335610b266b0dd57088787eab2697190fd..1859ed53eeb7c5e0ffa62da3066868b1de73053a 100644
--- a/qim3d/utils/_doi.py
+++ b/qim3d/utils/_doi.py
@@ -59,10 +59,11 @@ def get_bibtex(doi: str):
def custom_header(doi: str, header: str) -> str:
"""Allows a custom header to be passed
- For example:
+ Example:
+ import qim3d
doi = "https://doi.org/10.1101/2022.11.08.515664"
header = {"Accept": "text/bibliography"}
- response = qim3d.utils.doi.cusom_header(doi, header)
+ custom_header = qim3d.utils.custom_header(doi, header)
"""
return _log_and_get_text(doi, header)
diff --git a/qim3d/utils/_misc.py b/qim3d/utils/_misc.py
index 090672d2fc5370d16bd56c28c384b9efb4c528e7..b8f61bd875ef6de8711d726d21240604e367e1c3 100644
--- a/qim3d/utils/_misc.py
+++ b/qim3d/utils/_misc.py
@@ -119,9 +119,10 @@ def sizeof(num: float, suffix: str = "B") -> str:
Example:
- >>> sizeof(1024)
+ >>> import qim3d
+ >>> qim3d.utils.sizeof(1024)
'1.0 KB'
- >>> sizeof(1234567890)
+ >>> qim3d.utils.sizeof(1234567890)
'1.1 GB'
"""
for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
diff --git a/qim3d/viz/_cc.py b/qim3d/viz/_cc.py
index d07024b304d22fcb815312e70eabc54a88b54fde..24d047afbb9442f1a05d847dbe836ae84058f520 100644
--- a/qim3d/viz/_cc.py
+++ b/qim3d/viz/_cc.py
@@ -21,27 +21,27 @@ def plot_cc(
Parameters:
connected_components (CC): The connected components object.
- component_indexs (list | tuple, optional): The components to plot. If None the first max_cc_to_plot=32 components will be plotted. Defaults to None.
+ component_indexs (list or tuple, optional): The components to plot. If None the first max_cc_to_plot=32 components will be plotted. Defaults to None.
max_cc_to_plot (int, optional): The maximum number of connected components to plot. Defaults to 32.
- overlay (optional): Overlay image. Defaults to None.
+ overlay (np.ndarray or None, optional): Overlay image. Defaults to None.
crop (bool, optional): Whether to crop the image to the cc. Defaults to False.
- show (bool, optional): Whether to show the figure. Defaults to True.
- cmap (str, optional): Specifies the color map for the image. Defaults to "viridis".
- vmin (float, optional): Together with vmax define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
- vmax (float, optional): Together with vmin define the data range the colormap covers. By default colormap covers the full range. Defaults to None
- **kwargs: Additional keyword arguments to pass to `qim3d.viz.slices_grid`.
+ display_figure (bool, optional): Whether to show the figure. Defaults to True.
+ color_map (str, optional): Specifies the color map for the image. Defaults to "viridis".
+ value_min (float or None, optional): Together with vmax define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
+ value_max (float or None, optional): Together with vmin define the data range the colormap covers. By default colormap covers the full range. Defaults to None
+ **kwargs (Any): Additional keyword arguments to pass to `qim3d.viz.slices_grid`.
Returns:
- figs (list[plt.Figure]): List of figures, if `show=False`.
+ figs (list[plt.Figure]): List of figures, if `display_figure=False`.
Example:
```python
import qim3d
vol = qim3d.examples.cement_128x128x128[50:150]
vol_bin = vol<80
- cc = qim3d.processing.get_3d_cc(vol_bin)
- qim3d.viz.plot_cc(cc, crop=True, show=True, overlay=None, n_slices=5, component_indexs=[4,6,7])
- qim3d.viz.plot_cc(cc, crop=True, show=True, overlay=vol, n_slices=5, component_indexs=[4,6,7])
+ cc = qim3d.segmentation.get_3d_cc(vol_bin)
+ qim3d.viz.plot_cc(cc, crop=True, display_figure=True, overlay=None, num_slices=5, component_indexs=[4,6,7])
+ qim3d.viz.plot_cc(cc, crop=True, display_figure=True, overlay=vol, num_slices=5, component_indexs=[4,6,7])
```
@@ -79,12 +79,12 @@ def plot_cc(
)
else:
# assigns discrete color map to each connected component if not given
- if "cmap" not in kwargs:
- kwargs["cmap"] = qim3d.viz.colormaps.segmentation(len(component_indexs))
+ if "color_map" not in kwargs:
+ kwargs["color_map"] = qim3d.viz.colormaps.segmentation(len(component_indexs))
# Plot the connected component without overlay
fig = qim3d.viz.slices_grid(
- connected_components.get_cc(component, crop=crop), show=show, **kwargs
+ connected_components.get_cc(component, crop=crop), display_figure=display_figure, **kwargs
)
figs.append(fig)
diff --git a/qim3d/viz/_data_exploration.py b/qim3d/viz/_data_exploration.py
index e03f08526b176ff61d878cf11876473c7a36577c..c754604d44df47437ee7ea3e33deee751ce3681d 100644
--- a/qim3d/viz/_data_exploration.py
+++ b/qim3d/viz/_data_exploration.py
@@ -48,12 +48,12 @@ def slices_grid(
If `slice_positions` is given as a list, `num_slices` will be ignored and the slices from `slice_positions` will be plotted.
Args:
- vol np.ndarray: The 3D volume to be sliced.
+ volume (np.ndarray): The 3D volume to be sliced.
slice_axis (int, optional): Specifies the axis, or dimension, along which to slice. Defaults to 0.
- slice_positions (str, int, list, optional): One or several slicing levels. If None, linearly spaced slices will be displayed. Defaults to None.
+ slice_positions (int or list[int] or str or None, optional): One or several slicing levels. If None, linearly spaced slices will be displayed. Defaults to None.
num_slices (int, optional): Defines how many slices the user wants to be displayed. Defaults to 15.
max_columns (int, optional): The maximum number of columns to be plotted. Defaults to 5.
- color_map (str, optional): Specifies the color map for the image. Defaults to "viridis".
+ color_map (str or matplotlib.colors.LinearSegmentedColormap, optional): Specifies the color map for the image. Defaults to "magma".
value_min (float, optional): Together with value_max define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
value_max (float, optional): Together with value_min define the data range the colormap covers. By default colormap covers the full range. Defaults to None
image_height (int, optional): Height of the figure.
@@ -79,7 +79,7 @@ def slices_grid(
import qim3d
vol = qim3d.examples.shell_225x128x128
- qim3d.viz.slices_grid_grid(vol, num_slices=15)
+ qim3d.viz.slices_grid(vol, num_slices=15)
```
"""
@@ -335,7 +335,7 @@ def slicer(
Args:
volume (np.ndarray): The 3D volume to be sliced.
slice_axis (int, optional): Specifies the axis, or dimension, along which to slice. Defaults to 0.
- color_map (str, optional): Specifies the color map for the image. Defaults to "viridis".
+ color_map (str or matplotlib.colors.LinearSegmentedColormap, optional): Specifies the color map for the image. Defaults to 'magma'.
value_min (float, optional): Together with value_max define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
value_max (float, optional): Together with value_min define the data range the colormap covers. By default colormap covers the full range. Defaults to None
image_height (int, optional): Height of the figure. Defaults to 3.
@@ -409,7 +409,7 @@ def slicer_orthogonal(
Args:
volume (np.ndarray): The 3D volume to be sliced.
- color_map (str, optional): Specifies the color map for the image. Defaults to "viridis".
+ color_map (str or matplotlib.colors.LinearSegmentedColormap, optional): Specifies the color map for the image. Defaults to "magma".
value_min (float, optional): Together with value_max define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
value_max (float, optional): Together with value_min define the data range the colormap covers. By default colormap covers the full range. Defaults to None
image_height (int, optional): Height of the figure.
@@ -472,9 +472,12 @@ def fade_mask(
volume (np.ndarray): The volume to apply edge fading to.
axis (int, optional): The axis along which to apply the fading. Defaults to 0.
color_map (str, optional): Specifies the color map for the image. Defaults to "viridis".
- value_min (float, optional): Together with value_max define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
- value_max (float, optional): Together with value_min define the data range the colormap covers. By default colormap covers the full range. Defaults to None
+ value_min (float or None, optional): Together with value_max define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
+ value_max (float or None, optional): Together with value_min define the data range the colormap covers. By default colormap covers the full range. Defaults to None
+ Returns:
+ slicer_obj (widgets.HBox): The interactive widget for visualizing fade mask on slices of a 3D volume.
+
Example:
```python
import qim3d
@@ -504,12 +507,12 @@ def fade_mask(
)
axes[0].imshow(
- slice_img, cmap=color_map, value_min=new_value_min, value_max=new_value_max
+ slice_img, cmap=color_map, vmin=new_value_min, vmax=new_value_max
)
axes[0].set_title("Original")
axes[0].axis("off")
- mask = qim3d.processing.operations.fade_mask(
+ mask = qim3d.operations.fade_mask(
np.ones_like(volume),
decay_rate=decay_rate,
ratio=ratio,
@@ -521,7 +524,7 @@ def fade_mask(
axes[1].set_title("Mask")
axes[1].axis("off")
- masked_volume = qim3d.processing.operations.fade_mask(
+ masked_volume = qim3d.operations.fade_mask(
volume,
decay_rate=decay_rate,
ratio=ratio,
@@ -603,8 +606,8 @@ def chunks(zarr_path: str, **kwargs)-> widgets.interactive:
Function to visualize chunks of a Zarr dataset using the specified visualization method.
Args:
- zarr_path (str): Path to the Zarr dataset.
- **kwargs: Additional keyword arguments to pass to the visualization method.
+ zarr_path (str or os.PathLike): Path to the Zarr dataset.
+ **kwargs (Any): Additional keyword arguments to pass to the visualization method.
Example:
```python
@@ -692,7 +695,7 @@ def chunks(zarr_path: str, **kwargs)-> widgets.interactive:
viz_widget = widgets.Output()
with viz_widget:
viz_widget.clear_output(wait=True)
- fig = qim3d.viz.slices_grid_grid(chunk, **kwargs)
+ fig = qim3d.viz.slices_grid(chunk, **kwargs)
display(fig)
elif visualization_method == "volume":
viz_widget = widgets.Output()
@@ -871,9 +874,9 @@ def histogram(
Args:
volume (np.ndarray): A 3D NumPy array representing the volume to be visualized.
- bins (Union[int, str], optional): Number of histogram bins or a binning strategy (e.g., "auto"). Default is "auto".
+ bins (int or str, optional): Number of histogram bins or a binning strategy (e.g., "auto"). Default is "auto".
axis (int, optional): Axis along which to take a slice. Default is 0.
- slice_idx (Union[int, str], optional): Specifies the slice to visualize. If an integer, it represents the slice index along the selected axis.
+ slice_idx (int or str or None, optional): Specifies the slice to visualize. If an integer, it represents the slice index along the selected axis.
If "middle", the function uses the middle slice. If None, the entire volume is visualized. Default is None.
kde (bool, optional): Whether to overlay a kernel density estimate. Default is True.
log_scale (bool, optional): Whether to use a logarithmic scale on the y-axis. Default is False.
@@ -881,14 +884,14 @@ def histogram(
show_title (bool, optional): If True, displays a title with slice information. Default is True.
color (str, optional): Color for the histogram bars. If "qim3d", defaults to the qim3d color. Default is "qim3d".
edgecolor (str, optional): Color for the edges of the histogram bars. Default is None.
- figsize (tuple, optional): Size of the figure (width, height). Default is (8, 4.5).
+ figsize (tuple of floats, optional): Size of the figure (width, height). Default is (8, 4.5).
element (str, optional): Type of histogram to draw ('bars', 'step', or 'poly'). Default is "step".
return_fig (bool, optional): If True, returns the figure object instead of showing it directly. Default is False.
show (bool, optional): If True, displays the plot. If False, suppresses display. Default is True.
- **sns_kwargs: Additional keyword arguments for `seaborn.histplot`.
+ **sns_kwargs (Any): Additional keyword arguments for `seaborn.histplot`.
Returns:
- Optional[matplotlib.figure.Figure]: If `return_fig` is True, returns the generated figure object. Otherwise, returns None.
+ fig (Optional[matplotlib.figure.Figure]): If `return_fig` is True, returns the generated figure object. Otherwise, returns None.
Raises:
ValueError: If `axis` is not a valid axis index (0, 1, or 2).
diff --git a/qim3d/viz/_detection.py b/qim3d/viz/_detection.py
index 14ba42bff77169a2a18f24591b92e353e479d32c..200904de308604cb30888057c49007f353595f37 100644
--- a/qim3d/viz/_detection.py
+++ b/qim3d/viz/_detection.py
@@ -15,26 +15,48 @@ def circles(blobs: tuple[float,float,float,float], vol: np.ndarray, alpha: float
it defaults to the middle slice of the volume.
Args:
- blobs (array-like): An array-like object of blobs, where each blob is represented
+ blobs (np.ndarray): An array-like object of blobs, where each blob is represented
as a 4-tuple (p, r, c, radius). Usually the result of `qim3d.processing.blob_detection(vol)`
- vol (array-like): The 3D volume on which to plot the blobs.
+ vol (np.ndarray): The 3D volume on which to plot the blobs.
alpha (float, optional): The transparency of the blobs. Defaults to 0.5.
color (str, optional): The color of the blobs. Defaults to "#ff9900".
- **kwargs: Arbitrary keyword arguments for the `slices` function.
+ **kwargs (Any): Arbitrary keyword arguments for the `slices` function.
Returns:
slicer_obj (ipywidgets.interactive): An interactive widget for visualizing the blobs.
+ Example:
+ ```python
+ import qim3d
+ import qim3d.detection
+
+ # Get data
+ vol = qim3d.examples.cement_128x128x128
+
+ # Detect blobs, and get binary mask
+ blobs, _ = qim3d.detection.blobs(
+ vol,
+ min_sigma=1,
+ max_sigma=8,
+ threshold=0.001,
+ overlap=0.1,
+ background="bright"
+ )
+
+ # Visualize detected blobs with circles method
+ qim3d.viz.circles(blobs, vol, alpha=0.8, color='blue')
+ ```
+ 
"""
def _slicer(z_slice):
clear_output(wait=True)
fig = qim3d.viz.slices_grid(
- vol,
- n_slices=1,
- position=z_slice,
- cmap="gray",
- show_position=False,
+ vol[z_slice:z_slice + 1],
+ num_slices=1,
+ color_map="gray",
+ display_figure=False,
+ display_positions=False,
**kwargs
)
# Add circles from deteced blobs
diff --git a/qim3d/viz/_k3d.py b/qim3d/viz/_k3d.py
index b45a138ccaf80682851dc53bff770a29e11c6172..6fa107d4a21cebd432bf49e49f18a52db4830788 100644
--- a/qim3d/viz/_k3d.py
+++ b/qim3d/viz/_k3d.py
@@ -35,7 +35,6 @@ def volumetric(
Args:
img (numpy.ndarray): The input 3D image data. It should be a 3D numpy array.
aspectmode (str, optional): Determines the proportions of the scene's axes. Defaults to "data".
-
If `'data'`, the axes are drawn in proportion with the axes' ranges.
If `'cube'`, the axes are drawn as a cube, regardless of the axes' ranges.
show (bool, optional): If True, displays the visualization inline. Defaults to True.
@@ -43,15 +42,15 @@ def volumetric(
If a string is provided, it's interpreted as the file path where the HTML
file will be saved. Defaults to False.
grid_visible (bool, optional): If True, the grid is visible in the plot. Defaults to False.
- color_map (str or matplotlib.colors.Colormap or list, optional): The color map to be used for the volume rendering. If a string is passed, it should be a matplotlib colormap name. Defaults to None.
- constant_opacity (bool, float): Set to True if doing an object label visualization with a corresponding color_map; otherwise, the plot may appear poorly. Defaults to False.
- vmin (float, optional): Together with vmax defines the data range the colormap covers. By default colormap covers the full range. Defaults to None.
- vmax (float, optional): Together with vmin defines the data range the colormap covers. By default colormap covers the full range. Defaults to None
- samples (int, optional): The number of samples to be used for the volume rendering in k3d. Defaults to 512.
+ color_map (str or matplotlib.colors.Colormap or list, optional): The color map to be used for the volume rendering. If a string is passed, it should be a matplotlib colormap name. Defaults to 'magma'.
+ constant_opacity (bool): Set to True if doing an object label visualization with a corresponding color_map; otherwise, the plot may appear poorly. Defaults to False.
+ vmin (float or None, optional): Together with vmax defines the data range the colormap covers. By default colormap covers the full range. Defaults to None.
+ vmax (float or None, optional): Together with vmin defines the data range the colormap covers. By default colormap covers the full range. Defaults to None
+ samples (int or 'auto', optional): The number of samples to be used for the volume rendering in k3d. Input 'auto' for auto selection. Defaults to 'auto'.
Lower values will render faster but with lower quality.
max_voxels (int, optional): Defaults to 512^3.
data_type (str, optional): Default to 'scaled_float16'.
- **kwargs: Additional keyword arguments to be passed to the `k3d.plot` function.
+ **kwargs (Any): Additional keyword arguments to be passed to the `k3d.plot` function.
Returns:
plot (k3d.plot): If `show=False`, returns the K3D plot object.
@@ -197,7 +196,7 @@ def mesh(
save (bool or str, optional): If True, saves the visualization as an HTML file.
If a string is provided, it's interpreted as the file path where the HTML
file will be saved. Defaults to False.
- **kwargs: Additional keyword arguments to be passed to the `k3d.plot` function.
+ **kwargs (Any): Additional keyword arguments to be passed to the `k3d.plot` function.
Returns:
plot (k3d.plot): If `show=False`, returns the K3D plot object.
@@ -206,7 +205,7 @@ def mesh(
```python
import qim3d
- vol = qim3d.generate.blob(base_shape=(128,128,128),
+ vol = qim3d.generate.noise_object(base_shape=(128,128,128),
final_shape=(128,128,128),
noise_scale=0.03,
order=1,
@@ -215,7 +214,7 @@ def mesh(
threshold=0.5,
dtype='uint8'
)
- mesh = qim3d.processing.create_mesh(vol, step_size=3)
+ mesh = qim3d.mesh.from_volume(vol, step_size=3)
qim3d.viz.mesh(mesh.vertices, mesh.faces)
```
<iframe src="https://platform.qim.dk/k3d/mesh_visualization.html" width="100%" height="500" frameborder="0"></iframe>
diff --git a/qim3d/viz/_local_thickness.py b/qim3d/viz/_local_thickness.py
index c07438eec0c6dfb06f72c80373d4698fbffec6bc..0f63c64165c965c58db59df7aa0ff986c677f0e4 100644
--- a/qim3d/viz/_local_thickness.py
+++ b/qim3d/viz/_local_thickness.py
@@ -30,19 +30,19 @@ def local_thickness(
number of slices and rounded to the nearest integer. If None, the middle slice will
be used for 3D images. Unused for 2D images. Defaults to None.
show (bool, optional): If True, displays the plot (i.e. calls plt.show()). Defaults to False.
- figsize (Tuple[int, int], optional): The size of the figure. Defaults to (15, 5).
+ figsize (tuple, optional): The size of the figure. Defaults to (15, 5).
Raises:
ValueError: If the slice index is not an integer or a float between 0 and 1.
Returns:
- If the input is 3D, returns an interactive widget. Otherwise, returns a matplotlib figure.
+ local_thickness (widgets.interactive or plt.Figure): If the input is 3D, returns an interactive widget. Otherwise, returns a matplotlib figure.
Example:
```python
import qim3d
- fly = qim3d.examples.fly_150x256x256 # 3D volume
+ fly = qim3d.examples.fly_150x256x256
lt_fly = qim3d.processing.local_thickness(fly)
qim3d.viz.local_thickness(fly, lt_fly, axis=0)
```
diff --git a/qim3d/viz/_metrics.py b/qim3d/viz/_metrics.py
index 16d7c7ce94bf427e82c20221d6226333f11b1bd5..f1f41785c4d94a8f156bfddceaf54dff6a4a27fa 100644
--- a/qim3d/viz/_metrics.py
+++ b/qim3d/viz/_metrics.py
@@ -215,10 +215,11 @@ def grid_pred(
None
Example:
+ import qim3d
dataset = MySegmentationDataset()
model = MySegmentationModel()
- in_targ_preds = qim3d.utils.models.inference(dataset,model)
- grid_pred(in_targ_preds, cmap_im='viridis', alpha=0.5)
+ in_targ_preds = qim3d.ml.inference(dataset,model)
+ qim3d.viz.grid_pred(in_targ_preds, cmap_im='viridis', alpha=0.5)
"""
import torch
diff --git a/qim3d/viz/_structure_tensor.py b/qim3d/viz/_structure_tensor.py
index 8148810287fe206334cf1f1e72103e7b3db8b74e..43fb8b58b90d43de0104491643a7c8cc65ca0581 100644
--- a/qim3d/viz/_structure_tensor.py
+++ b/qim3d/viz/_structure_tensor.py
@@ -37,14 +37,14 @@ def vectors(
volume_cmap (str, optional): Defines colormap for display of the volume
vmin (float, optional): Together with vmax define the data range the colormap covers. By default colormap covers the full range. Defaults to None.
vmax (float, optional): Together with vmin define the data range the colormap covers. By default colormap covers the full range. Defaults to None
- slice_idx (int or float, optional): The initial slice to be visualized. The slice index
+ slice_idx (int or float or None, optional): The initial slice to be visualized. The slice index
can afterwards be changed. If value is an integer, it will be the index of the slice
to be visualized. If value is a float between 0 and 1, it will be multiplied by the
number of slices and rounded to the nearest integer. If None, the middle slice will
be used. Defaults to None.
grid_size (int, optional): The size of the grid. Defaults to 10.
interactive (bool, optional): If True, returns an interactive widget. Defaults to True.
- figsize (Tuple[int, int], optional): The size of the figure. Defaults to (15, 5).
+ figsize (tuple, optional): The size of the figure. Defaults to (15, 5).
show (bool, optional): If True, displays the plot (i.e. calls plt.show()). Defaults to False.
Raises:
@@ -52,7 +52,7 @@ def vectors(
ValueError: If the slice index is not an integer or a float between 0 and 1.
Returns:
- fig (Union[plt.Figure, widgets.interactive]): If `interactive` is True, returns an interactive widget. Otherwise, returns a matplotlib figure.
+ fig (widgets.interactive or plt.Figure): If `interactive` is True, returns an interactive widget. Otherwise, returns a matplotlib figure.
Note:
The orientation of the vectors is visualized using an HSV color map, where the saturation corresponds to the vector component
diff --git a/qim3d/viz/colormaps/_segmentation.py b/qim3d/viz/colormaps/_segmentation.py
index b6ee2f8834b39eaf166da8f1471d9e36d44c2485..523714f849cef17f39a2cb855df305334728d844 100644
--- a/qim3d/viz/colormaps/_segmentation.py
+++ b/qim3d/viz/colormaps/_segmentation.py
@@ -54,17 +54,17 @@ def segmentation(
seed (int, optional): Seed for random number generator. Defaults to 19.
Returns:
- cmap (matplotlib.colors.LinearSegmentedColormap): Colormap for matplotlib
+ color_map (matplotlib.colors.LinearSegmentedColormap): Colormap for matplotlib
Example:
```python
import qim3d
- cmap_bright = qim3d.viz.colormaps.objects(num_labels=100, style = 'bright', first_color_background=True, background_color="black", min_dist=0.7)
- cmap_soft = qim3d.viz.colormaps.objects(num_labels=100, style = 'soft', first_color_background=True, background_color="black", min_dist=0.2)
- cmap_earth = qim3d.viz.colormaps.objects(num_labels=100, style = 'earth', first_color_background=True, background_color="black", min_dist=0.8)
- cmap_ocean = qim3d.viz.colormaps.objects(num_labels=100, style = 'ocean', first_color_background=True, background_color="black", min_dist=0.9)
+ cmap_bright = qim3d.viz.colormaps.segmentation(num_labels=100, style = 'bright', first_color_background=True, background_color="black", min_dist=0.7)
+ cmap_soft = qim3d.viz.colormaps.segmentation(num_labels=100, style = 'soft', first_color_background=True, background_color="black", min_dist=0.2)
+ cmap_earth = qim3d.viz.colormaps.segmentation(num_labels=100, style = 'earth', first_color_background=True, background_color="black", min_dist=0.8)
+ cmap_ocean = qim3d.viz.colormaps.segmentation(num_labels=100, style = 'ocean', first_color_background=True, background_color="black", min_dist=0.9)
display(cmap_bright)
display(cmap_soft)
@@ -77,18 +77,18 @@ def segmentation(
import qim3d
vol = qim3d.examples.cement_128x128x128
- binary = qim3d.processing.filters.gaussian(vol, sigma = 2) < 60
- labeled_volume, num_labels = qim3d.processing.operations.watershed(binary)
+ binary = qim3d.filters.gaussian(vol, sigma = 2) < 60
+ labeled_volume, num_labels = qim3d.segmentation.watershed(binary)
- cmap = qim3d.viz.colormaps.objects(num_labels, style = 'bright')
- qim3d.viz.slicer(labeled_volume, axis = 1, cmap=cmap)
+ color_map = qim3d.viz.colormaps.segmentation(num_labels, style = 'bright')
+ qim3d.viz.slicer(labeled_volume, slice_axis = 1, color_map=color_map)
```
Tip:
It can be easily used when calling visualization functions as
```python
- qim3d.viz.slices_grid(segmented_volume, cmap = 'objects')
+ qim3d.viz.slices_grid(segmented_volume, color_map = 'objects')
```
which automatically detects number of unique classes
and creates the colormap object with defualt arguments.
diff --git a/qim3d/viz/itk_vtk_viewer/run.py b/qim3d/viz/itk_vtk_viewer/run.py
index 45554428509423772f4dc8ec089eb591cf869a43..33aade01793b69ec3e0c87d19302cf3bb171670e 100644
--- a/qim3d/viz/itk_vtk_viewer/run.py
+++ b/qim3d/viz/itk_vtk_viewer/run.py
@@ -90,7 +90,7 @@ def try_opening_itk_vtk(
is not installed, it raises a NotInstalledError.
Args:
- filename (str, optional): Path to the file or OME-Zarr store to be visualized. Trailing slashes in
+ filename (str or PathLike, optional): Path to the file or OME-Zarr store to be visualized. Trailing slashes in
the path are normalized. Defaults to None.
open_browser (bool, optional): If True, opens the visualization in a new browser tab.
Defaults to True.