Datasets
Models
Diff of
/docs/mesh/meshes.html
[000000]
..
[9173ee]
Switch to side-by-side view
--- a +++ b/docs/mesh/meshes.html @@ -0,0 +1,4444 @@ +<!doctype html> +<html lang="en"> +<head> +<meta charset="utf-8"> +<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" /> +<meta name="generator" content="pdoc 0.10.0" /> +<title>pymskt.mesh.meshes API documentation</title> +<meta name="description" content="" /> +<link rel="preload stylesheet" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/11.0.1/sanitize.min.css" integrity="sha256-PK9q560IAAa6WVRRh76LtCaI8pjTJ2z11v0miyNNjrs=" crossorigin> +<link rel="preload stylesheet" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/11.0.1/typography.min.css" integrity="sha256-7l/o7C8jubJiy74VsKTidCy1yBkRtiUGbVkYBylBqUg=" crossorigin> +<link rel="stylesheet preload" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/styles/github.min.css" crossorigin> +<style>:root{--highlight-color:#fe9}.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}#sidebar > *:last-child{margin-bottom:2cm}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}h1:target,h2:target,h3:target,h4:target,h5:target,h6:target{background:var(--highlight-color);padding:.2em 0}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{margin-top:.6em;font-weight:bold}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}dt:target .name{background:var(--highlight-color)}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}td{padding:0 .5em}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style> +<style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%;height:100vh;overflow:auto;position:sticky;top:0}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style> +<style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style> +<script defer src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/highlight.min.js" integrity="sha256-Uv3H6lx7dJmRfRvH8TH6kJD1TSK1aFcwgx+mdg3epi8=" crossorigin></script> +<script>window.addEventListener('DOMContentLoaded', () => hljs.initHighlighting())</script> +</head> +<body> +<main> +<article id="content"> +<header> +<h1 class="title">Module <code>pymskt.mesh.meshes</code></h1> +</header> +<section id="section-intro"> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">from logging import error +from posixpath import supports_unicode_filenames +import warnings +import numpy as np +import vtk +from pymskt.image.main import apply_transform_retain_array +from vtk.util.numpy_support import numpy_to_vtk, vtk_to_numpy +import pyacvd +import pyvista as pv +import SimpleITK as sitk +import os +import random +import string +# import pyfocusr # MAKE THIS AN OPTIONAL IMPORT? + +import pymskt +from pymskt.mesh import createMesh +from pymskt.utils import safely_delete_tmp_file, copy_image_transform_to_mesh +from pymskt.image import read_nrrd, crop_bone_based_on_width +from pymskt.mesh.utils import vtk_deep_copy +from pymskt.mesh.meshTools import (gaussian_smooth_surface_scalars, + get_mesh_physical_point_coords, + get_cartilage_properties_at_points, + smooth_scalars_from_second_mesh_onto_base, + transfer_mesh_scalars_get_weighted_average_n_closest, + resample_surface + ) +from pymskt.mesh.createMesh import create_surface_mesh +from pymskt.mesh.meshTransform import (SitkVtkTransformer, + get_versor_from_transform, + break_versor_into_center_rotate_translate_transforms, + apply_transform) +from pymskt.mesh.meshRegistration import non_rigidly_register, get_icp_transform +import pymskt.mesh.io as io + +class Mesh: + """ + An object to contain surface meshes for musculoskeletal anatomy. Includes helper + functions to build surface meshes, to process them, and to save them. + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + + + Attributes + ---------- + _mesh : vtk.vtkPolyData + Item passed from __init__, or created during life of class. + This is the main surface mesh of this class. + _seg_image : SimpleITK.Image + Segmentation image that can be used to create mesh. This is optional. + path_seg_image : str + Path to medical image (.nrrd) that can be loaded to create `_seg_image` + and then creat surface mesh `_mesh` + label_idx : int + Integer of anatomy to create surface mesh from `_seg_image` + min_n_pixels : int + Minimum number of pixels for an isolated island of a segmentation to be + retained + list_applied_transforms : list + A list of transformations applied to a surface mesh. + This list allows for undoing of most recent transform, or undoing + all of them by iterating over the list in reverse. + + Methods + ---------- + + """ + def __init__(self, + mesh=None, + seg_image=None, + path_seg_image=None, + label_idx=None, + min_n_pixels=5000 + ): + """ + Initialize Mesh class + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + """ + if type(mesh) in (str,): #accept path like objects? + print('mesh string passed, loading mesh from disk') + self._mesh = io.read_vtk(mesh) + else: + self._mesh = mesh + self._seg_image = seg_image + self._path_seg_image = path_seg_image + self._label_idx = label_idx + self._min_n_pixels = min_n_pixels + + self._list_applied_transforms = [] + + def read_seg_image(self, + path_seg_image=None): + """ + Read segmentation image from disk. Must be a single file (e.g., nrrd, 3D dicom) + + Parameters + ---------- + path_seg_image : str, optional + Path to the medical image file to be loaded in, by default None + + Raises + ------ + Exception + If path_seg_image does not exist, exception is raised. + """ + # If passing new location/seg image name, then update variables. + if path_seg_image is not None: + self._path_seg_image = path_seg_image + + # If seg image location / name exist, then load image else raise exception + if (self._path_seg_image is not None): + self._seg_image = sitk.ReadImage(self._path_seg_image) + else: + raise Exception('No file path (self._path_seg_image) provided.') + + def create_mesh(self, + smooth_image=True, + smooth_image_var=0.3125 / 2, + marching_cubes_threshold=0.5, + label_idx=None, + min_n_pixels=None): + """ + Create a surface mesh from the classes `_seg_image`. If `_seg_image` + does not exist, then read it in using `read_seg_image`. + + Parameters + ---------- + smooth_image : bool, optional + Should the `_seg_image` be gaussian filtered, by default True + smooth_image_var : float, optional + Variance of gaussian filter to apply to `_seg_image`, by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold contour level to create surface mesh on, by default 0.5 + label_idx : int, optional + Label value / index to create mesh from, by default None + min_n_pixels : int, optional + Minimum number of continuous pixels to include segmentation island + in the surface mesh creation, by default None + + Raises + ------ + Exception + If the total number of pixels segmentated (`n_pixels_labelled`) is + < `min_n_pixels` then there is no object in the image. + Exception + If no `_seg_image` and no `label_idx` then we don't know what tissue to create the + surface mesh from. + Exception + If no `_seg_image` or `path_seg_image` then we have no image to create mesh from. + """ + # allow assigning label idx during mesh creation step. + if label_idx is not None: + self._label_idx = label_idx + + if self._seg_image is None: + self.read_seg_image() + + # Ensure the image has a certain number of pixels with the label of interest, otherwise there might be an issue. + if min_n_pixels is None: min_n_pixels = self._min_n_pixels + seg_view = sitk.GetArrayViewFromImage(self._seg_image) + n_pixels_labelled = sum(seg_view[seg_view == self._label_idx]) + + if n_pixels_labelled < min_n_pixels: + raise Exception('The mesh does not exist in this segmentation!, only {} pixels detected, threshold # is {}'.format(n_pixels_labelled, + marching_cubes_threshold)) + tmp_filename = ''.join(random.choice(string.ascii_lowercase) for i in range(10)) + '.nrrd' + self._mesh = create_surface_mesh(self._seg_image, + self._label_idx, + smooth_image_var, + loc_tmp_save='/tmp', + tmp_filename=tmp_filename, + mc_threshold=marching_cubes_threshold, + filter_binary_image=smooth_image + ) + safely_delete_tmp_file('/tmp', + tmp_filename) + + def save_mesh(self, + filepath): + """ + Save the surface mesh from this class to disk. + + Parameters + ---------- + filepath : str + Location & filename to save the surface mesh (vtk.vtkPolyData) to. + """ + io.write_vtk(self._mesh, filepath) + + def resample_surface(self, + subdivisions=2, + clusters=10000 + ): + """ + Resample a surface mesh using the ACVD algorithm: + Version used: + - https://github.com/pyvista/pyacvd + Original version w/ more references: + - https://github.com/valette/ACVD + + Parameters + ---------- + subdivisions : int, optional + Subdivide the mesh to have more points before clustering, by default 2 + Probably not necessary for very dense meshes. + clusters : int, optional + The number of clusters (points/vertices) to create during resampling + surafce, by default 10000 + - This is not exact, might have slight differences. + """ + self._mesh = resample_surface(self._mesh, subdivisions=subdivisions, clusters=clusters) + + def apply_transform_to_mesh(self, + transform=None, + transformer=None, + save_transform=True): + """ + Apply a transformation to the surface mesh. + + Parameters + ---------- + transform : vtk.vtkTransform, optional + Transformation to apply to mesh, by default None + transformer : vtk.vtkTransformFilter, optional + Can supply transformFilter directly, by default None + save_transform : bool, optional + Should transform be saved to list of applied transforms, by default True + + Raises + ------ + Exception + No `transform` or `transformer` supplied - have not transformation + to apply. + """ + if (transform is not None) & (transformer is None): + transformer = vtk.vtkTransformPolyDataFilter() + transformer.SetTransform(transform) + + elif (transform is None) & (transformer is not None): + transform = transformer.GetTransform() + + if transformer is not None: + transformer.SetInputData(self._mesh) + transformer.Update() + self._mesh = vtk_deep_copy(transformer.GetOutput()) + + if save_transform is True: + self._list_applied_transforms.append(transform) + + else: + raise Exception('No transform or transformer provided') + + def reverse_most_recent_transform(self): + """ + Function to undo the most recent transformation stored in self._list_applied_transforms + """ + transform = self._list_applied_transforms.pop() + transform.Inverse() + self.apply_transform_to_mesh(transform=transform, save_transform=False) + + def reverse_all_transforms(self): + """ + Function to iterate over all of the self._list_applied_transforms (in reverse order) and undo them. + """ + while len(self._list_applied_transforms) > 0: + self.reverse_most_recent_transform() + + def non_rigidly_register( + self, + other_mesh, + as_source=True, + apply_transform_to_mesh=True, + return_transformed_mesh=False, + **kwargs + ): + """ + Function to perform non rigid registration between this mesh and another mesh. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Other mesh to use in registration process + as_source : bool, optional + Should the current mesh (in this object) be the source or the target, by default True + apply_transform_to_mesh : bool, optional + If as_source is True should we apply transformation to internal mesh, by default True + return_transformed_mesh : bool, optional + Should we return the registered mesh, by default False + + Returns + ------- + _type_ + _description_ + """ + # Setup the source & target meshes based on `as_source`` + if as_source is True: + source = self._mesh + target = other_mesh + elif as_source is False: + source = other_mesh + target = self._mesh + + # Get registered mesh (source to target) + source_transformed_to_target = non_rigidly_register( + target_mesh=target, + source_mesh=source, + **kwargs + ) + + # If current mesh is source & apply_transform_to_mesh is true then replace current mesh. + if (as_source is True) & (apply_transform_to_mesh is True): + self._mesh = source_transformed_to_target + + # curent mesh is target, or is source & want to return mesh, then return it. + if (as_source is False) or ((as_source is True) & (return_transformed_mesh is True)): + return source_transformed_to_target + + def rigidly_register( + self, + other_mesh, + as_source=True, + apply_transform_to_mesh=True, + return_transformed_mesh=False, + return_transform=False, + max_n_iter=100, + n_landmarks=1000, + reg_mode='similarity' + + ): + """ + Function to perform rigid registration between this mesh and another mesh. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Other mesh to use in registration process + as_source : bool, optional + Should the current mesh (in this object) be the source or the target, by default True + apply_transform_to_mesh : bool, optional + If as_source is True should we apply transformation to internal mesh, by default True + return_transformed_mesh : bool, optional + Should we return the registered mesh, by default False + max_n_iter : int, optional + Maximum number of iterations to perform, by default 100 + n_landmarks : int, optional + Number of landmarks to use in registration, by default 1000 + reg_mode : str, optional + Mode of registration to use, by default 'similarity' (similarity, rigid, or affine) + + Returns + ------- + _type_ + _description_ + """ + + if (return_transform is True) & (return_transformed_mesh is True): + raise Exception('Cannot return both transformed mesh and transform') + + if type(other_mesh) in (pymskt.mesh.meshes.BoneMesh, pymskt.mesh.meshes.Mesh): + other_mesh = other_mesh.mesh + + # Setup the source & target meshes based on `as_source`` + if as_source is True: + source = self._mesh + target = other_mesh + elif as_source is False: + source = other_mesh + target = self._mesh + + icp_transform = get_icp_transform( + source=source, + target=target, + max_n_iter=max_n_iter, + n_landmarks=n_landmarks, + reg_mode=reg_mode + ) + + # If current mesh is source & apply_transform_to_mesh is true then replace current mesh. + if (as_source is True) & (apply_transform_to_mesh is True): + self.apply_transform_to_mesh(transform=icp_transform) + + if return_transformed_mesh is True: + return self._mesh + + elif return_transform is True: + return icp_transform + + # curent mesh is target, or is source & want to return mesh, then return it. + elif (as_source is False) & (return_transformed_mesh is True): + return apply_transform(source=source, transform=icp_transform) + + else: + raise Exception('Nothing to return from rigid registration.') + + def copy_scalars_from_other_mesh_to_currect( + self, + other_mesh, + new_scalars_name='scalars_from_other_mesh', + weighted_avg=True, # Use weighted average, otherwise guassian smooth transfer + n_closest=3, + sigma=1., + idx_coords_to_smooth_base=None, + idx_coords_to_smooth_other=None, + set_non_smoothed_scalars_to_zero=True, + ): + """ + Convenience function to enable easy transfer scalars from another mesh to the current. + Can use either a gaussian smoothing function, or transfer using nearest neighbours. + + ** This function requires that the `other_mesh` is non-rigidly registered to the surface + of the mesh inside of this class. Or rigidly registered but using the same anatomy that + VERY closely matches. Otherwise, the transfered scalars will be bad. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Mesh we want to copy + new_scalars_name : str, optional + What to name the scalars being transfered to this current mesh, by default 'scalars_from_other_mesh' + weighted_avg : bool, optional + Should we use `weighted average` or `gaussian smooth` methods for transfer, by default True + n_closest : int, optional + If `weighted_avg` True, the number of nearest neighbours to use, by default 3 + sigma : float, optional + If `weighted_avg` False, the standard deviation of gaussian kernel, by default 1. + idx_coords_to_smooth_base : list, optional + If `weighted_avg` False, list of indices from current mesh to use in transfer, by default None + idx_coords_to_smooth_other : list, optional + If `weighted_avg` False, list of indices from `other_mesh` to use in transfer, by default None + set_non_smoothed_scalars_to_zero : bool, optional + Should all other indices (not included in idx_coords_to_smooth_other) be set to 0, by default True + """ + if type(other_mesh) is Mesh: + other_mesh = other_mesh.mesh + elif type(other_mesh) is vtk.vtkPolyData: + pass + else: + raise TypeError(f'other_mesh must be type `pymskt.mesh.Mesh` or `vtk.vtkPolyData` and received: {type(other_mesh)}') + + if weighted_avg is True: + transferred_scalars = transfer_mesh_scalars_get_weighted_average_n_closest( + self._mesh, + other_mesh, + n=n_closest + ) + else: + transferred_scalars = smooth_scalars_from_second_mesh_onto_base( + self._mesh, + other_mesh, + sigma=sigma, + idx_coords_to_smooth_base=idx_coords_to_smooth_base, + idx_coords_to_smooth_second=idx_coords_to_smooth_other, + set_non_smoothed_scalars_to_zero=set_non_smoothed_scalars_to_zero + ) + if (new_scalars_name is None) & (weighted_avg is True): + if transferred_scalars.shape[1] > 1: + n_arrays = other_mesh.GetPointData().GetNumberOfArrays() + array_names = [other_mesh.GetPointData().GetArray(array_idx).GetName() for array_idx in range(n_arrays)] + for idx, array_name in enumerate(array_names): + vtk_transferred_scalars = numpy_to_vtk(transferred_scalars[:,idx]) + vtk_transferred_scalars.SetName(array_name) + self._mesh.GetPointData().AddArray(vtk_transferred_scalars) + return + + vtk_transferred_scalars = numpy_to_vtk(transferred_scalars) + vtk_transferred_scalars.SetName(new_scalars_name) + self._mesh.GetPointData().AddArray(vtk_transferred_scalars) + + @property + def seg_image(self): + """ + Return the `_seg_image` object + + Returns + ------- + SimpleITK.Image + Segmentation image used to build the surface mesh + """ + return self._seg_image + + @seg_image.setter + def seg_image(self, new_seg_image): + """ + Set the `_seg_image` of the class to be the inputted `new_seg_image`. + + Parameters + ---------- + new_seg_image : SimpleITK.Image + New image to use for creating surface mesh. This can be used to provide image to + class if it was not provided during `__init__` + """ + self._seg_image = new_seg_image + + @property + def mesh(self): + """ + Return the `_mesh` object + + Returns + ------- + vtk.vtkPolyData + The main mesh of this class. + """ + return self._mesh + + @mesh.setter + def mesh(self, new_mesh): + """ + Set the `_mesh` of the class to be the inputted `new_mesh` + + Parameters + ---------- + new_mesh : vtk.vtkPolyData + New mesh for this class - or a method to provide a mesh to the class + after `__init__` has already been run. + """ + self._mesh = new_mesh + + @property + def point_coords(self): + """ + Convenience function to return the vertices (point coordinates) for the surface mesh. + + Returns + ------- + numpy.ndarray + Mx3 numpy array containing the x/y/z position of each vertex of the mesh. + """ + return get_mesh_physical_point_coords(self._mesh) + + @point_coords.setter + def point_coords(self, new_point_coords): + """ + Convenience function to change/update the vertices/points locations + + Parameters + ---------- + new_point_coords : numpy.ndarray + n_points X 3 numpy array to replace exisiting point coordinate locations + This can be used to easily/quickly update the x/y/z position of a set of points on a surface mesh. + The `new_point_coords` must include the same number of points as the mesh contains. + """ + orig_point_coords = get_mesh_physical_point_coords(self._mesh) + if new_point_coords.shape == orig_point_coords.shape: + self._mesh.GetPoints().SetData(numpy_to_vtk(new_point_coords)) + + + @property + def path_seg_image(self): + """ + Convenience function to get the `path_seg_image` + + Returns + ------- + str + Path to the segmentation image + """ + return self._path_seg_image + + @path_seg_image.setter + def path_seg_image(self, new_path_seg_image): + """ + Convenience function to set the `path_seg_image` + + Parameters + ---------- + new_path_seg_image : str + String to where segmentation image that should be loaded is. + """ + self._path_seg_image = new_path_seg_image + + @property + def label_idx(self): + """ + Convenience function to get `label_idx` + + Returns + ------- + int + Integer indeicating the index/value of the tissues in `seg_image` associated with this mesh. + """ + return self._label_idx + + @label_idx.setter + def label_idx(self, new_label_idx): + """ + Convenience function to set `label_idx` + + Parameters + ---------- + new_label_idx : int + Integer indeicating the index/value of the tissues in `seg_image` associated with this mesh. + """ + self._label_idx = new_label_idx + + @property + def min_n_pixels(self): + """ + Convenience function to get the minimum number of pixels for a segmentation region to be created as a mesh. + + Returns + ------- + int + Minimum number of pixels needed to create a mesh. Less than this and it will be skipped / error raised. + """ + return self._min_n_pixels + + @min_n_pixels.setter + def min_n_pixels(self, new_min_n_pixels): + """ + Convenience function to set the minimum number of pixels for a segmentation region to be created as a mesh. + + Parameters + ---------- + new_min_n_pixels : int + Minimum number of pixels needed to create a mesh. Less than this and it will be skipped / error raised. + """ + self._min_n_pixels = new_min_n_pixels + + @property + def list_applied_transforms(self): + """ + Convenience function to get the list of transformations that have been applied to this mesh. + + Returns + ------- + list + List of vtk.vtkTransform objects that have been applied to the current mesh. + """ + return self._list_applied_transforms + + +class CartilageMesh(Mesh): + """ + Class to create, store, and process cartilage meshes + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + + + Attributes + ---------- + _mesh : vtk.vtkPolyData + Item passed from __init__, or created during life of class. + This is the main surface mesh of this class. + _seg_image : SimpleITK.Image + Segmentation image that can be used to create mesh. This is optional. + path_seg_image : str + Path to medical image (.nrrd) that can be loaded to create `_seg_image` + and then creat surface mesh `_mesh` + label_idx : int + Integer of anatomy to create surface mesh from `_seg_image` + min_n_pixels : int + Minimum number of pixels for an isolated island of a segmentation to be + retained + list_applied_transforms : list + A list of transformations applied to a surface mesh. + This list allows for undoing of most recent transform, or undoing + all of them by iterating over the list in reverse. + + Methods + ---------- + + """ + + def __init__(self, + mesh=None, + seg_image=None, + path_seg_image=None, + label_idx=None, + min_n_pixels=1000 + ): + super().__init__(mesh=mesh, + seg_image=seg_image, + path_seg_image=path_seg_image, + label_idx=label_idx, + min_n_pixels=min_n_pixels) + + +class BoneMesh(Mesh): + """ + Class to create, store, and process bone meshes + + Intention is that this class includes functions to process other data & assign it to the bone surface. + It might be possible that instead this class & a cartilage class or, this class and image data etc. are + provided to another function or class that does those analyses. + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + list_cartilage_meshes : list, optional + List object which contains 1+ `CartilageMesh` objects that wrap + a vtk.vtkPolyData surface mesh of cartilage, by default None + list_cartilage_labels : list, optional + List of `int` values that represent the different cartilage + regions of interest appropriate for a single bone, by default None + crop_percent : float, optional + Proportion value to crop long-axis of bone so it is proportional + to the width of the bone for standardization purposes, by default 1.0 + bone : str, optional + String indicating what bone is being analyzed so that cropping + can be applied appropriatey. {'femur', 'tibia'}, by default 'femur'. + Patella is not an option because we do not need to crop for the patella. + + + Attributes + ---------- + _mesh : vtk.vtkPolyData + Item passed from __init__, or created during life of class. + This is the main surface mesh of this class. + _seg_image : SimpleITK.Image + Segmentation image that can be used to create mesh. This is optional. + path_seg_image : str + Path to medical image (.nrrd) that can be loaded to create `_seg_image` + and then creat surface mesh `_mesh` + label_idx : int + Integer of anatomy to create surface mesh from `_seg_image` + min_n_pixels : int + Minimum number of pixels for an isolated island of a segmentation to be + retained + list_applied_transforms : list + A list of transformations applied to a surface mesh. + This list allows for undoing of most recent transform, or undoing + all of them by iterating over the list in reverse. + crop_percent : float + Percent of width to crop along long-axis of bone + bone : str + A string indicating what bone is being represented by this class. + list_cartilage_meshes : list + List of cartialge meshes assigned to this bone. + list_cartilage_labels : list + List of cartilage labels for the `_seg_image` that are associated + with this bone. + + Methods + ---------- + + """ + + def __init__(self, + mesh=None, + seg_image=None, + path_seg_image=None, + label_idx=None, + min_n_pixels=5000, + list_cartilage_meshes=None, + list_cartilage_labels=None, + crop_percent=None, + bone='femur', + ): + """ + Class initialization + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + list_cartilage_meshes : list, optional + List object which contains 1+ `CartilageMesh` objects that wrap + a vtk.vtkPolyData surface mesh of cartilage, by default None + list_cartilage_labels : list, optional + List of `int` values that represent the different cartilage + regions of interest appropriate for a single bone, by default None + crop_percent : float, optional + Proportion value to crop long-axis of bone so it is proportional + to the width of the bone for standardization purposes, by default 1.0 + bone : str, optional + String indicating what bone is being analyzed so that cropping + can be applied appropriatey. {'femur', 'tibia'}, by default 'femur'. + Patella is not an option because we do not need to crop for the patella. + """ + self._crop_percent = crop_percent + self._bone = bone + self._list_cartilage_meshes = list_cartilage_meshes + self._list_cartilage_labels = list_cartilage_labels + + super().__init__(mesh=mesh, + seg_image=seg_image, + path_seg_image=path_seg_image, + label_idx=label_idx, + min_n_pixels=min_n_pixels) + + + def create_mesh(self, + smooth_image=True, + smooth_image_var=0.3125 / 2, + marching_cubes_threshold=0.5, + label_idx=None, + min_n_pixels=None, + crop_percent=None + ): + """ + This is an extension of `Mesh.create_mesh` that enables cropping of bones. + Bones might need to be cropped (this isnt necessary for cartilage) + So, adding this functionality to the processing steps before the bone mesh is created. + + All functionality, except for that relevant to `crop_percent` is the same as: + `Mesh.create_mesh`. + + Create a surface mesh from the classes `_seg_image`. If `_seg_image` + does not exist, then read it in using `read_seg_image`. + + Parameters + ---------- + smooth_image : bool, optional + Should the `_seg_image` be gaussian filtered, by default True + smooth_image_var : float, optional + Variance of gaussian filter to apply to `_seg_image`, by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold contour level to create surface mesh on, by default 0.5 + label_idx : int, optional + Label value / index to create mesh from, by default None + min_n_pixels : int, optional + Minimum number of continuous pixels to include segmentation island + in the surface mesh creation, by default None + crop_percent : [type], optional + [description], by default None + + Raises + ------ + Exception + If cropping & bone is not femur or tibia, then raise an error. + Exception + If the total number of pixels segmentated (`n_pixels_labelled`) is + < `min_n_pixels` then there is no object in the image. + Exception + If no `_seg_image` and no `label_idx` then we don't know what tissue to create the + surface mesh from. + Exception + If no `_seg_image` or `path_seg_image` then we have no image to create mesh from. + """ + + if self._seg_image is None: + self.read_seg_image() + + # Bones might need to be cropped (this isnt necessary for cartilage) + # So, adding this functionality to the processing steps before the bone mesh is created + if crop_percent is not None: + self._crop_percent = crop_percent + if (self._crop_percent is not None) and (('femur' in self._bone) or ('tibia' in self._bone)): + if 'femur' in self._bone: + bone_crop_distal = True + elif 'tibia' in self._bone: + bone_crop_distal = False + else: + raise Exception('var bone should be "femur" or "tiba" got: {} instead'.format(self._bone)) + + self._seg_image = crop_bone_based_on_width(self._seg_image, + self._label_idx, + percent_width_to_crop_height=self._crop_percent, + bone_crop_distal=bone_crop_distal) + elif self._crop_percent is not None: + warnings.warn(f'Trying to crop bone, but {self._bone} specified and only bones `femur`', + 'or `tibia` currently supported for cropping. If using another bone, consider', + 'making a pull request. If cropping not desired, set `crop_percent=None`.' + ) + super().create_mesh(smooth_image=smooth_image, smooth_image_var=smooth_image_var, marching_cubes_threshold=marching_cubes_threshold, label_idx=label_idx, min_n_pixels=min_n_pixels) + + def create_cartilage_meshes(self, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5): + """ + Helper function to create the list of cartilage meshes from the list of cartilage + labels. + + Parameters + ---------- + image_smooth_var_cart : float + Variance to smooth cartilage segmentations before finding surface using continuous + marching cubes. + marching_cubes_threshold : float + Threshold value to create cartilage surface at from segmentation images. + + Notes + ----- + ?? Should this function just be everything inside the for loop and then that + function gets called somewhere else? + """ + + self._list_cartilage_meshes = [] + for cart_label_idx in self._list_cartilage_labels: + seg_array_view = sitk.GetArrayViewFromImage(self._seg_image) + n_pixels_with_cart = np.sum(seg_array_view == cart_label_idx) + if n_pixels_with_cart == 0: + warnings.warn( + f"Not analyzing cartilage for label {cart_label_idx} because it doesnt have any pixels!", + UserWarning + ) + else: + cart_mesh = CartilageMesh(seg_image=self._seg_image, + label_idx=cart_label_idx) + cart_mesh.create_mesh(smooth_image_var=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + self._list_cartilage_meshes.append(cart_mesh) + + + def calc_cartilage_thickness(self, + list_cartilage_labels=None, + list_cartilage_meshes=None, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25 + ): + """ + Using bone mesh (`_mesh`) and the list of cartilage meshes (`list_cartilage_meshes`) + calcualte the cartilage thickness for each node on the bone surface. + + Parameters + ---------- + list_cartilage_labels : list, optional + Cartilag labels to be used to create cartilage meshes (if they dont + exist), by default None + list_cartilage_meshes : list, optional + Cartilage meshes to be used for calculating cart thickness, by default None + image_smooth_var_cart : float, optional + Variance of gaussian filter to be applied to binary cartilage masks, + by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold to create bone surface at, by default 0.5 + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + + Raises + ------ + Exception + No cartilage available (either `list_cartilage_meshes` or `list_cartilage_labels`) + """ + # If new cartilage infor/labels are provided, then replace existing with these ones. + if list_cartilage_meshes is not None: self._list_cartilage_meshes = list_cartilage_meshes + if list_cartilage_labels is not None: self._list_cartilage_labels = list_cartilage_labels + + # If no cartilage stuff provided, then cant do this function - raise exception. + if (self._list_cartilage_meshes is None) & (self._list_cartilage_labels is None): + raise Exception('No cartilage meshes or list of cartilage labels are provided! - These can be provided either to the class function `calc_cartilage_thickness` directly, or can be specified at the time of instantiating the `BoneMesh` class.') + + # if cartilage meshes don't exist yet, then make them. + if self._list_cartilage_meshes is None: + self.create_cartilage_meshes(image_smooth_var_cart=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + + # pre-allocate empty thicknesses so that as labels are iterated over, they can all be appended to the same bone. + thicknesses = np.zeros(self._mesh.GetNumberOfPoints()) + + # iterate over meshes and add their thicknesses to the thicknesses list. + for cart_mesh in self._list_cartilage_meshes: + node_data = get_cartilage_properties_at_points(self._mesh, + cart_mesh._mesh, + t2_vtk_image=None, + # seg_vtk_image=vtk_seg if assign_seg_label_to_bone is True else None, + seg_vtk_image=None, + ray_cast_length=ray_cast_length, + percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + ) + thicknesses += node_data + + # Assign the thickness scalars to the bone mesh surface. + thickness_scalars = numpy_to_vtk(thicknesses) + thickness_scalars.SetName('thickness (mm)') + self._mesh.GetPointData().SetScalars(thickness_scalars) + + def assign_cartilage_regions(self, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25): + """ + Assign cartilage regions to the bone surface (e.g. medial/lateral tibial cartilage) + - Can also be used for femur sub-regions (anterior, medial weight-bearing, etc.) + + Parameters + ---------- + image_smooth_var_cart : float, optional + Variance of gaussian filter to be applied to binary cartilage masks, + by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold to create bone surface at, by default 0.5 + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + """ + tmp_filename = ''.join(random.choice(string.ascii_lowercase) for i in range(10)) + '.nrrd' + path_save_tmp_file = os.path.join('/tmp', tmp_filename) + # if self._bone == 'femur': + # new_seg_image = qc.get_knee_segmentation_with_femur_subregions(seg_image, + # fem_cart_label_idx=1) + # sitk.WriteImage(new_seg_image, path_save_tmp_file) + # else: + sitk.WriteImage(self._seg_image, path_save_tmp_file) + vtk_seg_reader = read_nrrd(path_save_tmp_file, + set_origin_zero=True + ) + vtk_seg = vtk_seg_reader.GetOutput() + + seg_transformer = SitkVtkTransformer(self._seg_image) + + # Delete tmp files + safely_delete_tmp_file('/tmp', + tmp_filename) + + self.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform()) + labels = np.zeros(self._mesh.GetNumberOfPoints(), dtype=np.int) + + # if cartilage meshes don't exist yet, then make them. + if self._list_cartilage_meshes is None: + self.create_cartilage_meshes(image_smooth_var_cart=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + + # iterate over meshes and add their label (region) + for cart_mesh in self._list_cartilage_meshes: + cart_mesh.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform()) + node_data = get_cartilage_properties_at_points(self._mesh, + cart_mesh._mesh, + t2_vtk_image=None, + seg_vtk_image=vtk_seg, + ray_cast_length=ray_cast_length, + percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + ) + labels += node_data[1] + cart_mesh.reverse_all_transforms() + + # Assign the label (region) scalars to the bone mesh surface. + label_scalars = numpy_to_vtk(labels) + label_scalars.SetName('labels') + self._mesh.GetPointData().AddArray(label_scalars) + + self.reverse_all_transforms() + + def calc_cartilage_t2(self, + path_t2_nrrd, + path_seg_to_t2_transform=None, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25): + """ + Apply cartilage T2 values to bone surface. + + Parameters + ---------- + path_t2_nrrd : str + Path to nrrd image of T2 map to load / use. + path_seg_to_t2_transform : str, optional + Path to a transform file to be used for aligning T2 map with segmentations, + by default None + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + """ + print('Not yet implemented') + # if self._list_cartilage_meshes is None: + # raise('Should calculate cartialge thickness before getting T2') + # # ALTERNATIVELY - COULD ALLOW PASSING OF CARTILAGE REGIONS IN HERE + # # THOUGH, DOES THAT JUST COMPLICATE THINGS? + + # if path_seg_transform is not None: + # # this is in case there is a transformation needed to align the segmentation with the + # # underlying T2 image + # seg_transform = sitk.ReadTransform(path_seg_transform) + # seg_image = apply_transform_retain_array(self._seg_image, + # seg_transform, + # interpolator=sitk.sitkNearestNeighbor) + + + # versor = get_versor_from_transform(seg_transform) + # center_transform, rotate_transform, translate_transform = break_versor_into_center_rotate_translate_transforms(versor) + # # first apply negative of center of rotation to mesh + # self._mesh.apply_transform_to_mesh(transform=center_transform.GetInverse()) + # # now apply the transform (rotation then translation) + # self._mesh.apply_transform_to_mesh(transform=rotate_transform.GetInverse()) + # self._mesh.apply_transform_to_mesh(transform=translate_transform.GetInverse()) + # #then undo the center of rotation + # self._mesh.apply_transform_to_mesh(transform=center_transform) + + # # Read t2 map (vtk format) + # vtk_t2map_reader = read_nrrd(path_t2_nrrd, + # set_origin_zero=True) + # vtk_t2map = vtk_t2map_reader.GetOutput() + # sitk_t2map = sitk.ReadImage(path_t2_nrrd) + # t2_transformer = SitkVtkTransformer(sitk_t2map) + + # self._mesh.apply_transform_to_mesh(transform=t2_transformer.get_inverse_transform()) + + # t2 = np.zeros(self._mesh.GetNumberOfPoints()) + # # iterate over meshes and add their t2 to the t2 list. + # for cart_mesh in self._list_cartilage_meshes: + # if path_seg_to_t2_transform is not None: + # # first apply negative of center of rotation to mesh + # cart_mesh.apply_transform_to_mesh(transform=center_transform.GetInverse()) + # # now apply the transform (rotation then translation) + # cart_mesh.apply_transform_to_mesh(transform=rotate_transform.GetInverse()) + # cart_mesh.apply_transform_to_mesh(transform=translate_transform.GetInverse()) + # #then undo the center of rotation + # cart_mesh.apply_transform_to_mesh(transform=center_transform) + + # cart_mesh.apply_transform_to_mesh(transform=t2_transformer.get_inverse_transform()) + # _, t2_data = get_cartilage_properties_at_points(self._mesh, + # cart_mesh._mesh, + # t2_vtk_image=vtk_t2map, + # ray_cast_length=ray_cast_length, + # percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + # ) + # t2 += t2_data + # cart_mesh.reverse_all_transforms() + print('NOT DONE!!!') + + + + def smooth_surface_scalars(self, + smooth_only_cartilage=True, + scalar_sigma=1.6986436005760381, # This is a FWHM = 4 + scalar_array_name='thickness (mm)', + scalar_array_idx=None, + ): + + """ + Function to smooth the scalars with name `scalar_array_name` on the bone surface. + + Parameters + ---------- + smooth_only_cartilage : bool, optional + Should we only smooth where there is cartialge & ignore everywhere else, by default True + scalar_sigma : float, optional + Smoothing sigma (standard deviation or sqrt(variance)) for gaussian filter, by default 1.6986436005760381 + default is based on a Full Width Half Maximum (FWHM) of 4mm. + scalar_array_name : str + Name of scalar array to smooth, default 'thickness (mm)'. + scalar_array_idx : int, optional + Index of the scalar array to smooth (alternative to using `scalar_array_name`) , by default None + """ + if smooth_only_cartilage is True: + loc_cartilage = np.where(vtk_to_numpy(self._mesh.GetPointData().GetArray('thickness (mm)')) > 0.01)[0] + else: + loc_cartilage = None + self._mesh = gaussian_smooth_surface_scalars(self._mesh, + sigma=scalar_sigma, + idx_coords_to_smooth=loc_cartilage, + array_name=scalar_array_name, + array_idx=scalar_array_idx) + + @property + def list_cartilage_meshes(self): + """ + Convenience function to get the list of cartilage meshes + + Returns + ------- + list + A list of `CartilageMesh` objects associated with this bone + """ + return self._list_cartilage_meshes + + @list_cartilage_meshes.setter + def list_cartilage_meshes(self, new_list_cartilage_meshes): + """ + Convenience function to set the list of cartilage meshes + + Parameters + ---------- + new_list_cartilage_meshes : list + A list of `CartilageMesh` objects associated with this bone + """ + if type(new_list_cartilage_meshes) is list: + for mesh in new_list_cartilage_meshes: + if type(mesh) != pymskt.mesh.meshes.CartilageMesh: + raise TypeError('Item in `list_cartilage_meshes` is not a `CartilageMesh`') + elif type(new_list_cartilage_meshes) is pymskt.mesh.meshes.CartilageMesh: + new_list_cartilage_meshes = [new_list_cartilage_meshes,] + self._list_cartilage_meshes = new_list_cartilage_meshes + + @property + def list_cartilage_labels(self): + """ + Convenience function to get the list of labels for cartilage tissues associated + with this bone. + + Returns + ------- + list + list of `int`s for the cartilage tissues associated with this bone. + """ + return self._list_cartilage_labels + + @list_cartilage_labels.setter + def list_cartilage_labels(self, new_list_cartilage_labels): + """ + Convenience function to set the list of labels for cartilage tissues associated + with this bone + + Parameters + ---------- + new_list_cartilage_labels : list + list of `int`s for the cartilage tissues associated with this bone. + """ + if type(new_list_cartilage_labels) == list: + for label in new_list_cartilage_labels: + if type(label) != int: + raise TypeError(f'Item in `list_cartilage_labels` is not a `int` - got {type(label)}') + elif type(new_list_cartilage_labels) == int: + new_list_cartilage_labels = [new_list_cartilage_labels,] + self._list_cartilage_labels = new_list_cartilage_labels + + @property + def crop_percent(self): + """ + Convenience function to get the value that `crop_percent` is set to. + + Returns + ------- + float + Floating point > 0.0 indicating how much of the length of the bone should be included + when cropping - expressed as a proportion of the width. + """ + return self._crop_percent + + @crop_percent.setter + def crop_percent(self, new_crop_percent): + """ + Convenience function to set the value that `crop_percent` is set to. + + Parameters + ---------- + new_crop_percent : float + Floating point > 0.0 indicating how much of the length of the bone should be included + when cropping - expressed as a proportion of the width. + """ + if type(new_crop_percent) != float: + raise TypeError(f'New `crop_percent` provided is type {type(new_crop_percent)} - expected `float`') + self._crop_percent = new_crop_percent + + @property + def bone(self): + """ + Convenience function to get the name of the bone in this object. + + Returns + ------- + str + Name of the bone in this object - used to help identify how to crop the bone. + """ + return self._bone + + @bone.setter + def bone(self, new_bone): + """ + Convenience function to set the name of the bone in this object. + + Parameters + ---------- + new_bone : str + Name of the bone in this object - used to help identify how to crop the bone. + """ + if type(new_bone) != str: + raise TypeError(f'New bone provided is type {type(new_bone)} - expected `str`') + self._bone = new_bone + + + + </code></pre> +</details> +</section> +<section> +</section> +<section> +</section> +<section> +</section> +<section> +<h2 class="section-title" id="header-classes">Classes</h2> +<dl> +<dt id="pymskt.mesh.meshes.BoneMesh"><code class="flex name class"> +<span>class <span class="ident">BoneMesh</span></span> +<span>(</span><span>mesh=None, seg_image=None, path_seg_image=None, label_idx=None, min_n_pixels=5000, list_cartilage_meshes=None, list_cartilage_labels=None, crop_percent=None, bone='femur')</span> +</code></dt> +<dd> +<div class="desc"><p>Class to create, store, and process bone meshes</p> +<p>Intention is that this class includes functions to process other data & assign it to the bone surface. +It might be possible that instead this class & a cartilage class or, this class and image data etc. are +provided to another function or class that does those analyses.</p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code>, optional</dt> +<dd>vtkPolyData object that is basis of surface mesh, by default None</dd> +<dt><strong><code>seg_image</code></strong> : <code>SimpleITK.Image</code>, optional</dt> +<dd>Segmentation image that can be used to create surface mesh - used +instead of mesh, by default None</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code>, optional</dt> +<dd>Path to a medical image (.nrrd) to load and create mesh from, +by default None</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label of anatomy of interest, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>All islands smaller than this size are dropped, by default 5000</dd> +<dt><strong><code>list_cartilage_meshes</code></strong> : <code>list</code>, optional</dt> +<dd>List object which contains 1+ <code><a title="pymskt.mesh.meshes.CartilageMesh" href="#pymskt.mesh.meshes.CartilageMesh">CartilageMesh</a></code> objects that wrap +a vtk.vtkPolyData surface mesh of cartilage, by default None</dd> +<dt><strong><code>list_cartilage_labels</code></strong> : <code>list</code>, optional</dt> +<dd>List of <code>int</code> values that represent the different cartilage +regions of interest appropriate for a single bone, by default None</dd> +<dt><strong><code>crop_percent</code></strong> : <code>float</code>, optional</dt> +<dd>Proportion value to crop long-axis of bone so it is proportional +to the width of the bone for standardization purposes, by default 1.0</dd> +<dt><strong><code>bone</code></strong> : <code>str</code>, optional</dt> +<dd>String indicating what bone is being analyzed so that cropping +can be applied appropriatey. {'femur', 'tibia'}, by default 'femur'. +Patella is not an option because we do not need to crop for the patella.</dd> +</dl> +<h2 id="attributes">Attributes</h2> +<dl> +<dt><strong><code>_mesh</code></strong> : <code>vtk.vtkPolyData</code></dt> +<dd>Item passed from <strong>init</strong>, or created during life of class. +This is the main surface mesh of this class.</dd> +<dt><strong><code>_seg_image</code></strong> : <code>SimpleITK.Image</code></dt> +<dd>Segmentation image that can be used to create mesh. This is optional.</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code></dt> +<dd>Path to medical image (.nrrd) that can be loaded to create <code>_seg_image</code> +and then creat surface mesh <code>_mesh</code></dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code></dt> +<dd>Integer of anatomy to create surface mesh from <code>_seg_image</code></dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code></dt> +<dd>Minimum number of pixels for an isolated island of a segmentation to be +retained</dd> +<dt><strong><code>list_applied_transforms</code></strong> : <code>list</code></dt> +<dd>A list of transformations applied to a surface mesh. +This list allows for undoing of most recent transform, or undoing +all of them by iterating over the list in reverse.</dd> +<dt><strong><code>crop_percent</code></strong> : <code>float</code></dt> +<dd>Percent of width to crop along long-axis of bone</dd> +<dt><strong><code>bone</code></strong> : <code>str</code></dt> +<dd>A string indicating what bone is being represented by this class.</dd> +<dt><strong><code>list_cartilage_meshes</code></strong> : <code>list</code></dt> +<dd>List of cartialge meshes assigned to this bone.</dd> +<dt><strong><code>list_cartilage_labels</code></strong> : <code>list</code></dt> +<dd>List of cartilage labels for the <code>_seg_image</code> that are associated +with this bone.</dd> +</dl> +<h2 id="methods">Methods</h2> +<p>Class initialization</p> +<h2 id="parameters_1">Parameters</h2> +<dl> +<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code>, optional</dt> +<dd>vtkPolyData object that is basis of surface mesh, by default None</dd> +<dt><strong><code>seg_image</code></strong> : <code>SimpleITK.Image</code>, optional</dt> +<dd>Segmentation image that can be used to create surface mesh - used +instead of mesh, by default None</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code>, optional</dt> +<dd>Path to a medical image (.nrrd) to load and create mesh from, +by default None</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label of anatomy of interest, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>All islands smaller than this size are dropped, by default 5000</dd> +<dt><strong><code>list_cartilage_meshes</code></strong> : <code>list</code>, optional</dt> +<dd>List object which contains 1+ <code><a title="pymskt.mesh.meshes.CartilageMesh" href="#pymskt.mesh.meshes.CartilageMesh">CartilageMesh</a></code> objects that wrap +a vtk.vtkPolyData surface mesh of cartilage, by default None</dd> +<dt><strong><code>list_cartilage_labels</code></strong> : <code>list</code>, optional</dt> +<dd>List of <code>int</code> values that represent the different cartilage +regions of interest appropriate for a single bone, by default None</dd> +<dt><strong><code>crop_percent</code></strong> : <code>float</code>, optional</dt> +<dd>Proportion value to crop long-axis of bone so it is proportional +to the width of the bone for standardization purposes, by default 1.0</dd> +<dt><strong><code>bone</code></strong> : <code>str</code>, optional</dt> +<dd>String indicating what bone is being analyzed so that cropping +can be applied appropriatey. {'femur', 'tibia'}, by default 'femur'. +Patella is not an option because we do not need to crop for the patella.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">class BoneMesh(Mesh): + """ + Class to create, store, and process bone meshes + + Intention is that this class includes functions to process other data & assign it to the bone surface. + It might be possible that instead this class & a cartilage class or, this class and image data etc. are + provided to another function or class that does those analyses. + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + list_cartilage_meshes : list, optional + List object which contains 1+ `CartilageMesh` objects that wrap + a vtk.vtkPolyData surface mesh of cartilage, by default None + list_cartilage_labels : list, optional + List of `int` values that represent the different cartilage + regions of interest appropriate for a single bone, by default None + crop_percent : float, optional + Proportion value to crop long-axis of bone so it is proportional + to the width of the bone for standardization purposes, by default 1.0 + bone : str, optional + String indicating what bone is being analyzed so that cropping + can be applied appropriatey. {'femur', 'tibia'}, by default 'femur'. + Patella is not an option because we do not need to crop for the patella. + + + Attributes + ---------- + _mesh : vtk.vtkPolyData + Item passed from __init__, or created during life of class. + This is the main surface mesh of this class. + _seg_image : SimpleITK.Image + Segmentation image that can be used to create mesh. This is optional. + path_seg_image : str + Path to medical image (.nrrd) that can be loaded to create `_seg_image` + and then creat surface mesh `_mesh` + label_idx : int + Integer of anatomy to create surface mesh from `_seg_image` + min_n_pixels : int + Minimum number of pixels for an isolated island of a segmentation to be + retained + list_applied_transforms : list + A list of transformations applied to a surface mesh. + This list allows for undoing of most recent transform, or undoing + all of them by iterating over the list in reverse. + crop_percent : float + Percent of width to crop along long-axis of bone + bone : str + A string indicating what bone is being represented by this class. + list_cartilage_meshes : list + List of cartialge meshes assigned to this bone. + list_cartilage_labels : list + List of cartilage labels for the `_seg_image` that are associated + with this bone. + + Methods + ---------- + + """ + + def __init__(self, + mesh=None, + seg_image=None, + path_seg_image=None, + label_idx=None, + min_n_pixels=5000, + list_cartilage_meshes=None, + list_cartilage_labels=None, + crop_percent=None, + bone='femur', + ): + """ + Class initialization + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + list_cartilage_meshes : list, optional + List object which contains 1+ `CartilageMesh` objects that wrap + a vtk.vtkPolyData surface mesh of cartilage, by default None + list_cartilage_labels : list, optional + List of `int` values that represent the different cartilage + regions of interest appropriate for a single bone, by default None + crop_percent : float, optional + Proportion value to crop long-axis of bone so it is proportional + to the width of the bone for standardization purposes, by default 1.0 + bone : str, optional + String indicating what bone is being analyzed so that cropping + can be applied appropriatey. {'femur', 'tibia'}, by default 'femur'. + Patella is not an option because we do not need to crop for the patella. + """ + self._crop_percent = crop_percent + self._bone = bone + self._list_cartilage_meshes = list_cartilage_meshes + self._list_cartilage_labels = list_cartilage_labels + + super().__init__(mesh=mesh, + seg_image=seg_image, + path_seg_image=path_seg_image, + label_idx=label_idx, + min_n_pixels=min_n_pixels) + + + def create_mesh(self, + smooth_image=True, + smooth_image_var=0.3125 / 2, + marching_cubes_threshold=0.5, + label_idx=None, + min_n_pixels=None, + crop_percent=None + ): + """ + This is an extension of `Mesh.create_mesh` that enables cropping of bones. + Bones might need to be cropped (this isnt necessary for cartilage) + So, adding this functionality to the processing steps before the bone mesh is created. + + All functionality, except for that relevant to `crop_percent` is the same as: + `Mesh.create_mesh`. + + Create a surface mesh from the classes `_seg_image`. If `_seg_image` + does not exist, then read it in using `read_seg_image`. + + Parameters + ---------- + smooth_image : bool, optional + Should the `_seg_image` be gaussian filtered, by default True + smooth_image_var : float, optional + Variance of gaussian filter to apply to `_seg_image`, by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold contour level to create surface mesh on, by default 0.5 + label_idx : int, optional + Label value / index to create mesh from, by default None + min_n_pixels : int, optional + Minimum number of continuous pixels to include segmentation island + in the surface mesh creation, by default None + crop_percent : [type], optional + [description], by default None + + Raises + ------ + Exception + If cropping & bone is not femur or tibia, then raise an error. + Exception + If the total number of pixels segmentated (`n_pixels_labelled`) is + < `min_n_pixels` then there is no object in the image. + Exception + If no `_seg_image` and no `label_idx` then we don't know what tissue to create the + surface mesh from. + Exception + If no `_seg_image` or `path_seg_image` then we have no image to create mesh from. + """ + + if self._seg_image is None: + self.read_seg_image() + + # Bones might need to be cropped (this isnt necessary for cartilage) + # So, adding this functionality to the processing steps before the bone mesh is created + if crop_percent is not None: + self._crop_percent = crop_percent + if (self._crop_percent is not None) and (('femur' in self._bone) or ('tibia' in self._bone)): + if 'femur' in self._bone: + bone_crop_distal = True + elif 'tibia' in self._bone: + bone_crop_distal = False + else: + raise Exception('var bone should be "femur" or "tiba" got: {} instead'.format(self._bone)) + + self._seg_image = crop_bone_based_on_width(self._seg_image, + self._label_idx, + percent_width_to_crop_height=self._crop_percent, + bone_crop_distal=bone_crop_distal) + elif self._crop_percent is not None: + warnings.warn(f'Trying to crop bone, but {self._bone} specified and only bones `femur`', + 'or `tibia` currently supported for cropping. If using another bone, consider', + 'making a pull request. If cropping not desired, set `crop_percent=None`.' + ) + super().create_mesh(smooth_image=smooth_image, smooth_image_var=smooth_image_var, marching_cubes_threshold=marching_cubes_threshold, label_idx=label_idx, min_n_pixels=min_n_pixels) + + def create_cartilage_meshes(self, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5): + """ + Helper function to create the list of cartilage meshes from the list of cartilage + labels. + + Parameters + ---------- + image_smooth_var_cart : float + Variance to smooth cartilage segmentations before finding surface using continuous + marching cubes. + marching_cubes_threshold : float + Threshold value to create cartilage surface at from segmentation images. + + Notes + ----- + ?? Should this function just be everything inside the for loop and then that + function gets called somewhere else? + """ + + self._list_cartilage_meshes = [] + for cart_label_idx in self._list_cartilage_labels: + seg_array_view = sitk.GetArrayViewFromImage(self._seg_image) + n_pixels_with_cart = np.sum(seg_array_view == cart_label_idx) + if n_pixels_with_cart == 0: + warnings.warn( + f"Not analyzing cartilage for label {cart_label_idx} because it doesnt have any pixels!", + UserWarning + ) + else: + cart_mesh = CartilageMesh(seg_image=self._seg_image, + label_idx=cart_label_idx) + cart_mesh.create_mesh(smooth_image_var=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + self._list_cartilage_meshes.append(cart_mesh) + + + def calc_cartilage_thickness(self, + list_cartilage_labels=None, + list_cartilage_meshes=None, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25 + ): + """ + Using bone mesh (`_mesh`) and the list of cartilage meshes (`list_cartilage_meshes`) + calcualte the cartilage thickness for each node on the bone surface. + + Parameters + ---------- + list_cartilage_labels : list, optional + Cartilag labels to be used to create cartilage meshes (if they dont + exist), by default None + list_cartilage_meshes : list, optional + Cartilage meshes to be used for calculating cart thickness, by default None + image_smooth_var_cart : float, optional + Variance of gaussian filter to be applied to binary cartilage masks, + by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold to create bone surface at, by default 0.5 + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + + Raises + ------ + Exception + No cartilage available (either `list_cartilage_meshes` or `list_cartilage_labels`) + """ + # If new cartilage infor/labels are provided, then replace existing with these ones. + if list_cartilage_meshes is not None: self._list_cartilage_meshes = list_cartilage_meshes + if list_cartilage_labels is not None: self._list_cartilage_labels = list_cartilage_labels + + # If no cartilage stuff provided, then cant do this function - raise exception. + if (self._list_cartilage_meshes is None) & (self._list_cartilage_labels is None): + raise Exception('No cartilage meshes or list of cartilage labels are provided! - These can be provided either to the class function `calc_cartilage_thickness` directly, or can be specified at the time of instantiating the `BoneMesh` class.') + + # if cartilage meshes don't exist yet, then make them. + if self._list_cartilage_meshes is None: + self.create_cartilage_meshes(image_smooth_var_cart=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + + # pre-allocate empty thicknesses so that as labels are iterated over, they can all be appended to the same bone. + thicknesses = np.zeros(self._mesh.GetNumberOfPoints()) + + # iterate over meshes and add their thicknesses to the thicknesses list. + for cart_mesh in self._list_cartilage_meshes: + node_data = get_cartilage_properties_at_points(self._mesh, + cart_mesh._mesh, + t2_vtk_image=None, + # seg_vtk_image=vtk_seg if assign_seg_label_to_bone is True else None, + seg_vtk_image=None, + ray_cast_length=ray_cast_length, + percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + ) + thicknesses += node_data + + # Assign the thickness scalars to the bone mesh surface. + thickness_scalars = numpy_to_vtk(thicknesses) + thickness_scalars.SetName('thickness (mm)') + self._mesh.GetPointData().SetScalars(thickness_scalars) + + def assign_cartilage_regions(self, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25): + """ + Assign cartilage regions to the bone surface (e.g. medial/lateral tibial cartilage) + - Can also be used for femur sub-regions (anterior, medial weight-bearing, etc.) + + Parameters + ---------- + image_smooth_var_cart : float, optional + Variance of gaussian filter to be applied to binary cartilage masks, + by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold to create bone surface at, by default 0.5 + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + """ + tmp_filename = ''.join(random.choice(string.ascii_lowercase) for i in range(10)) + '.nrrd' + path_save_tmp_file = os.path.join('/tmp', tmp_filename) + # if self._bone == 'femur': + # new_seg_image = qc.get_knee_segmentation_with_femur_subregions(seg_image, + # fem_cart_label_idx=1) + # sitk.WriteImage(new_seg_image, path_save_tmp_file) + # else: + sitk.WriteImage(self._seg_image, path_save_tmp_file) + vtk_seg_reader = read_nrrd(path_save_tmp_file, + set_origin_zero=True + ) + vtk_seg = vtk_seg_reader.GetOutput() + + seg_transformer = SitkVtkTransformer(self._seg_image) + + # Delete tmp files + safely_delete_tmp_file('/tmp', + tmp_filename) + + self.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform()) + labels = np.zeros(self._mesh.GetNumberOfPoints(), dtype=np.int) + + # if cartilage meshes don't exist yet, then make them. + if self._list_cartilage_meshes is None: + self.create_cartilage_meshes(image_smooth_var_cart=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + + # iterate over meshes and add their label (region) + for cart_mesh in self._list_cartilage_meshes: + cart_mesh.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform()) + node_data = get_cartilage_properties_at_points(self._mesh, + cart_mesh._mesh, + t2_vtk_image=None, + seg_vtk_image=vtk_seg, + ray_cast_length=ray_cast_length, + percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + ) + labels += node_data[1] + cart_mesh.reverse_all_transforms() + + # Assign the label (region) scalars to the bone mesh surface. + label_scalars = numpy_to_vtk(labels) + label_scalars.SetName('labels') + self._mesh.GetPointData().AddArray(label_scalars) + + self.reverse_all_transforms() + + def calc_cartilage_t2(self, + path_t2_nrrd, + path_seg_to_t2_transform=None, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25): + """ + Apply cartilage T2 values to bone surface. + + Parameters + ---------- + path_t2_nrrd : str + Path to nrrd image of T2 map to load / use. + path_seg_to_t2_transform : str, optional + Path to a transform file to be used for aligning T2 map with segmentations, + by default None + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + """ + print('Not yet implemented') + # if self._list_cartilage_meshes is None: + # raise('Should calculate cartialge thickness before getting T2') + # # ALTERNATIVELY - COULD ALLOW PASSING OF CARTILAGE REGIONS IN HERE + # # THOUGH, DOES THAT JUST COMPLICATE THINGS? + + # if path_seg_transform is not None: + # # this is in case there is a transformation needed to align the segmentation with the + # # underlying T2 image + # seg_transform = sitk.ReadTransform(path_seg_transform) + # seg_image = apply_transform_retain_array(self._seg_image, + # seg_transform, + # interpolator=sitk.sitkNearestNeighbor) + + + # versor = get_versor_from_transform(seg_transform) + # center_transform, rotate_transform, translate_transform = break_versor_into_center_rotate_translate_transforms(versor) + # # first apply negative of center of rotation to mesh + # self._mesh.apply_transform_to_mesh(transform=center_transform.GetInverse()) + # # now apply the transform (rotation then translation) + # self._mesh.apply_transform_to_mesh(transform=rotate_transform.GetInverse()) + # self._mesh.apply_transform_to_mesh(transform=translate_transform.GetInverse()) + # #then undo the center of rotation + # self._mesh.apply_transform_to_mesh(transform=center_transform) + + # # Read t2 map (vtk format) + # vtk_t2map_reader = read_nrrd(path_t2_nrrd, + # set_origin_zero=True) + # vtk_t2map = vtk_t2map_reader.GetOutput() + # sitk_t2map = sitk.ReadImage(path_t2_nrrd) + # t2_transformer = SitkVtkTransformer(sitk_t2map) + + # self._mesh.apply_transform_to_mesh(transform=t2_transformer.get_inverse_transform()) + + # t2 = np.zeros(self._mesh.GetNumberOfPoints()) + # # iterate over meshes and add their t2 to the t2 list. + # for cart_mesh in self._list_cartilage_meshes: + # if path_seg_to_t2_transform is not None: + # # first apply negative of center of rotation to mesh + # cart_mesh.apply_transform_to_mesh(transform=center_transform.GetInverse()) + # # now apply the transform (rotation then translation) + # cart_mesh.apply_transform_to_mesh(transform=rotate_transform.GetInverse()) + # cart_mesh.apply_transform_to_mesh(transform=translate_transform.GetInverse()) + # #then undo the center of rotation + # cart_mesh.apply_transform_to_mesh(transform=center_transform) + + # cart_mesh.apply_transform_to_mesh(transform=t2_transformer.get_inverse_transform()) + # _, t2_data = get_cartilage_properties_at_points(self._mesh, + # cart_mesh._mesh, + # t2_vtk_image=vtk_t2map, + # ray_cast_length=ray_cast_length, + # percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + # ) + # t2 += t2_data + # cart_mesh.reverse_all_transforms() + print('NOT DONE!!!') + + + + def smooth_surface_scalars(self, + smooth_only_cartilage=True, + scalar_sigma=1.6986436005760381, # This is a FWHM = 4 + scalar_array_name='thickness (mm)', + scalar_array_idx=None, + ): + + """ + Function to smooth the scalars with name `scalar_array_name` on the bone surface. + + Parameters + ---------- + smooth_only_cartilage : bool, optional + Should we only smooth where there is cartialge & ignore everywhere else, by default True + scalar_sigma : float, optional + Smoothing sigma (standard deviation or sqrt(variance)) for gaussian filter, by default 1.6986436005760381 + default is based on a Full Width Half Maximum (FWHM) of 4mm. + scalar_array_name : str + Name of scalar array to smooth, default 'thickness (mm)'. + scalar_array_idx : int, optional + Index of the scalar array to smooth (alternative to using `scalar_array_name`) , by default None + """ + if smooth_only_cartilage is True: + loc_cartilage = np.where(vtk_to_numpy(self._mesh.GetPointData().GetArray('thickness (mm)')) > 0.01)[0] + else: + loc_cartilage = None + self._mesh = gaussian_smooth_surface_scalars(self._mesh, + sigma=scalar_sigma, + idx_coords_to_smooth=loc_cartilage, + array_name=scalar_array_name, + array_idx=scalar_array_idx) + + @property + def list_cartilage_meshes(self): + """ + Convenience function to get the list of cartilage meshes + + Returns + ------- + list + A list of `CartilageMesh` objects associated with this bone + """ + return self._list_cartilage_meshes + + @list_cartilage_meshes.setter + def list_cartilage_meshes(self, new_list_cartilage_meshes): + """ + Convenience function to set the list of cartilage meshes + + Parameters + ---------- + new_list_cartilage_meshes : list + A list of `CartilageMesh` objects associated with this bone + """ + if type(new_list_cartilage_meshes) is list: + for mesh in new_list_cartilage_meshes: + if type(mesh) != pymskt.mesh.meshes.CartilageMesh: + raise TypeError('Item in `list_cartilage_meshes` is not a `CartilageMesh`') + elif type(new_list_cartilage_meshes) is pymskt.mesh.meshes.CartilageMesh: + new_list_cartilage_meshes = [new_list_cartilage_meshes,] + self._list_cartilage_meshes = new_list_cartilage_meshes + + @property + def list_cartilage_labels(self): + """ + Convenience function to get the list of labels for cartilage tissues associated + with this bone. + + Returns + ------- + list + list of `int`s for the cartilage tissues associated with this bone. + """ + return self._list_cartilage_labels + + @list_cartilage_labels.setter + def list_cartilage_labels(self, new_list_cartilage_labels): + """ + Convenience function to set the list of labels for cartilage tissues associated + with this bone + + Parameters + ---------- + new_list_cartilage_labels : list + list of `int`s for the cartilage tissues associated with this bone. + """ + if type(new_list_cartilage_labels) == list: + for label in new_list_cartilage_labels: + if type(label) != int: + raise TypeError(f'Item in `list_cartilage_labels` is not a `int` - got {type(label)}') + elif type(new_list_cartilage_labels) == int: + new_list_cartilage_labels = [new_list_cartilage_labels,] + self._list_cartilage_labels = new_list_cartilage_labels + + @property + def crop_percent(self): + """ + Convenience function to get the value that `crop_percent` is set to. + + Returns + ------- + float + Floating point > 0.0 indicating how much of the length of the bone should be included + when cropping - expressed as a proportion of the width. + """ + return self._crop_percent + + @crop_percent.setter + def crop_percent(self, new_crop_percent): + """ + Convenience function to set the value that `crop_percent` is set to. + + Parameters + ---------- + new_crop_percent : float + Floating point > 0.0 indicating how much of the length of the bone should be included + when cropping - expressed as a proportion of the width. + """ + if type(new_crop_percent) != float: + raise TypeError(f'New `crop_percent` provided is type {type(new_crop_percent)} - expected `float`') + self._crop_percent = new_crop_percent + + @property + def bone(self): + """ + Convenience function to get the name of the bone in this object. + + Returns + ------- + str + Name of the bone in this object - used to help identify how to crop the bone. + """ + return self._bone + + @bone.setter + def bone(self, new_bone): + """ + Convenience function to set the name of the bone in this object. + + Parameters + ---------- + new_bone : str + Name of the bone in this object - used to help identify how to crop the bone. + """ + if type(new_bone) != str: + raise TypeError(f'New bone provided is type {type(new_bone)} - expected `str`') + self._bone = new_bone </code></pre> +</details> +<h3>Ancestors</h3> +<ul class="hlist"> +<li><a title="pymskt.mesh.meshes.Mesh" href="#pymskt.mesh.meshes.Mesh">Mesh</a></li> +</ul> +<h3>Instance variables</h3> +<dl> +<dt id="pymskt.mesh.meshes.BoneMesh.bone"><code class="name">var <span class="ident">bone</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get the name of the bone in this object. </p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>str</code></dt> +<dd>Name of the bone in this object - used to help identify how to crop the bone.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def bone(self): + """ + Convenience function to get the name of the bone in this object. + + Returns + ------- + str + Name of the bone in this object - used to help identify how to crop the bone. + """ + return self._bone</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.crop_percent"><code class="name">var <span class="ident">crop_percent</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get the value that <code>crop_percent</code> is set to. </p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>float</code></dt> +<dd>Floating point > 0.0 indicating how much of the length of the bone should be included +when cropping - expressed as a proportion of the width.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def crop_percent(self): + """ + Convenience function to get the value that `crop_percent` is set to. + + Returns + ------- + float + Floating point > 0.0 indicating how much of the length of the bone should be included + when cropping - expressed as a proportion of the width. + """ + return self._crop_percent</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.list_cartilage_labels"><code class="name">var <span class="ident">list_cartilage_labels</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get the list of labels for cartilage tissues associated +with this bone. </p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>list</code></dt> +<dd>list of <code>int</code>s for the cartilage tissues associated with this bone.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def list_cartilage_labels(self): + """ + Convenience function to get the list of labels for cartilage tissues associated + with this bone. + + Returns + ------- + list + list of `int`s for the cartilage tissues associated with this bone. + """ + return self._list_cartilage_labels</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.list_cartilage_meshes"><code class="name">var <span class="ident">list_cartilage_meshes</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get the list of cartilage meshes</p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>list</code></dt> +<dd>A list of <code><a title="pymskt.mesh.meshes.CartilageMesh" href="#pymskt.mesh.meshes.CartilageMesh">CartilageMesh</a></code> objects associated with this bone</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def list_cartilage_meshes(self): + """ + Convenience function to get the list of cartilage meshes + + Returns + ------- + list + A list of `CartilageMesh` objects associated with this bone + """ + return self._list_cartilage_meshes</code></pre> +</details> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="pymskt.mesh.meshes.BoneMesh.assign_cartilage_regions"><code class="name flex"> +<span>def <span class="ident">assign_cartilage_regions</span></span>(<span>self, image_smooth_var_cart=0.15625, marching_cubes_threshold=0.5, ray_cast_length=10.0, percent_ray_length_opposite_direction=0.25)</span> +</code></dt> +<dd> +<div class="desc"><p>Assign cartilage regions to the bone surface (e.g. medial/lateral tibial cartilage) +- Can also be used for femur sub-regions (anterior, medial weight-bearing, etc.)</p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>image_smooth_var_cart</code></strong> : <code>float</code>, optional</dt> +<dd>Variance of gaussian filter to be applied to binary cartilage masks, +by default 0.3125/2</dd> +<dt><strong><code>marching_cubes_threshold</code></strong> : <code>float</code>, optional</dt> +<dd>Threshold to create bone surface at, by default 0.5</dd> +<dt><strong><code>ray_cast_length</code></strong> : <code>float</code>, optional</dt> +<dd>Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & +outter shell), by default 10.0</dd> +<dt><strong><code>percent_ray_length_opposite_direction</code></strong> : <code>float</code>, optional</dt> +<dd>How far to project ray inside of the bone. This is done just in case the cartilage +surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def assign_cartilage_regions(self, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25): + """ + Assign cartilage regions to the bone surface (e.g. medial/lateral tibial cartilage) + - Can also be used for femur sub-regions (anterior, medial weight-bearing, etc.) + + Parameters + ---------- + image_smooth_var_cart : float, optional + Variance of gaussian filter to be applied to binary cartilage masks, + by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold to create bone surface at, by default 0.5 + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + """ + tmp_filename = ''.join(random.choice(string.ascii_lowercase) for i in range(10)) + '.nrrd' + path_save_tmp_file = os.path.join('/tmp', tmp_filename) + # if self._bone == 'femur': + # new_seg_image = qc.get_knee_segmentation_with_femur_subregions(seg_image, + # fem_cart_label_idx=1) + # sitk.WriteImage(new_seg_image, path_save_tmp_file) + # else: + sitk.WriteImage(self._seg_image, path_save_tmp_file) + vtk_seg_reader = read_nrrd(path_save_tmp_file, + set_origin_zero=True + ) + vtk_seg = vtk_seg_reader.GetOutput() + + seg_transformer = SitkVtkTransformer(self._seg_image) + + # Delete tmp files + safely_delete_tmp_file('/tmp', + tmp_filename) + + self.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform()) + labels = np.zeros(self._mesh.GetNumberOfPoints(), dtype=np.int) + + # if cartilage meshes don't exist yet, then make them. + if self._list_cartilage_meshes is None: + self.create_cartilage_meshes(image_smooth_var_cart=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + + # iterate over meshes and add their label (region) + for cart_mesh in self._list_cartilage_meshes: + cart_mesh.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform()) + node_data = get_cartilage_properties_at_points(self._mesh, + cart_mesh._mesh, + t2_vtk_image=None, + seg_vtk_image=vtk_seg, + ray_cast_length=ray_cast_length, + percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + ) + labels += node_data[1] + cart_mesh.reverse_all_transforms() + + # Assign the label (region) scalars to the bone mesh surface. + label_scalars = numpy_to_vtk(labels) + label_scalars.SetName('labels') + self._mesh.GetPointData().AddArray(label_scalars) + + self.reverse_all_transforms()</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.calc_cartilage_t2"><code class="name flex"> +<span>def <span class="ident">calc_cartilage_t2</span></span>(<span>self, path_t2_nrrd, path_seg_to_t2_transform=None, ray_cast_length=10.0, percent_ray_length_opposite_direction=0.25)</span> +</code></dt> +<dd> +<div class="desc"><p>Apply cartilage T2 values to bone surface. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>path_t2_nrrd</code></strong> : <code>str</code></dt> +<dd>Path to nrrd image of T2 map to load / use.</dd> +<dt><strong><code>path_seg_to_t2_transform</code></strong> : <code>str</code>, optional</dt> +<dd>Path to a transform file to be used for aligning T2 map with segmentations, +by default None</dd> +<dt><strong><code>ray_cast_length</code></strong> : <code>float</code>, optional</dt> +<dd>Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & +outter shell), by default 10.0</dd> +<dt><strong><code>percent_ray_length_opposite_direction</code></strong> : <code>float</code>, optional</dt> +<dd>How far to project ray inside of the bone. This is done just in case the cartilage +surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def calc_cartilage_t2(self, + path_t2_nrrd, + path_seg_to_t2_transform=None, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25): + """ + Apply cartilage T2 values to bone surface. + + Parameters + ---------- + path_t2_nrrd : str + Path to nrrd image of T2 map to load / use. + path_seg_to_t2_transform : str, optional + Path to a transform file to be used for aligning T2 map with segmentations, + by default None + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + """ + print('Not yet implemented') + # if self._list_cartilage_meshes is None: + # raise('Should calculate cartialge thickness before getting T2') + # # ALTERNATIVELY - COULD ALLOW PASSING OF CARTILAGE REGIONS IN HERE + # # THOUGH, DOES THAT JUST COMPLICATE THINGS? + + # if path_seg_transform is not None: + # # this is in case there is a transformation needed to align the segmentation with the + # # underlying T2 image + # seg_transform = sitk.ReadTransform(path_seg_transform) + # seg_image = apply_transform_retain_array(self._seg_image, + # seg_transform, + # interpolator=sitk.sitkNearestNeighbor) + + + # versor = get_versor_from_transform(seg_transform) + # center_transform, rotate_transform, translate_transform = break_versor_into_center_rotate_translate_transforms(versor) + # # first apply negative of center of rotation to mesh + # self._mesh.apply_transform_to_mesh(transform=center_transform.GetInverse()) + # # now apply the transform (rotation then translation) + # self._mesh.apply_transform_to_mesh(transform=rotate_transform.GetInverse()) + # self._mesh.apply_transform_to_mesh(transform=translate_transform.GetInverse()) + # #then undo the center of rotation + # self._mesh.apply_transform_to_mesh(transform=center_transform) + + # # Read t2 map (vtk format) + # vtk_t2map_reader = read_nrrd(path_t2_nrrd, + # set_origin_zero=True) + # vtk_t2map = vtk_t2map_reader.GetOutput() + # sitk_t2map = sitk.ReadImage(path_t2_nrrd) + # t2_transformer = SitkVtkTransformer(sitk_t2map) + + # self._mesh.apply_transform_to_mesh(transform=t2_transformer.get_inverse_transform()) + + # t2 = np.zeros(self._mesh.GetNumberOfPoints()) + # # iterate over meshes and add their t2 to the t2 list. + # for cart_mesh in self._list_cartilage_meshes: + # if path_seg_to_t2_transform is not None: + # # first apply negative of center of rotation to mesh + # cart_mesh.apply_transform_to_mesh(transform=center_transform.GetInverse()) + # # now apply the transform (rotation then translation) + # cart_mesh.apply_transform_to_mesh(transform=rotate_transform.GetInverse()) + # cart_mesh.apply_transform_to_mesh(transform=translate_transform.GetInverse()) + # #then undo the center of rotation + # cart_mesh.apply_transform_to_mesh(transform=center_transform) + + # cart_mesh.apply_transform_to_mesh(transform=t2_transformer.get_inverse_transform()) + # _, t2_data = get_cartilage_properties_at_points(self._mesh, + # cart_mesh._mesh, + # t2_vtk_image=vtk_t2map, + # ray_cast_length=ray_cast_length, + # percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + # ) + # t2 += t2_data + # cart_mesh.reverse_all_transforms() + print('NOT DONE!!!')</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.calc_cartilage_thickness"><code class="name flex"> +<span>def <span class="ident">calc_cartilage_thickness</span></span>(<span>self, list_cartilage_labels=None, list_cartilage_meshes=None, image_smooth_var_cart=0.15625, marching_cubes_threshold=0.5, ray_cast_length=10.0, percent_ray_length_opposite_direction=0.25)</span> +</code></dt> +<dd> +<div class="desc"><p>Using bone mesh (<code>_mesh</code>) and the list of cartilage meshes (<code>list_cartilage_meshes</code>) +calcualte the cartilage thickness for each node on the bone surface. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>list_cartilage_labels</code></strong> : <code>list</code>, optional</dt> +<dd>Cartilag labels to be used to create cartilage meshes (if they dont +exist), by default None</dd> +<dt><strong><code>list_cartilage_meshes</code></strong> : <code>list</code>, optional</dt> +<dd>Cartilage meshes to be used for calculating cart thickness, by default None</dd> +<dt><strong><code>image_smooth_var_cart</code></strong> : <code>float</code>, optional</dt> +<dd>Variance of gaussian filter to be applied to binary cartilage masks, +by default 0.3125/2</dd> +<dt><strong><code>marching_cubes_threshold</code></strong> : <code>float</code>, optional</dt> +<dd>Threshold to create bone surface at, by default 0.5</dd> +<dt><strong><code>ray_cast_length</code></strong> : <code>float</code>, optional</dt> +<dd>Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & +outter shell), by default 10.0</dd> +<dt><strong><code>percent_ray_length_opposite_direction</code></strong> : <code>float</code>, optional</dt> +<dd>How far to project ray inside of the bone. This is done just in case the cartilage +surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25</dd> +</dl> +<h2 id="raises">Raises</h2> +<dl> +<dt><code>Exception</code></dt> +<dd>No cartilage available (either <code>list_cartilage_meshes</code> or <code>list_cartilage_labels</code>)</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def calc_cartilage_thickness(self, + list_cartilage_labels=None, + list_cartilage_meshes=None, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5, + ray_cast_length=10.0, + percent_ray_length_opposite_direction=0.25 + ): + """ + Using bone mesh (`_mesh`) and the list of cartilage meshes (`list_cartilage_meshes`) + calcualte the cartilage thickness for each node on the bone surface. + + Parameters + ---------- + list_cartilage_labels : list, optional + Cartilag labels to be used to create cartilage meshes (if they dont + exist), by default None + list_cartilage_meshes : list, optional + Cartilage meshes to be used for calculating cart thickness, by default None + image_smooth_var_cart : float, optional + Variance of gaussian filter to be applied to binary cartilage masks, + by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold to create bone surface at, by default 0.5 + ray_cast_length : float, optional + Length (mm) of ray to cast from bone surface when trying to find cartilage (inner & + outter shell), by default 10.0 + percent_ray_length_opposite_direction : float, optional + How far to project ray inside of the bone. This is done just in case the cartilage + surface ends up slightly inside of (or coincident with) the bone surface, by default 0.25 + + Raises + ------ + Exception + No cartilage available (either `list_cartilage_meshes` or `list_cartilage_labels`) + """ + # If new cartilage infor/labels are provided, then replace existing with these ones. + if list_cartilage_meshes is not None: self._list_cartilage_meshes = list_cartilage_meshes + if list_cartilage_labels is not None: self._list_cartilage_labels = list_cartilage_labels + + # If no cartilage stuff provided, then cant do this function - raise exception. + if (self._list_cartilage_meshes is None) & (self._list_cartilage_labels is None): + raise Exception('No cartilage meshes or list of cartilage labels are provided! - These can be provided either to the class function `calc_cartilage_thickness` directly, or can be specified at the time of instantiating the `BoneMesh` class.') + + # if cartilage meshes don't exist yet, then make them. + if self._list_cartilage_meshes is None: + self.create_cartilage_meshes(image_smooth_var_cart=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + + # pre-allocate empty thicknesses so that as labels are iterated over, they can all be appended to the same bone. + thicknesses = np.zeros(self._mesh.GetNumberOfPoints()) + + # iterate over meshes and add their thicknesses to the thicknesses list. + for cart_mesh in self._list_cartilage_meshes: + node_data = get_cartilage_properties_at_points(self._mesh, + cart_mesh._mesh, + t2_vtk_image=None, + # seg_vtk_image=vtk_seg if assign_seg_label_to_bone is True else None, + seg_vtk_image=None, + ray_cast_length=ray_cast_length, + percent_ray_length_opposite_direction=percent_ray_length_opposite_direction + ) + thicknesses += node_data + + # Assign the thickness scalars to the bone mesh surface. + thickness_scalars = numpy_to_vtk(thicknesses) + thickness_scalars.SetName('thickness (mm)') + self._mesh.GetPointData().SetScalars(thickness_scalars)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.create_cartilage_meshes"><code class="name flex"> +<span>def <span class="ident">create_cartilage_meshes</span></span>(<span>self, image_smooth_var_cart=0.15625, marching_cubes_threshold=0.5)</span> +</code></dt> +<dd> +<div class="desc"><p>Helper function to create the list of cartilage meshes from the list of cartilage +labels. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>image_smooth_var_cart</code></strong> : <code>float</code></dt> +<dd>Variance to smooth cartilage segmentations before finding surface using continuous +marching cubes.</dd> +<dt><strong><code>marching_cubes_threshold</code></strong> : <code>float</code></dt> +<dd>Threshold value to create cartilage surface at from segmentation images.</dd> +</dl> +<h2 id="notes">Notes</h2> +<p>?? Should this function just be everything inside the for loop and then that +function gets called somewhere else?</p></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def create_cartilage_meshes(self, + image_smooth_var_cart=0.3125 / 2, + marching_cubes_threshold=0.5): + """ + Helper function to create the list of cartilage meshes from the list of cartilage + labels. + + Parameters + ---------- + image_smooth_var_cart : float + Variance to smooth cartilage segmentations before finding surface using continuous + marching cubes. + marching_cubes_threshold : float + Threshold value to create cartilage surface at from segmentation images. + + Notes + ----- + ?? Should this function just be everything inside the for loop and then that + function gets called somewhere else? + """ + + self._list_cartilage_meshes = [] + for cart_label_idx in self._list_cartilage_labels: + seg_array_view = sitk.GetArrayViewFromImage(self._seg_image) + n_pixels_with_cart = np.sum(seg_array_view == cart_label_idx) + if n_pixels_with_cart == 0: + warnings.warn( + f"Not analyzing cartilage for label {cart_label_idx} because it doesnt have any pixels!", + UserWarning + ) + else: + cart_mesh = CartilageMesh(seg_image=self._seg_image, + label_idx=cart_label_idx) + cart_mesh.create_mesh(smooth_image_var=image_smooth_var_cart, + marching_cubes_threshold=marching_cubes_threshold) + self._list_cartilage_meshes.append(cart_mesh)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.create_mesh"><code class="name flex"> +<span>def <span class="ident">create_mesh</span></span>(<span>self, smooth_image=True, smooth_image_var=0.15625, marching_cubes_threshold=0.5, label_idx=None, min_n_pixels=None, crop_percent=None)</span> +</code></dt> +<dd> +<div class="desc"><p>This is an extension of <code><a title="pymskt.mesh.meshes.Mesh.create_mesh" href="#pymskt.mesh.meshes.Mesh.create_mesh">Mesh.create_mesh()</a></code> that enables cropping of bones. +Bones might need to be cropped (this isnt necessary for cartilage) +So, adding this functionality to the processing steps before the bone mesh is created.</p> +<p>All functionality, except for that relevant to <code>crop_percent</code> is the same as: +<code><a title="pymskt.mesh.meshes.Mesh.create_mesh" href="#pymskt.mesh.meshes.Mesh.create_mesh">Mesh.create_mesh()</a></code>. </p> +<p>Create a surface mesh from the classes <code>_seg_image</code>. If <code>_seg_image</code> +does not exist, then read it in using <code>read_seg_image</code>. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>smooth_image</code></strong> : <code>bool</code>, optional</dt> +<dd>Should the <code>_seg_image</code> be gaussian filtered, by default True</dd> +<dt><strong><code>smooth_image_var</code></strong> : <code>float</code>, optional</dt> +<dd>Variance of gaussian filter to apply to <code>_seg_image</code>, by default 0.3125/2</dd> +<dt><strong><code>marching_cubes_threshold</code></strong> : <code>float</code>, optional</dt> +<dd>Threshold contour level to create surface mesh on, by default 0.5</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label value / index to create mesh from, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>Minimum number of continuous pixels to include segmentation island +in the surface mesh creation, by default None</dd> +<dt><strong><code>crop_percent</code></strong> : <code>[type]</code>, optional</dt> +<dd>[description], by default None</dd> +</dl> +<h2 id="raises">Raises</h2> +<dl> +<dt><code>Exception</code></dt> +<dd>If cropping & bone is not femur or tibia, then raise an error.</dd> +<dt><code>Exception</code></dt> +<dd>If the total number of pixels segmentated (<code>n_pixels_labelled</code>) is +< <code>min_n_pixels</code> then there is no object in the image.</dd> +<dt><code>Exception</code></dt> +<dd>If no <code>_seg_image</code> and no <code>label_idx</code> then we don't know what tissue to create the +surface mesh from.</dd> +<dt><code>Exception</code></dt> +<dd>If no <code>_seg_image</code> or <code>path_seg_image</code> then we have no image to create mesh from.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def create_mesh(self, + smooth_image=True, + smooth_image_var=0.3125 / 2, + marching_cubes_threshold=0.5, + label_idx=None, + min_n_pixels=None, + crop_percent=None + ): + """ + This is an extension of `Mesh.create_mesh` that enables cropping of bones. + Bones might need to be cropped (this isnt necessary for cartilage) + So, adding this functionality to the processing steps before the bone mesh is created. + + All functionality, except for that relevant to `crop_percent` is the same as: + `Mesh.create_mesh`. + + Create a surface mesh from the classes `_seg_image`. If `_seg_image` + does not exist, then read it in using `read_seg_image`. + + Parameters + ---------- + smooth_image : bool, optional + Should the `_seg_image` be gaussian filtered, by default True + smooth_image_var : float, optional + Variance of gaussian filter to apply to `_seg_image`, by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold contour level to create surface mesh on, by default 0.5 + label_idx : int, optional + Label value / index to create mesh from, by default None + min_n_pixels : int, optional + Minimum number of continuous pixels to include segmentation island + in the surface mesh creation, by default None + crop_percent : [type], optional + [description], by default None + + Raises + ------ + Exception + If cropping & bone is not femur or tibia, then raise an error. + Exception + If the total number of pixels segmentated (`n_pixels_labelled`) is + < `min_n_pixels` then there is no object in the image. + Exception + If no `_seg_image` and no `label_idx` then we don't know what tissue to create the + surface mesh from. + Exception + If no `_seg_image` or `path_seg_image` then we have no image to create mesh from. + """ + + if self._seg_image is None: + self.read_seg_image() + + # Bones might need to be cropped (this isnt necessary for cartilage) + # So, adding this functionality to the processing steps before the bone mesh is created + if crop_percent is not None: + self._crop_percent = crop_percent + if (self._crop_percent is not None) and (('femur' in self._bone) or ('tibia' in self._bone)): + if 'femur' in self._bone: + bone_crop_distal = True + elif 'tibia' in self._bone: + bone_crop_distal = False + else: + raise Exception('var bone should be "femur" or "tiba" got: {} instead'.format(self._bone)) + + self._seg_image = crop_bone_based_on_width(self._seg_image, + self._label_idx, + percent_width_to_crop_height=self._crop_percent, + bone_crop_distal=bone_crop_distal) + elif self._crop_percent is not None: + warnings.warn(f'Trying to crop bone, but {self._bone} specified and only bones `femur`', + 'or `tibia` currently supported for cropping. If using another bone, consider', + 'making a pull request. If cropping not desired, set `crop_percent=None`.' + ) + super().create_mesh(smooth_image=smooth_image, smooth_image_var=smooth_image_var, marching_cubes_threshold=marching_cubes_threshold, label_idx=label_idx, min_n_pixels=min_n_pixels)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.BoneMesh.smooth_surface_scalars"><code class="name flex"> +<span>def <span class="ident">smooth_surface_scalars</span></span>(<span>self, smooth_only_cartilage=True, scalar_sigma=1.6986436005760381, scalar_array_name='thickness (mm)', scalar_array_idx=None)</span> +</code></dt> +<dd> +<div class="desc"><p>Function to smooth the scalars with name <code>scalar_array_name</code> on the bone surface. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>smooth_only_cartilage</code></strong> : <code>bool</code>, optional</dt> +<dd>Should we only smooth where there is cartialge & ignore everywhere else, by default True</dd> +<dt><strong><code>scalar_sigma</code></strong> : <code>float</code>, optional</dt> +<dd>Smoothing sigma (standard deviation or sqrt(variance)) for gaussian filter, by default 1.6986436005760381 +default is based on a Full Width Half Maximum (FWHM) of 4mm.</dd> +<dt><strong><code>scalar_array_name</code></strong> : <code>str</code></dt> +<dd>Name of scalar array to smooth, default 'thickness (mm)'.</dd> +<dt><strong><code>scalar_array_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Index of the scalar array to smooth (alternative to using <code>scalar_array_name</code>) , by default None</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def smooth_surface_scalars(self, + smooth_only_cartilage=True, + scalar_sigma=1.6986436005760381, # This is a FWHM = 4 + scalar_array_name='thickness (mm)', + scalar_array_idx=None, + ): + + """ + Function to smooth the scalars with name `scalar_array_name` on the bone surface. + + Parameters + ---------- + smooth_only_cartilage : bool, optional + Should we only smooth where there is cartialge & ignore everywhere else, by default True + scalar_sigma : float, optional + Smoothing sigma (standard deviation or sqrt(variance)) for gaussian filter, by default 1.6986436005760381 + default is based on a Full Width Half Maximum (FWHM) of 4mm. + scalar_array_name : str + Name of scalar array to smooth, default 'thickness (mm)'. + scalar_array_idx : int, optional + Index of the scalar array to smooth (alternative to using `scalar_array_name`) , by default None + """ + if smooth_only_cartilage is True: + loc_cartilage = np.where(vtk_to_numpy(self._mesh.GetPointData().GetArray('thickness (mm)')) > 0.01)[0] + else: + loc_cartilage = None + self._mesh = gaussian_smooth_surface_scalars(self._mesh, + sigma=scalar_sigma, + idx_coords_to_smooth=loc_cartilage, + array_name=scalar_array_name, + array_idx=scalar_array_idx)</code></pre> +</details> +</dd> +</dl> +<h3>Inherited members</h3> +<ul class="hlist"> +<li><code><b><a title="pymskt.mesh.meshes.Mesh" href="#pymskt.mesh.meshes.Mesh">Mesh</a></b></code>: +<ul class="hlist"> +<li><code><a title="pymskt.mesh.meshes.Mesh.apply_transform_to_mesh" href="#pymskt.mesh.meshes.Mesh.apply_transform_to_mesh">apply_transform_to_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.copy_scalars_from_other_mesh_to_currect" href="#pymskt.mesh.meshes.Mesh.copy_scalars_from_other_mesh_to_currect">copy_scalars_from_other_mesh_to_currect</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.label_idx" href="#pymskt.mesh.meshes.Mesh.label_idx">label_idx</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.list_applied_transforms" href="#pymskt.mesh.meshes.Mesh.list_applied_transforms">list_applied_transforms</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.mesh" href="#pymskt.mesh.meshes.Mesh.mesh">mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.min_n_pixels" href="#pymskt.mesh.meshes.Mesh.min_n_pixels">min_n_pixels</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.non_rigidly_register" href="#pymskt.mesh.meshes.Mesh.non_rigidly_register">non_rigidly_register</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.path_seg_image" href="#pymskt.mesh.meshes.Mesh.path_seg_image">path_seg_image</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.point_coords" href="#pymskt.mesh.meshes.Mesh.point_coords">point_coords</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.read_seg_image" href="#pymskt.mesh.meshes.Mesh.read_seg_image">read_seg_image</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.resample_surface" href="#pymskt.mesh.meshes.Mesh.resample_surface">resample_surface</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.reverse_all_transforms" href="#pymskt.mesh.meshes.Mesh.reverse_all_transforms">reverse_all_transforms</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.reverse_most_recent_transform" href="#pymskt.mesh.meshes.Mesh.reverse_most_recent_transform">reverse_most_recent_transform</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.rigidly_register" href="#pymskt.mesh.meshes.Mesh.rigidly_register">rigidly_register</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.save_mesh" href="#pymskt.mesh.meshes.Mesh.save_mesh">save_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.seg_image" href="#pymskt.mesh.meshes.Mesh.seg_image">seg_image</a></code></li> +</ul> +</li> +</ul> +</dd> +<dt id="pymskt.mesh.meshes.CartilageMesh"><code class="flex name class"> +<span>class <span class="ident">CartilageMesh</span></span> +<span>(</span><span>mesh=None, seg_image=None, path_seg_image=None, label_idx=None, min_n_pixels=1000)</span> +</code></dt> +<dd> +<div class="desc"><p>Class to create, store, and process cartilage meshes</p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code>, optional</dt> +<dd>vtkPolyData object that is basis of surface mesh, by default None</dd> +<dt><strong><code>seg_image</code></strong> : <code>SimpleITK.Image</code>, optional</dt> +<dd>Segmentation image that can be used to create surface mesh - used +instead of mesh, by default None</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code>, optional</dt> +<dd>Path to a medical image (.nrrd) to load and create mesh from, +by default None</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label of anatomy of interest, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>All islands smaller than this size are dropped, by default 5000</dd> +</dl> +<h2 id="attributes">Attributes</h2> +<dl> +<dt><strong><code>_mesh</code></strong> : <code>vtk.vtkPolyData</code></dt> +<dd>Item passed from <strong>init</strong>, or created during life of class. +This is the main surface mesh of this class.</dd> +<dt><strong><code>_seg_image</code></strong> : <code>SimpleITK.Image</code></dt> +<dd>Segmentation image that can be used to create mesh. This is optional.</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code></dt> +<dd>Path to medical image (.nrrd) that can be loaded to create <code>_seg_image</code> +and then creat surface mesh <code>_mesh</code></dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code></dt> +<dd>Integer of anatomy to create surface mesh from <code>_seg_image</code></dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code></dt> +<dd>Minimum number of pixels for an isolated island of a segmentation to be +retained</dd> +<dt><strong><code>list_applied_transforms</code></strong> : <code>list</code></dt> +<dd>A list of transformations applied to a surface mesh. +This list allows for undoing of most recent transform, or undoing +all of them by iterating over the list in reverse.</dd> +</dl> +<h2 id="methods">Methods</h2> +<p>Initialize Mesh class</p> +<h2 id="parameters_1">Parameters</h2> +<dl> +<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code>, optional</dt> +<dd>vtkPolyData object that is basis of surface mesh, by default None</dd> +<dt><strong><code>seg_image</code></strong> : <code>SimpleITK.Image</code>, optional</dt> +<dd>Segmentation image that can be used to create surface mesh - used +instead of mesh, by default None</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code>, optional</dt> +<dd>Path to a medical image (.nrrd) to load and create mesh from, +by default None</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label of anatomy of interest, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>All islands smaller than this size are dropped, by default 5000</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">class CartilageMesh(Mesh): + """ + Class to create, store, and process cartilage meshes + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + + + Attributes + ---------- + _mesh : vtk.vtkPolyData + Item passed from __init__, or created during life of class. + This is the main surface mesh of this class. + _seg_image : SimpleITK.Image + Segmentation image that can be used to create mesh. This is optional. + path_seg_image : str + Path to medical image (.nrrd) that can be loaded to create `_seg_image` + and then creat surface mesh `_mesh` + label_idx : int + Integer of anatomy to create surface mesh from `_seg_image` + min_n_pixels : int + Minimum number of pixels for an isolated island of a segmentation to be + retained + list_applied_transforms : list + A list of transformations applied to a surface mesh. + This list allows for undoing of most recent transform, or undoing + all of them by iterating over the list in reverse. + + Methods + ---------- + + """ + + def __init__(self, + mesh=None, + seg_image=None, + path_seg_image=None, + label_idx=None, + min_n_pixels=1000 + ): + super().__init__(mesh=mesh, + seg_image=seg_image, + path_seg_image=path_seg_image, + label_idx=label_idx, + min_n_pixels=min_n_pixels)</code></pre> +</details> +<h3>Ancestors</h3> +<ul class="hlist"> +<li><a title="pymskt.mesh.meshes.Mesh" href="#pymskt.mesh.meshes.Mesh">Mesh</a></li> +</ul> +<h3>Inherited members</h3> +<ul class="hlist"> +<li><code><b><a title="pymskt.mesh.meshes.Mesh" href="#pymskt.mesh.meshes.Mesh">Mesh</a></b></code>: +<ul class="hlist"> +<li><code><a title="pymskt.mesh.meshes.Mesh.apply_transform_to_mesh" href="#pymskt.mesh.meshes.Mesh.apply_transform_to_mesh">apply_transform_to_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.copy_scalars_from_other_mesh_to_currect" href="#pymskt.mesh.meshes.Mesh.copy_scalars_from_other_mesh_to_currect">copy_scalars_from_other_mesh_to_currect</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.create_mesh" href="#pymskt.mesh.meshes.Mesh.create_mesh">create_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.label_idx" href="#pymskt.mesh.meshes.Mesh.label_idx">label_idx</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.list_applied_transforms" href="#pymskt.mesh.meshes.Mesh.list_applied_transforms">list_applied_transforms</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.mesh" href="#pymskt.mesh.meshes.Mesh.mesh">mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.min_n_pixels" href="#pymskt.mesh.meshes.Mesh.min_n_pixels">min_n_pixels</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.non_rigidly_register" href="#pymskt.mesh.meshes.Mesh.non_rigidly_register">non_rigidly_register</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.path_seg_image" href="#pymskt.mesh.meshes.Mesh.path_seg_image">path_seg_image</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.point_coords" href="#pymskt.mesh.meshes.Mesh.point_coords">point_coords</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.read_seg_image" href="#pymskt.mesh.meshes.Mesh.read_seg_image">read_seg_image</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.resample_surface" href="#pymskt.mesh.meshes.Mesh.resample_surface">resample_surface</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.reverse_all_transforms" href="#pymskt.mesh.meshes.Mesh.reverse_all_transforms">reverse_all_transforms</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.reverse_most_recent_transform" href="#pymskt.mesh.meshes.Mesh.reverse_most_recent_transform">reverse_most_recent_transform</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.rigidly_register" href="#pymskt.mesh.meshes.Mesh.rigidly_register">rigidly_register</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.save_mesh" href="#pymskt.mesh.meshes.Mesh.save_mesh">save_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.seg_image" href="#pymskt.mesh.meshes.Mesh.seg_image">seg_image</a></code></li> +</ul> +</li> +</ul> +</dd> +<dt id="pymskt.mesh.meshes.Mesh"><code class="flex name class"> +<span>class <span class="ident">Mesh</span></span> +<span>(</span><span>mesh=None, seg_image=None, path_seg_image=None, label_idx=None, min_n_pixels=5000)</span> +</code></dt> +<dd> +<div class="desc"><p>An object to contain surface meshes for musculoskeletal anatomy. Includes helper +functions to build surface meshes, to process them, and to save them. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code>, optional</dt> +<dd>vtkPolyData object that is basis of surface mesh, by default None</dd> +<dt><strong><code>seg_image</code></strong> : <code>SimpleITK.Image</code>, optional</dt> +<dd>Segmentation image that can be used to create surface mesh - used +instead of mesh, by default None</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code>, optional</dt> +<dd>Path to a medical image (.nrrd) to load and create mesh from, +by default None</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label of anatomy of interest, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>All islands smaller than this size are dropped, by default 5000</dd> +</dl> +<h2 id="attributes">Attributes</h2> +<dl> +<dt><strong><code>_mesh</code></strong> : <code>vtk.vtkPolyData</code></dt> +<dd>Item passed from <strong>init</strong>, or created during life of class. +This is the main surface mesh of this class.</dd> +<dt><strong><code>_seg_image</code></strong> : <code>SimpleITK.Image</code></dt> +<dd>Segmentation image that can be used to create mesh. This is optional.</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code></dt> +<dd>Path to medical image (.nrrd) that can be loaded to create <code>_seg_image</code> +and then creat surface mesh <code>_mesh</code></dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code></dt> +<dd>Integer of anatomy to create surface mesh from <code>_seg_image</code></dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code></dt> +<dd>Minimum number of pixels for an isolated island of a segmentation to be +retained</dd> +<dt><strong><code>list_applied_transforms</code></strong> : <code>list</code></dt> +<dd>A list of transformations applied to a surface mesh. +This list allows for undoing of most recent transform, or undoing +all of them by iterating over the list in reverse.</dd> +</dl> +<h2 id="methods">Methods</h2> +<p>Initialize Mesh class</p> +<h2 id="parameters_1">Parameters</h2> +<dl> +<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code>, optional</dt> +<dd>vtkPolyData object that is basis of surface mesh, by default None</dd> +<dt><strong><code>seg_image</code></strong> : <code>SimpleITK.Image</code>, optional</dt> +<dd>Segmentation image that can be used to create surface mesh - used +instead of mesh, by default None</dd> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code>, optional</dt> +<dd>Path to a medical image (.nrrd) to load and create mesh from, +by default None</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label of anatomy of interest, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>All islands smaller than this size are dropped, by default 5000</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">class Mesh: + """ + An object to contain surface meshes for musculoskeletal anatomy. Includes helper + functions to build surface meshes, to process them, and to save them. + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + + + Attributes + ---------- + _mesh : vtk.vtkPolyData + Item passed from __init__, or created during life of class. + This is the main surface mesh of this class. + _seg_image : SimpleITK.Image + Segmentation image that can be used to create mesh. This is optional. + path_seg_image : str + Path to medical image (.nrrd) that can be loaded to create `_seg_image` + and then creat surface mesh `_mesh` + label_idx : int + Integer of anatomy to create surface mesh from `_seg_image` + min_n_pixels : int + Minimum number of pixels for an isolated island of a segmentation to be + retained + list_applied_transforms : list + A list of transformations applied to a surface mesh. + This list allows for undoing of most recent transform, or undoing + all of them by iterating over the list in reverse. + + Methods + ---------- + + """ + def __init__(self, + mesh=None, + seg_image=None, + path_seg_image=None, + label_idx=None, + min_n_pixels=5000 + ): + """ + Initialize Mesh class + + Parameters + ---------- + mesh : vtk.vtkPolyData, optional + vtkPolyData object that is basis of surface mesh, by default None + seg_image : SimpleITK.Image, optional + Segmentation image that can be used to create surface mesh - used + instead of mesh, by default None + path_seg_image : str, optional + Path to a medical image (.nrrd) to load and create mesh from, + by default None + label_idx : int, optional + Label of anatomy of interest, by default None + min_n_pixels : int, optional + All islands smaller than this size are dropped, by default 5000 + """ + if type(mesh) in (str,): #accept path like objects? + print('mesh string passed, loading mesh from disk') + self._mesh = io.read_vtk(mesh) + else: + self._mesh = mesh + self._seg_image = seg_image + self._path_seg_image = path_seg_image + self._label_idx = label_idx + self._min_n_pixels = min_n_pixels + + self._list_applied_transforms = [] + + def read_seg_image(self, + path_seg_image=None): + """ + Read segmentation image from disk. Must be a single file (e.g., nrrd, 3D dicom) + + Parameters + ---------- + path_seg_image : str, optional + Path to the medical image file to be loaded in, by default None + + Raises + ------ + Exception + If path_seg_image does not exist, exception is raised. + """ + # If passing new location/seg image name, then update variables. + if path_seg_image is not None: + self._path_seg_image = path_seg_image + + # If seg image location / name exist, then load image else raise exception + if (self._path_seg_image is not None): + self._seg_image = sitk.ReadImage(self._path_seg_image) + else: + raise Exception('No file path (self._path_seg_image) provided.') + + def create_mesh(self, + smooth_image=True, + smooth_image_var=0.3125 / 2, + marching_cubes_threshold=0.5, + label_idx=None, + min_n_pixels=None): + """ + Create a surface mesh from the classes `_seg_image`. If `_seg_image` + does not exist, then read it in using `read_seg_image`. + + Parameters + ---------- + smooth_image : bool, optional + Should the `_seg_image` be gaussian filtered, by default True + smooth_image_var : float, optional + Variance of gaussian filter to apply to `_seg_image`, by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold contour level to create surface mesh on, by default 0.5 + label_idx : int, optional + Label value / index to create mesh from, by default None + min_n_pixels : int, optional + Minimum number of continuous pixels to include segmentation island + in the surface mesh creation, by default None + + Raises + ------ + Exception + If the total number of pixels segmentated (`n_pixels_labelled`) is + < `min_n_pixels` then there is no object in the image. + Exception + If no `_seg_image` and no `label_idx` then we don't know what tissue to create the + surface mesh from. + Exception + If no `_seg_image` or `path_seg_image` then we have no image to create mesh from. + """ + # allow assigning label idx during mesh creation step. + if label_idx is not None: + self._label_idx = label_idx + + if self._seg_image is None: + self.read_seg_image() + + # Ensure the image has a certain number of pixels with the label of interest, otherwise there might be an issue. + if min_n_pixels is None: min_n_pixels = self._min_n_pixels + seg_view = sitk.GetArrayViewFromImage(self._seg_image) + n_pixels_labelled = sum(seg_view[seg_view == self._label_idx]) + + if n_pixels_labelled < min_n_pixels: + raise Exception('The mesh does not exist in this segmentation!, only {} pixels detected, threshold # is {}'.format(n_pixels_labelled, + marching_cubes_threshold)) + tmp_filename = ''.join(random.choice(string.ascii_lowercase) for i in range(10)) + '.nrrd' + self._mesh = create_surface_mesh(self._seg_image, + self._label_idx, + smooth_image_var, + loc_tmp_save='/tmp', + tmp_filename=tmp_filename, + mc_threshold=marching_cubes_threshold, + filter_binary_image=smooth_image + ) + safely_delete_tmp_file('/tmp', + tmp_filename) + + def save_mesh(self, + filepath): + """ + Save the surface mesh from this class to disk. + + Parameters + ---------- + filepath : str + Location & filename to save the surface mesh (vtk.vtkPolyData) to. + """ + io.write_vtk(self._mesh, filepath) + + def resample_surface(self, + subdivisions=2, + clusters=10000 + ): + """ + Resample a surface mesh using the ACVD algorithm: + Version used: + - https://github.com/pyvista/pyacvd + Original version w/ more references: + - https://github.com/valette/ACVD + + Parameters + ---------- + subdivisions : int, optional + Subdivide the mesh to have more points before clustering, by default 2 + Probably not necessary for very dense meshes. + clusters : int, optional + The number of clusters (points/vertices) to create during resampling + surafce, by default 10000 + - This is not exact, might have slight differences. + """ + self._mesh = resample_surface(self._mesh, subdivisions=subdivisions, clusters=clusters) + + def apply_transform_to_mesh(self, + transform=None, + transformer=None, + save_transform=True): + """ + Apply a transformation to the surface mesh. + + Parameters + ---------- + transform : vtk.vtkTransform, optional + Transformation to apply to mesh, by default None + transformer : vtk.vtkTransformFilter, optional + Can supply transformFilter directly, by default None + save_transform : bool, optional + Should transform be saved to list of applied transforms, by default True + + Raises + ------ + Exception + No `transform` or `transformer` supplied - have not transformation + to apply. + """ + if (transform is not None) & (transformer is None): + transformer = vtk.vtkTransformPolyDataFilter() + transformer.SetTransform(transform) + + elif (transform is None) & (transformer is not None): + transform = transformer.GetTransform() + + if transformer is not None: + transformer.SetInputData(self._mesh) + transformer.Update() + self._mesh = vtk_deep_copy(transformer.GetOutput()) + + if save_transform is True: + self._list_applied_transforms.append(transform) + + else: + raise Exception('No transform or transformer provided') + + def reverse_most_recent_transform(self): + """ + Function to undo the most recent transformation stored in self._list_applied_transforms + """ + transform = self._list_applied_transforms.pop() + transform.Inverse() + self.apply_transform_to_mesh(transform=transform, save_transform=False) + + def reverse_all_transforms(self): + """ + Function to iterate over all of the self._list_applied_transforms (in reverse order) and undo them. + """ + while len(self._list_applied_transforms) > 0: + self.reverse_most_recent_transform() + + def non_rigidly_register( + self, + other_mesh, + as_source=True, + apply_transform_to_mesh=True, + return_transformed_mesh=False, + **kwargs + ): + """ + Function to perform non rigid registration between this mesh and another mesh. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Other mesh to use in registration process + as_source : bool, optional + Should the current mesh (in this object) be the source or the target, by default True + apply_transform_to_mesh : bool, optional + If as_source is True should we apply transformation to internal mesh, by default True + return_transformed_mesh : bool, optional + Should we return the registered mesh, by default False + + Returns + ------- + _type_ + _description_ + """ + # Setup the source & target meshes based on `as_source`` + if as_source is True: + source = self._mesh + target = other_mesh + elif as_source is False: + source = other_mesh + target = self._mesh + + # Get registered mesh (source to target) + source_transformed_to_target = non_rigidly_register( + target_mesh=target, + source_mesh=source, + **kwargs + ) + + # If current mesh is source & apply_transform_to_mesh is true then replace current mesh. + if (as_source is True) & (apply_transform_to_mesh is True): + self._mesh = source_transformed_to_target + + # curent mesh is target, or is source & want to return mesh, then return it. + if (as_source is False) or ((as_source is True) & (return_transformed_mesh is True)): + return source_transformed_to_target + + def rigidly_register( + self, + other_mesh, + as_source=True, + apply_transform_to_mesh=True, + return_transformed_mesh=False, + return_transform=False, + max_n_iter=100, + n_landmarks=1000, + reg_mode='similarity' + + ): + """ + Function to perform rigid registration between this mesh and another mesh. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Other mesh to use in registration process + as_source : bool, optional + Should the current mesh (in this object) be the source or the target, by default True + apply_transform_to_mesh : bool, optional + If as_source is True should we apply transformation to internal mesh, by default True + return_transformed_mesh : bool, optional + Should we return the registered mesh, by default False + max_n_iter : int, optional + Maximum number of iterations to perform, by default 100 + n_landmarks : int, optional + Number of landmarks to use in registration, by default 1000 + reg_mode : str, optional + Mode of registration to use, by default 'similarity' (similarity, rigid, or affine) + + Returns + ------- + _type_ + _description_ + """ + + if (return_transform is True) & (return_transformed_mesh is True): + raise Exception('Cannot return both transformed mesh and transform') + + if type(other_mesh) in (pymskt.mesh.meshes.BoneMesh, pymskt.mesh.meshes.Mesh): + other_mesh = other_mesh.mesh + + # Setup the source & target meshes based on `as_source`` + if as_source is True: + source = self._mesh + target = other_mesh + elif as_source is False: + source = other_mesh + target = self._mesh + + icp_transform = get_icp_transform( + source=source, + target=target, + max_n_iter=max_n_iter, + n_landmarks=n_landmarks, + reg_mode=reg_mode + ) + + # If current mesh is source & apply_transform_to_mesh is true then replace current mesh. + if (as_source is True) & (apply_transform_to_mesh is True): + self.apply_transform_to_mesh(transform=icp_transform) + + if return_transformed_mesh is True: + return self._mesh + + elif return_transform is True: + return icp_transform + + # curent mesh is target, or is source & want to return mesh, then return it. + elif (as_source is False) & (return_transformed_mesh is True): + return apply_transform(source=source, transform=icp_transform) + + else: + raise Exception('Nothing to return from rigid registration.') + + def copy_scalars_from_other_mesh_to_currect( + self, + other_mesh, + new_scalars_name='scalars_from_other_mesh', + weighted_avg=True, # Use weighted average, otherwise guassian smooth transfer + n_closest=3, + sigma=1., + idx_coords_to_smooth_base=None, + idx_coords_to_smooth_other=None, + set_non_smoothed_scalars_to_zero=True, + ): + """ + Convenience function to enable easy transfer scalars from another mesh to the current. + Can use either a gaussian smoothing function, or transfer using nearest neighbours. + + ** This function requires that the `other_mesh` is non-rigidly registered to the surface + of the mesh inside of this class. Or rigidly registered but using the same anatomy that + VERY closely matches. Otherwise, the transfered scalars will be bad. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Mesh we want to copy + new_scalars_name : str, optional + What to name the scalars being transfered to this current mesh, by default 'scalars_from_other_mesh' + weighted_avg : bool, optional + Should we use `weighted average` or `gaussian smooth` methods for transfer, by default True + n_closest : int, optional + If `weighted_avg` True, the number of nearest neighbours to use, by default 3 + sigma : float, optional + If `weighted_avg` False, the standard deviation of gaussian kernel, by default 1. + idx_coords_to_smooth_base : list, optional + If `weighted_avg` False, list of indices from current mesh to use in transfer, by default None + idx_coords_to_smooth_other : list, optional + If `weighted_avg` False, list of indices from `other_mesh` to use in transfer, by default None + set_non_smoothed_scalars_to_zero : bool, optional + Should all other indices (not included in idx_coords_to_smooth_other) be set to 0, by default True + """ + if type(other_mesh) is Mesh: + other_mesh = other_mesh.mesh + elif type(other_mesh) is vtk.vtkPolyData: + pass + else: + raise TypeError(f'other_mesh must be type `pymskt.mesh.Mesh` or `vtk.vtkPolyData` and received: {type(other_mesh)}') + + if weighted_avg is True: + transferred_scalars = transfer_mesh_scalars_get_weighted_average_n_closest( + self._mesh, + other_mesh, + n=n_closest + ) + else: + transferred_scalars = smooth_scalars_from_second_mesh_onto_base( + self._mesh, + other_mesh, + sigma=sigma, + idx_coords_to_smooth_base=idx_coords_to_smooth_base, + idx_coords_to_smooth_second=idx_coords_to_smooth_other, + set_non_smoothed_scalars_to_zero=set_non_smoothed_scalars_to_zero + ) + if (new_scalars_name is None) & (weighted_avg is True): + if transferred_scalars.shape[1] > 1: + n_arrays = other_mesh.GetPointData().GetNumberOfArrays() + array_names = [other_mesh.GetPointData().GetArray(array_idx).GetName() for array_idx in range(n_arrays)] + for idx, array_name in enumerate(array_names): + vtk_transferred_scalars = numpy_to_vtk(transferred_scalars[:,idx]) + vtk_transferred_scalars.SetName(array_name) + self._mesh.GetPointData().AddArray(vtk_transferred_scalars) + return + + vtk_transferred_scalars = numpy_to_vtk(transferred_scalars) + vtk_transferred_scalars.SetName(new_scalars_name) + self._mesh.GetPointData().AddArray(vtk_transferred_scalars) + + @property + def seg_image(self): + """ + Return the `_seg_image` object + + Returns + ------- + SimpleITK.Image + Segmentation image used to build the surface mesh + """ + return self._seg_image + + @seg_image.setter + def seg_image(self, new_seg_image): + """ + Set the `_seg_image` of the class to be the inputted `new_seg_image`. + + Parameters + ---------- + new_seg_image : SimpleITK.Image + New image to use for creating surface mesh. This can be used to provide image to + class if it was not provided during `__init__` + """ + self._seg_image = new_seg_image + + @property + def mesh(self): + """ + Return the `_mesh` object + + Returns + ------- + vtk.vtkPolyData + The main mesh of this class. + """ + return self._mesh + + @mesh.setter + def mesh(self, new_mesh): + """ + Set the `_mesh` of the class to be the inputted `new_mesh` + + Parameters + ---------- + new_mesh : vtk.vtkPolyData + New mesh for this class - or a method to provide a mesh to the class + after `__init__` has already been run. + """ + self._mesh = new_mesh + + @property + def point_coords(self): + """ + Convenience function to return the vertices (point coordinates) for the surface mesh. + + Returns + ------- + numpy.ndarray + Mx3 numpy array containing the x/y/z position of each vertex of the mesh. + """ + return get_mesh_physical_point_coords(self._mesh) + + @point_coords.setter + def point_coords(self, new_point_coords): + """ + Convenience function to change/update the vertices/points locations + + Parameters + ---------- + new_point_coords : numpy.ndarray + n_points X 3 numpy array to replace exisiting point coordinate locations + This can be used to easily/quickly update the x/y/z position of a set of points on a surface mesh. + The `new_point_coords` must include the same number of points as the mesh contains. + """ + orig_point_coords = get_mesh_physical_point_coords(self._mesh) + if new_point_coords.shape == orig_point_coords.shape: + self._mesh.GetPoints().SetData(numpy_to_vtk(new_point_coords)) + + + @property + def path_seg_image(self): + """ + Convenience function to get the `path_seg_image` + + Returns + ------- + str + Path to the segmentation image + """ + return self._path_seg_image + + @path_seg_image.setter + def path_seg_image(self, new_path_seg_image): + """ + Convenience function to set the `path_seg_image` + + Parameters + ---------- + new_path_seg_image : str + String to where segmentation image that should be loaded is. + """ + self._path_seg_image = new_path_seg_image + + @property + def label_idx(self): + """ + Convenience function to get `label_idx` + + Returns + ------- + int + Integer indeicating the index/value of the tissues in `seg_image` associated with this mesh. + """ + return self._label_idx + + @label_idx.setter + def label_idx(self, new_label_idx): + """ + Convenience function to set `label_idx` + + Parameters + ---------- + new_label_idx : int + Integer indeicating the index/value of the tissues in `seg_image` associated with this mesh. + """ + self._label_idx = new_label_idx + + @property + def min_n_pixels(self): + """ + Convenience function to get the minimum number of pixels for a segmentation region to be created as a mesh. + + Returns + ------- + int + Minimum number of pixels needed to create a mesh. Less than this and it will be skipped / error raised. + """ + return self._min_n_pixels + + @min_n_pixels.setter + def min_n_pixels(self, new_min_n_pixels): + """ + Convenience function to set the minimum number of pixels for a segmentation region to be created as a mesh. + + Parameters + ---------- + new_min_n_pixels : int + Minimum number of pixels needed to create a mesh. Less than this and it will be skipped / error raised. + """ + self._min_n_pixels = new_min_n_pixels + + @property + def list_applied_transforms(self): + """ + Convenience function to get the list of transformations that have been applied to this mesh. + + Returns + ------- + list + List of vtk.vtkTransform objects that have been applied to the current mesh. + """ + return self._list_applied_transforms</code></pre> +</details> +<h3>Subclasses</h3> +<ul class="hlist"> +<li><a title="pymskt.mesh.meshes.BoneMesh" href="#pymskt.mesh.meshes.BoneMesh">BoneMesh</a></li> +<li><a title="pymskt.mesh.meshes.CartilageMesh" href="#pymskt.mesh.meshes.CartilageMesh">CartilageMesh</a></li> +</ul> +<h3>Instance variables</h3> +<dl> +<dt id="pymskt.mesh.meshes.Mesh.label_idx"><code class="name">var <span class="ident">label_idx</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get <code>label_idx</code></p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>int</code></dt> +<dd>Integer indeicating the index/value of the tissues in <code>seg_image</code> associated with this mesh.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def label_idx(self): + """ + Convenience function to get `label_idx` + + Returns + ------- + int + Integer indeicating the index/value of the tissues in `seg_image` associated with this mesh. + """ + return self._label_idx</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.list_applied_transforms"><code class="name">var <span class="ident">list_applied_transforms</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get the list of transformations that have been applied to this mesh. </p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>list</code></dt> +<dd>List of vtk.vtkTransform objects that have been applied to the current mesh.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def list_applied_transforms(self): + """ + Convenience function to get the list of transformations that have been applied to this mesh. + + Returns + ------- + list + List of vtk.vtkTransform objects that have been applied to the current mesh. + """ + return self._list_applied_transforms</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.mesh"><code class="name">var <span class="ident">mesh</span></code></dt> +<dd> +<div class="desc"><p>Return the <code>_mesh</code> object</p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>vtk.vtkPolyData</code></dt> +<dd>The main mesh of this class.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def mesh(self): + """ + Return the `_mesh` object + + Returns + ------- + vtk.vtkPolyData + The main mesh of this class. + """ + return self._mesh</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.min_n_pixels"><code class="name">var <span class="ident">min_n_pixels</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get the minimum number of pixels for a segmentation region to be created as a mesh. </p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>int</code></dt> +<dd>Minimum number of pixels needed to create a mesh. Less than this and it will be skipped / error raised.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def min_n_pixels(self): + """ + Convenience function to get the minimum number of pixels for a segmentation region to be created as a mesh. + + Returns + ------- + int + Minimum number of pixels needed to create a mesh. Less than this and it will be skipped / error raised. + """ + return self._min_n_pixels</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.path_seg_image"><code class="name">var <span class="ident">path_seg_image</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to get the <code>path_seg_image</code></p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>str</code></dt> +<dd>Path to the segmentation image</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def path_seg_image(self): + """ + Convenience function to get the `path_seg_image` + + Returns + ------- + str + Path to the segmentation image + """ + return self._path_seg_image</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.point_coords"><code class="name">var <span class="ident">point_coords</span></code></dt> +<dd> +<div class="desc"><p>Convenience function to return the vertices (point coordinates) for the surface mesh. </p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>numpy.ndarray</code></dt> +<dd>Mx3 numpy array containing the x/y/z position of each vertex of the mesh.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def point_coords(self): + """ + Convenience function to return the vertices (point coordinates) for the surface mesh. + + Returns + ------- + numpy.ndarray + Mx3 numpy array containing the x/y/z position of each vertex of the mesh. + """ + return get_mesh_physical_point_coords(self._mesh)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.seg_image"><code class="name">var <span class="ident">seg_image</span></code></dt> +<dd> +<div class="desc"><p>Return the <code>_seg_image</code> object</p> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>SimpleITK.Image</code></dt> +<dd>Segmentation image used to build the surface mesh</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">@property +def seg_image(self): + """ + Return the `_seg_image` object + + Returns + ------- + SimpleITK.Image + Segmentation image used to build the surface mesh + """ + return self._seg_image</code></pre> +</details> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="pymskt.mesh.meshes.Mesh.apply_transform_to_mesh"><code class="name flex"> +<span>def <span class="ident">apply_transform_to_mesh</span></span>(<span>self, transform=None, transformer=None, save_transform=True)</span> +</code></dt> +<dd> +<div class="desc"><p>Apply a transformation to the surface mesh. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>transform</code></strong> : <code>vtk.vtkTransform</code>, optional</dt> +<dd>Transformation to apply to mesh, by default None</dd> +<dt><strong><code>transformer</code></strong> : <code>vtk.vtkTransformFilter</code>, optional</dt> +<dd>Can supply transformFilter directly, by default None</dd> +<dt><strong><code>save_transform</code></strong> : <code>bool</code>, optional</dt> +<dd>Should transform be saved to list of applied transforms, by default True</dd> +</dl> +<h2 id="raises">Raises</h2> +<dl> +<dt><code>Exception</code></dt> +<dd>No <code>transform</code> or <code>transformer</code> supplied - have not transformation +to apply.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def apply_transform_to_mesh(self, + transform=None, + transformer=None, + save_transform=True): + """ + Apply a transformation to the surface mesh. + + Parameters + ---------- + transform : vtk.vtkTransform, optional + Transformation to apply to mesh, by default None + transformer : vtk.vtkTransformFilter, optional + Can supply transformFilter directly, by default None + save_transform : bool, optional + Should transform be saved to list of applied transforms, by default True + + Raises + ------ + Exception + No `transform` or `transformer` supplied - have not transformation + to apply. + """ + if (transform is not None) & (transformer is None): + transformer = vtk.vtkTransformPolyDataFilter() + transformer.SetTransform(transform) + + elif (transform is None) & (transformer is not None): + transform = transformer.GetTransform() + + if transformer is not None: + transformer.SetInputData(self._mesh) + transformer.Update() + self._mesh = vtk_deep_copy(transformer.GetOutput()) + + if save_transform is True: + self._list_applied_transforms.append(transform) + + else: + raise Exception('No transform or transformer provided')</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.copy_scalars_from_other_mesh_to_currect"><code class="name flex"> +<span>def <span class="ident">copy_scalars_from_other_mesh_to_currect</span></span>(<span>self, other_mesh, new_scalars_name='scalars_from_other_mesh', weighted_avg=True, n_closest=3, sigma=1.0, idx_coords_to_smooth_base=None, idx_coords_to_smooth_other=None, set_non_smoothed_scalars_to_zero=True)</span> +</code></dt> +<dd> +<div class="desc"><p>Convenience function to enable easy transfer scalars from another mesh to the current. +Can use either a gaussian smoothing function, or transfer using nearest neighbours. </p> +<p>** This function requires that the <code>other_mesh</code> is non-rigidly registered to the surface +of the mesh inside of this class. Or rigidly registered but using the same anatomy that +VERY closely matches. Otherwise, the transfered scalars will be bad. +</p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>other_mesh</code></strong> : <code>pymskt.mesh.Mesh</code> or <code>vtk.vtkPolyData</code></dt> +<dd>Mesh we want to copy</dd> +<dt><strong><code>new_scalars_name</code></strong> : <code>str</code>, optional</dt> +<dd> </dd> +<dt>What to name the scalars being transfered to this current mesh, by default 'scalars_from_other_mesh'</dt> +<dt><strong><code>weighted_avg</code></strong> : <code>bool</code>, optional</dt> +<dd>Should we use <code>weighted average</code> or <code>gaussian smooth</code> methods for transfer, by default True</dd> +<dt><strong><code>n_closest</code></strong> : <code>int</code>, optional</dt> +<dd>If <code>weighted_avg</code> True, the number of nearest neighbours to use, by default 3</dd> +<dt><strong><code>sigma</code></strong> : <code>float</code>, optional</dt> +<dd>If <code>weighted_avg</code> False, the standard deviation of gaussian kernel, by default 1.</dd> +<dt><strong><code>idx_coords_to_smooth_base</code></strong> : <code>list</code>, optional</dt> +<dd>If <code>weighted_avg</code> False, list of indices from current mesh to use in transfer, by default None</dd> +<dt><strong><code>idx_coords_to_smooth_other</code></strong> : <code>list</code>, optional</dt> +<dd>If <code>weighted_avg</code> False, list of indices from <code>other_mesh</code> to use in transfer, by default None</dd> +<dt><strong><code>set_non_smoothed_scalars_to_zero</code></strong> : <code>bool</code>, optional</dt> +<dd>Should all other indices (not included in idx_coords_to_smooth_other) be set to 0, by default True</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def copy_scalars_from_other_mesh_to_currect( + self, + other_mesh, + new_scalars_name='scalars_from_other_mesh', + weighted_avg=True, # Use weighted average, otherwise guassian smooth transfer + n_closest=3, + sigma=1., + idx_coords_to_smooth_base=None, + idx_coords_to_smooth_other=None, + set_non_smoothed_scalars_to_zero=True, +): + """ + Convenience function to enable easy transfer scalars from another mesh to the current. + Can use either a gaussian smoothing function, or transfer using nearest neighbours. + + ** This function requires that the `other_mesh` is non-rigidly registered to the surface + of the mesh inside of this class. Or rigidly registered but using the same anatomy that + VERY closely matches. Otherwise, the transfered scalars will be bad. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Mesh we want to copy + new_scalars_name : str, optional + What to name the scalars being transfered to this current mesh, by default 'scalars_from_other_mesh' + weighted_avg : bool, optional + Should we use `weighted average` or `gaussian smooth` methods for transfer, by default True + n_closest : int, optional + If `weighted_avg` True, the number of nearest neighbours to use, by default 3 + sigma : float, optional + If `weighted_avg` False, the standard deviation of gaussian kernel, by default 1. + idx_coords_to_smooth_base : list, optional + If `weighted_avg` False, list of indices from current mesh to use in transfer, by default None + idx_coords_to_smooth_other : list, optional + If `weighted_avg` False, list of indices from `other_mesh` to use in transfer, by default None + set_non_smoothed_scalars_to_zero : bool, optional + Should all other indices (not included in idx_coords_to_smooth_other) be set to 0, by default True + """ + if type(other_mesh) is Mesh: + other_mesh = other_mesh.mesh + elif type(other_mesh) is vtk.vtkPolyData: + pass + else: + raise TypeError(f'other_mesh must be type `pymskt.mesh.Mesh` or `vtk.vtkPolyData` and received: {type(other_mesh)}') + + if weighted_avg is True: + transferred_scalars = transfer_mesh_scalars_get_weighted_average_n_closest( + self._mesh, + other_mesh, + n=n_closest + ) + else: + transferred_scalars = smooth_scalars_from_second_mesh_onto_base( + self._mesh, + other_mesh, + sigma=sigma, + idx_coords_to_smooth_base=idx_coords_to_smooth_base, + idx_coords_to_smooth_second=idx_coords_to_smooth_other, + set_non_smoothed_scalars_to_zero=set_non_smoothed_scalars_to_zero + ) + if (new_scalars_name is None) & (weighted_avg is True): + if transferred_scalars.shape[1] > 1: + n_arrays = other_mesh.GetPointData().GetNumberOfArrays() + array_names = [other_mesh.GetPointData().GetArray(array_idx).GetName() for array_idx in range(n_arrays)] + for idx, array_name in enumerate(array_names): + vtk_transferred_scalars = numpy_to_vtk(transferred_scalars[:,idx]) + vtk_transferred_scalars.SetName(array_name) + self._mesh.GetPointData().AddArray(vtk_transferred_scalars) + return + + vtk_transferred_scalars = numpy_to_vtk(transferred_scalars) + vtk_transferred_scalars.SetName(new_scalars_name) + self._mesh.GetPointData().AddArray(vtk_transferred_scalars)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.create_mesh"><code class="name flex"> +<span>def <span class="ident">create_mesh</span></span>(<span>self, smooth_image=True, smooth_image_var=0.15625, marching_cubes_threshold=0.5, label_idx=None, min_n_pixels=None)</span> +</code></dt> +<dd> +<div class="desc"><p>Create a surface mesh from the classes <code>_seg_image</code>. If <code>_seg_image</code> +does not exist, then read it in using <code>read_seg_image</code>. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>smooth_image</code></strong> : <code>bool</code>, optional</dt> +<dd>Should the <code>_seg_image</code> be gaussian filtered, by default True</dd> +<dt><strong><code>smooth_image_var</code></strong> : <code>float</code>, optional</dt> +<dd>Variance of gaussian filter to apply to <code>_seg_image</code>, by default 0.3125/2</dd> +<dt><strong><code>marching_cubes_threshold</code></strong> : <code>float</code>, optional</dt> +<dd>Threshold contour level to create surface mesh on, by default 0.5</dd> +<dt><strong><code>label_idx</code></strong> : <code>int</code>, optional</dt> +<dd>Label value / index to create mesh from, by default None</dd> +<dt><strong><code>min_n_pixels</code></strong> : <code>int</code>, optional</dt> +<dd>Minimum number of continuous pixels to include segmentation island +in the surface mesh creation, by default None</dd> +</dl> +<h2 id="raises">Raises</h2> +<dl> +<dt><code>Exception</code></dt> +<dd>If the total number of pixels segmentated (<code>n_pixels_labelled</code>) is +< <code>min_n_pixels</code> then there is no object in the image.</dd> +<dt><code>Exception</code></dt> +<dd>If no <code>_seg_image</code> and no <code>label_idx</code> then we don't know what tissue to create the +surface mesh from.</dd> +<dt><code>Exception</code></dt> +<dd>If no <code>_seg_image</code> or <code>path_seg_image</code> then we have no image to create mesh from.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def create_mesh(self, + smooth_image=True, + smooth_image_var=0.3125 / 2, + marching_cubes_threshold=0.5, + label_idx=None, + min_n_pixels=None): + """ + Create a surface mesh from the classes `_seg_image`. If `_seg_image` + does not exist, then read it in using `read_seg_image`. + + Parameters + ---------- + smooth_image : bool, optional + Should the `_seg_image` be gaussian filtered, by default True + smooth_image_var : float, optional + Variance of gaussian filter to apply to `_seg_image`, by default 0.3125/2 + marching_cubes_threshold : float, optional + Threshold contour level to create surface mesh on, by default 0.5 + label_idx : int, optional + Label value / index to create mesh from, by default None + min_n_pixels : int, optional + Minimum number of continuous pixels to include segmentation island + in the surface mesh creation, by default None + + Raises + ------ + Exception + If the total number of pixels segmentated (`n_pixels_labelled`) is + < `min_n_pixels` then there is no object in the image. + Exception + If no `_seg_image` and no `label_idx` then we don't know what tissue to create the + surface mesh from. + Exception + If no `_seg_image` or `path_seg_image` then we have no image to create mesh from. + """ + # allow assigning label idx during mesh creation step. + if label_idx is not None: + self._label_idx = label_idx + + if self._seg_image is None: + self.read_seg_image() + + # Ensure the image has a certain number of pixels with the label of interest, otherwise there might be an issue. + if min_n_pixels is None: min_n_pixels = self._min_n_pixels + seg_view = sitk.GetArrayViewFromImage(self._seg_image) + n_pixels_labelled = sum(seg_view[seg_view == self._label_idx]) + + if n_pixels_labelled < min_n_pixels: + raise Exception('The mesh does not exist in this segmentation!, only {} pixels detected, threshold # is {}'.format(n_pixels_labelled, + marching_cubes_threshold)) + tmp_filename = ''.join(random.choice(string.ascii_lowercase) for i in range(10)) + '.nrrd' + self._mesh = create_surface_mesh(self._seg_image, + self._label_idx, + smooth_image_var, + loc_tmp_save='/tmp', + tmp_filename=tmp_filename, + mc_threshold=marching_cubes_threshold, + filter_binary_image=smooth_image + ) + safely_delete_tmp_file('/tmp', + tmp_filename)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.non_rigidly_register"><code class="name flex"> +<span>def <span class="ident">non_rigidly_register</span></span>(<span>self, other_mesh, as_source=True, apply_transform_to_mesh=True, return_transformed_mesh=False, **kwargs)</span> +</code></dt> +<dd> +<div class="desc"><p>Function to perform non rigid registration between this mesh and another mesh. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>other_mesh</code></strong> : <code>pymskt.mesh.Mesh</code> or <code>vtk.vtkPolyData</code></dt> +<dd>Other mesh to use in registration process</dd> +<dt><strong><code>as_source</code></strong> : <code>bool</code>, optional</dt> +<dd>Should the current mesh (in this object) be the source or the target, by default True</dd> +<dt><strong><code>apply_transform_to_mesh</code></strong> : <code>bool</code>, optional</dt> +<dd>If as_source is True should we apply transformation to internal mesh, by default True</dd> +<dt><strong><code>return_transformed_mesh</code></strong> : <code>bool</code>, optional</dt> +<dd>Should we return the registered mesh, by default False</dd> +</dl> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>_type_</code></dt> +<dd><em>description</em></dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def non_rigidly_register( + self, + other_mesh, + as_source=True, + apply_transform_to_mesh=True, + return_transformed_mesh=False, + **kwargs +): + """ + Function to perform non rigid registration between this mesh and another mesh. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Other mesh to use in registration process + as_source : bool, optional + Should the current mesh (in this object) be the source or the target, by default True + apply_transform_to_mesh : bool, optional + If as_source is True should we apply transformation to internal mesh, by default True + return_transformed_mesh : bool, optional + Should we return the registered mesh, by default False + + Returns + ------- + _type_ + _description_ + """ + # Setup the source & target meshes based on `as_source`` + if as_source is True: + source = self._mesh + target = other_mesh + elif as_source is False: + source = other_mesh + target = self._mesh + + # Get registered mesh (source to target) + source_transformed_to_target = non_rigidly_register( + target_mesh=target, + source_mesh=source, + **kwargs + ) + + # If current mesh is source & apply_transform_to_mesh is true then replace current mesh. + if (as_source is True) & (apply_transform_to_mesh is True): + self._mesh = source_transformed_to_target + + # curent mesh is target, or is source & want to return mesh, then return it. + if (as_source is False) or ((as_source is True) & (return_transformed_mesh is True)): + return source_transformed_to_target</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.read_seg_image"><code class="name flex"> +<span>def <span class="ident">read_seg_image</span></span>(<span>self, path_seg_image=None)</span> +</code></dt> +<dd> +<div class="desc"><p>Read segmentation image from disk. Must be a single file (e.g., nrrd, 3D dicom)</p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>path_seg_image</code></strong> : <code>str</code>, optional</dt> +<dd>Path to the medical image file to be loaded in, by default None</dd> +</dl> +<h2 id="raises">Raises</h2> +<dl> +<dt><code>Exception</code></dt> +<dd>If path_seg_image does not exist, exception is raised.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def read_seg_image(self, + path_seg_image=None): + """ + Read segmentation image from disk. Must be a single file (e.g., nrrd, 3D dicom) + + Parameters + ---------- + path_seg_image : str, optional + Path to the medical image file to be loaded in, by default None + + Raises + ------ + Exception + If path_seg_image does not exist, exception is raised. + """ + # If passing new location/seg image name, then update variables. + if path_seg_image is not None: + self._path_seg_image = path_seg_image + + # If seg image location / name exist, then load image else raise exception + if (self._path_seg_image is not None): + self._seg_image = sitk.ReadImage(self._path_seg_image) + else: + raise Exception('No file path (self._path_seg_image) provided.')</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.resample_surface"><code class="name flex"> +<span>def <span class="ident">resample_surface</span></span>(<span>self, subdivisions=2, clusters=10000)</span> +</code></dt> +<dd> +<div class="desc"><p>Resample a surface mesh using the ACVD algorithm: +Version used: +- <a href="https://github.com/pyvista/pyacvd">https://github.com/pyvista/pyacvd</a> +Original version w/ more references: +- <a href="https://github.com/valette/ACVD">https://github.com/valette/ACVD</a></p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>subdivisions</code></strong> : <code>int</code>, optional</dt> +<dd>Subdivide the mesh to have more points before clustering, by default 2 +Probably not necessary for very dense meshes.</dd> +<dt><strong><code>clusters</code></strong> : <code>int</code>, optional</dt> +<dd>The number of clusters (points/vertices) to create during resampling +surafce, by default 10000 +- This is not exact, might have slight differences.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def resample_surface(self, + subdivisions=2, + clusters=10000 + ): + """ + Resample a surface mesh using the ACVD algorithm: + Version used: + - https://github.com/pyvista/pyacvd + Original version w/ more references: + - https://github.com/valette/ACVD + + Parameters + ---------- + subdivisions : int, optional + Subdivide the mesh to have more points before clustering, by default 2 + Probably not necessary for very dense meshes. + clusters : int, optional + The number of clusters (points/vertices) to create during resampling + surafce, by default 10000 + - This is not exact, might have slight differences. + """ + self._mesh = resample_surface(self._mesh, subdivisions=subdivisions, clusters=clusters)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.reverse_all_transforms"><code class="name flex"> +<span>def <span class="ident">reverse_all_transforms</span></span>(<span>self)</span> +</code></dt> +<dd> +<div class="desc"><p>Function to iterate over all of the self._list_applied_transforms (in reverse order) and undo them.</p></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def reverse_all_transforms(self): + """ + Function to iterate over all of the self._list_applied_transforms (in reverse order) and undo them. + """ + while len(self._list_applied_transforms) > 0: + self.reverse_most_recent_transform()</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.reverse_most_recent_transform"><code class="name flex"> +<span>def <span class="ident">reverse_most_recent_transform</span></span>(<span>self)</span> +</code></dt> +<dd> +<div class="desc"><p>Function to undo the most recent transformation stored in self._list_applied_transforms</p></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def reverse_most_recent_transform(self): + """ + Function to undo the most recent transformation stored in self._list_applied_transforms + """ + transform = self._list_applied_transforms.pop() + transform.Inverse() + self.apply_transform_to_mesh(transform=transform, save_transform=False)</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.rigidly_register"><code class="name flex"> +<span>def <span class="ident">rigidly_register</span></span>(<span>self, other_mesh, as_source=True, apply_transform_to_mesh=True, return_transformed_mesh=False, return_transform=False, max_n_iter=100, n_landmarks=1000, reg_mode='similarity')</span> +</code></dt> +<dd> +<div class="desc"><p>Function to perform rigid registration between this mesh and another mesh. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>other_mesh</code></strong> : <code>pymskt.mesh.Mesh</code> or <code>vtk.vtkPolyData</code></dt> +<dd>Other mesh to use in registration process</dd> +<dt><strong><code>as_source</code></strong> : <code>bool</code>, optional</dt> +<dd>Should the current mesh (in this object) be the source or the target, by default True</dd> +<dt><strong><code>apply_transform_to_mesh</code></strong> : <code>bool</code>, optional</dt> +<dd>If as_source is True should we apply transformation to internal mesh, by default True</dd> +<dt><strong><code>return_transformed_mesh</code></strong> : <code>bool</code>, optional</dt> +<dd>Should we return the registered mesh, by default False</dd> +<dt><strong><code>max_n_iter</code></strong> : <code>int</code>, optional</dt> +<dd>Maximum number of iterations to perform, by default 100</dd> +<dt><strong><code>n_landmarks</code></strong> : <code>int</code>, optional</dt> +<dd>Number of landmarks to use in registration, by default 1000</dd> +<dt><strong><code>reg_mode</code></strong> : <code>str</code>, optional</dt> +<dd>Mode of registration to use, by default 'similarity' (similarity, rigid, or affine)</dd> +</dl> +<h2 id="returns">Returns</h2> +<dl> +<dt><code>_type_</code></dt> +<dd><em>description</em></dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def rigidly_register( + self, + other_mesh, + as_source=True, + apply_transform_to_mesh=True, + return_transformed_mesh=False, + return_transform=False, + max_n_iter=100, + n_landmarks=1000, + reg_mode='similarity' + +): + """ + Function to perform rigid registration between this mesh and another mesh. + + Parameters + ---------- + other_mesh : pymskt.mesh.Mesh or vtk.vtkPolyData + Other mesh to use in registration process + as_source : bool, optional + Should the current mesh (in this object) be the source or the target, by default True + apply_transform_to_mesh : bool, optional + If as_source is True should we apply transformation to internal mesh, by default True + return_transformed_mesh : bool, optional + Should we return the registered mesh, by default False + max_n_iter : int, optional + Maximum number of iterations to perform, by default 100 + n_landmarks : int, optional + Number of landmarks to use in registration, by default 1000 + reg_mode : str, optional + Mode of registration to use, by default 'similarity' (similarity, rigid, or affine) + + Returns + ------- + _type_ + _description_ + """ + + if (return_transform is True) & (return_transformed_mesh is True): + raise Exception('Cannot return both transformed mesh and transform') + + if type(other_mesh) in (pymskt.mesh.meshes.BoneMesh, pymskt.mesh.meshes.Mesh): + other_mesh = other_mesh.mesh + + # Setup the source & target meshes based on `as_source`` + if as_source is True: + source = self._mesh + target = other_mesh + elif as_source is False: + source = other_mesh + target = self._mesh + + icp_transform = get_icp_transform( + source=source, + target=target, + max_n_iter=max_n_iter, + n_landmarks=n_landmarks, + reg_mode=reg_mode + ) + + # If current mesh is source & apply_transform_to_mesh is true then replace current mesh. + if (as_source is True) & (apply_transform_to_mesh is True): + self.apply_transform_to_mesh(transform=icp_transform) + + if return_transformed_mesh is True: + return self._mesh + + elif return_transform is True: + return icp_transform + + # curent mesh is target, or is source & want to return mesh, then return it. + elif (as_source is False) & (return_transformed_mesh is True): + return apply_transform(source=source, transform=icp_transform) + + else: + raise Exception('Nothing to return from rigid registration.')</code></pre> +</details> +</dd> +<dt id="pymskt.mesh.meshes.Mesh.save_mesh"><code class="name flex"> +<span>def <span class="ident">save_mesh</span></span>(<span>self, filepath)</span> +</code></dt> +<dd> +<div class="desc"><p>Save the surface mesh from this class to disk. </p> +<h2 id="parameters">Parameters</h2> +<dl> +<dt><strong><code>filepath</code></strong> : <code>str</code></dt> +<dd>Location & filename to save the surface mesh (vtk.vtkPolyData) to.</dd> +</dl></div> +<details class="source"> +<summary> +<span>Expand source code</span> +</summary> +<pre><code class="python">def save_mesh(self, + filepath): + """ + Save the surface mesh from this class to disk. + + Parameters + ---------- + filepath : str + Location & filename to save the surface mesh (vtk.vtkPolyData) to. + """ + io.write_vtk(self._mesh, filepath)</code></pre> +</details> +</dd> +</dl> +</dd> +</dl> +</section> +</article> +<nav id="sidebar"> +<h1>Index</h1> +<div class="toc"> +<ul></ul> +</div> +<ul id="index"> +<li><h3>Super-module</h3> +<ul> +<li><code><a title="pymskt.mesh" href="index.html">pymskt.mesh</a></code></li> +</ul> +</li> +<li><h3><a href="#header-classes">Classes</a></h3> +<ul> +<li> +<h4><code><a title="pymskt.mesh.meshes.BoneMesh" href="#pymskt.mesh.meshes.BoneMesh">BoneMesh</a></code></h4> +<ul class=""> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.assign_cartilage_regions" href="#pymskt.mesh.meshes.BoneMesh.assign_cartilage_regions">assign_cartilage_regions</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.bone" href="#pymskt.mesh.meshes.BoneMesh.bone">bone</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.calc_cartilage_t2" href="#pymskt.mesh.meshes.BoneMesh.calc_cartilage_t2">calc_cartilage_t2</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.calc_cartilage_thickness" href="#pymskt.mesh.meshes.BoneMesh.calc_cartilage_thickness">calc_cartilage_thickness</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.create_cartilage_meshes" href="#pymskt.mesh.meshes.BoneMesh.create_cartilage_meshes">create_cartilage_meshes</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.create_mesh" href="#pymskt.mesh.meshes.BoneMesh.create_mesh">create_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.crop_percent" href="#pymskt.mesh.meshes.BoneMesh.crop_percent">crop_percent</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.list_cartilage_labels" href="#pymskt.mesh.meshes.BoneMesh.list_cartilage_labels">list_cartilage_labels</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.list_cartilage_meshes" href="#pymskt.mesh.meshes.BoneMesh.list_cartilage_meshes">list_cartilage_meshes</a></code></li> +<li><code><a title="pymskt.mesh.meshes.BoneMesh.smooth_surface_scalars" href="#pymskt.mesh.meshes.BoneMesh.smooth_surface_scalars">smooth_surface_scalars</a></code></li> +</ul> +</li> +<li> +<h4><code><a title="pymskt.mesh.meshes.CartilageMesh" href="#pymskt.mesh.meshes.CartilageMesh">CartilageMesh</a></code></h4> +</li> +<li> +<h4><code><a title="pymskt.mesh.meshes.Mesh" href="#pymskt.mesh.meshes.Mesh">Mesh</a></code></h4> +<ul class=""> +<li><code><a title="pymskt.mesh.meshes.Mesh.apply_transform_to_mesh" href="#pymskt.mesh.meshes.Mesh.apply_transform_to_mesh">apply_transform_to_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.copy_scalars_from_other_mesh_to_currect" href="#pymskt.mesh.meshes.Mesh.copy_scalars_from_other_mesh_to_currect">copy_scalars_from_other_mesh_to_currect</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.create_mesh" href="#pymskt.mesh.meshes.Mesh.create_mesh">create_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.label_idx" href="#pymskt.mesh.meshes.Mesh.label_idx">label_idx</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.list_applied_transforms" href="#pymskt.mesh.meshes.Mesh.list_applied_transforms">list_applied_transforms</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.mesh" href="#pymskt.mesh.meshes.Mesh.mesh">mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.min_n_pixels" href="#pymskt.mesh.meshes.Mesh.min_n_pixels">min_n_pixels</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.non_rigidly_register" href="#pymskt.mesh.meshes.Mesh.non_rigidly_register">non_rigidly_register</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.path_seg_image" href="#pymskt.mesh.meshes.Mesh.path_seg_image">path_seg_image</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.point_coords" href="#pymskt.mesh.meshes.Mesh.point_coords">point_coords</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.read_seg_image" href="#pymskt.mesh.meshes.Mesh.read_seg_image">read_seg_image</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.resample_surface" href="#pymskt.mesh.meshes.Mesh.resample_surface">resample_surface</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.reverse_all_transforms" href="#pymskt.mesh.meshes.Mesh.reverse_all_transforms">reverse_all_transforms</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.reverse_most_recent_transform" href="#pymskt.mesh.meshes.Mesh.reverse_most_recent_transform">reverse_most_recent_transform</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.rigidly_register" href="#pymskt.mesh.meshes.Mesh.rigidly_register">rigidly_register</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.save_mesh" href="#pymskt.mesh.meshes.Mesh.save_mesh">save_mesh</a></code></li> +<li><code><a title="pymskt.mesh.meshes.Mesh.seg_image" href="#pymskt.mesh.meshes.Mesh.seg_image">seg_image</a></code></li> +</ul> +</li> +</ul> +</li> +</ul> +</nav> +</main> +<footer id="footer"> +<p>Generated by <a href="https://pdoc3.github.io/pdoc" title="pdoc: Python API documentation generator"><cite>pdoc</cite> 0.10.0</a>.</p> +</footer> +</body> +</html> \ No newline at end of file