def create_mesh(label_pix, labels_to_use, inds_to_phys=None):
# convert the numpy representation to VTK, so we can create a mesh
# using marching cubes for display later
vtk_import = vtkImageImport()
vtk_import.SetImportVoidPointer(label_pix, True)
vtk_import.SetDataScalarType(VTK_UNSIGNED_CHAR)
vtk_import.SetNumberOfScalarComponents(1)
vtk_import.SetDataExtent(0, label_pix.shape[2] - 1, 0,
label_pix.shape[1] - 1, 0, label_pix.shape[0] - 1)
vtk_import.SetWholeExtent(0, label_pix.shape[2] - 1, 0,
label_pix.shape[1] - 1, 0,
label_pix.shape[0] - 1)
vtk_import.Update()
flipper = vtkImageFlip()
flipper.SetInputData(vtk_import.GetOutput())
flipper.SetFilteredAxis(1)
flipper.FlipAboutOriginOff()
flipper.Update()
vtk_img = flipper.GetOutput()
marching_cubes = vtkDiscreteMarchingCubes()
marching_cubes.SetInputData(vtk_img)
num_labels_to_use = len(labels_to_use)
marching_cubes.SetNumberOfContours(num_labels_to_use)
for i in range(num_labels_to_use):
marching_cubes.SetValue(i, labels_to_use[i])
marching_cubes.Update()
smoother = vtkWindowedSincPolyDataFilter()
smoother.SetInputData(marching_cubes.GetOutput())
smoother.SetNumberOfIterations(25)
smoother.SetPassBand(0.1)
smoother.SetBoundarySmoothing(False)
smoother.SetFeatureEdgeSmoothing(False)
smoother.SetFeatureAngle(120.0)
smoother.SetNonManifoldSmoothing(True)
smoother.NormalizeCoordinatesOn()
smoother.Update()
mesh_reduce = vtkQuadricDecimation()
mesh_reduce.SetInputData(smoother.GetOutput())
mesh_reduce.SetTargetReduction(0.25)
mesh_reduce.Update()
vertex_xform = np.mat(np.eye(4))
vertex_xform[1, 1] = -1
vertex_xform[1, 3] = label_pix.shape[1] + 1
vertex_xform = inds_to_phys * vertex_xform
return xform_mesh(mesh_reduce.GetOutput(), vertex_xform)
def getVTKfromNumpy(self, img, spacing=[1.0, 1.0, 1.0]):
# This method of returning a numpy array was found on github
# it works well so used it for the volume Rendering
# img :
importer = vtk.vtkImageImport()
img_data = img.astype('uint8')
img_string = img_data.tostring()
dim = img.shape
importer.CopyImportVoidPointer(img_string, len(img_string))
importer.SetDataScalarType(VTK_UNSIGNED_CHAR)
importer.SetNumberOfScalarComponents(1)
extent = importer.GetDataExtent()
importer.SetDataExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetWholeExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetDataSpacing(spacing[0], spacing[1], spacing[2])
importer.SetDataOrigin(0, 0, 0)
return importer # vtk object
def numpy2VTK(img,spacing=[1.0,1.0,1.0]):
# evolved from code from Stou S.,
# on http://www.siafoo.net/snippet/314
importer = vtk.vtkImageImport()
img_data = img.astype('uint8')
img_string = img_data.tostring() # type short
dim = img.shape
importer.CopyImportVoidPointer(img_string, len(img_string))
importer.SetDataScalarType(VTK_UNSIGNED_CHAR)
importer.SetNumberOfScalarComponents(1)
extent = importer.GetDataExtent()
importer.SetDataExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetWholeExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetDataSpacing( spacing[0], spacing[1], spacing[2])
importer.SetDataOrigin( 0,0,0 )
return importer
def set_image(self, image):
"""Setup image actor from image data
Args:
image: RGB image array
"""
# Flip vertically and change BGR->RGB
image = np.copy(image)[::-1, :, ::-1]
# Save reference to image
self.image = np.ascontiguousarray(image, dtype=np.uint8)
# Setup vtkImageImport
height, width = image.shape[0:2]
vtk_image_import = vtk.vtkImageImport()
vtk_image_import.SetDataSpacing(1, 1, 1)
vtk_image_import.SetDataOrigin(0, 0, 0)
vtk_image_import.SetWholeExtent(0, width - 1, 0, height - 1, 0, 0)
vtk_image_import.SetDataExtentToWholeExtent()
vtk_image_import.SetDataScalarTypeToUnsignedChar()
vtk_image_import.SetNumberOfScalarComponents(3)
vtk_image_import.SetImportVoidPointer(self.image)
vtk_image_import.Update()
# Get vtkImageData
vtk_image_data = vtk_image_import.GetOutput()
self._save_image_data(vtk_image_data)
def as_image_data(volume, info=None):
"""
Convert a numpy array 'volume' to vtk.vtkImageData
"""
if info is None and not isinstance(volume, VTKImage):
raise ValueError('Need info instance of VTKInformation or '
'volume instance of VTKImage')
if info is None:
info = volume.information()
# TODO: Fix seg fault when extent is not (0, x, 0, y, 0, z)
# it's an issue with python's gc. The allocated memory
# for importer.GetOutput() is freed when vtk_array goes
# out of scope
importer = vtk.vtkImageImport()
importer.SetDataScalarType(info.datatype)
importer.SetNumberOfScalarComponents(1)
importer.SetDataExtent(info.extent)
importer.SetWholeExtent(info.extent)
importer.SetDataOrigin(info.origin)
importer.SetDataSpacing(info.spacing)
size = len(volume.flat) * volume.dtype.itemsize
array = volume.flatten('F')
vtk_array = numpy_support.numpy_to_vtk(array, 1, info.datatype)
# Set pointer to image scalars
importer.CopyImportVoidPointer(vtk_array.GetVoidPointer(0), size)
importer.Update()
return vtk_array, importer.GetOutput()
def numpy2vtk(data_matrix):
type_dict = {
np.dtype(np.uint8):
lambda dataImporter: dataImporter.SetDataScalarTypeToUnsignedChar,
np.dtype(np.int16):
lambda dataImporter: dataImporter.SetDataScalarTypeToShort,
np.dtype(np.uint16):
lambda dataImporter: dataImporter.SetDataScalarTypeToUnsignedShort,
np.dtype(np.int32):
lambda dataImporter: dataImporter.SetDataScalarTypeToInt,
np.dtype(np.float):
lambda dataImporter: dataImporter.SetDataScalarTypeToFloat,
np.dtype(np.double):
lambda dataImporter: dataImporter.SetDataScalarTypeToDouble,
}
dataImporter = vtk.vtkImageImport()
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
type_dict[data_matrix.dtype](dataImporter)()
dataImporter.SetNumberOfScalarComponents(1)
slice, height, width = len(data_matrix), len(data_matrix[0]), len(
data_matrix[0][0])
dataImporter.SetDataExtent(0, width - 1, 0, height - 1, 0, slice - 1)
dataImporter.SetWholeExtent(0, width - 1, 0, height - 1, 0, slice - 1)
return dataImporter
def ConvertSimpleITKtoVTK(img):
"""
"""
size = list(img.GetSize())
origin = list(img.GetOrigin())
spacing = list(img.GetSpacing())
ncomp = img.GetNumberOfComponentsPerPixel()
# convert the SimpleITK image to a numpy array
arr = sitk.GetArrayFromImage(img).transpose(2, 1, 0).flatten()
arr_string = arr.tostring()
# send the numpy array to VTK with a vtkImageImport object
dataImporter = vtk.vtkImageImport()
dataImporter.CopyImportVoidPointer(arr_string, len(arr_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(ncomp)
# Set the new VTK image's parameters
dataImporter.SetDataExtent(0, size[0] - 1, 0, size[1] - 1, 0, size[2] - 1)
dataImporter.SetWholeExtent(0, size[0] - 1, 0, size[1] - 1, 0, size[2] - 1)
dataImporter.SetDataOrigin(origin)
dataImporter.SetDataSpacing(spacing)
dataImporter.Update()
vtk_image = dataImporter.GetOutput()
return vtk_image
def __init__(self):
self.__vtkimport=vtk.vtkImageImport()
self.__vtkimport.SetDataScalarTypeToFloat()
self.__vtkimport.SetNumberOfScalarComponents(1)
self.__filePattern=self.__defaultFilePattern
self.__data = None
self._irs = vtk.vtkImageReslice()
def numpy2VTKimporter(img, spacing=[1.0, 1.0, 1.0], origin=[0.0, 0.0, 0.0]):
dim = img.shape
print("dim", dim)
# reshape the numpy array to (512,512,256)
# img = img.reshape(dim[0], dim[1], dim[2])
importer = vtk.vtkImageImport()
img_data = img.astype('uint8')
# img_string = img_data.tobytes() # type short
img_string = img_data.tostring() # type short
# importer.CopyImportVoidPointer(img_data, img_data.nbytes)
importer.CopyImportVoidPointer(img_string, len(img_string))
importer.SetDataScalarType(VTK_UNSIGNED_CHAR)
importer.SetNumberOfScalarComponents(1)
extent = importer.GetDataExtent()
print("extent", extent)
importer.SetDataExtent(extent[0], extent[0] + dim[2] - 1, extent[2],
extent[2] + dim[1] - 1, extent[4],
extent[4] + dim[0] - 1)
importer.SetWholeExtent(extent[0], extent[0] + dim[2] - 1, extent[2],
extent[2] + dim[1] - 1, extent[4],
extent[4] + dim[0] - 1)
importer.SetDataSpacing(spacing[0], spacing[1], spacing[2])
#importer.SetDataOrigin( origin[0], origin[1], origin[2] )
return importer
def ConvertNumpyVTKImage(NumpyImageData, arrayName , dim, vtkOrigin ): # Create initial image # imports raw data and stores it. dataImporter = vtk.vtkImageImport() # array is converted to a string of chars and imported. # numpy array stored as ROW MAJOR # MUST write out in COLUMN MAJOR format to be the same as VTK data_string = NumpyImageData.tostring(order='F') dataImporter.CopyImportVoidPointer(data_string, len(data_string)) # The type of the newly imported data is set to unsigned char (uint8) dataImporter.SetDataScalarTypeToDouble() # Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer # must be told this is the case. dataImporter.SetNumberOfScalarComponents(1) # The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this # simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case. # I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although # VTK complains if not both are used. dataImporter.SetDataExtent( 0, dim[0]-1, 0, dim[1]-1, 0, dim[2]-1) dataImporter.SetWholeExtent(0, dim[0]-1, 0, dim[1]-1, 0, dim[2]-1) dataImporter.SetDataSpacing( spacing ) dataImporter.SetDataOrigin( vtkOrigin ) dataImporter.SetScalarArrayName( arrayName ) dataImporter.Update() return dataImporter.GetOutput()
def saveVtk3d(filepath, img, spacing=[1.0, 1.0, 1.0]):
assert (img.ndim == 3)
nx, ny, nz = img.shape
dataImport = vtk.vtkImageImport()
dataImport.SetNumberOfScalarComponents(1)
dataImport.SetDataExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
dataImport.SetWholeExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
dataType = img.dtype
if dataType == np.float_ or dataType == np.float64:
dataImport.SetDataScalarTypeToDouble()
elif dataType == np.float32:
dataImport.SetDataScalarTypeToFloat()
elif dataType == np.int_ or dataType == np.int32:
dataImport.SetDataScalarTypeToInt()
elif dataType == np.int16:
dataImport.SetDataScalarTypeToShort()
elif dataType == np.uint16:
dataImport.SetDataScalarTypeToUnsignedShort()
elif dataType == np.uint8:
dataImport.SetDataScalarTypeToUnsignedChar()
else:
# convert image to unsigned short
img = utils.nnormalize(img)
img = np.round(img * 65535.0).astype(np.uint16)
dataString = img.tostring(order='F')
dataImport.CopyImportVoidPointer(dataString, len(dataString))
dataImport.SetDataSpacing(spacing)
dataImport.Update()
writer = vtk.vtkXMLImageDataWriter()
writer.SetFileName(filepath)
writer.SetInputData(dataImport.GetOutput())
writer.Write()
def __init__(self):
""" Class constructor """
# Initialize the OpenCV object responsible for acquire the images
self.capture = cv2.VideoCapture(0)
# Initialize the VTK object that is going to translate the image
self.image = vtk.vtkImageImport()
self.image.SetDataScalarTypeToUnsignedChar()
# Three color layers
self.image.SetNumberOfScalarComponents(3)
# Image dimensions
width, height = self.size
self.image.SetDataExtent(0, width-1, 0, height-1, 0, 0)
self.image.SetWholeExtent(0, width-1, 0, height-1, 0, 0)
self.update()
# Initialize render and assign the deepest layer
self.render = vtk.vtkRenderer()
self.render.SetLayer(0)
self.render.InteractiveOff()
# In VTK renders objects are shown through actors, like in a movie
self.image_actor = vtk.vtkImageActor()
image_port = self.image.GetOutputPort()
self.image_actor.GetMapper().SetInputConnection(image_port)
# Place actor into action
self.render.AddActor(self.image_actor)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.reader = vtk.vtkDICOMImageReader()
#self.viewerL = vtk.vtkImageViewer2()
#self.viewerR = vtk.vtkImageViewer2()
self.renL = vtk.vtkRenderer()
self.ui.leftVtk.GetRenderWindow().AddRenderer(self.renL)
self.renR = vtk.vtkRenderer()
self.ui.rightVtk.GetRenderWindow().AddRenderer(self.renR)
self.mapperL = vtk.vtkImageMapper()
self.mapperL.SetInputConnection(self.reader.GetOutputPort())
self.mapperR = vtk.vtkImageMapper()
self.actorL = vtk.vtkActor2D()
self.actorL.SetMapper(self.mapperL)
self.actorR = vtk.vtkActor2D()
self.actorR.SetMapper(self.mapperR)
self.renL.AddActor2D(self.actorL)
self.renR.AddActor2D(self.actorR)
self.importer = vtk.vtkImageImport()
self.mapperR.SetInputConnection(self.importer.GetOutputPort())
self.loadImage(os.path.join(STARTINGPATH, FILENAME))
self.setWindowingAlg()
def __init__(self, img, color):
self.volume = vtk.vtkVolume()
self.__color = color
dataImporter = vtk.vtkImageImport()
simg = np.ascontiguousarray(img, np.uint8)
dataImporter.CopyImportVoidPointer(simg.data, len(simg.data))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
dataImporter.SetWholeExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
self.__smoother = vtk.vtkImageGaussianSmooth()
self.__smoother.SetStandardDeviation(1, 1, 1)
self.__smoother.SetInputConnection(dataImporter.GetOutputPort())
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputConnection(self.__smoother.GetOutputPort())
self.__volumeProperty = vtk.vtkVolumeProperty()
self.__colorFunc = vtk.vtkColorTransferFunction()
self.__alpha = vtk.vtkPiecewiseFunction()
for i in range(256):
self.__colorFunc.AddRGBPoint(i, i * color[0], i * color[1], i * color[2])
self.__alpha.AddPoint(5, .01)
self.__alpha.AddPoint(10, .03)
self.__alpha.AddPoint(50, .1)
self.__alpha.AddPoint(150, .2)
self.__volumeProperty.SetColor(self.__colorFunc)
self.__volumeProperty.SetScalarOpacity(self.__alpha)
self.volume.SetMapper(volumeMapper)
self.volume.SetProperty(self.__volumeProperty)
def CreateVTKImage(imageDimensions, imageSpacing, imageOrigin):
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# array is converted to a string of chars and imported.
# numpy array stored as ROW MAJOR
# MUST write out in COLUMN MAJOR format to be the same as VTK
data_string = numpy.zeros(imageDimensions, dtype=numpy.float,
order='F').tostring(order='F')
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToDouble()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent(0, imageDimensions[0] - 1, 0,
imageDimensions[1] - 1, 0,
imageDimensions[2] - 1)
dataImporter.SetWholeExtent(0, imageDimensions[0] - 1, 0,
imageDimensions[1] - 1, 0,
imageDimensions[2] - 1)
dataImporter.SetDataSpacing(imageSpacing)
dataImporter.SetDataOrigin(imageOrigin)
dataImporter.SetScalarArrayName("scalars")
dataImporter.Update()
return dataImporter.GetOutput()
def numpy_to_vtk(numpy_data, spacing):
"""
Parameters
----------
image : 3d numpy array
spacing : 解像度情報．(float, float, float)のタプル型．
Returns
-------
numpy data : vtk data
"""
w, h, d = numpy_data.shape
scalar_type = numpy_support.get_vtk_array_type(numpy_data.dtype)
# データ順序がC形式でなければならないため，Fortran形式から変換．
if numpy_data.flags.c_contiguous != True:
numpy_data = np.ndarray.flatten(numpy_data, order='F')
numpy_data = np.reshape(numpy_data, (w, h, d), order='C')
vtk_data = vtk.vtkImageImport()
vtk_data.SetDataScalarType(scalar_type)
vtk_data.SetDataSpacing(spacing)
vtk_data.SetDataOrigin(0, 0, 0)
vtk_data.SetDataExtent(0, w - 1, 0, h - 1, 0, d - 1)
vtk_data.SetWholeExtent(0, w - 1, 0, h - 1, 0, d - 1)
vtk_data.SetNumberOfScalarComponents(1)
vtk_data.CopyImportVoidPointer(numpy_data, numpy_data.nbytes)
vtk_data.Update()
return vtk_data
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.reader = vtk.vtkDICOMImageReader()
#self.viewerL = vtk.vtkImageViewer2()
#self.viewerR = vtk.vtkImageViewer2()
self.renL = vtk.vtkRenderer()
self.ui.leftVtk.GetRenderWindow().AddRenderer(self.renL)
self.renR = vtk.vtkRenderer()
self.ui.rightVtk.GetRenderWindow().AddRenderer(self.renR)
self.mapperL = vtk.vtkImageMapper()
self.mapperL.SetInputConnection(self.reader.GetOutputPort())
self.mapperR = vtk.vtkImageMapper()
self.actorL = vtk.vtkActor2D()
self.actorL.SetMapper(self.mapperL)
self.actorR = vtk.vtkActor2D()
self.actorR.SetMapper(self.mapperR)
self.renL.AddActor2D(self.actorL)
self.renR.AddActor2D(self.actorR)
self.importer = vtk.vtkImageImport()
self.mapperR.SetInputConnection(self.importer.GetOutputPort())
self.loadImage(os.path.join(STARTINGPATH, FILENAME))
self.setWindowingAlg()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkImageImport(), 'Processing.',
(), ('vtkImageData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def vox2vtk(voxels, zero_point=None):
""" converts voxels to vkt mesh object
reduce_poly: 0-1, less to more simplification
zero_point: if a zero point is provided, the extent of the vtk file is set so that the zero point is in the center
"""
# import voxels
xs, ys, zs = voxels.shape
dataImporter = vtk.vtkImageImport()
data_string = voxels.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
# whole extent needs to be relative to original
dataImporter.SetDataExtent(0, zs - 1, 0, ys - 1, 0, xs - 1)
if zero_point is None:
dataImporter.SetWholeExtent(0, xs - 1, 0, ys - 1, 0, zs - 1)
else:
dataImporter.SetWholeExtent(-zero_point[0], zs - 1, -zero_point[1],
ys - 1, -zero_point[2], xs - 1)
# convert to mesh
dmc = vtk.vtkDiscreteMarchingCubes()
dmc.SetInputConnection(dataImporter.GetOutputPort())
dmc.GenerateValues(1, 1, 1)
dmc.Update()
return dmc
def ConvertNumpyVTKImage(NumpyImageData, ArrayName, ImageDim, ImageSpacing,
ImageOrigin):
# Create initial image
# imports raw data and stores it.
import vtk
dataImporter = vtk.vtkImageImport()
# array is converted to a string of chars and imported.
data_string = NumpyImageData.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToDouble()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent(0, ImageDim[0] - 1, 0, ImageDim[1] - 1, 0,
ImageDim[2] - 1)
dataImporter.SetWholeExtent(0, ImageDim[0] - 1, 0, ImageDim[1] - 1, 0,
ImageDim[2] - 1)
dataImporter.SetDataSpacing(ImageSpacing)
dataImporter.SetDataOrigin(ImageOrigin)
dataImporter.SetScalarArrayName(ArrayName)
dataImporter.Update()
return dataImporter.GetOutput()
def getMaskFromPoints(points, mx, my, mz, value=255):
"""
Create a mask where all given points are set to value (between 0-255)
"""
if value > 255:
value = 255
elif value < 0:
value = 0
size = mx * my
pointStructString = "%dB" % size
pointData = []
for y in range(0, my):
for x in range(0, mx):
pointData.append(value * points.get((x, y), 0))
packedPointString = struct.pack(pointStructString, *pointData)
importer = vtk.vtkImageImport()
importer.CopyImportVoidPointer(packedPointString, mx * my)
importer.SetDataScalarTypeToUnsignedChar()
importer.SetNumberOfScalarComponents(1)
importer.SetDataExtent(0, mx - 1, 0, my - 1, 0, 0)
importer.SetWholeExtent(0, mx - 1, 0, my - 1, 0, 0)
importer.Update()
append = vtk.vtkImageAppend()
append.SetAppendAxis(2)
for z in range(0, mz):
append.SetInput(z, importer.GetOutput())
append.Update()
image2 = append.GetOutput()
return image2
def label_to_importer(d):
"""
The numpy array of label send to vtk must be a cube shape
I can not figure out why???
"""
labels = np.unique(d)[1:]
binarys = []
for label in labels:
data = d.copy()
data[data != label] = 0
data[data == label] = 1
data_importer = vtk.vtkImageImport()
data_importer.CopyImportVoidPointer(data, data.nbytes)
data_importer.SetDataScalarTypeToUnsignedChar()
data_importer.SetNumberOfScalarComponents(1)
data_importer.SetDataExtent(0, data.shape[0] - 1, 0, data.shape[1] - 1,
0, data.shape[2] - 1)
data_importer.SetWholeExtent(0, data.shape[0] - 1, 0,
data.shape[1] - 1, 0, data.shape[2] - 1)
binarys.append(data_importer)
return binarys, labels
def getMaskFromPoints(points, mx, my, mz, value=255):
"""
Create a mask where all given points are set to value (between 0-255)
"""
if value > 255:
value = 255
elif value < 0:
value = 0
size = mx * my
pointStructString = "%dB" % size
pointData = []
for y in range(0, my):
for x in range(0, mx):
pointData.append(value * points.get((x, y), 0))
packedPointString = struct.pack(pointStructString, *pointData)
importer = vtk.vtkImageImport()
importer.CopyImportVoidPointer(packedPointString, mx * my)
importer.SetDataScalarTypeToUnsignedChar()
importer.SetNumberOfScalarComponents(1)
importer.SetDataExtent(0, mx - 1, 0, my - 1, 0, 0)
importer.SetWholeExtent(0, mx - 1, 0, my - 1, 0, 0)
importer.Update()
append = vtk.vtkImageAppend()
append.SetAppendAxis(2)
for z in range(0, mz):
append.SetInput(z, importer.GetOutput())
append.Update()
image2 = append.GetOutput()
return image2
def init_all_VolumeRendering_component(self, flagMesh):
self.flagMesh = flagMesh
self.ren= vtk.vtkRenderer()
self.renWin.AddRenderer(self.ren)
self.iren = vtk.vtkXRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
self.ren.GetVolumes()
self.alpha_channel_function = vtk.vtkPiecewiseFunction()
self.alpha_channel_function.AddPoint(0, 0.0, 0.5, 0.0)
self.alpha_channel_function.AddPoint(255, 1, 0.5, 0.0)
self.color_function = vtk.vtkColorTransferFunction()
self.color_function.AddRGBPoint(0, 0, 0.0, 0.0, 0.5, 0.0)
self.color_function.AddRGBPoint(255, 1, 1, 1, 0.5, 0.0)
self.volume_property = vtk.vtkVolumeProperty()
self.volume_property.SetColor(self.color_function)
self.volume_property.SetScalarOpacity(self.alpha_channel_function)
self.data_importer = vtk.vtkImageImport()
if self.flagMesh :
self.volume_mapper = vtk.vtkPolyDataMapper()
else:
self.volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper()
self.volume = vtk.vtkVolume()
def numpy2VTK(img,spacing=[1.0,1.0,1.0]):
# evolved from code from Stou S.,
# on http://www.siafoo.net/snippet/314
importer = vtk.vtkImageImport()
img_data = img.astype('uint8')
img_string = img_data.tostring() # type short
dim = img.shape
importer.CopyImportVoidPointer(img_string, len(img_string))
importer.SetDataScalarType(VTK_UNSIGNED_CHAR)
importer.SetNumberOfScalarComponents(1)
extent = importer.GetDataExtent()
importer.SetDataExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetWholeExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetDataSpacing( spacing[0], spacing[1], spacing[2])
importer.SetDataOrigin( 0,0,0 )
return importer
def vtk_marching_cubes(field,iso=0.5):
import vtk
int_field = (np.minimum(field*255,255)).astype(np.uint8)
nx, ny, nz = int_field.shape
data_string = int_field.tostring('F')
reader = vtk.vtkImageImport()
reader.CopyImportVoidPointer(data_string, len(data_string))
reader.SetDataScalarTypeToUnsignedChar()
reader.SetNumberOfScalarComponents(1)
reader.SetDataExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
reader.SetWholeExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
reader.Update()
contour = vtk.vtkImageMarchingCubes()
if vtk.VTK_MAJOR_VERSION <= 5:
contour.SetInput(reader.GetOutput())
else:
contour.SetInputData(reader.GetOutput())
contour.ComputeNormalsOn()
contour.ComputeGradientsOn()
contour.SetValue(0,int(iso*255))
contour.Update()
field_polydata = contour.GetOutput()
polydata_points = np.array([field_polydata.GetPoints().GetPoint(p) for p in xrange(field_polydata.GetPoints().GetNumberOfPoints())])
polydata_triangles = np.array([[field_polydata.GetCell(t).GetPointIds().GetId(i) for i in xrange(3)] for t in xrange(field_polydata.GetNumberOfCells())])
return polydata_points, polydata_triangles
def __init__(self):
# Objects for volume rendering
self.volume = vtk.vtkVolume()
self.volumeMapper = vtk.vtkSmartVolumeMapper()
self.volumeProperty = vtk.vtkVolumeProperty()
# Objects for slice rendering
self.sliceActor = vtk.vtkImageActor()
self.sliceMapper = vtk.vtkImageResliceMapper()
self.sliceProperty = vtk.vtkImageProperty()
# Objects for importing and reslicing the data
self.importer = [vtk.vtkImageImport()]
self.slice = [vtk.vtkImageResliceToColors()]
# Objects that point to the output algorithms
# These must be specified at run time by the implementing class
self.output = None
self.sliceOutput = None
# Some properties of the data
self.numberOfDataSets = 0
self.numberOfTimeFrames = 0
self.currentTimeFrame = 0
self.dimensions = [0, 0, 0]
def write_data(data,x,y,z):
siz = x*y*z
fs="%dH"%siz
print "min(data)=",min(data),"max(data)=",max(data)
print "size=",siz,"len of data=",len(data)
ss = struct.pack(fs,*data)
print "min(ss)=",min(ss),"max(ss)=",max(ss),"len(ss)=",len(ss)
importer=vtk.vtkImageImport()
importer.CopyImportVoidPointer(ss,len(ss))
importer.SetDataScalarTypeToUnsignedShort()
#importer.SetDataScalarTypeToUnsignedChar()
#importer.SetDataScalarType(5)
importer.SetNumberOfScalarComponents(1)
importer.SetDataExtent(0,x-1,0,y-1,0,z-1)
importer.SetWholeExtent(0,x-1,0,y-1,0,z-1)
importer.Update()
image = importer.GetOutput()
#print image
print "Image scalar range=",image.GetScalarRange()
print "Image scalar type=",image.GetScalarTypeAsString()
#print image
writer = vtk.vtkXMLImageDataWriter()
writer.SetInput(image)
writer.SetFileName("output.vti")
print "Writing..."
writer.Write()
print "done"
def DrawVoxelArray(self, arrayBuffer):
#reshape
resolution = self.VolumeMgr.resolution
sample = arrayBuffer.reshape(1, 1, resolution, resolution, resolution)
dataMatrix = self.MakeDataMatrix( np.asarray(sample, dtype=np.uint8), 255)
data_string = dataMatrix.tostring()
dataImporter = vtk.vtkImageImport()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, int(dim * v_res)-1, 0, int(dim * v_res)-1, 0, int(dim * v_res)-1)
dataImporter.SetWholeExtent(0, int(dim * v_res)-1, 0, int(dim * v_res)-1, 0, int(dim * v_res)-1)
self.VolumeMgr.AddVolumeData(dataImporter.GetOutputPort())
#Display BoundignBox
boundingBox = vtk.vtkOutlineFilter()
boundingBox.SetInputData(dataImporter.GetOutput())
bbmapper = vtk.vtkPolyDataMapper()
bbmapper.SetInputConnection(boundingBox.GetOutputPort())
bbActor = vtk.vtkActor()
bbActor.SetMapper(bbmapper)
bbActor.GetProperty().SetColor(1, 0, 0)
self.renderer.AddActor(bbActor)
self.Redraw()
def axonComparison(axons, N):
axonsToRender = []
for i in range(N):
axon = axons.pop(random.randrange(len(axons)))
axonsToRender.append(axon)
bins = main.BINS
data_matrix = numpy.zeros([500, 500, 500], dtype=numpy.uint16)
dataImporter = vtk.vtkImageImport()
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, 500, 0, 500, 0, 500)
dataImporter.SetWholeExtent(0, 500, 0, 500, 0, 500)
volumeProperty = vtk.vtkVolumeProperty()
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderer.SetBackground(1, 1, 1)
renderWin.SetSize(400, 400)
for axon in axonsToRender:
renderer = Utils.renderSingleAxon(axon, renderer, [random.random(), random.random(), random.random()])
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
def numpy2VTK(img,spacing=[1.0,1.0,1.0]):
importer = vtk.vtkImageImport()
img_data = img.astype('uint8')
img_string = img_data.tostring() # type short
dim = img.shape
importer.CopyImportVoidPointer(img_string, len(img_string))
importer.SetDataScalarType(VTK_UNSIGNED_CHAR)
importer.SetNumberOfScalarComponents(1)
extent = importer.GetDataExtent()
importer.SetDataExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetWholeExtent(extent[0], extent[0] + dim[2] - 1,
extent[2], extent[2] + dim[1] - 1,
extent[4], extent[4] + dim[0] - 1)
importer.SetDataSpacing( spacing[2], spacing[1], spacing[0])
importer.SetDataOrigin( 0,0,0 )
# flip = vtk.vtkImageFlip()
# flip.SetFilteredAxis(2)
# flip.SetInput(importer.GetOutput())
return importer
def __init__(self, default = '', color = [1.0, 0.766, 0.336], singleview = True):
# Create the importer and load a volume (gets things warmed up)
self.dataImporter = vtk.vtkImageImport()
if len(default) == 0:
# a dataset's config.yaml will specify the name of the default volume and it'll be included
default = '/Users/cam/data/dSpaceX/latest/nanoparticles_volume/unprocessed_data/shape_representations/Images.0002.nrrd'
self.loadNewVolume(default)
# colors
colors = vtk.vtkNamedColors()
# volume properties
volumeProperty = vtk.vtkVolumeProperty()
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(228, 0.0)
alphaChannelFunc.AddPoint(255, 0.25)
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(0, color[0]/2.0, color[1]/2.0, color[2]/2.0)
colorFunc.AddRGBPoint(255, color[0], color[1], color[2])
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetDiffuse(2.0)
volumeProperty.SetSpecular(1.5)
volumeProperty.SetSpecularPower(15)
# volume
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(self.dataImporter.GetOutputPort())
self.volume = vtk.vtkVolume()
self.volume.SetMapper(volumeMapper)
self.volume.SetProperty(volumeProperty)
# renderer
self.ren = vtk.vtkRenderer()
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
self.renWin.OffScreenRenderingOn() # ***** don't open a window *****
# add volume, set background and size
self.ren.AddVolume(self.volume)
self.ren.SetBackground(colors.GetColor3d("Wheat"))
# camera
self.resetCamera()
self.renWin.SetWindowName('TwistyTurnyNanoparticle')
# screenshot filter
self.w2if = vtk.vtkWindowToImageFilter()
self.w2if.SetInput(self.renWin)
self.w2if.SetInputBufferTypeToRGB()
self.w2if.ReadFrontBufferOff()
def array_to_vtk_image(array, copy_data, data_type="scalar"):
""" Create an ``vtkImage`` matching the contents and type of given array. If
``copy_data`` is ``True``, then the data of the will be copied. Otherwise the
data will be shared, and the array **must not** be destroyed before the
``vtkImage``. ``data_type`` specifies how the array should be interpreted :
either as a n-array of scalars (``data_type="scalar"``) or as an n-1 array
of vectors (``data_type="vector"``).
"""
if data_type not in ["scalar", "vector"] :
raise medipy.base.Exception("Unknown data_type: {0}".format(repr(data_type)))
if data_type == "scalar" :
ndim = array.ndim
elif data_type == "vector" :
ndim = array.ndim-1
if ndim > 3 :
raise medipy.base.Exception(
"Cannot convert a {0} array of dimension {1}".format(data_type,
array.ndim))
importer = vtkImageImport()
if numpy.iscomplexobj(array) :
# Get the first element of the array
element = array.flat.next()
scalar_type = vtk.util.numpy_support.get_vtk_array_type(element.real.dtype)
else :
scalar_type = vtk.util.numpy_support.get_vtk_array_type(array.dtype)
importer.SetDataScalarType(scalar_type)
if data_type == "scalar" :
number_of_components = 1
elif data_type == "vector" :
number_of_components = array.shape[ndim]
if numpy.iscomplexobj(array) :
number_of_components *= 2
importer.SetNumberOfScalarComponents(number_of_components)
extent = 6*[0]
extent[1] = array.shape[ndim-1]-1
if ndim >= 2 :
extent[3] = array.shape[ndim-2]-1
if ndim >= 3 :
extent[5] = array.shape[ndim-3]-1
importer.SetDataExtent(extent)
importer.SetWholeExtent(extent)
size = array.itemsize*reduce(operator.mul, array.shape, 1)
if copy_data :
importer.CopyImportVoidPointer(array, size)
else :
importer.SetImportVoidPointer(array, size)
importer.Update()
return importer.GetOutput()
def create_volume(self, time_step):
# Get data
npdatauchar = list()
vtk_volume_prop = vtk.vtkVolumeProperty()
vtk_volume_prop.IndependentComponentsOn()
vtk_volume_prop.SetInterpolationTypeToLinear()
for i, volume in enumerate(self.volume_list):
npdatauchar.append(volume.get_data(time_step, 200, 300, 0.5))
vtk_volume_prop.SetColor(i, volume.vtk_color)
vtk_volume_prop.SetScalarOpacity(i, volume.vtk_opacity)
vtk_volume_prop.ShadeOff(i)
npdatamulti = np.concatenate(
[aux[..., np.newaxis] for aux in npdatauchar], axis=3)
axes = self.volume_list[0].get_axes(time_step)
axes_spacing = self.volume_list[0].get_axes_spacing(
time_step, 200, 300, 0.5)
# Normalize spacing. Too small values lead to ghost volumes.
max_sp = max(axes_spacing["x"], axes_spacing["y"], axes_spacing["z"])
# Too big cells turn opaque, too small become transparent.
# max_cell_size normalizes the cell size
max_cell_size = 0.1
norm_factor = max_cell_size / max_sp
axes_spacing["x"] = axes_spacing["x"] * norm_factor
axes_spacing["y"] = axes_spacing["y"] * norm_factor
axes_spacing["z"] = axes_spacing["z"] * norm_factor
# Put data in VTK format
vtk_data_import = vtk.vtkImageImport()
vtk_data_import.SetImportVoidPointer(npdatamulti)
vtk_data_import.SetDataScalarTypeToUnsignedChar()
vtk_data_import.SetNumberOfScalarComponents(len(self.volume_list))
vtk_data_import.SetDataExtent(0, npdatamulti.shape[2] - 1, 0,
npdatamulti.shape[1] - 1, 0,
npdatamulti.shape[0] - 1)
vtk_data_import.SetWholeExtent(0, npdatamulti.shape[2] - 1, 0,
npdatamulti.shape[1] - 1, 0,
npdatamulti.shape[0] - 1)
vtk_data_import.SetDataSpacing(axes_spacing["x"], axes_spacing["y"],
axes_spacing["z"])
# data origin is also changed by the normalization
vtk_data_import.SetDataOrigin(axes["x"][0] * norm_factor,
axes["y"][0] * norm_factor,
axes["z"][0] * norm_factor)
vtk_data_import.Update()
# Create the mapper
vtk_volume_mapper = vtk.vtkGPUVolumeRayCastMapper()
vtk_volume_mapper.SetInputConnection(vtk_data_import.GetOutputPort())
vtk_volume_mapper.Update()
# Add to volume
self.vtk_volume.SetMapper(vtk_volume_mapper)
self.vtk_volume.SetProperty(vtk_volume_prop)
# Set visualization parameters
self.set_render_quality(self.render_quality)
self.set_color_level(self.volume_color_level)
self.set_color_window(self.volume_color_window)
# Add to render
self.renderer.AddVolume(self.vtk_volume)
self.renderer.ResetCamera()
self.interactor.Render()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkImageImport(),
'Processing.', (),
('vtkImageData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def loadDicom(self, path):
if path is None:
return
start_time = time.time()
self.image_path = path
self.image_dir = osp.dirname(osp.abspath(path))
self.image_suffix = osp.splitext(path)[1]
if str.lower(self.image_suffix) in ['.mp4', '.avi', '.flv', '.wmv']:
img_nda = skio.vread(path)
img_nda = img_nda.astype('float32')
self.image_type = 'video'
self._channel = img_nda.shape[3]
self._spacing = (1, 1, 1)
self._dims = (img_nda.shape[1], img_nda.shape[0], img_nda.shape[2])
print(img_nda.shape)
output = self.numpy_array_as_vtk_image_data(img_nda)
else:
img_itk = sitk.ReadImage(path)
spacing = img_itk.GetSpacing()
dims = img_itk.GetSize()
channel = img_itk.GetNumberOfComponentsPerPixel()
frame_count = 1 if len(dims) == 2 else dims[2]
spacing_z = 1 if len(dims) == 2 else spacing[2]
self._dims = (dims[0], dims[1], frame_count)
self._spacing = (spacing[0], spacing[1], spacing_z)
self._channel = channel
self.image_type = 'image' if frame_count == 1 else 'volume'
img_nda = sitk.GetArrayFromImage(img_itk)
img_nda = img_nda.astype('float32')
importer = vtk.vtkImageImport()
importer.SetDataScalarTypeToFloat()
importer.SetNumberOfScalarComponents(self._channel)
importer.SetDataExtent(0, self._dims[0] - 1, 0, self._dims[1] - 1,
0, self._dims[2] - 1)
importer.SetWholeExtent(0, self._dims[0] - 1, 0, self._dims[1] - 1,
0, self._dims[2] - 1)
importer.SetDataSpacing(self._spacing[0], self._spacing[1],
self._spacing[2])
importer.CopyImportVoidPointer(img_nda, img_nda.nbytes)
importer.Update()
output = importer.GetOutput()
# print(output)
self.image_data.DeepCopy(output)
print("---laod dicom: %s seconds ---" % (time.time() - start_time))
print("image dims ", self._dims)
print("image spacing ", self._spacing)
print("image channel ", self._channel)
# print('load image info:')
# print(output)
return self.image_data
def sitk2vtk(img, outVol=None, debugOn=False):
"""
converts a sitk image, img and returns it to vtkImageData
"""
"""Convert a SimpleITK image to a VTK image, via numpy."""
size = list(img.GetSize())
origin = list(img.GetOrigin())
spacing = list(img.GetSpacing())
sitktype = img.GetPixelID()
vtktype = pixelmap[sitktype]
ncomp = img.GetNumberOfComponentsPerPixel()
# convert the SimpleITK image to a numpy array
i2 = sitk.GetArrayFromImage(img)
i2_string = i2.tostring()
if debugOn:
print("data string address inside sitk2vtk", hex(id(i2_string)))
# send the numpy array to VTK with a vtkImageImport object
dataImporter = vtk.vtkImageImport()
dataImporter.CopyImportVoidPointer(i2_string, len(i2_string))
dataImporter.SetDataScalarType(vtktype)
dataImporter.SetNumberOfScalarComponents(ncomp)
# VTK expects 3-dimensional parameters
if len(size) == 2:
size.append(1)
if len(origin) == 2:
origin.append(0.0)
if len(spacing) == 2:
spacing.append(spacing[0])
# Set the new VTK image's parameters
dataImporter.SetDataExtent(0, size[0] - 1, 0, size[1] - 1, 0, size[2] - 1)
dataImporter.SetWholeExtent(0, size[0] - 1, 0, size[1] - 1, 0, size[2] - 1)
dataImporter.SetDataOrigin(origin)
dataImporter.SetDataSpacing(spacing)
dataImporter.Update()
vtk_image = dataImporter.GetOutput()
outVol = vtk.vtkImageData()
outVol.DeepCopy(vtk_image)
if debugOn:
print("Volume object inside sitk2vtk")
print(vtk_image)
print("type = ", vtktype)
print("num components = ", ncomp)
print(size)
print(origin)
print(spacing)
print(vtk_image.GetScalarComponentAsFloat(0, 0, 0, 0))
return outVol, size, origin, spacing
def viz_SetData(self, data):
self.__dataImporter = vtk.vtkImageImport()
data_string = data.tostring()
x, y, z = data.shape
self.__dataImporter.CopyImportVoidPointer(data_string,
len(data_string))
self.__dataImporter.SetDataScalarTypeToUnsignedChar()
self.__dataImporter.SetNumberOfScalarComponents(1)
self.__dataImporter.SetDataExtent(0, z - 1, 0, y - 1, 0, x - 1)
self.__dataImporter.SetWholeExtent(0, z - 1, 0, y - 1, 0, x - 1)
def MarchingCubes(img_data, isolevel):
importer = vtk.vtkImageImport()
img_string = img_data.tostring(order='F')
dim = img_data.shape
importer.CopyImportVoidPointer(img_string, len(img_string))
importer.SetDataScalarType(VTK_UNSIGNED_CHAR)
importer.SetNumberOfScalarComponents(1)
extent = importer.GetDataExtent()
importer.SetDataExtent(extent[0], extent[0] + dim[0] - 1, extent[2],
extent[2] + dim[1] - 1, extent[4],
extent[4] + dim[2] - 1)
importer.SetWholeExtent(extent[0], extent[0] + dim[0] - 1, extent[2],
extent[2] + dim[1] - 1, extent[4],
extent[4] + dim[2] - 1)
#importer.SetDataSpacing( dset.pixel_spacing[0], dset.pixel_spacing[1], dset.pixel_spacing[2])
outlineData = vtk.vtkOutlineFilter()
outlineData.SetInputConnection(importer.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(mapOutline)
skinExtractor = vtk.vtkContourFilter()
skinExtractor.SetInputConnection(importer.GetOutputPort())
skinExtractor.SetValue(0, isolevel)
skinExtractor.Update()
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(skinExtractor.GetOutputPort())
tri.Update()
# deci=vtk.vtkQuadricDecimation()
# deci.SetInputConnection(tri.GetOutputPort())
# deci.SetTargetReduction(0.95)
# # deci-$obj PreserveTopologyOn
# deci.Update()
skinNormals = vtk.vtkPolyDataNormals()
# skinNormals SetInputConnection [skinExtractor GetOutputPort]
skinNormals.SetInputConnection(tri.GetOutputPort())
skinNormals.SetFeatureAngle(60.0)
skinMapper = vtk.vtkPolyDataMapper()
skinMapper.SetInputConnection(skinNormals.GetOutputPort())
# skinMapper SetInputConnection [deci GetOutputPort]
#skinMapper.ScalarVisibilityOff()
skin = vtk.vtkActor()
skin.SetMapper(skinMapper)
return outline, skin
def vtk_iso(vol, iso_thresh=1):
im_data = vol.tostring()
img = vtk.vtkImageImport()
img.CopyImportVoidPointer(im_data, len(im_data))
img.SetDataScalarType(vtk.VTK_UNSIGNED_SHORT)
img.SetNumberOfScalarComponents(1)
img.SetDataExtent(0, vol.shape[2]-1, 0, vol.shape[1]-1, 0, vol.shape[0]-1)
img.SetWholeExtent(0, vol.shape[2]-1, 0, vol.shape[1]-1, 0, vol.shape[0]-1)
iso = vtk.vtkMarchingCubes()
iso.SetInput(img.GetOutput())
iso.SetValue(0, iso_thresh)
return iso,img
def convertNpyToVtk(imgNpy):
assert(imgNpy.dtype == np.uint8)
nx, ny, nz = imgNpy.shape
dataImporter = vtk.vtkImageImport()
dataString = imgNpy.tostring(order='F')
dataImporter.CopyImportVoidPointer(dataString, len(dataString))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, nx-1, 0, ny-1, 0, nz-1)
dataImporter.SetWholeExtent(0, nx-1, 0, ny-1, 0, nz-1)
dataImporter.Update()
return dataImporter.GetOutput()
def __init__(self, img, threshold, xysmoothing, zsmoothing, color, alpha):
dataImporter = vtk.vtkImageImport()
simg = np.ascontiguousarray(img, np.uint8)
dataImporter.CopyImportVoidPointer(simg.data, len(simg.data))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
dataImporter.SetWholeExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
self.__smoother = vtk.vtkImageGaussianSmooth()
self.__smoother.SetStandardDeviation(xysmoothing, xysmoothing, zsmoothing)
self.__smoother.SetInputConnection(dataImporter.GetOutputPort())
self.__threshold = vtk.vtkImageThreshold()
self.__threshold.SetInputConnection(self.__smoother.GetOutputPort())
self.__threshold.ThresholdByUpper(threshold)
self.__threshold.ReplaceInOn()
self.__threshold.SetInValue(1)
self.__threshold.ReplaceOutOn()
self.__threshold.SetOutValue(0)
self.__threshold.Update()
contour = vtk.vtkDiscreteMarchingCubes()
contour.SetInputConnection(self.__threshold.GetOutputPort())
contour.ComputeNormalsOn()
contour.SetValue(0, 1)
contour.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(contour.GetOutputPort())
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
triangleCellNormals=vtk.vtkPolyDataNormals()
triangleCellNormals.SetInputConnection(smoother.GetOutputPort())
triangleCellNormals.ComputeCellNormalsOn()
triangleCellNormals.ComputePointNormalsOff()
triangleCellNormals.ConsistencyOn()
triangleCellNormals.AutoOrientNormalsOn()
triangleCellNormals.Update()
triangleCellAn = vtk.vtkMeshQuality()
triangleCellAn.SetInputConnection(triangleCellNormals.GetOutputPort())
triangleCellAn.SetTriangleQualityMeasureToArea()
triangleCellAn.SaveCellQualityOn()
triangleCellAn.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(triangleCellAn.GetOutputPort())
mapper.ScalarVisibilityOn()
mapper.SetScalarRange(.3, 1)
mapper.SetScalarModeToUsePointData()
colorLookupTable = vtk.vtkLookupTable()
colorLookupTable.SetHueRange(.6, 1)
colorLookupTable.Build()
mapper.SetLookupTable(colorLookupTable)
self.SetMapper(mapper)
self.GetProperty().SetColor(*color)
self.GetProperty().SetOpacity(alpha)
def _createLogic(self):
# input
self._imageStack = None
# optional input
self._inputTransformStack = None
# output is a transform stack
self._transformStack = transformStackClass(self)
self._ipw1 = None
self._ipw2 = None
# some control variables
self._pairNumber = -1
# we need to have two converters from itk::Image to vtkImageData,
# hmmmm kay?
self._transform1 = itk.itkEuler2DTransform_New()
self._transform1.SetIdentity()
print self._transform1.GetParameters()
self._rescaler1 = itk.itkRescaleIntensityImageFilterF2F2_New()
self._rescaler1.SetOutputMinimum(0)
self._rescaler1.SetOutputMaximum(255)
self._itkExporter1 = itk.itkVTKImageExportF2_New()
self._itkExporter1.SetInput(self._rescaler1.GetOutput())
self._vtkImporter1 = vtk.vtkImageImport()
CVIPy.ConnectITKF2ToVTK(self._itkExporter1.GetPointer(),
self._vtkImporter1)
self._resampler2 = None
self._rescaler2 = itk.itkRescaleIntensityImageFilterF2F2_New()
self._rescaler2.SetOutputMinimum(0)
self._rescaler2.SetOutputMaximum(255)
self._itkExporter2 = itk.itkVTKImageExportF2_New()
self._itkExporter2.SetInput(self._rescaler2.GetOutput())
self._vtkImporter2 = vtk.vtkImageImport()
CVIPy.ConnectITKF2ToVTK(self._itkExporter2.GetPointer(),
self._vtkImporter2)
def save_vtk_image(images, dst, i):
image_import = vtk.vtkImageImport()
image_import.CopyImportVoidPointer(images.tostring(),
len(images.tostring()))
image_import.SetDataScalarTypeToUnsignedChar()
image_import.SetNumberOfScalarComponents(1)
image_import.SetDataExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1,
0, images.shape[0] - 1)
image_import.SetWholeExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1,
0, images.shape[0] - 1)
volume = vtk.vtkVolume()
volume_mapper = vtk.vtkVolumeRayCastMapper()
alpha_channel_func = vtk.vtkPiecewiseFunction()
alpha_channel_func.AddPoint(0, 0.0)
# alpha_channel_func.AddPoint(64, 0.3)
# alpha_channel_func.AddPoint(128, 0.5)
alpha_channel_func.AddPoint(100, 1.0)
alpha_channel_func.ClampingOn()
color_func = vtk.vtkPiecewiseFunction()
color_func.AddPoint(5, 0.3)
color_func.AddPoint(25, 0.5)
color_func.AddPoint(125, 0.7)
color_func.AddPoint(255, 1.0)
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(color_func)
volume_property.SetInterpolationTypeToLinear()
volume_property.SetScalarOpacity(alpha_channel_func)
volume.SetProperty(volume_property)
volume_ray_cast_func = vtk.vtkVolumeRayCastMIPFunction()
volume_mapper.SetInputConnection(image_import.GetOutputPort())
volume_mapper.SetVolumeRayCastFunction(volume_ray_cast_func)
# volume_mapper.SetSampleDistance(1)
# volume_mapper.SetAutoAdjustSampleDistances(0)
# volume_mapper.SetImageSampleDistance(1)
volume.SetMapper(volume_mapper)
ren = vtk.vtkRenderer()
ren.AddVolume(volume)
ren.SetBackground(0, 0, 0)
renWin = vtk.vtkRenderWindow()
renWin.SetSize(1024, 1024)
renWin.AddRenderer(ren)
renWin.Render()
window_2_image = vtk.vtkWindowToImageFilter()
window_2_image.SetInput(renWin)
window_2_image.Update()
png_writer = vtk.vtkPNGWriter()
png_writer.SetFileName(dst + '%05d' % (i) + '.png')
png_writer.SetInput(window_2_image.GetOutput())
png_writer.Write()
def read_data(filepattern, data_spacing, data_extent):
dims = data_extent[1] + 1, data_extent[3] + 1
dtype = np.dtype('B')
file_range = xrange(1, data_extent[5] + 1)
dat = np.array([np.reshape(np.fromfile(filepattern % i, dtype=dtype), dims)
for i in file_range]).tostring()
data_reader = vtk.vtkImageImport()
data_reader.CopyImportVoidPointer(dat, len(dat))
data_reader.SetDataScalarTypeToUnsignedChar()
data_reader.SetNumberOfScalarComponents(1)
data_reader.SetDataSpacing(*data_spacing)
data_reader.SetDataExtent(*data_extent)
data_reader.SetWholeExtent(*data_extent)
return data_reader
def save_vtk_image(images, dst, i):
image_import = vtk.vtkImageImport()
image_import.CopyImportVoidPointer(images.tostring(), len(images.tostring()))
image_import.SetDataScalarTypeToUnsignedChar()
image_import.SetNumberOfScalarComponents(1)
image_import.SetDataExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1, 0, images.shape[0] - 1)
image_import.SetWholeExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1, 0, images.shape[0] - 1)
volume = vtk.vtkVolume()
volume_mapper = vtk.vtkVolumeRayCastMapper()
alpha_channel_func = vtk.vtkPiecewiseFunction()
alpha_channel_func.AddPoint(0, 0.0)
# alpha_channel_func.AddPoint(64, 0.3)
# alpha_channel_func.AddPoint(128, 0.5)
alpha_channel_func.AddPoint(100, 1.0)
alpha_channel_func.ClampingOn()
color_func = vtk.vtkPiecewiseFunction()
color_func.AddPoint(5, 0.3)
color_func.AddPoint(25, 0.5)
color_func.AddPoint(125, 0.7)
color_func.AddPoint(255, 1.0)
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(color_func)
volume_property.SetInterpolationTypeToLinear()
volume_property.SetScalarOpacity(alpha_channel_func)
volume.SetProperty(volume_property)
volume_ray_cast_func = vtk.vtkVolumeRayCastMIPFunction()
volume_mapper.SetInputConnection(image_import.GetOutputPort())
volume_mapper.SetVolumeRayCastFunction(volume_ray_cast_func)
# volume_mapper.SetSampleDistance(1)
# volume_mapper.SetAutoAdjustSampleDistances(0)
# volume_mapper.SetImageSampleDistance(1)
volume.SetMapper(volume_mapper)
ren = vtk.vtkRenderer()
ren.AddVolume(volume)
ren.SetBackground(0, 0, 0)
renWin = vtk.vtkRenderWindow()
renWin.SetSize(1024, 1024)
renWin.AddRenderer(ren)
renWin.Render()
window_2_image = vtk.vtkWindowToImageFilter()
window_2_image.SetInput(renWin)
window_2_image.Update()
png_writer = vtk.vtkPNGWriter()
png_writer.SetFileName(dst + '%05d'%(i) + '.png')
png_writer.SetInput(window_2_image.GetOutput())
png_writer.Write()
def to_vtk_image(image):
image = np.flipud(image.copy()).astype('uint8')
imageString = image.tostring()
imageImporter = vtk.vtkImageImport()
imageImporter.CopyImportVoidPointer(imageString, len(imageString))
imageImporter.SetDataScalarTypeToUnsignedChar()
imageImporter.SetNumberOfScalarComponents(3)
imageImporter.SetDataExtent(0, image.shape[1]-1,
0, image.shape[0]-1,
0, 0)
imageImporter.SetWholeExtent(0, image.shape[1]-1,
0, image.shape[0]-1,
0, 0)
imageImporter.Update()
return imageImporter
def sitk2vtk(img):
size = list(img.GetSize())
origin = list(img.GetOrigin())
spacing = list(img.GetSpacing())
sitktype = img.GetPixelID()
vtktype = pixelmap[sitktype]
ncomp = img.GetNumberOfComponentsPerPixel()
# there doesn't seem to be a way to specify the image orientation in VTK
# convert the SimpleITK image to a numpy array
i2 = sitk.GetArrayFromImage(img)
i2_string = i2.tostring()
# send the numpy array to VTK with a vtkImageImport object
dataImporter = vtk.vtkImageImport()
dataImporter.CopyImportVoidPointer( i2_string, len(i2_string) )
dataImporter.SetDataScalarType(vtktype)
dataImporter.SetNumberOfScalarComponents(ncomp)
# VTK expects 3-dimensional parameters
if len(size) == 2:
size.append(1)
if len(origin) == 2:
origin.append(0.0)
if len(spacing) == 2:
spacing.append(spacing[0])
# Set the new VTK image's parameters
#
dataImporter.SetDataExtent (0, size[0]-1, 0, size[1]-1, 0, size[2]-1)
dataImporter.SetWholeExtent(0, size[0]-1, 0, size[1]-1, 0, size[2]-1)
dataImporter.SetDataOrigin(origin)
dataImporter.SetDataSpacing(spacing)
dataImporter.Update()
vtk_image = dataImporter.GetOutput()
return vtk_image
def toVtkImageData(a):
importer = vtkImageImport()
#FIXME
#In all cases I have seen, it is needed to reverse the shape here
#Does that hold universally, and do we understand why?
reverseShape = True
importer.SetDataScalarType(__numpyTypeToVtkType(a.dtype))
if reverseShape:
importer.SetDataExtent(0,a.shape[2]-1,0,a.shape[1]-1,0,a.shape[0]-1)
importer.SetWholeExtent(0,a.shape[2]-1,0,a.shape[1]-1,0,a.shape[0]-1)
else:
importer.SetDataExtent(0,a.shape[0]-1,0,a.shape[1]-1,0,a.shape[2]-1)
importer.SetWholeExtent(0,a.shape[0]-1,0,a.shape[1]-1,0,a.shape[2]-1)
importer.SetImportVoidPointer(a)
importer.Update()
return importer.GetOutput()
def get_vtk_image(self):
importer = vtk.vtkImageImport()
importer.SetDataSpacing(1,1,1)
importer.SetDataOrigin(0,0,0)
importer.SetWholeExtent(0, self.im.shape[1] - 1,
0, self.im.shape[0] - 1, 0, 0)
importer.SetDataExtentToWholeExtent()
importer.SetDataScalarTypeToUnsignedChar()
importer.SetNumberOfScalarComponents(self.im.shape[2])
importer.SetImportVoidPointer(self.im)
importer.Update()
flipY = vtk.vtkImageFlip()
flipY.SetFilteredAxis(1)
flipY.SetInputConnection(importer.GetOutputPort())
flipY.Update()
yActor = vtk.vtkImageActor()
yActor.SetInput(flipY.GetOutput())
return yActor
def __init__(self):
super(Mwindow, self).__init__()
self.importer = vtk.vtkImageImport()
self.main_widget = QVTKRenderWindowInteractor(parent=self)
self.setCentralWidget(self.main_widget)
self.ren = vtk.vtkRenderer()
self.image_actor = vtk.vtkImageActor()
self.image_actor.SetInputData(self.importer.GetOutput())
self.iren = vtk.vtkRenderWindowInteractor()
self.main_widget.GetRenderWindow().AddRenderer(self.ren)
self.ren.AddActor(self.image_actor)
self.im1 = cv2.imread('1.tif', cv2.CV_LOAD_IMAGE_UNCHANGED)
self.im1_str = self.im1.tostring()
self.importer.SetNumberOfScalarComponents(1)
self.importer.SetDataScalarTypeToUnsignedChar()
self.importer.SetWholeExtent(0, 799, 0, 799, 0, 0)
self.importer.SetDataExtent(0, 799, 0, 799, 0, 0)
self.image_actor.SetDisplayExtent(0, 799, 0, 799, 0, 0)
self.importer.SetImportVoidPointer(self.im1_str, len(self.im1_str))
def iniVTK(self):
self.last_added_sphere_ren1 = None
self.newed_spheres = vtk.vtkCollection()
self.sphere_radius_ren1 = 2.0
self.bouttons_spheres = []
self.slice_assembly = None
self.image_roi = None
self.im_importer = vtk.vtkImageImport()
self.sphere = vtk.vtkSphereSource()
self.sphere.SetRadius(2.0)
self.sphere_mapper = vtk.vtkPolyDataMapper()
self.sphere_mapper.SetInputConnection(self.sphere.GetOutputPort())
self.sphere_actor_ren2 = vtk.vtkActor()
self.sphere.SetCenter(show_height / 2, show_width / 2, 0)
self.sphere_actor_ren2.SetMapper(self.sphere_mapper)
self.sphere_actor_ren2.GetProperty().SetColor(255.0, 0, 0)
self.vtk_widget.GetRenderWindow().SetSize(800, 400)
self.image_actor = vtk.vtkImageActor()
self.ren1 = vtk.vtkRenderer()
self.ren2 = vtk.vtkRenderer()
self.interactorStyle = BouttonInteractorStyle()
self.vtk_widget.SetInteractorStyle(self.interactorStyle)
self.vtk_widget.GetRenderWindow().AddRenderer(self.ren1)
self.vtk_widget.GetRenderWindow().AddRenderer(self.ren2)
self.ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
self.ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
self.ren2.AddActor(self.sphere_actor_ren2)
self.imageLevelFilter = vtk.vtkImageMapToWindowLevelColors()
self.imageLevelFilter.SetLevel(400)
self.imageLevelFilter.SetWindow(800)
self.im_importer.SetNumberOfScalarComponents(1)
self.im_importer.SetDataScalarTypeToUnsignedShort()
self.im_importer.SetDataExtent(0, show_width - 1, 0, show_height - 1, 0, 0)
self.im_importer.SetWholeExtent(0, show_width - 1, 0, show_height - 1, 0, 0)
self.imageLevelFilter.SetInputConnection(self.im_importer.GetOutputPort())
self.image_actor.SetInput(self.imageLevelFilter.GetOutput())
self.ren1_sphere_actors = vtk.vtkActorCollection()
self.pointPicker = vtk.vtkPointPicker()
self.actorPicker = vtk.vtkPropPicker()
self.pickedActor = None
self.ren1.AddActor(self.image_actor)
self.ren2.AddActor(self.image_actor)
def makeVolumeRenderingPipeline(in_volume):
dataImporter = vtk.vtkImageImport()
if in_volume.dtype == numpy.uint8:
dataImporter.SetDataScalarTypeToUnsignedChar()
elif in_volume.dtype == numpy.uint16:
dataImporter.SetDataScalarTypeToUnsignedShort()
elif in_volume.dtype == numpy.int32:
dataImporter.SetDataScalarTypeToInt()
elif in_volume.dtype == numpy.int16:
dataImporter.SetDataScalarTypeToShort()
else:
raise RuntimeError("unknown data type %r of volume" % (in_volume.dtype,))
dataImporter.SetImportVoidPointer(in_volume, len(in_volume))
dataImporter.SetNumberOfScalarComponents(1)
extent = [0, in_volume.shape[2]-1, 0, in_volume.shape[1]-1, 0, in_volume.shape[0]-1]
dataImporter.SetDataExtent(*extent)
dataImporter.SetWholeExtent(*extent)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
for i in range(1, NOBJECTS):
alphaChannelFunc.AddPoint(i, 1.0)
colorFunc = vtk.vtkColorTransferFunction()
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
return dataImporter, colorFunc, volume, volumeMapper
def WriteVTKTemplateImage( TemplateFilename ):
import vtk
import vtk.util.numpy_support as vtkNumPy
import numpy
# set Image Template Dimensions
femBounds = (0.0,0.04,-0.04, 0.04, -0.03,0.06)
origin = (femBounds[0], femBounds[2], femBounds[4])
spacing = ( (femBounds[1]-femBounds[0])/ imageDimensions[0] ,
(femBounds[3]-femBounds[2])/ imageDimensions[1] ,
(femBounds[5]-femBounds[4])/ imageDimensions[2]
)
print femBounds, origin, spacing
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# array is converted to a string of chars and imported.
# numpy array stored as ROW MAJOR
# MUST write out in COLUMN MAJOR format to be the same as VTK
data_string = numpy.zeros(imageDimensions,dtype=numpy.float,order='F').tostring(order='F')
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToDouble()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent( 0, imageDimensions[0]-1, 0, imageDimensions[1]-1, 0, imageDimensions[2]-1)
dataImporter.SetWholeExtent(0, imageDimensions[0]-1, 0, imageDimensions[1]-1, 0, imageDimensions[2]-1)
dataImporter.SetDataSpacing( spacing )
dataImporter.SetDataOrigin( origin )
dataImporter.SetScalarArrayName( "scalars" )
dataImporter.Update()
vtkTemplateWriter = vtk.vtkDataSetWriter()
vtkTemplateWriter.SetFileName( TemplateFilename )
vtkTemplateWriter.SetInput( dataImporter.GetOutput() )
vtkTemplateWriter.Update()
return
def ConvertNumpyVTKImage(self,NumpyImageData): # Create initial image MapDim = self.MapDimensions # imports raw data and stores it. dataImporter = vtk.vtkImageImport() # array is converted to a string of chars and imported. data_string = NumpyImageData.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) # The type of the newly imported data is set to unsigned char (uint8) dataImporter.SetDataScalarTypeToFloat() # Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer # must be told this is the case. dataImporter.SetNumberOfScalarComponents(MapDim[3]) # The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this # simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case. # I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although # VTK complains if not both are used. dataImporter.SetDataExtent( 0, MapDim[0]-1, 0, MapDim[1]-1, 0, MapDim[2]-1) dataImporter.SetWholeExtent(0, MapDim[0]-1, 0, MapDim[1]-1, 0, MapDim[2]-1) dataImporter.SetDataSpacing( self.spacing ) dataImporter.SetDataOrigin( self.origin ) dataImporter.Update() return dataImporter.GetOutput()
def __init__(self, cmData, reslice=None):
self.cmData = cmData
self._min = 0
self._max = 255
self.dataImport = vtk.vtkImageImport()
self.dataImport.SetDataScalarTypeToUnsignedChar()
self.dataImport.SetNumberOfScalarComponents(1)
self.alphaFunc = vtk.vtkPiecewiseFunction()
self.colorFunc = vtk.vtkColorTransferFunction()
self.setupColorFunc()
self.prop = vtk.vtkVolumeProperty()
self.prop.SetColor(self.colorFunc)
self.prop.SetScalarOpacity(self.alphaFunc)
self.mapper = vtk.vtkSmartVolumeMapper()
self.mapper.SetBlendModeToMaximumIntensity()
if reslice is not None:
reslice.SetInputConnection(self.dataImport.GetOutputPort())
self.mapper.SetInputConnection(reslice.GetOutputPort())
else:
self.mapper.SetInputConnection(self.dataImport.GetOutputPort())
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.mapper)
self.volume.SetProperty(self.prop)
def numpy_to_vtk(matrix, data_spacing=None, data_extent=None):
"""Transform a Numpy matrix to a VTK data source.
Arguments:
- matrix: The Numpy data
- data_spacing: (x_spacing, y_spacing, z_spacing) or None
- data_extent: (xmin, xmax, ymin, ymax, zmin, zmax) or None
"""
if data_spacing is None:
data_spacing = (1, 1, 1)
if data_extent is None:
data_extent = (0, matrix.shape[0],
0, matrix.shape[1],
0, matrix.shape[2])
data = matrix.tostring()
data_reader = vtk.vtkImageImport()
data_reader.CopyImportVoidPointer(data, len(data))
data_reader.SetDataScalarTypeToUnsignedChar()
data_reader.SetNumberOfScalarComponents(1)
data_reader.SetDataSpacing(*data_spacing)
data_reader.SetDataExtent(*data_extent)
data_reader.SetWholeExtent(*data_extent)
return data_reader
def initView(self, data, widget):
self.space = data.getResolution().tolist()
# Resolution: x(col), y(row), z(slice)
if len(self.space) == 3:
self.space = [float(x) / self.space[-1] for x in self.space]
image_matrix = data.getData()
image_matrix = npy.round((image_matrix - npy.min(image_matrix)) / (npy.max(image_matrix) - npy.min(image_matrix)) * 255)
image_matrix = image_matrix.astype(npy.uint8)
self.dataImporter = vtk.vtkImageImport()
data_string = image_matrix.tostring()
self.dataImporter.CopyImportVoidPointer(data_string, len(data_string))
self.dataImporter.SetDataScalarTypeToUnsignedChar()
self.dataImporter.SetNumberOfScalarComponents(1)
extent = image_matrix.shape
self.dataImporter.SetDataExtent(0, extent[2] - 1, 0, extent[1] - 1, 0, extent[0] - 1)
self.dataImporter.SetWholeExtent(0, extent[2] - 1, 0, extent[1] - 1, 0, extent[0] - 1)
self.dataImporter.SetDataSpacing(self.space)
self.image_resample = vtk.vtkImageResample()
self.image_resample.SetInput(self.dataImporter.GetOutput())
self.renderer = vtk.vtkRenderer()
self.render_window = widget.GetRenderWindow()
self.render_window.AddRenderer(self.renderer)
