Python cmds.pointPosition函数代码示例

def curveCoord(surfaceSkin,influence,controlPoints,curve):
	'''
	Set the target coordinates for the specified control points to lie along a given isoparm
	@param surfaceSkin: surfaceSkin node to apply the coordinates to
	@type surfaceSkin: str
	@param influence: surfaceSkin influence to get coordinate for
	@type influence: str
	@param controlPoints: List of control points to set the target coordinates for
	@type controlPoints: list
	@param curve: Curve to derive coordinates from
	@type curve: str
	'''
	# Check surfaceSkin
	if not ssUtil.verifyNode(surfaceSkin):
		raise Exception('Object "'+surfaceSkin+'" is not a valid surfaceSkin node!')
	
	# Iterate through control point list
	for controlPoint in controlPoints:
		# Get component position
		pos = mc.pointPosition(controlPoint)
		# Get closest point on curve
		cCoord = glTools.utils.curve.closestPoint(curve,pos)
		pos = mc.pointPosition(curve+'.u['+str(cCoord)+']')
		# Get surface coordinate
		uvCoord = glTools.utils.surface.closestPoint(influence,pos)
		# Apply Coord
		applyCoord(surfaceSkin,influence,controlPoint,uvCoord)

    def doIt(self,argList):
        #print "Trying to build a house..."
        selected = cmds.ls(orderedSelection=True)
        if(len(selected) != 1):
            house = building([20,20],[0,0,0])
        else:
            print "Selected %s" %(selected[0])
            tmp = selected[0]
            a = cmds.pointPosition(tmp+'.vtx[0]')
            b = cmds.pointPosition(tmp+'.vtx[1]')
            c = cmds.pointPosition(tmp+'.vtx[2]')
            d = cmds.pointPosition(tmp+'.vtx[3]')

            width = int(b[0] - a[0])
            print width
            depth = int(b[2] - c[2])
            print depth

            offsetX = b[0] - width/2
            offsetY = int(b[1])
            offsetZ = b[2] - depth/2
            # print "Calculated %d x %d lot at [ %d, %d ]." %(width, depth, offsetX, offsetY )

            house = building([width-2,depth-2],[offsetX,offsetY,offsetZ])
        house.build()

def createCurve(ptList,start,end,group=''):
	'''
	'''
	# Initialize Curves
	crvList = []
	for pt in ptList:
		pos = mc.pointPosition(pt)
		curve = mc.curve(p=[pos,pos],d=1)
		curve = mc.rename(curve,pt+'_curve')
		crvList.append(curve)
	
	# Track Curves
	for i in range(start,end+1):
		mc.currentTime(i)
		for n in range(len(ptList)):
			pos = mc.pointPosition(ptList[n])
			mc.curve(crvList[n],a=True,p=pos)
	
	# Remove Initial CV and Rebuild
	for crv in crvList:
		mc.delete(crv+'.cv[0]')
		mc.rebuildCurve(crv,ch=False,rpo=True,rt=0,end=1,kr=2,kcp=True,kep=True)
	
	# Group Curves
	if group:
		# Check Group
		if not mc.objExists(group): group = mc.group(em=True,n=group)
		# Parent Curves to Group
		mc.parent(crvList,group)
	
	# Return Result
	if group: return [group]
	else: return crvList

def distanceBetween(*args):  # distance between two points
    if len(args) == 0:
        args = mc.ls(sl=True)
    if len(args) == 0:
        return
    p = []
    for a in args:
        if isIterable(a) and len(a) >= 3 and isinstance(a[0], (float, long, int)) and len(a) >= 3:
            p.append(a)
        elif isinstance(a, basestring) and mc.objExists(a):
            if len(a.split(".")) > 1:
                try:
                    p.append(mc.pointPosition(a))
                except:
                    pass
            else:
                try:
                    p.append(mc.pointPosition(a + ".rp"))
                except:
                    err = True
    if len(p) < 1:
        return
    if len(p) > 2:
        p[:] = p[:2]
    dx = abs(p[0][0] - p[1][0])
    dy = abs(p[0][1] - p[1][1])
    dz = abs(p[0][2] - p[1][2])
    return sqrt(dx * dx + dy * dy + dz * dz)

def splitBlendShape( percentRange = .1 ):
    #USER CAN CHANGE THIS NUMBER
    ###################
    # percentRange = .1
    ####  .1 = 10% falloff
    ####  .3 = 30% falloff
    ####   1 = 100% falloff (probably looks bad)
    ###################

    (sourceObj, targetObj) = cmds.ls(sl=1)
    sourceShape = getShapeNode(sourceObj)

    #look at number of verticies
    cmds.select(sourceObj)
    numVerts = cmds.polyEvaluate(v=1)

    #figure out width of face (assume X axis)
    rgtX = 0
    lftX = 0
    for i in range(0,numVerts):
           testX = cmds.pointPosition(targetObj + ".vtx[" + str(i) + "]", l=1)[0]
           if testX < rgtX:
                   rgtX = testX
           if testX > lftX:
                   lftX = testX
                   
    #duplicate face twice (one left, one right)
    cmds.select(targetObj)
    targetObj_Lft = cmds.duplicate(n=targetObj+'_Lft')[0]
    cmds.move(rgtX * -2.1, 0, 0, r=1)
    cmds.select(targetObj)
    targetObj_Rgt = cmds.duplicate(n=targetObj+'_Rgt')[0]
    cmds.move(rgtX * 2.1, 0, 0, r=1)

    side = 1
    #on each object
    for target in ([targetObj_Lft, targetObj_Rgt]):
        side *= -1
        #for each vert
        for i in range(0,numVerts):
            #get vert positions
            #sourcePos = cmds.getAttr(sourceShape + '.pnts[' + str(i) + ']')[0]
            #targetPos = cmds.getAttr(target + '.pnts[' + str(i) + ']')[0]
            sourcePos = cmds.pointPosition(sourceObj + ".vtx[" + str(i) + "]", l=1)
            targetPos = cmds.pointPosition(target + ".vtx[" + str(i) + "]", l=1)        
            
            #find difference
            differencePos = (sourcePos[0] - targetPos[0], sourcePos[1] - targetPos[1], sourcePos[2] - targetPos[2])
            
            #get falloff amount from side of object
            testX = cmds.pointPosition(sourceObj + ".vtx[" + str(i) + "]", l=1)[0]
            falloff = getValue(testX, percentRange, rgtX * side)
            
            #move vert difference * falloff amount
            cmds.xform(target + '.vtx[' + str(i) + ']', rt=(differencePos[0] * falloff, differencePos[1] * falloff, differencePos[2] * falloff))

    cmds.select(cl=True)

def averageCV(amount=1.0):
	for cv in mc.ls(sl=True,fl=True):
		num = int(cv.split('.cv[')[-1].split(']')[0])
		baseObj = cv.split('.')[0]
		pos1 = mc.pointPosition('%s.cv[%i]' % (baseObj, num+1))
		pos2 = mc.pointPosition('%s.cv[%i]' % (baseObj, num-1))
		pos3 = mc.pointPosition('%s.cv[%i]' % (baseObj, num))
		average = [(pos1[0]+pos2[0]+pos3[0])/3, (pos1[1]+pos2[1]+pos3[1])/3, (pos1[2]+pos2[2]+pos3[2])/3]
		relAvg = [average[0]-pos3[0], average[1]-pos3[1], average[2]-pos3[2]]
		mc.move(relAvg[0]*amount, relAvg[1]*amount, relAvg[2]*amount, cv, r=True)

def getDelta(targetVert, referenceGeo):
    '''
    returns delta of vert based on referenceGeo
    '''
    targetGeo = getMeshName(targetVert)
    referenceVert = targetVert.replace(targetGeo, referenceGeo)
    
    targetPos = mc.pointPosition(targetVert, l=True)
    referencePos = mc.pointPosition(referenceVert, l=True)

    return [tP - rP for (tP, rP) in zip(targetPos, referencePos)]

def createInterpolatedCurve(curve1, curve2, v):
	interpolatedCurve = mc.duplicate(curve1, rr=True, rc=True)[0]

	for shape in mc.listRelatives(curve2,shapes=True,fullPath=True):
		cvList = (mc.ls([shape+'.cv[*]'],flatten=True))
	
	mc.rebuildCurve(interpolatedCurve, ch=0, rpo=1, rt= 0, end = 1, kr = 0, kcp = 0, kep = 1, kt = 0, s = len(cvList)-3, d = 3, tol = 0)
	for i in range(len(cvList)):
		pos1 = mc.pointPosition('%s.cv[%i]' % (interpolatedCurve,i))
		pos2 = mc.pointPosition('%s.cv[%i]' % (curve2,i))
		newPos = ((pos2[0]-pos1[0])*v+pos1[0], (pos2[1]-pos1[1])*v+pos1[1], (pos2[2]-pos1[2])*v+pos1[2])    
		mc.move(newPos[0], newPos[1], newPos[2], '%s.cv[%i]' % (interpolatedCurve,i), a=True)

	return interpolatedCurve

def snapComponentsOnClosestVertex(referenceObject, components, tolerance) :
	"""
	This function snaps vertices onto the reference object vertices.

	:param referenceObject: Reference mesh.
	:type referenceObject: str
	:param components: Components.
	:type components: list
	"""

	vertices = cmds.ls(cmds.polyListComponentConversion(components, toVertex=True), fl=True)

	progressBar = mel.eval("$container=$gMainProgressBar");

	cmds.progressBar(progressBar, edit=True, beginProgress=True, isInterruptable=True, status="Snapping vertices ...", maxValue=len(vertices))

	loadPlugin("nearestPointOnMesh")

	nearestPointOnMeshNode = mel.eval("nearestPointOnMesh " + referenceObject)

	for vertex in vertices :
		if cmds.progressBar(progressBar, query=True, isCancelled=True) :
			break

		closestDistance = MAXIMUM_SEARCH_DISTANCE

		vertexPosition = cmds.pointPosition(vertex, world=True)
		cmds.setAttr(nearestPointOnMeshNode + ".inPosition", vertexPosition[0], vertexPosition[1], vertexPosition[2])
		associatedFaceId = cmds.getAttr(nearestPointOnMeshNode + ".nearestFaceIndex")
		vtxsFaces = cmds.filterExpand(cmds.polyListComponentConversion((referenceObject + ".f[" + str(associatedFaceId) + "]"), fromFace=True, 	toVertexFace=True), sm=70, expand=True)

		closestPosition = []
		for vtxsFace in vtxsFaces :
			associatedVtx = cmds.polyListComponentConversion(vtxsFace, fromVertexFace=True, toVertex=True)
			associatedVtxPosition = cmds.pointPosition(associatedVtx, world=True)

			distance = norme(vertexPosition, associatedVtxPosition)

			if distance < closestDistance :
				closestDistance = distance
				closestPosition = associatedVtxPosition

			if closestDistance < tolerance :
				cmds.move(closestPosition[0], closestPosition[1], closestPosition[2], vertex, worldSpace=True)

		cmds.progressBar(progressBar, edit=True, step=1)

	cmds.progressBar(progressBar, edit=True, endProgress=True)

	cmds.delete(nearestPointOnMeshNode)

def createEyelidsPlane():
	curSel = cmds.ls(sl=1,fl=1)
	eyeCtr = cmds.xform(curSel[2],ws=1,piv=1,q=1)[0:3]
	eyeCnra = cmds.pointPosition(curSel[0],w=1)
	eyeCnrb = cmds.pointPosition(curSel[1],w=1)

	eyeballPlane = cmds.polyCreateFacet(n='tmp_eyeball_plane',ch=0,p=[eyeCtr,eyeCnra,eyeCnrb])
	eyelidsPlane  = cmds.polyPlane(n='tmp_eyelids_plane')

	cmds.select((eyelidsPlane[0]+'.vtx[60]'),(eyelidsPlane[0]+'.vtx[70:71]'),(eyeballPlane[0]+'.vtx[0:2]'),r=1)
	mel.eval('snap3PointsTo3Points(0)')
	cmds.select(eyelidsPlane,r=1)
	cmds.xform(eyelidsPlane,os=1,r=1,ro=(0,0,90))
	cmds.delete(eyeballPlane)

def locMeEdgeLoop(polyEdge):
	"""
	>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	DESCRIPTION:
	Creates a locator from an edgeloop

	ARGUMENTS:
	polyEdge(string)

	RETURNS:
	locatorName(string)
	>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	"""
	# Get the loop
	if ':' in polyEdge:
		edges = mc.ls(polyEdge,flatten=True)
	elif ',' in polyEdge:
		edges = polyEdge
	else:
		edges = search.returnEdgeLoopFromEdge(polyEdge)

	mc.select(cl=True)
	mc.select(edges)

	mel.eval("PolySelectConvert 3")
	edgeVerts = mc.ls(sl=True,fl=True)
	postList = []
	for vert in edgeVerts:
		posList.append(mc.pointPosition(vert,w=True))
	objTrans = distance.returnAveragePointPosition(posList)
	mc.select(cl=True)

	# Make the loc
	locatorName = createLocFromObject(polyEdge)
	mc.move (objTrans[0],objTrans[1],objTrans[2], locatorName)

	# aim it
	posList = []
	for vtx in edgeVerts:
		posList.append( mc.pointPosition(vtx,w=True) )

	polyBuffer = geo.createPolyFromPosList(posList)

	constBuffer = mc.normalConstraint(polyBuffer,locatorName)
	mc.delete(constBuffer[0])
	mc.delete(polyBuffer)

	return locatorName

def snapToVertex(mesh, transform, vtxId=-1, snapPivot=False):
    """
	Snap a transform the the closest point on a specified mesh
	@param mesh: Mesh to snap to
	@type mesh: str
	@param transform: Transform to snap to mesh
	@type transform: str
	@param vtxId: Integer vertex id to snap to. If -1, snap to closest vertex.
	@type vtxId: int
	@param snapPivot: Move only the objects pivot to the vertex
	@type snapPivot: bool
	"""
    # Check mesh
    if not isMesh(mesh):
        raise Exception("Object " + mesh + " is not a valid mesh!")

    # Get transform position
    pos = mc.xform(transform, q=True, ws=True, rp=True)

    # Get mesh vertex to snap to
    if vtxId < 0:
        vtxId = closestVertex(mesh, pos)

    # Get vertex position
    vtxPt = mc.pointPosition(mesh + ".vtx[" + str(vtxId) + "]")

    # Snap to Vertex
    if snapPivot:
        mc.xform(obj, piv=vtxPt, ws=True)
    else:
        mc.move(vtxPt[0] - pos[0], vtxPt[1] - pos[1], vtxPt[2] - pos[2], transform, r=True, ws=True)

        # Retrun result
    return vtxPt

	def buildNurbsRibbon(self):
		if self.guideSpline:
			guideDeg = cmds.getAttr(self.guideSpline + '.degree' )
			guideSpan = cmds.getAttr(self.guideSpline + '.spans' )
			oneCurvePoints = []
			otherCurvePoints = []
			for i in xrange(guideDeg + guideSpan):
				cvPos = cmds.pointPosition(self.guideSpline + '.cv[' + str(i) + "]", w=True )
				newPara = cmds.closestPointOnCurve(self.guideSpline, ip=cvPos, paramU=True)  #Find the parameter Value
				newParaVal = cmds.getAttr(newPara + ".paramU")
				cmds.delete(newPara)
				infoNode = cmds.pointOnCurve(self.guideSpline, ch=True, pr=newParaVal)  #Now find the Position and tangent!
				posy = (cmds.getAttr(infoNode + ".position"))[0]  # returns the position
				posy = MVector(posy[0],posy[1],posy[2])
				normy = (cmds.getAttr(infoNode + ".tangent"))[0]
				normy = MVector(normy[0],normy[1],normy[2]) #Use MVector from maya.openMaya
				normy = normy.normal()
				vertVect = MVector(0,1,0)
				sideMove = normy^vertVect #This is the notation for a cross product. Pretty cool. Should be a normal movement
				sideMove = sideMove.normal() * 0.5
				sideMovePos = posy + sideMove 
				otherSideMovePos = posy - sideMove
				oneCurvePoints.append([sideMovePos[0],sideMovePos[1],sideMovePos[2]])
				otherCurvePoints.append([otherSideMovePos[0],otherSideMovePos[1],otherSideMovePos[2]])

			oneSideCurve = cmds.curve(editPoint = oneCurvePoints, degree=3)
			OtherSideCurve = cmds.curve(editPoint = otherCurvePoints, degree=3)
			self.tempConstructionParts.append(oneSideCurve)
			self.tempConstructionParts.append(OtherSideCurve)
			#Now we loft the surface between the two Curves!
			nameStart = nameBase(self.totalMarkerList[0].getName(), self.searchString, "loc", "nbs")
			nameStart += "ribbonSurface"
			self.guideNurbsRibbon = cmds.loft(oneSideCurve, OtherSideCurve, name = nameStart, constructionHistory = True, uniform = True, close = False, autoReverse = True, degree = 3, sectionSpans = 1, range = False, polygon = 0, reverseSurfaceNormals = True)
			self.guideNurbsRibbon = self.guideNurbsRibbon[0]
			self.ribbonParts.append(self.guideNurbsRibbon)

def locMeCvFromCvIndex(shape,cvIndex):
	"""
	>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	DESCRIPTION:
	Places locators on the cv's closest position on a curve

	ARGUMENTS:
	curve(string)

	RETURNS:
	locList(list)
	>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	"""
	cv = ('%s%s%i%s'%(shape,'.cv[',cvIndex,']'))
	if mc.objExists(cv):
		cvPos = mc.pointPosition (cv,w=True)
		wantedName = (cv + 'loc')
		actualName = mc.spaceLocator (n= wantedName)
		mc.move (cvPos[0],cvPos[1],cvPos[2], [actualName[0]])
		uPos = distance.returnClosestUPosition (actualName[0],shape)
		mc.move (uPos[0],uPos[1],uPos[2], [actualName[0]])
		return actualName[0]
	else:
		guiFactory.warning  ('Shape does not exist')
		return False

def locMeCVOnCurve(curveCV):
	"""
	>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	DESCRIPTION:
	Places locators on the cv's closest position on a curve

	ARGUMENTS:
	curve(string)

	RETURNS:
	locList(list)
	>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	"""
	if search.returnObjectType(curveCV) == 'curveCV':
		cvPos = mc.pointPosition (curveCV,w=True)
		wantedName = (curveCV + '_loc')
		actualName = mc.spaceLocator (n= wantedName)
		mc.move (cvPos[0],cvPos[1],cvPos[2], [actualName[0]])
		splitBuffer = curveCV.split('.')
		uPos = distance.returnClosestUPosition (actualName[0],splitBuffer[0])
		mc.move (uPos[0],uPos[1],uPos[2], [actualName[0]])
		return actualName[0]
	else:
		guiFactory.warning  ('Not a curveCV')
		return False