'
html += (
f"| Shape: | "
f"{shape[1]} × {shape[0]} (W×H) |
"
)
html += (
f"| Data type: | {dtype_str} |
"
)
html += (
f"| {z_label} range: | "
f"[{z_min}, {z_max}]"
)
if self.zunit:
html += f" {self.zunit}"
html += " |
"
# Origin and pixel spacing (for uniform coordinates)
if self.is_uniform_coords:
html += (
f"| Origin ({x_label}, {y_label}): | "
f"({self.x0:.4g}, {self.y0:.4g})"
)
if self.xunit:
html += f" {self.xunit}"
html += " |
"
html += (
f"| Pixel spacing (Δx, Δy): | "
f"({self.dx:.4g}, {self.dy:.4g})"
)
if self.xunit:
html += f" {self.xunit}"
html += " |
"
else:
# Non-uniform coordinates: show coordinate array info
x_coords_info = "N/A"
y_coords_info = "N/A"
if self.xcoords is not None and self.xcoords.size > 0:
x_coords_info = f"[{self.xcoords[0]:.4g}, {self.xcoords[-1]:.4g}]"
if self.ycoords is not None and self.ycoords.size > 0:
y_coords_info = f"[{self.ycoords[0]:.4g}, {self.ycoords[-1]:.4g}]"
html += (
f"| {x_label} coords: | "
f"{x_coords_info}"
)
if self.xunit:
html += f" {self.xunit}"
html += " |
"
html += (
f"| {y_label} coords: | "
f"{y_coords_info}"
)
if self.yunit:
html += f" {self.yunit}"
html += " |
"
# Extent (physical bounds)
html += (
f"| Extent ({x_label}): | "
f"[{self._compute_xmin():.4g}, {self._compute_xmax():.4g}]"
)
if self.xunit:
html += f" {self.xunit}"
html += " |
"
html += (
f"| Extent ({y_label}): | "
f"[{self._compute_ymin():.4g}, {self._compute_ymax():.4g}]"
)
if self.yunit:
html += f" {self.yunit}"
html += " |
"
# Physical size
html += (
f"| Physical size: | "
f"{self.width:.4g} × {self.height:.4g}"
)
if self.xunit:
html += f" {self.xunit}"
html += " |
"
if self.roi is not None:
html += (
f"| ROIs: | "
f"{len(self.roi)} |
"
)
html += "
"
return html
def get_data(self, roi_index: int | None = None) -> np.ndarray:
"""
Return original data (if ROI is not defined or `roi_index` is None),
or ROI data (if both ROI and `roi_index` are defined).
Args:
roi_index: ROI index
Returns:
Masked data
"""
if self.roi is None or roi_index is None:
view = self.data.view(ma.MaskedArray)
view.mask = np.isnan(self.data)
return view
single_roi = self.roi.get_single_roi(roi_index)
# pylint: disable=unbalanced-tuple-unpacking
x0, y0, x1, y1 = self.physical_to_indices(single_roi.get_bounding_box(self))
# Clip coordinates to image boundaries to handle ROIs extending beyond canvas
x0 = max(0, x0)
y0 = max(0, y0)
x1 = min(self.data.shape[1], x1)
y1 = min(self.data.shape[0], y1)
# If ROI is completely outside the image, return a fully masked array
# with a single element to avoid zero-size array errors in statistics
if x0 >= x1 or y0 >= y1:
empty_array = ma.masked_array([[np.nan]], dtype=self.data.dtype, mask=True)
return empty_array
return self.get_masked_view()[y0:y1, x0:x1]
def copy(
self,
title: str | None = None,
dtype: np.dtype | None = None,
all_metadata: bool = False,
) -> ImageObj:
"""Copy object.
Args:
title: title
dtype: data type
all_metadata: if True, copy all metadata, otherwise only basic metadata
Returns:
Copied object
"""
title = self.title if title is None else title
obj = ImageObj(title=title)
obj.title = title
obj.xlabel = self.xlabel
obj.ylabel = self.ylabel
obj.zlabel = self.zlabel
obj.xunit = self.xunit
obj.yunit = self.yunit
obj.zunit = self.zunit
obj.metadata = base.deepcopy_metadata(self.metadata, all_metadata=all_metadata)
obj.annotations = self.annotations
if self.data is not None:
obj.data = np.array(self.data, copy=True, dtype=dtype)
obj.is_uniform_coords = self.is_uniform_coords
if self.is_uniform_coords:
obj.dx = self.dx
obj.dy = self.dy
obj.x0 = self.x0
obj.y0 = self.y0
else:
obj.xcoords = np.array(self.xcoords, copy=True)
obj.ycoords = np.array(self.ycoords, copy=True)
obj.autoscale = self.autoscale
obj.xscalelog = self.xscalelog
obj.xscalemin = self.xscalemin
obj.xscalemax = self.xscalemax
obj.yscalelog = self.yscalelog
obj.yscalemin = self.yscalemin
obj.yscalemax = self.yscalemax
obj.zscalemin = self.zscalemin
obj.zscalemax = self.zscalemax
obj.dicom_template = self.dicom_template
return obj
def set_data_type(self, dtype: np.dtype) -> None:
"""Change data type.
If data type is integer, clip values to the new data type's range, thus avoiding
overflow or underflow.
Args:
Data type
"""
self.data = clip_astype(self.data, dtype)
def physical_to_indices(
self, coords: list[float], clip: bool = False, as_float: bool = False
) -> list[int] | list[float]:
"""Convert coordinates from physical (real world) to indices (pixel)
Args:
coords: flat list of physical coordinates [x0, y0, x1, y1, ...]
clip: if True, clip values to image boundaries
as_float: if True, return float indices (i.e. without rounding)
Returns:
Indices
Raises:
ValueError: if coords does not contain an even number of elements
"""
if len(coords) % 2 != 0:
raise ValueError(
"coords must contain an even number of elements (x, y pairs)."
)
indices = np.array(coords, float)
if indices.size > 0:
if self.is_uniform_coords:
# Use existing uniform conversion
indices[::2] = (indices[::2] - self.x0) / self.dx
indices[1::2] = (indices[1::2] - self.y0) / self.dy
else:
# Use interpolation for non-uniform coordinates
x_indices = np.arange(len(self.xcoords))
y_indices = np.arange(len(self.ycoords))
indices[::2] = np.interp(indices[::2], self.xcoords, x_indices)
indices[1::2] = np.interp(indices[1::2], self.ycoords, y_indices)
if clip:
indices[::2] = np.clip(indices[::2], 0, self.data.shape[1] - 1)
indices[1::2] = np.clip(indices[1::2], 0, self.data.shape[0] - 1)
if as_float:
return indices.tolist()
return np.floor(indices + 0.5).astype(int).tolist()
def indices_to_physical(self, indices: list[float]) -> list[float]:
"""Convert coordinates from indices to physical (real world)
Args:
indices: flat list of indices [x0, y0, x1, y1, ...]
Returns:
Coordinates
Raises:
ValueError: if indices does not contain an even number of elements
"""
if len(indices) % 2 != 0:
raise ValueError(
"indices must contain an even number of elements (x, y pairs)."
)
coords = np.array(indices, float)
if coords.size > 0:
if self.is_uniform_coords:
# Use existing uniform conversion
coords[::2] = coords[::2] * self.dx + self.x0
coords[1::2] = coords[1::2] * self.dy + self.y0
else:
# Use interpolation for non-uniform coordinates
x_indices = np.arange(len(self.xcoords))
y_indices = np.arange(len(self.ycoords))
coords[::2] = np.interp(coords[::2], x_indices, self.xcoords)
coords[1::2] = np.interp(coords[1::2], y_indices, self.ycoords)
return coords.tolist()