def writeDataDescriptor(self):
if not self.can_write:
return
self.computeDataPatterns()
jsonData = {
"arguments_order": self.argOrder,
"type": self.types,
"arguments": self.arguments,
"metadata": self.metadata,
"data": [],
}
# Add sections
for key, value in iteritems(self.sections):
jsonData[key] = value
# Add data
for key, value in iteritems(self.data):
jsonData["data"].append(value)
filePathToWrite = os.path.join(self.__root, "index.json")
with open(filePathToWrite, "w") as fileToWrite:
fileToWrite.write(json.dumps(jsonData))
def __init__(self, location, camera_data, metadata={}, sections={}):
self.dataHandler = DataHandler(location)
self.cameraDescription = camera_data
self.camera = None
self.imageCapture = CaptureRenderWindow()
for key, value in iteritems(metadata):
self.dataHandler.addMetaData(key, value)
for key, value in iteritems(sections):
self.dataHandler.addSection(key, value)
def __init__(self, location, camera_data, metadata={}, sections={}):
self.dataHandler = DataHandler(location)
self.cameraDescription = camera_data
self.camera = None
for key, value in iteritems(metadata):
self.dataHandler.addMetaData(key, value)
for key, value in iteritems(sections):
self.dataHandler.addSection(key, value)
# Update the can_write flag for MPI
self.dataHandler.can_write = (servermanager.vtkProcessModule.GetProcessModule().GetPartitionId() == 0)
def __init__(self, directory):
self.basePath = directory
self.layers = []
self.data = []
self.imageReader = vtkPNGReader()
# Load JSON metadata
with open(os.path.join(directory, "config.json"), "r") as f:
self.config = json.load(f)
self.nbLayers = len(self.config["scene"])
while len(self.layers) < self.nbLayers:
self.layers.append({})
with open(os.path.join(directory, "index.json"), "r") as f:
self.info = json.load(f)
with open(os.path.join(directory, "offset.json"), "r") as f:
offsets = json.load(f)
for key, value in iteritems(offsets):
meta = key.split("|")
if len(meta) == 2:
self.layers[int(meta[0])][meta[1]] = value
elif meta[1] in self.layers[int(meta[0])]:
self.layers[int(meta[0])][meta[1]][int(meta[2])] = value
else:
self.layers[int(meta[0])][meta[1]] = [value, value, value]
self.composite = CompositeJSON(len(self.layers))
def getDataAbsoluteFilePath(self, name, createDirectories=True):
dataPattern = self.data[name]["pattern"]
if "{pattern}" in dataPattern:
if len(self.basePattern) == 0:
dataPattern = dataPattern.replace("{pattern}/",
self.basePattern).replace(
"{pattern}",
self.basePattern)
self.data[name]["pattern"] = dataPattern
else:
dataPattern = dataPattern.replace("{pattern}",
self.basePattern)
self.data[name]["pattern"] = dataPattern
keyValuePair = {}
for key, value in iteritems(self.current):
keyValuePair[key] = self.arguments[key]["values"][value]
fullpath = os.path.join(self.__root,
dataPattern.format(**keyValuePair))
if createDirectories and self.can_write:
if not os.path.exists(os.path.dirname(fullpath)):
os.makedirs(os.path.dirname(fullpath))
return fullpath
def __init__(self, location, sceneConfig, cameraInfo, metadata={}, sections={}, view=None):
DataSetBuilder.__init__(self, location, cameraInfo, metadata, sections)
if view:
self.view = view
else:
self.view = simple.CreateView('RenderView')
self.view.ViewSize = sceneConfig['size']
self.view.CenterAxesVisibility = 0
self.view.OrientationAxesVisibility = 0
self.view.UpdatePropertyInformation()
if 'camera' in sceneConfig and 'CameraFocalPoint' in sceneConfig['camera']:
self.view.CenterOfRotation = sceneConfig['camera']['CameraFocalPoint']
# Initialize camera
for key, value in iteritems(sceneConfig['camera']):
self.view.GetProperty(key).SetData(value)
# Create a representation for all scene sources
self.config = sceneConfig
self.representations = []
for data in self.config['scene']:
rep = simple.Show(data['source'], self.view)
self.representations.append(rep)
if 'representation' in data:
for key in data['representation']:
rep.GetProperty(key).SetData(data['representation'][key])
# Add directory path
self.dataHandler.registerData(name='directory', rootFile=True, fileName='file.txt', categories=['trash'])
def __init__(self, directory):
self.basePath = directory
self.layers = []
self.data = []
self.imageReader = vtkPNGReader()
# Load JSON metadata
with open(os.path.join(directory, "config.json"), "r") as f:
self.config = json.load(f)
self.nbLayers = len(self.config['scene'])
while len(self.layers) < self.nbLayers:
self.layers.append({})
with open(os.path.join(directory, "index.json"), "r") as f:
self.info = json.load(f)
with open(os.path.join(directory, "offset.json"), "r") as f:
offsets = json.load(f)
for key, value in iteritems(offsets):
meta = key.split('|')
if len(meta) == 2:
self.layers[int(meta[0])][meta[1]] = value
elif meta[1] in self.layers[int(meta[0])]:
self.layers[int(meta[0])][meta[1]][int(meta[2])] = value
else:
self.layers[int(meta[0])][meta[1]] = [value, value, value]
self.composite = CompositeJSON(len(self.layers))
def registerData(self, **kwargs):
"""
name, type, mimeType, fileName, dependencies
"""
newData = {"metadata": {}}
argName = kwargs["name"]
for key, value in iteritems(kwargs):
if key == "fileName":
if "rootFile" in kwargs and kwargs["rootFile"]:
newData["pattern"] = "{pattern}/%s" % value
else:
newData["pattern"] = "{pattern}%s" % value
else:
newData[key] = value
self.data[argName] = newData
def registerArgument(self, **kwargs):
"""
We expect the following set of arguments
- priority
- name
- label (optional)
- values
- uiType
- defaultIdx
"""
newArgument = {}
argName = kwargs["name"]
self.argOrder.append(argName)
for key, value in iteritems(kwargs):
if key == "priority":
self.priority.append([argName, value])
elif key == "values":
self.realValues[argName] = value
newArgument[key] = ["{value}".format(value=x) for x in value]
else:
newArgument[key] = value
self.arguments[argName] = newArgument
def setArguments(self, **kwargs):
"""
Update the arguments index
"""
for key, value in iteritems(kwargs):
self.current[key] = value
def writeData(self, time=0):
if not self.dataHandler.can_write:
return
currentScene = [];
for data in self.config['scene']:
currentData = {
'name': data['name'],
'fields': {}
}
currentScene.append(currentData)
if self.surfaceExtract:
self.merge.Input = data['source']
else:
self.merge = simple.MergeBlocks(Input=data['source'], MergePoints=0)
self.surfaceExtract = simple.ExtractSurface(Input=self.merge)
# Extract surface
self.surfaceExtract.UpdatePipeline(time)
ds = self.surfaceExtract.SMProxy.GetClientSideObject().GetOutputDataObject(0)
originalDS = data['source'].SMProxy.GetClientSideObject().GetOutputDataObject(0)
originalPoints = ds.GetPoints()
# Points
points = vtkFloatArray()
nbPoints = originalPoints.GetNumberOfPoints()
points.SetNumberOfComponents(3)
points.SetNumberOfTuples(nbPoints)
for idx in range(nbPoints):
coord = originalPoints.GetPoint(idx)
points.SetTuple3(idx, coord[0], coord[1], coord[2])
pBuffer = buffer(points)
pMd5 = hashlib.md5(pBuffer).hexdigest()
pPath = os.path.join(self.dataHandler.getBasePath(), 'points',"%s.Float32Array" % pMd5)
currentData['points'] = 'points/%s.Float32Array' % pMd5
with open(pPath, 'wb') as f:
f.write(pBuffer)
# Polys
poly = ds.GetPolys()
nbCells = poly.GetNumberOfCells()
cellLocation = 0
idList = vtkIdList()
topo = vtkTypeUInt32Array()
topo.Allocate(poly.GetData().GetNumberOfTuples())
for cellIdx in range(nbCells):
poly.GetCell(cellLocation, idList)
cellSize = idList.GetNumberOfIds()
cellLocation += cellSize + 1
if cellSize == 3:
topo.InsertNextValue(idList.GetId(0))
topo.InsertNextValue(idList.GetId(1))
topo.InsertNextValue(idList.GetId(2))
elif cellSize == 4:
topo.InsertNextValue(idList.GetId(0))
topo.InsertNextValue(idList.GetId(1))
topo.InsertNextValue(idList.GetId(3))
topo.InsertNextValue(idList.GetId(1))
topo.InsertNextValue(idList.GetId(2))
topo.InsertNextValue(idList.GetId(3))
else:
print ("Cell size of", cellSize, "not supported")
iBuffer = buffer(topo)
iMd5 = hashlib.md5(iBuffer).hexdigest()
iPath = os.path.join(self.dataHandler.getBasePath(), 'index',"%s.Uint32Array" % iMd5)
currentData['index'] = 'index/%s.Uint32Array' % iMd5
with open(iPath, 'wb') as f:
f.write(iBuffer)
# Grow object side
self.objSize[data['name']]['points'] = max(self.objSize[data['name']]['points'], nbPoints)
self.objSize[data['name']]['index'] = max(self.objSize[data['name']]['index'], topo.GetNumberOfTuples())
# Colors / FIXME
for fieldName, fieldInfo in iteritems(data['colors']):
array = ds.GetPointData().GetArray(fieldName)
tupleSize = array.GetNumberOfComponents()
arraySize = array.GetNumberOfTuples()
outputField = vtkFloatArray()
outputField.SetNumberOfTuples(arraySize)
if tupleSize == 1:
for i in range(arraySize):
outputField.SetValue(i, array.GetValue(i))
else:
# compute magnitude
tupleIdxs = range(tupleSize)
for i in range(arraySize):
magnitude = 0
for j in tupleIdxs:
magnitude += math.pow(array.GetValue(i * tupleSize + j), 2)
outputField.SetValue(i, math.sqrt(magnitude))
fBuffer = buffer(outputField)
fMd5 = hashlib.md5(fBuffer).hexdigest()
fPath = os.path.join(self.dataHandler.getBasePath(), 'fields',"%s_%s.Float32Array" % (fieldName, fMd5))
with open(fPath, 'wb') as f:
f.write(fBuffer)
currentData['fields'][fieldName] = 'fields/%s_%s.Float32Array' % (fieldName, fMd5)
# Write scene
with open(self.dataHandler.getDataAbsoluteFilePath('scene'), 'w') as f:
f.write(json.dumps(currentScene, indent=2))
def writeData(self, time=0):
if not self.dataHandler.can_write:
return
currentScene = [];
for data in self.config['scene']:
currentData = {
'name': data['name'],
'fields': {},
'cells': {}
}
currentScene.append(currentData)
if self.surfaceExtract:
self.merge.Input = data['source']
else:
self.merge = simple.MergeBlocks(Input=data['source'], MergePoints=0)
self.surfaceExtract = simple.ExtractSurface(Input=self.merge)
# Extract surface
self.surfaceExtract.UpdatePipeline(time)
ds = self.surfaceExtract.SMProxy.GetClientSideObject().GetOutputDataObject(0)
originalDS = data['source'].SMProxy.GetClientSideObject().GetOutputDataObject(0)
originalPoints = ds.GetPoints()
# Points
points = vtkFloatArray()
nbPoints = originalPoints.GetNumberOfPoints()
points.SetNumberOfComponents(3)
points.SetNumberOfTuples(nbPoints)
for idx in range(nbPoints):
coord = originalPoints.GetPoint(idx)
points.SetTuple3(idx, coord[0], coord[1], coord[2])
pBuffer = buffer(points)
pMd5 = hashlib.md5(pBuffer).hexdigest()
pPath = os.path.join(self.dataHandler.getBasePath(), 'data',"%s.Float32Array" % pMd5)
currentData['points'] = 'data/%s.Float32Array' % pMd5
with open(pPath, 'wb') as f:
f.write(pBuffer)
# Handle cells
writeCellArray(self.dataHandler, currentData['cells'], 'verts', ds.GetVerts().GetData())
writeCellArray(self.dataHandler, currentData['cells'], 'lines', ds.GetLines().GetData())
writeCellArray(self.dataHandler, currentData['cells'], 'polys', ds.GetPolys().GetData())
writeCellArray(self.dataHandler, currentData['cells'], 'strips', ds.GetStrips().GetData())
# Fields
for fieldName, fieldInfo in iteritems(data['colors']):
array = None
if 'constant' in fieldInfo:
currentData['fields'][fieldName] = fieldInfo
continue
elif 'POINT_DATA' in fieldInfo['location']:
array = ds.GetPointData().GetArray(fieldName)
elif 'CELL_DATA' in fieldInfo['location']:
array = ds.GetCellData().GetArray(fieldName)
jsType = jsMapping[arrayTypesMapping[array.GetDataType()]]
arrayRange = array.GetRange(-1)
tupleSize = array.GetNumberOfComponents()
arraySize = array.GetNumberOfTuples()
if tupleSize == 1:
outputField = array
else:
# compute magnitude
outputField = array.NewInstance()
outputField.SetNumberOfTuples(arraySize)
tupleIdxs = range(tupleSize)
for i in range(arraySize):
magnitude = 0
for j in tupleIdxs:
magnitude += math.pow(array.GetValue(i * tupleSize + j), 2)
outputField.SetValue(i, math.sqrt(magnitude))
fBuffer = buffer(outputField)
fMd5 = hashlib.md5(fBuffer).hexdigest()
fPath = os.path.join(self.dataHandler.getBasePath(), 'data',"%s_%s.%s" % (fieldName, fMd5, jsType))
with open(fPath, 'wb') as f:
f.write(fBuffer)
currentRange = self.ranges[fieldName]
if currentRange[1] < currentRange[0]:
currentRange[0] = arrayRange[0];
currentRange[1] = arrayRange[1];
else:
currentRange[0] = arrayRange[0] if arrayRange[0] < currentRange[0] else currentRange[0];
currentRange[1] = arrayRange[1] if arrayRange[1] > currentRange[1] else currentRange[1];
currentData['fields'][fieldName] = {
'array' : 'data/%s_%s.%s' % (fieldName, fMd5, jsType),
'location': fieldInfo['location'],
'range': outputField.GetRange()
}
# Write scene
with open(self.dataHandler.getDataAbsoluteFilePath('scene'), 'w') as f:
f.write(json.dumps(currentScene, indent=4))
def writeData(self):
composite_size = len(self.representations)
self.view.UpdatePropertyInformation()
self.view.Background = [0,0,0]
imageSize = self.view.ViewSize[0] * self.view.ViewSize[1]
# Generate the heavy data
for camPos in self.getCamera():
self.view.CameraFocalPoint = camPos['focalPoint']
self.view.CameraPosition = camPos['position']
self.view.CameraViewUp = camPos['viewUp']
# Show all representations
for compositeIdx in range(composite_size):
rep = self.representations[compositeIdx]
rep.Visibility = 1
# Fix camera bounds
self.view.LockBounds = 0
simple.Render(self.view)
self.view.LockBounds = 1
# Update destination directory
dest_path = os.path.dirname(self.dataHandler.getDataAbsoluteFilePath('directory'))
# Write camera information
if self.dataHandler.can_write:
with open(os.path.join(dest_path, "camera.json"), 'w') as f:
f.write(json.dumps(camPos))
# Hide all representations
for compositeIdx in range(composite_size):
rep = self.representations[compositeIdx]
rep.Visibility = 0
# Show only active Representation
# Extract images for each fields
for compositeIdx in range(composite_size):
rep = self.representations[compositeIdx]
if compositeIdx > 0:
self.representations[compositeIdx - 1].Visibility = 0
rep.Visibility = 1
# capture Z
simple.Render()
zBuffer = self.view.CaptureDepthBuffer()
with open(os.path.join(dest_path, 'depth_%d.float32' % compositeIdx), 'wb') as f:
f.write(buffer(zBuffer))
# Prevent color interference
rep.DiffuseColor = [1,1,1]
# Handle light
for lightType in self.config['light']:
if lightType == 'intensity':
rep.AmbientColor = [1,1,1]
rep.SpecularColor = [1,1,1]
self.view.StartCaptureLuminance()
image = self.view.CaptureWindow(1)
imagescalars = image.GetPointData().GetScalars()
self.view.StopCaptureLuminance()
# Extract specular information
specularOffset = 1 # [diffuse, specular, ?]
imageSize = imagescalars.GetNumberOfTuples()
specularComponent = vtkUnsignedCharArray()
specularComponent.SetNumberOfComponents(1)
specularComponent.SetNumberOfTuples(imageSize)
for idx in range(imageSize):
specularComponent.SetValue(idx, imagescalars.GetValue(idx * 3 + specularOffset))
with open(os.path.join(dest_path, 'intensity_%d.uint8' % compositeIdx), 'wb') as f:
f.write(buffer(specularComponent))
# Free memory
image.UnRegister(None)
if lightType == 'normal':
if rep.Representation in ['Point Gaussian', 'Points', 'Outline', 'Wireframe']:
uniqNormal = [(camPos['position'][i] - camPos['focalPoint'][i]) for i in range(3)]
tmpNormalArray = vtkFloatArray()
tmpNormalArray.SetNumberOfComponents(1)
tmpNormalArray.SetNumberOfTuples(imageSize)
for comp in range(3):
tmpNormalArray.FillComponent(0, uniqNormal[comp])
with open(os.path.join(dest_path, 'normal_%d_%d.float32' % (compositeIdx, comp)), 'wb') as f:
f.write(buffer(tmpNormalArray))
else:
for comp in range(3):
# Configure view to handle POINT_DATA / CELL_DATA
self.view.DrawCells = 0
self.view.ArrayNameToDraw = 'Normals'
self.view.ArrayComponentToDraw = comp
self.view.ScalarRange = [-1.0, 1.0]
self.view.StartCaptureValues()
image = self.view.CaptureWindow(1)
imagescalars = image.GetPointData().GetScalars()
self.view.StopCaptureValues()
# Convert RGB => Float => Write
floatArray = data_converter.convertRGBArrayToFloatArray(imagescalars, [-1.0, 1.0])
with open(os.path.join(dest_path, 'normal_%d_%d.float32' % (compositeIdx, comp)), 'wb') as f:
f.write(buffer(floatArray))
# Free memory
image.UnRegister(None)
# Handle color by
for fieldName, fieldConfig in iteritems(self.config['scene'][compositeIdx]['colors']):
if 'constant' in fieldConfig:
# Skip nothing to render
continue
# Configure view to handle POINT_DATA / CELL_DATA
if fieldConfig['location'] == 'POINT_DATA':
self.view.DrawCells = 0
else:
self.view.DrawCells = 1
self.view.ArrayNameToDraw = fieldName
self.view.ArrayComponentToDraw = 0
self.view.ScalarRange = fieldConfig['range']
self.view.StartCaptureValues()
image = self.view.CaptureWindow(1)
imagescalars = image.GetPointData().GetScalars()
self.view.StopCaptureValues()
floatArray = data_converter.convertRGBArrayToFloatArray(imagescalars, fieldConfig['range'])
with open(os.path.join(dest_path, '%d_%s.float32' % (compositeIdx, fieldName)), 'wb') as f:
f.write(buffer(floatArray))
self.dataHandler.registerData(name='%d_%s' % (compositeIdx, fieldName), fileName='/%d_%s.float32' % (compositeIdx, fieldName), type='array', categories=['%d_%s' % (compositeIdx, fieldName)])
# Free memory
image.UnRegister(None)