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)