def select_deselect_edge_lists(root_edge, loop=True): kw = {'edgeLoop' if loop else 'edgeRing': root_edge.index} if root_edge in mampy.complist(): kw.update({'deselect': True}) else: kw.update({'add': True}) cmds.polySelect(root_edge.dagpath, **kw)
def edgeLoopsToCurve(edgeList,form=2,degree=1): ''' Generate edge loop curves from the specified list of edges. @param edgeList: The list of mesh edges to generate edge loop curves from. @type edgeList: list @param form: NURBS curve form. 0 = Periodic, 1 = Open, 2 = Best Guess. @type form: str @param degree: NURBS curve degree. @type degree: str ''' # Filter/Check Edge List edgeList = mc.filterExpand(edgeList,ex=True,sm=32) if not edgeList: raise Exception('Invalid edge list!') # For Each Edge edgeCurveList = [] for edge in edgeList: # Get Mesh edgeId = glTools.utils.component.index(edge) meshShape = mc.ls(edge,o=True)[0] mesh = mc.listRelatives(meshShape,p=True)[0] prefix = mesh.split(':')[-1] # To Edge Loop mc.polySelect(mesh,edgeLoop=edgeId) # Edge Loop to Curve edgeCurve = mc.polyToCurve(ch=False,form=form,degree=degree)[0] # Append List edgeCurveList.append(edgeCurve) # Return Result return edgeCurveList
def edgeLoopWeights(edgeList): """ """ # Check Edge List if not edgeList: raise Exception('Invalid or empty edge list!') edgeList = cmds.filterExpand(edgeList, ex=True, sm=32) or [] if not edgeList: raise Exception('Invalid edge list! List of polygon edges required...') # Get Mesh from Edges mesh = list(set(cmds.ls(edgeList, o=True) or [])) if len(mesh) > 1: raise Exception('Edges from multiple mesh shapes were supplied! ' + str(mesh)) mesh = mesh[0] for edge in edgeList: # Get Edge ID edgeID = glTools.utils.component.index(edge) # Get Vertices from Edge edgeVerts = cmds.polyListComponentConversion(edge, fe=True, tv=True) # Get Average Vertex Weights cmds.select(edgeVerts) glTools.tools.copyPasteWeights.averageWeights() # Select Edge Loop Vertices cmds.polySelect(mesh, edgeLoop=edgeID) loopEdges = cmds.ls(sl=1, fl=1) loopVerts = cmds.polyListComponentConversion(loopEdges, fe=True, tv=True) cmds.select(loopVerts) glTools.tools.copyPasteWeights.pasteWeights() # Return Result return mesh
def inbetween(): """Select components between the last two selections.""" # TODO: refactor and finish. ordered_selection = mampy.complist(os=True) if not len(ordered_selection) % 2 == 0: comp1, comp2 = ordered_selection[-2:] else: for comp in ordered_selection: cmds.polySelect(comp.cmdslist(), q=True, loop=True)
def main(): #get edge IDs curSel = mc.ls(sl=1,fl=1) edgeID = [] for str in curSel: edgeID.append(int(re.split('[]]',(re.split('[[]',str)[1]))[0])) #print(edgeID) # check if loop edgeLoopGp = mc.polySelect(el=edgeID[0],q=1) if len(edgeLoopGp)>1: loopLst = [] for edge in edgeLoopGp: edge = repr(edge) if edge.find(repr(edgeID[1]))==0: loopLst.append(edge) isEL = len(loopLst) else: isEL = 0 # check if ring edgeRingGp = mc.polySelect(er=edgeID[0],q=1) if len(edgeRingGp)>1: RingLst = [] for edge in edgeRingGp: edge = repr(edge) if edge.find(repr(edgeID[1]))==0: RingLst.append(edge) isER = len(RingLst) else: isER = 0 # check if border edgeBorderGp = mc.polySelect(eb=edgeID[0],q=1) if type(edgeBorderGp) is ListType: if len(edgeBorderGp)>1: BorderLst = [] for edge in edgeBorderGp: edge = repr(edge) if edge.find(repr(edgeID[1]))==0: BorderLst.append(edge) isBd = len(BorderLst) else: isBd = 0 #do pattern if isEL==1: # edge loop pattern mc.polySelect(lpt=(edgeID[0],edgeID[1])) elif isER==1: #edge ring pattern mc.polySelect(rpt=(edgeID[0],edgeID[1])) elif isBd==1: #edge ring pattern mc.polySelect(bpt=(edgeID[0],edgeID[1]))
def is_border(self, index): """ Check if component index is on border of mesh. """ if self.type == api.MFn.kMeshPolygonComponent: return self.mesh.onBoundary(index) elif self.type == api.MFn.kMeshEdgeComponent: return cmds.polySelect(self.dagpath, q=True, edgeBorder=index, ns=True) or False else: edge = self.new().add(index).to_edge() return any( [cmds.polySelect(self.dagpath, q=True, edgeBorder=i, ns=True) for i in edge.indices] ) return False
def doIt(self, argList): # get only the first object from argument list try: obj = misc.getArgObj(self.syntax(), argList)[0] except: cmds.warning("No object selected!") return if (cmds.objectType(obj) != 'transform'): cmds.error("Object is not of type transform!") return # get parser object and use (optional) progress string as reference to UI-text to show current progress of calculation argData = om.MArgParser (self.syntax(), argList) progress = argData.flagArgumentString('progress', 0) if (argData.isFlagSet('progress')) else "" simplices = misc.getTriangles(obj) # save each shell in nested loop with indices to objects faces shells = [] shell_indices = [] # save a list of booleans to indicate if tri already belongs to a found shell triInShell = [False]*len(simplices) # remember number of triangles already in one shell (to show progress) count = 0 # loop over shells until each facet is mapped to one shell while len(shell_indices) < len(simplices): try: # get indices of all faces connected to given face (smallest index not used yet) # method ".index" will raise an exception if element is not found --> all triangles are in one shell --> break shell_indices = cmds.polySelect(obj, ets = triInShell.index(False), noSelection = 1) except: break # append shell indices to nested list structure (to remember which indices belong to which shell) #shells.append(shell_indices) shells.append(cmds.polySelect(obj, ets = triInShell.index(False), noSelection = 1, ass = 1)) # set indices in boolean list to True for s in shell_indices: triInShell[s] = True count += len(shell_indices) # update progress in text field (percentage of triangles already in found shells) try: cmds.text(progress, e = 1, label = 'Processing... (' + "{0:.1f}%)".format(float(count)/len(simplices) * 100) ) + '%%)' cmds.refresh(f = 1) except: pass # set result (string representation of each shell's indices list) for s in shells: self.appendToResult(str(s))
def getShells(self, obj): """ @param[in] obj: object full name @type obj: string @returns: list of shells that is included in the passed in object in format [ [[obj.f[0], obj.f[1], obj.f[2]], [obj.f[3], obj.f[4], obj.f[5]], [another shell]], [another object]] """ output = [] # total data numOfShells = cmds.polyEvaluate(obj, s=1) faceList = cmds.ls(cmds.polyListComponentConversion(obj, tf=True), l=1, fl=1) for i in range(numOfShells): # cmds.select(obj) idx = int(faceList[0].split(".f[")[-1].split("]")[0]) shellFaces = cmds.polySelect(obj, q=1, ets=idx) shellFacesFormat = [] # obj.f[0], obj.f[1] ... if shellFaces: for j in shellFaces: __faceData = obj + ".f[" + str(j) + "]" shellFacesFormat.append(__faceData) faceList = self.comprehensionList(faceList, shellFacesFormat) output.append(shellFacesFormat) return output
def select_deselect_border_edge(root_edge, tolerance): def get_vector_from_edge(edge, index): p1, p2 = [edge.points[i] for i in edge.vertices[index]] return p2 - p1 root_edge_vector = get_vector_from_edge(root_edge, root_edge.index) edge_border_indices = cmds.polySelect( root_edge.dagpath, edgeBorder=root_edge.index, noSelection=True ) border_edge = root_edge.new().add(edge_border_indices) edges_to_select = root_edge.new() for idx in border_edge: border_edge_vector = get_vector_from_edge(border_edge, idx) if root_edge_vector.isParallel(border_edge_vector, tolerance): edges_to_select.add(idx) connected = edges_to_select.get_connected_components() for e in connected: if root_edge.index in e: if root_edge in mampy.complist(): cmds.select(e.cmdslist(), d=True) else: cmds.select(e.cmdslist(), add=True)
def dfs(control_set, start): seen, stack = set(), [start] while stack: index = stack.pop() if index not in seen: shell = cmds.polySelect(str(self.dagpath), q=True, ets=index, ns=True) seen.update(shell) stack.extend(control_set - seen) yield shell
def getPolyShells(self, mesh): # returns poly shells as lists of faces shells = [] polygons = [i for i in range(0, cmds.polyEvaluate(f=1))] for poly in polygons: faces = cmds.polySelect(mesh, ets=poly, q=1) shells.append(faces) for face in faces: polygons.pop(polygons.index(face)) return shells
def edgeLoopWeights(edgeList): ''' ''' # Check Edge List if not edgeList: raise Exception('Invalid or empty edge list!') edgeList = mc.filterExpand(edgeList, ex=True, sm=32) or [] if not edgeList: raise Exception('Invalid edge list! List of polygon edges required...') # Get Mesh from Edges mesh = list(set(mc.ls(edgeList, o=True) or [])) if len(mesh) > 1: raise Exception('Edges from multiple mesh shapes were supplied! ' + str(mesh)) mesh = mesh[0] for edge in edgeList: # Get Edge ID edgeID = glTools.utils.component.index(edge) # Get Vertices from Edge edgeVerts = mc.polyListComponentConversion(edge, fe=True, tv=True) # Get Average Vertex Weights mc.select(edgeVerts) glTools.tools.copyPasteWeights.averageWeights() # Select Edge Loop Vertices mc.polySelect(mesh, edgeLoop=edgeID) loopEdges = mc.ls(sl=1, fl=1) loopVerts = mc.polyListComponentConversion(loopEdges, fe=True, tv=True) mc.select(loopVerts) glTools.tools.copyPasteWeights.pasteWeights() # Return Result return mesh
def getMiddleEdgeByMiddleVerts(self, middVerts): middleEdgeArray = [] for mea in middVerts: edgeLoop = cmds.polySelect(self.polyName, edgeLoop=mea, ass=0, q=1) edgeName = '%s.e[%s]' % (self.polyName, str(int(edgeLoop[0]))) edgePos = cmds.xform(edgeName, ws=1, q=1, t=1) if round(edgePos[0], 5) == 0: edgeName = '%s.e[%s]' % (self.polyName, str(int(edgeLoop[-1]))) edgePos = cmds.xform(edgeName, ws=1, q=1, t=1) if round(edgePos[0], 5) == 0: intArray = [int(i) for i in edgeLoop] if intArray not in middleEdgeArray: middleEdgeArray.append(intArray) return middleEdgeArray
def curveFromEdgeRing(): sel = cmds.ls(sl=True, fl=True) avgPositionList = [] for s in sel: cmds.select(s, r=True) edgeNum = int(s.split('[')[1].replace(']', '')) cmds.polySelect(elb=edgeNum) edgeLoopVtxList = cmds.ls(cmds.polyListComponentConversion(cmds.ls( sl=True, fl=True), tv=True), fl=True) posXlist = [] posYlist = [] posZlist = [] for v in edgeLoopVtxList: posXlist.append(cmds.pointPosition(v)[0]) posYlist.append(cmds.pointPosition(v)[1]) posZlist.append(cmds.pointPosition(v)[2]) avgPos = [ numpy.mean(posXlist), numpy.mean(posYlist), numpy.mean(posZlist) ] avgPositionList.append(avgPos) if len(avgPositionList) <= 1: pass else: cmds.curve(d=3, p=avgPositionList)
def get_mesh_shell(self): """ Extend current :class:`Component` to contained mesh shell and return new :class:`Component`. :rtype: :class:`Component` """ faces = self.to_face() shell = set() for idx in faces.indices: if idx in shell: continue shell.update( cmds.polySelect(str(self.dagpath), q=True, ets=idx, ns=True) ) faces.add(shell) return faces.convert_to(self.type)
def create_link(self): """Creates a ring Attributes: linkNumber: What number of ring it is(the first is 0, second is 1 ... ETC) Returns: Ring object """ #general transforms ring = Ring(self.linkNumber, self.radius, self.linkRadius) cmds.setAttr(ring.get_shape() + ".subdivisionsAxis", 4) # change subdivisions to get rectangular shape cmds.setAttr(ring.get_transform() + ".rotateY", 45) # rotation in xz plane cmds.polySelect(ring.get_transform(), el=100) # stretching the square cmds.polySelect(ring.get_transform(), el=85, add=True) cmds.polyMoveEdge(translateX=(float(-self.radius) * (2.0 - math.sqrt(2)) / 2)) cmds.polySelect(ring.get_transform(), el=90) # stretching the square at opposite corners cmds.polySelect(ring.get_transform(), el=95, add=True) cmds.polyMoveEdge(translateX=(float(self.radius) * (2.0 - math.sqrt(2)) / 2)) #rotate along chain axis every 2nd link if self.rotationState == True: cmds.rotate(90, 0, 45, ring.get_transform(), ws=True) #Makes the next ring rotate 90 deg self.rotationState = not self.rotationState self.linkNumber += 1 #stores the ring for later modifications self.linkObjs.append(ring) self.move_link(ring) return ring
def getGeodesicDistancev2(mesh, v1Index, v2Index): #Catch special case if (v1Index == v2Index): return 0 #Get the shortest edge path sel = cmds.polySelect(mesh, shortestEdgePath=(v1Index, v2Index), ass=True ) #Calculate the path length dist = 0 for i in range(len(sel)): conv = cmds.polyListComponentConversion(sel[i], fe=True, tv=True) conv = cmds.filterExpand(conv, sm=31) dist += getEuclideanDistance(cmds.pointPosition(conv[0]), cmds.pointPosition(conv[1])) return dist
def filterCrease(self, polyName, wholeDelArrayTemp, isProtectCreaseLoop=True): arrayWithoutCrease = [] noneCreaseArray = [] creaseArray = [] self.progress.setMaximum(len(wholeDelArrayTemp)) self.progress.setLabelText('filter Crease...') self.progress.setValue(0) for count, pwda in enumerate(wholeDelArrayTemp): self.progress.setValue(count) fullString = '%s.e[%s]' % (polyName, str(pwda)) cVal = cmds.polyCrease(fullString, q=1, value=1) if cVal[0] <= 0: noneCreaseArray.append(int(pwda)) else: creaseArray.append(int(pwda)) creaseProtectArray = [] if isProtectCreaseLoop: for i in creaseArray: edgeLoop = cmds.polySelect(polyName, edgeLoop=int(i), ass=0, q=1) for el in edgeLoop: creaseProtectArray.append(int(el)) for i in noneCreaseArray: if i not in creaseProtectArray: arrayWithoutCrease.append(i) else: arrayWithoutCrease = list(noneCreaseArray) return arrayWithoutCrease
def findAllShapes(obj): faces = {} faces = set() faceCount = cmd.polyEvaluate(obj, f=True) for i in range(faceCount): faces.add(i) d = dict() i = 1 while len(faces) > 0: if i > 100: break start = (faces.pop()) faces.add(start) shellFaces = cmd.polySelect(obj, ets=start) verts = cmd.polyListComponentConversion(ff=True, tv=True) d[i] = verts for this in shellFaces: faces.remove(this) i += 1 return (d)
def returnEdgeLoopFromEdge(polyEdge): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Returns an edgeloop from an edge ARGUMENTS: polyEdge(string) RETURNS: edgeList(list) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ splitBuffer = polyEdge.split('.') polyObj = splitBuffer[0] edges = mc.polySelect([polyObj],edgeLoop = (returnIndiceFromName(polyEdge))) mc.select(cl=True) edges = lists.returnListNoDuplicates(edges) returnList = [] for edge in edges: returnList.append('%s%s%i%s' %(polyObj,'.e[',edge,']')) return returnList
def getBaseStructEdgeInformation(self, polyName, vertInformationDict, delLevel=1): cleanVertArray = vertInformationDict['keyVerts'] edgeLoopArray = [] # get the base struct edges. vertToStructEdgeDict = {} # return value simpleStructEdgeArray = [] for count, cva in enumerate(cleanVertArray): vert = '%s.vtx[%s]' % (polyName, str(cva)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = self.cleanInfos(edgeInfo[0]) relativeList = [] for eid in edgeID: edgeLoop = cmds.polySelect(polyName, edgeLoop=int(eid), ass=0, q=1) if len(edgeLoop) > ( delLevel + 1): # filter the items which length not enough. intArray = [] for el in edgeLoop: intArray.append(int(el)) if intArray: if intArray not in edgeLoopArray: edgeLoopArray.append(intArray) # collect information {vert:[edge1,edge2,...edge5]}} if self.isEdgesListMirror(intArray): spArray = self.splitLinesByMiddle([intArray]) for spa in spArray: if int(eid) in spa: relativeList.append(spa) else: relativeList.append(intArray) vertToStructEdgeDict.update({str(cva): relativeList}) # restore edges start from key vert. edgeLoopArrayWithoutMiddle = list(edgeLoopArray) spEdgeLoopArray = self.splitLinesByMiddle(edgeLoopArray) spEdgeLoopArray += (self.getMiddleEdgeByMiddleVerts( vertInformationDict['middleVerts'])) edgeLoopArrayWithoutMiddle += (self.getMiddleEdgeByMiddleVerts( vertInformationDict['middleVerts'])) # create struct weight structWeightDict = {} # return value for spela in spEdgeLoopArray: structWeightDict.update({str(spela): 1}) # add edge weight(crease vertex) creaseVertArray = vertInformationDict['creaseVerts'] if creaseVertArray: for cva in creaseVertArray: edgeArray = vertToStructEdgeDict[str(cva)] for ea in edgeArray: structWeightDict[str(ea)] += 1 structEdgeToVertsDict = {} # return value.very important for spela in spEdgeLoopArray: vertTempA = self.edgeListToVertList(spela) intArray = [] for vta in vertTempA: intArray.append(int(vta)) structEdgeToVertsDict.update({str(spela): intArray}) structEdges = [] for spela in spEdgeLoopArray: #print spela for sa in spela: structEdges.append(int(sa)) return { 'keyVertToStructEdgeDict': vertToStructEdgeDict, 'structEdgeWeightDict': structWeightDict, 'structEdgeToVertsDict': structEdgeToVertsDict, 'structEdgeFlat': structEdges, 'edgeLoopArrayWithoutMiddle': edgeLoopArrayWithoutMiddle, 'structEdgeList': spEdgeLoopArray }
def get_border_loop_indices_from_edge_index(index): return set(sorted([int(i) for i in cmds.polySelect(q=True, edgeBorder=index)]))
def CreateDoorBase(self, name="doorBase", width=_wallbaseWidth, height=_wallbaseHeight, divisions=2): if cmds.objExists(name): return name door = cmds.polyPlane(name=name, w=1, h=1, sx=2, sy=2, cuv=2, ch=1, ax=[1, 0, 0]) cmds.move(0, height / 2, 0, a=True) cmds.polySelect(name, edgeRing=1) cmds.polyCrease(value=0.9) cmds.select(f'{name}.f[0:]', r=True) cmds.sets(e=True, forceElement=self._matWall) offset = cmds.polyExtrudeFacet(constructionHistory=True, keepFacesTogether=True, offset=0.05, divisions=divisions) cmds.setAttr(f'{offset[0]}.localTranslate', 0, 0.05, 0) cmds.scale(1, 1, 0.6, r=True, p=[0, 0.45, 0]) cmds.polyExtrudeFacet(constructionHistory=True, keepFacesTogether=True, thickness=0.05, divisions=divisions) cmds.sets(e=True, forceElement=self._matDoorFrame) cmds.polyExtrudeFacet(constructionHistory=True, keepFacesTogether=True, offset=0.02, divisions=divisions) cmds.polyExtrudeFacet(constructionHistory=True, keepFacesTogether=True, thickness=-0.2, divisions=divisions) cmds.sets(e=True, forceElement=self._matDoor) cmds.select(f'{name}.f[4:8]', r=True) cmds.polyDelFacet() cmds.select(door) cmds.polyBevel3(fraction=0.1, offsetAsFraction=1, autoFit=1, depth=1, mitering=0, miterAlong=0, chamfer=0, segments=2, worldSpace=1, smoothingAngle=30) #freeze transformations cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0, pn=1) return door[0]
import maya.cmds as cmds #create cylinder 8 subdivisions axis cylinder = cmds.polyCylinder(sx=8, sy=1, sz=1) #select edges cmds.polySelect(cylinder, edgeRing=(24, 26, 28, 30, 32, 34, 36, 38)) #delete selection cmds.delete()
def get_border_loop_indices_from_edge_index(index): return set( sorted([int(i) for i in cmds.polySelect(q=True, edgeBorder=index)]))
def change_chain(self, links=None, length=None, thickness=None): """modifies the chain properties. Links, length and thickness can all be changed. EX: change_chain(self, links = int, length = float, thickness = float) """ #link number is flagged to change if links: changeInLinks = links - self.links self.links = links #if missing links create and parent links if changeInLinks > 0: for link in range(changeInLinks): newRing = self.create_link() cmds.parent(newRing.get_name(), self.linkObjs[0].get_name()) newRing.add_parent(self.linkObjs[0].get_transform()) #if too many links. Ensure the root node is not deleted elif changeInLinks < 0 and self.links > 1: self.linkObjs[len(self.linkObjs) - 1].delete_link() self.linkNumber -= 1 self.linkObjs.pop() #length is flagged to change if length: for ring in self.linkObjs: #reset the link to 0 for easier re-transform magnitudeOfTranslate = (ring.get_ringNumber()) * ( self.radius) + (ring.get_ringNumber()) * ( self.radius - 2 * (self.linkRadius)) cmds.move(-magnitudeOfTranslate, 0, 0, ring.get_transform()) changeInRadius = self.radius - length for ring in self.linkObjs: # Prepare the variables for transforming # pastTransformX = 0.8*(float(-self.radius)*(2.0-math.sqrt(2))/2) self.radius = length # newTransformX = 0.8*(float(-self.radius)*(2.0-math.sqrt(2))/2) #reshape cmds.polySelect(ring.get_transform(), el=100) # stretching the square cmds.polySelect(ring.get_transform(), el=85, add=True) cmds.polyMoveEdge(translateX=(changeInRadius)) cmds.polySelect(ring.get_transform(), el=100) # stretching the square z cmds.polySelect(ring.get_transform(), el=95, add=True) cmds.polyMoveEdge(translateZ=(changeInRadius)) cmds.polySelect(ring.get_transform(), el=90) cmds.polySelect(ring.get_transform(), el=95, add=True) cmds.polyMoveEdge(translateX=-(changeInRadius)) cmds.polySelect(ring.get_transform(), el=85) # stretching the square z cmds.polySelect(ring.get_transform(), el=90, add=True) cmds.polyMoveEdge(translateZ=-(changeInRadius)) self.move_link(ring) #thickness is flagged to change. if thickness: for ring in self.linkObjs: #reset the link to 0 for easier re-transform magnitudeOfTranslate = (ring.get_ringNumber()) * ( self.radius) + (ring.get_ringNumber()) * ( self.radius - 2 * (self.linkRadius)) cmds.move(-magnitudeOfTranslate, 0, 0, ring.get_transform()) # Prepare the variables for transforming pastTransformX = 0.8 * (newTransformX - pastTransformX) self.linkRadius = thickness newTransformX = -0.8 * (newTransformX - pastTransformX) #reshape cmds.polySelect(ring.get_transform(), el=100) # stretching the square cmds.polySelect(ring.get_transform(), el=85, add=True) cmds.polyMoveEdge(translateX=0.8 * (newTransformX - pastTransformX)) cmds.polySelect(ring.get_transform(), el=90) cmds.polySelect(ring.get_transform(), el=95, add=True) cmds.polyMoveEdge(translateX=-0.8 * (newTransformX - pastTransformX)) self.move_link(ring)
EDGE_STEP = 7 # select startEdge, then endEdge selEdges = mc.ls(sl=1)[0:2] endEdgeUndo = mc.undoInfo(q=1, un=1) prefix = selEdges[0].split('[')[0] endEdgeIndex = int(endEdgeUndo.split('[')[1][:-2]) selEdgesIndex = [int(edgeName.split('[')[1][:-1]) for edgeName in selEdges] for eachEdge in selEdgesIndex: if eachEdge != endEdgeIndex: startEdgeIndex = eachEdge break edgeLoopIndices = mc.polySelect(elp=[startEdgeIndex, endEdgeIndex], ns=1) edgeLoop = ['%s[%d]'%(prefix, edgeIndex) for edgeIndex in edgeLoopIndices] if edgeLoopIndices[-1] == startEdgeIndex: edgeLoop.reverse() edgeLoopIndices.reverse() centerPositions = [] # loop through edges to store center positions for i in range(len(edgeLoop)-1): currEdge = edgeLoop[i] currEdgeIndex = edgeLoopIndices[i] nextEdge = edgeLoop[i+1] nextEdgeIndex = edgeLoopIndices[i+1] currRing = mc.polySelect(er=currEdgeIndex, ns=1, ass=1)
def calculateBaseDeleteArray(self, polyName, delLevel=1): # delLevel attr means smooth level 1 to reverse divAttr = delLevel + 1 edgeArrayTemp = self.getBaseStructEdges(polyName) if edgeArrayTemp: edgeArray = edgeArrayTemp[0] addWeightStructEdges = edgeArrayTemp[1] else: return False # every item in the array is unique.it's all fine. self.progress.setMaximum(len(edgeArray)) self.progress.setLabelText('clean data..') self.progress.setValue(0) wholeEdges = [] for i in edgeArray: wholeEdges += i # ================== main part ================================= selEdgeArray = [] for count, ela in enumerate(edgeArray): self.progress.setValue(count) if len(ela) >= divAttr: # make data form.when divAttr equel 1,we need two item to calculate. # divAttr = 2 -> item length = 3 # divAttr = 3 -> item length = 4 divWorkArray = [ ela[i:i + divAttr] for i in range(0, len(ela), divAttr) ] # check array struct,is it 100% fit? if more or less.then removed them. for dwacheck in divWorkArray: if len(dwacheck) != divAttr: divWorkArray.remove(dwacheck) # collect the point on curve,who need to delete under base rule. delVertInEdge = [] for dwa in divWorkArray: tempArray = [] targetArray = [] for i in dwa: edge = '%s.e[%s]' % (polyName, str(i)) vtx = cmds.polyInfo(edge, edgeToVertex=1) vtxID = self.cleanInfos(vtx[0]) for vid in vtxID: if int(vid) in tempArray: targetArray.append(int(vid)) else: tempArray.append(int(vid)) delVertInEdge += targetArray # now we need convert the vert to the edge who crossed base struct edges. crossEdges = [] for dvi in delVertInEdge: vert = '%s.vtx[%s]' % (polyName, str(dvi)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = self.cleanInfos(edgeInfo[0]) # rule 1.the line can not in the base protect array. # in the touch point.there're two edges in base protect array. # now i need collect all of rest items. cellArray = [] for eid in edgeID: if not (int(eid) in wholeEdges): cellArray.append(int(eid)) crossEdges.append(cellArray) selEdgeArray.append(crossEdges) # ================== main part end ================================= # ================== add cease vert weight part ================================= # calculate the edges who need add weight. # program as same as the main function of this def. # just use a another array and loop again. # addWeightStructEdges addWeightEdgeArray = [] self.progress.setValue(0) for count, ela in enumerate(addWeightStructEdges): self.progress.setValue(count) if len(ela) >= divAttr: # make data form.when divAttr equel 1,we need two item to calculate. # divAttr = 2 -> item length = 3 # divAttr = 3 -> item length = 4 divWorkArray = [ ela[i:i + divAttr] for i in range(0, len(ela), divAttr) ] # check array struct,is it 100% fit? if more or less.then removed them. for dwacheck in divWorkArray: if len(dwacheck) != divAttr: divWorkArray.remove(dwacheck) # collect the point on curve,who need to delete under base rule. delVertInEdge = [] for dwa in divWorkArray: tempArray = [] targetArray = [] for i in dwa: edge = '%s.e[%s]' % (polyName, str(i)) vtx = cmds.polyInfo(edge, edgeToVertex=1) vtxID = self.cleanInfos(vtx[0]) for vid in vtxID: if int(vid) in tempArray: targetArray.append(int(vid)) else: tempArray.append(int(vid)) delVertInEdge += targetArray # now we need convert the vert to the edge who crossed base struct edges. crossEdges = [] for dvi in delVertInEdge: vert = '%s.vtx[%s]' % (polyName, str(dvi)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = self.cleanInfos(edgeInfo[0]) # rule 1.the line can not in the base protect array. # in the touch point.there're two edges in base protect array. # now i need collect all of rest items. cellArray = [] for eid in edgeID: if not (int(eid) in wholeEdges): cellArray.append(int(eid)) crossEdges.append(cellArray) addWeightEdgeArray.append(crossEdges) # ================== add cease vert weight part end ================================= countWeightTemp = addWeightEdgeArray + selEdgeArray self.progress.setMaximum(len(countWeightTemp)) self.progress.setLabelText('clean data....') self.progress.setValue(0) wholeDelArrayTemp = [] countDict = {} # edge weights dict. very important. for count, gg in enumerate(countWeightTemp): self.progress.setValue(count) for ce in gg: if ce: edgeLoop = cmds.polySelect(polyName, edgeLoop=int(ce[0]), ass=0, q=1) edgeLoop.sort() strEdge = str(edgeLoop) if strEdge not in countDict.keys(): countDict.update({strEdge: 5}) else: countDict[strEdge] += 1 ''' isFound = False for awe in addWeightEdgeArray: if ce in awe: isFound = True if isFound: countDict.update({strEdge:7}) ''' # ========================================== vertToKeyDict = {} vertToWeightDict = {} edgeArray # defined at the fist of def teamVertsByEdgeArray = [] for ea in edgeArray: tempArray = [] for i in ea: edge = '%s.e[%s]' % (polyName, str(i)) vtx = cmds.polyInfo(edge, edgeToVertex=1) vtxID = self.cleanInfos(vtx[0]) for vid in vtxID: if int(vid) not in tempArray: tempArray.append(int(vid)) teamVertsByEdgeArray.append(tempArray) crossEdges = [] for tvbea in teamVertsByEdgeArray: for tvb in tvbea: vert = '%s.vtx[%s]' % (polyName, str(tvb)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = self.cleanInfos(edgeInfo[0]) # rule 1.the line can not in the base protect array. # in the touch point.there're two edges in base protect array. # now i need collect all of rest items. cellArray = [] for eid in edgeID: if not (int(eid) in wholeEdges): edgeLoop = cmds.polySelect(polyName, edgeLoop=int(eid), ass=0, q=1) cellArray.append(edgeLoop) break if cellArray: crossEdges.append(cellArray) #print '^^^^^' #for ce in crossEdges: # print ce #print len(crossEdges) #print '^^^^^' # ========================================== # remove edges.just keep weight <= 5. # as high weight as confirm the edge have to be deleted. collectArray = [] for key, val in countDict.items(): if val > 5: keytemp = key.split(',') collectList = [] for kt in keytemp: digitTemp = '' for k in kt: if k.isdigit(): digitTemp += k digitVal = int(digitTemp) collectList.append(digitVal) collectArray.append(collectList) for cc in collectArray: for c in cc: wholeDelArrayTemp.append(c) return [collectArray, wholeDelArrayTemp]
def calculateBaseDeleteArray(polyName, delLevel=1): # delLevel attr means smooth level 1 to reverse divAttr = delLevel + 1 edgeArray = getBaseStructEdges(polyName) # every item in the array is unique.it's all fine. wholeEdges = [] for i in edgeArray: wholeEdges += i selEdgeArray = [] for ela in edgeArray: if len(ela) >= divAttr: # make data form.when divAttr equel 1,we need two item to calculate. # divAttr = 2 -> item length = 3 # divAttr = 3 -> item length = 4 divWorkArray = [ ela[i:i + divAttr] for i in range(0, len(ela), divAttr) ] # check array struct,is it 100% fit? if more or less.then removed them. for dwacheck in divWorkArray: if len(dwacheck) != divAttr: divWorkArray.remove(dwacheck) # collect the point on curve,who need to delete under base rule. delVertInEdge = [] for dwa in divWorkArray: tempArray = [] targetArray = [] for i in dwa: edge = '%s.e[%s]' % (polyName, str(i)) vtx = cmds.polyInfo(edge, edgeToVertex=1) vtxID = cleanInfos(vtx[0]) for vid in vtxID: if int(vid) in tempArray: targetArray.append(int(vid)) else: tempArray.append(int(vid)) delVertInEdge += targetArray # now we need convert the vert to the edge who crossed base struct edges. crossEdges = [] for dvi in delVertInEdge: vert = '%s.vtx[%s]' % (polyName, str(dvi)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = cleanInfos(edgeInfo[0]) # rule 1.the line can not in the base protect array. # in the touch point.there're two edges in base protect array. # now i need collect all of rest items. cellArray = [] for eid in edgeID: if not (int(eid) in wholeEdges): cellArray.append(int(eid)) crossEdges.append(cellArray) #selEdgeByIntArray(polyName,crossEdges) selEdgeArray.append(crossEdges) delArrayTemp = [] wholeDelArrayTemp = [] for gg in selEdgeArray: for ce in gg: if ce: edgeLoop = cmds.polySelect(polyName, edgeLoop=int(ce[0]), ass=0, q=1) delArrayTemp.append(edgeLoop) for el in edgeLoop: intEl = int(el) if not (intEl in wholeDelArrayTemp): wholeDelArrayTemp.append(intEl) return [delArrayTemp, wholeDelArrayTemp]
def getBaseStructEdges(self, polyName): vertArrayTemp = self.getAllVertsWhoHave5edges(polyName) if vertArrayTemp: cleanVertArray = vertArrayTemp[0] midEdgeArray = vertArrayTemp[1] creaseVertexArray = vertArrayTemp[2] self.progress.setMaximum(len(cleanVertArray)) self.progress.setLabelText('struct data...') self.progress.setValue(0) edgeLoopArray = [] sortTemp = [] # get the base struct edges on normal way. for count, cva in enumerate(cleanVertArray): self.progress.setValue(count) vert = '%s.vtx[%s]' % (polyName, str(cva)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = self.cleanInfos(edgeInfo[0]) for eid in edgeID: edgeLoop = cmds.polySelect(polyName, edgeLoop=int(eid), ass=0, q=1) intArray = [] for el in edgeLoop: intArray.append(int(el)) sEdgeLoop = list(intArray) sEdgeLoop.sort() if not (sEdgeLoop in sortTemp): edgeLoopArray.append(intArray) sortTemp.append(sEdgeLoop) # if middle edges exists.add middle edges into array. strTemp = [] if midEdgeArray: for mea in midEdgeArray: edgeLoop = cmds.polySelect(polyName, edgeLoop=mea, ass=0, q=1) strLoop = str(edgeLoop) if strLoop not in strTemp: strTemp.append(strLoop) edgeLoopArray.append(edgeLoop) # before this line.for loop have a filter to split the multiple occurrence edges. # so we need add the edges who defined by crease vertex after filter. # add edges weight by crease verts. addWeightStructEdges = [] for cva in creaseVertexArray: vert = '%s.vtx[%s]' % (polyName, str(cva)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = self.cleanInfos(edgeInfo[0]) for eid in edgeID: edgeLoop = cmds.polySelect(polyName, edgeLoop=int(eid), ass=0, q=1) intArray = [] for el in edgeLoop: intArray.append(int(el)) addWeightStructEdges.append(intArray) return [edgeLoopArray, addWeightStructEdges] else: return False
def SelectEdges(self): """ Select edges of a poly object """ cmds.polyCube(n="pCube1", ch=False) cmds.polySelect('pCube1', edgeRing=1) cmds.polySelect('pCube1', toggle=True, edgeRingPath=(0, 1))
for one in cvs: cmd.select(one) cmd.cluster(name='%s%d%s'% (name, i, type)) cmd.group(name='%s%d%sGP'% (name, i, type)) i += 1 cvsToCLR() #select edgeLoop from edge import re import maya.cmds as cmd edge = cmd.ls(sl=True) id = re.findall('\d+',(edge[0].split('.')[1])) cmd.polySelect(el=int(id[0])) [('pointOnSurfaceInfo', 'pos', u'pos4'), ('loft', 'lft', u'lft'), ('fourByFourMatrix', 'mat', u'mat'), ('decomposeMatrix', 'dcp', u'dcp')] def lotteryPicker(numTix, picks, possible): import random import time import math possible += 1 start_time = time.time() n = math.factorial(possible)
#selVertByIntArray(polyName,delVertInEdge) #now we need convert the vert to the edge who crossed base struct edges. #print holeEdge crossEdges = [] for dvi in delVertInEdge: vert = '%s.vtx[%s]' % (polyName, str(dvi)) edgeInfo = cmds.polyInfo(vert, vertexToEdge=1) edgeID = cleanInfos(edgeInfo[0]) for eid in edgeID: if not (int(eid) in holeEdge): crossEdges.append(int(eid)) break # if i removed 'break'.then will get two edges.i don't have to do that #selEdgeByIntArray(polyName,crossEdges) selEdgeArray.append(crossEdges) print selEdgeArray for gg in selEdgeArray: for ce in gg: edgeLoop = cmds.polySelect(polyName, edgeLoop=int(ce), ass=0, q=1) selEdgeByIntArray(polyName, edgeLoop, add=1)
def makeSym(*args): selLs = cmds.ls(sl = True) # When user select center edge loop. if '.e' in selLs[0]: numOfShells = cmds.polyEvaluate(shell = True) if numOfShells > 1: cmds.confirmDialog(title = 'Warning', message = 'Selected mesh is made of combining several geometry.\nSeparate mesh and try it again.') return False centerEdgeLoop = selLs objName = centerEdgeLoop[0].split('.')[0] uvKeepGeo = cmds.duplicate(objName, n = '{0}_uvKeep_geo'.format(objName)) mel.eval('PolySelectConvert 3;') tak_misc.zeroVtx() cmds.select(centerEdgeLoop, r = True) cmds.DetachComponent() leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName) symOpt = cmds.radioButtonGrp('symOptRadButGrp', q = True, select = True) # If user select 'x to -x' mean left to right. if symOpt == 1: rightestVtx = getSidestVtx(rightVtxDic) cmds.select(rightestVtx, r = True) mel.eval('PolySelectConvert 1;') # Convert vertex selection to face. rightestFace = cmds.ls(sl = True, fl = True)[0] rightestFaceId = int(re.search(r'.+f\[(\d+)\]', rightestFace).group(1)) cmds.polySelect(extendToShell = rightestFaceId) cmds.delete() # mirror geometry mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, mergeMode = 0, mergeThreshold = 0.001, ch = True) cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0) # If user select '-x to x' mean right to left. if symOpt == 2: leftestVtx = getSidestVtx(leftVtxDic) cmds.select(leftestVtx, r = True) mel.eval('PolySelectConvert 1;') # Convert vertex selection to face. leftestFace = cmds.ls(sl = True, fl = True)[0] leftestFaceId = int(re.search(r'.+f\[(\d+)\]', leftestFace).group(1)) cmds.polySelect(extendToShell = leftestFaceId) cmds.delete() # mirror geometry mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, mergeMode = 0, mergeThreshold = 0.001, ch = True) cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0) # When user select object. else: objName = selLs[0] uvKeepGeo = cmds.duplicate(objName, n = '{0}_uvKeep_geo'.format(objName)) leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName) symOpt = cmds.radioButtonGrp('symOptRadButGrp', q = True, select = True) if centerVtxDic.keys(): cmds.select(centerVtxDic.keys(), r = True) mel.eval('SelectEdgeLoopSp;') tak_misc.zeroVtx() leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName) # Refresh vertex position information. # If user select 'x to -x' mean left to right. if symOpt == 1: cmds.select(rightVtxDic.keys(), r = True) mel.eval('PolySelectConvert 1;') # Convert vertex selection to face. cmds.delete() # mirror geometry mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, ch = True) cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0) # If user select 'x to -x' mean right to left. if symOpt == 2: cmds.select(leftVtxDic.keys(), r = True) mel.eval('PolySelectConvert 1;') # Convert vertex selection to face. cmds.delete() # mirror geometry mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, ch = True) cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0) leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName) if centerVtxDic.keys(): cmds.select(centerVtxDic.keys(), r = True) cmds.polyMergeVertex(distance = 0.001) # Copy uv from uv keeped geometry to new symmetrized geometry. smpSpc = cmds.radioButtonGrp('symSmpSpcRdoBtn', q = True, select = True) if smpSpc == 2: smpSpc = 4 elif smpSpc == 3: smpSpc = 5 cmds.transferAttributes(uvKeepGeo, objName, transferUVs = 2, sampleSpace = smpSpc) # cmds.select(objName, r = True) # mel.eval("SoftPolyEdgeElements 1;") # cmds.select(objName, r = True) # mel.eval('polyNormalPerVertex -ufn true;') cmds.delete(objName, ch = True) cmds.delete(uvKeepGeo) cmds.select(objName, r = True)
CENTER_CRV = True EDGE_STEP = 7 # select startEdge, then endEdge selEdges = mc.ls(sl=1)[0:2] endEdgeUndo = mc.undoInfo(q=1, un=1) prefix = selEdges[0].split('[')[0] endEdgeIndex = int(endEdgeUndo.split('[')[1][:-2]) selEdgesIndex = [int(edgeName.split('[')[1][:-1]) for edgeName in selEdges] for eachEdge in selEdgesIndex: if eachEdge != endEdgeIndex: startEdgeIndex = eachEdge break edgeLoopIndices = mc.polySelect(elp=[startEdgeIndex, endEdgeIndex], ns=1) edgeLoop = ['%s[%d]' % (prefix, edgeIndex) for edgeIndex in edgeLoopIndices] if edgeLoopIndices[-1] == startEdgeIndex: edgeLoop.reverse() edgeLoopIndices.reverse() centerPositions = [] # loop through edges to store center positions for i in range(len(edgeLoop) - 1): currEdge = edgeLoop[i] currEdgeIndex = edgeLoopIndices[i] nextEdge = edgeLoop[i + 1] nextEdgeIndex = edgeLoopIndices[i + 1] currRing = mc.polySelect(er=currEdgeIndex, ns=1, ass=1)
def ES_TestCreate(): cmds.polySphere(n='Object001') cmds.polySelect('Object001', toggle=True, edgeLoop=180)