def _write_output(self, data, target_file_path):
#Check for existing target file, and ask for overwrite confirmation if required
if (not self._config.overwrite) and os.path.exists(target_file_path):
dlg = wx.MessageDialog(
self._view_frame,
"%s already exists! \nOverwrite?" % target_file_path,
"File already exists", wx.YES_NO | wx.NO_DEFAULT)
if dlg.ShowModal() == wx.ID_NO:
print 'Skipped writing %s' % target_file_path
if self._config.delete_after_conversion:
print 'Source %s not deleted, since no output was written' % source_file_path
return #skip this file if overwrite is denied
writer = None
if self._config.target_file_type == 0: # VTI
writer = vtk.vtkXMLImageDataWriter()
elif self._config.target_file_type == 1: # MHA
writer = vtk.vtkMetaImageWriter()
writer.SetCompression(True)
writer.SetFileDimensionality(3)
elif self._config.target_file_type == 2: # MHD
writer = vtk.vtkMetaImageWriter()
writer.SetCompression(False)
writer.SetFileDimensionality(3)
elif self._config.target_file_type == 3: # GIPL. We assume floating point values.
if self._config.target_numerical_type == 1: #float
writer = itk.ImageFileWriter.IF3.New()
elif self._config.target_numerical_type == 2: #short
writer = itk.ImageFileWriter.ISS3.New()
elif self._config.target_numerical_type == 3 or self._config.target_numerical_type == 4: #unsigned char
writer = itk.ImageFileWriter.IUC3.New()
else:
raise Exception(
'Writing ITK %s is not currently supported.' %
data_types_by_number[self._config.source_file_type])
else:
raise Exception('Undefined file type with numerical index %d' %
self._config.target_file_type)
final_data = data
if self._config.target_numerical_type == 4:
th = vtk.vtkImageThreshold()
th.ThresholdByLower(0.0)
th.SetInValue(0.0)
th.SetOutValue(1.0)
th.SetOutputScalarTypeToUnsignedChar()
th.SetInput(data)
th.Update()
final_data = th.GetOutput()
#Write the output
writer.SetInput(final_data)
writer.SetFileName(target_file_path)
print "Writing %s ..." % target_file_path
writer.Write()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkMetaImageWriter(), 'Writing vtkMetaImage.',
('vtkMetaImage',), (),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager):
# call parent constructor
ModuleBase.__init__(self, module_manager)
self._writer = vtk.vtkMetaImageWriter()
module_utils.setup_vtk_object_progress(
self, self._writer,
'Writing VTK ImageData')
# set up some defaults
self._config.filename = ''
self._config.compression = True
config_list = [
('Filename:', 'filename', 'base:str', 'filebrowser',
'Output filename for MetaImage file.',
{'fileMode' : wx.SAVE,
'fileMask' : 'MetaImage single file (*.mha)|*.mha|MetaImage separate header/(z)raw files (*.mhd)|*.mhd|All files (*)|*',
'defaultExt' : '.mha'}
),
('Compression:', 'compression', 'base:bool', 'checkbox',
'Compress the image / volume data')
]
ScriptedConfigModuleMixin.__init__(self, config_list,
{'Module (self)' : self})
def dat2mhd(fn):
with open("L2_17aug.dat") as fd:
D = np.fromfile(file=fd, dtype=np.uint8).reshape((256, 256, 120)).astype("float32") / 255.0
D = np.log(D + 1)
from scipy.ndimage.interpolation import zoom
D = zoom(D, [1, 1, 256.0 / 120.0])
flat_d = D.transpose(2, 1, 0).flatten()
vtk_d_array = ns.numpy_to_vtk(flat_d)
image = vtk.vtkImageData()
points = image.GetPointData()
points.SetScalars(vtk_d_array)
image.SetDimensions(D.shape)
image.Update()
w = vtk.vtkMetaImageWriter()
w.SetFileName("bla.hdr")
w.SetInput(image)
w.Write()
def dat2mhd(fn):
with open("L2_17aug.dat") as fd:
D = np.fromfile(file=fd, dtype=np.uint8).reshape(
(256, 256, 120)).astype("float32") / 255.0
D = np.log(D + 1)
from scipy.ndimage.interpolation import zoom
D = zoom(D, [1, 1, 256.0 / 120.0])
flat_d = D.transpose(2, 1, 0).flatten()
vtk_d_array = ns.numpy_to_vtk(flat_d)
image = vtk.vtkImageData()
points = image.GetPointData()
points.SetScalars(vtk_d_array)
image.SetDimensions(D.shape)
image.Update()
w = vtk.vtkMetaImageWriter()
w.SetFileName("bla.hdr")
w.SetInput(image)
w.Write()
def trim_mha(fn = "dataset.mha", fnout = "t.mha"):
if not os.path.exists(fn):
print "%s does not exists, skip" % (fn,)
return
# read mha image
rd = vtk.vtkMetaImageReader()
rd.SetFileName(fn)
rd.Update()
# the image data
img = vtk.vtkImageData()
img = rd.GetOutput()
# set spacing to (1.0, 1.0, 1.0)
spacing = img.GetSpacing()
new_spacing = (1.0, 1.0, 1.0)
img.SetSpacing(new_spacing)
# set the origin to (0.0, 0.0, 0.0)
new_orig = (0.0, 0.0, 0.0)
img.SetOrigin(new_orig)
# write mha
wt = vtk.vtkMetaImageWriter()
wt.SetInputData(img)
wt.SetFileName(fnout)
wt.Write()
return spacing
def saveImageToMeta(data, outputFile):
# Currently, saves only the first time point !
imageData = vtk.vtkImageData()
# Sets the vtkImageData object's dimensions to match the data
lx, ly, lz = data[0].shape
lt = len(data)
imageData.SetDimensions(lx, ly, lz)
# Allocates scalars of the UINT8 type (value=3)
imageData.AllocateScalars(3, 1)
writer = vtk.vtkMetaImageWriter()
path, file = os.path.split(outputFile)
if not os.path.exists(path):
os.mkdir(path)
# This function writes the data for one time step into the vtkImageData object,
# and returns the vtkImageData object
writer.SetFileName(outputFile)
writer.SetRAWFileName(outputFile + '.raw')
for z in range(lz):
for y in range(ly):
for x in range(lx):
imageData.SetScalarComponentFromDouble(x, y, z, 0,
data[0][x, y, z])
# Writes the VTI files if requested
writer.SetInputData(imageData)
writer.Write()
def write_raw_gz(image, filename):
"""
raw.gzデータの書き込み．
Parameters
----------
image : vtk data
filename : string
mhdまたはmha形式のパスを指定．
"""
root, ext = os.path.splitext(filename)
raw_name = root + ".raw.gz"
create_header(image, raw_name)
writer = vtk.vtkMetaImageWriter()
writer.SetInputData(image.GetOutput())
writer.SetFileName(filename)
writer.SetRAWFileName(raw_name)
writer.SetCompression(False)
writer.Write()
with open(raw_name, 'rb') as f:
xml = f.read()
with gzip.open(raw_name, 'w') as gzfile:
gzfile.write(xml)
def writeMhdFile(array, filePath):
from vtk.util import vtkImageImportFromArray as viifa
import time
import vtk
if (array.ndim == 2):
arrayTMP = np.zeros((1, ) + np.shape(array)) # Make it 3D
arrayTMP[0, :, :] = array
array = arrayTMP
T2 = viifa.vtkImageImportFromArray()
T2.SetArray(array)
T2.SetDataSpacing([1, 1, 1]) # Is dit wat je wil? De voxel spacing...
FineDensiteDims = np.shape(array)
T2.SetDataExtent([
0, FineDensiteDims[0] - 1, 0, FineDensiteDims[1] - 1, 0,
FineDensiteDims[2] - 1
])
T2.Update()
DensiteSurEchan = T2.GetOutput()
#Ecriture
imageWriter = vtk.vtkMetaImageWriter()
imageWriter.SetCompression(False)
imageWriter.SetFileName(filePath)
imageWriter.SetInputData(DensiteSurEchan)
imageWriter.Write()
def write_vtk_image(vtkIm, fn, M=None):
"""
This function writes a vtk image to disk
Args:
vtkIm: the vtk image to write
fn: file name
Returns:
None
"""
print("Writing vti with name: ", fn)
if M is not None:
M.Invert()
reslice = vtk.vtkImageReslice()
reslice.SetInputData(vtkIm)
reslice.SetResliceAxes(M)
reslice.SetInterpolationModeToNearestNeighbor()
reslice.Update()
vtkIm = reslice.GetOutput()
_, extension = os.path.splitext(fn)
if extension == '.vti':
writer = vtk.vtkXMLImageDataWriter()
elif extension == '.vtk':
writer = vtk.vtkStructuredPointsWriter()
elif extension == '.mhd':
writer = vtk.vtkMetaImageWriter()
else:
raise ValueError("Incorrect extension " + extension)
writer.SetInputData(vtkIm)
writer.SetFileName(fn)
writer.Update()
writer.Write()
return
def write_image(_data, path_to_image):
# == make sure data type is unsigned char
cast = vtk.vtkImageCast()
if vtk.VTK_MAJOR_VERSION <= 5:
cast.SetInput(_data)
else:
cast.SetInputData(_data)
cast.SetOutputScalarTypeToUnsignedChar()
cast.Update()
_data = cast.GetOutput()
# == write
file_ext = fu.get_file_extension(path_to_image)
if (file_ext == "vti"):
print("Writing as '.vti' file.")
image_writer = vtk.vtkXMLImageDataWriter()
elif (file_ext == "nii"):
print("Writing as '.nii' file.")
image_writer = vtk.vtkNIFTIImageWriter()
print(
"VTK seems to change image orientation of NIFTI. Make sure to check image orientation relative to original image"
)
elif (file_ext == "mhd" or file_ext == "mha"):
print("Writing as .mhd/.raw or .mha image.")
image_writer = vtk.vtkMetaImageWriter()
image_writer.SetCompression(False)
else:
print("No valid image file extension specified!")
if vtk.VTK_MAJOR_VERSION <= 5:
image_writer.SetInput(_data)
else:
image_writer.SetInputData(_data)
image_writer.SetFileName(path_to_image)
# image_writer.Update()
image_writer.Write()
print("Image has been saved as %s " % (path_to_image))
def write_image(image, filename):
"""Write vtk image data to file."""
aWriter = vtk.vtkMetaImageWriter()
aWriter.SetInputData(image)
aWriter.SetFileName(filename)
aWriter.SetFileDimensionality(3)
aWriter.SetCompression(False)
aWriter.Write()
def WriteMetaImageFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing meta image file.')
writer = vtk.vtkMetaImageWriter()
writer.SetInputData(self.Image)
writer.SetFileName(self.OutputFileName)
if (self.OutputRawFileName != ''):
writer.SetRAWFileName(self.OutputRawFileName)
writer.Write()
def WriteMetaImageFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing meta image file.')
writer = vtk.vtkMetaImageWriter()
writer.SetInputData(self.Image)
writer.SetFileName(self.OutputFileName)
if (self.OutputRawFileName != ''):
writer.SetRAWFileName(self.OutputRawFileName)
writer.Write()
def WriteMetaImageFile(self):
if self.OutputFileName == "":
self.PrintError("Error: no OutputFileName.")
self.PrintLog("Writing meta image file.")
writer = vtk.vtkMetaImageWriter()
writer.SetInput(self.Image)
writer.SetFileName(self.OutputFileName)
if self.OutputRawFileName != "":
writer.SetRAWFileName(self.OutputRawFileName)
writer.Write()
def WriteToFile(self, imageData, exportFileName, fileType):
if fileType == DataReader.TypeMHD:
if not exportFileName.endswith(".mhd"):
exportFileName = exportFileName + ".mhd"
writer = vtkMetaImageWriter()
writer.SetFileName(exportFileName)
writer.SetInputData(imageData)
writer.Write()
elif fileType == DataReader.TypeVTI:
writer = vtkXMLImageDataWriter()
writer.SetFileName(exportFileName)
writer.SetInputData(imageData)
writer.Write()
elif fileType == DataReader.TypeMHA:
writer = vtkMetaImageWriter()
writer.SetFileName(exportFileName)
writer.SetInputData(imageData)
writer.Write()
else:
raise NotImplementedError("No writing support for type " + str(fileType))
def write_mha(self):
output_filename = self.filename + '.mha'
# output_filename_raw = self.filename + '.raw'
print('writing mha')
mha_writer = vtk.vtkMetaImageWriter()
mha_writer.SetInputConnection(self.mesh.GetOutputPort())
mha_writer.SetFileName(output_filename)
# mha_writer.SetRAWFileName(output_filename_raw)
mha_writer.Write()
def WriteToFile(self, imageData, exportFileName, fileType):
if fileType == DataReader.TypeMHD:
if not exportFileName.endswith(".mhd"):
exportFileName = exportFileName + ".mhd"
writer = vtkMetaImageWriter()
writer.SetFileName(exportFileName)
writer.SetInputData(imageData)
writer.Write()
elif fileType == DataReader.TypeVTI:
writer = vtkXMLImageDataWriter()
writer.SetFileName(exportFileName)
writer.SetInputData(imageData)
writer.Write()
elif fileType == DataReader.TypeMHA:
writer = vtkMetaImageWriter()
writer.SetFileName(exportFileName)
writer.SetInputData(imageData)
writer.Write()
else:
raise NotImplementedError("No writing support for type " +
str(fileType))
def saveRawData(dir, datamodel, index):
data = datamodel[index]
image = data.getITKImage()
image_type = data.getITKImageType()
itk_vtk_converter = itk.ImageToVTKImageFilter[image_type].New()
itk_vtk_converter.SetInput(image)
writer = vtk.vtkMetaImageWriter()
writer.SetInput(itk_vtk_converter.GetOutput())
writer.SetFileName(dir + '.mhd')
writer.SetRAWFileName(dir + '.raw')
writer.Write()
del image
del itk_vtk_converter
del writer
def ensureInSegment(self, image, lesionMesh, pathSegment, nameSegment, image_pos_pat, image_ori_pat):
# Proceed to build reference frame for display objects based on DICOM coords
[transformed_image, transform_cube] = self.loadDisplay.dicomTransform(image, image_pos_pat, image_ori_pat)
dataToStencil = vtk.vtkPolyDataToImageStencil()
dataToStencil.SetInput(lesionMesh)
dataToStencil.SetOutputOrigin(transformed_image.GetOrigin())
print transformed_image.GetOrigin()
dataToStencil.SetOutputSpacing(transformed_image.GetSpacing())
print transformed_image.GetSpacing()
dataToStencil.SetOutputWholeExtent(transformed_image.GetExtent())
dataToStencil.Update()
stencil = vtk.vtkImageStencil()
stencil.SetInput(transformed_image)
stencil.SetStencil(dataToStencil.GetOutput())
stencil.ReverseStencilOff()
stencil.SetBackgroundValue(0.0)
stencil.Update()
newSegment = vtk.vtkMetaImageWriter()
newSegment.SetFileName(pathSegment+'/'+nameSegment+'.mhd')
newSegment.SetInput(stencil.GetOutput())
newSegment.Write()
thresh = vtk.vtkImageThreshold()
thresh.SetInput(stencil.GetOutput())
thresh.ThresholdByUpper(1)
thresh.SetInValue(255)
thresh.SetOutValue(0)
thresh.Update()
contouriso = vtk.vtkMarchingCubes()
contouriso.SetInput(thresh.GetOutput())
contouriso.SetValue(0,125)
contouriso.ComputeScalarsOn()
contouriso.Update()
# Recalculate num_voxels and vol_lesion on VOI
nvoxels = contouriso.GetOutput().GetNumberOfCells()
npoints = contouriso.GetOutput().GetNumberOfPoints()
print "Number of points: %d" % npoints
print "Number of cells: %d" % nvoxels
return contouriso.GetOutput()
def __save_mhd__(filename, GetOutput):
if (not GetOutput.IsA("vtkImageData")):
print "[__save_mhd__] ERROR: \'%s\' != \'vtkImageData\' " % GetOutput.GetClassName(
)
sys.exit()
filename, fileExtension = os.path.splitext(filename)
filename = filename.upper()
filename += ".mhd"
writer = vtk.vtkMetaImageWriter()
writer.SetInput(GetOutput)
writer.SetFileName(filename)
#writer.SetDataModeToAscii();
writer.Write()
print "[save_mhd] \'%s\'" % filename
def save_vtkimage(vtk_image, filename):
"""Utility that saves a VTK image to disk
The vtk image may have been constructed with :py:func:`nifti_volumetric_data_to_vtkimage`.
:param vtk_image: the VTK image to save
:param filename: the output file
.. note::
it is currently not possible to select the format
"""
import vtk
image_saver = vtk.vtkMetaImageWriter()
image_saver.SetInputData(vtk_image)
image_saver.SetFileName(filename)
image_saver.Write()
def getWriter(self,polyData):
writer = None;
if self.destFormat == "vti":
writer = vtk.vtkXMLImageDataWriter();
writer.SetFileName(self.dest);
elif self.destFormat in ("mha","mhd","raw"):
writer = vtk.vtkMetaImageWriter();
writer.SetFilePrefix(self.dest);
writer.SetFileName(self.dest);
elif self.destFormat == "mnc":
writer = vtk.vtkMINCImageWriter();
writer.SetFileName(self.dest);
writer.StrictValidationOff();
elif self.destFormat == "vtk":
writer = vtk.vtkUnstructuredGridWriter();
writer.SetFileName(self.dest);
writer.SetInputData(polyData);
writer.Update();
return writer;
def write_raw(image, filename, compression=False):
"""
rawデータの書き込み．
Parameters
----------
image : vtk data
filename : string
mhdまたはmha形式のパスを指定．
"""
root, ext = os.path.splitext(filename)
raw_name = root + ".raw"
create_header(image, raw_name)
writer = vtk.vtkMetaImageWriter()
writer.SetInputData(image.GetOutput())
writer.SetFileName(filename)
writer.SetCompression(compression)
writer.Write()
def write_vtk_image(vtkIm, fn):
"""
This function writes a vtk image to disk
Args:
vtkIm: the vtk image to write
fn: file name
Returns:
None
"""
print("Writing vti with name: ", fn)
_, extension = os.path.splitext(fn)
if extension == '.vti':
writer = vtk.vtkXMLImageDataWriter()
elif extension == '.mhd':
writer = vtk.vtkMetaImageWriter()
else:
raise ValueError("Incorrect extension " + extension)
writer.SetInputData(vtkIm)
writer.SetFileName(fn)
writer.Update()
writer.Write()
return
def write(objct, fileoutput, binary=True):
"""
Write 3D object to file. (same as `save()`).
Possile extensions are:
- vtk, vti, ply, obj, stl, byu, vtp, vti, mhd, xyz, tif, png, bmp.
"""
obj = objct
if isinstance(obj, Actor): # picks transformation
obj = objct.polydata(True)
elif isinstance(obj, (vtk.vtkActor, vtk.vtkVolume)):
obj = objct.GetMapper().GetInput()
elif isinstance(obj, (vtk.vtkPolyData, vtk.vtkImageData)):
obj = objct
fr = fileoutput.lower()
if ".vtk" in fr:
w = vtk.vtkPolyDataWriter()
elif ".ply" in fr:
w = vtk.vtkPLYWriter()
elif ".stl" in fr:
w = vtk.vtkSTLWriter()
elif ".vtp" in fr:
w = vtk.vtkXMLPolyDataWriter()
elif ".vtm" in fr:
g = vtk.vtkMultiBlockDataGroupFilter()
for ob in objct:
g.AddInputData(ob)
g.Update()
mb = g.GetOutputDataObject(0)
wri = vtk.vtkXMLMultiBlockDataWriter()
wri.SetInputData(mb)
wri.SetFileName(fileoutput)
wri.Write()
return mb
elif ".xyz" in fr:
w = vtk.vtkSimplePointsWriter()
elif ".facet" in fr:
w = vtk.vtkFacetWriter()
elif ".tif" in fr:
w = vtk.vtkTIFFWriter()
w.SetFileDimensionality(len(obj.GetDimensions()))
elif ".vti" in fr:
w = vtk.vtkXMLImageDataWriter()
elif ".mhd" in fr:
w = vtk.vtkMetaImageWriter()
elif ".png" in fr:
w = vtk.vtkPNGWriter()
elif ".jpg" in fr:
w = vtk.vtkJPEGWriter()
elif ".bmp" in fr:
w = vtk.vtkBMPWriter()
elif ".xml" in fr: # write tetrahedral dolfin xml
vertices = obj.coordinates()
faces = obj.cells()
ncoords = vertices.shape[0]
ntets = faces.shape[0]
outF = open(fileoutput, "w")
outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
outF.write(' <mesh celltype="tetrahedron" dim="3">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, z = vertices[i]
outF.write(' <vertex index="' + str(i) + '" x="' + str(x) +
'" y="' + str(y) + '" z="' + str(z) + '"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntets) + '">\n')
for i in range(ntets):
v0, v1, v2, v3 = faces[i]
outF.write(' <tetrahedron index="' + str(i) + '" v0="' +
str(v0) + '" v1="' + str(v1) + '" v2="' + str(v2) +
'" v3="' + str(v3) + '"/>\n')
outF.write(' </cells>\n')
outF.write(" </mesh>\n")
outF.write("</dolfin>\n")
outF.close()
return objct
else:
colors.printc("~noentry Unknown format",
fileoutput,
"file not saved.",
c="r")
return objct
try:
if hasattr(w, 'SetFileTypeToBinary'):
if binary:
w.SetFileTypeToBinary()
else:
w.SetFileTypeToASCII()
w.SetInputData(obj)
w.SetFileName(fileoutput)
w.Write()
colors.printc("~save Saved file: " + fileoutput, c="g")
except Exception as e:
colors.printc("~noentry Error saving: " + fileoutput, "\n", e, c="r")
return objct
def loadTif(filenames,
reader,
output_image,
convert_numpy=False,
image_info=None,
progress_callback=None):
#time.sleep(0.1) #required so that progress window displays
#progress_callback.emit(10)
resample = False
if resample:
reader = Converter.tiffStack2numpyEnforceBounds(filenames=filenames,
bounds=(12, 12, 12))
#reader.AddObserver(vtk.vtkCommand.ProgressEvent, partial(getProgress, progress_callback= progress_callback))
#reader.Update()
#output_image.ShallowCopy(reader.GetOutput())
#print ("Spacing ", output_image.GetSpacing())
#header_length = reader.GetFileHeaderLength()
#vol_bit_depth = reader.GetBytesPerElement()*8
#shape = reader.GetStoredArrayShape()
# if not reader.GetIsFortran():
# shape = shape[::-1]
# image_info['isBigEndian'] = reader.GetBigEndian()
# print("Header", header_length)
# print("vol_bit_depth", vol_bit_depth)
else:
sa = vtk.vtkStringArray()
for fname in filenames:
i = sa.InsertNextValue(fname)
print("read {} files".format(i))
reader.AddObserver(
vtk.vtkCommand.ProgressEvent,
partial(getProgress, progress_callback=progress_callback))
reader.SetFileNames(sa)
dtype = vtk.VTK_UNSIGNED_CHAR
if reader.GetOutput().GetScalarType() != dtype and False:
# need to cast to 8 bits unsigned
print("The if statement is true")
stats = vtk.vtkImageAccumulate()
stats.SetInputConnection(reader.GetOutputPort())
stats.Update()
iMin = stats.GetMin()[0]
iMax = stats.GetMax()[0]
if (iMax - iMin == 0):
scale = 1
else:
scale = vtk.VTK_UNSIGNED_CHAR_MAX / (iMax - iMin)
shiftScaler = vtk.vtkImageShiftScale()
shiftScaler.SetInputConnection(reader.GetOutputPort())
shiftScaler.SetScale(scale)
shiftScaler.SetShift(-iMin)
shiftScaler.SetOutputScalarType(dtype)
shiftScaler.Update()
tmpdir = tempfile.gettempdir()
writer = vtk.vtkMetaImageWriter()
writer.SetInputConnection(shiftScaler.GetOutputPort())
writer.SetFileName(os.path.join(tmpdir, 'input8bit.mhd'))
writer.Write()
reader = shiftScaler
reader.Update()
progress_callback.emit(80)
print("Convert np")
image_data = reader.GetOutput()
output_image.ShallowCopy(image_data)
progress_callback.emit(90)
if convert_numpy:
filename = os.path.abspath(filenames[0])[:-4] + ".npy"
numpy_array = Converter.vtk2numpy(reader.GetOutput())
#numpy_array = Converter.tiffStack2numpy(filenames = filenames)
numpy.save(filename, numpy_array)
image_info['numpy_file'] = filename
if image_info is not None:
if (isinstance(numpy_array[0][0][0], numpy.uint8)):
image_info['vol_bit_depth'] = '8'
elif (isinstance(numpy_array[0][0][0], numpy.uint16)):
image_info['vol_bit_depth'] = '16'
print(image_info['vol_bit_depth'])
image_info['sampled'] = False
#TODO: save volume header length
progress_callback.emit(100)
# --------------------------------------------------------------------- # Save projections # For VTK need a flat data array projections.resize((prod(projections.shape),)) data_vtk = numpy_to_vtk(projections) assert(data_vtk.GetNumberOfTuples() == projections.size) image_vtk = vtk.vtkImageData() # Convert to x,y,z order image_vtk.SetDimensions(detector_horizontal_pixels, detector_vertical_pixels, number_of_projections) image_vtk.SetOrigin(projection_origin[1], projection_origin[0], 0) image_vtk.SetSpacing((detector_pixel_size,)*3) image_vtk.GetPointData().SetScalars(data_vtk) writer = vtk.vtkMetaImageWriter() writer.SetFileName(output_file_root + ".mha") writer.SetRAWFileName(output_file_root + ".raw") writer.SetCompression(0) writer.SetInput(image_vtk) writer.Write() for ij in bad_pixel_list: dark_field[ij[0],ij[1]] = 0 flat_field[ij[0],ij[1]] = 0 multi_dark_field = zeros((number_of_dark_field_measurements, dark_field.shape[0], dark_field.shape[1]), int16) multi_dark_field[:] = dark_field multi_dark_field.resize((prod(multi_dark_field.shape),))
def saveImageMetaIO(image, file_name): #tested
"""
Saves the image data into a file as MetaIO format.
Parameters
----------
image : vtk.vtkImageData
An VTL image as used by WrapITK.
file_name : string
Path and file name (without suffix) where to save the image.
Notes
-----
A write operation will trigger the image pipeline to be processed.
"""
assert isinstance(image, vtk.vtkImageData)
writer = vtk.vtkMetaImageWriter()
writer.SetFileName(file_name + '.mhd')
writer.SetInput(image)
writer.Write()
# This definitions are taken from vtkSetGet.h
#define VTK_LARGE_FLOAT 1.0e+38F
#define VTK_LARGE_ID 2147483647
#define VTK_LARGE_INTEGER 2147483647
#define VTK_VOID 0
#define VTK_BIT 1
#define VTK_CHAR 2
#define VTK_UNSIGNED_CHAR 3
#define VTK_SHORT 4
#define VTK_UNSIGNED_SHORT 5
#define VTK_INT 6
#define VTK_UNSIGNED_INT 7
#define VTK_LONG 8
#define VTK_UNSIGNED_LONG 9
#define VTK_FLOAT 10
#define VTK_DOUBLE 11
#define VTK_ID_TYPE 12
#define VTK_BIT_MIN 0
#define VTK_BIT_MAX 1
#define VTK_CHAR_MIN -128
#define VTK_CHAR_MAX 127
#define VTK_UNSIGNED_CHAR_MIN 0
#define VTK_UNSIGNED_CHAR_MAX 255
#define VTK_SHORT_MIN -32768
#define VTK_SHORT_MAX 32767
#define VTK_UNSIGNED_SHORT_MIN 0
#define VTK_UNSIGNED_SHORT_MAX 65535
#define VTK_INT_MIN (-VTK_LARGE_INTEGER-1)
#define VTK_INT_MAX VTK_LARGE_INTEGER
#define VTK_UNSIGNED_INT_MIN 0
#define VTK_UNSIGNED_INT_MAX 4294967295UL
#define VTK_LONG_MIN (-VTK_LARGE_INTEGER-1)
#define VTK_LONG_MAX VTK_LARGE_INTEGER
#define VTK_UNSIGNED_LONG_MIN 0
#define VTK_UNSIGNED_LONG_MAX 4294967295UL
#define VTK_FLOAT_MIN -VTK_LARGE_FLOAT
#define VTK_FLOAT_MAX VTK_LARGE_FLOAT
#define VTK_DOUBLE_MIN -1.0e+99L
#define VTK_DOUBLE_MAX 1.0e+99L
#define VTK_POLY_DATA 0
#define VTK_STRUCTURED_POINTS 1
#define VTK_STRUCTURED_GRID 2
#define VTK_RECTILINEAR_GRID 3
#define VTK_UNSTRUCTURED_GRID 4
#define VTK_PIECEWISE_FUNCTION 5
#define VTK_IMAGE_DATA 6
#define VTK_DATA_OBJECT 7
#define VTK_DATA_SET 8
# A number of vtkImageData methods with example outputs and comments
# .getDimensions() -> the official image dimensions
# (511, 511, 182)
# .GetBounds() -> the actual bounds (as I use for display)
# (0.0, 379.25909173488617, 0.0, 379.25909173488617, 0.0, 273.0)
# .GetCenter() # the half of the bounds
# (189.62954586744308, 189.62954586744308, 136.5)
# .GetDataObjectType() # one of VTK_STRUCTURED_GRID, VTK_STRUCTURED_POINTS, VTK_UNSTRUCTURED_GRID, VTK_POLY_DATA, or VTK_RECTILINEAR_GRID
# 6 # VTK_IMAGE_DATA
# img.GetExtent()
# (0, 511, 0, 511, 0, 182)
# .GetExtentType() #VTK_PIECES_EXTENT or VTK_3D_EXTENT
# 1
# .GetInformation() # try to print this once
# vtk.Information object
# .GetLength() # no idea
# 601.8337954345383
# .GetNumberOfPoints() # 511*511*182
# 47972352L
# img.GetNumberOfScalarComponents()
# 1
# .getScalarRange() # range of gray values in this case!
# (-1024.0, 1680.0)
# .getScALARtYPE()
# 4
# .getScalarTypeAsString()
# 'short'
# .getScalarTypeMax() # max possible value
# 32767.0
# .getScalarTypeMin() # min possible value
# -32768.0
Ren1 = vtk.vtkRenderer()
Ren1.SetBackground(0.33,0.35,0.43)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(Ren1)
renWin.SetSize(300,300)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
reader = vtk.vtkImageReader()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0,63,0,63,1,93)
reader.SetDataSpacing(3.2,3.2,1.5)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
reader.Update()
pvTemp200 = vtk.vtkMetaImageWriter()
pvTemp200.SetFileName("mhdWriter.mhd")
pvTemp200.SetInputData(reader.GetOutput())
pvTemp200.Write()
pvTemp90 = vtk.vtkMetaImageReader()
pvTemp90.SetFileName("mhdWriter.mhd")
pvTemp90.Update()
pvTemp109 = vtk.vtkLookupTable()
pvTemp109.SetNumberOfTableValues(256)
pvTemp109.SetHueRange(0.6667,0)
pvTemp109.SetSaturationRange(1,1)
pvTemp109.SetValueRange(1,1)
pvTemp109.SetTableRange(37.3531,260)
pvTemp109.SetVectorComponent(0)
pvTemp109.Build()
pvTemp110 = vtk.vtkContourFilter()
def execute(self, arg, trans):
# Number of Chan-Vese iterations
nIter = 20
std = 1.5 # [mm], original
squareSize = 1.5 # [mm]
saveMetaImage = False
savePNGImage = False
# Actual work - now done using SciPy
# Gaussian smoothing
dx, dy, dz = arg.GetSpacing()
sx, sy = std / dx, std / dy
smoother = vtk.vtkImageGaussianSmooth()
smoother.SetStandardDeviations(sx, sy)
smoother.SetDimensionality(2)
smoother.SetInputData(arg)
smoother.Update()
if savePNGImage:
writer = vtk.vtkPNGWriter()
writer.SetFileName('./output.png')
writer.SetInputConnection(smoother.GetOutputPort())
writer.Write()
if saveMetaImage:
# Save to disk
writer = vtk.vtkMetaImageWriter()
writer.SetFileName('./output.mhd')
writer.SetInputConnection(smoother.GetOutputPort())
writer.Write()
smoothedData = smoother.GetOutput()
# Convert VTK to NumPy image
dims = arg.GetDimensions()
vtk_array = smoothedData.GetPointData().GetScalars()
nComponents = vtk_array.GetNumberOfComponents()
npData = vtk_to_numpy(vtk_array).reshape(
dims[2], dims[1], dims[0],
nComponents)[:, :, :, 0].reshape(dims[1], dims[0])
# Seed for active contours
iSquareSize = int(squareSize / dx)
init_ls = checkerboard_level_set(npData.shape, iSquareSize)
contours = morphological_chan_vese(npData,
nIter,
init_level_set=init_ls,
smoothing=2)
# Add singleton to get 3-dimensional data
data = contours[None, :]
# Convert Numpy to VTK data
importer = vtk.vtkImageImport()
importer.SetDataScalarType(vtk.VTK_SIGNED_CHAR)
importer.SetDataExtent(0, data.shape[2] - 1, 0, data.shape[1] - 1, 0,
data.shape[0] - 1)
importer.SetWholeExtent(0, data.shape[2] - 1, 0, data.shape[1] - 1, 0,
data.shape[0] - 1)
importer.SetImportVoidPointer(data.data)
importer.Update()
vtkData = importer.GetOutput()
vtkData.SetSpacing(smoothedData.GetSpacing())
vtkData.SetOrigin(0, 0, 0)
# Contour filter
contourFilter = vtk.vtkContourFilter()
iso_value = 0.5
contourFilter.SetInputData(vtkData)
contourFilter.SetValue(0, iso_value)
contourFilter.Update()
contourFilter.ReleaseDataFlagOn()
# Compute normals
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(contourFilter.GetOutputPort())
normals.SetFeatureAngle(60.0)
normals.ReleaseDataFlagOn()
# Join line segments
stripper = vtk.vtkStripper()
stripper.SetInputConnection(normals.GetOutputPort())
stripper.ReleaseDataFlagOn()
stripper.Update()
# Transform data from scaled screen to world coordinates
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(stripper.GetOutputPort())
transformFilter.SetTransform(trans)
transformFilter.Update()
result = transformFilter.GetOutput()
# Emit done with output
self.done.emit(result)
import os
import numpy as np
import natsort
import vtk
import sys
dataPath = sys.argv[1]
outputfile = sys.argv[2]
for dirName, subDir, fileList in os.walk(dataPath):
pass
index = natsort.index_natsorted(fileList)
fileList = natsort.order_by_index(fileList, index)
stringArray = vtk.vtkStringArray()
for i, fileName in enumerate(fileList):
stringArray.InsertNextValue(fileName)
reader = vtk.vtkDICOMImageReader()
reader.SetDirectoryName(dataPath)
reader.SetFileNames(stringArray)
writer = vtk.vtkMetaImageWriter()
writer.SetInputConnection(reader.GetOutputPort())
writer.SetFileName(outputfile + '.mhd')
writer.Write()
def saveImageMetaIO(image, file_name): #tested
"""
Saves the image data into a file as MetaIO format.
Note: A write operation will trigger the image pipeline to be processed.
@param image: an instance of vtk.vtkImageData
@param file_name: path to the save file as string, \wo file-suffix
"""
assert isinstance(image, vtk.vtkImageData)
writer = vtk.vtkMetaImageWriter()
writer.SetFileName(file_name + '.mhd')
writer.SetInput(image)
writer.Write()
# This definitions are taken from vtkSetGet.h
#define VTK_LARGE_FLOAT 1.0e+38F
#define VTK_LARGE_ID 2147483647
#define VTK_LARGE_INTEGER 2147483647
#define VTK_VOID 0
#define VTK_BIT 1
#define VTK_CHAR 2
#define VTK_UNSIGNED_CHAR 3
#define VTK_SHORT 4
#define VTK_UNSIGNED_SHORT 5
#define VTK_INT 6
#define VTK_UNSIGNED_INT 7
#define VTK_LONG 8
#define VTK_UNSIGNED_LONG 9
#define VTK_FLOAT 10
#define VTK_DOUBLE 11
#define VTK_ID_TYPE 12
#define VTK_BIT_MIN 0
#define VTK_BIT_MAX 1
#define VTK_CHAR_MIN -128
#define VTK_CHAR_MAX 127
#define VTK_UNSIGNED_CHAR_MIN 0
#define VTK_UNSIGNED_CHAR_MAX 255
#define VTK_SHORT_MIN -32768
#define VTK_SHORT_MAX 32767
#define VTK_UNSIGNED_SHORT_MIN 0
#define VTK_UNSIGNED_SHORT_MAX 65535
#define VTK_INT_MIN (-VTK_LARGE_INTEGER-1)
#define VTK_INT_MAX VTK_LARGE_INTEGER
#define VTK_UNSIGNED_INT_MIN 0
#define VTK_UNSIGNED_INT_MAX 4294967295UL
#define VTK_LONG_MIN (-VTK_LARGE_INTEGER-1)
#define VTK_LONG_MAX VTK_LARGE_INTEGER
#define VTK_UNSIGNED_LONG_MIN 0
#define VTK_UNSIGNED_LONG_MAX 4294967295UL
#define VTK_FLOAT_MIN -VTK_LARGE_FLOAT
#define VTK_FLOAT_MAX VTK_LARGE_FLOAT
#define VTK_DOUBLE_MIN -1.0e+99L
#define VTK_DOUBLE_MAX 1.0e+99L
#define VTK_POLY_DATA 0
#define VTK_STRUCTURED_POINTS 1
#define VTK_STRUCTURED_GRID 2
#define VTK_RECTILINEAR_GRID 3
#define VTK_UNSTRUCTURED_GRID 4
#define VTK_PIECEWISE_FUNCTION 5
#define VTK_IMAGE_DATA 6
#define VTK_DATA_OBJECT 7
#define VTK_DATA_SET 8
# A number of vtkImageData methods with example outputs and comments
# .getDimensions() -> the official image dimensions
# (511, 511, 182)
# .GetBounds() -> the actual bounds (as I use for display)
# (0.0, 379.25909173488617, 0.0, 379.25909173488617, 0.0, 273.0)
# .GetCenter() # the half of the bounds
# (189.62954586744308, 189.62954586744308, 136.5)
# .GetDataObjectType() # one of VTK_STRUCTURED_GRID, VTK_STRUCTURED_POINTS, VTK_UNSTRUCTURED_GRID, VTK_POLY_DATA, or VTK_RECTILINEAR_GRID
# 6 # VTK_IMAGE_DATA
# img.GetExtent()
# (0, 511, 0, 511, 0, 182)
# .GetExtentType() #VTK_PIECES_EXTENT or VTK_3D_EXTENT
# 1
# .GetInformation() # try to print this once
# vtk.Information object
# .GetLength() # no idea
# 601.8337954345383
# .GetNumberOfPoints() # 511*511*182
# 47972352L
# img.GetNumberOfScalarComponents()
# 1
# .getScalarRange() # range of gray values in this case!
# (-1024.0, 1680.0)
# .getScALARtYPE()
# 4
# .getScalarTypeAsString()
# 'short'
# .getScalarTypeMax() # max possible value
# 32767.0
# .getScalarTypeMin() # min possible value
# -32768.0
def write_slice(s, fn):
wt = vtk.vtkMetaImageWriter()
wt.SetInputConnection(s.GetOutputPort())
wt.SetFileName(fn)
wt.SetCompression(False)
wt.Write()
def testVTK2pOutputfile(self):
""" Takes a Study/ExamID/SeriesID/ dicom images and convertes them into a data structure to test integration pipeline"""
# Open filename list
StudyID = '18'
DicomExamNumber = '7714' # corresponds to old way of ret
Lesions_id = '1721'
SeriesID = 'S44' # corresponds to dynamic sequence;
###### Loading
print "Start by loading volumes..."
load = Inputs_init()
[series_path, phases_series, lesionID_path] = load.readVolumes(StudyID, DicomExamNumber, SeriesID, Lesions_id)
print "Path to series location: %s" % series_path
print "List of pre and post contrast volume names: %s" % phases_series
print "Path to lesion segmentation: %s" % lesionID_path
print "\n Load Segmentation..."
lesion3D = load.loadSegmentation(lesionID_path)
print "Data Structure: %s" % lesion3D.GetClassName()
print "Number of points: %d" % int(lesion3D.GetNumberOfPoints())
print "Number of cells: %d" % int(lesion3D.GetNumberOfCells())
print "\n Visualize volumes..."
loadDisplay = Display()
lesion3D_mesh = loadDisplay.addSegment(lesion3D)
loadDisplay.visualize(load.DICOMImages, load.image_pos_pat, load.image_ori_pat, sub=True, postS=3, interact=False)
#######################################################
###### Testing integration format change of input data
#######################################################
# Convert load.DICOMImages data to list of arrays [x,y,z] and lesion3D segmentation to mask [x,y,z]
self.npDICOMImages = {}
for i in range(len(load.DICOMImages)):
# convert 'DICOMImages': list[(vtkImageData) to npDICOMImages': list[(ndarray)
dims = load.DICOMImages[i].GetDimensions()
spacing = load.DICOMImages[i].GetSpacing()
im_scalars = load.DICOMImages[i].GetPointData().GetScalars()
np_imdata = vtk_to_numpy(im_scalars)
np_imdata = np_imdata.reshape(dims[2], dims[1], dims[0])
np_imdata = array(np_imdata.transpose(2,1,0)).astype(float)
# append
self.npDICOMImages['im'+str(i)] = np_imdata
# process time points needed for dynamic features
abspath_PhaseID = series_path+os.sep+str(phases_series[i])
# Get total number of files
[len_listSeries_files, FileNms_slices_sorted_stack] = processDicoms.ReadDicomfiles(abspath_PhaseID)
mostleft_slice = FileNms_slices_sorted_stack.slices[0]
# Get dicom header, retrieve
dicomInfo_series = dicom.read_file(abspath_PhaseID+os.sep+str(mostleft_slice))
# (0008,0032) AT S Acquisition Time # hh.mm.ss.frac
ti = str(dicomInfo_series[0x0008,0x0032].value)
self.npDICOMImages['ti'+str(i)]=ti
# create other information from dicom data
self.npDICOMImages['dims'] = load.DICOMImages[0].GetDimensions()
self.npDICOMImages['spacing'] = load.DICOMImages[0].GetSpacing()
self.npDICOMImages['nvol'] = len(load.DICOMImages)
self.npDICOMImages['image_pos_pat'] = load.image_pos_pat # position of far most left (indicates origin)
self.npDICOMImages['image_ori_pat'] = load.image_ori_pat
################################################################ NEEDED TO TEST CHANGING FORMAT OF DATA
# Create mask for VOI
[transformed_image, t] = Display().dicomTransform(load.DICOMImages[0], load.image_pos_pat, load.image_ori_pat)
self.vtkmask = load.createVTKMaskfromMesh(lesion3D, transformed_image) # SHOULD RETURN A VTKIMAGEDATA REPRESENTING MASK
# save image as metafile image
vtkimage_w = vtk.vtkMetaImageWriter()
vtkimage_w.SetInput(transformed_image)
vtkimage_w.SetFileName( 'vtkimage.mhd' )
vtkimage_w.Write()
# ## save mask as metafile image
vtkmask_w = vtk.vtkMetaImageWriter()
vtkmask_w.SetInput(self.vtkmask )
vtkmask_w.SetFileName( 'vtkmask.mhd' )
vtkmask_w.Write()
# write to image
maskscalars = self.vtkmask.GetPointData().GetScalars()
npmask = vtk_to_numpy(maskscalars)
npmask = npmask.reshape(self.npDICOMImages['dims'][2], self.npDICOMImages['dims'][1], self.npDICOMImages['dims'][0])
npmask = array(npmask.transpose(2,1,0)).astype(float)
self.npDICOMImages['mask'] = npmask # SHOULD RETURN A NUMPY ARRAY REPRESENTING MASK
# Save a dictionary into a pickle file. to retrieve later
# Not saving the arrays corectly
pickle.dump( self.npDICOMImages, open( "npDICOMImages.p", "wb" ), -1 )
###################################################### FINISH TESTING
return
def __init__(self):
# Defintion of visualization parameters
self.op_max_bl = 0.5
self.op_max_rm = 0.5
self.th_bl = 0.0
self.th_rm = 0.0
self.ri_bl = 1.0
self.ri_rm = 1.0
self.min_value = 0.0
self.max_value = 0.1
self.dimensions_vtk_data = [50, 50, 50]
self.spacing_vtk_data = [0.1, 0.1, 0.1]
self.scale_factor = 1.0
# bl parameters
self.blAmbient = 0.4
self.blDiffuse = 0.5
self.blSpecular = 0.05
# rm parameters
self.image_data_rm = self.createEmptyImageData()
self.rmAmbient = 0.4
self.rmDiffuse = 0.5
self.rmSpecular = 0.05
self.cutoff_factor_rm = 0.05
# Color map and scalar bar parameters
self.height_scalarBar = 250
self.HSV_color_max_value = 0, 1.0, 1.0
self.HSV_color_min_value = 0.166, 1.0, 1.0
# Saclar bar bools
self.bool_scalar_bar_bl = False
self.bool_scalar_bar_rm = False
# Maunal lookup table
self.lookup_table_matrix = []
# VTK writer to save mha rm file
self.writer_rm = vtk.vtkMetaImageWriter()
# Setup of 3D visualization pipeline
empty_image_bl = self.createEmptyImageData()
empty_image_rm = self.createEmptyImageData()
self.grid_volume = self.createGrid()
self.volumeMapperBl = vtk.vtkGPUVolumeRayCastMapper()
self.volumeMapperBl.SetInputData(empty_image_bl)
self.volumeMapperRm = vtk.vtkGPUVolumeRayCastMapper()
self.volumeMapperRm.SetInputData(empty_image_rm)
# Placeholder lookup tables are created
placeholderOpTransferFunctionBl = self.createLookupTableSlider( 'bl')
placeholderOpTransferFunctionRm = self.createLookupTableSlider( 'rm')
volumeGradientOpBl = vtk.vtkPiecewiseFunction()
volumeGradientOpBl.AddPoint(0.0, 0.2)
volumeGradientOpBl.AddPoint(0.080, 0.5)
volumeGradientOpBl.AddPoint(0.100, 0.8)
volumeGradientOpRm = vtk.vtkPiecewiseFunction()
volumeGradientOpRm.AddPoint(0, 0.2)
volumeGradientOpRm.AddPoint(0.080, 0.5)
volumeGradientOpRm.AddPoint(0.100, 0.8)
self.volumePropertyBl = vtk.vtkVolumeProperty()
self.volumePropertyBl.SetScalarOpacity(placeholderOpTransferFunctionBl)
self.volumePropertyBl.ShadeOn()
self.volumePropertyBl.SetInterpolationTypeToLinear()
self.volumePropertyBl.SetAmbient(self.blAmbient)
self.volumePropertyBl.SetDiffuse(self.blDiffuse)
self.volumePropertyBl.SetSpecular(self.blSpecular)
self.volumePropertyBl.SetGradientOpacity(volumeGradientOpBl)
self.volumePropertyRm = vtk.vtkVolumeProperty()
self.volumePropertyRm.SetScalarOpacity(placeholderOpTransferFunctionRm)
self.volumePropertyRm.ShadeOn()
self.volumePropertyRm.SetInterpolationTypeToLinear()
self.volumePropertyRm.SetAmbient(self.rmAmbient)
self.volumePropertyRm.SetDiffuse(self.rmDiffuse)
self.volumePropertyRm.SetSpecular(self.rmSpecular)
self.volumePropertyRm.SetGradientOpacity(volumeGradientOpRm)
self.volume_bl = vtk.vtkVolume()
self.volume_bl.SetMapper(self.volumeMapperBl)
self.volume_bl.SetProperty(self.volumePropertyBl)
self.volume_rm = vtk.vtkVolume()
self.volume_rm.SetMapper(self.volumeMapperRm)
self.volume_rm.SetProperty(self.volumePropertyRm)
# Creation of additional 2D actors to be visualized
# 1. Scalar bars to visualize color map range
self.actor_scalar_bar_bl = self.createColorScalarBar(0.0, 1.0)
self.actor_scalar_bar_rm = self.createColorScalarBar(0.0, 1.0)
# 2. Text actor to display camera position and focal point
self.text_actor = vtk.vtkTextActor()
self.text_actor.SetPosition ( 20, 20 )
self.text_actor.GetTextProperty().SetFontSize (24 )
self.text_actor.GetTextProperty().SetColor ( 0.8, 0.8, 0.8 )
self.text_actor.GetTextProperty().SetOpacity ( 0.8)
# Setup renderer
self.ren = vtk.vtkRenderer()
self.ren.AddVolume(self.volume_rm)
self.ren.AddVolume(self.volume_bl)
self.ren.AddActor2D (self.text_actor )
self.ren.SetBackground(1.0,1.0,1.0)
self.ren.ResetCamera()
def featureMap(self, DICOMImages, img_features, time_points, featuresKeys, caseLabeloutput, path_outputFolder):
"""Extracts feature maps per pixel based on request from vector of keywords featuresKeys """
## Retrive image data
VOIshape = img_features['VOI0'].shape
print VOIshape
self.init_features(img_features, featuresKeys)
data_deltaS=[]
self.allvar_F_r_i=[]
# append So and to
data_deltaS.append( 0 )
# Based on the course of signal intensity within the lesion
So = array(img_features['VOI0']).astype(float)
Crk = {'Cr0': mean(So)}
C = {}
Carray = []
# iterate point-by-point to extract feature map
for i in range(VOIshape[0]):
for j in range(VOIshape[1]):
for k in range(VOIshape[2]):
for timep in range(1, len(DICOMImages)):
pix_deltaS = (img_features['VOI'+str(timep)][i,j,k].astype(float) - img_features['VOI0'][i,j,k].astype(float))/img_features['VOI0'][i,j,k].astype(float)
if pix_deltaS<0: pix_deltaS=0
data_deltaS.append( pix_deltaS )
F_r_i = array(img_features['VOI'+str(timep)]).astype(float)
n_F_r_i, min_max_F_r_i, mean_F_r_i, var_F_r_i, skew_F_r_i, kurt_F_r_i = stats.describe(F_r_i)
self.allvar_F_r_i.append(var_F_r_i)
data = array(data_deltaS)
#print data
# create a set of Parameters
params = Parameters()
params.add('amp', value= 10, min=0)
params.add('alpha', value= 1, min=0)
params.add('beta', value= 0.05, min=0.0001, max=0.9)
# do fit, here with leastsq self.model
myfit = Minimizer(self.fcn2min, params, fcn_args=(time_points,), fcn_kws={'data':data})
myfit.prepare_fit()
myfit.leastsq()
####################################
# Calculate R-square: R_square = sum( y_fitted - y_mean)/ sum(y_data - y_mean)
R_square = sum( (self.model - mean(data))**2 )/ sum( (data - mean(data))**2 )
#print "R^2:"
#print R_square
self.R_square_map[i,j,k] = R_square
if 'amp' in featuresKeys:
amp = params['amp'].value
print "amp:"
print amp
self.amp_map[i,j,k] = amp
if 'beta' in featuresKeys:
beta = params['beta'].value
self.beta_map[i,j,k] = beta
if 'alpha' in featuresKeys:
alpha = params['alpha'].value
print "alpha:"
print alpha
self.alpha_map[i,j,k] = alpha
if 'iAUC1' in featuresKeys:
iAUC1 = params['amp'].value *( ((1-exp(-params['beta'].value*t[1]))/params['beta'].value) + (exp((-params['alpha'].value+params['beta'].value)*t[1])-1)/(params['alpha'].value+params['beta'].value) )
print "iAUC1"
print iAUC1
self.iAUC1_map[i,j,k] = iAUC1
if 'Slope_ini' in featuresKeys:
Slope_ini = params['amp'].value*params['alpha'].value
print "Slope_ini"
print Slope_ini
self.Slope_ini_map[i,j,k] = Slope_ini
if 'Tpeak' in featuresKeys:
Tpeak = (1/params['alpha'].value)*log(1+(params['alpha'].value/params['beta'].value))
self.Tpeak_map[i,j,k] = Tpeak
if 'Kpeak' in featuresKeys:
Kpeak = -params['amp'].value * params['alpha'].value * params['beta'].value
self.Kpeak_map[i,j,k] = Kpeak
if 'SER' in featuresKeys:
SER = exp( (t[4]-t[1])*params['beta'].value) * ( (1-exp(-params['alpha'].value*t[1]))/(1-exp(-params['alpha'].value*t[4])) )
print "SER"
print SER
self.SER_map[i,j,k] = SER
if 'maxCr' in featuresKeys:
print "Maximum Upate (Fii_1) = %d " % self.maxCr
self.maxC_map[i,j,k] = self.maxCr
if 'peakCr' in featuresKeys:
print "Peak Cr (Fii_2) = %d " % self.peakCr
self.peakCr_map[i,j,k] = self.peakCr
if 'UptakeRate' in featuresKeys:
self.UptakeRate = float(self.maxCr/self.peakCr)
print "Uptake rate (Fii_3) "
print self.UptakeRate
self.UptakeRate_map[i,j,k] = self.UptakeRate
if 'washoutRate' in featuresKeys:
if( self.peakCr == 4):
self.washoutRate = 0
else:
self.washoutRate = float( (self.maxCr - array(Crk['Cr'+str(4)]).astype(float))/(4-self.peakCr) )
print "WashOut rate (Fii_4) "
print self.washoutRate
self.washoutRate_map[i,j,k] = self.washoutRate
if 'var_F_r_i' in featuresKeys:
print("Variance F_r_i: {0:8.6f}".format( mean(self.allvar_F_r_i) ))
self.allvar_F_r_i_map[i,j,k] = mean(self.allvar_F_r_i)
data_deltaS=[]
data_deltaS.append( 0 )
# convert feature maps to image
if 'beta' in featuresKeys:
beta_map_stencil = self.convertfeatureMap2vtkImage(self.beta_map, self.imageStencil, 1000)
print path_outputFolder
print caseLabeloutput
# ## save mask as metafile image
os.chdir(path_outputFolder)
vtkmask_w = vtk.vtkMetaImageWriter()
vtkmask_w.SetInput(beta_map_stencil )
vtkmask_w.SetFileName( 'beta_'+os.sep+caseLabeloutput+'.mhd' )
vtkmask_w.Write()
vtkmask_w.Update()
self.xImagePlaneWidget.SetWindowLevel(640,75)
self.yImagePlaneWidget.SetWindowLevel(640,75)
self.zImagePlaneWidget.SetWindowLevel(640,75)
self.renderer1.Render()
self.visualize_map(beta_map_stencil)
if 'Tpeak' in featuresKeys:
Tpeak_map_stencil = self.convertfeatureMap2vtkImage(self.Tpeak_map, self.imageStencil, 1)
print path_outputFolder
print caseLabeloutput
# ## save mask as metafile image
os.chdir(path_outputFolder)
vtkmask_w = vtk.vtkMetaImageWriter()
vtkmask_w.SetInput( Tpeak_map_stencil )
vtkmask_w.SetFileName( 'Tpeak_'+os.sep+caseLabeloutput+'.mhd' )
vtkmask_w.Write()
vtkmask_w.Update()
self.xImagePlaneWidget.SetWindowLevel(240,35)
self.yImagePlaneWidget.SetWindowLevel(240,35)
self.zImagePlaneWidget.SetWindowLevel(240,35)
self.renderer1.Render()
self.visualize_map(Tpeak_map_stencil)
if 'Kpeak' in featuresKeys:
Kpeak_map_stencil = self.convertfeatureMap2vtkImage(self.Kpeak_map, self.imageStencil, 1)
print path_outputFolder
print caseLabeloutput
# ## save mask as metafile image
os.chdir(path_outputFolder)
vtkmask_w = vtk.vtkMetaImageWriter()
vtkmask_w.SetInput( Kpeak_map_stencil )
vtkmask_w.SetFileName( 'Kpeak_'+os.sep+caseLabeloutput+'.mhd' )
vtkmask_w.Write()
vtkmask_w.Update()
self.xImagePlaneWidget.SetWindowLevel(118,15)
self.yImagePlaneWidget.SetWindowLevel(118,15)
self.zImagePlaneWidget.SetWindowLevel(118,15)
self.renderer1.Render()
self.visualize_map(Kpeak_map_stencil)
return
def getVOIdata(self, DICOMImages, series_path, phases_series, image_pos_pat, image_ori_pat, VOIspacing, VOI_mesh, path_outputFolder, caseLabeloutput):
""" featuremap_beta: Creates some feature maps from image
INPUTS:
=======
image: (vtkImageData) Input image to Transform
image_pos_pat: (list(dicomInfo[0x0020,0x0032].value))) Image position patient Dicom Tag
image_ori_pat: (list(dicomInfo[0x0020,0x0037].value)) Image oreintation patient Dicom Tag
OUTPUTS:
=======
transformed_image (vtkImageData) Transformed imaged mapped to dicom coords frame
transform (vtkTransform) Transform used
"""
# necessary to read point coords
VOIPnt = [0,0,0]
ijk = [0,0,0]
pco = [0,0,0]
for i in range(len(DICOMImages)):
abspath_PhaseID = series_path+os.sep+str(phases_series[i])
print phases_series[i]
# Get total number of files
load = Inputs_init()
[len_listSeries_files, FileNms_slices_sorted_stack] = load.ReadDicomfiles(abspath_PhaseID)
mostleft_slice = FileNms_slices_sorted_stack.slices[0]
# Get dicom header, retrieve
dicomInfo_series = dicom.read_file(abspath_PhaseID+os.sep+str(mostleft_slice))
# (0008,0032) AT S Acquisition Time # hh.mm.ss.frac
ti = str(dicomInfo_series[0x0008,0x0032].value)
acquisitionTimepoint = datetime.time(hour=int(ti[0:2]), minute=int(ti[2:4]), second=int(ti[4:6]))
self.timepoints.append( datetime.datetime.combine(datetime.date.today(), acquisitionTimepoint) )
# find mapping to Dicom space
displayFuncs = Display()
[self.transformed_image, transform_cube] = displayFuncs.dicomTransform(DICOMImages[i], image_pos_pat, image_ori_pat)
#################### HERE GET IT AND MASK IT OUT
### Get inside of VOI
self.imageStencil = self.createMaskfromMesh(VOI_mesh, self.transformed_image)
if i==0:
print path_outputFolder
print caseLabeloutput
# ## save mask as metafile image
os.chdir(path_outputFolder)
vtkmask_w = vtk.vtkMetaImageWriter()
vtkmask_w.SetInput( self.imageStencil )
vtkmask_w.SetFileName( 'pre_con.mhd' )
vtkmask_w.Write()
vtkmask_w.Update()
# get non zero elements
VOI_scalars = self.imageStencil.GetPointData().GetScalars()
numpy_VOI_scalars = vtk_to_numpy(VOI_scalars)
numpy_VOI_scalars = numpy_VOI_scalars.reshape(self.VOIdims[2], self.VOIdims[1], self.VOIdims[0])
numpy_VOI_scalars = numpy_VOI_scalars.transpose(2,1,0)
print "\n VOIbounds"
print self.VOIbounds
# compute origin
IMorigin = displayFuncs.origin
if i==0:
print "\n Compute VOI extent:"
self.ext.append( round((self.VOIbounds[1]-self.VOIbounds[0])/VOIspacing[0]) )
self.ext.append( round((self.VOIbounds[3]-self.VOIbounds[2])/VOIspacing[1]) )
self.ext.append( round((self.VOIbounds[5]-self.VOIbounds[4])/VOIspacing[2]) )
print self.ext
# get non zero elements
image_scalars = self.transformed_image.GetPointData().GetScalars()
numpy_VOI_imagedata = vtk_to_numpy(image_scalars)
numpy_VOI_imagedata = numpy_VOI_imagedata.reshape(self.VOIdims[2], self.VOIdims[1], self.VOIdims[0])
numpy_VOI_imagedata = numpy_VOI_imagedata.transpose(2,1,0)
## compute ijk extent
self.ix = round((self.VOIbounds[0]-IMorigin[0])/VOIspacing[0])
self.iy = round((self.VOIbounds[2]-IMorigin[1])/VOIspacing[1])
self.iz = round((self.VOIbounds[4]-IMorigin[2])/VOIspacing[2])
numpy_VOI_imagedataext = numpy_VOI_imagedata[ self.ix:self.ix+self.ext[0], self.iy:self.iy+self.ext[1], self.iz:self.iz+self.ext[2] ]
print "Shape of numpy_VOI_imagedataext: "
print size(numpy_VOI_imagedataext)
#################### HERE GET IT AND MASK IT OUT
# Now collect pixVals
print "Saving %s" % 'VOIimage'+str(i)
self.deltaS['VOI'+str(i)] = numpy_VOI_imagedataext
numpy_VOI_imagedataext = []
# Visualize
if i==0:
self.addSegment(VOI_mesh)
self.renderer1.RemoveActor(self.actor_mesh)
self.visualize_map(self.imageStencil)
# Collecting timepoints in proper format
t_delta = []
t_delta.append(0)
total_time = 0
for i in range(len(DICOMImages)-1):
current_time = self.timepoints[i+1]
previous_time = self.timepoints[i]
difference_time = current_time - previous_time
timestop = divmod(difference_time.total_seconds(), 60)
t_delta.append( t_delta[i] + timestop[0]+timestop[1]*(1./60))
total_time = total_time+timestop[0]+timestop[1]*(1./60)
# finally print t_delta
print "\n time_points:"
print t_delta
print "total_time"
print total_time
self.time_points = array(t_delta)
return self.deltaS, self.time_points
def write(objct, fileoutput, binary=True):
"""
Write 3D object to file. (same as `save()`).
Possile extensions are:
- vtk, vti, npy, ply, obj, stl, byu, vtp, vti, mhd, xyz, tif, png, bmp.
"""
obj = objct
if isinstance(obj, Mesh): # picks transformation
obj = objct.polydata(True)
elif isinstance(obj, (vtk.vtkActor, vtk.vtkVolume)):
obj = objct.GetMapper().GetInput()
elif isinstance(obj, (vtk.vtkPolyData, vtk.vtkImageData)):
obj = objct
fr = fileoutput.lower()
if fr.endswith(".vtk"):
writer = vtk.vtkPolyDataWriter()
elif fr.endswith(".ply"):
writer = vtk.vtkPLYWriter()
pscal = obj.GetPointData().GetScalars()
if not pscal:
pscal = obj.GetCellData().GetScalars()
if pscal and pscal.GetName():
writer.SetArrayName(pscal.GetName())
#writer.SetColorMode(0)
lut = objct.GetMapper().GetLookupTable()
if lut:
writer.SetLookupTable(lut)
elif fr.endswith(".stl"):
writer = vtk.vtkSTLWriter()
elif fr.endswith(".vtp"):
writer = vtk.vtkXMLPolyDataWriter()
elif fr.endswith(".vtm"):
g = vtk.vtkMultiBlockDataGroupFilter()
for ob in objct:
if isinstance(ob, Mesh): # picks transformation
ob = ob.polydata(True)
elif isinstance(ob, (vtk.vtkActor, vtk.vtkVolume)):
ob = ob.GetMapper().GetInput()
g.AddInputData(ob)
g.Update()
mb = g.GetOutputDataObject(0)
wri = vtk.vtkXMLMultiBlockDataWriter()
wri.SetInputData(mb)
wri.SetFileName(fileoutput)
wri.Write()
return mb
elif fr.endswith(".xyz"):
writer = vtk.vtkSimplePointsWriter()
elif fr.endswith(".facet"):
writer = vtk.vtkFacetWriter()
elif fr.endswith(".tif"):
writer = vtk.vtkTIFFWriter()
writer.SetFileDimensionality(len(obj.GetDimensions()))
elif fr.endswith(".vti"):
writer = vtk.vtkXMLImageDataWriter()
elif fr.endswith(".mhd"):
writer = vtk.vtkMetaImageWriter()
elif fr.endswith(".nii"):
writer = vtk.vtkNIFTIImageWriter()
elif fr.endswith(".png"):
writer = vtk.vtkPNGWriter()
elif fr.endswith(".jpg"):
writer = vtk.vtkJPEGWriter()
elif fr.endswith(".bmp"):
writer = vtk.vtkBMPWriter()
elif fr.endswith(".npy"):
if utils.isSequence(objct):
objslist = objct
else:
objslist = [objct]
dicts2save = []
for obj in objslist:
dicts2save.append( _np_dump(obj) )
np.save(fileoutput, dicts2save)
return dicts2save
elif fr.endswith(".obj"):
outF = open(fileoutput, "w")
outF.write('# OBJ file format with ext .obj\n')
outF.write('# File Created by vtkplotter\n')
cobjct = objct.clone().clean()
for p in cobjct.points():
outF.write('v '+ str(p[0]) +" "+ str(p[1])+" "+ str(p[2])+'\n')
for vn in cobjct.normals(cells=False):
outF.write('vn '+str(vn[0])+" "+str(vn[1])+" "+str(vn[2])+'\n')
#pdata = cobjct.polydata().GetPointData().GetScalars()
#if pdata:
# ndata = vtk_to_numpy(pdata)
# for vd in ndata:
# outF.write('vp '+ str(vd) +'\n')
#ptxt = cobjct.polydata().GetPointData().GetTCoords() # not working
#if ptxt:
# ntxt = vtk_to_numpy(ptxt)
# print(len(cobjct.faces()), cobjct.points().shape, ntxt.shape)
# for vt in ntxt:
# outF.write('vt '+ str(vt[0]) +" "+ str(vt[1])+ ' 0\n')
for f in cobjct.faces():
fs = ''
for fi in f:
fs += " "+str(fi+1)
outF.write('f' + fs + '\n')
#ldata = cobjct.polydata().GetLines().GetData()
#print(cobjct.polydata().GetLines())
#if ldata:
# ndata = vtk_to_numpy(ldata)
# print(ndata)
# for l in ndata:
# ls = ''
# for li in l:
# ls += str(li+1)+" "
# outF.write('l '+ ls + '\n')
outF.close()
return objct
elif fr.endswith(".xml"): # write tetrahedral dolfin xml
vertices = objct.points().astype(str)
faces = np.array(objct.faces()).astype(str)
ncoords = vertices.shape[0]
outF = open(fileoutput, "w")
outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
if len(faces[0]) == 4:# write tetrahedral mesh
ntets = faces.shape[0]
outF.write(' <mesh celltype="tetrahedron" dim="3">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'" z="'+z+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntets) + '">\n')
for i in range(ntets):
v0, v1, v2, v3 = faces[i]
outF.write(' <tetrahedron index="'+str(i)
+ '" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'" v3="'+v3+'"/>\n')
elif len(faces[0]) == 3:# write triangle mesh
ntri = faces.shape[0]
outF.write(' <mesh celltype="triangle" dim="2">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, dummy_z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntri) + '">\n')
for i in range(ntri):
v0, v1, v2 = faces[i]
outF.write(' <triangle index="'+str(i)+'" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'"/>\n')
outF.write(' </cells>\n')
outF.write(" </mesh>\n")
outF.write("</dolfin>\n")
outF.close()
return objct
else:
colors.printc("~noentry Unknown format", fileoutput, "file not saved.", c="r")
return objct
try:
if hasattr(writer, 'SetFileTypeToBinary'):
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetInputData(obj)
writer.SetFileName(fileoutput)
writer.Write()
except Exception as e:
colors.printc("~noentry Error saving: " + fileoutput, "\n", e, c="r")
return objct
Ren1 = vtk.vtkRenderer()
Ren1.SetBackground(0.33, 0.35, 0.43)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(Ren1)
renWin.SetSize(300, 300)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
reader = vtk.vtkImageReader()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0, 63, 0, 63, 1, 93)
reader.SetDataSpacing(3.2, 3.2, 1.5)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
reader.Update()
pvTemp200 = vtk.vtkMetaImageWriter()
pvTemp200.SetFileName("mhdWriter.mhd")
pvTemp200.SetInputData(reader.GetOutput())
pvTemp200.Write()
pvTemp90 = vtk.vtkMetaImageReader()
pvTemp90.SetFileName("mhdWriter.mhd")
pvTemp90.Update()
pvTemp109 = vtk.vtkLookupTable()
pvTemp109.SetNumberOfTableValues(256)
pvTemp109.SetHueRange(0.6667, 0)
pvTemp109.SetSaturationRange(1, 1)
pvTemp109.SetValueRange(1, 1)
pvTemp109.SetTableRange(37.3531, 260)
pvTemp109.SetVectorComponent(0)
pvTemp109.Build()
pvTemp110 = vtk.vtkContourFilter()
def write(objct, fileoutput, binary=True):
"""
Write 3D object to file. (same as `save()`).
Possile extensions are:
- vtk, vti, npy, ply, obj, stl, byu, vtp, vti, mhd, xyz, tif, png, bmp.
"""
obj = objct
if isinstance(obj, Actor): # picks transformation
obj = objct.polydata(True)
elif isinstance(obj, (vtk.vtkActor, vtk.vtkVolume)):
obj = objct.GetMapper().GetInput()
elif isinstance(obj, (vtk.vtkPolyData, vtk.vtkImageData)):
obj = objct
fr = fileoutput.lower()
if ".vtk" in fr:
writer = vtk.vtkPolyDataWriter()
elif ".ply" in fr:
writer = vtk.vtkPLYWriter()
pscal = obj.GetPointData().GetScalars()
if not pscal:
pscal = obj.GetCellData().GetScalars()
if pscal and pscal.GetName():
writer.SetArrayName(pscal.GetName())
#writer.SetColorMode(0)
lut = objct.GetMapper().GetLookupTable()
if lut:
writer.SetLookupTable(lut)
elif ".stl" in fr:
writer = vtk.vtkSTLWriter()
elif ".obj" in fr:
writer = vtk.vtkOBJWriter()
elif ".vtp" in fr:
writer = vtk.vtkXMLPolyDataWriter()
elif ".vtm" in fr:
g = vtk.vtkMultiBlockDataGroupFilter()
for ob in objct:
g.AddInputData(ob)
g.Update()
mb = g.GetOutputDataObject(0)
wri = vtk.vtkXMLMultiBlockDataWriter()
wri.SetInputData(mb)
wri.SetFileName(fileoutput)
wri.Write()
return mb
elif ".xyz" in fr:
writer = vtk.vtkSimplePointsWriter()
elif ".facet" in fr:
writer = vtk.vtkFacetWriter()
elif ".tif" in fr:
writer = vtk.vtkTIFFWriter()
writer.SetFileDimensionality(len(obj.GetDimensions()))
elif ".vti" in fr:
writer = vtk.vtkXMLImageDataWriter()
elif ".mhd" in fr:
writer = vtk.vtkMetaImageWriter()
elif ".nii" in fr:
writer = vtk.vtkNIFTIImageWriter()
elif ".png" in fr:
writer = vtk.vtkPNGWriter()
elif ".jpg" in fr:
writer = vtk.vtkJPEGWriter()
elif ".bmp" in fr:
writer = vtk.vtkBMPWriter()
elif ".npy" in fr:
if utils.isSequence(objct):
objslist = objct
else:
objslist = [objct]
dicts2save = []
for obj in objslist:
dicts2save.append( _np_dump(obj) )
np.save(fileoutput, dicts2save)
return dicts2save
elif ".xml" in fr: # write tetrahedral dolfin xml
vertices = objct.coordinates().astype(str)
faces = np.array(objct.faces()).astype(str)
ncoords = vertices.shape[0]
outF = open(fileoutput, "w")
outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
if len(faces[0]) == 4:# write tetrahedral mesh
ntets = faces.shape[0]
outF.write(' <mesh celltype="tetrahedron" dim="3">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'" z="'+z+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntets) + '">\n')
for i in range(ntets):
v0, v1, v2, v3 = faces[i]
outF.write(' <tetrahedron index="'+str(i)
+ '" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'" v3="'+v3+'"/>\n')
elif len(faces[0]) == 3:# write triangle mesh
ntri = faces.shape[0]
outF.write(' <mesh celltype="triangle" dim="2">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, dummy_z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntri) + '">\n')
for i in range(ntri):
v0, v1, v2 = faces[i]
outF.write(' <triangle index="'+str(i)+'" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'"/>\n')
outF.write(' </cells>\n')
outF.write(" </mesh>\n")
outF.write("</dolfin>\n")
outF.close()
return objct
else:
colors.printc("~noentry Unknown format", fileoutput, "file not saved.", c="r")
return objct
try:
if hasattr(writer, 'SetFileTypeToBinary'):
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetInputData(obj)
writer.SetFileName(fileoutput)
writer.Write()
colors.printc("~save Saved file: " + fileoutput, c="g")
except Exception as e:
colors.printc("~noentry Error saving: " + fileoutput, "\n", e, c="r")
return objct
def main():
# 3D source sphere
sphereSource = vtk.vtkSphereSource()
sphereSource.SetPhiResolution(30)
sphereSource.SetThetaResolution(30)
sphereSource.SetCenter(40, 40, 0)
sphereSource.SetRadius(20)
# generate circle by cutting the sphere with an implicit plane
# (through its center, axis-aligned)
circleCutter = vtk.vtkCutter()
circleCutter.SetInputConnection(sphereSource.GetOutputPort())
cutPlane = vtk.vtkPlane()
cutPlane.SetOrigin(sphereSource.GetCenter())
cutPlane.SetNormal(0, 0, 1)
circleCutter.SetCutFunction(cutPlane)
stripper = vtk.vtkStripper()
stripper.SetInputConnection(circleCutter.GetOutputPort()) # valid circle
stripper.Update()
# that's our circle
circle = stripper.GetOutput()
# write circle out
polyDataWriter = vtk.vtkXMLPolyDataWriter()
polyDataWriter.SetInputData(circle)
polyDataWriter.SetFileName("circle.vtp")
polyDataWriter.SetCompressorTypeToNone()
polyDataWriter.SetDataModeToAscii()
polyDataWriter.Write()
# prepare the binary image's voxel grid
whiteImage = vtk.vtkImageData()
bounds = [0] * 6
circle.GetBounds(bounds)
spacing = [0] * 3 # desired volume spacing
spacing[0] = 0.5
spacing[1] = 0.5
spacing[2] = 0.5
whiteImage.SetSpacing(spacing)
# compute dimensions
dim = [0] * 3
for i in range(3):
dim[i] = int(
math.ceil((bounds[i * 2 + 1] - bounds[i * 2]) / spacing[i])) + 1
if dim[i] < 1:
dim[i] = 1
whiteImage.SetDimensions(dim)
whiteImage.SetExtent(0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1)
origin = [0] * 3
# NOTE: I am not sure whether or not we had to add some offset!
origin[0] = bounds[0] # + spacing[0] / 2
origin[1] = bounds[2] # + spacing[1] / 2
origin[2] = bounds[4] # + spacing[2] / 2
whiteImage.SetOrigin(origin)
whiteImage.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
# fill the image with foreground voxels:
inval = 255
outval = 0
count = whiteImage.GetNumberOfPoints()
# for (vtkIdType i = 0 i < count ++i)
for i in range(count):
whiteImage.GetPointData().GetScalars().SetTuple1(i, inval)
# sweep polygonal data (this is the important thing with contours!)
extruder = vtk.vtkLinearExtrusionFilter()
extruder.SetInputData(circle)
extruder.SetScaleFactor(1.0)
#extruder.SetExtrusionTypeToNormalExtrusion() # not working
extruder.SetExtrusionTypeToVectorExtrusion()
extruder.SetVector(0, 0, 1)
extruder.Update()
# polygonal data -. image stencil:
pol2stenc = vtk.vtkPolyDataToImageStencil()
pol2stenc.SetTolerance(0) # important if extruder.SetVector(0, 0, 1) !!!
pol2stenc.SetInputConnection(extruder.GetOutputPort())
#pol2stenc.SetInputData(circle)
pol2stenc.SetOutputOrigin(origin)
pol2stenc.SetOutputSpacing(spacing)
pol2stenc.SetOutputWholeExtent(whiteImage.GetExtent())
pol2stenc.Update()
# cut the corresponding white image and set the background:
imgstenc = vtk.vtkImageStencil()
imgstenc.SetInputData(whiteImage)
imgstenc.SetStencilConnection(pol2stenc.GetOutputPort())
imgstenc.ReverseStencilOff()
imgstenc.SetBackgroundValue(outval)
imgstenc.Update()
imageWriter = vtk.vtkMetaImageWriter()
imageWriter.SetFileName("labelImage.mhd")
imageWriter.SetInputConnection(imgstenc.GetOutputPort())
imageWriter.Write()
imageWriter = vtk.vtkPNGWriter()
imageWriter.SetFileName("labelImage.png")
imageWriter.SetInputConnection(imgstenc.GetOutputPort())
imageWriter.Write()
v1 = (P100 - np.asarray(P000))/np.linalg.norm((P100-P000))
print(v1.dot(v2))
print(v2.dot(v3))
print(v1.dot(v3))
print(v1)
print(v2)
print(v3)
print(P000)
# output.SetDirectionMatrix(v1[0],v1[1],v1[2],v2[0],v2[1],v2[2],v3[0],v3[1],v3[2])
# output.SetOrigin(np.dot(R,np.array([78.085,-164.968,163.991])))
output.SetOrigin(P000)
output.SetDirectionMatrix(v1[0],v2[0],v3[0],v1[1],v2[1],v3[1],v1[2],v2[2],v3[2])
# output.SetDirectionMatrix(0.5,0.5,0,0,1,0,0,0,1)
ImgWr =vtk.vtkMetaImageWriter()
ImgWr.SetFileName('FinalVol1.vti')
ImgWr.SetInputDataObject(output)
ImgWr.Write()
print("END")
# new_zx = np.zeros(zx.shape)
# new_zx = new_zx == 1
# normal = np.array([0.75,0,-0.75])
# ori0 = np.array([259,5,219])
def extractT2texture(self, t_T2image, image_pos_pat, image_ori_pat, VOI_mesh, patchdirname):
###################################
# Haralick et al. defined 10 grey-level co-occurrence matrix (GLCM) enhancement features
# 3D textrue features
# self = funcD
# T2image = self.load.T2Images
# image_pos_pat = self.load.T2image_pos_pat
# image_ori_pat = self.load.T2image_ori_pat
# VOI_mesh = funcD.lesion3D
# loadDisplay = funcD.loadDisplay
## Transform T2 img
#localloadDisplay = Display()
# Proceed to build reference frame for display objects based on DICOM coords
#[t_T2image, transform_cube] = loadDisplay.dicomTransform(T2image, image_pos_pat, image_ori_pat)
# Update info
t_T2image.UpdateInformation()
print "\nLoading VOI_mesh MASK... "
VOIPnt = [0,0,0]; pixVals_margin = []; pixVals = []
#################### TO NUMPY
VOI_scalars = t_T2image.GetPointData().GetScalars()
np_VOI_imagedata = vtk_to_numpy(VOI_scalars)
dims = t_T2image.GetDimensions()
spacing = t_T2image.GetSpacing()
np_VOI_imagedata = np_VOI_imagedata.reshape(dims[2], dims[1], dims[0])
np_VOI_imagedata = array(np_VOI_imagedata.transpose(2,1,0))
#****************************"
print "Normalizing data..."
np_VOI_imagedataflat = np_VOI_imagedata.flatten().astype(float)
np_VOI_imagedata_num = (np_VOI_imagedataflat-min(np_VOI_imagedataflat))
np_VOI_imagedata_den = (max(np_VOI_imagedataflat)-min(np_VOI_imagedataflat))
np_VOI_imagedata_flatten = 255*(np_VOI_imagedata_num/np_VOI_imagedata_den)
np_VOI_imagedata = np_VOI_imagedata_flatten.reshape(dims[0], dims[1], dims[2])
# Prepare lesion localization and PATCH size for Texture analysis
# lesion_centroid
lesionBox = VOI_mesh.GetBounds()
self.boxWidget.PlaceWidget( lesionBox )
self.boxWidget.On()
deltax = lesionBox[1] - lesionBox[0]
print deltax
deltay = lesionBox[3]-lesionBox[2]
print deltay
deltaz = lesionBox[5]-lesionBox[4]
print deltaz
# find largest dimension and use that for lesion radius
if deltax > deltay:
lesion_dia = deltax/spacing[0]
print "deltax was largest %d... " % lesion_dia
else:
lesion_dia = deltay/spacing[1]
print "deltay was largest %d... " % lesion_dia
lesion_radius = lesion_dia/2
lesionthick = deltaz/spacing[2]/2
print "VOI_efect_diameter %s... " % str(lesion_radius)
lesion_location = VOI_mesh.GetCenter()
print "lesion_location %s... " % str(lesion_location)
lesion_patches = []
######### translate lesion location to ijk coordinates
# sub_pre_transformed_image.FindPoint(lesion_location
pixId = t_T2image.FindPoint(lesion_location[0], lesion_location[1], lesion_location[2])
sub_pt = [0,0,0]
t_T2image.GetPoint(pixId, sub_pt)
ijk = [0,0,0]
pco = [0,0,0]
inorout = t_T2image.ComputeStructuredCoordinates( sub_pt, ijk, pco)
print "coresponding ijk_vtk indices:"
print ijk
ijk_vtk = ijk
# Perform texture classification using grey level co-occurrence matrices (GLCMs).
# A GLCM is a histogram of co-occurring greyscale values at a given offset over an image.
# compute some GLCM properties each patch
# p(i,j) is the (i,j)th entry in a normalized spatial gray-level dependence matrix;
lesion_patches = np_VOI_imagedata[
int(ijk_vtk[0] - lesion_radius-1):int(ijk_vtk[0] + lesion_radius+1),
int(ijk_vtk[1] - lesion_radius-1):int(ijk_vtk[1] + lesion_radius),
int(ijk_vtk[2] - lesionthick/2-1):int(ijk_vtk[2] + lesionthick/2+1) ]
print '\n Lesion_patches:'
print lesion_patches
#################### RESAMPLE TO ISOTROPIC
# pass to vtk
lesion_patches_shape = lesion_patches.shape
vtklesion_patches = lesion_patches.transpose(2,1,0)
vtklesion_patches_data = numpy_to_vtk(num_array=vtklesion_patches.ravel(), deep=True, array_type=vtk.VTK_FLOAT)
# probe into the unstructured grid using ImageData geometry
vtklesion_patches = vtk.vtkImageData()
vtklesion_patches.SetExtent(0,lesion_patches_shape[0]-1,0,lesion_patches_shape[1]-1,0,lesion_patches_shape[2]-1)
vtklesion_patches.SetOrigin(0,0,0)
vtklesion_patches.SetSpacing(spacing)
vtklesion_patches.GetPointData().SetScalars(vtklesion_patches_data)
# write ####################
isowriter = vtk.vtkMetaImageWriter()
isowriter.SetInput(vtklesion_patches)
isowriter.SetFileName(patchdirname+"_T2w.mha")
isowriter.Write()
isopix = mean(vtklesion_patches.GetSpacing())
resample = vtk.vtkImageResample ()
resample.SetInput( vtklesion_patches )
resample.SetAxisOutputSpacing( 0, isopix )
resample.SetAxisOutputSpacing( 1, isopix )
resample.SetAxisOutputSpacing( 2, isopix )
resample.Update()
isoImage = resample.GetOutput()
#################### get isotropic patches
ISO_scalars = isoImage.GetPointData().GetScalars()
np_ISO_Image = vtk_to_numpy(ISO_scalars)
isodims = isoImage.GetDimensions()
isospacing = isoImage.GetSpacing()
np_ISO_Imagedata = np_ISO_Image.reshape(isodims[2], isodims[1], isodims[0])
np_ISO_Imagedata = array(np_ISO_Imagedata.transpose(2,1,0))
#################### save isotropic patches
fig = plt.figure()
# patch histogram
ax1 = fig.add_subplot(221)
n, bins, patches = plt.hist(array(np_ISO_Imagedata.flatten()), 50, normed=1, facecolor='green', alpha=0.75)
ax1.set_ylabel('histo')
ax2 = fig.add_subplot(222)
plt.imshow(np_ISO_Imagedata[:,:,np_ISO_Imagedata.shape[2]/2])
plt.gray()
ax2.set_ylabel('iso: '+str(isodims) )
ax3 = fig.add_subplot(223)
plt.imshow(lesion_patches[:,:,lesion_patches.shape[2]/2])
plt.gray()
ax3.set_ylabel('original: '+str(lesion_patches_shape))
ax4 = fig.add_subplot(224)
plt.imshow(np_VOI_imagedata[:,:,ijk_vtk[2]])
plt.gray()
ax4.set_ylabel('lesion centroid(ijk): '+str(ijk_vtk))
# FInally display
# plt.show()
plt.savefig(patchdirname+'_T2w.png', format='png')
####################
#################### 3D GLCM
from graycomatrix3D import glcm3d
patch = np_ISO_Imagedata.astype(np.uint8)
lev = int(patch.max()+1) # levels
# perfor glmc extraction in all 13 directions in 3D pixel neighbors
g1 = glcm3d(lev, patch, offsets=[0,0,1]) # orientation 0 degrees (example same slices: equal to Nslices*0degree 2D case)
g2 = glcm3d(lev, patch, offsets=[0,1,-1]) # orientation 45 degrees (example same slices: equal to Nslices*45degree 2D case)
g3 = glcm3d(lev, patch, offsets=[0,1,0]) # orientation 90 degrees (example same slices: equal to Nslices*90degree 2D case)
g4 = glcm3d(lev, patch, offsets=[0,1,1]) # orientation 135 degrees (example same slices: equal to Nslices*135degree 2D case)
g5 = glcm3d(lev, patch, offsets=[1,0,-1]) # 0 degrees/45 degrees (example same slices: equal to (Nslices-1)*0degree 2D case)
g6 = glcm3d(lev, patch, offsets=[1,0,0]) # straight up (example same slices: equal to np.unique())
g7 = glcm3d(lev, patch, offsets=[1,0,1]) # 0 degree/135 degrees (example same slices: equal to (Nslices-1)*transpose of 0degree 2D case)
g8 = glcm3d(lev, patch, offsets=[1,1,0]) # 90 degrees/45 degrees (example same slices: equal to (Nslices-1)*90 degree 2D case)
g9 = glcm3d(lev, patch, offsets=[1,-1,0]) # 90 degrees/135 degrees (example same slices: equal to (Nslices-1)*transpose of 90 degree 2D case)
g10 = glcm3d(lev, patch, offsets=[1,1,-1]) # 45 degrees/45 degrees (example same slices: equal to (Nslices-1)*45 degree 2D case)
g11 = glcm3d(lev, patch, offsets=[1,-1,1]) # 45 degree/135 degrees (example same slices: equal to (Nslices-1)*transpose of 45 degree 2D case)
g12 = glcm3d(lev, patch, offsets=[1,1,1]) # 135 degrees/45 degrees (example same slices: equal to (Nslices-1)*135 degree 2D case)
g13 = glcm3d(lev, patch, offsets=[0,0,1]) # 135 degrees/135 degrees (example same slices: equal to (Nslices-1)*transpose of 135 degree 2D case)
# plot
fig = plt.figure()
fig.add_subplot(431); plt.imshow(g1); plt.gray()
fig.add_subplot(432); plt.imshow(g2); plt.gray()
fig.add_subplot(433); plt.imshow(g3); plt.gray()
fig.add_subplot(434); plt.imshow(g4); plt.gray()
fig.add_subplot(435); plt.imshow(g5); plt.gray()
fig.add_subplot(436); plt.imshow(g6); plt.gray()
fig.add_subplot(437); plt.imshow(g7); plt.gray()
fig.add_subplot(438); plt.imshow(g8); plt.gray()
# add all directions to make features non-directional
g = g1+g2+g3+g4+g5+g6+g7+g8+g9+g10+g11+g12+g13
fig.add_subplot(439); plt.imshow(g); plt.gray()
#plt.show()
### glcm normalization ###
if g.sum() != 0:
g = g.astype(float)/g.sum()
### compute auxiliary variables ###
(num_level, num_level2) = g.shape
I, J = np.ogrid[0:num_level, 0:num_level]
I = 1+ np.array(range(num_level)).reshape((num_level, 1))
J = 1+ np.array(range(num_level)).reshape((1, num_level))
diff_i = I - np.apply_over_axes(np.sum, (I * g), axes=(0, 1))[0, 0]
diff_j = J - np.apply_over_axes(np.sum, (J * g), axes=(0, 1))[0, 0]
std_i = np.sqrt(np.apply_over_axes(np.sum, (g * (diff_i) ** 2),axes=(0, 1))[0, 0])
std_j = np.sqrt(np.apply_over_axes(np.sum, (g * (diff_j) ** 2),axes=(0, 1))[0, 0])
cov = np.apply_over_axes(np.sum, (g * (diff_i * diff_j)),axes=(0, 1))[0, 0]
gxy = np.zeros(2*g.shape[0]-1) ### g x+y
gx_y = np.zeros(g.shape[0]) ### g x-y
for i in xrange(g.shape[0]):
for j in xrange(g.shape[0]):
gxy[i+j] += g[i,j]
gx_y[np.abs(i-j)] += g[i,j]
mx_y = (gx_y*np.arange(len(gx_y))).sum()
v = np.zeros(11)
i,j = np.indices(g.shape)+1
ii = np.arange(len(gxy))+2
ii_ = np.arange(len(gx_y))
### compute descriptors ###
v[0] = np.apply_over_axes(np.sum, (g ** 2), axes=(0, 1))[0, 0] # energy or Angular second moment
v[1] = np.apply_over_axes(np.sum, (g * ((I - J) ** 2)), axes=(0, 1))[0, 0] # Contrast
if std_i>1e-15 and std_j>1e-15: # handle the special case of standard deviations near zero
v[2] = cov/(std_i*std_j)#v[2] = greycoprops(g,'correlation') # Correlation
else:
v[2] = 1
v[3] = np.apply_over_axes(np.sum, (g* (diff_i) ** 2),axes=(0, 1))[0, 0]# Variance or Sum of squares
v[4] = np.sum(g * (1. / (1. + (I - J) ** 2))) # Inverse difference moment
v[5] = (gxy*ii).sum() # Sum average
v[6] = ((ii-v[5])*(ii-v[5])*gxy).sum() # Sum variance
v[7] = -1*(gxy*np.log10(gxy+ np.spacing(1))).sum() # Sum entropy
v[8] = -1*(g*np.log10(g+np.spacing(1))).sum() # Entropy
v[9] = ((ii_-mx_y)*(ii_-mx_y)*gx_y).sum() # Difference variance
v[10] = -1*(gx_y*np.log10(gx_y++np.spacing(1))).sum() # Difference entropy
# writing to file from row_lesionID Drow_PathRepID
##################################################
# writing to file from row_lesionID Drow_PathRepID
print "\n Append texture features for each post contrast"
[self.T2texture_energy_nondir, self.T2texture_contrast_nondir, self.T2texture_correlation_nondir,
self.T2texture_variance_nondir, self.T2texture_inversediffmoment_nondir, self.T2texture_sumaverage_nondir,
self.T2texture_sumvariance_nondir, self.T2texture_sumentropy_nondir, self.T2texture_entropy_nondir,
self.T2texture_diffvariance_nondir,self.T2texture_diffentropy_nondir] = v
##################################################
# orgamize into dataframe
self.textureT2Features = DataFrame( data=array([[ self.T2texture_energy_nondir, self.T2texture_contrast_nondir, self.T2texture_correlation_nondir,
self.T2texture_variance_nondir, self.T2texture_inversediffmoment_nondir, self.T2texture_sumaverage_nondir,
self.T2texture_sumvariance_nondir, self.T2texture_sumentropy_nondir, self.T2texture_entropy_nondir,
self.T2texture_diffvariance_nondir,self.T2texture_diffentropy_nondir ]]),
columns=['texture_energy_nondir','texture_contrast_nondir','texture_correlation_nondir', 'texture_variance_nondir', 'texture_inversediffmoment_nondir', 'texture_sumaverage_nondir', 'texture_sumvariance_nondir',
'texture_sumentropy_nondir', 'texture_entropy_nondir', 'texture_diffvariance_nondir', 'texture_diffentropy_nondir'])
return self.textureT2Features
