path: root/cad/src/operations/ops_motion.py

# Copyright 2004-2007 Nanorex, Inc.  See LICENSE file for details. 
"""
ops_motion.py -- various ways of moving or spatially distorting
selected atoms or chunks (and someday, attached jigs).
These operations don't create or destroy atoms or bonds.

@version: $Id$
@copyright: 2004-2007 Nanorex, Inc.  See LICENSE file for details.

History:

bruce 050507 made this by collecting appropriate methods from class Part.
"""

from utilities.Log import greenmsg, redmsg
from platform_dependent.PlatformDependent import fix_plurals
from geometry.VQT import V, norm, Q, vlen, orthodist
import foundation.env as env
from math import pi
from utilities.debug import print_compact_traceback

from model.chunk import Chunk
from model.jigs import Jig
from model.jigs_motors import Motor
from analysis.ESP.ESPImage import ESPImage
from foundation.Group import Group


class ops_motion_Mixin:
    """
    Mixin class for providing these methods to class Part
    """
    ###@@@ move/rot should be extended to apply to jigs too (and fit into some naming convention)
    
    def movesel(self, offset):
        """
        move selected chunks and jigs in space
        """
        movables = self.getSelectedMovables()
        
        self.translateSpecifiedMovables(offset, movables = movables)
        
    
    def translateSpecifiedMovables(self, offset, movables =()):
        """
        Translate the specified movables.
        @param movables: a list of movables (default value is empty tuple)
        @type movables: list 
        """        
        for m in movables:
            self.changed() 
            m.move(offset)    
  
    def rotsel(self, quat):
        """
        Rotate selected chunks/jigs in space. [Huaicai 8/30/05: Fixed the problem of each rotating
        around its own center, they will now rotate around their common center]
        """                   
        movables = self.getSelectedMovables()
        self.rotateSpecifiedMovables(quat, movables = movables)        
        return
    
    def rotateSpecifiedMovables(self, quat, movables =(), commonCenter = None):
        """
        Rotate the movables specified in the 'movables' list. 
        (Rotated as a unit)
        @param quat: Quaternion for the rotation. 
        @param movables: A list of movables. These movables will be 
                rotated around a common axis
        @type movables: list
        
        """
        numMovables = len(movables)
        
        if commonCenter is None:            
            # Find the common center of all selected chunks to fix bug 594 
            #--Huaicai 8/30/05
            comCenter = V(0.0, 0.0, 0.0)
            if numMovables:
                for m in movables: 
                    comCenter += m.center                      
                comCenter /= numMovables
           
        else:
            comCenter = commonCenter
     
        # Move the selected chunks    
        for m in movables:
            self.changed() #Not sure if this can be combined into one call
            # Get the moving offset because of the rotation around each 
            # movable's own center
            rotOff = quat.rot(m.center - comCenter)  
            rotOff = comCenter - m.center + rotOff 
            m.move(rotOff) 
            m.rot(quat) 
                    
    
    def Stretch(self):
        """
        stretch a Chunk
        """
        mc = env.begin_op("Stretch")
        try:
            cmd = greenmsg("Stretch: ")
            
            if not self.selmols:
                msg =  redmsg("No selected chunks to stretch")
                env.history.message(cmd + msg)
            else:
                self.changed()
                for m in self.selmols:
                    m.stretch(1.1)
                self.o.gl_update()
                
                # Added history message.  Mark 050413.
                info = fix_plurals( "Stretched %d chunk(s)" % len(self.selmols))
                env.history.message( cmd + info)
        finally:
            env.end_op(mc)
        return
    
    def Invert(self):
        """
        Invert the atoms of the selected chunk(s) around the chunk centers
        """
        mc = env.begin_op("Invert")
        cmd = greenmsg("Invert: ")
        
        if not self.selmols:
            msg = redmsg("No selected chunks to invert")
            env.history.message(cmd + msg)
            return
        self.changed()
        for m in self.selmols:
            m.stretch(-1.0)
        self.o.gl_update()
        
        info = fix_plurals( "Inverted %d chunk(s)" % len(self.selmols))
        env.history.message( cmd + info)
        env.end_op(mc) #e try/finally?
    
    def Mirror(self):
        """
        Mirror the selected chunk(s) about a selected grid plane.
        """
        cmd = greenmsg("Mirror: ")
        #ninad060814 this is necessary to fix a bug. Otherwise program will 
        #crash if you try to mirror when the top node of the part 
        #(main part of clipboard) is selected
        
        if self.topnode.picked:
            self.topnode.unpick_top()                                                  
        
        self.mirrorJigs = self.getQualifiedMirrorJigs()
               
        jigCounter = len(self.mirrorJigs)        
                        
        if jigCounter < 1:
            msg1 = "No mirror plane selected."
            msg2 = " Please select a Reference Plane or a Grid Plane first."
            msg = redmsg(msg1+msg2)
            instr1 = "(If it doesn't exist, create it using"
            instr2 = "<b>Insert > Reference Geometry menu </b> )"
            instruction = instr1 + instr2
            env.history.message(cmd + msg  + instruction)
            return 
        elif jigCounter >1:
            msg = redmsg("More than one plane selected. Please select only one plane and try again")
            env.history.message(cmd + msg ) 
            return 
        
        for j in self.mirrorJigs:
            j.unpick()
            
        copiedObject = self.o.assy.part.copy_sel_in_same_part()
        
        # ninad060812 Get the axis vector of the Grid Plane. Then you need to 
        #rotate the inverted chunk by pi around this axis vector
        self.mirrorAxis = self.mirrorJigs[0].getaxis()  
        
        if isinstance(copiedObject, Chunk):
            copiedObject.name = copiedObject.name + "-Mirror"
            self._mirrorChunk(copiedObject)            
            return        
        elif isinstance(copiedObject, Group):
            copiedObject.name = "Mirrored Items"
            def mirrorChild(obj):
                if isinstance(obj, Chunk):
                    self._mirrorChunk(obj)
                elif isinstance(obj, Jig):
                    self._mirrorJig(obj)
                                                           
            copiedObject.apply2all(mirrorChild)
        return                        
                
    def _mirrorChunk(self, chunkToMirror):
        """
        Converts the given chunk into its own mirror. 
        
        @param chunkToMirror: The chunk that needs to be converted into its own
               mirror chunk. 
        @type  chunkToMirror: instance of class Chunk
        @see:  self.Mirror
        """
        m = chunkToMirror
        # ninad060813 Following gives an orthogonal distance between the 
        #chunk center and mirror plane.
        self.mirrorDistance, self.wid = orthodist(m.center, 
                                                  self.mirrorAxis, 
                                                  self.mirrorJigs[0].center) 
        # @@@@ ninad060813 This moves the mirror chunk on the other side of 
        # the mirror plane. It surely moves the chunk along the axis of the 
        # mirror plane but I am still unsure if this *always* moves the 
        # chunk on the other side of the mirror. 
        #Probably the 'orthodist' function has helped me here?? 
        m.move(2*(self.mirrorDistance)*self.mirrorAxis)
        
        m.stretch(-1.0)
        m.rot(Q(self.mirrorAxis, pi))
        return
                
    def _mirrorJig(self, jigToMirror):
        """
        Converts the given jig into its own mirror. If the jig is a motor, 
        it also reverses its direction.
        @param jigToMirror: The jig that needs to be converted into its own
               mirror jig. 
        @type  jigToMirror: instance of class Jig
        @see:  self.Mirror
        """
        j = jigToMirror
        # ninad060813 This gives an orthogonal distance between the chunk 
        # center and mirror plane.
        
        #Fixed bug 2503. 
        if not (isinstance(j, Motor) or isinstance(j, ESPImage)):
            return
        
        self.mirrorDistance, self.wid = orthodist(j.center, self.mirrorAxis, 
                                                  self.mirrorJigs[0].center)         
        j.move(2*(self.mirrorDistance)*self.mirrorAxis)
        
        j.rot(Q(self.mirrorAxis, pi))
        
        #Reverse the direction of Linear and Rotary motor for correct 
        #mirror operation
        if isinstance(j, Motor):
            j.reverse_direction()
        return
            
    def getQualifiedMirrorJigs(self):
        """
        Returns a list of objects that can be used as a   
        reference in Mirror Feature. (referece plane and grid planes are valid 
        objects). Only the first object in this list is used for mirror. 
        See Mirror method for details
        """
        
        jigs = self.assy.getSelectedJigs()
        mirrorJigs = []

        for j in jigs:
            if j.mmp_record_name is "gridplane" or j.mmp_record_name is "plane":
                mirrorJigs.append(j)
                
        return mirrorJigs
    
    def align_NEW(self):
        """
        Align the axes of the selected movables to the axis of the movable
        that is placed at the highest order in the Model Tree
        """
        #@@This is not called yet.
        #method *always* uses the MT order to align chunks or jigs   
        #This supports jigs (including reference planes) but it has following
        #bug -- It always uses the selected movable that is placed highest
        #in the Model Tree, as the reference axis for alignment. (Instead 
        #it should align to the 'first selected movable' 
        #(this doesn't happen (or very rarely happens) in old align method where
        #'selmols' is used.) 

        cmd = greenmsg("Align to Common Axis: ")
        
        movables = self.assy.getSelectedMovables()
        for m in movables:
            print "movable =", m.name
        numMovables = len(movables)
        if len(movables) < 2:
            msg = redmsg("Need two or more selected chunks to align")
            env.history.message(cmd + msg)
            return
        self.changed()
        try:
            firstAxis = movables[0].getaxis()
            for m in movables[1:]:             
                m.rot(Q(m.getaxis(),firstAxis))                
            self.o.gl_update()
        except:
            print_compact_traceback ("bug: selected movable object doesn't have an \
            axis")
            msg = redmsg("bug: selected movable object doesn't have an axis")
            env.history.message(cmd + msg)
            return
        self.o.gl_update()
        
        info = fix_plurals( "Aligned %d item(s)" % (len(movables) - 1) ) \
            + " to axis of %s" % movables[0].name
        env.history.message( cmd + info)
        return
    
    def align(self):
        """
        
        """
        cmd = greenmsg("Align to Common Axis: ")     
 
        if len(self.selmols) < 2:
            msg = redmsg("Need two or more selected chunks to align")
            env.history.message(cmd + msg)
            return
        self.changed() #bruce 050131 bugfix or precaution
        #ax = V(0,0,0)
        #for m in self.selmols:
        #    ax += m.getaxis()
        #ax = norm(ax)
        ax = self.selmols[0].getaxis() # Axis of first selected chunk
        for m in self.selmols[1:]:
            m.rot(Q(m.getaxis(),ax))
        self.o.gl_update()
        
        info = fix_plurals( "Aligned %d chunk(s)" % (len(self.selmols) - 1) ) \
            + " to chunk %s" % self.selmols[0].name
        env.history.message( cmd + info)
    
    #Ninad 060904 The following is not called from UI. Need to see if this is useful to the user. 
    def alignPerpendicularToPlane(self):
        """
        Aligns the axes of selected jigs or chunks perpendicular to a reference plane
        """
        cmd = greenmsg("Align to Plane:")
        
        referencePlaneList = self.getQualifiedReferencePlanes()
        jigCounter = len(referencePlaneList) 
        
        self.changed()
        
        if jigCounter:
            referencePlane = referencePlaneList[0] #ninad060904 If more than 1 ref planes are selected, it selectes the first in the order in the mmp file
        
            
        if jigCounter < 1:
            msg = redmsg("Please select a plane first.")
            instruction = " Planes can also be created using the <b>Insert > Plane</b> command."
            env.history.message(cmd + msg  + instruction)
            return 

        movables = self.assy.getSelectedMovables()
        numMovables = len(movables)
        #print len(movables)
        
        if numMovables >1:
            for obj in movables:
                if obj is referencePlane:
                    pass
                refAxis = referencePlane.getaxis()
                obj.rot(Q(obj.getaxis(),refAxis))
                self.o.gl_update()
        else:
            msg = redmsg("No chunks or movable jigs selected to align perpendicular to the reference plane.")
            env.history.message(cmd + msg  + instruction)
            return 
            
                 
    def getQualifiedReferencePlanes(self, jigs): #Ninad 060904
        """
        Returns a list of jigs that can be used a  reference plane in align to plane feature.
        """
        referencePlaneList = []
        for j in jigs:
            if j.mmp_record_name is "gridplane":
                referencePlaneList += [j]
        return referencePlaneList 
        
    def alignmove(self):
        
        cmd = greenmsg("Move to Axis: ")
        
        if len(self.selmols) < 2:
            msg = redmsg("Need two or more selected chunks to align")
            env.history.message(cmd + msg)
            return
        self.changed()
        #ax = V(0,0,0)
        #for m in self.selmols:
        #    ax += m.getaxis()
        #ax = norm(ax)
        ax = self.selmols[0].getaxis() # Axis of first selected chunk
        ctr = self.selmols[0].center # Center of first selected chunk
        for m in self.selmols[1:]:
            m.rot(Q(m.getaxis(),ax))
            m.move(ctr-m.center) # offset
        
        self.o.gl_update()
        
        info = fix_plurals( "Aligned %d chunk(s)" % (len(self.selmols) - 1) ) \
            + " to chunk %s" % self.selmols[0].name
        env.history.message( cmd + info)
        
    pass # end of class ops_motion_Mixin

# end