def get_min_max_metadata(self, scene_metadata, field_name): """ Returns dictionary with the following entries: 1. MinRangeFixed 2. MaxRangeFixed 3. MinRange 3. MaxRange :param scene_metadata:{dict} metadata dictionary :param field_name: {str} field name :return: {dict} """ out_dict = {} if set(['MinRangeFixed', "MaxRangeFixed", 'MinRange', 'MaxRange']).issubset(set(scene_metadata.keys())): min_range_fixed = scene_metadata['MinRangeFixed'] max_range_fixed = scene_metadata['MaxRangeFixed'] min_range = scene_metadata['MinRange'] max_range = scene_metadata['MaxRange'] else: min_range_fixed = Configuration.getSetting("MinRangeFixed", field_name) max_range_fixed = Configuration.getSetting("MaxRangeFixed", field_name) min_range = Configuration.getSetting("MinRange", field_name) max_range = Configuration.getSetting("MaxRange", field_name) out_dict['MinRangeFixed'] = min_range_fixed out_dict['MaxRangeFixed'] = max_range_fixed out_dict['MinRange'] = min_range out_dict['MaxRange'] = max_range return out_dict
def set3DInvisibleTypes(self): ''' Initializes a dictionary self.invisibleCellTypes of invisible cell types - reads settings "Types3DInvisible" :return:None ''' self.colorMap = Configuration.getSetting("TypeColorMap") typesInvisibleStrTmp = str(Configuration.getSetting("Types3DInvisible")) # print "GOT ",typesInvisibleStrTmp if typesInvisibleStrTmp != self.typesInvisibleStr: self.typesInvisibleStr = str(Configuration.getSetting("Types3DInvisible")) typesInvisible = self.typesInvisibleStr.replace(" ", "") typesInvisible = typesInvisible.split(",") def cell_type_check(cell_type): try: cell_type_int = int(cell_type) if cell_type_int >= 0: return True else: return False except: False typesInvisible = [int(cell_type) for cell_type in typesInvisible if cell_type_check(cell_type)] # print "typesInvisibleVec=",typesInvisibleVec # turning list into a dictionary self.invisibleCellTypes.clear() for type in typesInvisible: self.invisibleCellTypes[int(type)] = 0
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 store_gui_vis_config(self, scrData): """ Stores visualization settings such as cell borders, on/or cell on/off etc... :param scrData: {instance of ScreenshotDescriptionData} :return: None """ tvw = self.tabViewWidget() if tvw: tvw.update_active_window_vis_flags(self.screenshotGraphicsWidget) scrData.cell_borders_on = tvw.border_act.isChecked() scrData.cells_on = tvw.cells_act.isChecked() scrData.cluster_borders_on = tvw.cluster_border_act.isChecked() scrData.cell_glyphs_on = tvw.cell_glyphs_act.isChecked() scrData.fpp_links_on = tvw.fpp_links_act.isChecked() scrData.lattice_axes_on = Configuration.getSetting( 'ShowHorizontalAxesLabels') or Configuration.getSetting( 'ShowVerticalAxesLabels') scrData.lattice_axes_labels_on = Configuration.getSetting("ShowAxes") scrData.bounding_box_on = Configuration.getSetting("BoundingBoxOn") invisible_types = Configuration.getSetting("Types3DInvisible") invisible_types = invisible_types.strip() if invisible_types: scrData.invisible_types = list( [int(x) for x in invisible_types.split(',')]) else: scrData.invisible_types = []
def get_config_metadata(self, field_name, field_type): """ Returns dictionary of auxiliary information needed to render borders :param field_name:{str} field_name :param field_type: {str} field type :return: {dict} """ metadata_dict = {} metadata_dict['BorderColor'] = qcolor_to_rgba(Configuration.getSetting('BorderColor')) metadata_dict['ClusterBorderColor'] = qcolor_to_rgba(Configuration.getSetting('ClusterBorderColor')) metadata_dict['BoundingBoxColor'] = qcolor_to_rgba(Configuration.getSetting('BoundingBoxColor')) metadata_dict['AxesColor'] = qcolor_to_rgba(Configuration.getSetting('AxesColor')) metadata_dict['ContourColor'] = qcolor_to_rgba(Configuration.getSetting('ContourColor')) metadata_dict['WindowColor'] = qcolor_to_rgba(Configuration.getSetting('WindowColor')) # todo - fix color of fpp links metadata_dict['FPPLinksColor'] = qcolor_to_rgba(Configuration.getSetting('FPPLinksColor')) metadata_dict['ShowHorizontalAxesLabels'] = Configuration.getSetting('ShowHorizontalAxesLabels') metadata_dict['ShowVerticalAxesLabels'] = Configuration.getSetting('ShowVerticalAxesLabels') # type-color map type_color_map_dict = OrderedDict() config_type_color_map = Configuration.getSetting("TypeColorMap") for type_id, qt_color in list(config_type_color_map.items()): type_color_map_dict[type_id] = qcolor_to_rgba(qt_color) metadata_dict['TypeColorMap'] = type_color_map_dict return metadata_dict
def add_3d_screenshot(self, _plotName, _plotType, _camera, metadata=None): # called from GraphicsFrameWidget if len(self.screenshotDataDict) > self.maxNumberOfScreenshots: print("MAX NUMBER OF SCREENSHOTS HAS BEEN REACHED") scrData = ScreenshotData() scrData.spaceDimension = "3D" scrData.plotData = (_plotName, _plotType) x_size = Configuration.getSetting("Screenshot_X") y_size = Configuration.getSetting("Screenshot_Y") (scrName, scrCoreName) = self.produce_screenshot_name(scrData) okToAddScreenshot = True for name in self.screenshotDataDict: scrDataFromDict = self.screenshotDataDict[name] if scrDataFromDict.screenshotCoreName == scrCoreName and scrDataFromDict.spaceDimension == "3D": if scrDataFromDict.compareCameras(_camera): print("CAMERAS ARE THE SAME") okToAddScreenshot = False break else: print("CAMERAS ARE DIFFERENT") if (not scrName in self.screenshotDataDict) and okToAddScreenshot: scrData.screenshotName = scrName scrData.screenshotCoreName = scrCoreName scrData.screenshotGraphicsWidget = self.screenshotGraphicsWidget scrData.win_width = x_size scrData.win_height = y_size if metadata is not None: scrData.metadata = metadata tvw = self.tabViewWidget() if tvw: tvw.update_active_window_vis_flags(self.screenshotGraphicsWidget) self.store_gui_vis_config(scrData=scrData) scrData.extractCameraInfo(_camera) # on linux there is a problem with X-server/Qt/QVTK implementation and calling resize right after additional QVTK # is created causes segfault so possible "solution" is to do resize right before taking screenshot. # It causes flicker but does not cause segfault # User should NOT close or minimize this "empty" window (on Linux anyway). if sys.platform == 'Linux' or sys.platform == 'linux' or sys.platform == 'linux2': self.screenshotDataDict[scrData.screenshotName] = scrData self.screenshotCounter3D += 1 else: self.screenshotDataDict[scrData.screenshotName] = scrData self.screenshotCounter3D += 1 else: print("Screenshot ", scrCoreName, " with current camera settings already exists. " \ "You need to rotate camera i.e. rotate picture " \ "using mouse to take additional screenshot") # serializing all screenshots self.serialize_screenshot_data()
def __initActions(self): """ Private method to define the user interface actions. """ self.actions = [] self.toolbarFileAct = QAction("&File", self) self.toolbarFileAct.setCheckable(True) self.toolbarFileAct.setChecked(True) self.actions.append(self.toolbarFileAct) self.toolbarViewAct = QAction("&View", self) self.toolbarViewAct.setCheckable(True) self.toolbarViewAct.setChecked(True) self.actions.append(self.toolbarViewAct) self.toolbarSimAct = QAction("&Simulation", self) self.toolbarSimAct.setCheckable(True) self.toolbarSimAct.setChecked(True) self.actions.append(self.toolbarSimAct) self.toolbarSimAct.setShortcut(Qt.CTRL + Qt.Key_M) self.modelAct = QAction("&Model Editor", self) self.modelAct.setCheckable(True) if Configuration.getSetting('DisplayModelEditor'): self.modelAct.setChecked(True) self.modelAct.triggered.connect(self.toggleModelEditor) self.actions.append(self.modelAct) self.pluginsAct = QAction("&Plugins", self) self.pluginsAct.setCheckable(True) self.pluginsAct.setChecked(True) self.pluginsAct.triggered.connect(self.__toggleCPlugins) self.actions.append(self.pluginsAct) self.latticeDataAct = QAction("&Lattice Data", self) self.latticeDataAct.setCheckable(True) if Configuration.getSetting('DisplayLatticeData'): self.latticeDataAct.setChecked(True) self.latticeDataAct.triggered.connect(self.toggleLatticeData) self.actions.append(self.latticeDataAct) self.consoleAct = QAction("&Console", self) self.consoleAct.setCheckable(True) self.toggleConsole(Configuration.getSetting('DisplayConsole')) if Configuration.getSetting('DisplayConsole'): self.consoleAct.setChecked(True) self.consoleAct.triggered.connect(self.toggleConsole) self.actions.append(self.consoleAct)
def add_2d_screenshot(self, _plotName, _plotType, _projection, _projectionPosition, _camera, metadata=None): if len(self.screenshotDataDict) > self.maxNumberOfScreenshots: print("MAX NUMBER OF SCREENSHOTS HAS BEEN REACHED") scrData = ScreenshotData() scrData.spaceDimension = "2D" scrData.plotData = (_plotName, _plotType) x_size = Configuration.getSetting("Screenshot_X") y_size = Configuration.getSetting("Screenshot_Y") scrData.projection = _projection scrData.projectionPosition = int(_projectionPosition) # import pdb; pdb.set_trace() (scrName, scrCoreName) = self.produce_screenshot_name(scrData) print(" add2DScreenshot(): THIS IS NEW SCRSHOT NAME", scrName) # e.g. Cell_Field_CellField_2D_XY_150 if not scrName in self.screenshotDataDict: scrData.screenshotName = scrName scrData.screenshotCoreName = scrCoreName scrData.screenshotGraphicsWidget = self.screenshotGraphicsWidget # = GraphicsFrameWidget (rf. __init__) scrData.win_width = x_size scrData.win_height = y_size if metadata is not None: scrData.metadata = metadata tvw = self.tabViewWidget() if tvw: tvw.update_active_window_vis_flags(self.screenshotGraphicsWidget) self.store_gui_vis_config(scrData=scrData) scrData.extractCameraInfo(_camera) # so "camera" icon (save images) remembers camera view # on linux there is a problem with X-server/Qt/QVTK implementation and calling resize right after additional QVTK # is created causes segfault so possible "solution" is to do resize right before taking screenshot. # It causes flicker but does not cause segfault. # User should NOT close or minimize this "empty" window (on Linux anyway). if sys.platform == 'Linux' or sys.platform == 'linux' or sys.platform == 'linux2': # pass self.screenshotDataDict[scrData.screenshotName] = scrData else: self.screenshotDataDict[scrData.screenshotName] = scrData else: print("Screenshot ", scrName, " already exists") # serializing all screenshots self.serialize_screenshot_data()
def get_vector_field_metadata(self, field_name, field_type): """ Returns dictionary of auxiliary information needed to render a give scene :param field_name:{str} field_name :param field_type: {str} field type :return: {dict} """ metadata_dict = self.get_con_field_metadata(field_name=field_name, field_type=field_type) metadata_dict['ArrowLength'] = Configuration.getSetting('ArrowLength', field_name) metadata_dict['FixedArrowColorOn'] = Configuration.getSetting('FixedArrowColorOn', field_name) metadata_dict['ArrowColor'] = qcolor_to_rgba(Configuration.getSetting('ArrowColor', field_name)) metadata_dict['ScaleArrowsOn'] = Configuration.getSetting('ScaleArrowsOn', field_name) return metadata_dict
def Render(self): color = Configuration.getSetting("WindowColor") self.ren.SetBackground( float(color.red()) / 255, float(color.green()) / 255, float(color.blue()) / 255) self.qvtkWidget.Render()
def restore_plots_layout(self): ''' This function restores plot layout - it is called from CompuCellSetup.py inside mainLoopNewPlayer function :return: None ''' windows_layout_dict = Configuration.getSetting('WindowsLayout') if not windows_layout_dict: return for winId, win in self.vm.win_inventory.getWindowsItems(PLOT_WINDOW_LABEL): plot_frame_widget = win.widget() plot_interface = plot_frame_widget.plotInterface() # plot_frame_widget.plotInterface is a weakref if not plot_interface: # if weakref to plot_interface is None we ignore such window continue if str(plot_interface.title) in list(windows_layout_dict.keys()): window_data_dict = windows_layout_dict[str(plot_interface.title)] gwd = GraphicsWindowData() gwd.fromDict(window_data_dict) if gwd.winType != 'plot': return win.resize(gwd.winSize) win.move(gwd.winPosition) win.setWindowTitle(plot_interface.title)
def restoreSingleWindow(self, plotWindowInterface): ''' Restores size and position of a single, just-added plot window :param plotWindowInterface: an insance of PlotWindowInterface - can be fetchet from PlotFrameWidget using PlotFrameWidgetInstance.plotInterface :return: None ''' windows_layout_dict = Configuration.getSetting('WindowsLayout') # print 'windowsLayoutDict=', windowsLayoutDict if not windows_layout_dict: return if str(plotWindowInterface.title) in list(windows_layout_dict.keys()): window_data_dict = windows_layout_dict[str(plotWindowInterface.title)] gwd = GraphicsWindowData() gwd.fromDict(window_data_dict) if gwd.winType != 'plot': return plot_window = self.vm.lastActiveRealWindow plot_window.resize(gwd.winSize) plot_window.move(gwd.winPosition) plot_window.setWindowTitle(plotWindowInterface.title)
def setScreenUpdateFrequency(self): import cc3d.player5.Configuration as Configuration try: self.screenUpdateFrequency = Configuration.getSetting( "ScreenUpdateFrequency") except: print('SIMTHREAD: Could not access configuration.')
def initParams(self): ''' this fcn stores current settings for all the keys of Configuration.Configuration.defaultConfigs as a self.paramCC3D dictionary ''' for key in Configuration.getSettingNameList(): self.paramCC3D[key] = Configuration.getSetting(key)
def check_version(self, check_interval=-1, display_no_update_info=False): """ This function checks if new CC3D version is available :return:None """ # here we decide whether the information about no new updates is displayed or not. For automatic update checks # this information should not be displayed. For manual update checks we need to inform the user # that there are no updates self.display_no_update_info = display_no_update_info # determine if check is necessary - for now we check every week in order not to bother users with too many checks last_version_check_date = Configuration.getSetting( 'LastVersionCheckDate') today = datetime.date.today() today_date_str = today.strftime('%Y%m%d') old_date = datetime.date(int(last_version_check_date[:4]), int(last_version_check_date[4:6]), int(last_version_check_date[6:])) t_delta = today - old_date if t_delta.days < check_interval: # check for CC3D recently return else: print('WILL DO THE CHECK') version_fetcher = WebFetcher(_parent=self) version_fetcher.gotWebContentSignal.connect(self.process_version_check) version_fetcher.fetch("http://www.compucell3d.org/current_version")
def updateColorButton(self, btn, name): ''' updates button (btn) and changes corresponding color setting (name).Shows Choose color dialog ''' color = self.selectColor(btn, Configuration.getSetting(name)) # which of the following is necessary at this point? Configuration.setSetting(name, color) self.paramCC3D[name] = color
def __init__(self, parent=None, originatingWidget=None): QtWidgets.QFrame.__init__(self, parent) self.is_screenshot_widget = False self.qvtkWidget = QVTKRenderWindowInteractor(self) # a QWidget self.setAttribute(QtCore.Qt.WA_DeleteOnClose) # MDIFIX self.parentWidget = ref(originatingWidget) self.plane = None self.planePos = None self.lineEdit = QtWidgets.QLineEdit() self.init_cross_section_actions() self.cstb = self.initCrossSectionToolbar() layout = QtWidgets.QBoxLayout(QtWidgets.QBoxLayout.TopToBottom) layout.addWidget(self.cstb) layout.addWidget(self.qvtkWidget) self.setLayout(layout) self.setMinimumSize(100, 100) # needs to be defined to resize smaller than 400x400 self.resize(600, 600) self.qvtkWidget.Initialize() self.qvtkWidget.Start() # todo 5 - adding generic drawer self.gd = GenericDrawer() self.gd.set_interactive_camera_flag(True) self.gd.set_pixelized_cartesian_scene(Configuration.getSetting("PixelizedCartesianFields")) # placeholder for current screenshot data self.current_screenshot_data = None # placeholder for currently used basic simulation data self.current_bsd = None self.camera2D = self.gd.get_active_camera() self.camera3D = self.gd.get_renderer().MakeCamera() self.renWin = self.qvtkWidget.GetRenderWindow() self.renWin.AddRenderer(self.gd.get_renderer()) self.metadata_fetcher_dict = { 'CellField': self.get_cell_field_metadata, 'ConField': self.get_con_field_metadata, 'ScalarField': self.get_con_field_metadata, 'ScalarFieldCellLevel': self.get_con_field_metadata, 'VectorField': self.get_vector_field_metadata, 'VectorFieldCellLevel': self.get_vector_field_metadata, }
def __createViewManager(self): self.zitems = [0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2.0, 3.0, 4.0, 8.0] self.viewmanager = SimpleTabView( self) # ViewManager.factory(self, self) self.viewmanager.set_recent_simulation_file( str(Configuration.getSetting("RecentFile"))) self.viewmanager.setZoomItems(self.zitems) # self.viewmanager.setOrientation(Qt.Vertical) self.setCentralWidget(self.viewmanager)
def populateLookupTable( self): # rwh: why is this method in both View & Model? self.drawModel.populateLookupTable( ) # have to update colors in model objects colorMap = Configuration.getSetting("TypeColorMap") for key in list(colorMap.keys()): r = colorMap[key].red() g = colorMap[key].green() b = colorMap[key].blue() self.lut.SetTableValue(key, self.toVTKColor(r), self.toVTKColor(g), self.toVTKColor(b), 1.0)
def on_outputLocationButton_clicked(self): currentOutputDir = Configuration.getSetting('OutputLocation') dirName = QFileDialog.getExistingDirectory( self, "Specify CC3D Output Directory", currentOutputDir, QFileDialog.ShowDirsOnly) dirName = str(dirName) dirName.rstrip() print("dirName=", dirName) if dirName == "": return dirName = os.path.abspath(dirName) self.outputLocationLineEdit.setText(dirName) Configuration.setSetting('OutputLocation', dirName)
def get_con_field_metadata(self, field_name, field_type): """ Returns dictionary of auxiliary information needed to render a give scene :param field_name:{str} field_name :param field_type: {str} field type :return: {dict} """ # metadata_dict = {} metadata_dict = self.get_config_metadata(field_name=field_name, field_type=field_type) con_field_name = field_name metadata_dict['MinRangeFixed'] = Configuration.getSetting("MinRangeFixed", con_field_name) metadata_dict['MaxRangeFixed'] = Configuration.getSetting("MaxRangeFixed", con_field_name) metadata_dict['MinRange'] = Configuration.getSetting("MinRange", con_field_name) metadata_dict['MaxRange'] = Configuration.getSetting("MaxRange", con_field_name) metadata_dict['ContoursOn'] = Configuration.getSetting("ContoursOn", con_field_name) metadata_dict['NumberOfContourLines'] = Configuration.getSetting("NumberOfContourLines", field_name) metadata_dict['ScalarIsoValues'] = cs_string_to_typed_list( Configuration.getSetting("ScalarIsoValues", field_name)) metadata_dict['LegendEnable'] = Configuration.getSetting("LegendEnable", field_name) metadata_dict['DisplayMinMaxInfo'] = Configuration.getSetting("DisplayMinMaxInfo") return metadata_dict
def populateLookupTable(self): # print MODULENAME,' populateLookupTable()' colorMap = Configuration.getSetting("TypeColorMap") # print MODULENAME,' populateLookupTable(): len(colorMap)=',len(colorMap) self.celltypeLUT.SetNumberOfTableValues(len(colorMap)) self.celltypeLUT.SetNumberOfColors(len(colorMap)) # lutGlyph.SetTableValue(5, 1,0,0, 1.0) # SetTableValue (vtkIdType indx, double r, double g, double b, double a=1.0) # lutGlyph.SetTableValue(8, 0,1,1, 1.0) # SetTableValue (vtkIdType indx, double r, double g, double b, double a=1.0) for key in list(colorMap.keys()): r = colorMap[key].red() g = colorMap[key].green() b = colorMap[key].blue() self.celltypeLUT.SetTableValue(key, self.toVTKColor(r), self.toVTKColor(g), self.toVTKColor(b), 1.0) # print " type=",key," red=",r," green=",g," blue=",b # print " type=",key," (VTK) red=",self.toVTKColor(r)," green=",self.toVTKColor(g)," blue=",self.toVTKColor(b) # self.qvtkWidget.repaint() self.celltypeLUT.Build() self.celltypeLUTMax = self.celltypeLUT.GetNumberOfTableValues() - 1 # cell types = [0,max] self.celltypeLUT.SetTableRange(0, self.celltypeLUTMax)
def check_version(self, check_interval=-1, display_no_update_info=False): """ This function checks if new CC3D version is available :return:None """ # checking if cc3d is running in nanohub. if it is do not check for updates (it'll be blocked by their firewall) if 'NANOHUB_SIM' in environ: return # here we decide whether the information about no new updates is displayed or not. For automatic update checks # this information should not be displayed. For manual update checks we need to inform the user # that there are no updates self.display_no_update_info = display_no_update_info # determine if check is necessary - for now we check every week in order # not to bother users with too many checks last_version_check_date = Configuration.getSetting( 'LastVersionCheckDate') today = datetime.date.today() old_date = datetime.date(int(last_version_check_date[:4]), int(last_version_check_date[4:6]), int(last_version_check_date[6:])) t_delta = today - old_date if t_delta.days < check_interval: # check for CC3D recently return else: print('WILL DO THE CHECK') if requests_web_fetcher_available: self.version_fetcher = WebFetcherRequests(_parent=self) else: self.version_fetcher = WebFetcher(_parent=self) self.version_fetcher.gotWebContentSignal.connect( self.process_version_check) self.version_fetcher.fetch(self.cc3d_updates_url)
def read_cell_type_color_data(self): """ :return: """ self.item_data = OrderedDict() type_color_map = Configuration.getSetting('TypeColorMap') names_ids = CompuCellSetup.simulation_utils.extract_type_names_and_ids() for type_id, type_name in names_ids.items(): try: color = type_color_map[type_id] except KeyError: color = QColor('black') self.item_data[type_id] = [type_name, color] self.update(item_data=self.item_data)
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__(self): QMainWindow.__init__(self) self.argv = None QApplication.setWindowIcon(QIcon(gip("cc3d_64x64_logo.png"))) self.setWindowIcon(QIcon(gip("cc3d_64x64_logo.png"))) self.setWindowTitle("CompuCell3D Player") self.origStdout = sys.stdout self.origStderr = sys.stderr self.__toolbars = {} # Setting self.viewmanager and dock windows self.__createViewManager() self.__createLayout() # # Generate the redirection helpers self.stdout = sys.stdout self.stderr = sys.stderr # Now setup the connections if Configuration.getSetting("UseInternalConsole"): self.stdout = Redirector(False) self.stderr = Redirector(True) self.stdout.appendStdout.connect(self.appendToStdout) self.stderr.appendStderr.connect(self.appendToStderr) self.appendStdoutSignal.connect(self.console.appendToStdout) self.appendStderrSignal.connect(self.console.appendToStderr) # I don't know why I need this cc3dApp().registerObject("UserInterface", self) cc3dApp().registerObject("ViewManager", self.viewmanager) # Setup actions self.__initActions() # Setup menus self.__initMenus() # Setup toolbars self.__initToolbars() # Setup status bar self.__initStatusbar() # now redirect stdout and stderr if Configuration.getSetting("CC3DOutputOn"): if Configuration.getSetting("UseInternalConsole"): # redirecting Python output to internal console self.use_internal_console_for_python_output(True) else: # Python output goes to system console self.enable_python_output(True) else: # silencing output from Python self.enable_python_output(False) self.initialize_gui_geometry() floating_flag = Configuration.getSetting('FloatingWindows') floating_non_graphics_flag = False # we allow non-graphics windows to be docked. This improves # layout when we request floating grahics windows self.modelEditorDock.setFloating(floating_non_graphics_flag) self.consoleDock.setFloating(floating_non_graphics_flag) self.latticeDataDock.setFloating(floating_non_graphics_flag) if floating_flag: # in order to have all dock widgets expand (i.e. fill all available space) # we hide central widget when graphics windows are floating self.centralWidget().hide()
def initialize_gui_geometry(self, allow_main_window_move: bool = True): """ Initializes GUI geometry based on saved settings and based on current screen configuration :param allow_main_window_move: flag that specifies whether we may move main window according to settings or not We typically allow to moving of the main window at the GUI startup but not after loading simulation :return: """ current_screen_geometry_settings = self.get_current_screen_geometry_settings( ) saved_screen_geometry_settings = Configuration.getSetting( "ScreenGeometry") main_window_size = Configuration.getSetting("MainWindowSizeDefault") main_window_position = Configuration.getSetting( "MainWindowPositionDefault") if self.viewmanager.MDI_ON: player_sizes = Configuration.getSetting("PlayerSizesDefault") else: player_sizes = Configuration.getSetting( "PlayerSizesFloatingDefault") if current_screen_geometry_settings == saved_screen_geometry_settings: # this indicates that saved screen geometry is the same as current screen geometry and we will use # saved settings because we are working with same screen configuration so it is safe to restore if self.viewmanager.MDI_ON: # configuration of MDI main_window_size = Configuration.getSetting("MainWindowSize") main_window_position = Configuration.getSetting( "MainWindowPosition") player_sizes = Configuration.getSetting("PlayerSizes") else: main_window_size = Configuration.getSetting( "MainWindowSizeFloating") main_window_position = Configuration.getSetting( "MainWindowPositionFloating") player_sizes = Configuration.getSetting("PlayerSizesFloating") self.resize(main_window_size) # we want main window to move only during initial opening of the GUI but not upon loading new simulation if allow_main_window_move: self.move(main_window_position) if player_sizes and player_sizes.size() > 0: self.restoreState(player_sizes)
def __initActions(self): """ Private method to define the user interface actions. """ self.actions = [] # self.zoomInAct = QAction(QIcon(gip("zoomIn.png")), "&Zoom In", self) # self.actions.append(self.zoomInAct) # Replaced "viewActions" by "actions":self.viewActions.append(self.zoomInAct) # # # self.zoomOutAct = QAction(QIcon(gip("zoomOut.png")), "&Zoom Out", self) # self.actions.append(self.zoomOutAct) # # Why do I need self.zoomFixedAct? # #self.zoomFixedAct = QAction(self) # self.zoomFixed = QComboBox() # self.zoomFixed.setToolTip("Zoom Fixed") # self.zoomFixed.addItems(self.__zoomItems()) # self.zoomFixed.setCurrentIndex(3) # self.zoomFixed.addAction(self.zoomFixedAct) # self.actions.append(self.zoomFixedAct) # self.screenshotAct = QAction(QIcon("player5/icons/screenshot.png"), "&Take Screenshot", self) # self.actions.append(self.screenshotAct) self.toolbarFileAct = QAction("&File", self) self.toolbarFileAct.setCheckable(True) self.toolbarFileAct.setChecked(True) self.actions.append(self.toolbarFileAct) self.toolbarViewAct = QAction("&View", self) self.toolbarViewAct.setCheckable(True) self.toolbarViewAct.setChecked(True) self.actions.append(self.toolbarViewAct) self.toolbarSimAct = QAction("&Simulation", self) self.toolbarSimAct.setCheckable(True) self.toolbarSimAct.setChecked(True) self.actions.append(self.toolbarSimAct) self.toolbarSimAct.setShortcut(Qt.CTRL + Qt.Key_M) self.modelAct = QAction("&Model Editor", self) self.modelAct.setCheckable(True) # self.modelAct.setChecked(True) #not self.projectBrowserDock.isHidden() if Configuration.getSetting('DisplayModelEditor'): self.modelAct.setChecked(True) # self.connect(self.modelAct, SIGNAL("triggered(bool)"), self.toggleModelEditor) self.modelAct.triggered.connect(self.toggleModelEditor) # self.connect(self.modelAct, SIGNAL("triggered(bool)"), self.toggleModelEditor) self.actions.append(self.modelAct) self.pluginsAct = QAction("&Plugins", self) self.pluginsAct.setCheckable(True) self.pluginsAct.setChecked(True) # self.connect(self.pluginsAct, SIGNAL("triggered()"), self.__toggleCPlugins) self.pluginsAct.triggered.connect(self.__toggleCPlugins) self.actions.append(self.pluginsAct) self.latticeDataAct = QAction("&Lattice Data", self) self.latticeDataAct.setCheckable(True) if Configuration.getSetting('DisplayLatticeData'): self.latticeDataAct.setChecked(True) # self.latticeDataAct.setChecked(False) # self.connect(self.latticeDataAct, SIGNAL("triggered(bool)"), self.toggleLatticeData) self.latticeDataAct.triggered.connect(self.toggleLatticeData) self.actions.append(self.latticeDataAct) # self.connect(self.zoomInAct, SIGNAL('triggered()'), self.viewmanager.zoomIn) # self.connect(self.zoomOutAct, SIGNAL('triggered()'), self.viewmanager.zoomOut) # self.connect(self.zoomFixed, SIGNAL('activated(int)'), self.viewmanager.zoomFixed) # self.connect(self.screenshotAct, SIGNAL('triggered()'), self.viewmanager.takeShot) # self.connect(self.newGraphicsWindowAct, SIGNAL('triggered()'), self.viewmanager.addVTKWindowToWorkspace) # Keep this code. There won't be plotting in 3.4.0 version """ self.plotAct = QAction("&Plot", self) self.plotAct.setCheckable(True) self.plotAct.setChecked(True) self.actions.append(self.plotAct) """ self.consoleAct = QAction("&Console", self) self.consoleAct.setCheckable(True) self.toggleConsole(Configuration.getSetting('DisplayConsole')) if Configuration.getSetting('DisplayConsole'): self.consoleAct.setChecked(True) # self.connect(self.consoleAct, SIGNAL("triggered(bool)"), self.toggleConsole) self.consoleAct.triggered.connect(self.toggleConsole) self.actions.append(self.consoleAct)
def __init__(self): QMainWindow.__init__(self) self.argv = None # self.resize(QSize(900, 650)) QApplication.setWindowIcon(QIcon(gip("cc3d_64x64_logo.png"))) self.setWindowIcon(QIcon(gip("cc3d_64x64_logo.png"))) self.setWindowTitle("CompuCell3D Player") self.origStdout = sys.stdout self.origStderr = sys.stderr # Setting self.viewmanager and dock windows # TODO self.__createViewManager() self.__createLayout() # # Generate the redirection helpers self.stdout = Redirector(False) self.stderr = Redirector(True) # #TODO self.stderr.setStdErrConsole(self.console.getStdErrConsole()) # Now setup the connections if Configuration.getSetting("UseInternalConsole"): self.stdout.appendStdout.connect(self.appendToStdout) self.stderr.appendStderr.connect(self.appendToStderr) self.appendStdoutSignal.connect(self.console.appendToStdout) self.appendStderrSignal.connect(self.console.appendToStderr) # self.connect(self.stdout, SIGNAL('appendStdout'), self.appendToStdout) # self.connect(self.stderr, SIGNAL('appendStderr'), self.appendToStderr) # # self.connect(self, SIGNAL('appendStdout'), self.console.appendToStdout) # self.connect(self, SIGNAL('appendStderr'), self.console.appendToStderr) # I don't know why I need this cc3dApp().registerObject("UserInterface", self) cc3dApp().registerObject("ViewManager", self.viewmanager) self.__initActions() # Setup actions self.__initMenus() # Setup menus # self.__createViewManager() self.__initToolbars() # Setup toolbars self.__initStatusbar() # Setup status bar # self.tabWidget=QTabWidget(self) # self.tabWidget=SimpleTabView(self) # self.setCentralWidget(self.tabWidget) # now redirect stdout and stderr if Configuration.getSetting("CC3DOutputOn"): if Configuration.getSetting("UseInternalConsole"): # redirecting Python output to internal console self.useInternalConsoleForPythonOutput(True) else: # Python output goes to system console self.enablePythonOutput(True) else: # silencing output from Python self.enablePythonOutput(False) # TODO if self.viewmanager.MDI_ON: # configuration of MDI playerSizes = Configuration.getSetting("PlayerSizes") if playerSizes and playerSizes.size() > 0: self.resize(Configuration.getSetting("MainWindowSize")) self.move(Configuration.getSetting("MainWindowPosition")) self.restoreState(playerSizes) else: self.resize(Configuration.getSetting("MainWindowSize")) self.move(Configuration.getSetting("MainWindowPosition")) else: # configuration of floating windows playerSizes = Configuration.getSetting("PlayerSizesFloating") if playerSizes and playerSizes.size() > 0: self.resize(Configuration.getSetting("MainWindowSizeFloating")) self.resize( self.size().width(), 20 ) # resizing vertical dimension to be minimal - for PyQt5 we cannot use 0 self.move( Configuration.getSetting("MainWindowPositionFloating")) self.restoreState(playerSizes) else: self.resize(Configuration.getSetting("MainWindowSizeFloating")) self.resize( self.size().width(), 20 ) # resizing vertical dimension to be minimal - for PyQt5 we cannot use 0 self.move( Configuration.getSetting("MainWindowPositionFloating")) # if playerSizes and playerSizes.size()>0: # self.resize(Configuration.getSetting("MainWindowSize")) # self.move(Configuration.getSetting("MainWindowPosition")) # self.restoreState(playerSizes) # else: # self.resize(Configuration.getSetting("MainWindowSize")) # self.move(Configuration.getSetting("MainWindowPosition")) # MDIFIX floatingFlag = Configuration.getSetting('FloatingWindows') self.modelEditorDock.setFloating(floatingFlag) self.consoleDock.setFloating(floatingFlag) self.latticeDataDock.setFloating(floatingFlag)
def __init__(self, ui): QObject.__init__(self) self.visual = { "CellsOn": Configuration.getSetting("CellsOn"), "CellBordersOn": Configuration.getSetting("CellBordersOn"), "ClusterBordersOn": Configuration.getSetting("ClusterBordersOn"), "CellGlyphsOn": Configuration.getSetting("CellGlyphsOn"), "FPPLinksOn": Configuration.getSetting("FPPLinksOn"), "CC3DOutputOn": Configuration.getSetting("CC3DOutputOn"), "ConcentrationLimitsOn": Configuration.getSetting("ConcentrationLimitsOn"), "ZoomFactor": Configuration.getSetting("ZoomFactor"), } # file actions self.open_act = None self.open_lds_act = None self.exit_act = None self.twedit_act = None # Simulation actions self.run_act = None self.step_act = None self.pause_act = None self.stop_act = None self.restore_default_settings_act = None # visualization actions self.cells_act = None self.border_act = None self.cluster_border_act = None self.cell_glyphs_act = None self.fpp_links_act = None self.limits_act = None self.cc3d_output_on_act = None self.reset_camera_act = None self.zoom_in_act = None self.zoom_out_act = None # tools Actions self.config_act = None self.pif_from_vtk_act = None self.pif_from_simulation_act = None self.restart_snapshot_from_simulation_act = None # windows actions self.python_steering_panel_act = None self.new_graphics_window_act = None self.tile_act = None self.cascade_act = None self.minimize_all_graphics_windows_act = None self.restore_all_graphics_windows_act = None self.close_active_window_act = None # help actions self.quick_act = None self.tutor_act = None self.ref_man_act = None self.about_act = None self.mail_subscribe_act = None self.mail_unsubscribe_act = None self.mail_subscribe_unsubscribe_web_act = None self.check_update_act = None self.whats_this_act = None self.display_no_update_info = False self.init_actions() self.ui = ui