def generate_cell_type_lookup_table(scene_metadata=None,
actual_screenshot=False):
"""
generates cell type color lookup table. Depending whether we got metadata for
actual screenshot or not we will use cell type color lookup table based on
settings or we will use colors defined int he screenshot description file
:param scene_metadata: scene metadata dict
:param actual_screenshot: flag that tells if we got metadata for actual screenshot
:return:
"""
if actual_screenshot:
if scene_metadata is None:
color_map = Configuration.getSetting("TypeColorMap")
else:
color_map = scene_metadata["TypeColorMap"]
else:
color_map = Configuration.getSetting("TypeColorMap")
cell_type_color_lookup_table = vtk.vtkLookupTable()
# You need to explicitly call Build() when constructing the LUT by hand
cell_type_color_lookup_table.Build()
cell_type_color_lookup_table.SetNumberOfTableValues(len(color_map))
cell_type_color_lookup_table.SetNumberOfColors(len(color_map))
for type_id, color_obj in list(color_map.items()):
type_id = int(type_id)
rgba = to_vtk_rgb(color_obj=color_obj)
rgba.append(1.0)
cell_type_color_lookup_table.SetTableValue(type_id, *rgba)
return cell_type_color_lookup_table
def init_axes_actors(self, actor_specs, drawing_params=None):
"""
Initializes outline actors for hex actors
:param actor_specs: {ActorSpecs}
:param drawing_params: {DrawingParameters}
:return: None
"""
actors_dict = actor_specs.actors_dict
field_dim = self.currentDrawingParameters.bsd.fieldDim
scene_metadata = drawing_params.screenshot_data.metadata
mdata = MetadataHandler(mdata=scene_metadata)
axes_actor = actors_dict['axes_actor']
axes_color = to_vtk_rgb(mdata.get('AxesColor', data_type='color'))
tprop = vtk.vtkTextProperty()
tprop.SetColor(axes_color)
tprop.ShadowOn()
axes_actor.SetNumberOfLabels(4) # number of labels
# lattice_type_str = self.get_lattice_type_str()
# if lattice_type_str.lower() == 'hexagonal':
if self.is_lattice_hex(drawing_params=drawing_params):
axes_actor.SetBounds(0, field_dim.x, 0,
field_dim.y * math.sqrt(3.0) / 2.0, 0,
field_dim.z * math.sqrt(6.0) / 3.0)
else:
axes_actor.SetBounds(0, field_dim.x, 0, field_dim.y, 0,
field_dim.z)
axes_actor.SetLabelFormat("%6.4g")
axes_actor.SetFlyModeToOuterEdges()
axes_actor.SetFontFactor(1.5)
# axesActor.GetProperty().SetColor(float(color.red())/255,float(color.green())/255,float(color.blue())/255)
axes_actor.GetProperty().SetColor(axes_color)
xAxisActor = axes_actor.GetXAxisActor2D()
# xAxisActor.RulerModeOn()
# xAxisActor.SetRulerDistance(40)
# xAxisActor.SetRulerMode(20)
# xAxisActor.RulerModeOn()
xAxisActor.SetNumberOfMinorTicks(3)
def populate_cell_type_lookup_table(self, scene_metadata=None):
"""
Populates lookup table
:param scene_metadata:
:return:
"""
if scene_metadata is None:
color_map = Configuration.getSetting("TypeColorMap")
else:
color_map = scene_metadata["TypeColorMap"]
self.celltypeLUT = vtk.vtkLookupTable()
# You need to explicitly call Build() when constructing the LUT by hand
self.celltypeLUT.Build()
self.celltypeLUT.SetNumberOfTableValues(len(color_map))
self.celltypeLUT.SetNumberOfColors(len(color_map))
for type_id, qt_color in list(color_map.items()):
rgba = to_vtk_rgb(qcolor_to_rgba(qt_color))
rgba.append(1.0)
self.celltypeLUT.SetTableValue(type_id, *rgba)
def init_outline_actors(self, actor_specs, drawing_params=None):
"""
Initializes outline actors for hex actors
:param actor_specs: {ActorSpecs}
:param drawing_params: {DrawingParameters}
:return: None
"""
actors_dict = actor_specs.actors_dict
field_dim = self.currentDrawingParameters.bsd.fieldDim
scene_metadata = drawing_params.screenshot_data.metadata
mdata = MetadataHandler(mdata=scene_metadata)
outline_data = vtk.vtkImageData()
outline_data.SetDimensions(field_dim.x + 1, field_dim.y + 1,
field_dim.z + 1)
outline = vtk.vtkOutlineFilter()
if VTK_MAJOR_VERSION >= 6:
outline.SetInputData(outline_data)
else:
outline.SetInput(outline_data)
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = actors_dict['outline_actor']
outline_actor.SetMapper(outline_mapper)
# lattice_type_str = self.get_lattice_type_str()
# if lattice_type_str.lower() == 'hexagonal':
if self.is_lattice_hex(drawing_params=drawing_params):
outline_actor.SetScale(self.xScaleHex, self.yScaleHex,
self.zScaleHex)
outline_color = to_vtk_rgb(
mdata.get('BoundingBoxColor', data_type='color'))
outline_actor.GetProperty().SetColor(*outline_color)
def init_fpp_links_actors(self, actor_specs, drawing_params=None):
"""
initializes fpp links actors
:param actor_specs:
:param drawing_params:
:return: None
"""
fppPlugin = CompuCell.getFocalPointPlasticityPlugin()
# if (fppPlugin == 0): # bogus check
if not fppPlugin: # bogus check
print(' fppPlugin is null, returning')
return
actors_dict = actor_specs.actors_dict
field_dim = self.currentDrawingParameters.bsd.fieldDim
scene_metadata = drawing_params.screenshot_data.metadata
mdata = MetadataHandler(mdata=scene_metadata)
xdim = field_dim.x
ydim = field_dim.y
try:
cellField = self.currentDrawingParameters.bsd.sim.getPotts(
).getCellFieldG()
inventory = self.currentDrawingParameters.bsd.sim.getPotts(
).getCellInventory()
except AttributeError:
raise AttributeError('Could not access Potts object')
cellList = CellList(inventory)
points = vtk.vtkPoints()
lines = vtk.vtkCellArray()
beginPt = 0
lineNum = 0
for cell in cellList:
vol = cell.volume
if vol < self.eps: continue
xmid0 = cell.xCOM
ymid0 = cell.yCOM
zmid0 = cell.zCOM
points.InsertNextPoint(xmid0, ymid0, zmid0)
endPt = beginPt + 1
for fppd in InternalFocalPointPlasticityDataList(fppPlugin, cell):
xmid = fppd.neighborAddress.xCOM
ymid = fppd.neighborAddress.yCOM
zmid = fppd.neighborAddress.zCOM
xdiff = xmid - xmid0
ydiff = ymid - ymid0
zdiff = zmid - zmid0
actualDist = math.sqrt(xdiff**2 + ydiff**2 + zdiff**2)
if actualDist > fppd.maxDistance:
# implies we have wraparound (via periodic BCs)
# we are not drawing those links that wrap around the lattice - leaving the code for now
# todo - most likely will redo this part later
continue
# add dangling "out" line to beginning cell
if abs(xdiff) > abs(ydiff): # wraps around in x-direction
if xdiff < 0:
xmid0end = xmid0 + self.stubSize
else:
xmid0end = xmid0 - self.stubSize
ymid0end = ymid0
points.InsertNextPoint(xmid0end, ymid0end, 0)
lines.InsertNextCell(2) # our line has 2 points
lines.InsertCellPoint(beginPt)
lines.InsertCellPoint(endPt)
actualDist = xdim - actualDist # compute (approximate) real actualDist
lineNum += 1
endPt += 1
else: # wraps around in y-direction
xmid0end = xmid0
if ydiff < 0:
ymid0end = ymid0 + self.stubSize
else:
ymid0end = ymid0 - self.stubSize
points.InsertNextPoint(xmid0end, ymid0end, 0)
lines.InsertNextCell(2) # our line has 2 points
lines.InsertCellPoint(beginPt)
lines.InsertCellPoint(endPt)
actualDist = ydim - actualDist # compute (approximate) real actualDist
lineNum += 1
endPt += 1
# link didn't wrap around on lattice
else:
points.InsertNextPoint(xmid, ymid, zmid)
lines.InsertNextCell(2) # our line has 2 points
lines.InsertCellPoint(beginPt)
lines.InsertCellPoint(endPt)
lineNum += 1
endPt += 1
for fppd in FocalPointPlasticityDataList(fppPlugin, cell):
xmid = fppd.neighborAddress.xCOM
ymid = fppd.neighborAddress.yCOM
zmid = fppd.neighborAddress.zCOM
xdiff = xmid - xmid0
ydiff = ymid - ymid0
zdiff = ymid - zmid0
actualDist = math.sqrt(xdiff**2 + ydiff**2 + zdiff**2)
if actualDist > fppd.maxDistance: # implies we have wraparound (via periodic BCs)
# we are not drawing those links that wrap around the lattice - leaving the code for now
# todo - most likely will redo this part later
continue
# add dangling "out" line to beginning cell
if abs(xdiff) > abs(ydiff): # wraps around in x-direction
# print '>>>>>> wraparound X'
if xdiff < 0:
xmid0end = xmid0 + self.stubSize
else:
xmid0end = xmid0 - self.stubSize
ymid0end = ymid0
points.InsertNextPoint(xmid0end, ymid0end, 0)
lines.InsertNextCell(2) # our line has 2 points
lines.InsertCellPoint(beginPt)
lines.InsertCellPoint(endPt)
# coloring the FPP links
actualDist = xdim - actualDist # compute (approximate) real actualDist
lineNum += 1
endPt += 1
else: # wraps around in y-direction
xmid0end = xmid0
if ydiff < 0:
ymid0end = ymid0 + self.stubSize
else:
ymid0end = ymid0 - self.stubSize
points.InsertNextPoint(xmid0end, ymid0end, 0)
lines.InsertNextCell(2) # our line has 2 points
lines.InsertCellPoint(beginPt)
lines.InsertCellPoint(endPt)
# coloring the FPP links
actualDist = ydim - actualDist # compute (approximate) real actualDist
lineNum += 1
endPt += 1
# link didn't wrap around on lattice
else:
points.InsertNextPoint(xmid, ymid, zmid)
lines.InsertNextCell(2) # our line has 2 points
lines.InsertCellPoint(beginPt)
lines.InsertCellPoint(endPt)
lineNum += 1
endPt += 1
beginPt = endPt # update point index
# -----------------------
if lineNum == 0:
return
FPPLinksPD = vtk.vtkPolyData()
FPPLinksPD.SetPoints(points)
FPPLinksPD.SetLines(lines)
fpp_links_actor = actors_dict['fpp_links_actor']
if VTK_MAJOR_VERSION >= 6:
self.FPPLinksMapper.SetInputData(FPPLinksPD)
else:
FPPLinksPD.Update()
self.FPPLinksMapper.SetInput(FPPLinksPD)
fpp_links_actor.SetMapper(self.FPPLinksMapper)
fpp_links_color = to_vtk_rgb(
mdata.get('FPPLinksColor', data_type='color'))
# coloring borders
fpp_links_actor.GetProperty().SetColor(*fpp_links_color)
def init_vector_field_actors(self, actor_specs, drawing_params=None):
"""
initializes vector field actors for cartesian lattice
:param actor_specs: {ActorSpecs}
:param drawing_params: {DrawingParameters}
:return: None
"""
actors_dict = actor_specs.actors_dict
field_dim = self.currentDrawingParameters.bsd.fieldDim
field_name = drawing_params.fieldName
field_type = drawing_params.fieldType.lower()
scene_metadata = drawing_params.screenshot_data.metadata
mdata = MetadataHandler(mdata=scene_metadata)
dim = [field_dim.x, field_dim.y, field_dim.z]
vector_grid = vtk.vtkUnstructuredGrid()
points = vtk.vtkPoints()
vectors = vtk.vtkFloatArray()
vectors.SetNumberOfComponents(3)
vectors.SetName("visVectors")
points_int_addr = extract_address_int_from_vtk_object(vtkObj=points)
vectors_int_addr = extract_address_int_from_vtk_object(vtkObj=vectors)
fill_successful = False
hex_flag = False
if self.is_lattice_hex(drawing_params=drawing_params):
hex_flag = True
if field_type == 'vectorfield':
fill_successful = self.field_extractor.fillVectorFieldData2DHex(
points_int_addr, vectors_int_addr, field_name,
self.currentDrawingParameters.plane,
self.currentDrawingParameters.planePos)
elif field_type == 'vectorfieldcelllevel':
fill_successful = self.field_extractor.fillVectorFieldCellLevelData2DHex(
points_int_addr, vectors_int_addr, field_name,
self.currentDrawingParameters.plane,
self.currentDrawingParameters.planePos)
else:
if field_type == 'vectorfield':
fill_successful = self.field_extractor.fillVectorFieldData2D(
points_int_addr, vectors_int_addr, field_name,
self.currentDrawingParameters.plane,
self.currentDrawingParameters.planePos)
elif field_type == 'vectorfieldcelllevel':
fill_successful = self.field_extractor.fillVectorFieldCellLevelData2D(
points_int_addr, vectors_int_addr, field_name,
self.currentDrawingParameters.plane,
self.currentDrawingParameters.planePos)
if not fill_successful:
return
vector_grid.SetPoints(points)
vector_grid.GetPointData().SetVectors(vectors)
cone = vtk.vtkConeSource()
cone.SetResolution(5)
cone.SetHeight(2)
cone.SetRadius(0.5)
# cone.SetRadius(4)
range_array = vectors.GetRange(-1)
min_magnitude = range_array[0]
max_magnitude = range_array[1]
min_max_dict = self.get_min_max_metadata(scene_metadata=scene_metadata,
field_name=field_name)
min_range_fixed = min_max_dict['MinRangeFixed']
max_range_fixed = min_max_dict['MaxRangeFixed']
min_range = min_max_dict['MinRange']
max_range = min_max_dict['MaxRange']
# Note! should really avoid doing a getSetting with each step to speed up the rendering;
# only update when changed in Prefs
if min_range_fixed:
min_magnitude = min_range
if max_range_fixed:
max_magnitude = max_range
glyphs = vtk.vtkGlyph3D()
if VTK_MAJOR_VERSION >= 6:
glyphs.SetInputData(vector_grid)
else:
glyphs.SetInput(vector_grid)
glyphs.SetSourceConnection(cone.GetOutputPort())
# glyphs.SetScaleModeToScaleByVector()
# glyphs.SetColorModeToColorByVector()
# scaling arrows here ArrowLength indicates scaling factor not actual length
# glyphs.SetScaleFactor(Configuration.getSetting("ArrowLength"))
vector_field_actor = actors_dict['vector_field_actor']
# scaling factor for an arrow - ArrowLength indicates scaling factor not actual length
arrowScalingFactor = mdata.get('ArrowLength', default=1.0)
if mdata.get('FixedArrowColorOn', default=False):
glyphs.SetScaleModeToScaleByVector()
dataScalingFactor = max(abs(min_magnitude), abs(max_magnitude))
if dataScalingFactor == 0.0:
# in this case we are plotting 0 vectors and in this case data scaling factor will be set to 1
dataScalingFactor = 1.0
glyphs.SetScaleFactor(arrowScalingFactor / dataScalingFactor)
# coloring arrows
arrow_color = to_vtk_rgb(mdata.get('ArrowColor',
data_type='color'))
vector_field_actor.GetProperty().SetColor(arrow_color)
else:
glyphs.SetColorModeToColorByVector()
glyphs.SetScaleFactor(arrowScalingFactor)
self.glyphsMapper.SetInputConnection(glyphs.GetOutputPort())
self.glyphsMapper.SetLookupTable(self.scalarLUT)
self.glyphsMapper.SetScalarRange([min_magnitude, max_magnitude])
vector_field_actor.SetMapper(self.glyphsMapper)
self.init_min_max_actor(
min_max_actor=actors_dict['min_max_text_actor'],
range_array=range_array)
if hex_flag:
vector_field_actor.SetScale(self.xScaleHex, self.yScaleHex,
self.zScaleHex)
def init_fpp_links_actors(self, actor_specs, drawing_params=None):
"""
initializes fpp links actors
:param actor_specs:
:param drawing_params:
:return: None
"""
fpp_plugin = CompuCell.getFocalPointPlasticityPlugin()
if not fpp_plugin:
print(' fppPlugin is null, returning')
return
actors_dict = actor_specs.actors_dict
field_dim = self.currentDrawingParameters.bsd.fieldDim
scene_metadata = drawing_params.screenshot_data.metadata
mdata = MetadataHandler(mdata=scene_metadata)
try:
inventory = self.currentDrawingParameters.bsd.sim.getPotts(
).getCellInventory()
except AttributeError:
raise AttributeError('Could not access Potts object')
cell_list = CellList(inventory)
points = vtk.vtkPoints()
lines = vtk.vtkCellArray()
pt_counter = 0
for cell in cell_list:
vol = cell.volume
if vol < self.eps:
continue
mid_com = np.array([cell.xCOM, cell.yCOM, cell.zCOM], dtype=float)
for fppd in InternalFocalPointPlasticityDataList(fpp_plugin, cell):
pt_counter = self.add_link(field_dim=field_dim,
fppd=fppd,
mid_com=mid_com,
pt_counter=pt_counter,
lines=lines,
points=points)
for fppd in FocalPointPlasticityDataList(fpp_plugin, cell):
pt_counter = self.add_link(field_dim=field_dim,
fppd=fppd,
mid_com=mid_com,
pt_counter=pt_counter,
lines=lines,
points=points)
fpp_links_pd = vtk.vtkPolyData()
fpp_links_pd.SetPoints(points)
fpp_links_pd.SetLines(lines)
fpp_links_actor = actors_dict['fpp_links_actor']
if VTK_MAJOR_VERSION >= 6:
self.FPPLinksMapper.SetInputData(fpp_links_pd)
else:
fpp_links_pd.Update()
self.FPPLinksMapper.SetInput(fpp_links_pd)
fpp_links_actor.SetMapper(self.FPPLinksMapper)
fpp_links_color = to_vtk_rgb(
mdata.get('FPPLinksColor', data_type='color'))
# coloring borders
fpp_links_actor.GetProperty().SetColor(*fpp_links_color)