def load_polydata(file_name): # get file extension (type) file_extension = file_name.split(".")[-1].lower() # todo better generic load if file_extension == "vtk": reader = vtk.vtkPolyDataReader() elif file_extension == "vtp": reader = vtk.vtkPolyDataReader() elif file_extension == "fib": reader = vtk.vtkPolyDataReader() elif file_extension == "ply": reader = vtk.vtkPLYReader() elif file_extension == "stl": reader = vtk.vtkSTLReader() elif file_extension == "xml": reader = vtk.vtkXMLPolyDataReader() elif file_extension == "obj": reader = vtk.vtkOBJReader() #try: # try to read as a normal obj # reader = vtk.vtkOBJReader() #except: # than try load a MNI obj format # reader = vtk.vtkMNIObjectReader() else: raise "polydata " + file_extension + " is not suported" reader.SetFileName(file_name) reader.Update() print file_name, " Mesh ", file_extension, "Loaded" return reader.GetOutput()
def Merge5 (): reader = vtk.vtkPolyDataReader() reader.SetFileName('test10.vtk') reader2 = vtk.vtkPolyDataReader() reader2.SetFileName('test12.vtk') reader3 = vtk.vtkPolyDataReader() reader3.SetFileName('test13.vtk') app = vtk.vtkAppendPolyData() app.AddInputConnection(reader.GetOutputPort()) tr = vtk.vtkTransform() tr.Translate(-50.916666, -1.083333, 0) tr.RotateZ(90) tp = vtk.vtkTransformPolyDataFilter() tp.SetTransform(tr) tp.SetInputConnection(reader2.GetOutputPort()) app.AddInputConnection(tp.GetOutputPort()) tr2 = vtk.vtkTransform() tr2.Translate(-50.916666, -1.083333, 0) tp2 = vtk.vtkTransformPolyDataFilter() tp2.SetTransform(tr2) tp2.SetInputConnection(reader3.GetOutputPort()) app.AddInputConnection(tp2.GetOutputPort()) return app
def test_airway_particles(): try: # Get the path to the this test so that we can reference the test data this_dir = os.path.dirname(os.path.realpath(__file__)) # Set up the inputs to AirwayParticles input_ct = this_dir + '/../../../Testing/Data/Input/airwaygauss.nrrd' input_mask = this_dir + '/../../../Testing/Data/Input/airwaygauss_mask.nrrd' #tmp_dir = this_dir + '/../../../Testing/tmp/' tmp_dir = tempfile.mkdtemp() output_particles = os.path.join(tmp_dir,'airway_particles.vtk') print tmp_dir max_scale = 6.0 live_th = 40.0 seed_th = 30.0 scale_samples = 5 down_sample_rate = 1.0 min_intensity = -1100 max_intensity = -400 # Generate the airway particles ap = AirwayParticles(input_ct, output_particles, tmp_dir, input_mask, max_scale, live_th, seed_th, scale_samples, down_sample_rate, min_intensity, max_intensity) ap.execute() # Read in the reference data set for comparison ref_reader = vtk.vtkPolyDataReader() ref_reader.SetFileName(this_dir + '/../../../Testing/Data/Input/airway_particles.vtk') ref_reader.Update() # Now read in the output data set test_reader = vtk.vtkPolyDataReader() test_reader.SetFileName(output_particles) test_reader.Update() pm = ParticleMetrics(ref_reader.GetOutput(), test_reader.GetOutput(), 'airway') assert pm.get_particles_dice() > 0.97, \ "Airway particle Dice score lower than expected" finally: #Clear particles cache ap._clean_tmp_dir=True ap.clean_tmp_dir() shutil.rmtree(tmp_dir)
def loadVtk(filename): if 'vtp' in filename: vreader = vtk.vtkXMLPolyDataReader() else: vreader = vtk.vtkPolyDataReader() vreader.SetFileName(filename) vreader.Update() polydata = vreader.GetOutput() polydata.ReleaseDataFlagOn() streamlines = [] verts = vtk_to_numpy(polydata.GetPoints().GetData()) scalars = {} pointdata = polydata.GetPointData() for si in range(pointdata.GetNumberOfArrays()): sname = pointdata.GetArrayName(si) scalars[sname] = vtk_to_numpy(pointdata.GetArray(si)) for i in range(polydata.GetNumberOfCells()): pids = polydata.GetCell(i).GetPointIds() ids = [ pids.GetId(p) for p in range(pids.GetNumberOfIds())] streamlines.append(ids) res = {'points':verts, 'values':scalars, 'streamlines':streamlines} return res
def __init__(self): self._extension_map = {} self._all_readers = [] self._reader = vtk.vtkPolyDataReader() # register file types self.registerFileTypes()
def CanReadFile(self, filename): ''' Static methods for I/O @param filename: str @rtype: unsigned int ''' if self.IsMeshExtension(os.path.splitext(filename)[1]): return self.FILE_IS_VTK if self.IsOBJExtension(os.path.splitext(filename)[1]): reader = vtk.vtkOBJReader() reader.SetFileName(filename) try: reader.Update() except: # del reader return 0 # del reader return self.FILE_IS_OBJ if not self.IsVtkExtension(os.path.splitext(filename)[1]): return 0 try: reader = vtk.vtkPolyDataReader() reader.SetFileName(filename) if reader.IsFilePolyData(): # del reader return self.FILE_IS_VTK # del reader except: pass return 0
def vtk2vtp(inputfile, outputfile): """Read a vtk polydata and save as vtp.""" reader = vtk.vtkPolyDataReader() reader.SetFileName(inputfile) reader.Update() surface = reader.GetOutput() writevtp(surface,outputfile)
def readMeshFile(filename, verbose=False): """Read mesh file. The input format is determined by file name extension. Degenerate data gets removed and polygons get split into triangles to support varios restrictive output formats.""" informat = path.splitext(options.infilename)[1].strip('.') # set reader based on filename extension if informat=='stl': reader = vtk.vtkSTLReader() elif informat=='vtk': reader = vtk.vtkPolyDataReader() elif informat=='obj': reader = vtk.vtkMNIObjectReader() #elif informat=='tag': # reader = vtk.vtkMNITagPointReader() else: raise ValueError('cannot read input format' + informat) reader.SetFileName(filename) # merge duplicate points, and/or remove unused points and/or remove degenerate cells clean = vtk.vtkCleanPolyData() clean.SetInputConnection(reader.GetOutputPort()) # convert input polygons and strips to triangles triangles = vtk.vtkTriangleFilter() triangles.SetInputConnection(clean.GetOutputPort()) #triangles = reader.GetOutputPort() # skipping above 'cleaning' doesn't work if verbose: print "read", filename return triangles
def load_streamlines_poyldata(file_name): # get file extension (type) reader = vtk.vtkPolyDataReader() reader.SetFileName(file_name) reader.Update() line_data = reader.GetOutput() return line_data
def convert_mris(input_name, output_name): """ Converts a FreeSurfer surface to VTK file format """ # convert surface to VTK format if output_name.endswith('.vtp'): temp_name = output_name[0:-1] + 'k' else: temp_name = output_name if not temp_name.endswith('.vtk'): raise RuntimeError('Output file name extension must be either .vtk or .vtp') check_call(['mris_convert', input_name, temp_name]) # get surface RAS translation out = check_output(["mris_info", input_name], stderr=STDOUT) m = re.search("c_\(ras\)\s:\s\((-?\d+\.\d+),\s(-?\d+\.\d+),\s(-?\d+\.\d+)\)", out) if m is None: raise RuntimeError('Could not find c_(ras) coordinates in mris_info output!') tx = float(m.group(1)) ty = float(m.group(2)) tz = float(m.group(3)) # transform vertex positions to scanner RAS of orig.mgz reader = vtkPolyDataReader() reader.SetFileName(temp_name) reader.Update() surface = reader.GetOutput() points = surface.GetPoints() for i in range(points.GetNumberOfPoints()): x, y, z = points.GetPoint(i) points.SetPoint(i, x + tx, y + ty, z + tz) surface.SetPoints(points) if output_name.endswith('.vtp'): writer = vtkXMLPolyDataWriter() else: writer = vtkPolyDataWriter() writer.SetFileName(output_name) writer.SetInput(surface) writer.Write() if temp_name != output_name: remove(temp_name)
def __init__(self, module_manager): """Constructor (initialiser) for the PD reader. This is almost standard code for most of the modules making use of the FilenameViewModuleMixin mixin. """ # call the constructor in the "base" ModuleBase.__init__(self, module_manager) # setup necessary VTK objects self._reader = vtk.vtkPolyDataReader() # ctor for this specific mixin FilenameViewModuleMixin.__init__( self, 'Select a filename', 'VTK data (*.vtk)|*.vtk|All files (*)|*', {'vtkPolyDataReader': self._reader}) module_utils.setup_vtk_object_progress( self, self._reader, 'Reading vtk polydata') # set up some defaults self._config.filename = '' self.sync_module_logic_with_config()
def read_polydata(filename): """Read whole-brain tractography as vtkPolyData format.""" if VERBOSE: print "Reading in data from", filename, "..." basename, extension = os.path.splitext(filename) if (extension == '.vtk'): reader = vtk.vtkPolyDataReader() elif (extension == '.vtp'): reader = vtk.vtkXMLPolyDataReader() else: print 'Cannot recognize model file format' return None reader.SetFileName(filename) reader.Update() outpd = reader.GetOutput() del reader if VERBOSE: print "Done reading in data from", filename print "Number of lines found:", outpd.GetNumberOfLines() return outpd
def readPData( filename, verbose=1): myVTK.myPrint(verbose, "*** readPData: "+filename+" ***") assert (os.path.isfile(filename)), "Wrong filename (\""+filename+"\"). Aborting." if ('vtk' in filename): pdata_reader = vtk.vtkPolyDataReader() elif ('vtp' in filename): pdata_reader = vtk.vtkXMLPolyDataReader() else: assert 0, "File must be .vtk or .vtp. Aborting." pdata_reader.SetFileName(filename) pdata_reader.Update() pdata = pdata_reader.GetOutput() myVTK.myPrint(verbose-1, "n_points = "+str(pdata.GetNumberOfPoints())) myVTK.myPrint(verbose-1, "n_verts = "+str(pdata.GetNumberOfVerts())) myVTK.myPrint(verbose-1, "n_lines = "+str(pdata.GetNumberOfLines())) myVTK.myPrint(verbose-1, "n_polys = "+str(pdata.GetNumberOfPolys())) myVTK.myPrint(verbose-1, "n_strips = "+str(pdata.GetNumberOfStrips())) return pdata
def mris2vtk(input_name, output_name): """ Converts a FreeSurfer surface to VTK file format """ # convert surface to VTK format check_call(['mris_convert', input_name, output_name]) # get surface RAS translation out = check_output(["mris_info", input_name], stderr=STDOUT) m = re.search("c_\(ras\)\s:\s\((-?\d+\.\d+),\s(-?\d+\.\d+),\s(-?\d+\.\d+)\)", out) if m is None: raise RuntimeError('Could not find c_(ras) coordinates in mris_info output!') tx = float(m.group(1)) ty = float(m.group(2)) tz = float(m.group(3)) # transform vertex positions to scanner RAS of orig.mgz reader = vtkPolyDataReader() reader.SetFileName(output_name) reader.Update() surface = reader.GetOutput() points = surface.GetPoints() for i in range(points.GetNumberOfPoints()): x, y, z = points.GetPoint(i) points.SetPoint(i, x + tx, y + ty, z + tz) surface.SetPoints(points) writer = vtkPolyDataWriter() writer.SetFileName(output_name) writer.SetInput(surface) writer.Write()
def vtk2objfcn(vtkfile,objfile,decimFactor): import vtk import random from math import * import numpy obj = open(objfile,'w') reader = vtk.vtkPolyDataReader() reader.SetFileName(vtkfile) reader.Update() out = reader.GetOutput() verttotal = 0 #print out.GetNumberOfLines() for i in xrange(0,out.GetNumberOfLines()-1,decimFactor): bounds = out.GetCell(i).GetBounds() for j in range(out.GetCell(i).GetNumberOfPoints()): voutstr = "v %7.3f %7.3f %7.3f\n" % (out.GetPoint(out.GetCell(i).GetPointId(j))[0]-90.,out.GetPoint(out.GetCell(i).GetPointId(j))[1]-126.,out.GetPoint(out.GetCell(i).GetPointId(j))[2]-72.) obj.write(voutstr) loutstr = 'l' for k in range(out.GetCell(i).GetNumberOfPoints()-1): loutstr += ' %7d' % (k+1+verttotal) loutstr += '\n' obj.write(loutstr) verttotal += out.GetCell(i).GetNumberOfPoints() obj.close() print('Done!')
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkPolyDataReader(), 'Reading vtkPolyData.', (), ('vtkPolyData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def PolyDataReader(self, currentElement): reader = vtk.vtkPolyDataReader() try: reader.SetFileName(os.path.join(self.basedir, currentElement.get('SetFileName'))) except: self.logger.error(' .. <PolyDataReader> failed to SetFileName') return reader
def read_vtkPolyData(filename): r''' Reads a VTKPolyData file and outputs a tracts/tracts_data pair Parameters ---------- filename : str VTKPolyData filename Returns ------- tracts : list of float array N_ix3 Each element of the list is a tract represented as point array, the length of the i-th tract is N_i tract_data : dict of <data name>= list of float array of N_ixM Each element in the list corresponds to a tract, N_i is the length of the i-th tract and M is the number of components of that data type. ''' if filename.endswith('xml') or filename.endswith('vtp'): polydata_reader = vtk.vtkXMLPolyDataReader() else: polydata_reader = vtk.vtkPolyDataReader() polydata_reader.SetFileName(filename) polydata_reader.Update() polydata = polydata_reader.GetOutput() return vtkPolyData_to_tracts(polydata)
def get_num_fibers(filename): #reader = vtk.vtkDataSetReader() reader = vtk.vtkPolyDataReader() reader.SetFileName(filename) reader.Update() nlines = reader.GetOutput().GetNumberOfLines() return nlines
def MeshToVolume(Filename): reader = vtk.vtkPolyDataReader() pol2stenc = vtk.vtkPolyDataToImageStencil() imgstenc = vtk.vtkImageStencil() reader.SetFileName(os.path.join(subjects_dir,subject_dir,Filename)) reader.Update() ref_mesh = reader.GetOutput() ref_volume = vtk.vtkImageData() # define output volume dimension spacing = (0.5,0.5,0.5) ref_volume.SetSpacing(spacing) bounds = ref_mesh.GetBounds() dim = [math.ceil(bounds[ii*2+1] - bounds[ii*2] / spacing[ii]) for ii in range(0,3)] origin = [bounds[ii*2] + spacing[ii] / 2 for ii in range(0,3)] extent = (0,dim[0] - 1,0,dim[1] -1 ,0,dim[2]-1) ref_volume.SetOrigin(origin) ref_volume.SetDimensions(dim) ref_volume.SetExtent(extent) ref_volume.SetScalarTypeToUnsignedChar() ref_volume.AllocateScalars() # Fill the image with white voxels for i in range(0,ref_volume.GetNumberOfPoints()): ref_volume.GetPointData().GetScalars().SetTuple1(i,255) print ref_volume.GetNumberOfPoints() pol2stenc.SetInput(ref_mesh) pol2stenc.SetOutputOrigin(origin) pol2stenc.SetOutputSpacing(spacing) pol2stenc.SetOutputWholeExtent(ref_volume.GetExtent()) pol2stenc.Update() imgstenc.SetInput(ref_volume) imgstenc.SetStencil(pol2stenc.GetOutput()) imgstenc.ReverseStencilOff() imgstenc.SetBackgroundValue(0) imgstenc.Update() tmp = imgstenc.GetOutput() writer = vtk.vtkImageWriter() writer.SetFileName('prova.nii.gz') writer.SetInput(ref_volume) writer.Update() out = v2n(tmp.GetPointData().GetScalars()) return np.reshape(out, (dim[0],dim[1],dim[2]))
def ReadVTKSurfaceFile(self): if (self.InputFileName == ''): self.PrintError('Error: no InputFileName.') self.PrintLog('Reading VTK surface file.') reader = vtk.vtkPolyDataReader() reader.SetFileName(self.InputFileName) reader.Update() self.Surface = reader.GetOutput()
def getReader(self, model_type=None): self.model_type = model_type if self.model_type == 'UnstructuredGrid': return vtk.vtkUnstructuredGridReader() elif self.model_type == 'PolyData': return vtk.vtkPolyDataReader() else: raise ValueError("model type informed is unknow...")
def readVTK(filename): #read the vtk file with an unstructured grid reader = vtk.vtkPolyDataReader() reader.SetFileName(filename) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() return reader
def read_vtkpd(filename): reader = vtk.vtkPolyDataReader() reader.SetFileName(filename) reader.Update() pd = vtk.vtkPolyData() pd.ShallowCopy(reader.GetOutput()) return pd
def Merge3 (): reader = vtk.vtkPolyDataReader() reader.SetFileName('test0.vtk') reader2 = vtk.vtkPolyDataReader() reader2.SetFileName('test1.vtk') reader3 = vtk.vtkPolyDataReader() reader3.SetFileName('test2.vtk') reader4 = vtk.vtkPolyDataReader() reader4.SetFileName('test3.vtk') app = vtk.vtkAppendPolyData() app.AddInputConnection(reader.GetOutputPort()) tr = vtk.vtkTransform() tr.RotateZ(90) tp = vtk.vtkTransformPolyDataFilter() tp.SetTransform(tr) tp.SetInputConnection(reader2.GetOutputPort()) app.AddInputConnection(tp.GetOutputPort()) tr2 = vtk.vtkTransform() tr2.Translate(43.333333, 3.25, 0) tp2 = vtk.vtkTransformPolyDataFilter() tp2.SetTransform(tr2) tp2.SetInputConnection(reader3.GetOutputPort()) app.AddInputConnection(tp2.GetOutputPort()) tr3 = vtk.vtkTransform() tr3.Translate(43.333333, 3.25, 0) tr3.RotateZ(90) tp3 = vtk.vtkTransformPolyDataFilter() tp3.SetTransform(tr3) tp3.SetInputConnection(reader4.GetOutputPort()) app.AddInputConnection(tp3.GetOutputPort()) return app
def read_paths(fold): print fold fname = fold+'/pathsq.vtk' print fname npArray = fold+'/pathsq' # fname = '/home/florian/MEGAsync/calcul/LCS_tractor/data/paths.vtk' if os.path.isfile(npArray + '.npy'): print 'loading ', npArray t0 = time.time() xx = np.load(npArray + '.npy') print 'already existing array loaded in', time.time() - t0, 's' else: reader = vtk.vtkPolyDataReader() reader.SetFileName(fname) reader.Update() data = reader.GetOutput() ll = data.GetLines() n_pts = ll.GetSize() # nb of points n_lines = ll.GetNumberOfCells() # nb of lines idList = vtk.vtkIdList() idList.SetNumberOfIds(n_lines) print idList idList.SetId(0, 0) abscissaArray = vtk.vtkFloatArray() traj = [] # list of pos vel = [] # list of vel vort = [] # list of vort k = 0 for i in xrange(n_lines): cell = data.GetCell(i) abscissa = 0.0 previousPoint = None if i % np.int(n_lines / 100) == 0: print k, '% read' k += 1 llength = cell.GetNumberOfPoints() pos = [] # np.empty([llength, 3]) # pos, u, vort u = [] # np.empty([llength, 3]) # pos, u, vort vorti = [] # np.empty([llength]) # pos, u, vort for j in range(llength): pointId = cell.GetPointId(j) pos.append(data.GetPoint(pointId)) u.append(vtk_to_numpy(data.GetPointData().GetArray("U"))[pointId]) vorti.append(vtk_to_numpy(data.GetPointData().GetArray("Vorticity"))[pointId]) traj.append(pos) vel.append(u) vort.append(vorti) # print traj # x = [traj, vel, vort] xx = np.array([traj,vel,vort]) np.save(npArray, xx) print 'shit\'s read' print 'end of path lines reading' return xx
def readVTKPD(fn): ''' reads a vtk polydata object from a file ''' pd_reader = vtk.vtkPolyDataReader() pd_reader.SetFileName(fn) pd_reader.Update() pd = pd_reader.GetOutput() return pd
def __init__(self, dataDir = 'data', streamFile = 'stream.vtk'): """ Read the initial streamlines. call signature: readStream(dataDir = 'data', streamFile = 'stream.vtk') Keyword arguments: *dataDir*: Data directory. *streamFile*: Read the initial streamline from this file. """ # load the data reader = vtk.vtkPolyDataReader() reader.SetFileName(dataDir + '/' + streamFile) reader.Update() output = reader.GetOutput() # get the fields field = output.GetFieldData() nArrays = field.GetNumberOfArrays() class params: pass p = params() for i in range(nArrays): arrayName = field.GetArrayName(i) if any(arrayName == np.array(['l', 'sl'])): setattr(self, arrayName, VN.vtk_to_numpy(field.GetArray(arrayName))) elif any(arrayName == np.array(['hMin', 'hMax', 'lMax', 'tol', 'iterMax', 'nt'])): setattr(self, arrayName, VN.vtk_to_numpy(field.GetArray(arrayName))[0]) else: # change this if parameters can have more than one entry setattr(p, arrayName, VN.vtk_to_numpy(field.GetArray(arrayName))[0]) setattr(self, 'p', p) # get the points points = output.GetPoints() pointsData = points.GetData() data = VN.vtk_to_numpy(pointsData) #data = np.swapaxes(data, 0, 1) print self.nt print self.sl print data.shape tracers = np.zeros([self.nt, np.max(self.sl), 3], dtype = data.dtype) sl = 0 for i in range(self.nt): #if (i > 0): #sl = self.sl[i-1] #else: #sl = 0 print sl, self.sl[i] tracers[i,:self.sl[i],:] = data[sl:sl+self.sl[i],:] sl += self.sl[i] setattr(self, 'tracers', tracers)
def execute(self): for kk,file_name in enumerate(self.file_list): reader=vtk.vtkPolyDataReader() reader.SetFileName(file_name) reader.Update() poly = self.compute_radius(reader.GetOutput(),spacing_list[kk]) if self.use_field_data == False: poly.GetPointData().\ SetNormals(poly.GetPointData().\ GetArray(self.normal_map[self.feature_type])) else: poly.GetPointData().\ SetNormals(poly.GetFieldData().\ GetArray(self.normal_map[self.feature_type])) glypher=self.create_glyphs(poly) if len(self.color_list) <= kk: color=[] else: color=self.color_list[kk] if len(self.opacity_list) <= kk: opacity=1 else: opacity=self.opacity_list[kk] self.create_actor(glypher,color=color,opacity=opacity) if len(self.lung)>0: reader=vtk.vtkPolyDataReader() reader.SetFileName(self.lung) reader.Update() tt=vtk.vtkTransform() tt.Identity() tt.GetMatrix().SetElement(0,0,-1) tt.GetMatrix().SetElement(1,1,-1) tf=vtk.vtkTransformPolyDataFilter() tf.SetTransform(tt) tf.SetInput(reader.GetOutput()) tf.SetTransform(tt) self.create_actor(tf,0.1,color=[0.8,0.4,0.01]) self.add_color_bar() self.render()
def load_velocity(filename): import os if not os.path.exists(filename): return None from numpy import zeros from vtk import vtkPolyDataReader, vtkCellDataToPointData reader = vtkPolyDataReader() reader.SetFileName(filename) reader.ReadAllVectorsOn() reader.Update() data = reader.GetOutput() # Extracting triangulation information triangles = data.GetPolys().GetData() points = data.GetPoints() # Mapping data: cell -> point mapper = vtkCellDataToPointData() mapper.AddInputData(data) mapper.Update() mapped_data = mapper.GetOutput() # Extracting interpolate point data udata = mapped_data.GetPointData().GetArray(0) ntri = triangles.GetNumberOfTuples()/4 npts = points.GetNumberOfPoints() nvls = udata.GetNumberOfTuples() tri = zeros((ntri, 3)) x = zeros(npts) y = zeros(npts) ux = zeros(nvls) uy = zeros(nvls) for i in xrange(0, ntri): tri[i, 0] = triangles.GetTuple(4*i + 1)[0] tri[i, 1] = triangles.GetTuple(4*i + 2)[0] tri[i, 2] = triangles.GetTuple(4*i + 3)[0] for i in xrange(npts): pt = points.GetPoint(i) x[i] = pt[0] y[i] = pt[1] for i in xrange(0, nvls): U = udata.GetTuple(i) ux[i] = U[0] uy[i] = U[1] return (x, y, tri, ux, uy)
def load_vtk(filename): reader = vtk.vtkPolyDataReader() reader.SetFileName(filename) reader.Update() return reader.GetOutput()
def onInputShapesDirectoryChanged(self): inputShapesDirectory = self.shapeInputDirectory.directory.encode('utf-8') # Set this directory as the default output directory as well self.outputDirectory.directory = str(inputShapesDirectory) row = 0 allShapeSigmaWs = [] for curFile in sorted(os.listdir(inputShapesDirectory)): if not (curFile.endswith(".vtk")): continue self.tableWidget_inputShapeParameters.setRowCount(row + 1) # Read the vtk file to set a default kernel width shapeFile = '%s/%s' %(inputShapesDirectory, curFile) polyReader = vtk.vtkPolyDataReader() polyReader.SetFileName(shapeFile) polyReader.Update() shape = polyReader.GetOutput() shapeBounds = shape.GetBounds() xRange = shapeBounds[1] - shapeBounds[0] yRange = shapeBounds[3] - shapeBounds[2] zRange = shapeBounds[5] - shapeBounds[4] smallestRange = min(xRange, yRange, zRange) initSigmaW = int(smallestRange*0.50) allShapeSigmaWs.append(initSigmaW) # Try to extract the time point as a suffix curTimePoint = 0.0 numsInFilename = re.findall(r'[-+]?\d*\.\d+|\d+', curFile) if (len(numsInFilename) > 0): curTimePoint = numsInFilename[-1] # We assume the final number in the filename is the time point # Column 0: #rootname = os.path.basename(curFile).split(".")[0] rootname = os.path.splitext(os.path.basename(curFile))[0] labelVTKFile = qt.QLabel(rootname) labelVTKFile.setAlignment(0x84) self.tableWidget_inputShapeParameters.setCellWidget(row, 0, labelVTKFile) # Column 1-2-3-4: (Time Point, Sigma W, Tris, Weight) # We might want to consider using different UI elements for Time Point and Kernel Width that do not have explicit ranges for column in range(1,5): widget = qt.QWidget() layout = qt.QHBoxLayout(widget) # If this is the 'Shape Index' column we limit this to an integer if (column == 3): spinBox = qt.QSpinBox() spinBox.setRange(0,1000) spinBox.value = 0 # The rest of the columns are doubles else: spinBox = qt.QDoubleSpinBox() if column == 1: # Time Point spinBox.value = float(curTimePoint) spinBox.connect('valueChanged(double)', self.onSetTimePointRange) spinBox.setRange(-1e10, 1e10) if column == 2: # Kernel Width spinBox.setRange(0.001, 1e10) spinBox.value = initSigmaW if column == 4: # Weight spinBox.value = 1 spinBox.setRange(0,1) spinBox.setSingleStep(0.1); layout.addWidget(spinBox) layout.setAlignment(0x84) layout.setContentsMargins(0, 0, 0, 0) widget.setLayout(layout) self.tableWidget_inputShapeParameters.setCellWidget(row, column, widget) row = row + 1 # We can set a default for deformation kernel width as smallest shape kernel self.defKernelWidth.value = min(allShapeSigmaWs) # Update the time range (if time point suffixes provided initialization) self.onSetTimePointRange()
def mitograph_extended_analysis(directory, cellID, genotype, timespace, switchpoint, refeed): if os.path.isdir(directory) != 1: raise Exception( "Error: Input directory is not a valid directory name.") # collect a list of all surface reconstructions to be analyzed directory_contents = sorted(os.listdir(directory)) surfaces = [] for file in directory_contents: if file.endswith('surface.vtk'): surfaces += [file] # specifies the volume threshold used to distinguish mitochondria # from cellular debris, hot pixels, and other non-mitochondrial noise # units are cubed microns # number of objects falling below this threshold in each cell is recorded minvol = 0.0250 # specifies a minimum size to be counted as a potential artifact # number of potential artifacts will be used downstream to identify segmentation artifacts on a whole-cell level minartifact = 0.045 # specifies a maximum volume threshold used to distinguish cells # from massive, overly-segmented background noise maxvol = 10000 with open((directory + '/' + os.path.basename(directory) + '_morphological_summaries_by_mitochondrion.txt'), 'wb') as csv_ind: ind_csv_writer = csv.writer(csv_ind, csv.excel_tab) ind_csv_writer.writerow(['mitograph_extended_analysis_v11.py']) ind_csv_writer.writerow(['directory: ' + directory]) ind_csv_writer.writerow( ['minimum volume threshold for mitochondrion: ' + str(minvol)]) ind_csv_writer.writerow( ['maximum volume threshold for cell: ' + str(maxvol)]) ind_csv_writer.writerow('') ind_csv_writer.writerow([ 'image path', 'cellID', 'genotype', 'time', 'mitochondrion', 'volume (um^3)', 'surface area (um^2)', 'normalized shape index', 'sphericity', 'compactedness' ]) csv_ind.close() with open((directory + '/' + os.path.basename(directory) + '_morphological_summaries_by_whole_cell.txt'), 'wb') as csv_totals: total_csv_writer = csv.writer(csv_totals, csv.excel_tab) total_csv_writer.writerow(['mitograph_extended_analysis_v11.py']) total_csv_writer.writerow(['directory: ' + directory]) total_csv_writer.writerow( ['minimum volume threshold for mitochondrion: ' + str(minvol)]) total_csv_writer.writerow( ['maximum volume threshold for cell: ' + str(maxvol)]) total_csv_writer.writerow('') total_csv_writer.writerow([ 'image path', 'cellID', 'genotype', 'time', 'total number of mitochondria', 'total mitochondrial volume (um^3)', 'total mitochondrial surface area (um^2)', 'total normalized shape index', 'total sphericity', 'total length (um)', 'average volume of mitochondrion (um^3)', 'average surface area of mitochondrion (um^2)', 'average NSI of mitochondrion', 'average sphericity of mitochondrion', 'volume-weighted average surface area of mitochondria (um^2)', 'volume-weighted average NSI of mitochondrion', 'volume-weighted average sphericity of mitochondrion', 'average compactedness of mitochondrion', 'volume-weighted average compactedness of mitochondrion', 'average width (um)', 'std width (um)', 'number of endpoints', 'artifacts' ]) csv_totals.close() for surface in surfaces: surface_and_path = directory + '/' + surface stagename = surface.split('_')[-5] stagepos = (stagename[1:]).zfill(2) # read in contents of .vtk file as polydata reader = vtk.vtkPolyDataReader() filename = '\'' + surface_and_path + '\'' print('processing file: ' + filename) reader.SetFileName(surface_and_path) reader.Update() # determine the time, in minutes # times prior to glucose withdrawal are expressed as a function of time until withdrawal # e.g., -15 minutes # times following glucose return are recorded as strings preceded by r # e.g., 'r60' minutes # remember that time here is 1-indexed, making this work counterintuitively # extract timepoint number from file name timepos = int(filename[-25:-22]) # if the timepoint, converted into minutes since initiation, # is earlier than glucose return, then calculate time as the difference # between the timepoint number and timepoint of glucose withdrawal, times the time interval if (((timepos - 1) * timespace) < (refeed * 60)) or refeed == 'NA': time = (timepos - 1 - (switchpoint * 60 / timespace)) * timespace # if post-refeeding: # calculate time as the difference between the timepoint number and timepoint of # glucose refeeding, times the time interval else: time = 'r' + str( (timepos - 1 - (refeed * 60 / timespace)) * timespace) # convert to triangle mesh triangulated = vtk.vtkTriangleFilter() triangulated.SetInputConnection(reader.GetOutputPort()) triangulated.Update() # test whether the entire cell exceeds the maximum volume ceiling indicating background segmentation # if so, proceed directly to the next iteration of the loop on the next surface massvol_test = vtk.vtkMassProperties() massvol_test.SetInputConnection(triangulated.GetOutputPort()) massvol_test.Update() test_vol = massvol_test.GetVolume() if test_vol >= maxvol: continue else: # apply connectivity filter; extract number of distinct mitochondria connect_filter = vtk.vtkPolyDataConnectivityFilter() connect_filter.SetInputConnection(triangulated.GetOutputPort()) connect_filter.Update() mitochondria = connect_filter.GetNumberOfExtractedRegions() # initialize dictionaries containing connectivity filter output; massproperties; # and shape descriptives for individual mitochondria, to be keyed by region number mitochonnectdict = {} masspropdict = {} volumes = {} surface_areas = {} NSIs = {} sphericity = {} compacteds = {} avgvolume = 0 avgSA = 0 avgNSI = 0 avgsphericity = 0 avgcompacted = 0 weighted_avgSA = 0 weighted_avgNSI = 0 weighted_avgsphericity = 0 weighted_avgcompacted = 0 total_volume = 0 total_length = 'NA' total_surface_area = 0 avg_width = 'NA' std_width = 'NA' endpoints = 'NA' # initializes a count of segmented objects that meet a size threshold requirement # as a noise elimination step to remove non-mitochondrial junk threshmitos = 0 # searches for mitograph summary file # if it exists: find the network length associated with the cell skeleton_and_path = directory + '/summary.txt' if os.path.isfile(skeleton_and_path): df = pd.read_csv(skeleton_and_path, skiprows=8, sep='\t') skelname = '///' + surface[:-12] total_length = float( df[df.Image.str.endswith(skelname)]['total_length_(um)']) avg_width = float( df[df.Image.str.endswith(skelname)]['avg_width_(um)']) std_width = float( df[df.Image.str.endswith(skelname)]['std_width_(um)']) endpoints = float( df[df.Image.str.endswith(skelname)]['#Endpoints']) artifacts = 0 for i in range(mitochondria): # cycle through individual mitochondria identified by connectivity filter # partition via multiple connectivity filters # save filters in a dictionary keyed to each connectivity region key = i mitochonnectdict[key] = vtk.vtkPolyDataConnectivityFilter() mitochonnectdict[key].SetInputConnection( triangulated.GetOutputPort()) mitochonnectdict[key].Update() mitochonnectdict[key].SetExtractionModeToSpecifiedRegions() mitochonnectdict[key].AddSpecifiedRegion(i) mitochonnectdict[key].Update() # create a vtkmassproperties class for each separate connectivity partition # save each instance in a dictionary keyed to each connectivity region masspropdict[key] = vtk.vtkMassProperties() masspropdict[key].SetInputConnection( mitochonnectdict[key].GetOutputPort()) masspropdict[key].Update() # calculate the volume of the mitochondrion testvol = masspropdict[key].GetVolume() # if it falls below the artifact threshold: record as an artifact if testvol <= minartifact: artifacts += 1 # test whether the volume of the mitochondrion surpasses the threshold size # if yes: proceed with morphological analysis and iterate real mitochondrial count # if no: break for loop and proceed to next cell if testvol <= minvol: continue else: # extract volume, surface area, and normalized shape index from massproperties class t = threshmitos volumes[t] = masspropdict[key].GetVolume() surface_areas[t] = masspropdict[key].GetSurfaceArea() NSIs[t] = masspropdict[key].GetNormalizedShapeIndex() compacteds[t] = np.power(surface_areas[t], 1.5) / float( volumes[t]) total_volume += volumes[t] avgvolume += volumes[t] avgcompacted += compacteds[t] total_surface_area += surface_areas[t] avgSA += surface_areas[t] avgNSI += NSIs[t] # calculate sphericity sphericity[t] = (np.power(np.pi, (1.0 / 3.0)) * np.power( (6 * volumes[t]), (2.0 / 3.0))) / float(surface_areas[t]) avgsphericity += sphericity[t] # add the product of volume and surface area, normalized shape index, or sphericity # to a running calculation of averages of shape parameters weighted by volume weighted_avgSA += (volumes[t] * surface_areas[t]) weighted_avgNSI += (volumes[t] * NSIs[t]) weighted_avgsphericity += (volumes[t] * sphericity[t]) weighted_avgcompacted += (volumes[t] * compacteds[t]) # add this mitochondrion to the count of confirmed mitochondrial structures threshmitos += 1 # write measurements of individual mitochondria to a csv file with open((directory + '/' + os.path.basename(directory) + '_morphological_summaries_by_mitochondrion.txt'), 'a') as csv_ind: ind_csv_writer = csv.writer(csv_ind, csv.excel_tab) for j in range(threshmitos): ind_csv_writer.writerow([ surface[:-12], (cellID + stagepos + filename[-16:-13]), genotype, time, (j + 1), volumes[j], surface_areas[j], NSIs[j], sphericity[j], compacteds[j] ]) csv_ind.close() # perform massproperties calculations for bulk mitochondrial content in cell # note that total volume and surface area were calculated previously from thresholded mitochondrial content total_massproperties = vtk.vtkMassProperties() total_massproperties.SetInputConnection( triangulated.GetOutputPort()) total_massproperties.Update() #total_volume = total_massproperties.GetVolume() #total_surface_area = total_massproperties.GetSurfaceArea() total_NSI = total_massproperties.GetNormalizedShapeIndex() total_sphericity = (np.power(np.pi, (1.0 / 3.0)) * np.power( (6 * total_volume), (2.0 / 3.0))) / float(total_surface_area) # get cell-averaged data avgvolume = avgvolume / float(threshmitos) avgSA = avgSA / float(threshmitos) avgNSI = avgNSI / float(threshmitos) avgsphericity = avgsphericity / float(threshmitos) # get cell-averaged data weighted by mitochondrion volume if total_volume > 0: weighted_avgSA = weighted_avgSA / float(total_volume) weighted_avgNSI = weighted_avgNSI / float(total_volume) weighted_avgsphericity = weighted_avgsphericity / float( total_volume) weighted_avgcompacted = weighted_avgcompacted / float( total_volume) else: weighted_avgSA = 0 weighted_avgNSI = 0 weighted_avgsphericity = 0 weighted_avgcompacted = 0 # write cell-total and cell-averaged output to a second csv file with open((directory + '/' + os.path.basename(directory) + '_morphological_summaries_by_whole_cell.txt'), 'a') as csv_totals: total_csv_writer = csv.writer(csv_totals, csv.excel_tab) total_csv_writer.writerow([ surface[:-12], (cellID + stagepos + filename[-16:-13]), genotype, time, threshmitos, total_volume, total_surface_area, total_NSI, total_sphericity, total_length, avgvolume, avgSA, avgNSI, avgsphericity, weighted_avgSA, weighted_avgNSI, weighted_avgsphericity, avgcompacted, weighted_avgcompacted, avg_width, std_width, endpoints, artifacts ]) csv_totals.close() print('Analysis complete!')
#!/usr/bin/env python import sys import vtk if (len(sys.argv) == 1): print "This script should at least contain 1 argument.\nUsage: vtkpython vtktovtp.py $inputFile" sys.exit() path = sys.argv[1] opath = "/tmp/tmp.vtp" if len(sys.argv) > 2: opath = sys.argv[3] reader = vtk.vtkPolyDataReader() reader.SetFileName(path) reader.Update() input = reader.GetOutput() nPoints = input.GetNumberOfPoints() nCells = input.GetNumberOfCells() print "Input Mesh \nPoints: " + str(nPoints) + "\nCells: " + str(nCells) writer = vtk.vtkXMLPolyDataWriter() writer.SetInput(input) writer.SetFileName(opath) writer.SetDataModeToAscii() writer.Write()
def testDeciFranFace(self): # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren2 = vtk.vtkRenderer() ren3 = vtk.vtkRenderer() ren4 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.AddRenderer(ren2) renWin.AddRenderer(ren3) renWin.AddRenderer(ren4) pnm1 = vtk.vtkPNGReader() pnm1.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.png") atext = vtk.vtkTexture() atext.SetInputConnection(pnm1.GetOutputPort()) atext.InterpolateOn() # create a cyberware source # fran = vtk.vtkPolyDataReader() fran.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.vtk") # Create a table of decimation conditions # boundaryVertexDeletion = ["On", "Off"] accumulates = ["On", "Off"] deci = dict() mapper = dict() actor = dict() for topology in boundaryVertexDeletion: for accumulate in accumulates: idx = topology + accumulate deci.update({idx: vtk.vtkDecimatePro()}) deci[idx].SetInputConnection(fran.GetOutputPort()) deci[idx].SetTargetReduction(.95) if topology == "On": deci[idx].PreserveTopologyOn() elif topology == "Off": deci[idx].PreserveTopologyOff() if accumulate == "On": deci[idx].AccumulateErrorOn() elif accumulate == "Off": deci[idx].AccumulateErrorOff() mapper.update({idx: vtk.vtkPolyDataMapper()}) mapper[idx].SetInputConnection(deci[idx].GetOutputPort()) actor.update({idx: vtk.vtkActor()}) actor[idx].SetMapper(mapper[idx]) actor[idx].SetTexture(atext) # Add the actors to the renderer, set the background and size # ren1.SetViewport(0, .5, .5, 1) ren2.SetViewport(.5, .5, 1, 1) ren3.SetViewport(0, 0, .5, .5) ren4.SetViewport(.5, 0, 1, .5) ren1.AddActor(actor["OnOn"]) ren2.AddActor(actor["OnOff"]) ren3.AddActor(actor["OffOn"]) ren4.AddActor(actor["OffOff"]) camera = vtk.vtkCamera() ren1.SetActiveCamera(camera) ren2.SetActiveCamera(camera) ren3.SetActiveCamera(camera) ren4.SetActiveCamera(camera) ren1.GetActiveCamera().SetPosition(0.314753, -0.0699988, -0.264225) ren1.GetActiveCamera().SetFocalPoint(0.00188636, -0.136847, -5.84226e-09) ren1.GetActiveCamera().SetViewAngle(30) ren1.GetActiveCamera().SetViewUp(0, 1, 0) ren1.ResetCameraClippingRange() ren2.ResetCameraClippingRange() ren3.ResetCameraClippingRange() ren4.ResetCameraClippingRange() ren1.SetBackground(1, 1, 1) ren2.SetBackground(1, 1, 1) ren3.SetBackground(1, 1, 1) ren4.SetBackground(1, 1, 1) renWin.SetSize(500, 500) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "deciFranFace.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
age_i = sorted_ageArr[idx] label_i = sorted_labelArr[idx] subjFolderPath = dataFolderPath + "PHD-AS1-" + subj_i + "/" + label_i + "/surfaces/decimated_aligned/" Haus_EGReg_i = 0 Haus_LReg_i = 0 Haus_DiffeoReg_i = 0 for a in range(len(anatomy_list)): anatomy = anatomy_list[a] # Input Paths inputPath_i = subjFolderPath + "cmrep_" + anatomy + "/mesh/def3_target.vtk" inputReader = vtk.vtkPolyDataReader() inputReader.SetFileName(inputPath_i) inputReader.Update() input_i = inputReader.GetOutput() # Estimated Paths EGRegPath_i = EGRegFolderPath + "CMRep_EGReg_Recon_" + anatomy + "_Subjects_" + subj_i + "_t_" + str( age_i) + ".vtk" EGReg_reader = vtk.vtkPolyDataReader() EGReg_reader.SetFileName(EGRegPath_i) EGReg_reader.Update() EGReg_est = EGReg_reader.GetOutput() LRegPath_i = PC_LRegFolderPath + "Surface_ShapeWork_CTRL_Complex_" + anatomy + "_LinearModel_" + subj_i + "_" + str(
def run_script(args): """ Run the commandline script for MFSDA. """ """+++++++++++++++++++++++++++++++++++""" """Step 1. load dataset """ print("loading data ......") print("+++++++Read the surface shape data+++++++") fh = open(args.shapeData, 'rU') y_design = [] nshape = 0 numpoints = -1 header = fh.readline() toks = header.split(sep=',') covs_tmp = [] for line in fh.readlines(): toks = line.strip().split(sep=',') # Read VTK file vtkfilename = toks[0].rstrip() print("Reading {}".format(vtkfilename)) reader = vtk.vtkPolyDataReader() reader.SetFileName(vtkfilename) reader.Update() shapedata = reader.GetOutput() shapedatapoints = shapedata.GetPoints() y_design.append([]) if numpoints == -1: numpoints = shapedatapoints.GetNumberOfPoints() if numpoints != shapedatapoints.GetNumberOfPoints(): print( "WARNING! The number of points is not the same for the shape:", vtkfilename) for i in range(shapedatapoints.GetNumberOfPoints()): p = shapedatapoints.GetPoint(i) y_design[nshape].append(p) nshape += 1 # Build covariate matrix covs_tmp.append(toks[1:]) y_design = np.array(y_design) y_design.reshape(nshape, numpoints, 3) y_design = np.array(y_design) y_design.reshape(nshape, numpoints, 3) print("The dimension of shape matrix is " + str(y_design.shape)) print("+++++++Read the sphere coordinate data+++++++") print("Reading", args.coordData) reader = vtk.vtkPolyDataReader() reader.SetFileName(args.coordData) reader.Update() coordData = reader.GetOutput() shapedatapoints = coordData.GetPoints() if numpoints != shapedatapoints.GetNumberOfPoints(): print( "WARNING! The template does not have the same number of points as the shapes" ) coord_mat = [] for i in range(shapedatapoints.GetNumberOfPoints()): p = shapedatapoints.GetPoint(i) coord_mat.append(p) coord_mat = np.array(coord_mat) # Set up design matrix design_data = np.array(covs_tmp, dtype=float) # read the covariate type var_type = getCovariateType(design_data) """+++++++++++++++++++++++++++++++++++""" """Step 2. Statistical analysis: including (1) smoothing and (2) hypothesis testing""" gpvals, lpvals_fdr, clu_pvals, efit_beta, efity_design, efit_eta = mfsda.run_stats( y_design, coord_mat, design_data, var_type) """+++++++++++++++++++++++++++++++++++""" """Step3. Save all the results""" if not os.path.exists(args.outputDir): os.makedirs(args.outputDir) pvalues = {} pvalues['Gpvals'] = gpvals.tolist() pvalues['clu_pvals'] = clu_pvals.tolist() pvalues['Lpvals_fdr'] = lpvals_fdr.tolist() with open(os.path.join(args.outputDir, 'pvalues.json'), 'w') as outfile: json.dump(pvalues, outfile) efit = {} efit['efitBetas'] = efit_beta.tolist() efit['efitYdesign'] = efity_design.tolist() efit['efitEtas'] = efit_eta.tolist() with open(os.path.join(args.outputDir, 'efit.json'), 'w') as outfile: json.dump(efit, outfile)
def readvtk(filename): """Read VTK file""" reader = vtk.vtkPolyDataReader() reader.SetFileName(filename) reader.Update() return reader.GetOutput()
def SelectCuttingPlane(input_file): ## Get vtk format file_format = input_file.split(".")[-1] input_vtk = input_file.replace(file_format, "vtk") if file_format == "nrrd": print("\nCreating mesh from: " + input_file) print("\nSaving as: " + input_vtk) xml_filename = input_file.rsplit(os.sep, 1)[0] + "/cutting_plane_nrrd2vtk.xml" create_meshfromDT_xml(xml_filename, input_file, input_vtk) execCommand = ["MeshFromDistanceTransforms", xml_filename] subprocess.check_call(execCommand) print("Calling cmd:\n" + " ".join(execCommand)) elif file_format == "ply": execCommand = ["ply2vtk", input_file, input_vtk] subprocess.check_call(execCommand) print("Calling cmd:\n" + " ".join(execCommand)) elif file_format == "stl": execCommand = ["stl2vtk", input_file, input_vtk] subprocess.check_call(execCommand) print("Calling cmd:\n" + " ".join(execCommand)) elif file_format == "vtk": pass else: print("Error, file format unrecognized: " + input_file) ## VTK interactive window print( '\n Use the interactive window to select your cutting plane. When you are content with your selection, simply close the window. \n' ) # read data from file # read data from file reader = vtk.vtkPolyDataReader() reader.SetFileName(input_vtk) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() # get data data = reader.GetOutput() (xmin, xmax, ymin, ymax, zmin, zmax) = data.GetBounds() (xcenter, ycenter, zcenter) = data.GetCenter() #create mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(data) # The actor is a grouping mechanism actor = vtk.vtkActor() actor.SetMapper(mapper) # create camera camera = vtk.vtkCamera() camera.SetFocalPoint(xcenter, ycenter, zcenter) camera.SetPosition(100, -300, -50) camera.SetViewUp(0, 0, 1) # create a renderer renderer = vtk.vtkRenderer() renderer.SetActiveCamera(camera) renderer.SetBackground(0.2, 0.2, 0.5) renderer.SetBackground2(0.4, 0.4, 1.0) renderer.SetGradientBackground(True) renderer.AddActor(actor) # create a render_window render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window.SetSize(1000, 1000) # create a renderwindowiren iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(render_window) iren.Initialize() rep = vtk.vtkImplicitPlaneRepresentation() rep.SetPlaceFactor(1.25) rep.PlaceWidget(actor.GetBounds()) rep.SetNormal(0, 0, 1) # Create a vtkImagePlaneWidget and activate it plane_widget = vtk.vtkImplicitPlaneWidget2() plane_widget.SetInteractor(iren) plane_widget.SetRepresentation(rep) plane_widget.On() iren.Initialize() iren.Start() # use orgin as one point and use normla to solve for two others (o1, o2, o3) = rep.GetOrigin() (n1, n2, n3) = rep.GetNormal() # using x = 1 and y =-1 solve for z pt1_z = (-n1 + (n1 * o1) + n2 + (n2 * o2) + (n3 * o3)) / n3 # using x = -1 and y = 1 solve for z pt2_z = (n1 + (n1 * o1) - n2 + (n2 * o2) + (n3 * o3)) / n3 # fix 0 edge case if o1 == 0 and o2 == 0: o1 = -1 o2 = -1 return np.array([[o1, o2, o3], [1, -1, pt1_z], [-1, 1, pt2_z]])
def show_allLandmarks(file_name, fixedLandmarks, curveLandmarks): # input the curve landmarks in a list: curveLandmarks = [curve1, curve2] #if you dont wish to input both fixed and curve landmarks you can # place a [] as the input #shows all the landmarks on the 3D model import vtk # from vtk.util.numpy_support import vtk_to_numpy from dipy.viz import window #import os # Read the surface from file if file_name[-3:] == 'vtk': object = vtk.vtkPolyDataReader() if file_name[-3:] == 'ply': object = vtk.vtkPLYReader() if file_name[-3:] == 'stl': object = vtk.vtkSTLReader() object.SetFileName(file_name) objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(object.GetOutputPort()) objectMapper.ScalarVisibilityOff() objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper) objectActor.GetProperty().SetColor(0.5, 0.5, 0.5) renderer = window.Renderer() renderer.add(objectActor) def markcurve(x, y, z, landnum, curve, annotnum): sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((0, 0, 1)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(annotnum + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) renderer.AddActor(textActor) #add line if landnum > 0: lineSource = vtk.vtkLineSource() lineSource.SetPoint1(curve[landnum - 1]) lineSource.SetPoint2([x, y, z]) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(lineSource.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(mapper) lineActor.GetProperty().SetLineWidth(4) lineActor.GetProperty().SetColor((0, 1, 0)) renderer.AddActor(lineActor) show_m.iren.Render() def markfixed(x, y, z, landnum): sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((1, 0, 0)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(landnum + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) renderer.AddActor(textActor) show_m.iren.Render() show_m = window.ShowManager(renderer, size=(800, 800)) totalnum = 0 # if fixedLandmarks: for lnum in range(len(fixedLandmarks)): lm = fixedLandmarks[lnum] markfixed(lm[0], lm[1], lm[2], totalnum) totalnum += 1 for c in curveLandmarks: for lnum in range(len(c)): lm = c[lnum] markcurve(lm[0], lm[1], lm[2], lnum, c, totalnum) totalnum += 1 show_m.initialize() show_m.render() show_m.start()
def main(): fileName = get_program_parameters() colors = vtk.vtkNamedColors() fran = vtk.vtkPolyDataReader() fran.SetFileName(fileName) normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(fran.GetOutputPort()) normals.FlipNormalsOn() franMapper = vtk.vtkPolyDataMapper() franMapper.SetInputConnection(normals.GetOutputPort()) franActor = vtk.vtkActor() franActor.SetMapper(franMapper) franActor.GetProperty().SetColor(colors.GetColor3d("Flesh")) # We subsample the dataset because we want to glyph just a subset of # the points. Otherwise the display is cluttered and cannot be easily # read. The RandomModeOn and SetOnRatio combine to random select one out # of every 10 points in the dataset. # ptMask = vtk.vtkMaskPoints() ptMask.SetInputConnection(normals.GetOutputPort()) ptMask.SetOnRatio(10) ptMask.RandomModeOn() # In this case we are using a cone as a glyph. We transform the cone so # its base is at 0,0,0. This is the point where glyph rotation occurs. cone = vtk.vtkConeSource() cone.SetResolution(6) transform = vtk.vtkTransform() transform.Translate(0.5, 0.0, 0.0) transformF = vtk.vtkTransformPolyDataFilter() transformF.SetInputConnection(cone.GetOutputPort()) transformF.SetTransform(transform) # vtkGlyph3D takes two inputs: the input point set (SetInputConnection) # which can be any vtkDataSet and the glyph (SetSourceConnection) which # must be a vtkPolyData. We are interested in orienting the glyphs by the # surface normals that we previously generated. glyph = vtk.vtkGlyph3D() glyph.SetInputConnection(ptMask.GetOutputPort()) glyph.SetSourceConnection(transformF.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleModeToScaleByVector() glyph.SetScaleFactor(0.004) spikeMapper = vtk.vtkPolyDataMapper() spikeMapper.SetInputConnection(glyph.GetOutputPort()) spikeActor = vtk.vtkActor() spikeActor.SetMapper(spikeMapper) spikeActor.GetProperty().SetColor(colors.GetColor3d("Emerald_Green")) # Create the RenderWindow, Renderer and Interactor. # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size. # ren1.AddActor(franActor) ren1.AddActor(spikeActor) renWin.SetSize(640, 480) ren1.SetBackground(colors.GetColor3d("SlateGray")) # Render the image. # renWin.Render() ren1.GetActiveCamera().Zoom(1.4) ren1.GetActiveCamera().Azimuth(110) renWin.Render() iren.Start()
def choose_curveLandmarks(file_name, fixedLandmarks=[]): #Place curve landmarks #can display fixed landmarks for aiding placement import vtk from dipy.viz import window import numpy as np #import os # Read the surface from file if file_name[-3:] == 'vtk': object = vtk.vtkPolyDataReader() if file_name[-3:] == 'ply': object = vtk.vtkPLYReader() if file_name[-3:] == 'stl': object = vtk.vtkSTLReader() object.SetFileName(file_name) objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(object.GetOutputPort()) objectMapper.ScalarVisibilityOff() objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper) objectActor.GetProperty().SetColor(0.5, 0.5, 0.5) # grey renderer = window.Renderer() renderer.add(objectActor) landmarks = [] actortextdict = {} actorlinedict = {} def mark(x, y, z): sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((0, 0, 1)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(len(landmarks) + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) actortextdict[marker] = textActor renderer.AddActor(textActor) #add line if len(landmarks) > 0: lineSource = vtk.vtkLineSource() lineSource.SetPoint1(landmarks[-1]) lineSource.SetPoint2([x, y, z]) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(lineSource.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(mapper) lineActor.GetProperty().SetLineWidth(4) lineActor.GetProperty().SetColor((0, 1, 0)) actorlinedict[marker] = lineActor renderer.AddActor(lineActor) show_m.iren.Render() def pick_cell(renwinInteractor, event): x, y = renwinInteractor.GetEventPosition() picker = vtk.vtkCellPicker() picker.PickFromListOn() picker.AddPickList(objectActor) picker.SetTolerance(0.01) picker.Pick(x, y, 0, renderer) points = picker.GetPickedPositions() numPoints = points.GetNumberOfPoints() if numPoints < 1: return pnt = points.GetPoint(0) mark(*pnt) landmarks.append(pnt) def remove_cell(renwinInteractor, event): x, y = renwinInteractor.GetEventPosition() picker = vtk.vtkPropPicker() # picker.PickFromListOn() # picker.AddPickList(objectActor) # picker.SetTolerance(0.01) picker.Pick(x, y, 0, renderer) pickedActor = picker.GetActor() if pickedActor: if pickedActor != objectActor: mapper = pickedActor.GetMapper() inputs = mapper.GetInput() point = inputs.GetCenter() if point not in fixedLandmarks: renderer.RemoveActor(pickedActor) renderer.RemoveActor(actortextdict[pickedActor]) if len(landmarks) > 1: renderer.RemoveActor(actorlinedict[pickedActor]) show_m.iren.Render() if point in landmarks: landmarks.remove(point) def markfixed(x, y, z, landnum): sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((1, 0, 0)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(landnum + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) renderer.AddActor(textActor) show_m.iren.Render() show_m = window.ShowManager(renderer, size=(800, 800)) show_m.iren.AddObserver('LeftButtonPressEvent', pick_cell) show_m.iren.AddObserver('RightButtonPressEvent', remove_cell) # if fixedLandmarks: for lnum in range(len(fixedLandmarks)): lm = fixedLandmarks[lnum] markfixed(lm[0], lm[1], lm[2], lnum) show_m.initialize() show_m.render() show_m.start() return np.array(landmarks)
def choose_fixedLandmarks(file_name, template=[]): #place fixed landmarks on 3D model #left click to place, right click to remove #can display a template for aiding placement import vtk from dipy.viz import window import numpy as np # import the 3D surface from file if file_name[-3:] == 'vtk': object = vtk.vtkPolyDataReader() if file_name[-3:] == 'ply': object = vtk.vtkPLYReader() if file_name[-3:] == 'stl': object = vtk.vtkSTLReader() object.SetFileName(file_name) objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(object.GetOutputPort()) objectMapper.ScalarVisibilityOff() objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper) objectActor.GetProperty().SetColor(0.5, 0.5, 0.5) # grey #left over from other work, don't delete yet #objectActor.GetProperty().SetColor(.24, .70, .44) #mediumseagreen #objectActor.GetProperty().SetColor(0.498039, 1, 0.831373) #springgreen #objectActor.GetProperty().SetColor(color[0],color[1],color[2]) # Attach to a renderer # ren = vtk.vtkRenderer() # ren.AddActor(objectActor) # ren.SetBackground(0.1, 0.1, 0.1) # Attach to a window # renWin = vtk.vtkRenderWindow() # renWin.AddRenderer(ren) # #renWin.SetWindowName("surface") # renWin.SetSize(500,500) # Attach to an interactor # iren = vtk.vtkRenderWindowInteractor() # iren.SetRenderWindow(renWin) # style = vtk.vtkInteractorStyleSwitch() # style.SetCurrentStyleToTrackballCamera() # iren.SetInteractorStyle(style) # iren.Initialize() # iren.Start() # # #create render window renderer = window.Renderer() #add 3D surface to window renderer.add(objectActor) #initialize landmarks landmarks = [] #initialize dictionary for tying landmarks to annotations actortextdict = {} def mark(x, y, z): #function for placing a landmark sphere sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((1, 0, 0)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(len(landmarks) + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) actortextdict[marker] = textActor renderer.AddActor(textActor) show_m.iren.Render() def pick_cell(renwinInteractor, event): #function for placing a landmark at mouse click position x, y = renwinInteractor.GetEventPosition() picker = vtk.vtkCellPicker() picker.PickFromListOn() picker.AddPickList(objectActor) picker.SetTolerance(0.01) picker.Pick(x, y, 0, renderer) points = picker.GetPickedPositions() numPoints = points.GetNumberOfPoints() if numPoints < 1: return pnt = points.GetPoint(0) mark(*pnt) landmarks.append(pnt) def remove_cell(renwinInteractor, event): #function for removing a landmark at mouse click position x, y = renwinInteractor.GetEventPosition() picker = vtk.vtkPropPicker() # picker.PickFromListOn() # picker.AddPickList(objectActor) # picker.SetTolerance(0.01) picker.Pick(x, y, 0, renderer) pickedActor = picker.GetActor() if pickedActor: if pickedActor != objectActor: mapper = pickedActor.GetMapper() inputs = mapper.GetInput() point = inputs.GetCenter() if point not in template: renderer.RemoveActor(pickedActor) renderer.RemoveActor(actortextdict[pickedActor]) show_m.iren.Render() if point in landmarks: landmarks.remove(point) def marktemplate(x, y, z, landnum): #function for placing template landmarks sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((1, 1, 0)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(landnum + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) renderer.AddActor(textActor) show_m.iren.Render() show_m = window.ShowManager(renderer, size=(800, 800)) show_m.iren.AddObserver('LeftButtonPressEvent', pick_cell) show_m.iren.AddObserver('RightButtonPressEvent', remove_cell) tempnum = 0 for lnum in range(len(template)): lm = template[lnum] marktemplate(lm[0], lm[1], lm[2], tempnum) tempnum += 1 show_m.initialize() show_m.render() show_m.start() return np.array(landmarks)
def show_fixedLandmarks(file_name, landmarks): #show the landmarks on the 3D model import vtk from dipy.viz import window # Read the surface from file if file_name[-3:] == 'vtk': object = vtk.vtkPolyDataReader() if file_name[-3:] == 'ply': object = vtk.vtkPLYReader() if file_name[-3:] == 'stl': object = vtk.vtkSTLReader() object.SetFileName(file_name) objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(object.GetOutputPort()) objectMapper.ScalarVisibilityOff() objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper) objectActor.GetProperty().SetColor(0.5, 0.5, 0.5) renderer = window.Renderer() renderer.add(objectActor) def mark(x, y, z, landnum): sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((1, 0, 0)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(landnum + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) renderer.AddActor(textActor) show_m.iren.Render() show_m = window.ShowManager(renderer, size=(800, 800)) for lnum in range(len(landmarks)): lm = landmarks[lnum] mark(lm[0], lm[1], lm[2], lnum) show_m.initialize() show_m.render() show_m.start()
def main(args): inputSurface = args.surf if args.n_rot > 1 and not os.path.exists(args.out): os.mkdir(args.out) path, extension = os.path.splitext(inputSurface) extension = extension.lower() if extension == ".vtk": reader = vtk.vtkPolyDataReader() reader.SetFileName(inputSurface) reader.Update() original_surf = reader.GetOutput() elif extension == ".stl": reader = vtk.vtkSTLReader() reader.SetFileName(inputSurface) reader.Update() original_surf = reader.GetOutput() if args.n_rot == 1: rotated_surf = transform(original_surf, args.rot_v, args.angle) outfilename = args.out print("Writting:", outfilename) polydatawriter = vtk.vtkPolyDataWriter() polydatawriter.SetFileName(outfilename) polydatawriter.SetInputData(rotated_surf) polydatawriter.Write() else: for i in range(args.n_rot): rotated_surf = transform(original_surf) outfilename, ext = os.path.splitext(inputSurface) outfilename = os.path.join( args.out, os.path.basename(outfilename)) + "_" + str(i) + ".vtk" print("Writting:", outfilename) polydatawriter = vtk.vtkPolyDataWriter() polydatawriter.SetFileName(outfilename) polydatawriter.SetInputData(rotated_surf) polydatawriter.Write() if (args.visualize): mapper_orig = vtk.vtkPolyDataMapper() mapper_orig.SetInputData(original_surf) mapper_transform = vtk.vtkPolyDataMapper() mapper_transform.SetInputData(rotated_surf) actor1 = vtk.vtkActor() actor1.SetMapper(mapper_orig) actor2 = vtk.vtkActor() actor2.SetMapper(mapper_transform) colors = vtk.vtkNamedColors() actor1.GetProperty().SetColor(colors.GetColor3d('Red')) actor2.GetProperty().SetColor(colors.GetColor3d('Blue')) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) WIDTH = 640 HEIGHT = 480 renWin.SetSize(WIDTH, HEIGHT) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # assign actor to the renderer ren.AddActor(actor1) ren.AddActor(actor2) # enable user interface interactor iren.Initialize() renWin.Render() iren.Start()
def readMeshFile(filename, clean=True, verbose=False, recompute_normals=True): """Read mesh file. The input format is determined by file name extension. Polygons get split into triangles to support various restrictive output formats. If clean, degenerate data gets removed.""" informat = path.splitext(options.infilename)[1].strip('.') # set reader based on filename extension if informat == 'stl': reader = vtk.vtkSTLReader() elif informat == 'vtk': reader = vtk.vtkPolyDataReader() elif informat == 'obj': reader = vtk.vtkMNIObjectReader() elif informat == 'ply': reader = vtk.vtkPLYReader() elif informat == 'vtp': reader = vtk.vtkXMLPolyDataReader() #elif informat=='tag': # reader = vtk.vtkMNITagPointReader() else: raise ValueError('cannot read input format: ' + informat) reader.SetFileName(filename) reader.Update() if verbose: print("read %i polygons from file %s" % \ (reader.GetOutput().GetNumberOfPolys(), filename)) # merge duplicate points, and/or remove unused points and/or remove degenerate cells if clean: polydata = vtk.vtkCleanPolyData() polydata.SetInputConnection(reader.GetOutputPort()) poly_data_algo = polydata if verbose: print("cleaned poly data") else: poly_data_algo = reader # convert input polygons and strips to triangles triangles = vtk.vtkTriangleFilter() triangles.SetInputConnection(poly_data_algo.GetOutputPort()) if recompute_normals: normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(triangles.GetOutputPort()) normals.SplittingOff() normals.ComputePointNormalsOn() normals.AutoOrientNormalsOn() normals.ConsistencyOn() normals.NonManifoldTraversalOn() if verbose: print("recomputed normals") print("finished reading", filename) return normals else: if verbose: print("finished reading", filename) return triangles
def test_airway_particles(): # Get the path to the this test so that we can reference the test data this_dir = os.path.dirname(os.path.realpath(__file__)) # Set up the inputs to AirwayParticles input_ct = this_dir + '/../../../Testing/Data/Input/airway.nrrd' output_particles = this_dir + '/../../../Testing/tmp/airway_particles.vtk' tmp_dir = this_dir + '/../../../Testing/tmp/' input_mask = None max_scale = 6.0 live_th = 50.0 seed_th = 40.0 scale_samples = 5 down_sample_rate = 1.0 min_intensity = -1100 max_intensity = -400 # Generate the airway particles ap = AirwayParticles(input_ct, output_particles, tmp_dir, input_mask, max_scale, live_th, seed_th, scale_samples, down_sample_rate, min_intensity, max_intensity) ap.execute() # Read in the reference data set for comparison ref_reader = vtk.vtkPolyDataReader() ref_reader.SetFileName(this_dir + '/../../../Testing/Data/Input/airway_particles.vtk') ref_reader.Update() # Now read in the output data set test_reader = vtk.vtkPolyDataReader() test_reader.SetFileName( this_dir + '/../../../Testing/Data/Input/airway_particles.vtk') test_reader.Update() # The test passes provided that every particle in the reference data set # has a partner within an '_irad' distance of some particle in the test # data set and vice versa irad = ap._irad for i in xrange(0, ref_reader.GetOutput().GetNumberOfPoints()): ref_point = np.array(ref_reader.GetOutput().GetPoint(i)) test_pass = False for j in xrange(0, test_reader.GetOutput().GetNumberOfPoints()): test_point = np.array(test_reader.GetOutput().GetPoint(j)) dist = sqrt(sum((ref_point - test_point)**2)) if dist <= irad: test_pass = True break assert test_pass, 'Airway particle has no match' for i in xrange(0, test_reader.GetOutput().GetNumberOfPoints()): test_point = np.array(test_reader.GetOutput().GetPoint(i)) test_pass = False for j in xrange(0, ref_reader.GetOutput().GetNumberOfPoints()): ref_point = np.array(ref_reader.GetOutput().GetPoint(j)) dist = sqrt(sum((ref_point - test_point)**2)) if dist <= irad: test_pass = True break assert test_pass, 'Airway particle has no match' # Clean up the tmp directory. Note that this block should probably change # if this test is altered files = [ 'V-000-005.nrrd', 'V-001-005.nrrd', 'V-002-005.nrrd', 'V-003-005.nrrd', 'V-004-005.nrrd', 'airway_particles.vtk', 'ct-deconv.nrrd', 'hess.nrrd', 'heval0.nrrd', 'heval1.nrrd', 'heval2.nrrd', 'hevec0.nrrd', 'hevec1.nrrd', 'hevec2.nrrd', 'hmode.nrrd', 'pass1.nrrd', 'pass2.nrrd', 'pass3.nrrd', 'val.nrrd', '2dd.nrrd', 'curvdir1.nrrd', 'curvdir2.nrrd', 'flowlinecurv.nrrd', 'gausscurv.nrrd', 'gmag.nrrd', 'gvec.nrrd', 'hf.nrrd', 'kappa1.nrrd', 'kappa2.nrrd', 'lapl.nrrd', 'meancurv.nrrd', 'median.nrrd', 'si.nrrd', 'st.nrrd', 'totalcurv.nrrd' ] for f in files: if os.path.isfile(tmp_dir + f): subprocess.call("rm " + tmp_dir + f, shell=True)
def main(): file_name, color_scheme = get_program_parameters() color_scheme = abs(color_scheme) if color_scheme > 2: color_scheme = 0; colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor("BkgColor", [26, 51, 102, 255]) # Read a vtk file # hawaii = vtk.vtkPolyDataReader() hawaii.SetFileName(file_name) hawaii.Update() bounds = [0.0] * 6 hawaii.GetOutput().GetBounds(bounds) elevation = vtk.vtkElevationFilter() elevation.SetInputConnection(hawaii.GetOutputPort()) elevation.SetLowPoint(0, 0, 0) elevation.SetHighPoint(0, 0, 1000) elevation.SetScalarRange(0, 1000) lut = MakeLUT(color_scheme) hawaiiMapper = vtk.vtkDataSetMapper() hawaiiMapper.SetInputConnection(elevation.GetOutputPort()) hawaiiMapper.SetScalarRange(0, 1000) hawaiiMapper.ScalarVisibilityOn() hawaiiMapper.SetLookupTable(lut) hawaiiActor = vtk.vtkActor() hawaiiActor.SetMapper(hawaiiMapper) # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size # ren.AddActor(hawaiiActor) # Match the window shape to the object. # renWin.SetSize(500, int(500 * bounds[1] / bounds[3])) renWin.SetSize(500, 500) iren.Initialize() # Render the image. # Centered on Honolulu. # Diamond Head is the crater lower left. # Punchbowl is the crater in the centre. renWin.Render() ren.SetBackground(colors.GetColor3d("BkgColor")) ren.GetActiveCamera().Zoom(1.5) ren.GetActiveCamera().Roll(-90) renWin.Render() iren.Start()
def read_polydata(filename, datatype=None): """ Load the given file, and return a vtkPolyData object for it. Args: filename (str): Path to input file. datatype (str): Additional parameter for vtkIdList objects. Returns: polyData (vtkSTL/vtkPolyData/vtkXMLStructured/ vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/ vtkXMLImage/Tecplot): Output data. """ # Check if file exists if not path.exists(filename): raise RuntimeError("Could not find file: %s" % filename) # Check filename format fileType = filename.split(".")[-1] if fileType == '': raise RuntimeError('The file does not have an extension') # Get reader if fileType == 'stl': reader = vtk.vtkSTLReader() reader.MergingOn() elif fileType == 'vtk': # Read header with open(filename, "rb") as f: head = list(islice(f, 10)) head = "".join([l.decode('utf-8', 'backslashreplace') for l in head]).lower() # Set reader based on header if "unstructured_grid" in head: reader = vtk.vtkUnstructuredGridReader() elif "structured_grid" in head: reader = vtk.vtkStructuredGridReader() elif "rectilinear_grid" in head: reader = vtk.vtkRectilinearGridReader() elif "structured_points" in head: reader = vtk.vtkStructuredPointsReader() elif "polydata" in head: reader = vtk.vtkPolyDataReader() elif fileType == 'vtp': reader = vtk.vtkXMLPolyDataReader() elif fileType == 'vts': reader = vtk.vtkXMLStructuredGridReader() elif fileType == 'vtr': reader = vtk.vtkXMLRectilinearGridReader() elif fileType == 'vtu': reader = vtk.vtkXMLUnstructuredGridReader() elif fileType == "vti": reader = vtk.vtkXMLImageDataReader() elif fileType == "np" and datatype == "vtkIdList": result = np.load(filename).astype(np.int) id_list = vtk.vtkIdList() id_list.SetNumberOfIds(result.shape[0]) for i in range(result.shape[0]): id_list.SetId(i, result[i]) return id_list else: raise RuntimeError('Unknown file type %s' % fileType) # Read reader.SetFileName(filename) reader.Update() polydata = reader.GetOutput() return polydata
def main(): fileName = get_program_parameters() colors = vtk.vtkNamedColors() # Create lines which serve as the 'seed' geometry. The lines spell the # word 'hello'. # reader = vtk.vtkPolyDataReader() reader.SetFileName(fileName) lineMapper = vtk.vtkPolyDataMapper() lineMapper.SetInputConnection(reader.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(lineMapper) lineActor.GetProperty().SetColor(colors.GetColor3d('Tomato')) lineActor.GetProperty().SetLineWidth(3.0) # Create implicit model with vtkImplicitModeller. This computes a scalar # field which is the distance from the generating geometry. The contour # filter then extracts the geometry at the distance value 0.25 from the # generating geometry. # imp = vtk.vtkImplicitModeller() imp.SetInputConnection(reader.GetOutputPort()) imp.SetSampleDimensions(110, 40, 20) imp.SetMaximumDistance(0.25) imp.SetModelBounds(-1.0, 10.0, -1.0, 3.0, -1.0, 1.0) contour = vtk.vtkContourFilter() contour.SetInputConnection(imp.GetOutputPort()) contour.SetValue(0, 0.25) impMapper = vtk.vtkPolyDataMapper() impMapper.SetInputConnection(contour.GetOutputPort()) impMapper.ScalarVisibilityOff() impActor = vtk.vtkActor() impActor.SetMapper(impMapper) impActor.GetProperty().SetColor(colors.GetColor3d('Peacock')) impActor.GetProperty().SetOpacity(0.5) # Create the usual graphics stuff. # Create the RenderWindow, Renderer and Interactor. # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.SetWindowName('Hello') iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size # ren1.AddActor(lineActor) ren1.AddActor(impActor) ren1.SetBackground(colors.GetColor3d('Wheat')) renWin.SetSize(640, 480) camera = vtk.vtkCamera() camera.SetFocalPoint(4.5, 1, 0) camera.SetPosition(4.5, 1.0, 6.73257) camera.SetViewUp(0, 1, 0) ren1.SetActiveCamera(camera) ren1.ResetCamera() camera.Dolly(1.3) camera.SetClippingRange(1.81325, 90.6627) renWin.Render() iren.Start()
def main(): colors = vtk.vtkNamedColors() fileName1, fileName2, fileName3 = get_program_parameters() aRenderer = vtk.vtkRenderer() aRenderWindow = vtk.vtkRenderWindow() aRenderWindow.AddRenderer(aRenderer) anInteractor = vtk.vtkRenderWindowInteractor() anInteractor.SetRenderWindow(aRenderWindow) aRenderWindow.SetSize(300, 300) aRenderWindow.SetWindowName('BlobbyLogo') # Read the geometry file containing the letter v. letterV = vtk.vtkPolyDataReader() letterV.SetFileName(fileName1) # Read the geometry file containing the letter t. letterT = vtk.vtkPolyDataReader() letterT.SetFileName(fileName2) # Read the geometry file containing the letter k. letterK = vtk.vtkPolyDataReader() letterK.SetFileName(fileName3) # Create a transform and transform filter for each letter. VTransform = vtk.vtkTransform() VTransformFilter = vtk.vtkTransformPolyDataFilter() VTransformFilter.SetInputConnection(letterV.GetOutputPort()) VTransformFilter.SetTransform(VTransform) TTransform = vtk.vtkTransform() TTransformFilter = vtk.vtkTransformPolyDataFilter() TTransformFilter.SetInputConnection(letterT.GetOutputPort()) TTransformFilter.SetTransform(TTransform) KTransform = vtk.vtkTransform() KTransformFilter = vtk.vtkTransformPolyDataFilter() KTransformFilter.SetInputConnection(letterK.GetOutputPort()) KTransformFilter.SetTransform(KTransform) # Now append them all. appendAll = vtk.vtkAppendPolyData() appendAll.AddInputConnection(VTransformFilter.GetOutputPort()) appendAll.AddInputConnection(TTransformFilter.GetOutputPort()) appendAll.AddInputConnection(KTransformFilter.GetOutputPort()) # Create normals. logoNormals = vtk.vtkPolyDataNormals() logoNormals.SetInputConnection(appendAll.GetOutputPort()) logoNormals.SetFeatureAngle(60) # Map to rendering primitives. logoMapper = vtk.vtkPolyDataMapper() logoMapper.SetInputConnection(logoNormals.GetOutputPort()) # Now an actor. logo = vtk.vtkActor() logo.SetMapper(logoMapper) # Now create an implicit model of the same letter. blobbyLogoImp = vtk.vtkImplicitModeller() blobbyLogoImp.SetInputConnection(appendAll.GetOutputPort()) blobbyLogoImp.SetMaximumDistance(.075) blobbyLogoImp.SetSampleDimensions(64, 64, 64) blobbyLogoImp.SetAdjustDistance(0.05) # Extract an iso surface. blobbyLogoIso = vtk.vtkContourFilter() blobbyLogoIso.SetInputConnection(blobbyLogoImp.GetOutputPort()) blobbyLogoIso.SetValue(1, 1.5) # Map to rendering primitives. blobbyLogoMapper = vtk.vtkPolyDataMapper() blobbyLogoMapper.SetInputConnection(blobbyLogoIso.GetOutputPort()) blobbyLogoMapper.ScalarVisibilityOff() tomato = vtk.vtkProperty() tomato.SetDiffuseColor(colors.GetColor3d('tomato')) tomato.SetSpecular(.3) tomato.SetSpecularPower(20) banana = vtk.vtkProperty() banana.SetDiffuseColor(colors.GetColor3d('banana')) banana.SetDiffuse(.7) banana.SetSpecular(.4) banana.SetSpecularPower(20) # Now an actor. blobbyLogo = vtk.vtkActor() blobbyLogo.SetMapper(blobbyLogoMapper) blobbyLogo.SetProperty(banana) # Position the letters. VTransform.Translate(-16.0, 0.0, 12.5) VTransform.RotateY(40) KTransform.Translate(14.0, 0.0, 0.0) KTransform.RotateY(-40) # Move the polygonal letters to the front. logo.SetProperty(tomato) logo.SetPosition(0, 0, 6) aRenderer.AddActor(logo) aRenderer.AddActor(blobbyLogo) aRenderer.SetBackground(colors.GetColor3d('SlateGray')) aRenderWindow.Render() # Interact with the data. anInteractor.Start()
def volumetric_spline_augmentation(file, save_name='', save_points=0): #file = '0212.vtk' file_name = 'C:/Users/lowes/OneDrive/Skrivebord/DTU/6_Semester/Bachelor/LAA_segmentation/' + file path = 'C:/Users/lowes/OneDrive/Skrivebord/DTU/6_Semester/Bachelor/Augmented_data/' out_name = path + file.split('.')[0] + 'aug' + save_name + '.vtk' pd_in = vtk.vtkPolyDataReader() pd_in.SetFileName(file_name) pd_in.Update() pd = pd_in.GetOutput() # Get bounding box bounds = pd.GetBounds() x_min = bounds[0] x_max = bounds[1] y_min = bounds[2] y_max = bounds[3] z_min = bounds[4] z_max = bounds[5] # get a measure of scale as the diagonal length scale = math.sqrt((x_max - x_min) * (x_max - x_min) + (y_max - y_min) * (y_max - y_min) + (z_max - z_min) * (z_max - z_min)) # Reference points # Here just corners of the bounding box # TODO: make more points n = 3 i = 0 p1 = vtk.vtkPoints() p1.SetNumberOfPoints(n * n * n) xlin = np.linspace(x_min, x_max, n) ylin = np.linspace(y_min, y_max, n) zlin = np.linspace(z_min, z_max, n) for x in xlin: for y in ylin: for z in zlin: p1.SetPoint(i, x, y, z) i += 1 ''' p1.SetPoint(0, x_min, y_min, z_min) p1.SetPoint(1, x_max, y_min, z_min) p1.SetPoint(2, x_min, y_max, z_min) p1.SetPoint(3, x_max, y_max, z_min) p1.SetPoint(4, x_min, y_min, z_max) p1.SetPoint(5, x_max, y_min, z_max) p1.SetPoint(6, x_min, y_max, z_max) p1.SetPoint(7, x_max, y_max, z_max) ''' # Deformed points p2 = vtk.vtkPoints() # Start by copying all info from p1 p2.DeepCopy(p1) # Displace the points in a random direction displacement_length = scale * 0.05 #change parameter around a bit for i in range(p2.GetNumberOfPoints()): p = list(p2.GetPoint(i)) for j in range(3): p[j] = p[j] + (2.0 * random() - 1) * displacement_length p2.SetPoint(i, p) transform = vtk.vtkThinPlateSplineTransform() transform.SetSourceLandmarks(p1) transform.SetTargetLandmarks(p2) transform.SetBasisToR2LogR() transform.Update() transform_filter = vtk.vtkTransformPolyDataFilter() transform_filter.SetTransform(transform) transform_filter.SetInputData(pd) transform_filter.Update() vs = np.array(transform_filter.GetOutput().GetPoints().GetData()) face_labels = np.array( transform_filter.GetOutput().GetCellData().GetScalars()) poly = dsa.WrapDataObject(transform_filter.GetOutput()).Polygons faces = np.reshape(poly, (-1, 4))[:, 1:4] print('writing file') #vcolor = [] with open(out_name, 'w+') as f: f.write( "# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n" % len(vs)) for vi, v in enumerate(vs): #vcol = ' %f %f %f' % (vcolor[vi, 0], vcolor[vi, 1], vcolor[vi, 2]) if vcolor is not None else '' f.write("%f %f %f\n" % (v[0], v[1], v[2])) f.write("POLYGONS %d %d \n" % (len(faces), 4 * len(faces))) for face_id in range(len(faces) - 1): f.write("3 %d %d %d\n" % (faces[face_id][0], faces[face_id][1], faces[face_id][2])) f.write("3 %d %d %d" % (faces[-1][0], faces[-1][1], faces[-1][2])) f.write( "\n \nCELL_DATA %d \nSCALARS scalars double \nLOOKUP_TABLE default" % len(faces)) for j, face in enumerate(faces): if j % 9 == 0: f.write("\n") f.write("%d " % face_labels[j]) print('done writing') if save_points: fig = plt.figure() ax = fig.add_subplot(projection='3d') points = np.asarray(p1.GetData()) ax.scatter(points[:, 0], points[:, 1], points[:, 2], linewidth=8) #plt.show() #fig = plt.figure() #ax = fig.add_subplot(projection='3d') points = np.asarray(p2.GetData()) ax.scatter(points[:, 0], points[:, 1], points[:, 2], linewidth=8, marker='x') plt.show() vs1 = np.array(p1.GetData()) out_p1 = path + file.split('.')[0] + '_p1.vtk' with open(out_p1, 'w+') as f: f.write( "# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n" % len(vs1)) for vi, v in enumerate(vs1): f.write("%f %f %f\n" % (v[0], v[1], v[2])) vs = np.array(p1.GetData()) vs2 = np.array(p2.GetData()) out_p2 = path + file.split('.')[0] + '_p2.vtk' with open(out_p2, 'w+') as f: f.write( "# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n" % len(vs2)) for vi, v in enumerate(vs2): f.write("%f %f %f\n" % (v[0], v[1], v[2])) '''
def buildATPMesh(): # Report our CWD just for testing purposes. print("CWD:", os.getcwd()) # Read in the mesh. print("Reading", meshFile) meshReader = vtk.vtkXMLPolyDataReader() meshReader.SetFileName(meshFile) meshReader.Update() ecMesh = meshReader.GetOutput() # Read in the centreline. print("Reading", centrelineFile) centrelineReader = vtk.vtkPolyDataReader() centrelineReader.SetFileName(centrelineFile) centrelineReader.Update() centreline = centrelineReader.GetOutput() origin = centreline.GetPoint(0) print("Origin:", origin) # Put the ecMesh through centroids filter. centroidFilter = vtk.vtkCellCenters() centroidFilter.SetInputData(ecMesh) centroidFilter.Update() centroids = centroidFilter.GetOutput() # Iterate over each centroid and find the closest segment centroidPoints = centroids.GetPoints() # Only for DEBUG output. distArray = vtk.vtkDoubleArray() distArray.SetName("Dist") # For each point calculate the distance from origin. totalPoints = centroidPoints.GetNumberOfPoints() for ptId in range(totalPoints): distance = vtk.vtkMath.Distance2BetweenPoints( origin, centroidPoints.GetPoint(ptId)) distArray.InsertNextValue(math.sqrt(distance)) # Get the range of the distance values. inMin, inMax = distArray.GetRange() atpArray = vtk.vtkFloatArray() atpArray.SetName('initialATP') # Normalise distance values. for i in range(distArray.GetNumberOfTuples()): dist = distArray.GetTuple(i)[0] distRescaled = rescale(dist, inMin, inMax) atpVal = sigmoidATP(distRescaled) atpArray.InsertNextValue(atpVal) # Prepare debug ATP mesh. debugAtpDataset = ecMesh debugAtpDataset.GetCellData().AddArray(distArray) debugAtpDataset.GetCellData().AddArray(atpArray) # Save the debug ATP mesh. debugAtpMapWriter = vtk.vtkXMLPolyDataWriter() debugAtpMapWriter.SetFileName(debugAtpFile) debugAtpMapWriter.SetInputData(debugAtpDataset) debugAtpMapWriter.Update() # Prepare the ATP mesh by converting all points to vercices. pointsToVerticesFilter = vtk.vtkVertexGlyphFilter() pointsToVerticesFilter.SetInputData(centroids) pointsToVerticesFilter.Update() atpDataset = pointsToVerticesFilter.GetOutput() atpDataset.GetCellData().AddArray(atpArray) # Assert the number of cells is equal to the number of items in the cell arrays. assert atpArray.GetNumberOfTuples() == debugAtpDataset.GetNumberOfCells( ), "Number of cells (%d) and cell data values (%d) mismatch." % ( atpArray.GetNumberOfTuples(), debugAtpDataset.GetNumberOfCells()) atpMapWriter = vtk.vtkXMLPolyDataWriter() atpMapWriter.SetFileName(atpFile) atpMapWriter.SetInputData(atpDataset) atpMapWriter.Update() # Provide a quick visualisation of the ATP profile for validation. pointsX = numpy.arange(outMin, outMax, 0.001) pointsY = [] for pt in pointsX: pointsY.append(sigmoidATP(pt)) pyplot.plot(pointsX, pointsY, 'b') pyplot.show()
def main(): colors = vtk.vtkNamedColors() fileName1, fileName2 = get_program_parameters() # This example shows how to use decimation to reduce a polygonal mesh. We also # use mesh smoothing and generate surface normals to give a pleasing result. # # We start by reading some data that was originally captured from # a Cyberware laser digitizing system. # fran = vtk.vtkPolyDataReader() fran.SetFileName(fileName1) # Read the corresponding texture. textureReader = vtk.vtkPNGReader() textureReader.SetFileName(fileName2) texture = vtk.vtkTexture() texture.InterpolateOn() texture.SetInputConnection(textureReader.GetOutputPort()) # We want to preserve topology (not let any cracks form). This may limit # the total reduction possible, which we have specified at 90%. # deci = vtk.vtkDecimatePro() deci.SetInputConnection(fran.GetOutputPort()) deci.SetTargetReduction(0.9) deci.PreserveTopologyOn() decimatedNormals = vtk.vtkPolyDataNormals() decimatedNormals.SetInputConnection(deci.GetOutputPort()) decimatedNormals.FlipNormalsOn() decimatedNormals.SetFeatureAngle(60) originalNormals = vtk.vtkPolyDataNormals() originalNormals.SetInputConnection(fran.GetOutputPort()) originalNormals.FlipNormalsOn() originalNormals.SetFeatureAngle(60) decimatedMapper = vtk.vtkPolyDataMapper() decimatedMapper.SetInputConnection(decimatedNormals.GetOutputPort()) decimatedActor = vtk.vtkActor() decimatedActor.SetMapper(decimatedMapper) decimatedActor.GetProperty().SetAmbient(.5) decimatedActor.GetProperty().SetDiffuse(.5) decimatedActor.SetTexture(texture) originalMapper = vtk.vtkPolyDataMapper() originalMapper.SetInputConnection(originalNormals.GetOutputPort()) originalActor = vtk.vtkActor() originalActor.SetMapper(originalMapper) originalActor.GetProperty().SetAmbient(.5) originalActor.GetProperty().SetDiffuse(.5) originalActor.SetTexture(texture) # Create the RenderWindow, Renderer and Interactor. # renderer1 = vtk.vtkRenderer() renderer1.SetViewport(0., 0.0, 0.5, 1.0) renderer2 = vtk.vtkRenderer() renderer2.SetViewport(0.5, 0.0, 1.0, 1.0) renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer1) renderWindow.AddRenderer(renderer2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) # Add the actors to the renderer, set the background and size. # renderer1.AddActor(originalActor) renderer2.AddActor(decimatedActor) renderer1.SetBackground(colors.GetColor3d("Wheat")) renderer2.SetBackground(colors.GetColor3d("Papaya_Whip")) renderWindow.SetSize(800, 400) # Render the image. # cam1 = vtk.vtkCamera() cam1.SetClippingRange(0.0475572, 2.37786) cam1.SetFocalPoint(0.052665, -0.129454, -0.0573973) cam1.SetPosition(0.327637, -0.116299, -0.256418) cam1.SetViewUp(-0.0225386, 0.999137, 0.034901) renderer1.SetActiveCamera(cam1) renderer2.SetActiveCamera(cam1) renderWindow.Render() interactor.Start()
def convert(input, config=None, verbose=True, coords_only=False): extension = os.path.splitext(input)[1].lower() if extension == '.vtp': r = vtk.vtkXMLPolyDataReader() r.SetFileName(input) r.Update() polydata = r.GetOutput() elif extension == '.vtk': r = vtk.vtkPolyDataReader() r.SetFileName(input) r.Update() polydata = r.GetOutput() else: raise Error('Invalid input format.') # print(polydata.GetBounds()) points = numpy_support.vtk_to_numpy(polydata.GetPoints().GetData()) lines = numpy_support.vtk_to_numpy(polydata.GetLines().GetData()) number_of_streamlines = polydata.GetLines().GetNumberOfCells() # # scalars are per point # pointdata = polydata.GetPointData() number_of_scalars = pointdata.GetNumberOfArrays() scalars = [] scalar_types = [] scalar_names = [] if not coords_only: for i in range(number_of_scalars): arr_name = pointdata.GetArrayName(i) scalar_names.append(str(arr_name)) arr = pointdata.GetArray(i) # arr.ComputeScalarRange() # print(arr) number_of_components = arr.GetNumberOfComponents() data_type = arr.GetDataType() scalar_types.append((data_type, number_of_components)) if verbose: print('Loading scalar', arr_name) scalars.append(numpy_support.vtk_to_numpy(arr)) # # properties are per streamline # celldata = polydata.GetCellData() number_of_properties = celldata.GetNumberOfArrays() properties = [] property_types = [] property_names = [] if not coords_only: for i in range(number_of_properties): arr_name = celldata.GetArrayName(i) property_names.append(str(arr_name)) arr = celldata.GetArray(i) # print(i, arr) number_of_components = arr.GetNumberOfComponents() data_type = arr.GetDataType() property_types.append((data_type, number_of_components)) if verbose: print('Loading property', arr_name) properties.append(numpy_support.vtk_to_numpy(arr)) # # convert to streamlines # ordered_indices = [] ordered_scalars = [] i = 0 current_fiber_id = 0 line_length = 0 # sanity check if len(lines) > 0: line_length = lines[i] line_index = 0 lines_just_length = [] while (line_index < number_of_streamlines): lines_just_length.append(line_length) current_line = lines[i + 1 + line_index:i + 1 + line_length + line_index] current_indices = [] # print('line',line_index) for k in range(len(current_line) - 1): indexA = current_line[k] indexB = current_line[k + 1] # print(indexA, indexB) current_indices.append(indexA) current_indices.append(indexB) ordered_indices += current_indices i += line_length line_index += 1 if line_index < number_of_streamlines: line_length = lines[i + line_index] # # now, create fiber cluster data structure # fibercluster = { 'number_of_streamlines': number_of_streamlines, 'per_vertex_data': collections.OrderedDict(), 'indices': lines_just_length, #ordered_indices 'per_streamline_data': collections.OrderedDict() } fibercluster['per_vertex_data']['POSITION'] = { 'componentType': vtkDataType_to_gltfComponentType[polydata.GetPoints().GetDataType()], 'type': vtkNumberOfComponents_to_gltfType[ polydata.GetPoints().GetData().GetNumberOfComponents()], 'data': points #ordered_vertices } for i, s in enumerate(scalar_names): vtkdatatype = scalar_types[i][0] vtknumberofcomponents = scalar_types[i][1] thisdata = scalars[i] #[] if vtknumberofcomponents in vtkNumberOfComponents_to_gltfType: gltfType = vtkNumberOfComponents_to_gltfType[vtknumberofcomponents] else: # for now, we will just pass it through gltfType = vtknumberofcomponents fibercluster['per_vertex_data'][s] = { 'componentType': vtkDataType_to_gltfComponentType[vtkdatatype], 'type': gltfType, 'data': thisdata } for i, p in enumerate(property_names): vtkdatatype = property_types[i][0] vtknumberofcomponents = property_types[i][1] thisdata = properties[i] #[] if vtknumberofcomponents in vtkNumberOfComponents_to_gltfType: gltfType = vtkNumberOfComponents_to_gltfType[vtknumberofcomponents] else: # for now, we will just pass it through gltfType = vtknumberofcomponents fibercluster['per_streamline_data'][p] = { 'componentType': vtkDataType_to_gltfComponentType[vtkdatatype], 'type': gltfType, 'data': thisdata } return fibercluster
def volumetric_spline_augmentation(): out_name = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/DataAug/0079aug.vtk' file_name = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/LAA_segmentation/0079.vtk' out_name_grid = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/DataAug/0079_grid.vtk' out_name_grid_warped = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/DataAug/0079_grid_warped.vtk' pd_in = vtk.vtkPolyDataReader() pd_in.SetFileName(file_name) pd_in.Update() pd = pd_in.GetOutput() grid_3d = create_3d_grid(pd) print('writing grid') writer = vtk.vtkPolyDataWriter() writer.SetFileName(out_name_grid) writer.SetInputData(grid_3d) writer.Write() print('done writing') # Get bounding box bounds = pd.GetBounds() x_min = bounds[0] x_max = bounds[1] y_min = bounds[2] y_max = bounds[3] z_min = bounds[4] z_max = bounds[5] # get a measure of scale as the diagonal length scale = math.sqrt((x_max - x_min) * (x_max - x_min) + (y_max - y_min) * (y_max - y_min) + (z_max - z_min) * (z_max - z_min)) # Reference points # Here just corners of the bounding box # TODO: make more points n = 8 i = 0 p1 = vtk.vtkPoints() p1.SetNumberOfPoints(n * n * n) xlin = np.linspace(x_min, x_max, n) ylin = np.linspace(y_min, y_max, n) zlin = np.linspace(z_min, z_max, n) for x in xlin: for y in ylin: for z in zlin: p1.SetPoint(i, x, y, z) i += 1 ''' p1.SetPoint(0, x_min, y_min, z_min) p1.SetPoint(1, x_max, y_min, z_min) p1.SetPoint(2, x_min, y_max, z_min) p1.SetPoint(3, x_max, y_max, z_min) p1.SetPoint(4, x_min, y_min, z_max) p1.SetPoint(5, x_max, y_min, z_max) p1.SetPoint(6, x_min, y_max, z_max) p1.SetPoint(7, x_max, y_max, z_max) ''' # Deformed points p2 = vtk.vtkPoints() # Start by copying all info from p1 p2.DeepCopy(p1) # Displace the points in a random direction displacement_length = scale * 0.03 #change parameter around a bit for i in range(p2.GetNumberOfPoints()): p = list(p2.GetPoint(i)) for j in range(3): p[j] = p[j] + (2.0 * random() - 1) * displacement_length p2.SetPoint(i, p) transform = vtk.vtkThinPlateSplineTransform() transform.SetSourceLandmarks(p1) transform.SetTargetLandmarks(p2) transform.SetBasisToR2LogR() transform.Update() transform_filter = vtk.vtkTransformPolyDataFilter() transform_filter.SetTransform(transform) transform_filter.SetInputData(pd) transform_filter.Update() vs = np.array(transform_filter.GetOutput().GetPoints().GetData()) face_labels = np.array( transform_filter.GetOutput().GetCellData().GetScalars()) poly = dsa.WrapDataObject(transform_filter.GetOutput()).Polygons faces = np.reshape(poly, (-1, 4))[:, 1:4] #vcolor = [] print('writing aug mesh') with open(out_name, 'w+') as f: f.write( "# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n" % len(vs)) for vi, v in enumerate(vs): #vcol = ' %f %f %f' % (vcolor[vi, 0], vcolor[vi, 1], vcolor[vi, 2]) if vcolor is not None else '' f.write("%f %f %f\n" % (v[0], v[1], v[2])) f.write("POLYGONS %d %d \n" % (len(faces), 4 * len(faces))) for face_id in range(len(faces) - 1): f.write("3 %d %d %d\n" % (faces[face_id][0], faces[face_id][1], faces[face_id][2])) f.write("3 %d %d %d" % (faces[-1][0], faces[-1][1], faces[-1][2])) f.write( "\n \nCELL_DATA %d \nSCALARS scalars double \nLOOKUP_TABLE default" % len(faces)) for j, face in enumerate(faces): if j % 9 == 0: f.write("\n") f.write("%d " % face_labels[j]) print('done writing') transform_filter_grid = vtk.vtkTransformPolyDataFilter() transform_filter_grid.SetTransform(transform) transform_filter_grid.SetInputData(grid_3d) transform_filter_grid.Update() #grid_points = np.array( transform_filter.GetOutput().GetPoints().GetData() ) #grid_lines = np.array( transform_filter.GetOutput().GetLines().GetData() ) #poly = dsa.WrapDataObject(transform_filter.GetOutput()).Polygons #faces = np.reshape(poly,(-1,4))[:,1:4] #print('writing warped grid') #with open(out_name, 'w+') as f: #f.write("# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n" % len(grid_points)) #for vi, v in enumerate(grid_points): #vcol = ' %f %f %f' % (vcolor[vi, 0], vcolor[vi, 1], vcolor[vi, 2]) if vcolor is not None else '' #f.write("%f %f %f\n" % (v[0], v[1], v[2])) #f.write("LINES %d %d \n" % (len(grid_lines),2*len(grid_lines)-1)) #for lines_id in range(len(grid_lines) - 1): #f.write("3 %d %d %d\n" % (grid_lines[face_id][0] , faces[face_id][1], faces[face_id][2])) #f.write("3 %d %d %d" % (faces[-1][0], faces[-1][1], faces[-1][2])) #f.write("\n \nCELL_DATA %d \nSCALARS scalars double \nLOOKUP_TABLE default" % len(faces)) #for j,face in enumerate(faces): #if j%9 == 0: #f.write("\n") #f.write("%d " % face_labels[j]) #print('done writing') filt = vtk.vtkConnectivityFilter() filt.SetInputData(grid_3d) # get the data from the MC alg. #filt.ColorRegionsOn() filt.Update() ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) WIDTH = 640 HEIGHT = 480 renWin.SetSize(WIDTH, HEIGHT) #create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # mapper dataMapper1 = vtk.vtkPolyDataMapper() dataMapper2 = vtk.vtkPolyDataMapper() #dataMapper1.AddInputConnection(pd_in.GetOutputPort()) #dataMapper2.AddInputConnection(filt.GetOutputPort()) dataMapper1.AddInputConnection(transform_filter.GetOutputPort()) dataMapper2.AddInputConnection(transform_filter_grid.GetOutputPort()) #vtkPolyDataMapper = dataMapper.SetInputConnection(0,transform_filter.GetOutputPort()) #dataMapper.SetInputConnection(0,transform_filter.GetOutputPort()) #dataMapper.SetInputConnection(1,transform_filter_grid.GetOutputPort()) # actor dataActor1 = vtk.vtkActor() dataActor2 = vtk.vtkActor() dataActor1.SetMapper(dataMapper1) dataActor2.SetMapper(dataMapper2) # assign actor to the renderer ren.AddActor(dataActor1) ren.AddActor(dataActor2) # enable user interface interactor iren.Initialize() renWin.Render() iren.Start()
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # this is a tcl version of plate vibration ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # read a vtk file # plate = vtk.vtkPolyDataReader() plate.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/plate.vtk") plate.SetVectorsName("mode8") warp = vtk.vtkWarpVector() warp.SetInputConnection(plate.GetOutputPort()) warp.SetScaleFactor(0.5) normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(warp.GetOutputPort()) color = vtk.vtkVectorDot() color.SetInputConnection(normals.GetOutputPort()) lut = vtk.vtkLookupTable() lut.SetNumberOfColors(256) lut.Build() i = 0 while i < 128: lut.SetTableValue(i,expr.expr(globals(), locals(),["(","128.0","-i",")/","128.0"]),expr.expr(globals(), locals(),["(","128.0","-i",")/","128.0"]),expr.expr(globals(), locals(),["(","128.0","-i",")/","128.0"]),1) i = i + 1
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # read data # input = vtk.vtkPolyDataReader() input.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/brainImageSmooth.vtk") # # generate vectors clean = vtk.vtkCleanPolyData() clean.SetInputConnection(input.GetOutputPort()) smooth = vtk.vtkWindowedSincPolyDataFilter() smooth.SetInputConnection(clean.GetOutputPort()) smooth.GenerateErrorVectorsOn() smooth.GenerateErrorScalarsOn() smooth.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(smooth.GetOutputPort()) mapper.SetScalarRange(smooth.GetOutput().GetScalarRange()) brain = vtk.vtkActor() brain.SetMapper(mapper)
def flow(mesh_file, iter_num, show_flow=False): reader = vtk.vtkPolyDataReader() reader.SetFileName(mesh_file) reader.Update() mesh = reader.GetOutput() tol = 0.05 q = 1.0 dt = 0.001 orig_mesh = mesh prev_mesh = mesh thin_plate_spline_list = [] for i in range(iter_num + 1): deformed_surface_writer = vtk.vtkPolyDataWriter() deformed_surface_writer.SetFileName('data/flow/' + str(i) + '.vtk') deformed_surface_writer.SetInputData(mesh) deformed_surface_writer.Update() taubin_smooth = vtk.vtkWindowedSincPolyDataFilter() taubin_smooth.SetInputData(mesh) taubin_smooth.SetNumberOfIterations(20) taubin_smooth.BoundarySmoothingOff() taubin_smooth.FeatureEdgeSmoothingOff() taubin_smooth.SetPassBand(0.01) taubin_smooth.NonManifoldSmoothingOn() taubin_smooth.NormalizeCoordinatesOn() taubin_smooth.Update() mesh = taubin_smooth.GetOutput() normal_generator = vtk.vtkPolyDataNormals() normal_generator.SetInputData(mesh) normal_generator.SplittingOff() normal_generator.ComputePointNormalsOn() normal_generator.ComputeCellNormalsOff() normal_generator.Update() mesh = normal_generator.GetOutput() curvatures = vtk.vtkCurvatures() curvatures.SetCurvatureTypeToMean() curvatures.SetInputData(mesh) curvatures.Update() mean_curvatures = curvatures.GetOutput().GetPointData().GetArray("Mean_Curvature") normals = normal_generator.GetOutput().GetPointData().GetNormals() mesh_pts = mesh.GetPoints() for j in range(mesh.GetNumberOfPoints()): current_point = mesh.GetPoint(j) current_normal = np.array(normals.GetTuple3(j)) current_mean_curvature = mean_curvatures.GetValue(j) pt = np.array(mesh_pts.GetPoint(j)) pt -= dt * current_mean_curvature * current_normal mesh_pts.SetPoint(j, pt) mesh_pts.Modified() mesh.SetPoints(mesh_pts) mesh.Modified() # if i % 100 == 0 and show_flow: # plotter = pyvista.Plotter() # plotter.add_mesh(mesh) # plotter.show() tps_deform = get_thin_plate_spline_deform(prev_mesh, mesh) prev_mesh = mesh thin_plate_spline_list.append(tps_deform) # new_mesh = apply_tps_on_spokes_poly(mesh, thin_plate_spline_list) # plotter = pyvista.Plotter() # plotter.add_mesh(new_mesh, color='red', opacity=0.3) # plotter.add_mesh(orig_mesh, color='blue', opacity=0.3) # plotter.show() return mesh, thin_plate_spline_list
def addColors(infilename, outfilename, colorfilename=None, colorstring=None, binary=True, verbose=False): """add color array""" outformat = path.splitext(outfilename)[1].strip('.') if outformat != 'ply': raise ValueError('colors are only supported for PLY format') informat = path.splitext(infilename)[1].strip('.') # set reader based on filename extension if informat == 'stl': reader = vtk.vtkSTLReader() elif informat == 'vtk': reader = vtk.vtkPolyDataReader() elif informat == 'obj': reader = vtk.vtkMNIObjectReader() elif informat == 'ply': reader = vtk.vtkPLYReader() elif informat == 'vtp': reader = vtk.vtkXMLPolyDataReader() else: raise ValueError('cannot read input format: ' + informat) reader.SetFileName(infilename) reader.Update() #N = reader.GetOutput().GetNumberOfPolys() N = reader.GetOutput().GetNumberOfPoints() if verbose: print("read %i points (vertices)" % (N, )) if colorfilename: colorar = readColorFile(colorfilename) if N != colorar.shape[0]: raise ValueError('number of rows in color file does not match' + 'number of points in mesh file') elif colorstring: color = [int(i) for i in colorstring.split()] colorar = np.ones((N, 3)) * np.array(color) Colors = vtk.vtkUnsignedCharArray() Colors.SetNumberOfComponents(3) Colors.SetName("Colors") for i in range(0, N): Colors.InsertNextTuple3(*colorar[i, :]) polydata = vtk.vtkPolyData() polydata = reader.GetOutput() polydata.GetPointData().SetScalars(Colors) polydata.Modified() writer = vtk.vtkPLYWriter() writer.SetArrayName("Colors") writer.SetInputData(polydata) writer.SetFileName(outfilename) if binary: if verbose: print('setting output to binary') writer.SetFileTypeToBinary() else: if verbose: print('setting output to ascii') writer.SetFileTypeToASCII() err = writer.Write()