Esempio n. 1
0
def findMeshMidPointFromObject(mesh,obj,axisToCheck = ['x','z'],
                               vector = False, maxDistance = 1000, maxIterations = 10,**kws):
    try:#findMeshMidPointFromObject
        _str_funcName = 'findMeshMidPointFromObject'
        log.debug(">>> %s >> "%_str_funcName + "="*75)             
        if len(mc.ls(mesh))>1:
            raise StandardError,"findMeshMidPointFromObject>>> More than one mesh named: %s"%mesh      
        if type(axisToCheck) not in [list,tuple]:axisToCheck=[axisToCheck]
        axis = ['x','y','z']
        for a in axisToCheck:
            if a not in axis:
                raise StandardError,"findMeshMidPointFromObject>>> Not a valid axis : %s not in ['x','y','z']"%axisToCheck
        l_lastPos = []
        loc = locators.locMeObjectStandAlone(obj)
        for i in range(maxIterations):
            l_positions = []
            for a in axisToCheck:
                log.debug("firing: %s"%a)
                d_posReturn = findMeshIntersectionFromObjectAxis(mesh, loc, axis = '%s+'%a,vector=vector,maxDistance = maxDistance)
                d_negReturn = findMeshIntersectionFromObjectAxis(mesh, loc, axis = '%s-'%a,vector=vector,maxDistance = maxDistance)

                if 'hit' in d_posReturn.keys() and d_negReturn.keys():
                    l_pos = [d_posReturn.get('hit'),d_negReturn.get('hit')]
                    pos = distance.returnAveragePointPosition(l_pos)          
                    l_positions.append(pos)
		else:
		    raise RuntimeError,"No hit deteted. Object isn't in the mesh"
            if len(l_positions) == 1:
                l_pos =  l_positions[0]
            else:
                l_pos =  distance.returnAveragePointPosition(l_positions)
            if l_lastPos:dif = cgmMath.mag( cgmMath.list_subtract(l_pos,l_lastPos) )
            else:dif = 'No last'
            log.debug("findMeshMidPointFromObject>>> Step : %s | dif: %s | last: %s | pos: %s "%(i,dif,l_lastPos,l_pos)) 					
            if l_lastPos and cgmMath.isVectorEquivalent(l_lastPos,l_pos,2):
                log.debug("findMeshMidPointFromObject>>> Match found step: %s"%(i))
                mc.delete(loc)
                return l_pos
            mc.move(l_pos[0],l_pos[1],l_pos[2],loc,ws=True)
            l_lastPos = l_pos#If we get to here, add the current
        mc.delete(loc)    
        return l_pos
    except StandardError,error:
        for kw in [mesh,obj,axisToCheck,vector,maxDistance,maxIterations]:
            log.debug("%s"%kw)  
	try:mc.delete(loc)
	except:pass
        raise StandardError, "%s >> error: %s"%(_str_funcName,error)
 def findSurfaceMidPointFromObject(self):
     '''
     findSurfaceMidPointFromObject
     '''
     try:
         self._str_funcName = 'findSurfaceMidPointFromObject'
         log.debug(">>> %s >> "%self._str_funcName + "="*75)
         if len(mc.ls(surface))>1:
             raise StandardError,"findSurfaceMidPointFromObject>>> More than one surface named: %s"%surface
         if type(axisToCheck) not in [list,tuple]:axisToCheck=[axisToCheck]
         axis = ['x','y','z']
         for a in axisToCheck :
             if a not in axis:
                 raise StandardError,"findSurfaceMidPointFromObject>>> Not a valid axis : %s not in ['x','y','z']"%axisToCheck
         self.l_lastPos = []
         self.loc = locators.locMeObjectStandAlone(obj)
         for i in range(maxIterations):
             self.l_positions = []
             for a in axisToCheck:
                 log.debug("firing: %s"%a)
                 self.d_posReturn = findSurfaceIntersectionFromObjectAxis(surface, self.loc, axis = '%s+'%a,vector=vector,maxDistance = maxDistance) 
                 self.d_negReturn = findSurfaceIntersectionFromObjectAxis(surface, self.loc, axis = '%s-'%a,vector=vector,maxDistance = maxDistance) 
                 if 'hit' in self.d_posReturn.keys() and self.d_negReturn.keys():
                     self.l_pos = [self.d_posReturn.get('hit'),self.d_negReturn.get('hit')]
                     self.pos = distance.returnAveragePointPosition(self.l_pos)
                     self.l_positions.append(self.pos)
             if len(self.l_positions) == 1:
                 self.l_pos =  self.l_positions[0]
             else:
                 self.l_pos =  distance.returnAveragePointPosition(self.l_positions)
             if self.l_lastPos:self.dif = cgmMath.mag( cgmMath.list_subtract(self.l_pos,self.l_lastPos) )
             else:self.dif = 'No last'
             log.debug("findSurfaceMidPointFromObject>>> Step : %s | dif: %s | last: %s | pos: %s "%(i,self.dif,self.l_lastPos,self.l_pos))
             if self.l_lastPos and cgmMath.isVectorEquivalent(self.l_lastPos,self.l_pos,2):
                 log.debug("findSurfaceMidPointFromObject>>> Match found step: %s"%(i))
                 mc.delete(self.loc)
                 return self.l_pos 
             mc.move(self.l_pos[0],self.l_pos[1],self.l_pos[2],self.loc,ws=True)
             self.l_lastPos = self.l_pos#If we get to here, add the current    
         mc.delete(self.loc)    
         return self.l_pos
     except StandardError,error:
         raise StandardError, "error"
Esempio n. 3
0
def updateTemplate(self,saveTemplatePose = False,**kws):
    """
    Function to update a skeleton if it's been resized
    """
    if not self.isSized():
        log.warning("'%s' not sized. Can't update"%self.getShortName())
        return False
    if not self.isTemplated():
        log.warning("'%s' not templated. Can't update"%self.getShortName())
        return False
    
    if saveTemplatePose:self.storeTemplatePose()#Save our pose before destroying anything
        
    i_templateNull = self.templateNull#link for speed
    corePosList = i_templateNull.templateStarterData
    i_root = i_templateNull.root
    i_controlObjects = i_templateNull.controlObjects
    
    
    if not cgmMath.isVectorEquivalent(i_templateNull.controlObjects[0].translate,[0,0,0]):
        raise StandardError,"updateTemplate: doesn't currently support having a moved first template object"
        return False
    
    mc.xform(i_root.parent, translation = corePosList[0],worldSpace = True)
    
    for i,i_obj in enumerate(i_controlObjects[1:]):
        log.info(i_obj.getShortName())
        objConstraints = constraints.returnObjectConstraints(i_obj.parent)
        if objConstraints:mc.delete(objConstraints) 
        buffer = search.returnParentsFromObjectToParent(i_obj.mNode,i_root.mNode)
        i_obj.parent = False
        if buffer:mc.delete(buffer)
        mc.xform(i_obj.mNode, translation = corePosList[1:][i],worldSpace = True) 
        
    buffer = search.returnParentsFromObjectToParent(i_controlObjects[0].mNode,i_root.mNode)
    i_controlObjects[0].parent = False
    if buffer:mc.delete(buffer)
    
    doParentControlObjects(self)
    self.loadTemplatePose()#Restore the pose
    return True
Esempio n. 4
0
		else:
		    d_castReturn = RayCast.findMeshIntersectionFromObjectAxis(mesh, mi_loc.mNode, axis=aimAxis, maxDistance = maxDistance, singleReturn=False) or {}
		    log.debug("castReturn: %s"%d_castReturn)
		    if d_castReturn.get('hits'):
			closestPoint = distance.returnFurthestPoint(mi_loc.getPosition(),d_castReturn.get('hits')) or False
			d_castReturn['hit'] = closestPoint
			log.debug("From %s: %s" %(rotateValue,d_castReturn))"""

                d_rawHitFromValue[rotateValue] = hit

            except Exception,error:
                for arg in error.args:
                    log.error(arg)
                raise Exception,"createMeshSliceCurve>> error: %s"%error 
            log.debug("rotateValue %s | raw hit: %s"%(rotateValue,hit))
            if hit and not cgmMath.isVectorEquivalent(hit,d_rawHitFromValue.get(l_rotateSettings[i-1])):
                log.debug("last raw: %s"%d_rawHitFromValue.get(l_rotateSettings[i-1]))
                if markHits or offsetMode != 'vector':
                    mi_tmpLoc = cgmMeta.cgmObject(mc.spaceLocator(n='loc_%s'%i)[0])
                    mc.move (hit[0],hit[1],hit[2], mi_tmpLoc.mNode,ws=True)	                    
                if offsetMode =='vector':
                    _baseVector = MATH.get_vector_of_two_points(pos_base,
                                                                hit)
                    _baseDist = DIST.get_distance_between_points(pos_base, 
                                                                 hit)
                    hit = DIST.get_pos_by_vec_dist(pos_base,_baseVector, _baseDist + vectorOffset)
                elif posOffset:
                    constBuffer = mc.normalConstraint(mesh,mi_tmpLoc.mNode,
                                                      aimVector=[0,0,1],
                                                      upVector=[0,1,0],
                                                      worldUpType = 'scene')
Esempio n. 5
0
			
		else:
		    d_castReturn = RayCast.findMeshIntersectionFromObjectAxis(mesh, mi_loc.mNode, axis=aimAxis, maxDistance = maxDistance, singleReturn=False) or {}
		    log.debug("castReturn: %s"%d_castReturn)
		    if d_castReturn.get('hits'):
			closestPoint = distance.returnFurthestPoint(mi_loc.getPosition(),d_castReturn.get('hits')) or False
			d_castReturn['hit'] = closestPoint
			log.debug("From %s: %s" %(rotateValue,d_castReturn))
		    
		hit = d_castReturn.get('hit') or False
		d_rawHitFromValue[rotateValue] = hit
    
	    except StandardError,error:
		    raise StandardError,"createMeshSliceCurve>> error: %s"%error 
	    log.debug("rotateValue %s | raw hit: %s"%(rotateValue,hit))
	    if hit and not cgmMath.isVectorEquivalent(hit,d_rawHitFromValue.get(l_rotateSettings[i-1])):
		log.debug("last raw: %s"%d_rawHitFromValue.get(l_rotateSettings[i-1]))
		if markHits or posOffset:
		    mi_tmpLoc = cgmMeta.cgmObject(mc.spaceLocator(n='loc_%s'%i)[0])
		    mc.move (hit[0],hit[1],hit[2], mi_tmpLoc.mNode,ws=True)	
		    if posOffset:
			if offsetMode =='vector':
			    constBuffer = mc.aimConstraint(mi_obj.mNode,mi_tmpLoc.mNode,
				                              aimVector=[0,0,-1],
				                              upVector=[0,1,0],
				                              worldUpType = 'scene')
			else:
			    constBuffer = mc.normalConstraint(mesh,mi_tmpLoc.mNode,
				                              aimVector=[0,0,1],
				                              upVector=[0,1,0],
				                              worldUpType = 'scene')