<!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.meshTools 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.meshTools</code></h1>
</header>
<section id="section-intro">
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">import os
import time
from turtle import distance
import vtk
from vtk.util.numpy_support import vtk_to_numpy, numpy_to_vtk
import SimpleITK as sitk
import pyacvd
import pyvista as pv
import numpy as np
from pymskt.utils import n2l, l2n, safely_delete_tmp_file
from pymskt.mesh.utils import is_hit, get_intersect, get_surface_normals, get_obb_surface
import pymskt.image as pybtimage
import pymskt.mesh.createMesh as createMesh
import pymskt.mesh.meshTransform as meshTransform
from pymskt.cython_functions import gaussian_kernel
epsilon = 1e-7
class ProbeVtkImageDataAlongLine:
"""
Class to find values along a line. This is used to get things like the mean T2 value normal
to a bones surface & within the cartialge region. This is done by defining a line in a
particualar location.
Parameters
----------
line_resolution : float
How many points to create along the line.
vtk_image : vtk.vtkImageData
Image read into vtk so that we can apply the probe to it.
save_data_in_class : bool, optional
Whether or not to save data along the line(s) to the class, by default True
save_mean : bool, optional
Whether the mean value should be saved along the line, by default False
save_std : bool, optional
Whether the standard deviation of the data along the line should be
saved, by default False
save_most_common : bool, optional
Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False
filler : int, optional
What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0
non_zero_only : bool, optional
Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.
Attributes
----------
save_mean : bool
Whether the mean value should be saved along the line, by default False
save_std : bool
Whether the standard deviation of the data along the line should be
saved, by default False
save_most_common : bool
Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False
filler : float
What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0
non_zero_only : bool
Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.
line : vtk.vtkLineSource
Line to put into `probe_filter` and to determine mean/std/common values for.
probe_filter : vtk.vtkProbeFilter
Filter to use to get the image data along the line.
_mean_data : list
List of the mean values for each vertex / line projected
_std_data : list
List of standard deviation of each vertex / line projected
_most_common_data : list
List of most common data of each vertex / line projected
Methods
-------
"""
def __init__(self,
line_resolution,
vtk_image,
save_data_in_class=True,
save_mean=False,
save_std=False,
save_most_common=False,
save_max=False,
filler=0,
non_zero_only=True,
data_categorical=False
):
"""[summary]
Parameters
----------
line_resolution : float
How many points to create along the line.
vtk_image : vtk.vtkImageData
Image read into vtk so that we can apply the probe to it.
save_data_in_class : bool, optional
Whether or not to save data along the line(s) to the class, by default True
save_mean : bool, optional
Whether the mean value should be saved along the line, by default False
save_std : bool, optional
Whether the standard deviation of the data along the line should be
saved, by default False
save_most_common : bool, optional
Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False
save_max : bool, optional
Whether the max value should be saved along the line, be default False
filler : int, optional
What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0
non_zero_only : bool, optional
Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.
data_categorical : bool, optional
Specify whether or not the data is categorical to determine the interpolation
method that should be used.
"""
self.save_mean = save_mean
self.save_std = save_std
self.save_most_common = save_most_common
self.save_max = save_max
self.filler = filler
self.non_zero_only = non_zero_only
self.line = vtk.vtkLineSource()
self.line.SetResolution(line_resolution)
self.probe_filter = vtk.vtkProbeFilter()
self.probe_filter.SetSourceData(vtk_image)
if data_categorical is True:
self.probe_filter.CategoricalDataOn()
if save_data_in_class is True:
if self.save_mean is True:
self._mean_data = []
if self.save_std is True:
self._std_data = []
if self.save_most_common is True:
self._most_common_data = []
if self.save_max is True:
self._max_data = []
def get_data_along_line(self,
start_pt,
end_pt):
"""
Function to get scalar values along a line between `start_pt` and `end_pt`.
Parameters
----------
start_pt : list
List of the x,y,z position of the starting point in the line.
end_pt : list
List of the x,y,z position of the ending point in the line.
Returns
-------
numpy.ndarray
numpy array of scalar values obtained along the line.
"""
self.line.SetPoint1(start_pt)
self.line.SetPoint2(end_pt)
self.probe_filter.SetInputConnection(self.line.GetOutputPort())
self.probe_filter.Update()
scalars = vtk_to_numpy(self.probe_filter.GetOutput().GetPointData().GetScalars())
if self.non_zero_only is True:
scalars = scalars[scalars != 0]
return scalars
def save_data_along_line(self,
start_pt,
end_pt):
"""
Save the appropriate outcomes to a growing list.
Parameters
----------
start_pt : list
List of the x,y,z position of the starting point in the line.
end_pt : list
List of the x,y,z position of the ending point in the line.
"""
scalars = self.get_data_along_line(start_pt, end_pt)
if len(scalars) > 0:
if self.save_mean is True:
self._mean_data.append(np.mean(scalars))
if self.save_std is True:
self._std_data.append(np.std(scalars, ddof=1))
if self.save_most_common is True:
# most_common is for getting segmentations and trying to assign a bone region
# to be a cartilage ROI. This is becuase there might be a normal vector that
# cross > 1 cartilage region (e.g., weight-bearing vs anterior fem cartilage)
self._most_common_data.append(np.bincount(scalars).argmax())
if self.save_max is True:
self._max_data.append(np.max(scalars))
else:
self.append_filler()
def append_filler(self):
"""
Add filler value to the requisite lists (_mean_data, _std_data, etc.) as
appropriate.
"""
if self.save_mean is True:
self._mean_data.append(self.filler)
if self.save_std is True:
self._std_data.append(self.filler)
if self.save_most_common is True:
self._most_common_data.append(self.filler)
if self.save_max is True:
self._max_data.append(self.filler)
@property
def mean_data(self):
"""
Return the `_mean_data`
Returns
-------
list
List of mean values along each line tested.
"""
if self.save_mean is True:
return self._mean_data
else:
return None
@property
def std_data(self):
"""
Return the `_std_data`
Returns
-------
list
List of the std values along each line tested.
"""
if self.save_std is True:
return self._std_data
else:
return None
@property
def most_common_data(self):
"""
Return the `_most_common_data`
Returns
-------
list
List of the most common value for each line tested.
"""
if self.save_most_common is True:
return self._most_common_data
else:
return None
@property
def max_data(self):
"""
Return the `_max_data`
Returns
-------
list
List of the most common value for each line tested.
"""
if self.save_max is True:
return self._max_data
else:
return None
def get_cartilage_properties_at_points(surface_bone,
surface_cartilage,
t2_vtk_image=None,
seg_vtk_image=None,
ray_cast_length=20.,
percent_ray_length_opposite_direction=0.25,
no_thickness_filler=0.,
no_t2_filler=0.,
no_seg_filler=0,
line_resolution=100): # Could be nan??
"""
Extract cartilage outcomes (T2 & thickness) at all points on bone surface.
Parameters
----------
surface_bone : BoneMesh
Bone mesh containing vtk.vtkPolyData - get outcomes for nodes (vertices) on
this mesh
surface_cartilage : CartilageMesh
Cartilage mesh containing vtk.vtkPolyData - for obtaining cartilage outcomes.
t2_vtk_image : vtk.vtkImageData, optional
vtk object that contains our Cartilage T2 data, by default None
seg_vtk_image : vtk.vtkImageData, optional
vtk object that contains the segmentation mask(s) to help assign
labels to bone surface (e.g., most common), 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 20.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
no_thickness_filler : float, optional
Value to use instead of thickness (if no cartilage), by default 0.
no_t2_filler : float, optional
Value to use instead of T2 (if no cartilage), by default 0.
no_seg_filler : int, optional
Value to use if no segmentation label available (because no cartilage?), by default 0
line_resolution : int, optional
Number of points to have along line, by default 100
Returns
-------
list
Will return list of data for:
Cartilage thickness
Mean T2 at each point on bone
Most common cartilage label at each point on bone (normal to surface).
"""
normals = get_surface_normals(surface_bone)
points = surface_bone.GetPoints()
obb_cartilage = get_obb_surface(surface_cartilage)
point_normals = normals.GetOutput().GetPointData().GetNormals()
thickness_data = []
if (t2_vtk_image is not None) or (seg_vtk_image is not None):
# if T2 data, or a segmentation image is provided, then setup Probe tool to
# get T2 values and/or cartilage ROI for each bone vertex.
line = vtk.vtkLineSource()
line.SetResolution(line_resolution)
if t2_vtk_image is not None:
t2_data_probe = ProbeVtkImageDataAlongLine(line_resolution,
t2_vtk_image,
save_mean=True,
filler=no_t2_filler)
if seg_vtk_image is not None:
seg_data_probe = ProbeVtkImageDataAlongLine(line_resolution,
seg_vtk_image,
save_most_common=True,
filler=no_seg_filler,
data_categorical=True)
# Loop through all points
for idx in range(points.GetNumberOfPoints()):
point = points.GetPoint(idx)
normal = point_normals.GetTuple(idx)
end_point_ray = n2l(l2n(point) + ray_cast_length*l2n(normal))
start_point_ray = n2l(l2n(point) + ray_cast_length*percent_ray_length_opposite_direction*(-l2n(normal)))
# Check if there are any intersections for the given ray
if is_hit(obb_cartilage, start_point_ray, end_point_ray): # intersections were found
# Retrieve coordinates of intersection points and intersected cell ids
points_intersect, cell_ids_intersect = get_intersect(obb_cartilage, start_point_ray, end_point_ray)
# points
if len(points_intersect) == 2:
thickness_data.append(np.sqrt(np.sum(np.square(l2n(points_intersect[0]) - l2n(points_intersect[1])))))
if t2_vtk_image is not None:
t2_data_probe.save_data_along_line(start_pt=points_intersect[0],
end_pt=points_intersect[1])
if seg_vtk_image is not None:
seg_data_probe.save_data_along_line(start_pt=points_intersect[0],
end_pt=points_intersect[1])
else:
thickness_data.append(no_thickness_filler)
if t2_vtk_image is not None:
t2_data_probe.append_filler()
if seg_vtk_image is not None:
seg_data_probe.append_filler()
else:
thickness_data.append(no_thickness_filler)
if t2_vtk_image is not None:
t2_data_probe.append_filler()
if seg_vtk_image is not None:
seg_data_probe.append_filler()
if (t2_vtk_image is None) & (seg_vtk_image is None):
return np.asarray(thickness_data, dtype=np.float)
elif (t2_vtk_image is not None) & (seg_vtk_image is not None):
return (np.asarray(thickness_data, dtype=np.float),
np.asarray(t2_data_probe.mean_data, dtype=np.float),
np.asarray(seg_data_probe.most_common_data, dtype=np.int)
)
elif t2_vtk_image is not None:
return (np.asarray(thickness_data, dtype=np.float),
np.asarray(t2_data_probe.mean_data, dtype=np.float)
)
elif seg_vtk_image is not None:
return (np.asarray(thickness_data, dtype=np.float),
np.asarray(seg_data_probe.most_common_data, dtype=np.int)
)
def set_mesh_physical_point_coords(mesh, new_points):
"""
Convenience function to update the x/y/z point coords of a mesh
Nothing is returned becuase the mesh object is updated in-place.
Parameters
----------
mesh : vtk.vtkPolyData
Mesh object we want to update the point coordinates for
new_points : np.ndarray
Numpy array shaped n_points x 3. These are the new point coordinates that
we want to update the mesh to have.
"""
orig_point_coords = get_mesh_physical_point_coords(mesh)
if new_points.shape == orig_point_coords.shape:
mesh.GetPoints().SetData(numpy_to_vtk(new_points))
def get_mesh_physical_point_coords(mesh):
"""
Get a numpy array of the x/y/z location of each point (vertex) on the `mesh`.
Parameters
----------
mesh :
[description]
Returns
-------
numpy.ndarray
n_points x 3 array describing the x/y/z position of each point.
Notes
-----
Below is the original method used to retrieve the point coordinates.
point_coordinates = np.zeros((mesh.GetNumberOfPoints(), 3))
for pt_idx in range(mesh.GetNumberOfPoints()):
point_coordinates[pt_idx, :] = mesh.GetPoint(pt_idx)
"""
point_coordinates = vtk_to_numpy(mesh.GetPoints().GetData())
return point_coordinates
def smooth_scalars_from_second_mesh_onto_base(base_mesh,
second_mesh,
sigma=1.,
idx_coords_to_smooth_base=None,
idx_coords_to_smooth_second=None,
set_non_smoothed_scalars_to_zero=True
): # sigma is equal to fwhm=2 (1mm in each direction)
"""
Function to copy surface scalars from one mesh to another. This is done in a "smoothing" fashioon
to get a weighted-average of the closest point - this is because the points on the 2 meshes won't
be coincident with one another. The weighted average is done using a gaussian smoothing.
Parameters
----------
base_mesh : vtk.vtkPolyData
The base mesh to smooth the scalars from `second_mesh` onto.
second_mesh : vtk.vtkPolyData
The mesh with the scalar values that we want to pass onto the `base_mesh`.
sigma : float, optional
Sigma (standard deviation) of gaussian filter to apply to scalars, by default 1.
idx_coords_to_smooth_base : list, optional
List of the indices of nodes that are of interest for transferring (typically cartilage),
by default None
idx_coords_to_smooth_second : list, optional
List of the indices of the nodes that are of interest on the second mesh, by default None
set_non_smoothed_scalars_to_zero : bool, optional
Whether or not to set all notes that are not smoothed to zero, by default True
Returns
-------
numpy.ndarray
An array of the scalar values for each node on the base mesh that includes the scalar values
transfered (smoothed) from the secondary mesh.
"""
base_mesh_pts = get_mesh_physical_point_coords(base_mesh)
if idx_coords_to_smooth_base is not None:
base_mesh_pts = base_mesh_pts[idx_coords_to_smooth_base, :]
second_mesh_pts = get_mesh_physical_point_coords(second_mesh)
if idx_coords_to_smooth_second is not None:
second_mesh_pts = second_mesh_pts[idx_coords_to_smooth_second, :]
gauss_kernel = gaussian_kernel(base_mesh_pts, second_mesh_pts, sigma=sigma)
second_mesh_scalars = np.copy(vtk_to_numpy(second_mesh.GetPointData().GetScalars()))
if idx_coords_to_smooth_second is not None:
# If sub-sampled second mesh - then only give the scalars from those sub-sampled points on mesh.
second_mesh_scalars = second_mesh_scalars[idx_coords_to_smooth_second]
smoothed_scalars_on_base = np.sum(gauss_kernel * second_mesh_scalars, axis=1)
if idx_coords_to_smooth_base is not None:
# if sub-sampled baseline mesh (only want to set cartilage to certain points/vertices), then
# set the calculated smoothed scalars to only those nodes (and leave all other nodes the same as they were
# originally.
if set_non_smoothed_scalars_to_zero is True:
base_mesh_scalars = np.zeros(base_mesh.GetNumberOfPoints())
else:
base_mesh_scalars = np.copy(vtk_to_numpy(base_mesh.GetPointData().GetScalars()))
base_mesh_scalars[idx_coords_to_smooth_base] = smoothed_scalars_on_base
return base_mesh_scalars
else:
return smoothed_scalars_on_base
def transfer_mesh_scalars_get_weighted_average_n_closest(new_mesh, old_mesh, n=3):
"""
Transfer scalars from old_mesh to new_mesh using the weighted-average of the `n` closest
nodes/points/vertices. Similar but not exactly the same as `smooth_scalars_from_second_mesh_onto_base`
This function is ideally used for things like transferring cartilage thickness values from one mesh to another
after they have been registered together. This is necessary for things like performing statistical analyses or
getting aggregate statistics.
Parameters
----------
new_mesh : vtk.vtkPolyData
The new mesh that we want to transfer scalar values onto. Also `base_mesh` from
`smooth_scalars_from_second_mesh_onto_base`
old_mesh : vtk.vtkPolyData
The mesh that we want to transfer scalars from. Also called `second_mesh` from
`smooth_scalars_from_second_mesh_onto_base`
n : int, optional
The number of closest nodes that we want to get weighed average of, by default 3
Returns
-------
numpy.ndarray
An array of the scalar values for each node on the `new_mesh` that includes the scalar values
transfered (smoothed) from the `old_mesh`.
"""
kDTree = vtk.vtkKdTreePointLocator()
kDTree.SetDataSet(old_mesh)
kDTree.BuildLocator()
n_arrays = old_mesh.GetPointData().GetNumberOfArrays()
array_names = [old_mesh.GetPointData().GetArray(array_idx).GetName() for array_idx in range(n_arrays)]
new_scalars = np.zeros((new_mesh.GetNumberOfPoints(), n_arrays))
scalars_old_mesh = [np.copy(vtk_to_numpy(old_mesh.GetPointData().GetArray(array_name))) for array_name in array_names]
# print('len scalars_old_mesh', len(scalars_old_mesh))
# scalars_old_mesh = np.copy(vtk_to_numpy(old_mesh.GetPointData().GetScalars()))
for new_mesh_pt_idx in range(new_mesh.GetNumberOfPoints()):
point = new_mesh.GetPoint(new_mesh_pt_idx)
closest_ids = vtk.vtkIdList()
kDTree.FindClosestNPoints(n, point, closest_ids)
list_scalars = []
distance_weighting = []
for closest_pts_idx in range(closest_ids.GetNumberOfIds()):
pt_idx = closest_ids.GetId(closest_pts_idx)
_point = old_mesh.GetPoint(pt_idx)
list_scalars.append([scalars[pt_idx] for scalars in scalars_old_mesh])
distance_weighting.append(1 / np.sqrt(np.sum(np.square(np.asarray(point) - np.asarray(_point) + epsilon))))
total_distance = np.sum(distance_weighting)
# print('list_scalars', list_scalars)
# print('distance_weighting', distance_weighting)
# print('total_distance', total_distance)
normalized_value = np.sum(np.asarray(list_scalars) * np.expand_dims(np.asarray(distance_weighting), axis=1),
axis=0) / total_distance
# print('new_mesh_pt_idx', new_mesh_pt_idx)
# print('normalized_value', normalized_value)
# print('new_scalars shape', new_scalars.shape)
new_scalars[new_mesh_pt_idx, :] = normalized_value
return new_scalars
def get_smoothed_scalars(mesh, max_dist=2.0, order=2, gaussian=False):
"""
perform smoothing of scalars on the nodes of a surface mesh.
return the smoothed values of the nodes so they can be used as necessary.
(e.g. to replace originals or something else)
Smoothing is done for all data within `max_dist` and uses a simple weighted average based on
the distance to the power of `order`. Default is squared distance (`order=2`)
Parameters
----------
mesh : vtk.vtkPolyData
Surface mesh that we want to smooth scalars of.
max_dist : float, optional
Maximum distance of nodes that we want to smooth (mm), by default 2.0
order : int, optional
Order of the polynomial used for weighting other nodes within `max_dist`, by default 2
gaussian : bool, optional
Should this use a gaussian smoothing, or weighted average, by default False
Returns
-------
numpy.ndarray
An array of the scalar values for each node on the `mesh` after they have been smoothed.
"""
kDTree = vtk.vtkKdTreePointLocator()
kDTree.SetDataSet(mesh)
kDTree.BuildLocator()
thickness_smoothed = np.zeros(mesh.GetNumberOfPoints())
scalars = l2n(mesh.GetPointData().GetScalars())
for idx in range(mesh.GetNumberOfPoints()):
if scalars[idx] >0: # don't smooth nodes with thickness == 0 (or negative? if that were to happen)
point = mesh.GetPoint(idx)
closest_ids = vtk.vtkIdList()
kDTree.FindPointsWithinRadius(max_dist, point, closest_ids) # This will return a value ( 0 or 1). Can use that for debudding.
list_scalars = []
list_distances = []
for closest_pt_idx in range(closest_ids.GetNumberOfIds()):
pt_idx = closest_ids.GetId(closest_pt_idx)
_point = mesh.GetPoint(pt_idx)
list_scalars.append(scalars[pt_idx])
list_distances.append(np.sqrt(np.sum(np.square(np.asarray(point) - np.asarray(_point) + epsilon))))
distances_weighted = (max_dist - np.asarray(list_distances))**order
scalars_weights = distances_weighted * np.asarray(list_scalars)
normalized_value = np.sum(scalars_weights) / np.sum(distances_weighted)
thickness_smoothed[idx] = normalized_value
return thickness_smoothed
def gaussian_smooth_surface_scalars(mesh, sigma=1., idx_coords_to_smooth=None, array_name='thickness (mm)', array_idx=None):
"""
The following is another function to smooth the scalar values on the surface of a mesh.
This one performs a gaussian smoothing using the supplied sigma and only smooths based on
the input `idx_coords_to_smooth`. If no `idx_coords_to_smooth` is provided, then all of the
points are smoothed. `idx_coords_to_smooth` should be a list of indices of points to include.
e.g., coords_to_smooth = np.where(vtk_to_numpy(mesh.GetPointData().GetScalars())>0.01)[0]
This would give only coordinates where the scalar values of the mesh are >0.01. This example is
useful for cartilage where we might only want to smooth in locations that we have cartilage and
ignore the other areas.
Parameters
----------
mesh : vtk.vtkPolyData
This is a surface mesh of that we want to smooth the scalars of.
sigma : float, optional
The standard deviation of the gaussian filter to apply, by default 1.
idx_coords_to_smooth : list, optional
List of the indices of the vertices (points) that we want to include in the
smoothing. For example, we can only smooth values that are cartialge and ignore
all non-cartilage points, by default None
array_name : str, optional
Name of the scalar array that we want to smooth/filter, by default 'thickness (mm)'
array_idx : int, optional
The index of the scalar array that we want to smooth/filter - this is an alternative
option to `array_name`, by default None
Returns
-------
vtk.vtkPolyData
Return the original mesh for which the scalars have been smoothed. However, this is not
necessary becuase if the original mesh still exists then it should have been updated
during the course of the pipeline.
"""
point_coordinates = get_mesh_physical_point_coords(mesh)
if idx_coords_to_smooth is not None:
point_coordinates = point_coordinates[idx_coords_to_smooth, :]
kernel = gaussian_kernel(point_coordinates, point_coordinates, sigma=sigma)
original_array = mesh.GetPointData().GetArray(array_idx if array_idx is not None else array_name)
original_scalars = np.copy(vtk_to_numpy(original_array))
if idx_coords_to_smooth is not None:
smoothed_scalars = np.sum(kernel * original_scalars[idx_coords_to_smooth],
axis=1)
original_scalars[idx_coords_to_smooth] = smoothed_scalars
smoothed_scalars = original_scalars
else:
smoothed_scalars = np.sum(kernel * original_scalars, axis=1)
smoothed_scalars = numpy_to_vtk(smoothed_scalars)
smoothed_scalars.SetName(original_array.GetName())
original_array.DeepCopy(smoothed_scalars) # Assign the scalars back to the original mesh
# return the mesh object - however, if the original is not deleted, it should be smoothed
# appropriately.
return mesh
def resample_surface(mesh, 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
----------
mesh : vtk.vtkPolyData
Polydata mesh to be re-sampled.
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.
Returns
-------
vtk.vtkPolyData :
Return the resampled mesh. This will be a pyvista version of the vtk mesh
but this is usable in all vtk function so it is not an issue.
"""
pv_smooth_mesh = pv.wrap(mesh)
clus = pyacvd.Clustering(pv_smooth_mesh)
clus.subdivide(subdivisions)
clus.cluster(clusters)
mesh = clus.create_mesh()
return mesh
### THE FOLLOWING IS AN OLD/ORIGINAL VERSION OF THIS THAT SMOOTHED ALL ARRAYS ATTACHED TO MESH
# def gaussian_smooth_surface_scalars(mesh, sigma=(1,), idx_coords_to_smooth=None):
# """
# The following is another function to smooth the scalar values on the surface of a mesh.
# This one performs a gaussian smoothing using the supplied sigma and only smooths based on
# the input `idx_coords_to_smooth`. If no `idx_coords_to_smooth` is provided, then all of the
# points are smoothed. `idx_coords_to_smooth` should be a list of indices of points to include.
# e.g., coords_to_smooth = np.where(vtk_to_numpy(mesh.GetPointData().GetScalars())>0.01)[0]
# This would give only coordinates where the scalar values of the mesh are >0.01. This example is
# useful for cartilage where we might only want to smooth in locations that we have cartilage and
# ignore the other areas.
# """
# point_coordinates = get_mesh_physical_point_coords(mesh)
# if idx_coords_to_smooth is not None:
# point_coordinates = point_coordinates[idx_coords_to_smooth, :]
# kernels = []
# if isinstance(sigma, (list, tuple)):
# for sig in sigma:
# kernels.append(gaussian_kernel(point_coordinates, point_coordinates, sigma=sig))
# elif isinstance(sigma, (float, int)):
# kernels.append(gaussian_kernel(point_coordinates, point_coordinates, sigma=sigma))
# n_arrays = mesh.GetPointData().GetNumberOfArrays()
# if n_arrays > len(kernels):
# if len(kernels) == 1:
# kernels = [kernels[0] for x in range(n_arrays)]
# for array_idx in range(n_arrays):
# original_array = mesh.GetPointData().GetArray(array_idx)
# original_scalars = np.copy(vtk_to_numpy(original_array))
# if idx_coords_to_smooth is not None:
# smoothed_scalars = np.sum(kernels[array_idx] * original_scalars[idx_coords_to_smooth],
# axis=1)
# original_scalars[idx_coords_to_smooth] = smoothed_scalars
# smoothed_scalars = original_scalars
# else:
# smoothed_scalars = np.sum(kernels[array_idx] * original_scalars, axis=1)
# smoothed_scalars = numpy_to_vtk(smoothed_scalars)
# smoothed_scalars.SetName(original_array.GetName())
# original_array.DeepCopy(smoothed_scalars)
# return mesh
# def get_smoothed_cartilage_thickness_values(loc_nrrd_images,
# seg_image_name,
# bone_label,
# list_cart_labels,
# image_smooth_var=1.0,
# smooth_cart=False,
# image_smooth_var_cart=1.0,
# ray_cast_length=10.,
# percent_ray_len_opposite_dir=0.2,
# smooth_surface_scalars=True,
# smooth_only_cartilage_values=True,
# scalar_gauss_sigma=1.6986436005760381, # This is a FWHM = 4
# bone_pyacvd_subdivisions=2,
# bone_pyacvd_clusters=20000,
# crop_bones=False,
# crop_percent=0.7,
# bone=None,
# loc_t2_map_nrrd=None,
# t2_map_filename=None,
# t2_smooth_sigma_multiple_of_thick=3,
# assign_seg_label_to_bone=False,
# mc_threshold=0.5,
# bone_label_threshold=5000,
# path_to_seg_transform=None,
# reverse_seg_transform=True,
# verbose=False):
# """
# :param loc_nrrd_images:
# :param seg_image_name:
# :param bone_label:
# :param list_cart_labels:
# :param image_smooth_var:
# :param loc_tmp_save:
# :param tmp_bone_filename:
# :param smooth_cart:
# :param image_smooth_var_cart:
# :param tmp_cart_filename:
# :param ray_cast_length:
# :param percent_ray_len_opposite_dir:
# :param smooth_surface_scalars:
# :param smooth_surface_scalars_gauss:
# :param smooth_only_cartilage_values:
# :param scalar_gauss_sigma:
# :param scalar_smooth_max_dist:
# :param scalar_smooth_order:
# :param bone_pyacvd_subdivisions:
# :param bone_pyacvd_clusters:
# :param crop_bones:
# :param crop_percent:
# :param bone:
# :param tmp_cropped_image_filename:
# :param loc_t2_map_nrrd:.
# :param t2_map_filename:
# :param t2_smooth_sigma_multiple_of_thick:
# :param assign_seg_label_to_bone:
# :param multiple_cart_labels_separate:
# :param mc_threshold:
# :return:
# Notes:
# multiple_cart_labels_separate REMOVED from the function.
# """
# # Read segmentation image
# seg_image = sitk.ReadImage(os.path.join(loc_nrrd_images, seg_image_name))
# seg_image = set_seg_border_to_zeros(seg_image, border_size=1)
# seg_view = sitk.GetArrayViewFromImage(seg_image)
# n_pixels_labelled = sum(seg_view[seg_view == bone_label])
# if n_pixels_labelled < bone_label_threshold:
# raise Exception('The bone does not exist in this segmentation!, only {} pixels detected, threshold # is {}'.format(n_pixels_labelled,
# bone_label_threshold))
# # Read segmentation in vtk format if going to assign labels to surface.
# # Also, if femur break it up into its parts.
# if assign_seg_label_to_bone is True:
# tmp_filename = ''.join(random.choice(string.ascii_lowercase) for i in range(10)) + '.nrrd'
# if bone == 'femur':
# new_seg_image = qc.get_knee_segmentation_with_femur_subregions(seg_image,
# fem_cart_label_idx=1)
# sitk.WriteImage(new_seg_image, os.path.join('/tmp', tmp_filename))
# else:
# sitk.WriteImage(seg_image, os.path.join('/tmp', tmp_filename))
# vtk_seg_reader = read_nrrd('/tmp',
# tmp_filename,
# set_origin_zero=True
# )
# vtk_seg = vtk_seg_reader.GetOutput()
# seg_transformer = SitkVtkTransformer(seg_image)
# # Delete tmp files
# safely_delete_tmp_file('/tmp',
# tmp_filename)
# # Crop the bones if that's an option/thing.
# if crop_bones is True:
# if 'femur' in bone:
# bone_crop_distal = True
# elif 'tibia' in bone:
# bone_crop_distal = False
# else:
# raise Exception('var bone should be "femur" or "tiba" got: {} instead'.format(bone))
# seg_image = crop_bone_based_on_width(seg_image,
# bone_label,
# percent_width_to_crop_height=crop_percent,
# bone_crop_distal=bone_crop_distal)
# if verbose is True:
# tic = time.time()
# # Create bone mesh/smooth/resample surface points.
# ns_bone_mesh = BoneMesh(seg_image=seg_image,
# label_idx=bone_label)
# if verbose is True:
# print('Loaded mesh')
# ns_bone_mesh.create_mesh(smooth_image=True,
# smooth_image_var=image_smooth_var,
# marching_cubes_threshold=mc_threshold
# )
# if verbose is True:
# print('Smoothed bone surface')
# ns_bone_mesh.resample_surface(subdivisions=bone_pyacvd_subdivisions,
# clusters=bone_pyacvd_clusters)
# if verbose is True:
# print('Resampled surface')
# n_bone_points = ns_bone_mesh._mesh.GetNumberOfPoints()
# if verbose is True:
# toc = time.time()
# print('Creating bone mesh took: {}'.format(toc - tic))
# tic = time.time()
# # Pre-allocate empty arrays for t2/labels if they are being placed on surface.
# if assign_seg_label_to_bone is True:
# # Apply inverse transform to get it into the space of the image.
# # This is easier than the reverse function.
# if assign_seg_label_to_bone is True:
# ns_bone_mesh.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform())
# labels = np.zeros(n_bone_points, dtype=np.int)
# thicknesses = np.zeros(n_bone_points, dtype=np.float)
# if verbose is True:
# print('Number bone mesh points: {}'.format(n_bone_points))
# # Iterate over cartilage labels
# # Create mesh & store thickness + cartilage label + t2 in arrays
# for cart_label_idx in list_cart_labels:
# # Test to see if this particular cartilage label even exists in the label :P
# # This is important for people that may have no cartilage (of a particular type)
# seg_array_view = sitk.GetArrayViewFromImage(seg_image)
# n_pixels_with_cart = np.sum(seg_array_view == cart_label_idx)
# if n_pixels_with_cart == 0:
# print("Not analyzing cartilage for label {} because it doesnt have any pixels!".format(cart_label_idx))
# continue
# ns_cart_mesh = CartilageMesh(seg_image=seg_image,
# label_idx=cart_label_idx)
# ns_cart_mesh.create_mesh(smooth_image=smooth_cart,
# smooth_image_var=image_smooth_var_cart,
# marching_cubes_threshold=mc_threshold)
# # Perform Thickness & label simultaneously.
# if assign_seg_label_to_bone is True:
# ns_cart_mesh.apply_transform_to_mesh(transform=seg_transformer.get_inverse_transform())
# node_data = get_cartilage_properties_at_points(ns_bone_mesh._mesh,
# ns_cart_mesh._mesh,
# t2_vtk_image=None,
# seg_vtk_image=vtk_seg if assign_seg_label_to_bone is True else None,
# ray_cast_length=ray_cast_length,
# percent_ray_length_opposite_direction=percent_ray_len_opposite_dir
# )
# if assign_seg_label_to_bone is False:
# thicknesses += node_data
# else:
# thicknesses += node_data[0]
# labels += node_data[1]
# if verbose is True:
# print('Cartilage label: {}'.format(cart_label_idx))
# print('Mean thicknesses (all): {}'.format(np.mean(thicknesses)))
# if verbose is True:
# toc = time.time()
# print('Calculating all thicknesses: {}'.format(toc - tic))
# tic = time.time()
# # Assign thickness & T2 data (if it exists) to bone surface.
# thickness_scalars = numpy_to_vtk(thicknesses)
# thickness_scalars.SetName('thickness (mm)')
# ns_bone_mesh._mesh.GetPointData().SetScalars(thickness_scalars)
# # Smooth surface scalars
# if smooth_surface_scalars is True:
# if smooth_only_cartilage_values is True:
# loc_cartilage = np.where(vtk_to_numpy(ns_bone_mesh._mesh.GetPointData().GetScalars())>0.01)[0]
# ns_bone_mesh.mesh = gaussian_smooth_surface_scalars(ns_bone_mesh.mesh,
# sigma=scalar_gauss_sigma,
# idx_coords_to_smooth=loc_cartilage)
# else:
# ns_bone_mesh.mesh = gaussian_smooth_surface_scalars(ns_bone_mesh.mesh, sigma=scalar_gauss_sigma)
# if verbose is True:
# toc = time.time()
# print('Smoothing scalars took: {}'.format(toc - tic))
# # Add the label values to the bone after smoothing is finished.
# if assign_seg_label_to_bone is True:
# label_scalars = numpy_to_vtk(labels)
# label_scalars.SetName('Cartilage Region')
# ns_bone_mesh._mesh.GetPointData().AddArray(label_scalars)
# if assign_seg_label_to_bone is True:
# # Transform bone back to the position it was in before rotating it (for the t2 analysis)
# ns_bone_mesh.reverse_all_transforms()
# return ns_bone_mesh.mesh</code></pre>
</details>
</section>
<section>
</section>
<section>
</section>
<section>
<h2 class="section-title" id="header-functions">Functions</h2>
<dl>
<dt id="pymskt.mesh.meshTools.gaussian_smooth_surface_scalars"><code class="name flex">
<span>def <span class="ident">gaussian_smooth_surface_scalars</span></span>(<span>mesh, sigma=1.0, idx_coords_to_smooth=None, array_name='thickness (mm)', array_idx=None)</span>
</code></dt>
<dd>
<div class="desc"><p>The following is another function to smooth the scalar values on the surface of a mesh.
This one performs a gaussian smoothing using the supplied sigma and only smooths based on
the input <code>idx_coords_to_smooth</code>. If no <code>idx_coords_to_smooth</code> is provided, then all of the
points are smoothed. <code>idx_coords_to_smooth</code> should be a list of indices of points to include. </p>
<p>e.g., coords_to_smooth = np.where(vtk_to_numpy(mesh.GetPointData().GetScalars())>0.01)[0]
This would give only coordinates where the scalar values of the mesh are >0.01. This example is
useful for cartilage where we might only want to smooth in locations that we have cartilage and
ignore the other areas. </p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>This is a surface mesh of that we want to smooth the scalars of.</dd>
<dt><strong><code>sigma</code></strong> : <code>float</code>, optional</dt>
<dd>The standard deviation of the gaussian filter to apply, by default 1.</dd>
<dt><strong><code>idx_coords_to_smooth</code></strong> : <code>list</code>, optional</dt>
<dd>List of the indices of the vertices (points) that we want to include in the
smoothing. For example, we can only smooth values that are cartialge and ignore
all non-cartilage points, by default None</dd>
<dt><strong><code>array_name</code></strong> : <code>str</code>, optional</dt>
<dd>Name of the scalar array that we want to smooth/filter, by default 'thickness (mm)'</dd>
<dt><strong><code>array_idx</code></strong> : <code>int</code>, optional</dt>
<dd>The index of the scalar array that we want to smooth/filter - this is an alternative
option to <code>array_name</code>, by default None</dd>
</dl>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>vtk.vtkPolyData</code></dt>
<dd>Return the original mesh for which the scalars have been smoothed. However, this is not
necessary becuase if the original mesh still exists then it should have been updated
during the course of the pipeline.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def gaussian_smooth_surface_scalars(mesh, sigma=1., idx_coords_to_smooth=None, array_name='thickness (mm)', array_idx=None):
"""
The following is another function to smooth the scalar values on the surface of a mesh.
This one performs a gaussian smoothing using the supplied sigma and only smooths based on
the input `idx_coords_to_smooth`. If no `idx_coords_to_smooth` is provided, then all of the
points are smoothed. `idx_coords_to_smooth` should be a list of indices of points to include.
e.g., coords_to_smooth = np.where(vtk_to_numpy(mesh.GetPointData().GetScalars())>0.01)[0]
This would give only coordinates where the scalar values of the mesh are >0.01. This example is
useful for cartilage where we might only want to smooth in locations that we have cartilage and
ignore the other areas.
Parameters
----------
mesh : vtk.vtkPolyData
This is a surface mesh of that we want to smooth the scalars of.
sigma : float, optional
The standard deviation of the gaussian filter to apply, by default 1.
idx_coords_to_smooth : list, optional
List of the indices of the vertices (points) that we want to include in the
smoothing. For example, we can only smooth values that are cartialge and ignore
all non-cartilage points, by default None
array_name : str, optional
Name of the scalar array that we want to smooth/filter, by default 'thickness (mm)'
array_idx : int, optional
The index of the scalar array that we want to smooth/filter - this is an alternative
option to `array_name`, by default None
Returns
-------
vtk.vtkPolyData
Return the original mesh for which the scalars have been smoothed. However, this is not
necessary becuase if the original mesh still exists then it should have been updated
during the course of the pipeline.
"""
point_coordinates = get_mesh_physical_point_coords(mesh)
if idx_coords_to_smooth is not None:
point_coordinates = point_coordinates[idx_coords_to_smooth, :]
kernel = gaussian_kernel(point_coordinates, point_coordinates, sigma=sigma)
original_array = mesh.GetPointData().GetArray(array_idx if array_idx is not None else array_name)
original_scalars = np.copy(vtk_to_numpy(original_array))
if idx_coords_to_smooth is not None:
smoothed_scalars = np.sum(kernel * original_scalars[idx_coords_to_smooth],
axis=1)
original_scalars[idx_coords_to_smooth] = smoothed_scalars
smoothed_scalars = original_scalars
else:
smoothed_scalars = np.sum(kernel * original_scalars, axis=1)
smoothed_scalars = numpy_to_vtk(smoothed_scalars)
smoothed_scalars.SetName(original_array.GetName())
original_array.DeepCopy(smoothed_scalars) # Assign the scalars back to the original mesh
# return the mesh object - however, if the original is not deleted, it should be smoothed
# appropriately.
return mesh</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.get_cartilage_properties_at_points"><code class="name flex">
<span>def <span class="ident">get_cartilage_properties_at_points</span></span>(<span>surface_bone, surface_cartilage, t2_vtk_image=None, seg_vtk_image=None, ray_cast_length=20.0, percent_ray_length_opposite_direction=0.25, no_thickness_filler=0.0, no_t2_filler=0.0, no_seg_filler=0, line_resolution=100)</span>
</code></dt>
<dd>
<div class="desc"><p>Extract cartilage outcomes (T2 & thickness) at all points on bone surface. </p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>surface_bone</code></strong> : <code>BoneMesh</code></dt>
<dd>Bone mesh containing vtk.vtkPolyData - get outcomes for nodes (vertices) on
this mesh</dd>
<dt><strong><code>surface_cartilage</code></strong> : <code>CartilageMesh</code></dt>
<dd>Cartilage mesh containing vtk.vtkPolyData - for obtaining cartilage outcomes.</dd>
<dt><strong><code>t2_vtk_image</code></strong> : <code>vtk.vtkImageData</code>, optional</dt>
<dd>vtk object that contains our Cartilage T2 data, by default None</dd>
<dt><strong><code>seg_vtk_image</code></strong> : <code>vtk.vtkImageData</code>, optional</dt>
<dd>vtk object that contains the segmentation mask(s) to help assign
labels to bone surface (e.g., most common), 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 20.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>
<dt><strong><code>no_thickness_filler</code></strong> : <code>float</code>, optional</dt>
<dd>Value to use instead of thickness (if no cartilage), by default 0.</dd>
<dt><strong><code>no_t2_filler</code></strong> : <code>float</code>, optional</dt>
<dd>Value to use instead of T2 (if no cartilage), by default 0.</dd>
<dt><strong><code>no_seg_filler</code></strong> : <code>int</code>, optional</dt>
<dd>Value to use if no segmentation label available (because no cartilage?), by default 0</dd>
<dt><strong><code>line_resolution</code></strong> : <code>int</code>, optional</dt>
<dd>Number of points to have along line, by default 100</dd>
</dl>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>list</code></dt>
<dd>Will return list of data for:
Cartilage thickness
Mean T2 at each point on bone
Most common cartilage label at each point on bone (normal to surface).</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def get_cartilage_properties_at_points(surface_bone,
surface_cartilage,
t2_vtk_image=None,
seg_vtk_image=None,
ray_cast_length=20.,
percent_ray_length_opposite_direction=0.25,
no_thickness_filler=0.,
no_t2_filler=0.,
no_seg_filler=0,
line_resolution=100): # Could be nan??
"""
Extract cartilage outcomes (T2 & thickness) at all points on bone surface.
Parameters
----------
surface_bone : BoneMesh
Bone mesh containing vtk.vtkPolyData - get outcomes for nodes (vertices) on
this mesh
surface_cartilage : CartilageMesh
Cartilage mesh containing vtk.vtkPolyData - for obtaining cartilage outcomes.
t2_vtk_image : vtk.vtkImageData, optional
vtk object that contains our Cartilage T2 data, by default None
seg_vtk_image : vtk.vtkImageData, optional
vtk object that contains the segmentation mask(s) to help assign
labels to bone surface (e.g., most common), 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 20.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
no_thickness_filler : float, optional
Value to use instead of thickness (if no cartilage), by default 0.
no_t2_filler : float, optional
Value to use instead of T2 (if no cartilage), by default 0.
no_seg_filler : int, optional
Value to use if no segmentation label available (because no cartilage?), by default 0
line_resolution : int, optional
Number of points to have along line, by default 100
Returns
-------
list
Will return list of data for:
Cartilage thickness
Mean T2 at each point on bone
Most common cartilage label at each point on bone (normal to surface).
"""
normals = get_surface_normals(surface_bone)
points = surface_bone.GetPoints()
obb_cartilage = get_obb_surface(surface_cartilage)
point_normals = normals.GetOutput().GetPointData().GetNormals()
thickness_data = []
if (t2_vtk_image is not None) or (seg_vtk_image is not None):
# if T2 data, or a segmentation image is provided, then setup Probe tool to
# get T2 values and/or cartilage ROI for each bone vertex.
line = vtk.vtkLineSource()
line.SetResolution(line_resolution)
if t2_vtk_image is not None:
t2_data_probe = ProbeVtkImageDataAlongLine(line_resolution,
t2_vtk_image,
save_mean=True,
filler=no_t2_filler)
if seg_vtk_image is not None:
seg_data_probe = ProbeVtkImageDataAlongLine(line_resolution,
seg_vtk_image,
save_most_common=True,
filler=no_seg_filler,
data_categorical=True)
# Loop through all points
for idx in range(points.GetNumberOfPoints()):
point = points.GetPoint(idx)
normal = point_normals.GetTuple(idx)
end_point_ray = n2l(l2n(point) + ray_cast_length*l2n(normal))
start_point_ray = n2l(l2n(point) + ray_cast_length*percent_ray_length_opposite_direction*(-l2n(normal)))
# Check if there are any intersections for the given ray
if is_hit(obb_cartilage, start_point_ray, end_point_ray): # intersections were found
# Retrieve coordinates of intersection points and intersected cell ids
points_intersect, cell_ids_intersect = get_intersect(obb_cartilage, start_point_ray, end_point_ray)
# points
if len(points_intersect) == 2:
thickness_data.append(np.sqrt(np.sum(np.square(l2n(points_intersect[0]) - l2n(points_intersect[1])))))
if t2_vtk_image is not None:
t2_data_probe.save_data_along_line(start_pt=points_intersect[0],
end_pt=points_intersect[1])
if seg_vtk_image is not None:
seg_data_probe.save_data_along_line(start_pt=points_intersect[0],
end_pt=points_intersect[1])
else:
thickness_data.append(no_thickness_filler)
if t2_vtk_image is not None:
t2_data_probe.append_filler()
if seg_vtk_image is not None:
seg_data_probe.append_filler()
else:
thickness_data.append(no_thickness_filler)
if t2_vtk_image is not None:
t2_data_probe.append_filler()
if seg_vtk_image is not None:
seg_data_probe.append_filler()
if (t2_vtk_image is None) & (seg_vtk_image is None):
return np.asarray(thickness_data, dtype=np.float)
elif (t2_vtk_image is not None) & (seg_vtk_image is not None):
return (np.asarray(thickness_data, dtype=np.float),
np.asarray(t2_data_probe.mean_data, dtype=np.float),
np.asarray(seg_data_probe.most_common_data, dtype=np.int)
)
elif t2_vtk_image is not None:
return (np.asarray(thickness_data, dtype=np.float),
np.asarray(t2_data_probe.mean_data, dtype=np.float)
)
elif seg_vtk_image is not None:
return (np.asarray(thickness_data, dtype=np.float),
np.asarray(seg_data_probe.most_common_data, dtype=np.int)
)</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.get_mesh_physical_point_coords"><code class="name flex">
<span>def <span class="ident">get_mesh_physical_point_coords</span></span>(<span>mesh)</span>
</code></dt>
<dd>
<div class="desc"><p>Get a numpy array of the x/y/z location of each point (vertex) on the <code>mesh</code>.</p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>mesh</code></strong></dt>
<dd>[description]</dd>
</dl>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>numpy.ndarray</code></dt>
<dd>n_points x 3 array describing the x/y/z position of each point.</dd>
</dl>
<h2 id="notes">Notes</h2>
<p>Below is the original method used to retrieve the point coordinates. </p>
<p>point_coordinates = np.zeros((mesh.GetNumberOfPoints(), 3))
for pt_idx in range(mesh.GetNumberOfPoints()):
point_coordinates[pt_idx, :] = mesh.GetPoint(pt_idx)</p></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def get_mesh_physical_point_coords(mesh):
"""
Get a numpy array of the x/y/z location of each point (vertex) on the `mesh`.
Parameters
----------
mesh :
[description]
Returns
-------
numpy.ndarray
n_points x 3 array describing the x/y/z position of each point.
Notes
-----
Below is the original method used to retrieve the point coordinates.
point_coordinates = np.zeros((mesh.GetNumberOfPoints(), 3))
for pt_idx in range(mesh.GetNumberOfPoints()):
point_coordinates[pt_idx, :] = mesh.GetPoint(pt_idx)
"""
point_coordinates = vtk_to_numpy(mesh.GetPoints().GetData())
return point_coordinates</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.get_smoothed_scalars"><code class="name flex">
<span>def <span class="ident">get_smoothed_scalars</span></span>(<span>mesh, max_dist=2.0, order=2, gaussian=False)</span>
</code></dt>
<dd>
<div class="desc"><p>perform smoothing of scalars on the nodes of a surface mesh.
return the smoothed values of the nodes so they can be used as necessary.
(e.g. to replace originals or something else)
Smoothing is done for all data within <code>max_dist</code> and uses a simple weighted average based on
the distance to the power of <code>order</code>. Default is squared distance (<code>order=2</code>)</p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>Surface mesh that we want to smooth scalars of.</dd>
<dt><strong><code>max_dist</code></strong> : <code>float</code>, optional</dt>
<dd>Maximum distance of nodes that we want to smooth (mm), by default 2.0</dd>
<dt><strong><code>order</code></strong> : <code>int</code>, optional</dt>
<dd>Order of the polynomial used for weighting other nodes within <code>max_dist</code>, by default 2</dd>
<dt><strong><code>gaussian</code></strong> : <code>bool</code>, optional</dt>
<dd>Should this use a gaussian smoothing, or weighted average, by default False</dd>
</dl>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>numpy.ndarray</code></dt>
<dd>An array of the scalar values for each node on the <code>mesh</code> after they have been smoothed.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def get_smoothed_scalars(mesh, max_dist=2.0, order=2, gaussian=False):
"""
perform smoothing of scalars on the nodes of a surface mesh.
return the smoothed values of the nodes so they can be used as necessary.
(e.g. to replace originals or something else)
Smoothing is done for all data within `max_dist` and uses a simple weighted average based on
the distance to the power of `order`. Default is squared distance (`order=2`)
Parameters
----------
mesh : vtk.vtkPolyData
Surface mesh that we want to smooth scalars of.
max_dist : float, optional
Maximum distance of nodes that we want to smooth (mm), by default 2.0
order : int, optional
Order of the polynomial used for weighting other nodes within `max_dist`, by default 2
gaussian : bool, optional
Should this use a gaussian smoothing, or weighted average, by default False
Returns
-------
numpy.ndarray
An array of the scalar values for each node on the `mesh` after they have been smoothed.
"""
kDTree = vtk.vtkKdTreePointLocator()
kDTree.SetDataSet(mesh)
kDTree.BuildLocator()
thickness_smoothed = np.zeros(mesh.GetNumberOfPoints())
scalars = l2n(mesh.GetPointData().GetScalars())
for idx in range(mesh.GetNumberOfPoints()):
if scalars[idx] >0: # don't smooth nodes with thickness == 0 (or negative? if that were to happen)
point = mesh.GetPoint(idx)
closest_ids = vtk.vtkIdList()
kDTree.FindPointsWithinRadius(max_dist, point, closest_ids) # This will return a value ( 0 or 1). Can use that for debudding.
list_scalars = []
list_distances = []
for closest_pt_idx in range(closest_ids.GetNumberOfIds()):
pt_idx = closest_ids.GetId(closest_pt_idx)
_point = mesh.GetPoint(pt_idx)
list_scalars.append(scalars[pt_idx])
list_distances.append(np.sqrt(np.sum(np.square(np.asarray(point) - np.asarray(_point) + epsilon))))
distances_weighted = (max_dist - np.asarray(list_distances))**order
scalars_weights = distances_weighted * np.asarray(list_scalars)
normalized_value = np.sum(scalars_weights) / np.sum(distances_weighted)
thickness_smoothed[idx] = normalized_value
return thickness_smoothed</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.resample_surface"><code class="name flex">
<span>def <span class="ident">resample_surface</span></span>(<span>mesh, 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>mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>Polydata mesh to be re-sampled.</dd>
<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>
<p>The number of clusters (points/vertices) to create during resampling
surafce, by default 10000
- This is not exact, might have slight differences.</p>
<h2 id="returns">Returns</h2>
<p>vtk.vtkPolyData :
Return the resampled mesh. This will be a pyvista version of the vtk mesh
but this is usable in all vtk function so it is not an issue.</p>
</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def resample_surface(mesh, 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
----------
mesh : vtk.vtkPolyData
Polydata mesh to be re-sampled.
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.
Returns
-------
vtk.vtkPolyData :
Return the resampled mesh. This will be a pyvista version of the vtk mesh
but this is usable in all vtk function so it is not an issue.
"""
pv_smooth_mesh = pv.wrap(mesh)
clus = pyacvd.Clustering(pv_smooth_mesh)
clus.subdivide(subdivisions)
clus.cluster(clusters)
mesh = clus.create_mesh()
return mesh</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.set_mesh_physical_point_coords"><code class="name flex">
<span>def <span class="ident">set_mesh_physical_point_coords</span></span>(<span>mesh, new_points)</span>
</code></dt>
<dd>
<div class="desc"><p>Convenience function to update the x/y/z point coords of a mesh</p>
<p>Nothing is returned becuase the mesh object is updated in-place. </p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>Mesh object we want to update the point coordinates for</dd>
<dt><strong><code>new_points</code></strong> : <code>np.ndarray</code></dt>
<dd>Numpy array shaped n_points x 3. These are the new point coordinates that
we want to update the mesh to have.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def set_mesh_physical_point_coords(mesh, new_points):
"""
Convenience function to update the x/y/z point coords of a mesh
Nothing is returned becuase the mesh object is updated in-place.
Parameters
----------
mesh : vtk.vtkPolyData
Mesh object we want to update the point coordinates for
new_points : np.ndarray
Numpy array shaped n_points x 3. These are the new point coordinates that
we want to update the mesh to have.
"""
orig_point_coords = get_mesh_physical_point_coords(mesh)
if new_points.shape == orig_point_coords.shape:
mesh.GetPoints().SetData(numpy_to_vtk(new_points))</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base"><code class="name flex">
<span>def <span class="ident">smooth_scalars_from_second_mesh_onto_base</span></span>(<span>base_mesh, second_mesh, sigma=1.0, idx_coords_to_smooth_base=None, idx_coords_to_smooth_second=None, set_non_smoothed_scalars_to_zero=True)</span>
</code></dt>
<dd>
<div class="desc"><p>Function to copy surface scalars from one mesh to another. This is done in a "smoothing" fashioon
to get a weighted-average of the closest point - this is because the points on the 2 meshes won't
be coincident with one another. The weighted average is done using a gaussian smoothing.</p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>base_mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>The base mesh to smooth the scalars from <code>second_mesh</code> onto.</dd>
<dt><strong><code>second_mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>The mesh with the scalar values that we want to pass onto the <code>base_mesh</code>.</dd>
<dt><strong><code>sigma</code></strong> : <code>float</code>, optional</dt>
<dd>Sigma (standard deviation) of gaussian filter to apply to scalars, by default 1.</dd>
<dt><strong><code>idx_coords_to_smooth_base</code></strong> : <code>list</code>, optional</dt>
<dd>List of the indices of nodes that are of interest for transferring (typically cartilage),
by default None</dd>
<dt><strong><code>idx_coords_to_smooth_second</code></strong> : <code>list</code>, optional</dt>
<dd>List of the indices of the nodes that are of interest on the second mesh, by default None</dd>
<dt><strong><code>set_non_smoothed_scalars_to_zero</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether or not to set all notes that are not smoothed to zero, by default True</dd>
</dl>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>numpy.ndarray</code></dt>
<dd>An array of the scalar values for each node on the base mesh that includes the scalar values
transfered (smoothed) from the secondary mesh.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def smooth_scalars_from_second_mesh_onto_base(base_mesh,
second_mesh,
sigma=1.,
idx_coords_to_smooth_base=None,
idx_coords_to_smooth_second=None,
set_non_smoothed_scalars_to_zero=True
): # sigma is equal to fwhm=2 (1mm in each direction)
"""
Function to copy surface scalars from one mesh to another. This is done in a "smoothing" fashioon
to get a weighted-average of the closest point - this is because the points on the 2 meshes won't
be coincident with one another. The weighted average is done using a gaussian smoothing.
Parameters
----------
base_mesh : vtk.vtkPolyData
The base mesh to smooth the scalars from `second_mesh` onto.
second_mesh : vtk.vtkPolyData
The mesh with the scalar values that we want to pass onto the `base_mesh`.
sigma : float, optional
Sigma (standard deviation) of gaussian filter to apply to scalars, by default 1.
idx_coords_to_smooth_base : list, optional
List of the indices of nodes that are of interest for transferring (typically cartilage),
by default None
idx_coords_to_smooth_second : list, optional
List of the indices of the nodes that are of interest on the second mesh, by default None
set_non_smoothed_scalars_to_zero : bool, optional
Whether or not to set all notes that are not smoothed to zero, by default True
Returns
-------
numpy.ndarray
An array of the scalar values for each node on the base mesh that includes the scalar values
transfered (smoothed) from the secondary mesh.
"""
base_mesh_pts = get_mesh_physical_point_coords(base_mesh)
if idx_coords_to_smooth_base is not None:
base_mesh_pts = base_mesh_pts[idx_coords_to_smooth_base, :]
second_mesh_pts = get_mesh_physical_point_coords(second_mesh)
if idx_coords_to_smooth_second is not None:
second_mesh_pts = second_mesh_pts[idx_coords_to_smooth_second, :]
gauss_kernel = gaussian_kernel(base_mesh_pts, second_mesh_pts, sigma=sigma)
second_mesh_scalars = np.copy(vtk_to_numpy(second_mesh.GetPointData().GetScalars()))
if idx_coords_to_smooth_second is not None:
# If sub-sampled second mesh - then only give the scalars from those sub-sampled points on mesh.
second_mesh_scalars = second_mesh_scalars[idx_coords_to_smooth_second]
smoothed_scalars_on_base = np.sum(gauss_kernel * second_mesh_scalars, axis=1)
if idx_coords_to_smooth_base is not None:
# if sub-sampled baseline mesh (only want to set cartilage to certain points/vertices), then
# set the calculated smoothed scalars to only those nodes (and leave all other nodes the same as they were
# originally.
if set_non_smoothed_scalars_to_zero is True:
base_mesh_scalars = np.zeros(base_mesh.GetNumberOfPoints())
else:
base_mesh_scalars = np.copy(vtk_to_numpy(base_mesh.GetPointData().GetScalars()))
base_mesh_scalars[idx_coords_to_smooth_base] = smoothed_scalars_on_base
return base_mesh_scalars
else:
return smoothed_scalars_on_base</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.transfer_mesh_scalars_get_weighted_average_n_closest"><code class="name flex">
<span>def <span class="ident">transfer_mesh_scalars_get_weighted_average_n_closest</span></span>(<span>new_mesh, old_mesh, n=3)</span>
</code></dt>
<dd>
<div class="desc"><p>Transfer scalars from old_mesh to new_mesh using the weighted-average of the <code>n</code> closest
nodes/points/vertices. Similar but not exactly the same as <code><a title="pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base" href="#pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base">smooth_scalars_from_second_mesh_onto_base()</a></code></p>
<p>This function is ideally used for things like transferring cartilage thickness values from one mesh to another
after they have been registered together. This is necessary for things like performing statistical analyses or
getting aggregate statistics. </p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>new_mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>The new mesh that we want to transfer scalar values onto. Also <code>base_mesh</code> from
<code><a title="pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base" href="#pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base">smooth_scalars_from_second_mesh_onto_base()</a></code></dd>
<dt><strong><code>old_mesh</code></strong> : <code>vtk.vtkPolyData</code></dt>
<dd>The mesh that we want to transfer scalars from. Also called <code>second_mesh</code> from
<code><a title="pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base" href="#pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base">smooth_scalars_from_second_mesh_onto_base()</a></code></dd>
<dt><strong><code>n</code></strong> : <code>int</code>, optional</dt>
<dd>The number of closest nodes that we want to get weighed average of, by default 3</dd>
</dl>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>numpy.ndarray</code></dt>
<dd>An array of the scalar values for each node on the <code>new_mesh</code> that includes the scalar values
transfered (smoothed) from the <code>old_mesh</code>.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def transfer_mesh_scalars_get_weighted_average_n_closest(new_mesh, old_mesh, n=3):
"""
Transfer scalars from old_mesh to new_mesh using the weighted-average of the `n` closest
nodes/points/vertices. Similar but not exactly the same as `smooth_scalars_from_second_mesh_onto_base`
This function is ideally used for things like transferring cartilage thickness values from one mesh to another
after they have been registered together. This is necessary for things like performing statistical analyses or
getting aggregate statistics.
Parameters
----------
new_mesh : vtk.vtkPolyData
The new mesh that we want to transfer scalar values onto. Also `base_mesh` from
`smooth_scalars_from_second_mesh_onto_base`
old_mesh : vtk.vtkPolyData
The mesh that we want to transfer scalars from. Also called `second_mesh` from
`smooth_scalars_from_second_mesh_onto_base`
n : int, optional
The number of closest nodes that we want to get weighed average of, by default 3
Returns
-------
numpy.ndarray
An array of the scalar values for each node on the `new_mesh` that includes the scalar values
transfered (smoothed) from the `old_mesh`.
"""
kDTree = vtk.vtkKdTreePointLocator()
kDTree.SetDataSet(old_mesh)
kDTree.BuildLocator()
n_arrays = old_mesh.GetPointData().GetNumberOfArrays()
array_names = [old_mesh.GetPointData().GetArray(array_idx).GetName() for array_idx in range(n_arrays)]
new_scalars = np.zeros((new_mesh.GetNumberOfPoints(), n_arrays))
scalars_old_mesh = [np.copy(vtk_to_numpy(old_mesh.GetPointData().GetArray(array_name))) for array_name in array_names]
# print('len scalars_old_mesh', len(scalars_old_mesh))
# scalars_old_mesh = np.copy(vtk_to_numpy(old_mesh.GetPointData().GetScalars()))
for new_mesh_pt_idx in range(new_mesh.GetNumberOfPoints()):
point = new_mesh.GetPoint(new_mesh_pt_idx)
closest_ids = vtk.vtkIdList()
kDTree.FindClosestNPoints(n, point, closest_ids)
list_scalars = []
distance_weighting = []
for closest_pts_idx in range(closest_ids.GetNumberOfIds()):
pt_idx = closest_ids.GetId(closest_pts_idx)
_point = old_mesh.GetPoint(pt_idx)
list_scalars.append([scalars[pt_idx] for scalars in scalars_old_mesh])
distance_weighting.append(1 / np.sqrt(np.sum(np.square(np.asarray(point) - np.asarray(_point) + epsilon))))
total_distance = np.sum(distance_weighting)
# print('list_scalars', list_scalars)
# print('distance_weighting', distance_weighting)
# print('total_distance', total_distance)
normalized_value = np.sum(np.asarray(list_scalars) * np.expand_dims(np.asarray(distance_weighting), axis=1),
axis=0) / total_distance
# print('new_mesh_pt_idx', new_mesh_pt_idx)
# print('normalized_value', normalized_value)
# print('new_scalars shape', new_scalars.shape)
new_scalars[new_mesh_pt_idx, :] = normalized_value
return new_scalars</code></pre>
</details>
</dd>
</dl>
</section>
<section>
<h2 class="section-title" id="header-classes">Classes</h2>
<dl>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine"><code class="flex name class">
<span>class <span class="ident">ProbeVtkImageDataAlongLine</span></span>
<span>(</span><span>line_resolution, vtk_image, save_data_in_class=True, save_mean=False, save_std=False, save_most_common=False, save_max=False, filler=0, non_zero_only=True, data_categorical=False)</span>
</code></dt>
<dd>
<div class="desc"><p>Class to find values along a line. This is used to get things like the mean T2 value normal
to a bones surface & within the cartialge region. This is done by defining a line in a
particualar location. </p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>line_resolution</code></strong> : <code>float</code></dt>
<dd>How many points to create along the line.</dd>
<dt><strong><code>vtk_image</code></strong> : <code>vtk.vtkImageData</code></dt>
<dd>Image read into vtk so that we can apply the probe to it.</dd>
<dt><strong><code>save_data_in_class</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether or not to save data along the line(s) to the class, by default True</dd>
<dt><strong><code>save_mean</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether the mean value should be saved along the line, by default False</dd>
<dt><strong><code>save_std</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether the standard deviation of the data along the line should be
saved, by default False</dd>
<dt><strong><code>save_most_common</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False</dd>
<dt><strong><code>filler</code></strong> : <code>int</code>, optional</dt>
<dd>What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0</dd>
<dt><strong><code>non_zero_only</code></strong> : <code>bool</code>, optional</dt>
<dd>Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.</dd>
</dl>
<h2 id="attributes">Attributes</h2>
<dl>
<dt><strong><code>save_mean</code></strong> : <code>bool</code></dt>
<dd>Whether the mean value should be saved along the line, by default False</dd>
<dt><strong><code>save_std</code></strong> : <code>bool</code></dt>
<dd>Whether the standard deviation of the data along the line should be
saved, by default False</dd>
<dt><strong><code>save_most_common</code></strong> : <code>bool </code></dt>
<dd>Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False</dd>
<dt><strong><code>filler</code></strong> : <code>float</code></dt>
<dd>What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0</dd>
<dt><strong><code>non_zero_only</code></strong> : <code>bool </code></dt>
<dd>Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.</dd>
<dt><strong><code>line</code></strong> : <code>vtk.vtkLineSource</code></dt>
<dd>Line to put into <code>probe_filter</code> and to determine mean/std/common values for.</dd>
<dt><strong><code>probe_filter</code></strong> : <code>vtk.vtkProbeFilter</code></dt>
<dd>Filter to use to get the image data along the line.</dd>
<dt><strong><code>_mean_data</code></strong> : <code>list</code></dt>
<dd>List of the mean values for each vertex / line projected</dd>
<dt><strong><code>_std_data</code></strong> : <code>list</code></dt>
<dd>List of standard deviation of each vertex / line projected</dd>
<dt><strong><code>_most_common_data</code></strong> : <code>list</code></dt>
<dd>List of most common data of each vertex / line projected</dd>
</dl>
<h2 id="methods">Methods</h2>
<p>[summary]</p>
<h2 id="parameters_1">Parameters</h2>
<dl>
<dt><strong><code>line_resolution</code></strong> : <code>float</code></dt>
<dd>How many points to create along the line.</dd>
<dt><strong><code>vtk_image</code></strong> : <code>vtk.vtkImageData</code></dt>
<dd>Image read into vtk so that we can apply the probe to it.</dd>
<dt><strong><code>save_data_in_class</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether or not to save data along the line(s) to the class, by default True</dd>
<dt><strong><code>save_mean</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether the mean value should be saved along the line, by default False</dd>
<dt><strong><code>save_std</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether the standard deviation of the data along the line should be
saved, by default False</dd>
<dt><strong><code>save_most_common</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False</dd>
<dt><strong><code>save_max</code></strong> : <code>bool</code>, optional</dt>
<dd>Whether the max value should be saved along the line, be default False</dd>
<dt><strong><code>filler</code></strong> : <code>int</code>, optional</dt>
<dd>What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0</dd>
<dt><strong><code>non_zero_only</code></strong> : <code>bool</code>, optional</dt>
<dd>Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.</dd>
<dt><strong><code>data_categorical</code></strong> : <code>bool</code>, optional</dt>
<dd>Specify whether or not the data is categorical to determine the interpolation
method that should be used.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">class ProbeVtkImageDataAlongLine:
"""
Class to find values along a line. This is used to get things like the mean T2 value normal
to a bones surface & within the cartialge region. This is done by defining a line in a
particualar location.
Parameters
----------
line_resolution : float
How many points to create along the line.
vtk_image : vtk.vtkImageData
Image read into vtk so that we can apply the probe to it.
save_data_in_class : bool, optional
Whether or not to save data along the line(s) to the class, by default True
save_mean : bool, optional
Whether the mean value should be saved along the line, by default False
save_std : bool, optional
Whether the standard deviation of the data along the line should be
saved, by default False
save_most_common : bool, optional
Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False
filler : int, optional
What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0
non_zero_only : bool, optional
Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.
Attributes
----------
save_mean : bool
Whether the mean value should be saved along the line, by default False
save_std : bool
Whether the standard deviation of the data along the line should be
saved, by default False
save_most_common : bool
Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False
filler : float
What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0
non_zero_only : bool
Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.
line : vtk.vtkLineSource
Line to put into `probe_filter` and to determine mean/std/common values for.
probe_filter : vtk.vtkProbeFilter
Filter to use to get the image data along the line.
_mean_data : list
List of the mean values for each vertex / line projected
_std_data : list
List of standard deviation of each vertex / line projected
_most_common_data : list
List of most common data of each vertex / line projected
Methods
-------
"""
def __init__(self,
line_resolution,
vtk_image,
save_data_in_class=True,
save_mean=False,
save_std=False,
save_most_common=False,
save_max=False,
filler=0,
non_zero_only=True,
data_categorical=False
):
"""[summary]
Parameters
----------
line_resolution : float
How many points to create along the line.
vtk_image : vtk.vtkImageData
Image read into vtk so that we can apply the probe to it.
save_data_in_class : bool, optional
Whether or not to save data along the line(s) to the class, by default True
save_mean : bool, optional
Whether the mean value should be saved along the line, by default False
save_std : bool, optional
Whether the standard deviation of the data along the line should be
saved, by default False
save_most_common : bool, optional
Whether the mode (most common) value should be saved used for identifying cartilage
regions on the bone surface, by default False
save_max : bool, optional
Whether the max value should be saved along the line, be default False
filler : int, optional
What value should be placed at locations where we don't have a value
(e.g., where we don't have T2 values), by default 0
non_zero_only : bool, optional
Only save non-zero values along the line, by default True
This is done becuase zeros are normally regions of error (e.g.
poor T2 relaxation fit) and thus would artifically reduce the outcome
along the line.
data_categorical : bool, optional
Specify whether or not the data is categorical to determine the interpolation
method that should be used.
"""
self.save_mean = save_mean
self.save_std = save_std
self.save_most_common = save_most_common
self.save_max = save_max
self.filler = filler
self.non_zero_only = non_zero_only
self.line = vtk.vtkLineSource()
self.line.SetResolution(line_resolution)
self.probe_filter = vtk.vtkProbeFilter()
self.probe_filter.SetSourceData(vtk_image)
if data_categorical is True:
self.probe_filter.CategoricalDataOn()
if save_data_in_class is True:
if self.save_mean is True:
self._mean_data = []
if self.save_std is True:
self._std_data = []
if self.save_most_common is True:
self._most_common_data = []
if self.save_max is True:
self._max_data = []
def get_data_along_line(self,
start_pt,
end_pt):
"""
Function to get scalar values along a line between `start_pt` and `end_pt`.
Parameters
----------
start_pt : list
List of the x,y,z position of the starting point in the line.
end_pt : list
List of the x,y,z position of the ending point in the line.
Returns
-------
numpy.ndarray
numpy array of scalar values obtained along the line.
"""
self.line.SetPoint1(start_pt)
self.line.SetPoint2(end_pt)
self.probe_filter.SetInputConnection(self.line.GetOutputPort())
self.probe_filter.Update()
scalars = vtk_to_numpy(self.probe_filter.GetOutput().GetPointData().GetScalars())
if self.non_zero_only is True:
scalars = scalars[scalars != 0]
return scalars
def save_data_along_line(self,
start_pt,
end_pt):
"""
Save the appropriate outcomes to a growing list.
Parameters
----------
start_pt : list
List of the x,y,z position of the starting point in the line.
end_pt : list
List of the x,y,z position of the ending point in the line.
"""
scalars = self.get_data_along_line(start_pt, end_pt)
if len(scalars) > 0:
if self.save_mean is True:
self._mean_data.append(np.mean(scalars))
if self.save_std is True:
self._std_data.append(np.std(scalars, ddof=1))
if self.save_most_common is True:
# most_common is for getting segmentations and trying to assign a bone region
# to be a cartilage ROI. This is becuase there might be a normal vector that
# cross > 1 cartilage region (e.g., weight-bearing vs anterior fem cartilage)
self._most_common_data.append(np.bincount(scalars).argmax())
if self.save_max is True:
self._max_data.append(np.max(scalars))
else:
self.append_filler()
def append_filler(self):
"""
Add filler value to the requisite lists (_mean_data, _std_data, etc.) as
appropriate.
"""
if self.save_mean is True:
self._mean_data.append(self.filler)
if self.save_std is True:
self._std_data.append(self.filler)
if self.save_most_common is True:
self._most_common_data.append(self.filler)
if self.save_max is True:
self._max_data.append(self.filler)
@property
def mean_data(self):
"""
Return the `_mean_data`
Returns
-------
list
List of mean values along each line tested.
"""
if self.save_mean is True:
return self._mean_data
else:
return None
@property
def std_data(self):
"""
Return the `_std_data`
Returns
-------
list
List of the std values along each line tested.
"""
if self.save_std is True:
return self._std_data
else:
return None
@property
def most_common_data(self):
"""
Return the `_most_common_data`
Returns
-------
list
List of the most common value for each line tested.
"""
if self.save_most_common is True:
return self._most_common_data
else:
return None
@property
def max_data(self):
"""
Return the `_max_data`
Returns
-------
list
List of the most common value for each line tested.
"""
if self.save_max is True:
return self._max_data
else:
return None</code></pre>
</details>
<h3>Instance variables</h3>
<dl>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.max_data"><code class="name">var <span class="ident">max_data</span></code></dt>
<dd>
<div class="desc"><p>Return the <code>_max_data</code></p>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>list</code></dt>
<dd>List of the most common value for each line tested.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">@property
def max_data(self):
"""
Return the `_max_data`
Returns
-------
list
List of the most common value for each line tested.
"""
if self.save_max is True:
return self._max_data
else:
return None</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.mean_data"><code class="name">var <span class="ident">mean_data</span></code></dt>
<dd>
<div class="desc"><p>Return the <code>_mean_data</code></p>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>list</code></dt>
<dd>List of mean values along each line tested.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">@property
def mean_data(self):
"""
Return the `_mean_data`
Returns
-------
list
List of mean values along each line tested.
"""
if self.save_mean is True:
return self._mean_data
else:
return None</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.most_common_data"><code class="name">var <span class="ident">most_common_data</span></code></dt>
<dd>
<div class="desc"><p>Return the <code>_most_common_data</code></p>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>list</code></dt>
<dd>List of the most common value for each line tested.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">@property
def most_common_data(self):
"""
Return the `_most_common_data`
Returns
-------
list
List of the most common value for each line tested.
"""
if self.save_most_common is True:
return self._most_common_data
else:
return None</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.std_data"><code class="name">var <span class="ident">std_data</span></code></dt>
<dd>
<div class="desc"><p>Return the <code>_std_data</code></p>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>list</code></dt>
<dd>List of the std values along each line tested.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">@property
def std_data(self):
"""
Return the `_std_data`
Returns
-------
list
List of the std values along each line tested.
"""
if self.save_std is True:
return self._std_data
else:
return None</code></pre>
</details>
</dd>
</dl>
<h3>Methods</h3>
<dl>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.append_filler"><code class="name flex">
<span>def <span class="ident">append_filler</span></span>(<span>self)</span>
</code></dt>
<dd>
<div class="desc"><p>Add filler value to the requisite lists (_mean_data, _std_data, etc.) as
appropriate.</p></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def append_filler(self):
"""
Add filler value to the requisite lists (_mean_data, _std_data, etc.) as
appropriate.
"""
if self.save_mean is True:
self._mean_data.append(self.filler)
if self.save_std is True:
self._std_data.append(self.filler)
if self.save_most_common is True:
self._most_common_data.append(self.filler)
if self.save_max is True:
self._max_data.append(self.filler)</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.get_data_along_line"><code class="name flex">
<span>def <span class="ident">get_data_along_line</span></span>(<span>self, start_pt, end_pt)</span>
</code></dt>
<dd>
<div class="desc"><p>Function to get scalar values along a line between <code>start_pt</code> and <code>end_pt</code>. </p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>start_pt</code></strong> : <code>list</code></dt>
<dd>List of the x,y,z position of the starting point in the line.</dd>
<dt><strong><code>end_pt</code></strong> : <code>list</code></dt>
<dd>List of the x,y,z position of the ending point in the line.</dd>
</dl>
<h2 id="returns">Returns</h2>
<dl>
<dt><code>numpy.ndarray</code></dt>
<dd>numpy array of scalar values obtained along the line.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def get_data_along_line(self,
start_pt,
end_pt):
"""
Function to get scalar values along a line between `start_pt` and `end_pt`.
Parameters
----------
start_pt : list
List of the x,y,z position of the starting point in the line.
end_pt : list
List of the x,y,z position of the ending point in the line.
Returns
-------
numpy.ndarray
numpy array of scalar values obtained along the line.
"""
self.line.SetPoint1(start_pt)
self.line.SetPoint2(end_pt)
self.probe_filter.SetInputConnection(self.line.GetOutputPort())
self.probe_filter.Update()
scalars = vtk_to_numpy(self.probe_filter.GetOutput().GetPointData().GetScalars())
if self.non_zero_only is True:
scalars = scalars[scalars != 0]
return scalars</code></pre>
</details>
</dd>
<dt id="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.save_data_along_line"><code class="name flex">
<span>def <span class="ident">save_data_along_line</span></span>(<span>self, start_pt, end_pt)</span>
</code></dt>
<dd>
<div class="desc"><p>Save the appropriate outcomes to a growing list. </p>
<h2 id="parameters">Parameters</h2>
<dl>
<dt><strong><code>start_pt</code></strong> : <code>list</code></dt>
<dd>List of the x,y,z position of the starting point in the line.</dd>
<dt><strong><code>end_pt</code></strong> : <code>list</code></dt>
<dd>List of the x,y,z position of the ending point in the line.</dd>
</dl></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">def save_data_along_line(self,
start_pt,
end_pt):
"""
Save the appropriate outcomes to a growing list.
Parameters
----------
start_pt : list
List of the x,y,z position of the starting point in the line.
end_pt : list
List of the x,y,z position of the ending point in the line.
"""
scalars = self.get_data_along_line(start_pt, end_pt)
if len(scalars) > 0:
if self.save_mean is True:
self._mean_data.append(np.mean(scalars))
if self.save_std is True:
self._std_data.append(np.std(scalars, ddof=1))
if self.save_most_common is True:
# most_common is for getting segmentations and trying to assign a bone region
# to be a cartilage ROI. This is becuase there might be a normal vector that
# cross > 1 cartilage region (e.g., weight-bearing vs anterior fem cartilage)
self._most_common_data.append(np.bincount(scalars).argmax())
if self.save_max is True:
self._max_data.append(np.max(scalars))
else:
self.append_filler()</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-functions">Functions</a></h3>
<ul class="">
<li><code><a title="pymskt.mesh.meshTools.gaussian_smooth_surface_scalars" href="#pymskt.mesh.meshTools.gaussian_smooth_surface_scalars">gaussian_smooth_surface_scalars</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.get_cartilage_properties_at_points" href="#pymskt.mesh.meshTools.get_cartilage_properties_at_points">get_cartilage_properties_at_points</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.get_mesh_physical_point_coords" href="#pymskt.mesh.meshTools.get_mesh_physical_point_coords">get_mesh_physical_point_coords</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.get_smoothed_scalars" href="#pymskt.mesh.meshTools.get_smoothed_scalars">get_smoothed_scalars</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.resample_surface" href="#pymskt.mesh.meshTools.resample_surface">resample_surface</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.set_mesh_physical_point_coords" href="#pymskt.mesh.meshTools.set_mesh_physical_point_coords">set_mesh_physical_point_coords</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base" href="#pymskt.mesh.meshTools.smooth_scalars_from_second_mesh_onto_base">smooth_scalars_from_second_mesh_onto_base</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.transfer_mesh_scalars_get_weighted_average_n_closest" href="#pymskt.mesh.meshTools.transfer_mesh_scalars_get_weighted_average_n_closest">transfer_mesh_scalars_get_weighted_average_n_closest</a></code></li>
</ul>
</li>
<li><h3><a href="#header-classes">Classes</a></h3>
<ul>
<li>
<h4><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine">ProbeVtkImageDataAlongLine</a></code></h4>
<ul class="">
<li><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.append_filler" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.append_filler">append_filler</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.get_data_along_line" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.get_data_along_line">get_data_along_line</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.max_data" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.max_data">max_data</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.mean_data" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.mean_data">mean_data</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.most_common_data" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.most_common_data">most_common_data</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.save_data_along_line" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.save_data_along_line">save_data_along_line</a></code></li>
<li><code><a title="pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.std_data" href="#pymskt.mesh.meshTools.ProbeVtkImageDataAlongLine.std_data">std_data</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>
Datasets
Models
