def NumpyCombinePixelValues(self,inputVolumeNode1, inputVolumeNode2): """This method gets Numpy array information from the input volumes and combines the pixel information to give an output numpy array. All input volumes must be the same size""" # Print to Slicer CLI print('Combining input pixels...'), start_time = time.time() # Get Image Data for Input Volumes imdata1 = inputVolumeNode1.GetImageData() imdata2 = inputVolumeNode2.GetImageData() # Get Dimensions of First Input (all inputs should match) x,y,z = imdata1.GetDimensions() # Get scalar data for all inputs scalars1 = imdata1.GetPointData().GetScalars() scalars2 = imdata2.GetPointData().GetScalars() ## Make Numpy Arrays from Scalar Data array1 = numpy_support.vtk_to_numpy(scalars1) array2 = numpy_support.vtk_to_numpy(scalars2) # Combine Arrays (must divide before summing or will add to more than 256 and wrap around values) #outputNumpyarray = array1/2+array2/2 outputNumpyarray = np.around(27*np.true_divide(array1,array2)) # For Normalization # Print to Slicer CLI end_time = time.time() print('done (%0.2f s)') % float(end_time-start_time) return outputNumpyarray
def read_data_and_build_snapshot_matrix(x_min,x_max,y_min,y_max,z_min,z_max,snapshot_dir,file_list,\ num_snapshots,num_points,num_components,var_name, A): reader = vtk.vtkUnstructuredGridReader() reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() extract_region = "false" if ( (x_min<x_max) and (y_min<y_max) and (z_min<z_max) ): extract_region = "true" extract = vtk.vtkExtractUnstructuredGrid() extract.SetExtent(x_min, x_max, y_min, y_max, z_min, z_max) extract.MergingOn() u_temp_read = np.array(np.zeros((num_points,3), dtype=np.float64)) print '\n Reading data ...' for j in range(0,num_snapshots+1): print ' Reading file ', file_list[j].strip(), 'file number ', j, ' of ', num_snapshots reader.SetFileName(snapshot_dir + file_list[j].strip()) reader.Update() if (extract_region=="true"): extract.SetInput(reader.GetOutput()) extract.Update() u_temp_read = VN.vtk_to_numpy(extract.GetOutput().GetPointData().GetVectors(var_name)) else: u_temp_read = VN.vtk_to_numpy(reader.GetOutput().GetPointData().GetVectors(var_name)) for k in range(0,num_components): A[k*num_points:(k+1)*num_points,j] = u_temp_read[:,k]
def get_normals(polydata): #normals = polydata.GetPointData().GetArray("Normals") normals = polydata.GetPointData().GetArray("Normals") print numpy_support.vtk_to_numpy(normals) return numpy_support.vtk_to_numpy(normals)
def execute(self): vessel=self._vessel array_v =dict(); for ff in ["ChestRegion"]: tmp=vessel.GetPointData().GetArray(ff) if isinstance(tmp,vtk.vtkDataArray) == False: tmp=vessel.GetFieldData().GetArray(ff) array_v[ff]=vtk_to_numpy(tmp) xyz_arr=vtk_to_numpy(vessel.GetPoints().GetData()) fig=plt.figure() ax = fig.add_subplot(111, projection='3d') ax.set_aspect('equal') X=xyz_arr[:,0] Y=xyz_arr[:,1] Z=xyz_arr[:,2] ax.scatter(X,Y,Z,s=1,c=array_v['ChestRegion'],marker='.',cmap=plt.cm.jet,linewidth=0) ax.grid(True) plt.xlabel('x') plt.ylabel('y') # Create cubic bounding box to simulate equal aspect ratio max_range = np.array([X.max()-X.min(), Y.max()-Y.min(), Z.max()-Z.min()]).max() Xb = 0.5*max_range*np.mgrid[-1:2:2,-1:2:2,-1:2:2][0].flatten() + 0.5*(X.max()+X.min()) Yb = 0.5*max_range*np.mgrid[-1:2:2,-1:2:2,-1:2:2][1].flatten() + 0.5*(Y.max()+Y.min()) Zb = 0.5*max_range*np.mgrid[-1:2:2,-1:2:2,-1:2:2][2].flatten() + 0.5*(Z.max()+Z.min()) # Comment or uncomment following both lines to test the fake bounding box: for xb, yb, zb in zip(Xb, Yb, Zb): ax.plot([xb], [yb], [zb], 'w') ax.view_init(elev=20.,azim=80) fig.savefig(self.output_prefix+'_vasculatureQualityControl.png',dpi=180)
def GetRawDICOMData(filenames,fileID): print filenames,fileID vtkRealDcmReader = vtk.vtkDICOMImageReader() vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) ) vtkRealDcmReader.Update() vtkRealData = vtk.vtkImageCast() vtkRealData.SetOutputScalarTypeToFloat() vtkRealData.SetInput( vtkRealDcmReader.GetOutput() ) vtkRealData.Update( ) real_image = vtkRealData.GetOutput().GetPointData() real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0)) vtkImagDcmReader = vtk.vtkDICOMImageReader() vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) ) vtkImagDcmReader.Update() vtkImagData = vtk.vtkImageCast() vtkImagData.SetOutputScalarTypeToFloat() vtkImagData.SetInput( vtkImagDcmReader.GetOutput() ) vtkImagData.Update( ) imag_image = vtkImagData.GetOutput().GetPointData() imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0)) vtkAppend = vtk.vtkImageAppendComponents() vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() ) vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() ) vtkAppend.Update( ) vtkDcmWriter = vtk.vtkDataSetWriter() vtkDcmWriter.SetFileName("rawdata.%04d.vtk" % fileID ) vtkDcmWriter.SetInput(vtkAppend.GetOutput()) vtkDcmWriter.Update() return (real_array,imag_array)
def rdmmag(X1,X2): X1 = vtk_to_numpy(X1) X2 = vtk_to_numpy(X2) rdm = la.norm(X1/la.norm(X1)-X2/la.norm(X2)) rmag = abs(1.-la.norm(X2)/la.norm(X1)) print " RDM = ",rdm, "\t rMAG = ",rmag return rdm, rmag
def _extractRectGridByBounds(vtrObj,boundObj): ''' Function that extracts cell from a rectilinear grid (vtr) using bounds. Should be signifacantly faster the extractBounds method. ''' import numpy as np, SimPEG as simpeg, vtk import vtk.util.numpy_support as npsup bO = boundObj.GetBounds() xC = npsup.vtk_to_numpy(vtrObj.GetXCoordinates()) yC = npsup.vtk_to_numpy(vtrObj.GetYCoordinates()) zC = npsup.vtk_to_numpy(vtrObj.GetZCoordinates()) iLT = np.where(xC <= bO[0])[0] iL = 0 if iLT.shape[0] == 0 else iLT[-1] iUT = np.where(xC >= bO[1])[0] iU = len(xC) if iUT.shape[0] == 0 else iUT[0] jLT = np.where(yC <= bO[2])[0] jL = 0 if jLT.shape[0] == 0 else jLT[-1] jUT = np.where(yC >= bO[3])[0] jU = len(yC) if jUT.shape[0] == 0 else jUT[0] kLT = np.where(zC <= bO[4])[0] kL = 0 if kLT.shape[0] == 0 else kLT[-1] kUT = np.where(zC >= bO[5])[0] kU = len(zC) if kUT.shape[0] == 0 else kUT[0] extRect = vtk.vtkExtractRectilinearGrid() extRect.SetInputData(vtrObj) extRect.SetVOI((iL,iU,jL,jU,kL,kU)) extRect.Update() return extRect
def PlotData(self): # remove any measurement line that might exist self.removeMeasurementLine(False) if self._usebar is False: # handle 'pixel' vs 'mm' options: self._transform.Identity() self._transform.Scale(self._unit_scalings[self._unit], self._unit_scalings[ self._unit], self._unit_scalings[self._unit]) self._plotData.Update() points = numpy_support.vtk_to_numpy( self._plotData.GetPoints().GetData()) points = (points - points[0]).transpose() self.xdata = sum(points * points) ** 0.5 self.ydata = numpy_support.vtk_to_numpy( self._plotData.GetPointData().GetScalars()).astype('float32') else: inc = abs(self.xdata[1] - self.xdata[0]) self.lower_panel.m_spinCtrlLower.SetIncrement(inc) self.lower_panel.m_spinCtrlUpper.SetIncrement(inc) self.lower_panel.m_spinCtrlLower.SetMin(self.xdata[0]) self.lower_panel.m_spinCtrlLower.SetMax(self.xdata[-1]) self.lower_panel.m_spinCtrlUpper.SetMin(self.xdata[0]) self.lower_panel.m_spinCtrlUpper.SetMax(self.xdata[-1]) self.draw_plot() self.canvas.draw()
def vtk_ensure_trilist(polydata): try: import vtk from vtk.util.numpy_support import vtk_to_numpy trilist = vtk_to_numpy(polydata.GetPolys().GetData()) # 5 is the triangle type - if we have another type we need to # use a vtkTriangleFilter c = vtk.vtkCellTypes() polydata.GetCellTypes(c) if c.GetNumberOfTypes() != 1 or polydata.GetCellType(0) != 5: warnings.warn('Non-triangular mesh connectivity was detected - ' 'this is currently unsupported and thus the ' 'connectivity is being coerced into a triangular ' 'mesh. This may have unintended consequences.') t_filter = vtk.vtkTriangleFilter() t_filter.SetInputData(polydata) t_filter.Update() trilist = vtk_to_numpy(t_filter.GetOutput().GetPolys().GetData()) return trilist.reshape([-1, 4])[:, 1:] except Exception as e: warnings.warn(str(e)) return None
def read_vtk(self, data_dir='./data', file_name='separatrices.vtk'): """ Read the separatrices from a vtk file. call signature: read_vtk(data_dir='./data', file_name='separatrices.vtk') Arguments: *data_dir*: Origin data directory. *file_name*: Origin file name. """ reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(os.path.join(data_dir, file_name)) reader.Update() output = reader.GetOutput() # Read the separatrices. points = output.GetPoints() cells = output.GetCells() self.separatrices = [] self.connectivity = [] for separatrix in range(points.GetNumberOfPoints()): self.separatrices.append(points.GetPoint(separatrix)) self.separatrices = np.array(self.separatrices) self.connectivity = np.array([VN.vtk_to_numpy(cells.GetData())[1::3], VN.vtk_to_numpy(cells.GetData())[2::3]]) self.connectivity = self.connectivity.swapaxes(0, 1)
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 test_pointdata(self): self.nrrdArray = ns.vtk_to_numpy( self.rnrrd.GetOutput().GetPointData().GetScalars() ) self.itkArray = ns.vtk_to_numpy( self.ritk.GetOutput().GetPointData().GetScalars() ) self.assertTrue(numpy.allclose(self.nrrdArray, self.itkArray))
def rdmmag(X1, X2): """Rdm and Mag calculation.""" X1 = vtk_to_numpy(X1) X2 = vtk_to_numpy(X2) rdm = la.norm(X1 / la.norm(X1) - X2 / la.norm(X2)) rmag = abs(1. - la.norm(X2) / la.norm(X1)) print(" RDM = ", rdm, "\t rMAG = ", rmag) return rdm, rmag
def getDataArray(vtkObj,name,arrType='Cell'): """Function that returns the cell/point data array. """ return npsup.vtk_to_numpy(vtkObj.GetCellData().GetArray(name)) if arrType == 'Cell': return npsup.vtk_to_numpy(vtkObj.GetCellData().GetArray(name)) elif arrType == 'Point': return npsup.vtk_to_numpy(vtkObj.GetPointData().GetArray(name)) else: raise Exception('Not a support arrType')
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 __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 ply_importer(filepath, asset=None, texture_resolver=None, **kwargs): """Allows importing Wavefront (OBJ) files. Uses VTK. Parameters ---------- asset : `object`, optional An optional asset that may help with loading. This is unused for this implementation. texture_resolver : `callable`, optional A callable that recieves the mesh filepath and returns a single path to the texture to load. \**kwargs : `dict`, optional Any other keyword arguments. Returns ------- shape : :map:`PointCloud` or subclass The correct shape for the given inputs. """ import vtk from vtk.util.numpy_support import vtk_to_numpy ply_importer = vtk.vtkPLYReader() ply_importer.SetFileName(str(filepath)) ply_importer.Update() # Get the output polydata = ply_importer.GetOutput() # We must have point data! points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float) trilist = np.require(vtk_ensure_trilist(polydata), requirements=['C']) texture = None if texture_resolver is not None: texture_path = texture_resolver(filepath) if texture_path is not None and texture_path.exists(): texture = mio.import_image(texture_path) tcoords = None if texture is not None: try: tcoords = vtk_to_numpy(polydata.GetPointData().GetTCoords()) except Exception: pass if isinstance(tcoords, np.ndarray) and tcoords.size == 0: tcoords = None colour_per_vertex = None return _construct_shape_type(points, trilist, tcoords, texture, colour_per_vertex)
def feature_extractor(self,in_vtk): points = vtk_to_numpy(in_vtk.GetPoints().GetData()) vec= vtk_to_numpy(in_vtk.GetPointData().GetArray("hevec0")) #features =np.concatenate((points, vec[:,0:1]),axis=1) features = points #features=StandardScaler().fit_transform(features) pca = PCA(n_components=4) pca.fit(features) features_t=pca.transform(features) return features_t[:,[0,1]]
def read_vtk(self, data_dir='./data', file_name='nulls.vtk'): """ Read the null point from a vtk file. call signature: read_vtk(data_dir='./data', file_name='nulls.vtk') Arguments: *data_dir*: Origin data directory. *file_name*: Origin file name. """ reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(os.path.join(data_dir, file_name)) reader.Update() output = reader.GetOutput() # Read the null points. points = output.GetPoints() self.nulls = [] for null in range(points.GetNumberOfPoints()): self.nulls.append(points.GetPoint(null)) self.nulls = np.array(self.nulls) point_data = output.GetPointData() eigen_values_vtk = [] eigen_values = [] eigen_vectors_vtk = [] eigen_vectors = [] fan_vectors_vtk = [] fan_vectors = [] for dim in range(3): eigen_values_vtk.append(point_data.GetVectors('eigen_value_{0}'.format(dim))) eigen_values.append(VN.vtk_to_numpy(eigen_values_vtk[-1])) eigen_vectors_vtk.append(point_data.GetVectors('eigen_vector_{0}'.format(dim))) eigen_vectors.append(VN.vtk_to_numpy(eigen_vectors_vtk[-1])) if dim < 2: fan_vectors_vtk.append(point_data.GetVectors('fan_vector_{0}'.format(dim))) fan_vectors.append(VN.vtk_to_numpy(fan_vectors_vtk[-1])) sign_trace_vtk = point_data.GetVectors('sign_trace') sign_trace = VN.vtk_to_numpy(sign_trace_vtk) normals_vtk = point_data.GetVectors('normal') normals = VN.vtk_to_numpy(normals_vtk) self.eigen_values = np.swapaxes(np.array(eigen_values), 0, 1) self.eigen_vectors = np.swapaxes(np.array(eigen_vectors), 0, 1) self.fan_vectors = np.swapaxes(np.array(fan_vectors), 0, 1) self.sign_trace = np.array(sign_trace) self.normals = np.array(normals)
def get_points_normals_from(polydata): nodes_vtk_array = polydata.GetPoints().GetData() array = vtk_to_numpy(nodes_vtk_array) numberArrays = polydata.GetPointData().GetNumberOfArrays() for i in range(numberArrays): if polydata.GetPointData().GetArrayName(i) == "Normals": array_normals = vtk_to_numpy(polydata.GetPointData().GetScalars("Normals")) return array, array_normals else: raise Exception("No available Normals")
def PrepareMesh(self, nclus, subratio, verbose): """ Initialize mesh parameters, to include subdividing mesh if necessary""" # Check if the mesh needs to be subdivided if self.mode == 'face': n = self.origmesh.GetPolys().GetNumberOfCells() else: n = self.origmesh.GetPoints().GetNumberOfPoints() # Required number of points/faces nreq = nclus*subratio if nreq > n: # Determine the number of subdivisions given that each subdivision generates 4 triangles # per single triangle input or two points per triangle if self.mode == 'face': nsub = int(ceil(log(float(nreq)/n, 4))) # solved given nreq = n*4**nsub else: nsub = int(ceil(log(float(nreq)/n, 3))) # solved given nreq = n*2**nsub if verbose: print('Subdividing mesh with {:d} subdivision(s)'.format(nsub)); sys.stdout.flush() # Perform subdivision self.mesh = SubdivideMesh(self.origmesh, nsub) else: self.mesh = self.origmesh # Extract vertices and faces of mesh f = VN.vtk_to_numpy(self.mesh.GetPolys().GetData()).reshape((-1, 4)).astype(np.int32) v = VN.vtk_to_numpy(self.mesh.GetPoints().GetData()).astype(np.float) # Store faces without padding self.fc = f[:, 1:] if self.mode == 'face': # Get face areas and centroids self.area = GetTriangleArea(v, f) self.cent = v.take(self.fc, axis=0).mean(1) else: # Compute the mean of area of the triangles adjcent to a point self.area = GetPointWeight(v, f) # Centers are simply the surface points self.cent = v # Develop face/edge associations or get the points at either edge of unique edges self.edgeID = GetEdgeID(self.fc, self.mode) self.nclus = nclus
def extract_particles(self,ids): data=vtk.vtkPolyData() points=vtk_to_numpy(self._in_vtk.GetPoints().GetData()) s_points=vtk.vtkPoints() cell_arr=vtk.vtkCellArray() #s_points.SetData(numpy_to_vtk(points[ids,:])) #s_points.SetNumberOfPoints(s_points.GetData().GetNumberOfTuples()) s_p = points[ids,:] s_points.SetNumberOfPoints(s_p.shape[0]) cell_arr.SetNumberOfCells(s_p.shape[0]) for kk in xrange(s_p.shape[0]): s_points.SetPoint(kk,s_p[kk,0],s_p[kk,1],s_p[kk,2]) cell_arr.InsertNextCell(1) cell_arr.InsertCellPoint(kk) data.SetPoints(s_points) data.SetVerts(cell_arr) #Transfer point data and field data for pd,out_pd in zip([self._in_vtk.GetPointData(),self._in_vtk.GetFieldData()],[data.GetPointData(),data.GetFieldData()]): for k in xrange(pd.GetNumberOfArrays()): arr=vtk_to_numpy(pd.GetArray(pd.GetArrayName(k))) if len(arr.shape) == 1: s_vtk_arr=numpy_to_vtk(arr[ids],1) else: s_vtk_arr=numpy_to_vtk(arr[ids,:],1) s_vtk_arr.SetName(pd.GetArrayName(k)) out_pd.AddArray(s_vtk_arr) return data #Method to do the extraction using a vtk pipeline (experimental with seg fault) def extract_using_vtk(self,ids): node=vtk.vtkSelectionNode() sel = vtk.vtkSelection() node.GetProperties().Set(vtk.vtkSelectionNode.CONTENT_TYPE(),\ vtk.vtkSelectionNode.INDICES) node.GetProperties().Set(vtk.vtkSelectionNode.FIELD_TYPE(),\ vtk.vtkSelectionNode.POINT) #Create Id Array with point Ids for each cluster vtk_ids=numpy_to_vtkIdTypeArray(ids) node.SetSelectionList(vtk_ids) #sel_filter = vtk.vtkExtractSelectedPolyDataIds() sel_filter = vtk.vtkExtractSelection() sel_filter.SetInput(0,self._in_vtk) sel_filter.SetInput(1,sel) sel_filter.Update() return sel_filter.GetOutput()
def compute_nonzeromean(polydata,inarrayname,pointdata=True): if polydata.GetNumberOfPoints() > 0 : if pointdata: array = vtk_to_numpy(polydata.GetPointData().GetArray(inarrayname)) else: array = vtk_to_numpy(polydata.GetCellData().GetArray(inarrayname)) array_masked = np.ma.array( array, mask = (array <= 0) ) array_nonan = array_masked[~np.isnan(array_masked)] return array_nonan.mean() else: return 0.
def GetRawDICOMData(filenames,fileID): print filenames,fileID vtkRealDcmReader = vtk.vtkDICOMImageReader() vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) ) vtkRealDcmReader.Update() vtkRealData = vtk.vtkImageCast() vtkRealData.SetOutputScalarTypeToFloat() vtkRealData.SetInput( vtkRealDcmReader.GetOutput() ) vtkRealData.Update( ) real_image = vtkRealData.GetOutput().GetPointData() real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0)) vtkImagDcmReader = vtk.vtkDICOMImageReader() vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) ) vtkImagDcmReader.Update() vtkImagData = vtk.vtkImageCast() vtkImagData.SetOutputScalarTypeToFloat() vtkImagData.SetInput( vtkImagDcmReader.GetOutput() ) vtkImagData.Update( ) imag_image = vtkImagData.GetOutput().GetPointData() imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0)) vtkAppend = vtk.vtkImageAppendComponents() vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() ) vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() ) vtkAppend.Update( ) # write raw data vtkRawData = vtkAppend.GetOutput() vtkRawData.SetSpacing( spacing ) vtkDcmWriter = vtk.vtkDataSetWriter() vtkDcmWriter.SetFileTypeToBinary() vtkDcmWriter.SetFileName("s%d/rawdata.%04d.vtk" % (dirID,fileID) ) vtkDcmWriter.SetInput( vtkRawData ) vtkDcmWriter.Update() # write raw phase data vtkPhase = vtk.vtkImageMathematics() vtkPhase.SetInput1( vtkRealData.GetOutput() ) vtkPhase.SetInput2( vtkImagData.GetOutput() ) vtkPhase.SetOperationToATAN2( ) vtkPhase.Update( ) vtkPhaseData = vtkPhase.GetOutput() vtkPhaseData.SetSpacing( spacing ) vtkDcmWriter = vtk.vtkDataSetWriter() vtkDcmWriter.SetFileTypeToBinary() vtkDcmWriter.SetFileName("s%d/phase.%04d.vtk" % (dirID,fileID) ) vtkDcmWriter.SetInput( vtkPhaseData) vtkDcmWriter.Update() return (real_array,imag_array)
def __init__(self, polyData): vertices3D = convert.vtk_to_numpy(polyData.GetPoints().GetData()) # FiPy needs its coordinates in an array like: # [[x0, x1, ..., xn-1], # [y0, y1, ..., yn-1]] # VTK gives us: # [[x0, y0, z0], # [x1, y1, z1], # ..., # [xn-1, yn-1, zn-1]] self.vertices = vertices3D[:,0:2].transpose() # VTK gives us a flat array of cells like # [nPoints, pId0, pId1, pId2, ... nPoints,... ] cells = convert.vtk_to_numpy(polyData.GetPolys().GetData()) self.nTris = nTris = polyData.GetPolys().GetNumberOfCells() cells.shape = (nTris, 4) # So now cells[i] contains (3, id0, id1, id2) for triangle i # FiPy requires a list of the FACES (in 2D the lines) making up each # cell. Make the array the maximum possible size for now. self.faces = np.zeros((2, 3*nTris), dtype=np.int) # Since these have to be unique, construct a sparse lookup matrix # (a dictionary is very sloooooow) ############################################################ # SUPER IMPORTANT- since the default value of the matrix is # zero, we're going to use 1-indexing for these so +1 when # writing and -1 when reading. ############################################################ self.faceCache = lil_matrix((nTris,nTris), dtype=np.int) # Track the number of faces added. self.nFaces = 0 # A cell is defined by the IDs of its faces self.cells = np.zeros((3, nTris), dtype=np.int) # Track the number added self.nCells = 0 for triPtIds in cells[:,1:]: for i in xrange(3): self.cells[i, self.nCells] = self._InsertUniqueFace(triPtIds[i], triPtIds[(i+1) % 3]) continue self.nCells += 1 continue # Trim the unused face rows self.faces = self.faces[:,:self.nFaces] return
def readVTK(reader,fname): reader.SetFileName(fname) reader.Update() polydata = reader.GetOutput() nodes_vtk_array= polydata.GetPoints().GetData() var_vtk_array = polydata.GetCellData().GetArray(0) #Get the coordinates of the nodes and their temperatures nodes_nummpy_array = numpy_support.vtk_to_numpy(nodes_vtk_array) x,y,z= nodes_nummpy_array[:,0] , nodes_nummpy_array[:,1] , nodes_nummpy_array[:,2] var_numpy_array = numpy_support.vtk_to_numpy(var_vtk_array) return var_numpy_array
def OnNavR(self, prev_ped_id): out_polys = self.areapoly1.GetOutputDataObject(0) poly_bounds = VN.vtk_to_numpy(out_polys.GetCellData().GetArray('area')) vertex_ids = VN.vtk_to_numpy(out_polys.GetCellData().GetArray('vertex_ids')) same_scale_ids = N.nonzero(self.ds.Scales==self.ds.Scales[prev_ped_id])[0] same_scale_xmins = poly_bounds[self.ds.Scales==self.ds.Scales[prev_ped_id], 0] ordered_scale_ids = same_scale_ids[same_scale_xmins.argsort()] prev_idx = N.nonzero(ordered_scale_ids==prev_ped_id)[0] if prev_idx < (ordered_scale_ids.size - 1): return ordered_scale_ids[prev_idx + 1] else: return ordered_scale_ids[prev_idx]
def readVTRFile(fileName): """ Read VTK Rectilinear (vtr xml file) and return SimPEG Tensor mesh and model Input: :param vtrFileName, path to the vtr model file to write to Output: :return SimPEG TensorMesh object :return SimPEG model dictionary """ # Import from vtk import vtkXMLRectilinearGridReader as vtrFileReader from vtk.util.numpy_support import vtk_to_numpy # Read the file vtrReader = vtrFileReader() vtrReader.SetFileName(fileName) vtrReader.Update() vtrGrid = vtrReader.GetOutput() # Sort information hx = np.abs(np.diff(vtk_to_numpy(vtrGrid.GetXCoordinates()))) xR = vtk_to_numpy(vtrGrid.GetXCoordinates())[0] hy = np.abs(np.diff(vtk_to_numpy(vtrGrid.GetYCoordinates()))) yR = vtk_to_numpy(vtrGrid.GetYCoordinates())[0] zD = np.diff(vtk_to_numpy(vtrGrid.GetZCoordinates())) # Check the direction of hz if np.all(zD < 0): hz = np.abs(zD[::-1]) zR = vtk_to_numpy(vtrGrid.GetZCoordinates())[-1] else: hz = np.abs(zD) zR = vtk_to_numpy(vtrGrid.GetZCoordinates())[0] x0 = np.array([xR,yR,zR]) # Make the SimPEG object from SimPEG import Mesh tensMsh = Mesh.TensorMesh([hx,hy,hz],x0) # Grap the models modelDict = {} for i in np.arange(vtrGrid.GetCellData().GetNumberOfArrays()): modelName = vtrGrid.GetCellData().GetArrayName(i) if np.all(zD < 0): modFlip = vtk_to_numpy(vtrGrid.GetCellData().GetArray(i)) tM = tensMsh.r(modFlip,'CC','CC','M') modArr = tensMsh.r(tM[:,:,::-1],'CC','CC','V') else: modArr = vtk_to_numpy(vtrGrid.GetCellData().GetArray(i)) modelDict[modelName] = modArr # Return the data return tensMsh, modelDict
def vtkPolyData_to_tracts(polydata, return_tractography_object=True): r''' Reads a VTKPolyData object and outputs a tracts/tracts_data pair Parameters ---------- polydata : vtkPolyData VTKPolyData Object 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. ''' result = {} result['lines'] = ns.vtk_to_numpy(polydata.GetLines().GetData()) result['points'] = ns.vtk_to_numpy(polydata.GetPoints().GetData()) result['numberOfLines'] = polydata.GetNumberOfLines() data = {} if polydata.GetPointData().GetScalars(): data['ActiveScalars'] = polydata.GetPointData().GetScalars().GetName() if polydata.GetPointData().GetVectors(): data['ActiveVectors'] = polydata.GetPointData().GetVectors().GetName() if polydata.GetPointData().GetTensors(): data['ActiveTensors'] = polydata.GetPointData().GetTensors().GetName() for i in range(polydata.GetPointData().GetNumberOfArrays()): array = polydata.GetPointData().GetArray(i) np_array = ns.vtk_to_numpy(array) if np_array.ndim == 1: np_array = np_array.reshape(len(np_array), 1) data[polydata.GetPointData().GetArrayName(i)] = np_array result['pointData'] = data tracts, data = vtkPolyData_dictionary_to_tracts_and_data(result) if return_tractography_object: tr = Tractography() tr.append(tracts, data) return tr else: return tracts, data
def get_cell_volumes(x_min,x_max,y_min,y_max,z_min,z_max,filename,cell_volume): reader = vtk.vtkUnstructuredGridReader() reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() reader.SetFileName(filename) reader.Update() if ( (x_min<x_max) and (y_min<y_max) and (z_min<z_max) ): extract = vtk.vtkExtractUnstructuredGrid() extract.SetExtent(x_min, x_max, y_min, y_max, z_min, z_max) extract.SetInput(reader.GetOutput()) extract.MergingOn() extract.Update() cell_volume = VN.vtk_to_numpy(extract.GetOutput().GetPointData().GetScalars("cell_volume")) else: cell_volume = VN.vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars("cell_volume"))
def convert(input, output, force=True, only_points=True): # print('Converting', len(input), 'files.') file_i = input if not os.path.exists(file_i): print('ERROR', 'Could not find file:', file_i) return # print('Converting', file_i) input_basename = os.path.basename(file_i) if input_basename.endswith('vtp'): r = vtk.vtkXMLPolyDataReader() r.SetFileName(file_i) r.Update() polydata = r.GetOutput() elif input_basename.endswith('vtk'): r = vtk.vtkPolyDataReader() r.SetFileName(file_i) r.Update() polydata = r.GetOutput() points = numpy_support.vtk_to_numpy(polydata.GetPoints().GetData()) lines = numpy_support.vtk_to_numpy(polydata.GetLines().GetData()) number_of_streamlines = polydata.GetLines().GetNumberOfCells() # if (number_of_streamlines == 0): # print('ERROR', 'No streamlines in file:', file_i) # continue # # convert to streamlines # streamlines = [] i = 0 current_fiber_id = 0 line_length = 0 if len(lines) > 0: line_length = lines[i] line_index = 0 while (line_index < number_of_streamlines): # print(line_index,'start',i+1,'len',line_length) current_line = lines[i + 1 + line_index:i + 1 + line_length + line_index] current_points = np.zeros((line_length, 3), dtype=np.float32) for p_i, p in enumerate(current_line): current_points[p_i] = points[p] streamlines.append(current_points) i += line_length line_index += 1 if line_index < number_of_streamlines: line_length = lines[i + line_index] # # # # create header # # # hdr = {'vox_to_ras':np.eye(4), # 'voxel_size':np.ones(3), # 'dim':np.array([256,256,256]), # 'scalar_name':scalar_names, # 'property_name':property_names} tractogram = nibabel.streamlines.tractogram.Tractogram( streamlines, affine_to_rasmm=np.eye(4)) tck = nibabel.streamlines.tck.TckFile(tractogram) with open(output, 'wb') as f: # nibabel.trackvis.write(f, streamlines, hdr) tck.save(f)
def find_plane_mesh_intersection(mesh, proj, use_vtk_for_intersection=True): # Find axis orthogonal to the projection of interest axis = [a for a in [0, 1, 2] if a not in proj][0] # Get all mesh points points = vtknp.vtk_to_numpy(mesh.GetPoints().GetData()) if not np.abs(points[:, axis]).sum(): raise Exception("Only zeros found in the plane axis.") if use_vtk_for_intersection: mid = np.mean(points[:, axis]) '''Set the plane a little off center to avoid undefined intersections. Without this the code hangs when the mesh has any edge aligned with the projection plane. Also add a little of noisy to the coordinates to help with the same problem.''' mid += 0.75 offset = 0.1 * np.ptp(points, axis=0).max() # Create a vtkPlaneSource plane = vtk.vtkPlaneSource() plane.SetXResolution(4) plane.SetYResolution(4) if axis == 0: plane.SetOrigin(mid, points[:, 1].min() - offset, points[:, 2].min() - offset) plane.SetPoint1(mid, points[:, 1].min() - offset, points[:, 2].max() + offset) plane.SetPoint2(mid, points[:, 1].max() + offset, points[:, 2].min() - offset) if axis == 1: plane.SetOrigin(points[:, 0].min() - offset, mid, points[:, 2].min() - offset) plane.SetPoint1(points[:, 0].min() - offset, mid, points[:, 2].max() + offset) plane.SetPoint2(points[:, 0].max() + offset, mid, points[:, 2].min() - offset) if axis == 2: plane.SetOrigin(points[:, 0].min() - offset, points[:, 1].min() - offset, mid) plane.SetPoint1(points[:, 0].min() - offset, points[:, 1].max() + offset, mid) plane.SetPoint2(points[:, 0].max() + offset, points[:, 1].min() - offset, mid) plane.Update() plane = plane.GetOutput() # Trangulate the plane triangulate = vtk.vtkTriangleFilter() triangulate.SetInputData(plane) triangulate.Update() plane = triangulate.GetOutput() # Calculate intersection intersection = vtk.vtkIntersectionPolyDataFilter() intersection.SetInputData(0, mesh) intersection.SetInputData(1, plane) intersection.Update() intersection = intersection.GetOutput() # Get coordinates of intersecting points points = vtknp.vtk_to_numpy(intersection.GetPoints().GetData()) coords = points[:, proj] else: valids = np.where((points[:, axis] > -2.5) & (points[:, axis] < 2.5)) coords = points[valids[0]][:, proj] # Sorting points clockwise # This has been discussed here: # https://stackoverflow.com/questions/51074984/sorting-according-to-clockwise-point-coordinates/51075469 # but seems not to be very efficient. Better version is proposed here: # https://stackoverflow.com/questions/57566806/how-to-arrange-the-huge-list-of-2d-coordinates-in-a-clokwise-direction-in-python center = tuple( map( operator.truediv, reduce(lambda x, y: map(operator.add, x, y), coords), [len(coords)] * 2, )) coords = sorted( coords, key=lambda coord: (-135 - math.degrees( math.atan2(*tuple(map(operator.sub, coord, center))[::-1]))) % 360, ) # Store sorted coordinates # points[:, proj] = coords return np.array(coords)
def vtkcontourfgrid(cutMapper, pl3d_output, src_output, var_name, levels, snapshot_dir, plane_normal, scalarRange): # if not X_is_running(): # return #off-screen rendering #gfac = vtk.vtkGraphicsFactory #gfac.SetOffScreenOnlyMode(1) #gfac.SetUseMesaClasses(1) #im_fac = vtk.vtkImagingFactory #im_fac.SetUseMesaClasses(1) pl3d_output.GetPointData().SetActiveScalars(var_name) if (scalarRange == (0, 0)): #print scalarRange # this prevents zero values from setting colourbar scalarnump = VN.vtk_to_numpy( src_output.GetPointData().GetScalars(var_name)) minval = np.amin(scalarnump) try: if (minval >= 0.0): minval = np.amin(scalarnump[scalarnump > 0.0]) except Exception: pass maxval = np.amax(scalarnump) scalarRange = (minval, maxval) #print scalarRange #scalarRange =pl3d_output.GetPointData().GetScalars(var_name).GetRange() cutMapper.SetScalarRange(scalarRange) cutActor = vtk.vtkActor() cutActor.SetMapper(cutMapper) lut = vtk.vtkLookupTable() #MakeLUT() lut.SetNumberOfTableValues(levels) lut.SetHueRange(0.667, 0.0) lut.SetNanColor(1, 0, 0, 1) lut.Build() cutMapper.SetLookupTable(lut) scalarBar = vtk.vtkScalarBarActor() scalarBar.SetLookupTable(lut) scalarBar.SetTitle(var_name) # Add the actors to the renderer, set the background and size #ren.AddActor(outlineActor) #ren.AddActor(planeActor) # Create the RenderWindow, Renderer and both Actors ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetOffScreenRendering(1) #off-screen render renWin.AddRenderer(ren) #iren = vtk.vtkRenderWindowInteractor() #iren.SetRenderWindow(renWin) ren.AddActor(cutActor) ren.AddActor2D(scalarBar) ren.SetBackground(0, 0, 0) renWin.SetSize(2800, 1600) camera = vtk.vtkCamera() camera.SetPosition(plane_normal) ren.SetActiveCamera(camera) #zoom ren.ResetCamera() ren.GetActiveCamera().Zoom(0.9) ren.GetActiveCamera().Dolly(1.4) ren.ResetCameraClippingRange() #off-screen renWin.Render() win2im = vtk.vtkWindowToImageFilter() win2im.SetInput(renWin) win2im.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(snapshot_dir + '.png') writer.SetInputConnection(win2im.GetOutputPort()) writer.Write()
def main(sysargs): # handle arguments parser = argparse.ArgumentParser('Process args') parser.add_argument('--inputDWI', required=True, type=str) parser.add_argument('--bvalues', required=True, type=str) parser.add_argument('--tolerance', required=True, type=float) parser.add_argument('--outputDWI', required=True, type=str) args = parser.parse_args(sysargs) dwifile = args.inputDWI outfile = args.outputDWI target_bvals = map(float, args.bvalues.split(',')) bval_tolerance = args.tolerance # load data sn = slicer.vtkMRMLNRRDStorageNode() sn.SetFileName(dwifile) node_in = mrml.vtkMRMLDiffusionWeightedVolumeNode() print("loading: ", dwifile) sn.ReadData(node_in) dwi_in = slicer.util.arrayFromVolume(node_in) # sanity check that the last axis is volumes assert (node_in.GetNumberOfGradients() == dwi_in.shape[-1] ), "Number of gradients do not match the size of last image axis!" bvals_in = numpy_support.vtk_to_numpy(node_in.GetBValues()) grads_in = numpy_support.vtk_to_numpy(node_in.GetDiffusionGradients()) for (i, g) in enumerate(grads_in): norm = np.linalg.norm(g) if norm > 1e-6: grads_in[i] = g * 1 / norm print(" input gradients: ") print(grads_in) print(" input bvals: ") print(bvals_in) # select the indices to keep based on b value indices = [] for (i, bval) in enumerate(bvals_in): for check_bval in target_bvals: if abs(bval - check_bval) < bval_tolerance: indices.append(i) print("selected indices: ", indices) # output shape: (3d_vol_shape..., num_indices) num_indices = len(indices) shape_out = dwi_in.shape[:-1] + (num_indices, ) print("input shape: ", dwi_in.shape) print("output shape: ", shape_out) # construct output subset vol_out = np.zeros(shape_out, dtype=dwi_in.dtype) grads_out = np.zeros((num_indices, 3)) bvals_out = np.zeros(num_indices) for (new_i, index) in enumerate(indices): vol_out[:, :, :, new_i] = dwi_in[:, :, :, index] grads_out[new_i, :] = grads_in[index, :] bvals_out[new_i] = bvals_in[index] print("selected bvals: ", bvals_out) print(" grads_out shape: ", grads_out.shape) print(" vol_out shape: ", vol_out.shape) # write output sn_out = slicer.vtkMRMLNRRDStorageNode() sn_out.SetFileName(outfile) node_out = mrml.vtkMRMLDiffusionWeightedVolumeNode() # copy image information node_out.Copy(node_in) # reset the attribute dictionary, otherwise it will be transferred over attrs = vtk.vtkStringArray() node_out.GetAttributeNames(attrs) for i in xrange(0, attrs.GetNumberOfValues()): node_out.SetAttribute(attrs.GetValue(i), None) # reset the data array to force resizing, otherwise we will just keep the old data too node_out.SetAndObserveImageData(None) slicer.util.updateVolumeFromArray(node_out, vol_out) node_out.SetNumberOfGradients(num_indices) node_out.SetBValues(numpy_support.numpy_to_vtk(bvals_out)) node_out.SetDiffusionGradients(numpy_support.numpy_to_vtk(grads_out)) node_out.Modified() sn_out.WriteData(node_out)
from vtk.util import numpy_support as VN reader = vtkStructuredPointsReader() reader.SetFileName('../../../temp/bb480.vtk') reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() data = reader.GetOutput() dim = data.GetDimensions() vec = list(dim) vec = [i - 1 for i in dim] vec.append(3) u = VN.vtk_to_numpy(data.GetCellData().GetArray('velocity')) b = VN.vtk_to_numpy(data.GetCellData().GetArray('cell_centered_B')) u = u.reshape(vec, order='F') b = b.reshape(vec, order='F') x = zeros(data.GetNumberOfPoints()) y = zeros(data.GetNumberOfPoints()) z = zeros(data.GetNumberOfPoints()) for i in range(data.GetNumberOfPoints()): x[i], y[i], z[i] = data.GetPoint(i) x = x.reshape(dim, order='F') y = y.reshape(dim, order='F') z = z.reshape(dim, order='F')
def getter(self): colors = getattr(self.vtk_polydata, "Get{}Data".format(vtk_name))().GetScalars() if colors is None: return return vtk_to_numpy(colors)
#renderer.TwoSidedLightingOff() #renderer.LightFollowCameraOff() renderer.AddLight(light1) renderer.AddLight(light2) renderer.AddLight(light3) renderWindow.Render() vtkwin_im = vtk.vtkWindowToImageFilter() vtkwin_im.SetInput(renderWindow) vtkwin_im.Update() vtk_image = vtkwin_im.GetOutput() height, width, _ = vtk_image.GetDimensions() vtk_array = vtk_image.GetPointData().GetScalars() components = vtk_array.GetNumberOfComponents() arr = vtk_to_numpy(vtk_array).reshape(height, width, components) """ vrml_exporter = vtk.vtkVRMLExporter() vrml_exporter.SetInput(renderWindow) vrml_exporter.SetFileName('test.wrl') vrml_exporter.Write() obj_exporter = vtk.vtkOBJExporter() obj_exporter.SetInput(renderWindow) obj_exporter.SetFilePrefix('test') obj_exporter.Write() """ renderWindowInteractor.Start() renderWindowInteractor.GetRenderWindow().Finalize()
import numpy as np import matplotlib.pyplot as plt import seaborn as sns sns.set() if __name__ == "__main__": input_folder = "/home/steven/scriptie/inputs/sphere_r_100_p_20" imgdata = vtk_functions.folder_to_imgdata(input_folder) sigma = 3 if sigma > 0: padding = sigma * 2 imgdata = vtk_functions.pad_imgdata(imgdata, padding) imgdata = vtk_functions.gauss_imgdata(imgdata, sigma=sigma) polydata = vtk_functions.imgdata_to_pd(imgdata) polydata = vtk_functions.normals(polydata) polydata = vtk_functions.mean_curvature(polydata) k = numpy_support.vtk_to_numpy( polydata.GetPointData().GetArray("Mean_Curvature")) print(len(k)) ax = sns.distplot(k) plt.show()
def points(self): """ returns a pointer to the points as a numpy object """ vtk_data = self.GetPoints().GetData() arr = vtk_to_numpy(vtk_data) return pyvista_ndarray(arr, vtk_data)
def t_coords(self): """The active texture coordinates on the points""" if self.GetPointData().GetTCoords() is not None: return vtk_to_numpy(self.GetPointData().GetTCoords()) return None
y_half *= scale_factor z_half *= scale_factor x_range = x_full y_range = y_half * 2 z_range = z_half * 2 from vtk.util import numpy_support grids = [] for i in range(int(vv.app.scene.EndTime) + 1): vv.app.scene.AnimationTime = i grid = np.zeros((x_range, y_range, z_range)) #pts = np.fromfile(pc_file, np.float32, -1).reshape((-1, 4)) pts = numpy_support.vtk_to_numpy(poly.GetPoints().GetData()) pts = pts[:, :3] * scale_factor pts += [0, y_half, z_half] pts = np.round(pts).astype(int) pts = pts[pts[:, 0] >= 0] pts = pts[pts[:, 0] < x_full] pts = pts[pts[:, 1] >= 0] pts = pts[pts[:, 1] < y_range] pts = pts[pts[:, 2] >= 0] pts = pts[pts[:, 2] < z_range] grid[pts[:, 0], pts[:, 1], pts[:, 2]] = 1 grids.append(grid) #for i in range(1, len(grids)):
def bitmap2memmap(files, slice_size, orientation, spacing, resolution_percentage): """ From a list of dicom files it creates memmap file in the temp folder and returns it and its related filename. """ message = _("Generating multiplanar visualization...") if len(files) > 1: update_progress= vtk_utils.ShowProgress(len(files) - 1, dialog_type = "ProgressDialog") temp_file = tempfile.mktemp() if orientation == 'SAGITTAL': if resolution_percentage == 1.0: shape = slice_size[1], slice_size[0], len(files) else: shape = math.ceil(slice_size[1]*resolution_percentage),\ math.ceil(slice_size[0]*resolution_percentage), len(files) elif orientation == 'CORONAL': if resolution_percentage == 1.0: shape = slice_size[1], len(files), slice_size[0] else: shape = math.ceil(slice_size[1]*resolution_percentage), len(files),\ math.ceil(slice_size[0]*resolution_percentage) else: if resolution_percentage == 1.0: shape = len(files), slice_size[1], slice_size[0] else: shape = len(files), math.ceil(slice_size[1]*resolution_percentage),\ math.ceil(slice_size[0]*resolution_percentage) if resolution_percentage == 1.0: matrix = numpy.memmap(temp_file, mode='w+', dtype='int16', shape=shape) cont = 0 max_scalar = None min_scalar = None xy_shape = None first_resample_entry = False for n, f in enumerate(files): image_as_array = bitmap_reader.ReadBitmap(f) image = converters.to_vtk(image_as_array, spacing=spacing,\ slice_number=1, orientation=orientation.upper()) if resolution_percentage != 1.0: image_resized = ResampleImage2D(image, px=None, py=None,\ resolution_percentage = resolution_percentage, update_progress = None) yx_shape = image_resized.GetDimensions()[1], image_resized.GetDimensions()[0] if not(first_resample_entry): shape = shape[0], yx_shape[0], yx_shape[1] matrix = numpy.memmap(temp_file, mode='w+', dtype='int16', shape=shape) first_resample_entry = True image = image_resized min_aux, max_aux = image.GetScalarRange() if min_scalar is None or min_aux < min_scalar: min_scalar = min_aux if max_scalar is None or max_aux > max_scalar: max_scalar = max_aux array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars()) if array.dtype == 'uint16': array = array - 32768/2 array = array.astype("int16") if orientation == 'CORONAL': array.shape = matrix.shape[0], matrix.shape[2] matrix[:, n, :] = array[:,::-1] elif orientation == 'SAGITTAL': array.shape = matrix.shape[0], matrix.shape[1] # TODO: Verify if it's necessary to add the slices swapped only in # sagittal rmi or only in # Rasiane's case or is necessary in all # sagittal cases. matrix[:, :, n] = array[:,::-1] else: array.shape = matrix.shape[1], matrix.shape[2] matrix[n] = array if len(files) > 1: update_progress(cont,message) cont += 1 matrix.flush() scalar_range = min_scalar, max_scalar print("MATRIX", matrix.shape) return matrix, scalar_range, temp_file
def test_pointdata(self): self.nrrdArray = ns.vtk_to_numpy( self.rnrrd.GetOutput().GetPointData().GetTensors()) self.itkArray = ns.vtk_to_numpy( self.ritk.GetOutput().GetPointData().GetTensors()) self.assertTrue(numpy.allclose(self.nrrdArray, self.itkArray))
# gh_b = (np.percentile(b_distarray,100) - np.percentile(b_distarray,75))/np.percentile(b_distarray,100) # b_rim_qartile1 = np.percentile(b_distarray, 25) # b_rim_qartile2 = np.percentile(b_distarray, 50) # b_rim_qartile3 = np.percentile(b_distarray, 75) # # # print(b_distarray) # # print("Mean: " +str(np.mean(b_distarray))) # # print("Median: " +str(np.median(b_distarray))) # # print("Min: " +str(np.min(b_distarray))) # # print("Max: " +str(np.max(b_distarray))) # # n, bins, patches = plt.hist(b_distarray) #, 50, normed=1, facecolor='green', alpha=0.75) # # plt.show() n_pt = surfdist_n.GetPointData() n_distscalars = n_pt.GetScalars() n_distarray = numpy_support.vtk_to_numpy(n_distscalars) n_distarray_clipped = n_distarray[n_distarray > 0] gh_n_clipped = (np.percentile(n_distarray_clipped,100) - np.percentile(n_distarray_clipped,75))/np.percentile(n_distarray_clipped,100) n_rim_qartile1_clipped = np.percentile(n_distarray_clipped, 25) n_rim_qartile2_clipped = np.percentile(n_distarray_clipped, 50) n_rim_qartile3_clipped = np.percentile(n_distarray_clipped, 75) gh_n = (np.percentile(n_distarray,100) - np.percentile(n_distarray,75))/np.percentile(n_distarray,100) n_rim_qartile1 = np.percentile(n_distarray, 25) n_rim_qartile2 = np.percentile(n_distarray, 50) n_rim_qartile3 = np.percentile(n_distarray, 75) csvline = currentline + [n_necroticvol, n_edemavol, n_enhvol, n_enhrimwidth, gh_n, n_rim_qartile1, n_rim_qartile2, n_rim_qartile3, gh_n_clipped, n_rim_qartile1_clipped, n_rim_qartile2_clipped, n_rim_qartile3_clipped] # csvline = currentline + [gtnecroticvol, gtedemavol, gtenhvol, gtenhrimwidth, gh_gt, gt_rim_qartile1, gt_rim_qartile2, gt_rim_qartile3, gh_gt_clipped, gt_rim_qartile1_clipped, gt_rim_qartile2_clipped, gt_rim_qartile3_clipped, # b_necroticvol, b_edemavol, b_enhvol, b_enhrimwidth, gh_b, b_rim_qartile1, b_rim_qartile2, b_rim_qartile3, gh_b_clipped, b_rim_qartile1_clipped, b_rim_qartile2_clipped, b_rim_qartile3_clipped,
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 extractfeatures_inside(self, DICOMImages, image_pos_pat, image_ori_pat, series_path, phases_series, VOI_mesh): """ Start pixVals for collection pixel values at VOI """ pixVals = [] deltaS = {} # necessary to read point coords VOIPnt = [0,0,0] ijk = [0,0,0] pco = [0,0,0] for i in range(len(DICOMImages)): abspath_PhaseID = series_path+os.sep+str(phases_series[i]) print phases_series[i] # Get total number of files load = Inputs_init() [len_listSeries_files, FileNms_slices_sorted_stack] = load.ReadDicomfiles(abspath_PhaseID) mostleft_slice = FileNms_slices_sorted_stack.slices[0] # Get dicom header, retrieve dicomInfo_series = dicom.read_file(abspath_PhaseID+os.sep+str(mostleft_slice)) # (0008,0031) AT S Series Time # hh.mm.ss.frac seriesTime = str(dicomInfo_series[0x0008,0x0031].value) # (0008,0033) AT S Image Time # hh.mm.ss.frac imageTime = str(dicomInfo_series[0x0008,0x0033].value) # (0008,0032) AT S Acquisition Time # hh.mm.ss.frac ti = str(dicomInfo_series[0x0008,0x0032].value) acquisitionTimepoint = datetime.time(hour=int(ti[0:2]), minute=int(ti[2:4]), second=int(ti[4:6])) self.timepoints.append( datetime.datetime.combine(datetime.date.today(), acquisitionTimepoint) ) # find mapping to Dicom space [transformed_image, transform_cube] = Display().dicomTransform(DICOMImages[i], image_pos_pat, image_ori_pat) ### Get inside of VOI [VOI_scalars, VOIdims] = self.createMaskfromMesh(VOI_mesh, transformed_image) print "\n VOIdims" print VOIdims # get non zero elements image_scalars = transformed_image.GetPointData().GetScalars() numpy_VOI_imagedata = vtk_to_numpy(image_scalars) numpy_VOI_imagedata = numpy_VOI_imagedata.reshape(VOIdims[2], VOIdims[1], VOIdims[0]) numpy_VOI_imagedata = numpy_VOI_imagedata.transpose(2,1,0) print "Shape of VOI_imagedata: " print numpy_VOI_imagedata.shape #################### HERE GET IT AND MASK IT OUT self.nonzeroVOIextracted = nonzero(VOI_scalars) print self.nonzeroVOIextracted VOI_imagedata = numpy_VOI_imagedata[self.nonzeroVOIextracted] print "shape of VOI_imagedata Clipped:" print VOI_imagedata.shape for j in range( len(VOI_imagedata) ): pixValx = VOI_imagedata[j] pixVals.append(pixValx) # Now collect pixVals print "Saving %s" % 'delta'+str(i) deltaS['delta'+str(i)] = pixVals pixVals = [] print self.timepoints # Collecting timepoints in proper format t_delta = [] t_delta.append(0) total_time = 0 for i in range(len(DICOMImages)-1): current_time = self.timepoints[i+1] previous_time = self.timepoints[i] difference_time =current_time - previous_time timestop = divmod(difference_time.total_seconds(), 60) t_delta.append( t_delta[i] + timestop[0]+timestop[1]*(1./60)) total_time = total_time+timestop[0]+timestop[1]*(1./60) # finally print t_delta print t_delta t = array(t_delta) print "total_time" print total_time ############################################################## # Finished sampling deltaS # APply lmfit to deltaS # first sample the mean data_deltaS = []; t_deltaS = []; mean_deltaS = []; sd_deltaS = []; se_deltaS = []; n_deltaS = [] # append So and to data_deltaS.append( 0 ) t_deltaS.append(0) mean_deltaS.append( mean(deltaS['delta0']) ) sd_deltaS.append(0) se_deltaS.append(0) n_deltaS.append( len(deltaS['delta0']) ) for k in range(1,len(DICOMImages)): deltaS_i = ( mean(array(deltaS['delta'+str(k)]).astype(float)) - mean(deltaS['delta0']) )/ mean(deltaS['delta0']) data_deltaS.append( deltaS_i ) t_deltaS.append(k) print 'delta'+str(k) print data_deltaS[k] ############################################################## # Calculate data_error # estimate the population mean and SD from our samples to find SE # SE tells us the distribution of individual scores around the sampled mean. mean_deltaS_i = mean(array(deltaS['delta'+str(k)])) std_deltaS_i = std(array(deltaS['delta'+str(k)])) n_deltaS_i = len(array(deltaS['delta'+str(k)])) sd_deltaS.append( std_deltaS_i ) mean_deltaS.append( mean_deltaS_i ) # Standard Error of the mean SE # the smaller the variability in the data, the more confident we are that one value (the mean) accurately reflects them. se_deltaS.append(std_deltaS_i/sqrt(n_deltaS_i)) n_deltaS.append(n_deltaS_i) # make array for data_deltaS data = array(data_deltaS) print "\n================\nMean and SE (i.e VOI sample data)" print mean_deltaS print se_deltaS # create a set of Parameters params = Parameters() params.add('amp', value= 10, min=0) params.add('alpha', value= 1, min=0) params.add('beta', value= 0.05, min=0.0001, max=0.9) # do fit, here with leastsq model # define objective function: returns the array to be minimized def fcn2min(params, t, data): global model, model_res, x """ model EMM for Bilateral DCE-MRI, subtract data""" # unpack parameters: # extract .value attribute for each parameter amp = params['amp'].value # Upper limit of deltaS alpha = params['alpha'].value # rate of signal increase min-1 beta = params['beta'].value # rate of signal decrease min-1 model = amp * (1- exp(-alpha*t)) * exp(-beta*t) x = linspace(0, t[4], 101) model_res = amp * (1- exp(-alpha*x)) * exp(-beta*x) return model - data ##### myfit = Minimizer(fcn2min, params, fcn_args=(t,), fcn_kws={'data':data}) myfit.prepare_fit() myfit.leastsq() # On a successful fit using the leastsq method, several goodness-of-fit statistics # and values related to the uncertainty in the fitted variables will be calculated print "myfit.success" print myfit.success print "myfit.residual" print myfit.residual print "myfit.chisqr" print myfit.chisqr print "myfit.redchi" print myfit.redchi # calculate final result final = data + myfit.residual # write error report report_errors(params) # Calculate R-square # R_square = sum( y_fitted - y_mean)/ sum(y_data - y_mean) R_square = sum( (model - mean(data))**2 )/ sum( (data - mean(data))**2 ) print "R^2" print R_square self.amp = params['amp'].value self.alpha = params['alpha'].value self.beta = params['beta'].value ################################################## # Now Calculate Extract parameters from model self.iAUC1 = params['amp'].value *( ((1-exp(-params['beta'].value*t[1]))/params['beta'].value) + (exp((-params['alpha'].value+params['beta'].value)*t[1])-1)/(params['alpha'].value+params['beta'].value) ) print "iAUC1" print self.iAUC1 self.Slope_ini = params['amp'].value*params['alpha'].value print "Slope_ini" print self.Slope_ini self.Tpeak = (1/params['alpha'].value)*log(1+(params['alpha'].value/params['beta'].value)) print "Tpeak" print self.Tpeak self.Kpeak = -params['amp'].value * params['alpha'].value * params['beta'].value print "Kpeak" print self.Kpeak self.SER = exp( (t[4]-t[1])*params['beta'].value) * ( (1-exp(-params['alpha'].value*t[1]))/(1-exp(-params['alpha'].value*t[4])) ) print "SER" print self.SER ################################################## # Now Calculate enhancement Kinetic based features # Based on the course of signal intensity within the lesion print "\n Saving %s" % 'Crk' So = array(deltaS['delta0']).astype(float) Crk = {'Cr0': mean(So)} C = {} Carray = [] for k in range(1,len(DICOMImages)): Sk = array(deltaS['delta'+str(k)]).astype(float) Cr = 0 for j in range( len(So) ): # extract average enhancement over the lesion at each time point Cr = Cr + (Sk[j] - So[j])/So[j] Carray.append((Sk[j] - So[j])/So[j]) # compile C['C'+str(k)] = Carray Crk['Cr'+str(k)] = Cr/len(Sk) # Extract Fii_1 for k in range(1,5): currentCr = array(Crk['Cr'+str(k)]).astype(float) print currentCr if( self.maxCr < currentCr): self.maxCr = float(currentCr) self.peakCr = int(k) print "Maximum Upate (Fii_1) = %d " % self.maxCr print "Peak Cr (Fii_2) = %d " % self.peakCr # Uptake rate self.UptakeRate = float(self.maxCr/self.peakCr) print "Uptake rate (Fii_3) " print self.UptakeRate # WashOut Rate if( self.peakCr == 4): self.washoutRate = 0 else: self.washoutRate = float( (self.maxCr - array(Crk['Cr'+str(4)]).astype(float))/(4-self.peakCr) ) print "WashOut rate (Fii_4) " print self.washoutRate ################################################## # Now Calculate enhancement-variance Kinetic based features # Based on Crk['Cr'+str(k)] = Cr/len(Sk) print "\n Saving %s" % 'Vrk' Vrk = {} for k in range(1,5): Ci = array(C['C'+str(k)]).astype(float) Cri = array(Crk['Cr'+str(k)]).astype(float) Vr = 0 for j in range( len(Ci) ): # extract average enhancement over the lesion at each time point Vr = Vr + (Ci[j] - Cri)**2 # compile Vrk['Vr'+str(k)] = Vr/(len(Ci)-1) # Extract Fiii_1 for k in range(1,5): currentVr = array(Vrk['Vr'+str(k)]).astype(float) if( self.maxVr < currentVr): print currentVr self.maxVr = float(currentVr) self.peakVr = int(k) print "Maximum Variation of enhan (Fiii_1) = %d " % self.maxVr print "Peak Vr (Fii_2) = %d " % self.peakVr # Vr_increasingRate self.Vr_increasingRate = self.maxVr/self.peakVr print "Vr_increasingRate (Fiii_3)" print self.Vr_increasingRate # Vr_decreasingRate if( self.peakVr == 4): Vr_decreasingRate = 0 else: Vr_decreasingRate = float((self.maxVr - array(Vrk['Vr'+str(4)]).astype(float))/(4-self.peakVr)) print "Vr_decreasingRate (Fiii_4) " print Vr_decreasingRate # Vr_post_1 self.Vr_post_1 = float( array(Vrk['Vr'+str(1)]).astype(float)) print "Vr_post_1 (Fiii_5)" print self.Vr_post_1 ################################################## # orgamize into dataframe self.dynamicEMM_inside = DataFrame( data=array([[ self.amp, self.alpha, self.beta, self.iAUC1, self.Slope_ini, self.Tpeak, self.Kpeak, self.SER, self.maxCr, self.peakCr, self.UptakeRate, self.washoutRate, self.maxVr, self.peakVr, self.Vr_increasingRate, self.Vr_post_1]]), columns=['A.inside', 'alpha.inside', 'beta.inside', 'iAUC1.inside', 'Slope_ini.inside', 'Tpeak.inside', 'Kpeak.inside', 'SER.inside', 'maxCr.inside', 'peakCr.inside', 'UptakeRate.inside', 'washoutRate.inside', 'maxVr.inside', 'peakVr.inside','Vr_increasingRate.inside', 'Vr_post_1.inside']) ############################################################# # try to plot results pylab.figure() pylab.errorbar(t, data, yerr=se_deltaS, fmt='ro', label='data+SE') # data 'ro' red dots as markers pylab.plot(t, final, 'b+', label='data+residuals') # data+residuals 'b+' blue pluses pylab.plot(t, model, 'b', label='model') # model fit 'b' blue pylab.plot(x, model_res, 'k', label='model fit') # model fit 'k' blakc pylab.xlabel(" post-contrast time (min)") pylab.ylabel("delta S(t)") pylab.legend() return self.dynamicEMM_inside
def points(self): points = self.vtk_polydata.GetPoints() if points is None: return None else: return vtk_to_numpy(points.GetData())
#to be adapted namefile = pathbase+'/RUNS_'+args[0]+'/run_OPTIM_Ga'+str(Ga)+'_Rcg'+str(Rcg)+'_Rdhdt'+str(Rdhdt)+'/mesh_'+str(nbparts)+'/' filespvtu = glob.glob(namefile+'*pvtu') filespvtu.sort() filein = filespvtu[-1] #print filein #get the vtu data reader = vtk.vtkXMLPUnstructuredGridReader() reader.SetFileName(filein) reader.Update() output=reader.GetOutput() PointData=output.GetPointData()#données du nodes Coords=vtk_to_numpy(output.GetPoints().GetData()) #pour obtenir les indices de nodes a la surface cellData=output.GetCellData() pointData=output.GetPointData() GeometryIDS=vtk_to_numpy(cellData.GetArray(0)) #la condition de borde 1 correspond a la surface indexGEO=np.where(GeometryIDS==1) listPoints=set()#pour garde les index for i in indexGEO[0]: celda1=output.GetCell(i) ids=celda1.GetPointIds() if ids.GetNumberOfIds()==3:#utiliser que les elementes que ont 3 ids == triangles (pas le lignes ou les nodes)
from vtk.util import numpy_support import tracking_filter reload(tracking_filter) inp = self.GetInput() p0 = inp.GetBlock(0) p1 = inp.GetBlock(1) t = int(inp.GetInformation().Get(vtk.vtkDataObject.DATA_TIME_STEP())) # transform PolyData to Numpy array pts0 = None pts1 = None if p0 is not None and p1 is not None: pts0 = numpy_support.vtk_to_numpy(p0.GetPoints().GetData()) pts1 = numpy_support.vtk_to_numpy(p1.GetPoints().GetData()) # run tracking pts, lines, colors = tracking_filter.run_tracking(pts0, pts1, t) if pts is not None and lines is not None and colors is not None: # numpy to polydata poly = vtk.vtkPolyData() # points points = vtk.vtkPoints() points.SetData(numpy_support.numpy_to_vtk(pts, deep=True, array_type=vtk.VTK_FLOAT)) poly.SetPoints(points) # lines vtklines = vtk.vtkCellArray()
def scale(self): return np.linalg.norm(vtk_to_numpy(self.polydata.GetPoints().GetData()), 'fro')
shiftScale.SetInputConnection(reader.GetOutputPort()) shiftScale.Update() print(reader.GetRescaleSlope()) print(reader.GetRescaleOffset()) # Get the 'vtkImageData' object from the reader imageData = reader.GetOutput() # Get the 'vtkPointData' object from the 'vtkImageData' object pointData = imageData.GetPointData() # Ensure that only one array exists within the 'vtkPointData' object assert (pointData.GetNumberOfArrays() == 1) # Get the `vtkArray` (or whatever derived type) which is needed for the `numpy_support.vtk_to_numpy` function arrayData = pointData.GetArray(0) # Convert the `vtkArray` to a NumPy array ArrayDicom = numpy_support.vtk_to_numpy(arrayData) # Reshape the NumPy array to 3D using 'ConstPixelDims' as a 'shape' ArrayDicom = ArrayDicom.reshape(ConstPixelDims, order='F') trace = go.Heatmap(z=numpy.rot90(ArrayDicom[:, 120, :])) data = [trace] py.iplot(data, filename='basic-heatmap') threshold = vtk.vtkImageThreshold() threshold.SetInputConnection(reader.GetOutputPort()) threshold.ThresholdByLower(400) threshold.ReplaceInOn() threshold.SetInValue(0) threshold.ReplaceOutOn() threshold.SetOutValue(1) threshold.Update()
def vertices(self): return vtk_to_numpy(self.polydata.GetPoints().GetData())
def vtkcontourf_obj(cutMapper, pl3d_output, src_output, var_name, levels, snapshot_dir, plane_normal, scalarRange, i_d): # if not X_is_running(): # return #off-screen rendering #gfac = vtk.vtkGraphicsFactory #gfac.SetOffScreenOnlyMode(1) #gfac.SetUseMesaClasses(1) #im_fac = vtk.vtkImagingFactory #im_fac.SetUseMesaClasses(1) pl3d_output.GetPointData().SetActiveScalars(var_name) if (scalarRange == (0, 0)): #print scalarRange # this prevents zero values from setting colourbar scalarnump = VN.vtk_to_numpy( src_output.GetOutput().GetPointData().GetScalars(var_name)) minval = np.amin(scalarnump) try: if (minval >= 0.0): minval = np.amin(scalarnump[scalarnump > 0.0]) except Exception: pass maxval = np.amax(scalarnump) scalarRange = (minval, maxval) #print scalarRange # set bounds to be symmetric if requested if i_d.symmetric: if (np.abs(minval) > np.abs(maxval)): maxval = -minval else: minval = -maxval scalarRange = (minval, maxval) #set minval/maxval to zero if very small if (np.abs(minval) < np.finfo(np.float64).eps): minval = 0.0 if (np.abs(maxval) < np.finfo(np.float64).eps): minval = 0.0 scalarRange = (minval, maxval) #scalarRange =pl3d_output.GetPointData().GetScalars(var_name).GetRange() else: minval = scalarRange[0] maxval = scalarRange[1] cutMapper.SetScalarRange(scalarRange) cutActor = vtk.vtkActor() cutActor.SetMapper(cutMapper) #cutActor.SetMapper(src_output) lut = vtk.vtkLookupTable() #MakeLUT() lut.SetNumberOfTableValues(levels) if (i_d.colourmap == 'jet'): lut.SetHueRange(0.667, 0.0) elif (i_d.colourmap == 'viridis'): lut.SetHueRange(0.801282320, 0.149576098) lut.SetSaturationRange(0.985203081, 0.855085320) lut.SetValueRange(0.329415190, 0.993247890) lut.SetNanColor(1, 0, 0, 1) lut.Build() cutMapper.SetLookupTable(lut) scalarBar = vtk.vtkScalarBarActor() scalarBar.SetLookupTable(lut) scalarBar.SetTitle(var_name) absmax = np.amax([np.abs(minval), np.abs(maxval)]) if (absmax < 1000 and absmax > .1): scalarBar.SetLabelFormat("%-#3.2f") elif (absmax < .1): scalarBar.SetLabelFormat("%-#3.2e") tprop = vtk.vtkTextProperty() tprop.SetColor(0, 0, 0) #if i_d.non_dimensionalise: tprop.SetFontSize(10) scalarBar.SetTitleTextProperty(tprop) scalarBar.SetLabelTextProperty(tprop) scalarBar.SetTextPad(1) # Add the actors to the renderer, set the background and size #ren.AddActor(outlineActor) #ren.AddActor(planeActor) # Create the RenderWindow, Renderer and both Actors ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetOffScreenRendering(1) #off-screen render renWin.AddRenderer(ren) #iren = vtk.vtkRenderWindowInteractor() #iren.SetRenderWindow(renWin) ren.AddActor(cutActor) ren.AddActor2D(scalarBar) ren.SetBackground(1, 1, 1) renWin.SetSize(i_d.render_size[0], i_d.render_size[1]) camera = vtk.vtkCamera() camera.SetPosition(plane_normal) ren.SetActiveCamera(camera) #zoom ren.ResetCamera() ren.GetActiveCamera().Zoom(0.9) ren.GetActiveCamera().Dolly(1.4) ren.ResetCameraClippingRange() #off-screen renWin.Render() win2im = vtk.vtkWindowToImageFilter() win2im.SetInput(renWin) win2im.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(snapshot_dir + '.png') writer.SetInputConnection(win2im.GetOutputPort()) writer.Write()
def get_inside_point_ids(gui, ugrid, ugrid_flipped, model_name, representation='points'): """ The points that are returned from the frustum, despite being defined as inside are not all inside. The cells are correct though. If you determine the cells outside the volume and the points associated with that, and boolean the two, you can find the points that are actually inside. In other words, ``points`` corresponds to the points inside the volume and barely outside. ``point_ids_flipped`` corresponds to the points entirely outside the volume. Parameters ========== ugrid : vtk.vtkUnstructuredGrid() the "inside" grid ugrid_flipped : vtk.vtkUnstructuredGrid() the outside grid Returns ======= ugrid : vtk.vtkUnstructuredGrid() an updated grid that has the correct points nids : (n, ) int ndarray the node_ids """ nids = None points = ugrid.GetPointData() if points is None: return ugrid, nids ids = points.GetArray('Ids') if ids is None: return ugrid, nids # all points associated with the correctly selected cells are returned # but we get extra points for the cells that are inside and out point_ids = vtk_to_numpy(ids) nids = gui.get_node_ids(model_name, point_ids) # these are the points outside the box/frustum (and also include the bad point) points_flipped = ugrid_flipped.GetPointData() ids_flipped = points_flipped.GetArray('Ids') point_ids_flipped = vtk_to_numpy(ids_flipped) nids_flipped = gui.get_node_ids(model_name, point_ids_flipped) #nids = gui.gui.get_reverse_node_ids(model_name, point_ids_flipped) # setA - setB nids2 = np.setdiff1d(nids, nids_flipped, assume_unique=True) #narrays = points.GetNumberOfArrays() #for iarray in range(narrays): #name = points.GetArrayName(iarray) #print('iarray=%s name=%r' % (iarray, name)) #------------------ if representation == 'points': # we need to filter the nodes that were filtered by the # numpy setdiff1d, so we don't show extra points ugrid = create_filtered_point_ugrid(ugrid, nids, nids2) nids = nids2 return ugrid, nids
def surface2inds(vrtx, trgl, mesh, boundaries=True, internal=True): """" Function to read gocad polystructure file and output indexes of mesh with in the structure. """ import vtk import vtk.util.numpy_support as npsup # Adjust the index trgl = trgl - 1 # Make vtk pts ptsvtk = vtk.vtkPoints() ptsvtk.SetData(npsup.numpy_to_vtk(vrtx, deep=1)) # Make the polygon connection polys = vtk.vtkCellArray() for face in trgl: poly = vtk.vtkPolygon() poly.GetPointIds().SetNumberOfIds(len(face)) for nrv, vert in enumerate(face): poly.GetPointIds().SetId(nrv, vert) polys.InsertNextCell(poly) # Make the polydata, structure of connections and vrtx polyData = vtk.vtkPolyData() polyData.SetPoints(ptsvtk) polyData.SetPolys(polys) # Make implicit func ImpDistFunc = vtk.vtkImplicitPolyDataDistance() ImpDistFunc.SetInput(polyData) # Convert the mesh vtkMesh = vtk.vtkRectilinearGrid() vtkMesh.SetDimensions(mesh.nNx, mesh.nNy, mesh.nNz) vtkMesh.SetXCoordinates(npsup.numpy_to_vtk(mesh.vectorNx, deep=1)) vtkMesh.SetYCoordinates(npsup.numpy_to_vtk(mesh.vectorNy, deep=1)) vtkMesh.SetZCoordinates(npsup.numpy_to_vtk(mesh.vectorNz, deep=1)) # Add indexes vtkInd = npsup.numpy_to_vtk(np.arange(mesh.nC), deep=1) vtkInd.SetName("Index") vtkMesh.GetCellData().AddArray(vtkInd) extractImpDistRectGridFilt = vtk.vtkExtractGeometry() # Object constructor extractImpDistRectGridFilt.SetImplicitFunction(ImpDistFunc) # extractImpDistRectGridFilt.SetInputData(vtkMesh) if boundaries is True: extractImpDistRectGridFilt.ExtractBoundaryCellsOn() else: extractImpDistRectGridFilt.ExtractBoundaryCellsOff() if internal is True: extractImpDistRectGridFilt.ExtractInsideOn() else: extractImpDistRectGridFilt.ExtractInsideOff() print("Extracting indices from grid...") # Executing the pipe extractImpDistRectGridFilt.Update() # Get index inside insideGrid = extractImpDistRectGridFilt.GetOutput() insideGrid = npsup.vtk_to_numpy(insideGrid.GetCellData().GetArray("Index")) # Return the indexes inside return insideGrid
def __init__(self, filename, cwd=os.getcwd()): super().__init__(filename, cwd) cell_data = self.grid.GetCellData() cell_data_vectors = cell_data.GetVectors() self.values = vtk_to_numpy(cell_data_vectors)
def compute_s2s_error(surface, surfacetarget, nsamples, ofile=''): """Compute the symmetric surface-to-surface distance (s2s-metric) for surface and surfacetarget. Resample the s2s-array to nsamples.""" # cap the surfaces to improve surface to surface distance on clipped areas surfacecap = capsurface(surface, 'autolabels') edges = extractboundaryedge(surfacecap) if edges.GetNumberOfPoints() > 0: surfacecap = fillholes(surfacecap) surfacetargetcap = capsurface(surfacetarget, 'autolabels') edges = extractboundaryedge(surfacetargetcap) if edges.GetNumberOfPoints() > 0: surfacetargetcap = fillholes(surfacetargetcap) # compute distances seg2gtsurf = surface2surfacedistance(surfacecap, surfacetargetcap, 'S2S') gt2segsurf = surface2surfacedistance(surfacetargetcap, surfacecap, 'S2S') if ofile: writevtp(seg2gtsurf, ofile + 'seg2gt.vtp') writevtp(gt2segsurf, ofile + 'gt2seg.vtp') # to have ~ same amount of samples per case # extract body and pvs # re sample to nsamples per case indexes = ['body', 'pvs'] rfrom = {'body': 36, 'pvs': 76} rto = {'body': 36, 'pvs': 79} # initialise metric dictionary s2s_all = {'body': [0.], 'pvs': [0.]} for index in indexes: # extracting each region # including all points seg2gtsurf = pointthreshold(seg2gtsurf, 'autolabels', rfrom[index], rto[index], 1) gt2segsurf = pointthreshold(gt2segsurf, 'autolabels', rfrom[index], rto[index], 1) # turning distance array into numpy if (seg2gtsurf.GetPointData().GetArray('S2S') != None): seg2gtarray = vtk_to_numpy( seg2gtsurf.GetPointData().GetArray('S2S')) else: seg2gtarray = [] if (gt2segsurf.GetPointData().GetArray('S2S') != None): gt2segarray = vtk_to_numpy( gt2segsurf.GetPointData().GetArray('S2S')) else: gt2segarray = [] # resample to nsamples (unless array smaller than that) if len(seg2gtarray) > nsamples: seg2gtarray = resamplearray(seg2gtarray, nsamples) if len(gt2segarray) > nsamples: gt2segarray = resamplearray(gt2segarray, nsamples) # concatenate error to have symmetric metric superarray = np.concatenate([seg2gtarray, gt2segarray]) s2s_all[index] = superarray return s2s_all
factors = ['Dach1'] # First, read in the .vtp file for mesh and Dach1 datareader = vtk.vtkXMLImageDataReader() datareader.SetFileName('test.vti') datareader.Update() mesh = vtk.vtkPolyData() mesh = datareader.GetOutput() for MF in xrange(0, len(factors)): ref = vtk.vtkXMLImageDataReader() ref.SetFileName(factors[MF] + '.vti') ref.Update() # Read your data into another polydata variable for reading dach = vtk.vtkPolyData() dach = ref.GetOutput() # Convert Dach1 and Pressure to micron units and new arrays to point data Dach1 = VN.vtk_to_numpy(dach.GetPointData().GetArray('ImageFile')) Dach1_numpy = WSS_CONV_FACTOR * Dach1 Dach1_vtk = VN.numpy_to_vtk(Dach1_numpy) Dach1_vtk.SetName(factors[MF]) mesh.GetPointData().AddArray(Dach1_vtk) # Write a new .vtp file that has all converted values and mapped values. w = vtk.vtkXMLImageDataWriter() w.SetInputData(mesh) w.SetFileName('E175_H2_ImageData_Combined.vti') w.Write()
def compute_forces(vtk_file_path, force_file_path, config_dict): """ Function to compute force of a VTK file Function 'compute_forces' computes surface forces at points for SU2 result files. Args: vtk_file_path (str): Path of the VTK file force_file_path (str): Path to the results force file to write config_dict (dict): SU2 cfg file dictionary to dimensionalize non-dimensional output Returns: mesh (vtkhelpers object instance): Python instance of SU2 result file with added force and normal vectors """ # To read .vtu file reader = vtk.vtkXMLUnstructuredGridReader() #test reader.SetFileName(vtk_file_path) # To read .vtk file # reader = vtk.vtkUnstructuredGridReader() # reader.SetFileName(vtk_file_path) # reader.SetReadAllNormals(1) # reader.SetReadAllScalars(1) # reader.SetReadAllTensors(1) # reader.SetReadAllVectors(1) reader.Update() mesh = reader.GetOutput() coord = vtk_to_numpy(mesh.GetPoints().GetData()) cells = vtk_to_numpy(mesh.GetCells().GetData()).reshape(-1, 4)[:, 1:] point_nvecs = compute_point_normals(coord, cells) press = np.ascontiguousarray( vtk_to_numpy(mesh.GetPointData().GetAbstractArray('Pressure'))).astype( np.double) # TODO raine ERROR, now we need config_dict anyway if config_dict is not None: press = dimensionalize_pressure(press, config_dict) force = point_nvecs * press[:, None] #unit_norm = point_nvecs / np.linalg.norm(point_nvecs, axis=1, keepdims=True) # had to chage that with the last version of numpy unit_norm = point_nvecs / np.linalg.norm(point_nvecs) for name, values in iteritems({'n': unit_norm, 'f': force}): vectors = numpy_to_vtk(np.ascontiguousarray(values).astype(np.double), deep=True, array_type=vtk.VTK_FLOAT) vectors.SetName(name) mesh.GetPointData().AddArray(vectors) mesh.GetPointData().SetActiveVectors(name) # Write CSV force file ids = range(len(coord)) su2_mesh_path = config_dict.get('MESH_FILENAME') marker_dict = get_mesh_markers_ids(su2_mesh_path) mesh_maker = [] # Find which marker corespond to which ids for i in range(len(coord)): id_to_test = ids[i] find = False for marker, ids_list in marker_dict.items(): if not find: if id_to_test in ids_list: mesh_maker.append(marker) find = True df = pandas.DataFrame( data={ "ids": ids, 'x': coord[:, 0], 'y': coord[:, 1], 'z': coord[:, 2], 'fx': force[:, 0], 'fy': force[:, 1], 'fz': force[:, 2], 'marker': mesh_maker }) df.to_csv(force_file_path, sep=',', index=False) return mesh
def read_VTK(basefile,stratafile,initTime): ''' This function reads strataform basement and stratigraphic VTK files and return numpy arrays for: - x, y, z coordinates - ages - mean grain size ''' if os.path.isfile(basefile) and os.access(basefile, os.R_OK): print "Basement file exists and is readable" else: print "Either basement file is missing or is not readable" return if os.path.isfile(stratafile) and os.access(stratafile, os.R_OK): print "Stratigraphic file exists and is readable" else: print "Either stratigraphic file is missing or is not readable" return # Load basement surface vtk file as input Breader = vtkXMLUnstructuredGridReader() Breader.SetFileName(basefile) Breader.Update() # Get the coordinates of basement surface nodes bnodes_vtk_array= Breader.GetOutput().GetPoints().GetData() # Get the coordinates of the nodes and their mean grain sizes and ages bnodes_nummpy_array = vtk_to_numpy(bnodes_vtk_array) bx,by,bz= bnodes_nummpy_array[:,0],bnodes_nummpy_array[:,1],bnodes_nummpy_array[:,2] minBase = bz.min() dx = bx[1]-bx[0] nx = int((bx.max()-bx.min())/dx)+1 ny = int((by.max()-by.min())/dx)+1 baseX,baseY,baseZ = bx[nx*ny:],by[nx*ny:],bz[nx*ny:] bmgz = np.zeros(len(baseX)) bage = np.zeros(len(baseX)) bage.fill(initTime) # Load stratigraphic layer vtk file as input Sreader = vtk.vtkXMLUnstructuredGridReader() Sreader.SetFileName(stratafile) Sreader.Update() # Get the coordinates of nodes in the mesh snodes_vtk_array= Sreader.GetOutput().GetPoints().GetData() mgz_vtk = Sreader.GetOutput().GetPointData().GetArray("mean grain size") age_vtk = Sreader.GetOutput().GetPointData().GetArray("age smooth") # Get the coordinates of the nodes and their mean grain sizes and ages snodes_nummpy_array = vtk_to_numpy(snodes_vtk_array) sx,sy,sz = snodes_nummpy_array[:,0],snodes_nummpy_array[:,1],snodes_nummpy_array[:,2] mgz_numpy_array = vtk_to_numpy(mgz_vtk) smgz = mgz_numpy_array*1000. # change from m to mm age_numpy_array = vtk_to_numpy(age_vtk) sage = age_numpy_array # Concatenate basement and stratigraphy arrays x = np.hstack((baseX, sx)) y = np.hstack((baseY, sy)) z = np.hstack((baseZ, sz)) mgz = np.hstack((bmgz, smgz)) age = np.hstack((bage, sage)) print "Numpy arrays with relevant informations have been created." return minBase, x, y, z, mgz, age