223031012
/
DAMASK_EICMD
mirror of https://github.com/achalhp/DAMASK_EICMD.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

modernized to reflect rectilinearGrid processing. Now supports vector data and in-place adding.

This commit is contained in:
Philip Eisenlohr 2016-04-13 18:03:40 -04:00
parent 0b09ce31db
commit ea0bc80af9
1 changed files with 125 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
processing/post/vtk_addPointcloudData.py
View File

@ -1,8 +1,9 @@
#!/usr/bin/env python #!/usr/bin/env python
# -*- coding: UTF-8 no BOM -*- # -*- coding: UTF-8 no BOM -*-
import os,sys,vtk import os,vtk
import damask import damask
from collections import defaultdict
from optparse import OptionParser from optparse import OptionParser
scriptName = os.path.splitext(os.path.basename(__file__))[0] scriptName = os.path.splitext(os.path.basename(__file__))[0]
@ -17,125 +18,163 @@ Add scalar and RGB tuples from ASCIItable to existing VTK point cloud (.vtp).
""", version = scriptID) """, version = scriptID)
parser.add_option('-v', '--vtk', dest='vtk', \ parser.add_option( '--vtk',
dest = 'vtk',
type = 'string', metavar = 'string',
help = 'VTK file name') help = 'VTK file name')
parser.add_option( '--inplace',
dest = 'inplace',
action = 'store_true',
help = 'modify VTK file in-place')
parser.add_option('-r', '--render',
dest = 'render',
action = 'store_true',
help = 'open output in VTK render window')
parser.add_option('-s', '--scalar', dest='scalar', action='extend', \ parser.add_option('-s', '--scalar', dest='scalar', action='extend', \
help = 'scalar values') help = 'scalar values')
parser.add_option('-v', '--vector',
dest = 'vector',
action = 'extend', metavar = '<string LIST>',
help = 'vector value label(s)')
parser.add_option('-c', '--color', dest='color', action='extend', \ parser.add_option('-c', '--color', dest='color', action='extend', \
help = 'RGB color tuples') help = 'RGB color tuples')
parser.set_defaults(scalar = []) parser.set_defaults(scalar = [],
parser.set_defaults(color = []) vector = [],
color = [],
inplace = False,
render = False,
)
(options, filenames) = parser.parse_args() (options, filenames) = parser.parse_args()
datainfo = { # list of requested labels per datatype if not options.vtk: parser.error('No VTK file specified.')
'scalar': {'len':1, if not os.path.exists(options.vtk): parser.error('VTK file does not exist.')
'label':[]},
'color': {'len':3,
'label':[]},
}
if not os.path.exists(options.vtk):
parser.error('VTK file does not exist'); sys.exit()
reader = vtk.vtkXMLPolyDataReader() reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(options.vtk) reader.SetFileName(options.vtk)
reader.Update() reader.Update()
Npoints = reader.GetNumberOfPoints() Npoints = reader.GetNumberOfPoints()
Ncells = reader.GetNumberOfCells() Ncells = reader.GetNumberOfCells()
Nvertices = reader.GetNumberOfVerts() Nvertices = reader.GetNumberOfVerts()
Polydata = reader.GetOutput() Polydata = reader.GetOutput()
if Npoints != Ncells or Npoints != Nvertices: if Npoints != Ncells or Npoints != Nvertices:
parser.error('Number of points, cells, and vertices in VTK differ from each other'); sys.exit() parser.error('Number of points, cells, and vertices in VTK differ from each other.')
if options.scalar is not None: datainfo['scalar']['label'] += options.scalar
if options.color is not None: datainfo['color']['label'] += options.color
# ------------------------------------------ setup file handles --------------------------------------- damask.util.croak('{}: {} points, {} vertices, and {} cells...'.format(options.vtk,Npoints,Nvertices,Ncells))
files = [] # --- loop over input files -------------------------------------------------------------------------
if filenames == []:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout, 'croak':sys.stderr})
else:
for name in filenames:
if os.path.exists(name):
files.append({'name':name, 'input':open(name), 'output':sys.stderr, 'croak':sys.stderr})
#--- loop over input files ------------------------------------------------------------------------ if filenames == []: filenames = [None]
for file in files:
if file['name'] != 'STDIN': file['croak'].write('\033[1m'+scriptName+'\033[0m: '+file['name']+'\n')
else: file['croak'].write('\033[1m'+scriptName+'\033[0m\n')
table = damask.ASCIItable(file['input'],file['output'],False) # make unbuffered ASCII_table for name in filenames:
table.head_read() # read ASCII header info try: table = damask.ASCIItable(name = name,
buffered = False,
readonly = True)
except: continue
damask.util.report(scriptName, name)
# --------------- figure out columns to process # --- interpret header ----------------------------------------------------------------------------
active = {}
column = {}
array = {} table.head_read()
remarks = []
errors = []
VTKarray = {}
active = defaultdict(list)
for datatype,info in datainfo.items(): for datatype,dimension,label in [['scalar',1,options.scalar],
for label in info['label']: ['vector',3,options.vector],
foundIt = False ['color',3,options.color],
for key in ['1_'+label,label]: ]:
if key in table.labels: for i,dim in enumerate(table.label_dimension(label)):
foundIt = True me = label[i]
if datatype not in active: active[datatype] = [] if dim == -1: remarks.append('{} "{}" not found...'.format(datatype,me))
if datatype not in column: column[datatype] = {} elif dim > dimension: remarks.append('"{}" not of dimension {}...'.format(me,dimension))
if datatype not in array: array[datatype] = {} else:
active[datatype].append(label) remarks.append('adding {} "{}"...'.format(datatype,me))
column[datatype][label] = table.labels.index(key) # remember columns of requested data active[datatype].append(me)
if datatype == 'scalar':
array[datatype][label] = vtk.vtkDoubleArray() if datatype in ['scalar','vector']: VTKarray[me] = vtk.vtkDoubleArray()
array[datatype][label].SetNumberOfComponents(1) elif datatype == 'color': VTKarray[me] = vtk.vtkUnsignedCharArray()
array[datatype][label].SetName(label)
elif datatype == 'color': VTKarray[me].SetNumberOfComponents(dimension)
array[datatype][label] = vtk.vtkUnsignedCharArray() VTKarray[me].SetName(label[i])
array[datatype][label].SetNumberOfComponents(3)
array[datatype][label].SetName(label) if remarks != []: damask.util.croak(remarks)
if not foundIt: if errors != []:
file['croak'].write('column %s not found...\n'%label) damask.util.croak(errors)
table.close(dismiss = True)
continue
# ------------------------------------------ process data --------------------------------------- # ------------------------------------------ process data ---------------------------------------
while table.data_read(): # read next data line of ASCII table while table.data_read(): # read next data line of ASCII table
for datatype,labels in active.items(): # loop over scalar,color for datatype,labels in active.items(): # loop over scalar,color
for label in labels: # loop over all requested items for me in labels: # loop over all requested items
theData = table.data[column[datatype][label]:\ theData = [table.data[i] for i in table.label_indexrange(me)] # read strings
column[datatype][label]+datainfo[datatype]['len']] # read strings if datatype == 'color': VTKarray[me].InsertNextTuple3(*map(lambda x: int(255.*float(x)),theData))
if datatype == 'color': elif datatype == 'vector': VTKarray[me].InsertNextTuple3(*map(float,theData))
theData = map(lambda x: int(255.*float(x)),theData) elif datatype == 'scalar': VTKarray[me].InsertNextValue(float(theData[0]))
array[datatype][label].InsertNextTuple3(theData[0],theData[1],theData[2],)
elif datatype == 'scalar':
array[datatype][label].InsertNextValue(float(theData[0]))
table.input_close() # close input ASCII table table.input_close() # close input ASCII table
# ------------------------------------------ add data --------------------------------------- # ------------------------------------------ add data ---------------------------------------
for datatype,labels in active.items(): # loop over scalar,color damask.util.croak('adding now...')
for datatype,labels in active.items(): # loop over scalar,color
damask.util.croak('type {}'.format(datatype))
if datatype == 'color': if datatype == 'color':
Polydata.GetPointData().SetScalars(array[datatype][labels[0]]) Polydata.GetPointData().SetScalars(VTKarray[active['color'][0]])
Polydata.GetCellData().SetScalars(array[datatype][labels[0]]) Polydata.GetCellData().SetScalars(VTKarray[active['color'][0]])
for label in labels: # loop over all requested items for me in labels: # loop over all requested items
Polydata.GetPointData().AddArray(array[datatype][label]) damask.util.croak('label {}'.format(me))
Polydata.GetCellData().AddArray(array[datatype][label]) Polydata.GetPointData().AddArray(VTKarray[me])
Polydata.GetCellData().AddArray(VTKarray[me])
damask.util.croak('...done.')
Polydata.Modified() Polydata.Modified()
if vtk.VTK_MAJOR_VERSION <= 5: if vtk.VTK_MAJOR_VERSION <= 5: Polydata.Update()
Polydata.Update()
# ------------------------------------------ output result --------------------------------------- # ------------------------------------------ output result ---------------------------------------
writer = vtk.vtkXMLPolyDataWriter() writer = vtk.vtkXMLPolyDataWriter()
writer.SetDataModeToBinary() writer.SetDataModeToBinary()
writer.SetCompressorTypeToZLib() writer.SetCompressorTypeToZLib()
writer.SetFileName(os.path.splitext(options.vtk)[0]+'_added.vtp') writer.SetFileName(os.path.splitext(options.vtk)[0]+('.vtp' if options.inplace else '_added.vtp'))
if vtk.VTK_MAJOR_VERSION <= 5: if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(Polydata)
writer.SetInput(Polydata) else: writer.SetInputData(Polydata)
else: writer.Write()
writer.SetInputData(Polydata)
writer.Write() # ------------------------------------------ render result ---------------------------------------
if options.render:
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(Polydata)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create the graphics structure. The renderer renders into the
# render window. The render window interactor captures mouse events
# and will perform appropriate camera or actor manipulation
# depending on the nature of the events.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
ren.AddActor(actor)
ren.SetBackground(1, 1, 1)
renWin.SetSize(200, 200)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.Initialize()
renWin.Render()
iren.Start()