Example #1
0
    def init_gui(self):
        if self.propMgr is None:
            self.propMgr = FusePropertyManager(self)
            #@bug BUG: following is a workaround for bug 2494
            changes.keep_forever(self.propMgr)

        self.propMgr.show()

        self.change_fuse_mode(str(self.propMgr.fuseComboBox.currentText()))
            # This maintains state of fuse mode when leaving/reentering mode,
            # and syncs the PM and glpane (and does a gl_update).

        self.w.toolsFuseChunksAction.setChecked(1)

        self.updateCommandToolbar(bool_entering = True)

        # connect signals
        #(these all need to be disconnected in restore_gui) [mark 050901]
        self.connect_or_disconnect_signals(True)

        if self.o.assy.selmols:
            self.graphicsMode.something_was_picked = True
Example #2
0
class FuseChunks_Command(Move_Command, fusechunksBase):
    """
    Allows user to move chunks and fuse them to other chunks in the part.
    Two fuse methods are supported:
    1. Make Bonds - bondpoints between chunks will form bonds when they are
       near each other.
    2. Fuse Atoms - atoms between chunks will be fused when they overlap each
       other.
    """
    # class constants
    commandName = 'FUSECHUNKS'
    default_mode_status_text = "Mode: Fuse Chunks"
    featurename = "Fuse Chunks Mode"
    bondable_pairs = [] # List of bondable singlets
    ways_of_bonding = {} # Number of bonds each singlet found
    bondable_pairs_atoms = [] # List of atom pairs that can be bonded
    overlapping_atoms = [] # List of overlapping atoms

    tol = 1.0 # in Angstroms
        # For "Make Bonds", tol is the distance between two bondable singlets
        # For "Fuse Atoms", tol is the distance between two atoms to be
        # considered overlapping

    fuse_mode = '' # The Fuse mode, either 'Make Bonds' or 'Fuse Atoms'.
    propMgr = None

    GraphicsMode_class = FuseChunks_GraphicsMode

    def _create_GraphicsMode(self):
        GM_class = self.GraphicsMode_class
        assert issubclass(GM_class, GraphicsMode_API)
        args = [self]
        kws = {}
        self.graphicsMode = GM_class(*args, **kws)

        self.translate_graphicsMode = Translate_in_FuseChunks_GraphicsMode(*args, **kws)
        self.rotate_graphicsMode  = Rotate_in_FuseChunks_GraphicsMode(*args, **kws)


    def init_gui(self):
        if self.propMgr is None:
            self.propMgr = FusePropertyManager(self)
            #@bug BUG: following is a workaround for bug 2494
            changes.keep_forever(self.propMgr)

        self.propMgr.show()

        self.change_fuse_mode(str(self.propMgr.fuseComboBox.currentText()))
            # This maintains state of fuse mode when leaving/reentering mode,
            # and syncs the PM and glpane (and does a gl_update).

        self.w.toolsFuseChunksAction.setChecked(1)

        self.updateCommandToolbar(bool_entering = True)

        # connect signals
        #(these all need to be disconnected in restore_gui) [mark 050901]
        self.connect_or_disconnect_signals(True)

        if self.o.assy.selmols:
            self.graphicsMode.something_was_picked = True

        #if self.propMgr.isTranslateGroupBoxActive:
            ## toggle on the Move Free action in the Property Manager
            #self.propMgr.transFreeButton.setChecked(True)
            #self.graphicsMode.moveOption = 'MOVEDEFAULT'
        #else:
            #self.propMgr.rotateFreeButton.setChecked(True)
            #self.graphicsrotateOption = 'ROTATEDEFAULT'

    def restore_gui(self):
        self.updateCommandToolbar(bool_entering = False)
        self.connect_or_disconnect_signals(False)
        self.w.toolsFuseChunksAction.setChecked(False)
        self.propMgr.close()

    def connect_or_disconnect_signals(self, connect):
        if connect:
            change_connect = self.w.connect
        else:
            change_connect = self.w.disconnect

        change_connect(self.exitFuseAction, SIGNAL("triggered()"),
                       self.w.toolsDone)

        #Connect or disconnect signals in property manager
        self.propMgr.connect_or_disconnect_signals(connect)

        return

    def Backup(self):
        """
        Undo any bonds made between chunks.
        """
        # This undoes only the last fused chunks.  Will work on supporting
        # multiple undos when we get a single undo working.   Mark 050326

        # Bust bonds between last pair/set of fused chunks.
        if self.bondable_pairs_atoms:
            for a1, a2 in self.bondable_pairs_atoms:
                b = a1.get_neighbor_bond(a2)
                if b: b.bust()


            if self.merged_chunks:
                nchunks_str = "%d" % (len(self.merged_chunks) + 1,)
                msg = "Fuse Chunks: Bonds broken between %s chunks." % (nchunks_str)
                env.history.message(msg)
                msg = "Warning: Cannot separate the original chunks. You can " \
                "do this yourself using <b>Modify > Separate</b>."
                env.history.message(orangemsg(msg))

                cnames = "Their names were: "
                # Here are the original names...
                for chunk in self.merged_chunks:
                    cnames += '[' + chunk.name + '] '
                env.history.message(cnames)

            self.o.gl_update()

        else:
            msg = "Fuse Chunks: No bonds have been made yet.  Undo ignored."
            env.history.message(redmsg(msg))



    def tolerance_changed(self, val):
        """
        Slot for tolerance slider.
        """
        self.tol = val * .01

        if self.o.assy.selmols:
            self.o.gl_update()
        else:
            # Since no chunks are selected, there are no bonds, but the slider
            # tolerance label still needs
            # updating.  This fixed bug 502-14.  Mark 050407
            self.reset_tolerance_label()

    def reset_tolerance_label(self):
        """
        Reset the tolerance label to 0 bonds or 0 overlapping atoms
        """
        if self.fuse_mode == MAKEBONDS:
            tol_str = fusechunks_lambda_tol_nbonds(self.tol, 0, 0, 0) # 0 bonds
        else:
            # 0 overlapping atoms
            tol_str = fusechunks_lambda_tol_natoms(self.tol, 0)

        tolerenceLabel = tol_str
        self.propMgr.toleranceSlider.labelWidget.setText(tolerenceLabel)

    def change_fuse_mode(self, fuse_mode):
        """
        Sets the Fuse mode
        """
        if self.fuse_mode == fuse_mode:
            return # The mode did not change.  Don't do anything.
        self.fuse_mode = str(fuse_mode) # Must cast here.

        if self.fuse_mode == MAKEBONDS:
            self.propMgr.fusePushButton.setText('Make Bonds')
        else:
            self.propMgr.fusePushButton.setText('Fuse Atoms')

        self.propMgr.updateMessage()
        self.o.gl_update() # the Draw() method will update based on the current
                           #combo box item.

    def find_fusables(self):
        """
        Finds bondable pairs or overlapping atoms, based on the
        Fuse Action combo box
        """
        if self.fuse_mode == MAKEBONDS:
            self.find_bondable_pairs()
        else:
            self.find_overlapping_atoms()

    def find_bondable_pairs(self, chunk_list = None):
        """
        Checks the bondpoints of the selected chunk to see if they are close
        enough to bond with any other bondpoints in a list of chunks.
        Hidden chunks are skipped.
        """
        tol_str = fusechunksBase.find_bondable_pairs(self, chunk_list, None)
        tolerenceLabel = tol_str
        self.propMgr.toleranceSlider.labelWidget.setText(tolerenceLabel)

    def fuse_something(self):
        """
        Slot for 'Make Bonds/Fuse Atoms' button.
        """
        if self.fuse_mode == MAKEBONDS:
            self.make_bonds()
        else:
            self.fuse_atoms()

    def make_bonds(self):
        """
        Make bonds between all bondable pairs of singlets
        """
        self._make_bonds_1()
        self._make_bonds_2()
        self._make_bonds_3()
        self._make_bonds_4()

    def _make_bonds_2(self):
        # Merge the chunks if the "merge chunks" checkbox is checked
        if self.propMgr.mergeChunksCheckBox.isChecked() and self.bondable_pairs_atoms:
            for a1, a2 in self.bondable_pairs_atoms:
                # Ignore a1, they are atoms from the selected chunk(s)
                # It is possible that a2 is an atom from a selected chunk,
                # so check it
                if a2.molecule != a1.molecule:
                    if a2.molecule not in self.merged_chunks:
                        self.merged_chunks.append(a2.molecule)
                        a1.molecule.merge(a2.molecule)

    def _make_bonds_4(self):
        msg = fix_plurals( "%d bond(s) made" % self.total_bonds_made)
        env.history.message(msg)

        # Update the slider tolerance label.  This fixed bug 502-14. Mark 050407
        self.reset_tolerance_label()

        if self.bondable_pairs_atoms:
            # This must be done before gl_update, or it will try to draw the
            # bondable singlets again, which generates errors.
            self.bondable_pairs = []
            self.ways_of_bonding = {}

        self.w.win_update()

        ######### Overlapping Atoms methods #############

    def find_overlapping_atoms(self):
        """
        Checks atoms of the selected chunk to see if they overlap atoms
        in other chunks of the same type (element).  Hidden chunks are skipped.
        """
        # Future versions should allow more flexible rules for overlapping
        # atoms, but this needs to be discussed with others before implementing
        # anything.
        # For now, only atoms of the same type qualify as overlapping atoms.
        # As is, it is extremely useful for fusing chunks of diamond,
        # lonsdaleite or SiC,
        # which is done quite a lot with casings.  This will save me hours of
        # modeling work.
        # Mark 050902

        self.overlapping_atoms = []

        for chunk in self.o.assy.selmols:

            if chunk.hidden or chunk.display == diINVISIBLE:
                # Skip selected chunk if hidden or invisible.
                # Fixes bug 970. mark 060404
                continue

            # Loop through all the mols in the part to search for bondable
            # pairs of singlets.
            for mol in self.o.assy.molecules:
                if chunk is mol:
                    continue # Skip itself
                if mol.hidden or mol.display == diINVISIBLE:
                    continue # Skip hidden or invisible chunks
                if mol in self.o.assy.selmols:
                    continue # Skip other selected chunks

                # Skip this mol if its bounding box does not overlap the
                # selected chunk's bbox.
                # Remember: chunk = a selected chunk, mol = a non-selected
                # chunk.
                if not chunk.overlapping_chunk(mol, self.tol):
                    # print "Skipping ", mol.name
                    continue
                else:

                    # Loop through all the atoms in the selected chunk.
                    # Use values() if the loop ever modifies chunk or mol--
                    for a1 in chunk.atoms.itervalues():
                        # Singlets can't be overlapping atoms --
                        if a1.element is Singlet:
                            continue
                        # We can skip mol if the atom lies outside its bbox.
                        if not mol.overlapping_atom(a1, self.tol):
                            continue

                        # Loop through all the atoms in this chunk.
                        for a2 in mol.atoms.itervalues():
                            # Only atoms of the same type can be overlapping.
                            # This also screens singlets, since a1 can't be a
                            # singlet.
                            if a1.element is not a2.element:
                                continue

                            # Compares the distance between a1 and a2.
                            # If the distance
                            # is <= tol, then we have an overlapping atom.
                            # I know this isn't a proper use of tol,
                            # but it works for now.   Mark 050901
                            if vlen (a1.posn() - a2.posn()) <= self.tol:
                                # Add this pair to the list--
                                self.overlapping_atoms.append( (a1,a2) )
                                # No need to check other atoms in this chunk--
                                break

        # Update tolerance label and status bar msgs.
        natoms = len(self.overlapping_atoms)
        tol_str = fusechunks_lambda_tol_natoms(self.tol, natoms)
        tolerenceLabel = tol_str
        self.propMgr.toleranceSlider.labelWidget.setText(tolerenceLabel)


    def fuse_atoms(self):
        """
        Deletes overlapping atoms found with the selected chunk(s).
        Only the overlapping atoms from the unselected chunk(s) are deleted.
        If the "Merge Chunks" checkbox
        is checked, then find_bondable_pairs() and make_bonds() is called,
        resulting in the merging of chunks.
        """
        total_atoms_fused = 0 # The total number of atoms fused.

        # fused_chunks stores the list of chunks that contain overlapping atoms
        # (but no selected chunks, though)
        fused_chunks = []

        # Delete overlapping atoms.
        for a1, a2 in self.overlapping_atoms:
            if a2.molecule not in fused_chunks:
                fused_chunks.append(a2.molecule)
            a2.kill()

#        print "Fused chunks list:", fused_chunks

        # Merge the chunks if the "merge chunks" checkbox is checked
        if self.propMgr.mergeChunksCheckBox.isChecked() and self.overlapping_atoms:
            # This will bond and merge the selected chunks only with
            # chunks that had overlapping atoms.
            #& This has bugs when the bonds don't line up nicely between
            # overlapping atoms in the selected chunk
            #& and the bondpoints of the deleted atoms' neighbors.
            # Needs a bug report. mark 060406.
            self.find_bondable_pairs(fused_chunks)
            self.make_bonds()

        # Print history msgs to inform the user what happened.
        total_atoms_fused = len(self.overlapping_atoms)
        msg = fix_plurals( "%d atom(s) fused with %d chunk(s)" % (total_atoms_fused, len(fused_chunks)))
        env.history.message(msg)
        #"%s => %s overlapping atoms" % (tol_str, natoms_str)

        # Update the slider tolerance label.
        self.reset_tolerance_label()

        self.overlapping_atoms = []
            # This must be done before win_update(), or it will try to draw the
            # overlapping atoms again, which generates errors.

        self.w.win_update()


    #Command Toolbar to be revised ============================================

    def getFlyoutActionList(self): #Ninad 20070618
        """
        Returns a tuple that contains mode spcific actionlists in the
        added in the flyout toolbar of the mode.
        CommandToolbar._createFlyoutToolBar method calls this
        @return: params: A tuple that contains 3 lists:
        (subControlAreaActionList, commandActionLists, allActionsList)
        """

        #'allActionsList' returns all actions in the flyout toolbar
        #including the subcontrolArea actions
        allActionsList = []

        #Action List for  subcontrol Area buttons.
        #In this mode, there is really no subcontrol area.
        #We will treat subcontrol area same as 'command area'
        #(subcontrol area buttons will have an empty list as their command area
        #list). We will set  the Comamnd Area palette background color to the
        #subcontrol area.

        subControlAreaActionList =[]

        self.exitFuseAction = NE1_QWidgetAction(self.w, win = self.w)
        self.exitFuseAction.setText("Exit Fuse")
        self.exitFuseAction.setCheckable(True)
        self.exitFuseAction.setChecked(True)
        self.exitFuseAction.setIcon(
            geticon("ui/actions/Toolbars/Smart/Exit.png"))
        subControlAreaActionList.append(self.exitFuseAction)

        separator = QAction(self.w)
        separator.setSeparator(True)
        subControlAreaActionList.append(separator)

        allActionsList.extend(subControlAreaActionList)

        #Empty actionlist for the 'Command Area'
        commandActionLists = []

        #Append empty 'lists' in 'commandActionLists equal to the
        #number of actions in subControlArea
        for i in range(len(subControlAreaActionList)):
            lst = []
            commandActionLists.append(lst)

        params = (subControlAreaActionList, commandActionLists, allActionsList)

        return params

    def updateCommandToolbar(self, bool_entering = True):#Ninad 20070618
        """
        Update the command toolbar
        """
        # object that needs its own flyout toolbar. In this case it is just
        #the mode itself.

        action = self.w.toolsFuseChunksAction
        obj = self
        self.w.commandToolbar.updateCommandToolbar(action,
                                                   obj,
                                                   entering =bool_entering)