def cellContainsPoint(inputs, locations): array = vtkDoubleArray() array.SetNumberOfComponents(3) array.SetNumberOfTuples(len(locations)) for i in range(len(locations)): array.SetTuple(i, locations[i]) node = vtkSelectionNode() node.SetFieldType(vtkSelectionNode.CELL) node.SetContentType(vtkSelectionNode.LOCATIONS) node.SetSelectionList(array) from paraview.vtk.vtkFiltersExtraction import vtkLocationSelector selector = vtkLocationSelector() selector.Initialize(node, "vtkInsidedness") inputDO = inputs[0].VTKObject outputDO = inputDO.NewInstance() outputDO.CopyStructure(inputDO) output = dsa.WrapDataObject(outputDO) if outputDO.IsA('vtkCompositeDataSet'): it = inputDO.NewIterator() it.InitTraversal() while not it.IsDoneWithTraversal(): outputDO.SetDataSet(it, inputDO.GetDataSet(it).NewInstance()) it.GoToNextItem() selector.ComputeSelectedElements(inputDO, outputDO) return output.CellData.GetArray('vtkInsidedness')
def setSampleData(tbl,lineName,dirName="sets"): """Read sample data and put it into a vtkTable Use in 'Programmable Filter'. Set output type to 'vtkTable'. To get (for instance) the data on line 'lineCenter' from the sampled data in the directory sets (it will automatically use the current time) in the source code write from PyFoam.Paraview.Data import setSampleData setSampleData(self.GetOutput(),"lineCenter",dirName="sets") """ actualDir=checkDir(dirName) data=SamplePlot(args=[case().name, "--directory="+actualDir, "--time="+str(vTime()), "--line="+lineName, "--fuzzy-time", "--numpy"]).data nExp=re.compile(lineName+"_t=[^ ]+ (.+)") for n in data.dtype.names: m=nExp.match(n) vals=data[n] if m: n=m.group(1) col=vtk.vtkDoubleArray() col.SetName(n) for v in vals: col.InsertNextValue(v) tbl.AddColumn(col) return tbl
def setSampleData(tbl, lineName, dirName="sets"): """Read sample data and put it into a vtkTable Use in 'Programmable Filter'. Set output type to 'vtkTable'. To get (for instance) the data on line 'lineCenter' from the sampled data in the directory sets (it will automatically use the current time) in the source code write from PyFoam.Paraview.Data import setSampleData setSampleData(self.GetOutput(),"lineCenter",dirName="sets") """ actualDir = checkDir(dirName) data = SamplePlot(args=[ case().name, "--directory=" + actualDir, "--time=" + str(vTime()), "--line=" + lineName, "--fuzzy-time", "--numpy" ]).data nExp = re.compile(lineName + "_t=[^ ]+ (.+)") for n in data.dtype.names: m = nExp.match(n) vals = data[n] if m: n = m.group(1) col = vtk.vtkDoubleArray() col.SetName(n) for v in vals: col.InsertNextValue(v) tbl.AddColumn(col) return tbl
def pointIsNear(locations, distance, inputs): array = vtk.vtkDoubleArray() array.SetNumberOfComponents(3) array.SetNumberOfTuples(len(locations)) for i in range(len(locations)): array.SetTuple(i, locations[i]) node = vtk.vtkSelectionNode() node.SetFieldType(vtk.vtkSelectionNode.POINT) node.SetContentType(vtk.vtkSelectionNode.LOCATIONS) node.GetProperties().Set(vtk.vtkSelectionNode.EPSILON(), distance) node.SetSelectionList(array) selection = vtk.vtkSelection() selection.AddNode(node) from vtk.vtkFiltersExtraction import vtkExtractSelectedLocations pointsNear = vtkExtractSelectedLocations() pointsNear.SetInputData(0, inputs[0].VTKObject) pointsNear.SetInputData(1, selection) pointsNear.Update() extractedPoints = pointsNear.GetOutput() numPoints = inputs[0].GetNumberOfPoints() result = np.zeros((numPoints, ), dtype=np.int8) extracted = dsa.WrapDataObject(extractedPoints) pointIds = extracted.PointData.GetArray('vtkOriginalPointIds') result[pointIds] = 1 import vtk.util.numpy_support as np_s vtkarray = np_s.numpy_to_vtk(result, deep=True) return dsa.vtkDataArrayToVTKArray(vtkarray)
def cellContainsPoint(inputs, locations): array = vtkDoubleArray() array.SetNumberOfComponents(3) array.SetNumberOfTuples(len(locations)) for i in range(len(locations)): array.SetTuple(i, locations[i]) node = vtkSelectionNode() node.SetFieldType(vtkSelectionNode.CELL) node.SetContentType(vtkSelectionNode.LOCATIONS) node.SetSelectionList(array) selection = vtkSelection() selection.AddNode(node) from vtkmodules.vtkFiltersExtraction import vtkExtractSelectedLocations cellsNear = vtkExtractSelectedLocations() cellsNear.SetInputData(0, inputs[0].VTKObject) cellsNear.SetInputData(1, selection) cellsNear.Update() extractedCells = cellsNear.GetOutput() numCells = inputs[0].GetNumberOfCells() result = np.zeros((numCells,), dtype = np.int8) extracted = dsa.WrapDataObject(extractedCells) cellIds = extracted.CellData.GetArray('vtkOriginalCellIds') if isinstance(cellIds, dsa.VTKCompositeDataArray): for a in cellIds.GetArrays(): result[a] = 1 else: result[cellIds] = 1 import vtkmodules.util.numpy_support as np_s vtkarray = np_s.numpy_to_vtk(result, deep=True) return dsa.vtkDataArrayToVTKArray(vtkarray)
def pointIsNear(locations, distance, inputs): array = vtkDoubleArray() array.SetNumberOfComponents(3) array.SetNumberOfTuples(len(locations)) for i in range(len(locations)): array.SetTuple(i, locations[i]) node = vtkSelectionNode() node.SetFieldType(vtkSelectionNode.POINT) node.SetContentType(vtkSelectionNode.LOCATIONS) node.GetProperties().Set(vtkSelectionNode.EPSILON(), distance) node.SetSelectionList(array) from paraview.vtk.vtkFiltersExtraction import vtkLocationSelector selector = vtkLocationSelector() selector.Initialize(node, "vtkInsidedness") inputDO = inputs[0].VTKObject outputDO = inputDO.NewInstance() outputDO.CopyStructure(inputDO) output = dsa.WrapDataObject(outputDO) if outputDO.IsA('vtkCompositeDataSet'): it = inputDO.NewIterator() it.InitTraversal() while not it.IsDoneWithTraversal(): outputDO.SetDataSet(it, inputDO.GetDataSet(it).NewInstance()) it.GoToNextItem() selector.ComputeSelectedElements(inputDO, outputDO) return output.PointData.GetArray('vtkInsidedness')
def setTimelineData(tbl, dirName, fields=[], positions=[], time=0): """Read timeline data and put it into a vtkTable Use in 'Programmable Filter'. Set output type to 'vtkTable'. To get (for instance) the fields p and U on position 'min' from the timeline data in the directory swakExpression_foo in the source code write from PyFoam.Paraview.Data import setTimelineData setTimelineData(self.GetOutput(),"volumeMinMax_pressureExtreme",positions=["minimum"],fields=["p","magU"]) """ actualDir = checkDir(dirName) data = TimelinePlot(args=[ case().name, "--directory=" + actualDir, "--time=" + str(time), "--basic-mode=lines", "--numpy" ] + ["--field=%s" % f for f in fields] + ["--position=%s" % p for p in positions]).data for i, n in enumerate(data.dtype.names): vals = data[n] col = vtk.vtkDoubleArray() col.SetName(n) for v in vals: col.InsertNextValue(v) tbl.AddColumn(col) return tbl
def pointIsNear(locations, distance, inputs): array = vtkDoubleArray() array.SetNumberOfComponents(3) array.SetNumberOfTuples(len(locations)) for i in range(len(locations)): array.SetTuple(i, locations[i]) node = vtkSelectionNode() node.SetFieldType(vtkSelectionNode.POINT) node.SetContentType(vtkSelectionNode.LOCATIONS) node.GetProperties().Set(vtkSelectionNode.EPSILON(), distance) node.SetSelectionList(array) from paraview.vtk.vtkFiltersExtraction import vtkLocationSelector selector = vtkLocationSelector() selector.SetInsidednessArrayName("vtkInsidedness") selector.Initialize(node) inputDO = inputs[0].VTKObject outputDO = inputDO.NewInstance() outputDO.CopyStructure(inputDO) output = dsa.WrapDataObject(outputDO) if outputDO.IsA('vtkCompositeDataSet'): it = inputDO.NewIterator() it.InitTraversal() while not it.IsDoneWithTraversal(): outputDO.SetDataSet(it, inputDO.GetDataSet(it).NewInstance()) it.GoToNextItem() selector.Execute(inputDO, outputDO) return output.PointData.GetArray('vtkInsidedness')
def setTimelineData(tbl,dirName,fields=[],positions=[],time=0): """Read timeline data and put it into a vtkTable Use in 'Programmable Filter'. Set output type to 'vtkTable'. To get (for instance) the fields p and U on position 'min' from the timeline data in the directory swakExpression_foo in the source code write from PyFoam.Paraview.Data import setTimelineData setTimelineData(self.GetOutput(),"volumeMinMax_pressureExtreme",positions=["minimum"],fields=["p","magU"]) """ actualDir=checkDir(dirName) data=TimelinePlot(args=[case().name, "--directory="+actualDir, "--time="+str(time), "--basic-mode=lines", "--numpy"]+ ["--field=%s" % f for f in fields]+ ["--position=%s" % p for p in positions]).data for i,n in enumerate(data.dtype.names): vals=data[n] col=vtk.vtkDoubleArray() col.SetName(n) for v in vals: col.InsertNextValue(v) tbl.AddColumn(col) return tbl
def cellContainsPoint(inputs, locations): array = vtk.vtkDoubleArray() array.SetNumberOfComponents(3) array.SetNumberOfTuples(len(locations)) for i in range(len(locations)): array.SetTuple(i, locations[i]) node = vtk.vtkSelectionNode() node.SetFieldType(vtk.vtkSelectionNode.CELL) node.SetContentType(vtk.vtkSelectionNode.LOCATIONS) node.SetSelectionList(array) selection = vtk.vtkSelection() selection.AddNode(node) from vtk.vtkFiltersExtraction import vtkExtractSelectedLocations cellsNear = vtkExtractSelectedLocations() cellsNear.SetInputData(0, inputs[0].VTKObject) cellsNear.SetInputData(1, selection) cellsNear.Update() extractedCells = cellsNear.GetOutput() numCells = inputs[0].GetNumberOfCells() result = np.zeros((numCells, ), dtype=np.int8) extracted = dsa.WrapDataObject(extractedCells) cellIds = extracted.CellData.GetArray('vtkOriginalCellIds') if isinstance(cellIds, dsa.VTKCompositeDataArray): for a in cellIds.GetArrays(): result[a] = 1 else: result[cellIds] = 1 import vtk.util.numpy_support as np_s vtkarray = np_s.numpy_to_vtk(result, deep=True) return dsa.vtkDataArrayToVTKArray(vtkarray)
def Values2VTKArray(values,n,name): ncomps=len(values)/n array=vtk.vtkDoubleArray() array.SetNumberOfComponents(ncomps) array.SetNumberOfTuples(n) for i in range(n): a = [] for j in range(ncomps): a.append(values[i+j*n]) array.SetTupleValue(i, a)
def Values2VTKArray(values,n,name): ncomps=len(values)/n array=vtk.vtkDoubleArray() array.SetNumberOfComponents(ncomps) array.SetNumberOfTuples(n) for i in range(n): a = [] for j in range(ncomps): a.append(values[i+j*n]) array.SetTypedTuple(i, a)
def Values2VTKArray(values, n, name): ncomps = len(values) / n array = vtk.vtkDoubleArray() array.SetNumberOfComponents(ncomps) array.SetNumberOfTuples(n) i = 0 for x in values: array.SetValue(i, x) i += 1 array.SetName(name) return array
def Values2VTKArray(values,n,name): ncomps=len(values)/n array=vtk.vtkDoubleArray() array.SetNumberOfComponents(ncomps) array.SetNumberOfTuples(n) i=0 for x in values: array.SetValue(i,x) i+=1 array.SetName(name) return array
def RequestData(self, request, inInfoVec, outInfoVec): from paraview import vtk import time startTime = time.time() pdi = vtk.vtkUnstructuredGrid.GetData(inInfoVec[0], 0) pdo = vtk.vtkUnstructuredGrid.GetData(outInfoVec, 0) pdo.ShallowCopy(pdi) # Assign MaterialIDs numcells = pdi.GetNumberOfCells() celldata = pdi.GetCellData() cellmid = celldata.GetArray("MaterialIDs") matIdsRange = cellmid.GetRange() numlines = int(matIdsRange[1]) + 1 # Load data firstline = True FileName = os.path.normcase(self._csv_file) f = open(FileName) # Read header if firstline: firstline = False header = f.readline().split(";") # How many materialparameter numparam = int(len(header)) # Restore data as List in List datalist = [] for line in f: data = line.split(";") datalist.append(data) # Assign properties to CellData for j in range(1, numparam): # skip first column (MID) dataArray = vtk.vtkDoubleArray() dataArray.SetNumberOfComponents(1) dataArray.SetName(header[j]) for i in range(numlines): for k in range(numcells): t = int(cellmid.GetTuple1(k)) dataArray.InsertNextValue(float(datalist[t][j])) pdo.GetCellData().AddArray(dataArray) print('Material parameters were assigned. It took %8.2f seconds.' % (time.time() - startTime)) return 1
def setPlotData(tbl, solverName, plotName): """Read plot data and put it into a vtkTable Use in 'Programmable Filter'. Set output type to 'vtkTable'. To get (for instance) the plot data generated by solver 'compressibleInterFoam' (if run with pyFoamRunner.py) under the name 'linear' write from PyFoam.Paraview.Data import setPlotData setPlotData(self.GetOutput(),"compressibleInterFoam","linear") """ actualFile = path.join("PyFoamRunner." + solverName + ".analyzed", "pickledPlots") data = RedoPlot( args=[actualFile, "--pickle-file", "--numpy"]).plotNumpy[plotName] for n in data.dtype.names: vals = data[n] col = vtk.vtkDoubleArray() col.SetName(n) for v in vals: col.InsertNextValue(v) tbl.AddColumn(col) return tbl
def setPlotData(tbl,solverName,plotName): """Read plot data and put it into a vtkTable Use in 'Programmable Filter'. Set output type to 'vtkTable'. To get (for instance) the plot data generated by solver 'compressibleInterFoam' (if run with pyFoamRunner.py) under the name 'linear' write from PyFoam.Paraview.Data import setPlotData setPlotData(self.GetOutput(),"compressibleInterFoam","linear") """ actualFile=path.join("PyFoamRunner."+solverName+".analyzed","pickledPlots") data=RedoPlot(args=[actualFile, "--pickle-file", "--numpy"]).plotNumpy[plotName] for n in data.dtype.names: vals=data[n] col=vtk.vtkDoubleArray() col.SetName(n) for v in vals: col.InsertNextValue(v) tbl.AddColumn(col) return tbl
def pointIsNear(locations, distance, inputs): array = vtkDoubleArray() array.SetNumberOfComponents(3) array.SetNumberOfTuples(len(locations)) for i in range(len(locations)): array.SetTuple(i, locations[i]) node = vtkSelectionNode() node.SetFieldType(vtkSelectionNode.POINT) node.SetContentType(vtkSelectionNode.LOCATIONS) node.GetProperties().Set(vtkSelectionNode.EPSILON(), distance) node.SetSelectionList(array) selection = vtkSelection() selection.AddNode(node) from vtkmodules.vtkFiltersExtraction import vtkExtractSelectedLocations pointsNear = vtkExtractSelectedLocations() pointsNear.SetInputData(0, inputs[0].VTKObject) pointsNear.SetInputData(1, selection) pointsNear.Update() extractedPoints = pointsNear.GetOutput() numPoints = inputs[0].GetNumberOfPoints() result = np.zeros((numPoints,), dtype = np.int8) extracted = dsa.WrapDataObject(extractedPoints) pointIds = extracted.PointData.GetArray('vtkOriginalPointIds') if isinstance(pointIds, dsa.VTKCompositeDataArray): for a in pointIds.GetArrays(): result[a] = 1 else: result[pointIds] = 1 import vtkmodules.util.numpy_support as np_s vtkarray = np_s.numpy_to_vtk(result, deep=True) return dsa.vtkDataArrayToVTKArray(vtkarray)
def RescaleDataRange(self, view, time): """DataRange can change across time, sometime we want to rescale the color map to match to the closer actual data range.""" reps = view.Representations for rep in reps: if not hasattr(rep, 'Visibility') or \ not rep.Visibility or \ not hasattr(rep, 'MapScalars') or \ not rep.MapScalars or \ not rep.LookupTable: # rep is either not visibile or not mapping scalars using a LUT. continue input = rep.Input input.UpdatePipeline(time) #make sure range is up-to-date lut = rep.LookupTable if rep.ColorAttributeType == 'POINT_DATA': datainformation = input.GetPointDataInformation() elif rep.ColorAttributeType == 'CELL_DATA': datainformation = input.GetCellDataInformation() else: print 'something strange with color attribute type', rep.ColorAttributeType if datainformation.GetArray(rep.ColorArrayName) == None: # there is no array on this process. it's possible # that this process has no points or cells continue if lut.VectorMode != 'Magnitude' or \ datainformation.GetArray(rep.ColorArrayName).GetNumberOfComponents() == 1: datarange = datainformation.GetArray( rep.ColorArrayName).GetRange(lut.VectorComponent) else: datarange = [0, 0] for i in range( datainformation.GetArray( rep.ColorArrayName).GetNumberOfComponents()): for j in range(2): datarange[j] += datainformation.GetArray( rep.ColorArrayName).GetRange( i)[j] * datainformation.GetArray( rep.ColorArrayName).GetRange(i)[j] datarange[0] = math.sqrt(datarange[0]) datarange[1] = math.sqrt(datarange[1]) import vtkParallelCorePython import paraview.vtk as vtk import paraview.servermanager pm = paraview.servermanager.vtkProcessModule.GetProcessModule() globalController = pm.GetGlobalController() localarray = vtk.vtkDoubleArray() localarray.SetNumberOfTuples(2) localarray.SetValue( 0, -datarange[0] ) # negate so that MPI_MAX gets min instead of doing a MPI_MIN and MPI_MAX localarray.SetValue(1, datarange[1]) globalarray = vtk.vtkDoubleArray() globalarray.SetNumberOfTuples(2) globalController.AllReduce(localarray, globalarray, 0) globaldatarange = [ -globalarray.GetValue(0), globalarray.GetValue(1) ] rgbpoints = lut.RGBPoints.GetData() numpts = len(rgbpoints) / 4 if globaldatarange[0] != rgbpoints[0] or globaldatarange[ 1] != rgbpoints[(numpts - 1) * 4]: # rescale all of the points oldrange = rgbpoints[(numpts - 1) * 4] - rgbpoints[0] newrange = globaldatarange[1] - globaldatarange[0] # only readjust if the new range isn't zero. if newrange != 0: newrgbpoints = list(rgbpoints) # if the old range isn't 0 then we use that ranges distribution if oldrange != 0: for v in range(numpts - 1): newrgbpoints[v * 4] = globaldatarange[0] + ( rgbpoints[v * 4] - rgbpoints[0]) * newrange / oldrange # avoid numerical round-off, at least with the last point newrgbpoints[(numpts - 1) * 4] = globaldatarange[1] else: # the old range is 0 so the best we can do is to space the new points evenly for v in range(numpts + 1): newrgbpoints[v * 4] = globaldatarange[ 0] + v * newrange / (1.0 * numpts) lut.RGBPoints.SetData(newrgbpoints)
def RescaleDataRange(datadescription, cp_views, timestep): import math for view in cp_views: if timestep % view.cpFrequency == 0 or datadescription.GetForceOutput() == True: reps = view.Representations for rep in reps: if hasattr(rep, 'Visibility') and rep.Visibility == 1 and hasattr(rep, 'MapScalars') and rep.MapScalars != '': input = rep.Input input.UpdatePipeline() #make sure range is up-to-date lut = rep.LookupTable if lut == None: continue if rep.ColorAttributeType == 'POINT_DATA': datainformation = input.GetPointDataInformation() elif rep.ColorAttributeType == 'CELL_DATA': datainformation = input.GetCellDataInformation() else: print 'something strange with color attribute type', rep.ColorAttributeType if datainformation.GetArray(rep.ColorArrayName) == None: # there is no array on this process. it's possible # that this process has no points or cells continue if lut.VectorMode != 'Magnitude' or \ datainformation.GetArray(rep.ColorArrayName).GetNumberOfComponents() == 1: datarange = datainformation.GetArray(rep.ColorArrayName).GetRange(lut.VectorComponent) else: datarange = [0,0] for i in range(datainformation.GetArray(rep.ColorArrayName).GetNumberOfComponents()): for j in range(2): datarange[j] += datainformation.GetArray(rep.ColorArrayName).GetRange(i)[j]*datainformation.GetArray(rep.ColorArrayName).GetRange(i)[j] datarange[0] = math.sqrt(datarange[0]) datarange[1] = math.sqrt(datarange[1]) import vtkParallelCorePython import paraview.vtk as vtk pm = paraview.servermanager.vtkProcessModule.GetProcessModule() globalController = pm.GetGlobalController() localarray = vtk.vtkDoubleArray() localarray.SetNumberOfTuples(2) localarray.SetValue(0, -datarange[0]) # negate so that MPI_MAX gets min instead of doing a MPI_MIN and MPI_MAX localarray.SetValue(1, datarange[1]) globalarray = vtk.vtkDoubleArray() globalarray.SetNumberOfTuples(2) globalController.AllReduce(localarray, globalarray, 0) globaldatarange = [-globalarray.GetValue(0), globalarray.GetValue(1)] rgbpoints = lut.RGBPoints.GetData() numpts = len(rgbpoints)/4 if globaldatarange[0] != rgbpoints[0] or globaldatarange[1] != rgbpoints[(numpts-1)*4]: # rescale all of the points oldrange = rgbpoints[(numpts-1)*4] - rgbpoints[0] newrange = globaldatarange[1] - globaldatarange[0] # only readjust if the new range isn't zero. if newrange != 0: newrgbpoints = list(rgbpoints) # if the old range isn't 0 then we use that ranges distribution if oldrange != 0: for v in range(numpts-1): newrgbpoints[v*4] = globaldatarange[0]+(rgbpoints[v*4] - rgbpoints[0])*newrange/oldrange # avoid numerical round-off, at least with the last point newrgbpoints[(numpts-1)*4] = rgbpoints[(numpts-1)*4] else: # the old range is 0 so the best we can do is to space the new points evenly for v in range(numpts+1): newrgbpoints[v*4] = globaldatarange[0]+v*newrange/(1.0*numpts) lut.RGBPoints.SetData(newrgbpoints)
def RescaleDataRange(self, view, time): """DataRange can change across time, sometime we want to rescale the color map to match to the closer actual data range.""" reps = view.Representations for rep in reps: if not hasattr(rep, 'Visibility') or \ not rep.Visibility or \ not hasattr(rep, 'MapScalars') or \ not rep.MapScalars or \ not rep.LookupTable: # rep is either not visible or not mapping scalars using a LUT. continue; input = rep.Input input.UpdatePipeline(time) #make sure range is up-to-date lut = rep.LookupTable colorArrayInfo = rep.GetArrayInformationForColorArray() if not colorArrayInfo: import sys datarange = [sys.float_info.max, -sys.float_info.max] else: if lut.VectorMode != 'Magnitude' or \ colorArrayInfo.GetNumberOfComponents() == 1: datarange = colorArrayInfo.GetComponentRange(lut.VectorComponent) else: # -1 corresponds to the magnitude. datarange = colorArrayInfo.GetComponentRange(-1) from paraview.vtk import vtkDoubleArray import paraview.servermanager pm = paraview.servermanager.vtkProcessModule.GetProcessModule() globalController = pm.GetGlobalController() localarray = vtkDoubleArray() localarray.SetNumberOfTuples(2) localarray.SetValue(0, -datarange[0]) # negate so that MPI_MAX gets min instead of doing a MPI_MIN and MPI_MAX localarray.SetValue(1, datarange[1]) globalarray = vtkDoubleArray() globalarray.SetNumberOfTuples(2) globalController.AllReduce(localarray, globalarray, 0) globaldatarange = [-globalarray.GetValue(0), globalarray.GetValue(1)] rgbpoints = lut.RGBPoints.GetData() numpts = len(rgbpoints)//4 if globaldatarange[0] != rgbpoints[0] or globaldatarange[1] != rgbpoints[(numpts-1)*4]: # rescale all of the points oldrange = rgbpoints[(numpts-1)*4] - rgbpoints[0] newrange = globaldatarange[1] - globaldatarange[0] # only readjust if the new range isn't zero. if newrange != 0: newrgbpoints = list(rgbpoints) # if the old range isn't 0 then we use that ranges distribution if oldrange != 0: for v in range(numpts-1): newrgbpoints[v*4] = globaldatarange[0]+(rgbpoints[v*4] - rgbpoints[0])*newrange/oldrange # avoid numerical round-off, at least with the last point newrgbpoints[(numpts-1)*4] = globaldatarange[1] else: # the old range is 0 so the best we can do is to space the new points evenly for v in range(numpts+1): newrgbpoints[v*4] = globaldatarange[0]+v*newrange/(1.0*numpts) lut.RGBPoints.SetData(newrgbpoints)
j_d=j_d+(1-alpha.GetValue(i))*U.GetComponent(i,0)*A.GetValue(i) a_d=a_d/Atotal j_a=j_a/Atotal j_d=j_d/Atotal time.append(k/5) a_d_time.append(a_d) j_a_time.append(j_a) if a_d==0: v_d_time.append(0) else: v_d_time.append(j_d/a_d) print('Location at '+str(l)+' and time is '+str(k/5)) # T=vtk.vtkTable() t=vtk.vtkDoubleArray() t.SetName("Time [s]") for i in time: t.InsertNextValue(i) T.AddColumn(t) alpha=vtk.vtkDoubleArray() alpha.SetName("Alpha_d") for i in a_d_time: alpha.InsertNextValue(i) T.AddColumn(alpha) v_j=vtk.vtkDoubleArray() v_j.SetName("V_j [m/s]") for i in j_a_time: v_j.InsertNextValue(i)
else: ctype = 0 numCellPoints = 0 print("Failed to identify element type") return ctype, numCellPoints # function ends here ctype, numCellPoints = findCellType(celltype) #print ctype, numCellPoints for cell in range(numCells): celltype = words[pos2 + cell * (numCellPoints + 3) + 2] pos_this_cell = pos2 + cell * (numCellPoints + 3) + 3 ctype, numCellPoints = findCellType(celltype) pointIds = vtk.vtkIdList() for pointId in range(numCellPoints): pointIds.InsertId(pointId, int(words[pos_this_cell + pointId])) output.InsertNextCell(ctype, pointIds) # For Material properties of cell numberOfComponents = 1 # For .msh material property by default it is 1 dataArray = vtk.vtkDoubleArray() output.GetCellData().AddArray(dataArray) dataArray.SetNumberOfComponents(numberOfComponents) dataArray.SetName('matgroup') for cell in range(numCells): matgroup = words[pos2 + cell * (numCellPoints + 3) + 1] dataArray.InsertNextValue(float(matgroup))
valid_tuples = [] for idx, val in idx_vals_tuples: if idx < 0 or idx >= nPoints: print 'Skipping invalid tuples (%d, %lf)' % (idx, val) continue valid_tuples.append((idx, val)) if len(valid_tuples) == 0: continue vtkPropIdx = vtk.vtkIdTypeArray() vtkPropIdx.SetName("PropIdx" + arrayName) vtkPropIdx.SetNumberOfValues(len(valid_tuples)) vtkPropVals = vtk.vtkDoubleArray() vtkPropVals.SetName("PropVals" + arrayName) vtkPropVals.SetNumberOfValues(len(valid_tuples)) # Record changes for i, (idx, val) in enumerate(valid_tuples): vtkPropIdx.SetValue(i, idx) vtkPropVals.SetValue(i, val) # Set new array pdo.GetFieldData().AddArray(vtkPropIdx) pdo.GetFieldData().AddArray(vtkPropVals) ################################
# Use vtkStructuredGrid # has all the right things but extents and bounds and cells seem to get confused and hence # nothing gets plotted import numpy from paraview import vtk import os pts = vtk.vtkPoints() newArray = vtk.vtkDoubleArray() # this is how far I've got before... newArray.SetName("testdata") newArray.SetNumberOfComponents(1) # stuff our numbers into pdo.GetPointData().GetArray(0).InsertNextValue(float) one by one, # followed by pts.InsertNextPoint(x,y,z), so need to get xyz as well xmin, xmax, Nx, ymin, ymax, Ny, zmin, zmax, Nz = -1, 1, 10, -1, 2, 20, -1, 3, 30 loci = numpy.mgrid[xmin:xmax:1j * Nx, ymin:ymax:1j * Ny, zmin:zmax:1j * Nz].reshape(3, -1) values = numpy.random.random(loci[0].shape) exts = [0, Nx - 1, 0, Ny - 1, 0, Nz - 1] pdo.SetExtent(exts) for ind in range(loci[0].shape[0]): newArray.InsertNextValue(values[ind]) # pts.InsertNextPoint(loci[0,ind],loci[1,ind],loci[2,ind]) pdo = self.GetOutput() pdo.GetPointData().AddArray(newArray) # pdo.SetPoints(pts) # pdo.SetActiveAttribute() # try to add this executive = self.GetExecutive() outInfo = executive.GetOutputInformation(0)
import os filepath="C:\\Users\\jiabin\\Documents\\MATLAB\\python_script\\datafile.txt" filename=os.path.normcase(filepath) pts=vtk.vtkPoints() f=open(filename) pdo=self.GetOutput() firstline=True for line in f: if firstline: firstline=False for pos,word in enumerate(line.split(",")): if pos > 2: newArray = vtk.vtkDoubleArray() newArray.SetName(word) newArray.SetNumberOfComponents(1) pdo.GetPointData().AddArray(newArray) else: for pos,word in enumerate(line.split(",")): print word if pos == 0: x = float(word) if pos == 1: y = float(word) if pos == 2: z = float(word) if pos > 2: array = pdo.GetPointData().GetArray(pos-3) array.InsertNextValue(float(word))
def RescaleDataRange(self, view, time): """DataRange can change across time, sometime we want to rescale the color map to match to the closer actual data range.""" reps = view.Representations for rep in reps: if not hasattr(rep, 'Visibility') or \ not rep.Visibility or \ not hasattr(rep, 'MapScalars') or \ not rep.MapScalars or \ not rep.LookupTable: # rep is either not visibile or not mapping scalars using a LUT. continue; input = rep.Input input.UpdatePipeline(time) #make sure range is up-to-date lut = rep.LookupTable if rep.ColorAttributeType == 'POINT_DATA' or rep.ColorAttributeType == "POINTS": datainformation = input.GetPointDataInformation() elif rep.ColorAttributeType == 'CELL_DATA' or rep.ColorAttributeType == "CELLS": datainformation = input.GetCellDataInformation() else: print 'something strange with color attribute type', rep.ColorAttributeType if datainformation.GetArray(rep.ColorArrayName) == None: # there is no array on this process. it's possible # that this process has no points or cells continue if lut.VectorMode != 'Magnitude' or \ datainformation.GetArray(rep.ColorArrayName).GetNumberOfComponents() == 1: datarange = datainformation.GetArray(rep.ColorArrayName).GetRange(lut.VectorComponent) else: # -1 corresponds to the magnitude. datarange = datainformation.GetArray(rep.ColorArrayName).GetRange(-1) import vtkParallelCorePython import paraview.vtk as vtk import paraview.servermanager pm = paraview.servermanager.vtkProcessModule.GetProcessModule() globalController = pm.GetGlobalController() localarray = vtk.vtkDoubleArray() localarray.SetNumberOfTuples(2) localarray.SetValue(0, -datarange[0]) # negate so that MPI_MAX gets min instead of doing a MPI_MIN and MPI_MAX localarray.SetValue(1, datarange[1]) globalarray = vtk.vtkDoubleArray() globalarray.SetNumberOfTuples(2) globalController.AllReduce(localarray, globalarray, 0) globaldatarange = [-globalarray.GetValue(0), globalarray.GetValue(1)] rgbpoints = lut.RGBPoints.GetData() numpts = len(rgbpoints)/4 if globaldatarange[0] != rgbpoints[0] or globaldatarange[1] != rgbpoints[(numpts-1)*4]: # rescale all of the points oldrange = rgbpoints[(numpts-1)*4] - rgbpoints[0] newrange = globaldatarange[1] - globaldatarange[0] # only readjust if the new range isn't zero. if newrange != 0: newrgbpoints = list(rgbpoints) # if the old range isn't 0 then we use that ranges distribution if oldrange != 0: for v in range(numpts-1): newrgbpoints[v*4] = globaldatarange[0]+(rgbpoints[v*4] - rgbpoints[0])*newrange/oldrange # avoid numerical round-off, at least with the last point newrgbpoints[(numpts-1)*4] = globaldatarange[1] else: # the old range is 0 so the best we can do is to space the new points evenly for v in range(numpts+1): newrgbpoints[v*4] = globaldatarange[0]+v*newrange/(1.0*numpts) lut.RGBPoints.SetData(newrgbpoints)
def RescaleDataRange(self, view, time): """DataRange can change across time, sometime we want to rescale the color map to match to the closer actual data range.""" reps = view.Representations for rep in reps: if not hasattr(rep, 'Visibility') or \ not rep.Visibility or \ not hasattr(rep, 'MapScalars') or \ not rep.MapScalars or \ not rep.LookupTable: # rep is either not visible or not mapping scalars using a LUT. continue input = rep.Input input.UpdatePipeline(time) #make sure range is up-to-date lut = rep.LookupTable colorArrayInfo = rep.GetArrayInformationForColorArray() if not colorArrayInfo: import sys datarange = [sys.float_info.max, -sys.float_info.max] else: if lut.VectorMode != 'Magnitude' or \ colorArrayInfo.GetNumberOfComponents() == 1: datarange = colorArrayInfo.GetComponentRange( lut.VectorComponent) else: # -1 corresponds to the magnitude. datarange = colorArrayInfo.GetComponentRange(-1) from paraview.vtk import vtkDoubleArray import paraview.servermanager pm = paraview.servermanager.vtkProcessModule.GetProcessModule() globalController = pm.GetGlobalController() localarray = vtkDoubleArray() localarray.SetNumberOfTuples(2) localarray.SetValue( 0, -datarange[0] ) # negate so that MPI_MAX gets min instead of doing a MPI_MIN and MPI_MAX localarray.SetValue(1, datarange[1]) globalarray = vtkDoubleArray() globalarray.SetNumberOfTuples(2) globalController.AllReduce(localarray, globalarray, 0) globaldatarange = [ -globalarray.GetValue(0), globalarray.GetValue(1) ] rgbpoints = lut.RGBPoints.GetData() numpts = len(rgbpoints) // 4 if globaldatarange[0] != rgbpoints[0] or globaldatarange[ 1] != rgbpoints[(numpts - 1) * 4]: # rescale all of the points oldrange = rgbpoints[(numpts - 1) * 4] - rgbpoints[0] newrange = globaldatarange[1] - globaldatarange[0] # only readjust if the new range isn't zero. if newrange != 0: newrgbpoints = list(rgbpoints) # if the old range isn't 0 then we use that ranges distribution if oldrange != 0: for v in range(numpts - 1): newrgbpoints[v * 4] = globaldatarange[0] + ( rgbpoints[v * 4] - rgbpoints[0]) * newrange / oldrange # avoid numerical round-off, at least with the last point newrgbpoints[(numpts - 1) * 4] = globaldatarange[1] else: # the old range is 0 so the best we can do is to space the new points evenly for v in range(numpts + 1): newrgbpoints[v * 4] = globaldatarange[ 0] + v * newrange / (1.0 * numpts) lut.RGBPoints.SetData(newrgbpoints)
import os filepath="/home/jiabin/python/datafile.txt" filename=os.path.normcase(filepath) pts=vtk.vtkPoints() f=open(filename) pdo=self.GetOutput() firstline=True for line in f: if firstline: firstline=False for pos,word in enumerate(line.split(",")): if pos > 2: newArray = vtk.vtkDoubleArray() newArray.SetName(word) newArray.SetNumberOfComponents(1) pdo.GetPointData().AddArray(newArray) else: for pos,word in enumerate(line.split(",")): print word if pos == 0: x = float(word) if pos == 1: y = float(word) if pos == 2: z = float(word) if pos > 2: array = pdo.GetPointData().GetArray(pos-3) array.InsertNextValue(float(word))