def show_vector_field_actors(self, actor_specs, drawing_params=None, show_flag=True): """ Shows vector field actors :param actor_specs: {ActorSpecs} :param drawing_params: {DrawingParameters} :param show_flag: {bool} :return: None """ scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) if show_flag: self.add_actor_to_renderer(actor_label='vector_field_actor', actor_obj=self.glyphsActor) if mdata.get('DisplayMinMaxInfo', default=True): self.add_actor_to_renderer(actor_label='min_max_text_actor', actor_obj=self.min_max_text_actor) else: self.remove_actor_from_renderer(actor_label='vector_field_actor', actor_obj=self.glyphsActor) self.remove_actor_from_renderer(actor_label='min_max_text_actor', actor_obj=self.min_max_text_actor)
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 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 show_concentration_field_actors(self, actor_specs, drawing_params=None, show_flag=True): """ Shows concentration actors :param actor_specs: {ActorSpecs} :param drawing_params: {DrawingParameters} :param show_flag: {bool} :return: None """ scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) if show_flag: self.add_actor_to_renderer(actor_label='concentration_actor', actor_obj=self.conActor) if mdata.get('ContoursOn', default=False): self.add_actor_to_renderer(actor_label='contour_actor', actor_obj=self.contourActor) if mdata.get('LegendEnable', default=False): self.add_actor_to_renderer(actor_label='legend_actor', actor_obj=self.legendActor) if mdata.get('DisplayMinMaxInfo', default=True): self.add_actor_to_renderer(actor_label='min_max_text_actor', actor_obj=self.min_max_text_actor) else: self.remove_actor_from_renderer(actor_label='concentration_actor', actor_obj=self.conActor) self.remove_actor_from_renderer(actor_label='contour_actor', actor_obj=self.contourActor) self.remove_actor_from_renderer(actor_label='legend_actor', actor_obj=self.legendActor) self.remove_actor_from_renderer(actor_label='min_max_text_actor', actor_obj=self.min_max_text_actor)
def show_fpp_links_actors(self, actor_specs, drawing_params=None, show_flag=True): """ Shows fpp links actors :param actor_specs: {ActorSpecs} :param drawing_params: {DrawingParameters} :param show_flag: {bool} :return: None """ scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) if show_flag: self.add_actor_to_renderer(actor_label='fpp_links_actor', actor_obj=self.FPPLinksActor) else: self.remove_actor_from_renderer(actor_label='fpp_links_actor', actor_obj=self.FPPLinksActor)
def show_cluster_border_actors(self, actor_specs, drawing_params=None, show_flag=True): """ Shows concentration actors :param actor_specs: {ActorSpecs} :param drawing_params: {DrawingParameters} :param show_flag: {bool} :return: None """ scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) if show_flag: self.add_actor_to_renderer(actor_label='cluster_border_actor', actor_obj=self.clusterBorderActor) else: self.remove_actor_from_renderer(actor_label='cluster_border_actor', actor_obj=self.clusterBorderActor)
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_concentration_field_actors(self, actor_specs, drawing_params=None): """ initializes concentration field actors :param actor_specs: :param drawing_params: :return: None """ actors_dict = actor_specs.actors_dict field_dim = self.currentDrawingParameters.bsd.fieldDim # dim_order = self.dimOrder(self.currentDrawingParameters.plane) # dim = self.planeMapper(dim_order, (field_dim.x, field_dim.y, field_dim.z))# [fieldDim.x, fieldDim.y, fieldDim.z] dim = [field_dim.x, field_dim.y, field_dim.z] field_name = drawing_params.fieldName scene_metadata = drawing_params.screenshot_data.metadata mdata = MetadataHandler(mdata=scene_metadata) try: isovalues = mdata.get('ScalarIsoValues', default=[]) isovalues = list([float(x) for x in isovalues]) except: print('Could not process isovalue list ') isovalues = [] try: numIsos = mdata.get('NumberOfContourLines', default=3) except: print('could not process NumberOfContourLines setting') numIsos = 0 hex_flag = False lattice_type_str = self.get_lattice_type_str() if lattice_type_str.lower() == 'hexagonal': hex_flag = True types_invisible = PlayerPython.vectorint() for type_label in drawing_params.screenshot_data.invisible_types: types_invisible.append(int(type_label)) # self.isovalStr = Configuration.getSetting("ScalarIsoValues", field_name) # if type(self.isovalStr) == QVariant: # self.isovalStr = str(self.isovalStr.toString()) # else: # self.isovalStr = str(self.isovalStr) con_array = vtk.vtkDoubleArray() con_array.SetName("concentration") con_array_int_addr = extract_address_int_from_vtk_object( vtkObj=con_array) cell_type_con = vtk.vtkIntArray() cell_type_con.SetName("concelltype") cell_type_con_int_addr = extract_address_int_from_vtk_object( vtkObj=cell_type_con) field_type = drawing_params.fieldType.lower() if field_type == 'confield': fill_successful = self.field_extractor.fillConFieldData3D( con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) elif field_type == 'scalarfield': fill_successful = self.field_extractor.fillScalarFieldData3D( con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) elif field_type == 'scalarfieldcelllevel': fill_successful = self.field_extractor.fillScalarFieldCellLevelData3D( con_array_int_addr, cell_type_con_int_addr, field_name, types_invisible) if not fill_successful: return range_array = con_array.GetRange() min_con = range_array[0] max_con = range_array[1] field_max = range_array[1] # print MODULENAME, ' initScalarFieldDataActors(): min,maxCon=',self.minCon,self.maxCon 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_con = min_range if max_range_fixed: max_con = max_range uGrid = vtk.vtkStructuredPoints() uGrid.SetDimensions( dim[0] + 2, dim[1] + 2, dim[2] + 2 ) # only add 2 if we're filling in an extra boundary (rf. FieldExtractor.cpp) # uGrid.SetDimensions(self.dim[0],self.dim[1],self.dim[2]) # uGrid.GetPointData().SetScalars(self.cellTypeCon) # cellType scalar field uGrid.GetPointData().SetScalars(con_array) # uGrid.GetPointData().AddArray(self.conArray) # additional scalar field voi = vtk.vtkExtractVOI() ## voi.SetInputConnection(uGrid.GetOutputPort()) # voi.SetInput(uGrid.GetOutput()) if VTK_MAJOR_VERSION >= 6: voi.SetInputData(uGrid) else: voi.SetInput(uGrid) voi.SetVOI(1, dim[0] - 1, 1, dim[1] - 1, 1, dim[2] - 1) # crop out the artificial boundary layer that we created isoContour = vtk.vtkContourFilter() # skinExtractorColor = vtk.vtkDiscreteMarchingCubes() # skinExtractorColor = vtk.vtkMarchingCubes() # isoContour.SetInput(uGrid) isoContour.SetInputConnection(voi.GetOutputPort()) isoNum = 0 for isoNum, isoVal in enumerate(isovalues): try: isoContour.SetValue(isoNum, isoVal) except: print( MODULENAME, ' initScalarFieldDataActors(): cannot convert to float: ', self.isovalStr[idx]) if isoNum > 0: isoNum += 1 delIso = (max_con - min_con) / (numIsos + 1 ) # exclude the min,max for isovalues isoVal = min_con + delIso for idx in range(numIsos): isoContour.SetValue(isoNum, isoVal) isoNum += 1 isoVal += delIso # UGLY hack to NOT display anything since our attempt to RemoveActor (below) don't seem to work if isoNum == 0: isoVal = field_max + 1.0 # go just outside valid range isoContour.SetValue(isoNum, isoVal) # concLut = vtk.vtkLookupTable() # concLut.SetTableRange(conc_vol.GetScalarRange()) # concLut.SetTableRange([self.minCon,self.maxCon]) self.scalarLUT.SetTableRange([min_con, max_con]) # concLut.SetNumberOfColors(256) # concLut.Build() # concLut.SetTableValue(39,0,0,0,0) # skinColorMapper = vtk.vtkPolyDataMapper() # skinColorMapper.SetInputConnection(skinNormals.GetOutputPort()) # self.conMapper.SetInputConnection(skinExtractorColor.GetOutputPort()) self.conMapper.SetInputConnection(isoContour.GetOutputPort()) self.conMapper.ScalarVisibilityOn() self.conMapper.SetLookupTable(self.scalarLUT) # # # print " this is conc_vol.GetScalarRange()=",conc_vol.GetScalarRange() # self.conMapper.SetScalarRange(conc_vol.GetScalarRange()) self.conMapper.SetScalarRange([min_con, max_con]) # self.conMapper.SetScalarRange(0,1500) # rwh - what does this do? # self.conMapper.SetScalarModeToUsePointFieldData() # self.conMapper.ColorByArrayComponent("concentration",0) # print MODULENAME,"initScalarFieldDataActors(): Plotting 3D Scalar field" # self.conMapper = vtk.vtkPolyDataMapper() # self.conActor = vtk.vtkActor() concentration_actor = actors_dict['concentration_actor'] concentration_actor.SetMapper(self.conMapper) self.init_min_max_actor( min_max_actor=actors_dict['min_max_text_actor'], range_array=range_array) if hex_flag: concentration_actor.SetScale(self.xScaleHex, self.yScaleHex, self.zScaleHex) if actor_specs.metadata is None: actor_specs.metadata = {'mapper': self.conMapper} else: actor_specs.metadata['mapper'] = self.conMapper if mdata.get('LegendEnable', default=False): self.init_legend_actors(actor_specs=actor_specs, drawing_params=drawing_params)
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)