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.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 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