def load_mesh_stl(fn, return_polydata_only=False):
"""
Args:
return_polydata_only (bool): If true, return polydata; if false (default), return (vertices, faces)
"""
if not os.path.exists(fn):
print('load_mesh_stl: File does not exist %s\n' % fn)
return None
reader = vtk.vtkSTLReader()
reader.SetFileName(fn)
reader.Update()
polydata = reader.GetOutput()
assert polydata is not None
if return_polydata_only:
return polydata
vertices = vtk_to_numpy(polydata.GetPoints().GetData())
a = vtk_to_numpy(polydata.GetPolys().GetData())
faces = np.c_[a[1::4], a[2::4], a[3::4]]
return vertices, faces
def fpm_reader(filename):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
vtk_data = reader.GetOutput()
coord = numpy_support.vtk_to_numpy(vtk_data.GetPoints().GetData())
concen = numpy_support.vtk_to_numpy(
vtk_data.GetPointData().GetArray(0))[:, None]
velocity = numpy_support.vtk_to_numpy(vtk_data.GetPointData().GetArray(1))
point_data = np.concatenate((coord, concen, velocity), axis=-1)
return point_data
def create_sample_element(cell_type, order=3, visualize=True):
try:
import vtk
from vtkmodules.util.numpy_support import vtk_to_numpy
except ImportError:
raise ImportError("python bindings for vtk cannot be found")
cell_type = cell_type.upper()
vtk_cell_type = getattr(vtk, cell_type, None)
if vtk_cell_type is None:
raise ValueError("unknown cell type: '%s'" % cell_type)
source = vtk.vtkCellTypeSource()
source.SetCellType(vtk_cell_type)
source.SetBlocksDimensions(1, 1, 1)
if "LAGRANGE" in cell_type:
source.SetCellOrder(order)
source.Update()
grid = source.GetOutput()
if visualize:
filename = "sample_%s.vtu" % cell_type.lower()
print("cell type: %s" % cell_type)
print("output: %s" % filename)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(filename)
writer.SetCompressorTypeToNone()
writer.SetDataModeToAscii()
writer.SetInputData(grid)
writer.Write()
cell = grid.GetCell(0)
points = vtk_to_numpy(cell.GetPoints().GetData()).T
dim = cell.GetCellDimension()
points = points[0:dim]
if cell_type in VTK_LAGRANGE_SIMPLICES:
from pyvisfile.vtk.vtk_ordering import vtk_lagrange_simplex_node_tuples
nodes = np.array(vtk_lagrange_simplex_node_tuples(dim, order))
error = la.norm(nodes / order - points.T)
print("error[%d]: %.5e" % (order, error))
assert error < 5.0e-7
if visualize:
filename = "sample_%s" % cell_type.lower()
plot_node_ordering(filename, points, show=False)
if cell_type in VTK_LAGRANGE_SIMPLICES:
filename = "sample_%s_new" % cell_type.lower()
plot_node_ordering(filename, nodes.T, show=False)
def data_array(data_array, location="PointData", name=None):
if data_array:
dataRange = data_array.GetRange(-1)
nb_comp = data_array.GetNumberOfComponents()
values = vtk_to_numpy(data_array)
js_types = to_js_type[str(values.dtype)]
return {
"name": name if name else data_array.GetName(),
"values": b64_encode_numpy(values),
"numberOfComponents": nb_comp,
"type": js_types,
"location": location,
"dataRange": dataRange,
}
def VtkRead(filepath, t):
if not const.VTK_WARNING:
log_path = os.path.join(inv_paths.USER_LOG_DIR, "vtkoutput.txt")
fow = vtkFileOutputWindow()
fow.SetFileName(log_path.encode(const.FS_ENCODE))
ow = vtkOutputWindow()
ow.SetInstance(fow)
global no_error
if t == "bmp":
reader = vtkBMPReader()
elif t == "tiff" or t == "tif":
reader = vtkTIFFReader()
elif t == "png":
reader = vtkPNGReader()
elif t == "jpeg" or t == "jpg":
reader = vtkJPEGReader()
else:
return False
reader.AddObserver("ErrorEvent", VtkErrorToPy)
reader.SetFileName(filepath)
reader.Update()
if no_error:
image = reader.GetOutput()
dim = image.GetDimensions()
if reader.GetNumberOfScalarComponents() > 1:
luminanceFilter = vtkImageLuminance()
luminanceFilter.SetInputData(image)
luminanceFilter.Update()
image = vtkImageData()
image.DeepCopy(luminanceFilter.GetOutput())
img_array = numpy_support.vtk_to_numpy(
image.GetPointData().GetScalars())
img_array.shape = (dim[1], dim[0])
return img_array
else:
no_error = True
return False
def _dump_ren_win(self):
qDebug('ObjectRenderer: DUMPING RENDER')
self._render_window.PushState()
self.openGLInitState()
self._render_window.Start()
# Render
self._render_window.Render()
width, height = self._render_window.GetSize()
arr = vtk.vtkUnsignedCharArray()
self.ren_win.GetRGBACharPixelData(0, 0, width - 1, height - 1, 0, arr)
data = vtk_to_numpy(arr).reshape(height, width, -1)[::-1]
self._render_window.PopState()
self.__m_vtkFboItem.window().resetOpenGLState()
return data
def mip_z():
ImageSlab = vtk.vtkImageSlabReslice()
ImageSlab.SetInputData(imagedata)
ImageSlab.SetResliceAxesOrigin(center)
ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_z)
ImageSlab.SetSlabThickness(ConstPixelSpacing[2] * ConstPixelDims[2])
ImageSlab.SetBlendModeToMax()
ImageSlab.SetSlabResolution(ConstPixelSpacing[2])
ImageSlab.Update()
image = ImageSlab.GetOutput()
m = image.GetDimensions()
vtk_data = image.GetPointData().GetScalars()
arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
arr = (arr - np.min(arr)) / ((np.max(arr) - np.min(arr)) / 255)
# cv2.imwrite( path + name +'.jpg', arr)
return arr
def CalculateHistogram(self):
image = self.image
r = int(image.GetScalarRange()[1] - image.GetScalarRange()[0])
accumulate = vtkImageAccumulate()
accumulate.SetInputData(image)
accumulate.SetComponentExtent(0, r - 1, 0, 0, 0, 0)
accumulate.SetComponentOrigin(image.GetScalarRange()[0], 0, 0)
# accumulate.ReleaseDataFlagOn()
accumulate.Update()
n_image = numpy_support.vtk_to_numpy(
accumulate.GetOutput().GetPointData().GetScalars())
del accumulate
init, end = image.GetScalarRange()
Publisher.sendMessage('Load histogram',
histogram=n_image,
init=init,
end=end)
def mip_y():
ImageSlab = vtk.vtkImageSlabReslice()
ImageSlab.SetInputData(imagedata)
ImageSlab.SetResliceAxesOrigin(center)
ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_y)
ImageSlab.SetSlabThickness(ConstPixelSpacing[1] * ConstPixelDims[1])
ImageSlab.SetBlendModeToMax()
ImageSlab.SetSlabResolution(ConstPixelSpacing[1])
ImageSlab.Update()
image = ImageSlab.GetOutput()
m = image.GetDimensions()
vtk_data = image.GetPointData().GetScalars()
arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
arr = (arr - np.min(arr)) / ((np.max(arr) - np.min(arr)) / 255)
width = int(ConstPixelDims[2] *
(ConstPixelSpacing[2] / ConstPixelSpacing[0]))
height = ConstPixelDims[0]
dim = (width, height)
resized = cv2.resize(np.rot90(arr, -1), dim, interpolation=cv2.INTER_AREA)
# cv2.imwrite( path + name +'.jpg', resized)
return resized
def polydata_to_mesh(polydata):
"""
Extract vertice and face data from a polydata object.
Returns:
(vertices, faces)
"""
vertices = np.array(
[polydata.GetPoint(i) for i in range(polydata.GetNumberOfPoints())])
try:
face_data_arr = vtk_to_numpy(polydata.GetPolys().GetData())
faces = np.c_[face_data_arr[1::4], face_data_arr[2::4],
face_data_arr[3::4]]
except:
sys.stderr.write('polydata_to_mesh: No faces are loaded.\n')
faces = []
return vertices, faces
def mip_x():
ImageSlab = vtk.vtkImageSlabReslice()
ImageSlab.SetInputData(imagedata)
ImageSlab.SetResliceAxesOrigin(center)
ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_x)
ImageSlab.SetSlabThickness(ConstPixelSpacing[0] * ConstPixelDims[0])
ImageSlab.SetBlendModeToMax()
ImageSlab.SetSlabResolution(ConstPixelSpacing[0])
ImageSlab.Update()
image = ImageSlab.GetOutput()
m = image.GetDimensions()
vtk_data = image.GetPointData().GetScalars()
arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
arr = (arr - numpy.min(arr)) / ((numpy.max(arr) - numpy.min(arr)) / 255)
width = columns
height = int(
len(lstFilesDCM) * (ConstPixelSpacing[2] / ConstPixelSpacing[1]))
dim = (width, height)
resized = cv2.resize(numpy.rot90(arr, 1),
dim,
interpolation=cv2.INTER_AREA)
return resized
def bitmap2memmap(files, slice_size, orientation, spacing, resolution_percentage):
"""
From a list of dicom files it creates memmap file in the temp folder and
returns it and its related filename.
"""
message = _("Generating multiplanar visualization...")
if len(files) > 1:
update_progress = vtk_utils.ShowProgress(
len(files) - 1, dialog_type="ProgressDialog"
)
temp_file = tempfile.mktemp()
if orientation == "SAGITTAL":
if resolution_percentage == 1.0:
shape = slice_size[1], slice_size[0], len(files)
else:
shape = (
math.ceil(slice_size[1] * resolution_percentage),
math.ceil(slice_size[0] * resolution_percentage),
len(files),
)
elif orientation == "CORONAL":
if resolution_percentage == 1.0:
shape = slice_size[1], len(files), slice_size[0]
else:
shape = (
math.ceil(slice_size[1] * resolution_percentage),
len(files),
math.ceil(slice_size[0] * resolution_percentage),
)
else:
if resolution_percentage == 1.0:
shape = len(files), slice_size[1], slice_size[0]
else:
shape = (
len(files),
math.ceil(slice_size[1] * resolution_percentage),
math.ceil(slice_size[0] * resolution_percentage),
)
if resolution_percentage == 1.0:
matrix = numpy.memmap(temp_file, mode="w+", dtype="int16", shape=shape)
cont = 0
max_scalar = None
min_scalar = None
xy_shape = None
first_resample_entry = False
for n, f in enumerate(files):
image_as_array = bitmap_reader.ReadBitmap(f)
image = converters.to_vtk(
image_as_array,
spacing=spacing,
slice_number=1,
orientation=orientation.upper(),
)
if resolution_percentage != 1.0:
image_resized = ResampleImage2D(
image,
px=None,
py=None,
resolution_percentage=resolution_percentage,
update_progress=None,
)
yx_shape = (
image_resized.GetDimensions()[1],
image_resized.GetDimensions()[0],
)
if not (first_resample_entry):
shape = shape[0], yx_shape[0], yx_shape[1]
matrix = numpy.memmap(temp_file, mode="w+", dtype="int16", shape=shape)
first_resample_entry = True
image = image_resized
min_aux, max_aux = image.GetScalarRange()
if min_scalar is None or min_aux < min_scalar:
min_scalar = min_aux
if max_scalar is None or max_aux > max_scalar:
max_scalar = max_aux
array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars())
if array.dtype == "uint16":
new_array = np.empty_like(array, dtype=np.int16)
new_array = array - 32768
array = new_array
if orientation == "CORONAL":
array.shape = matrix.shape[0], matrix.shape[2]
matrix[:, n, :] = array[:, ::-1]
elif orientation == "SAGITTAL":
array.shape = matrix.shape[0], matrix.shape[1]
# TODO: Verify if it's necessary to add the slices swapped only in
# sagittal rmi or only in # Rasiane's case or is necessary in all
# sagittal cases.
matrix[:, :, n] = array[:, ::-1]
else:
array.shape = matrix.shape[1], matrix.shape[2]
matrix[n] = array
if len(files) > 1:
update_progress(cont, message)
cont += 1
matrix.flush()
scalar_range = min_scalar, max_scalar
return matrix, scalar_range, temp_file
def mesh_array(array):
if array:
return b64_encode_numpy(vtk_to_numpy(array.GetData()))
def create_sample_element(cell_type, order=3, visualize=True):
from distutils.version import LooseVersion
if LooseVersion(vtk.VTK_VERSION) > "8.2.0":
vtk_version = (2, 2)
else:
vtk_version = (2, 1)
cell_type = cell_type.upper()
vtk_cell_type = getattr(vtk, cell_type, None)
if vtk_cell_type is None:
raise ValueError("unknown cell type: '%s'" % cell_type)
source = vtk.vtkCellTypeSource()
source.SetCellType(vtk_cell_type)
source.SetBlocksDimensions(1, 1, 1)
if "LAGRANGE" in cell_type:
source.SetCellOrder(order)
# 0 - single precision; 1 - double precision
source.SetOutputPrecision(1)
source.Update()
grid = source.GetOutput()
cell = grid.GetCell(0)
points = vtk_to_numpy(cell.GetPoints().GetData()).copy().T
dim = cell.GetCellDimension()
points = points[0:dim]
basename = f"sample_{cell_type.lower()}"
if visualize:
filename = f"{basename}.vtu"
print("vtk xml version:", vtk_version)
print("cell type: %s" % cell_type)
print("output: %s" % filename)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(filename)
writer.SetCompressorTypeToNone()
writer.SetDataModeToAscii()
writer.SetInputData(grid)
writer.Write()
# NOTE: vtkCellTypeSource always tesselates a square and the way it does
# that to get tetrahedra changed in
# https://gitlab.kitware.com/vtk/vtk/-/merge_requests/6529
if LooseVersion(vtk.VTK_VERSION) > "8.2.0" \
and cell_type == "VTK_LAGRANGE_TETRAHEDRON":
rot = np.array([
[1, -1, 0],
[0, 1, -1],
[0, 0, 2]
])
points = rot @ points
if cell_type in VTK_LAGRANGE_SIMPLICES:
from pyvisfile.vtk.vtk_ordering import (
vtk_lagrange_simplex_node_tuples,
vtk_lagrange_simplex_node_tuples_to_permutation)
node_tuples = vtk_lagrange_simplex_node_tuples(dim, order,
vtk_version=vtk_version)
vtk_lagrange_simplex_node_tuples_to_permutation(node_tuples)
nodes = np.array(node_tuples) / order
error = la.norm(nodes - points.T)
elif cell_type in VTK_LAGRANGE_QUADS:
from pyvisfile.vtk.vtk_ordering import (
vtk_lagrange_quad_node_tuples,
vtk_lagrange_quad_node_tuples_to_permutation)
node_tuples = vtk_lagrange_quad_node_tuples(dim, order,
vtk_version=vtk_version)
vtk_lagrange_quad_node_tuples_to_permutation(node_tuples)
nodes = np.array(node_tuples) / order
error = la.norm(nodes - points.T)
else:
error = None
# NOTE: skipping the curve check because the ordering is off in the
# vtkCellTypeSource output
# https://gitlab.kitware.com/vtk/vtk/-/merge_requests/6555
if LooseVersion(vtk.VTK_VERSION) <= "8.2.0" \
and cell_type == "VTK_LAGRANGE_CURVE":
error = None
if error is not None:
if error < 5.0e-15:
print(f"\033[92m[PASSED] order {order:2d} error {error:.5e}\033[0m")
else:
print(f"\033[91m[FAILED] order {order:2d} error {error:.5e}\033[0m")
if not visualize:
return
filename = f"{basename}_vtk"
plot_node_ordering(filename, points, show=False)
if cell_type in (VTK_LAGRANGE_SIMPLICES + VTK_LAGRANGE_QUADS):
filename = f"{basename}_pyvisfile"
plot_node_ordering(filename, nodes.T, show=False)
ImageSlab.SetInputData(imagedata)
ImageSlab.SetResliceAxesOrigin(center)
ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_y)
ImageSlab.SetSlabThickness(ConstPixelSpacing[1] * ConstPixelDims[1])
ImageSlab.SetBlendModeToMax()
ImageSlab.SetSlabResolution(ConstPixelSpacing[1])
ImageSlab.Update()
image = ImageSlab.GetOutput()
m = image.GetDimensions()
# print(m)
writer = vtk.vtkMetaImageWriter()
writer.SetInputData(image)
writer.SetFileName("E:/Dicom/test/DicomResource/test11.mhd")
writer.Write()
vtk_data = image.GetPointData().GetScalars()
arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
# print(numpy.max(arr))
# print(numpy.min(arr))
arr = (arr - numpy.min(arr)) / ((numpy.max(arr) - numpy.min(arr)) / 255)
print(numpy.shape(arr))
width = int(len(lstFilesDCM) * (ConstPixelSpacing[2] / ConstPixelSpacing[0]))
height = Dim[0]
dim = (width, height)
resized = cv2.resize(numpy.rot90(arr, -1), dim, interpolation=cv2.INTER_AREA)
cv2.imwrite('mip12.png', resized)
def Poly2Label2D(poly, dim, origin, spacing):
'''
Input:
poly: numpy array (n*2), poly to convert
dim: dimention of target label
origin: origin of target label
spacing: spacing of target label
Output: numpy array, result 2D label
Description: Convert a 2D contour to 2D label
'''
# 1 构建poly
NumOfPoints = len(poly)
Points = vtk.vtkPoints()
polydata = vtk.vtkPolyData()
Points.Reset()
i = 0
while i < NumOfPoints:
Points.InsertPoint(i, (poly[i][0], poly[i][1], 0))
i += 1
polydata.Modified()
lines = vtk.vtkCellArray()
lines.InsertNextCell(NumOfPoints+1)
i = 0
while i < NumOfPoints:
lines.InsertCellPoint(i)
i += 1
lines.InsertCellPoint(0)
polydata.SetPoints(Points)
polydata.SetLines(lines)
polydata.Modified()
# 2 建立空白图像
Image = vtk.vtkImageData()
Image.SetDimensions(dim[0], dim[1], 1)
Image.SetOrigin(origin[0], origin[1], 0)
Image.SetSpacing(spacing[0], spacing[1], 0)
Image.AllocateScalars(vtk.VTK_INT, 1)
count = Image.GetNumberOfPoints()
# Fill every entry of the image data with "0"
for i in range(count):
Image.GetPointData().GetScalars().SetTuple1(i, 0)
# 3 LinearExtrusionFilter
extrudeFilter = vtk.vtkLinearExtrusionFilter()
extrudeFilter.SetInputData(polydata)
extrudeFilter.SetScaleFactor(1)
extrudeFilter.SetExtrusionTypeToNormalExtrusion()
extrudeFilter.SetVector( 0, 0, 1)
# 4 poly沿z轴平移-0.5
m1 = vtk.vtkMatrix4x4()
m1.SetElement(2, 3, -0.5)
linearTransform = vtk.vtkMatrixToLinearTransform()
linearTransform.GetMatrix().DeepCopy(m1)
transformPolyData = vtk.vtkTransformPolyDataFilter()
transformPolyData.SetInputConnection(extrudeFilter.GetOutputPort())
transformPolyData.SetTransform(linearTransform)
# 5 转换
dataToStencil = vtk.vtkPolyDataToImageStencil()
dataToStencil.SetInputConnection(transformPolyData.GetOutputPort())
dataToStencil.SetOutputSpacing(spacing[0], spacing[1], 0)
dataToStencil.SetOutputOrigin(origin[0], origin[1], 0)
stencil = vtk.vtkImageStencil()
stencil.SetStencilConnection(dataToStencil.GetOutputPort())
stencil.SetInputData(Image)
stencil.ReverseStencilOn()
stencil.SetBackgroundValue(1)
stencil.Update()
# 6 vtk 2 numpy
dataObj = stencil.GetOutput()
vtkArray = dataObj.GetPointData().GetArray(0)
numpyarray = numpy_support.vtk_to_numpy(vtkArray)
Output = numpy.reshape(numpyarray, dim, order='F')
return Output