def polytube(self, p1_x, p1_y, p1_z, p2_x, p2_y, p2_z, p0_x, p0_y, p0_z, p1_r, p2_r, polys): for i in range(0, polys): inc = math.pi * 2.0 / polys p = self.get_point_given_dist([p0_x, p0_y, p0_z], [p1_x, p1_y, p1_z], p1_r) point1 = self.point_rotate_3d(p0_x, p0_y, p0_z, p1_x, p1_y, p1_z, p[0], p[1], p[2], -(inc * i) ) point2 = self.point_rotate_3d(p0_x, p0_y, p0_z, p1_x, p1_y, p1_z, p[0], p[1], p[2], -(inc * i + inc) ) p = self.get_point_given_dist([p1_x, p1_y, p1_z], [p2_x, p2_y, p2_z], p2_r) point3 = self.point_rotate_3d(p1_x, p1_y, p1_z, p2_x, p2_y, p2_z, p[0], p[1], p[2], -(inc * i) ) point4 = self.point_rotate_3d(p1_x, p1_y, p1_z, p2_x, p2_y, p2_z, p[0], p[1], p[2], -(inc * i + inc) ) cmds.polyCreateFacet(p=[point2, point1, point3, point4], name='treePart#')
def polytube(p1_x, p1_y, p1_z, p2_x, p2_y, p2_z, p1_r, p2_r, a1_x, a1_y, a1_z, a2_x, a2_y, a2_z, polys): for i in range(0, polys): inc = math.pi * 2 / polys # points are being repositioned before rotation point1 = get_rotations( p1_x + p1_r * math.cos(inc * i), # xyz of the point to be rotated p1_y, p1_z + p1_r * math.sin(inc * i), a1_x, a1_y, a1_z, # xyz angles of the rotation p1_x, p1_y, p1_z # axis of the rotation ) point2 = get_rotations(p1_x + p1_r * math.cos(inc * i + inc), p1_y, p1_z + p1_r * math.sin(inc * i + inc), a1_x, a1_y, a1_z, p1_x, p1_y, p1_z) point3 = get_rotations(p2_x + p2_r * math.cos(inc * i), p2_y, p2_z + p2_r * math.sin(inc * i), a2_x, a2_y, a2_z, p1_x, p1_y, p1_z) point4 = get_rotations(p2_x + p2_r * math.cos(inc * i + inc), p2_y, p2_z + p2_r * math.sin(inc * i + inc), a2_x, a2_y, a2_z, p1_x, p1_y, p1_z) cmds.polyCreateFacet(p=[point2, point1, point3, point4])
def create_orient_group(): #turn on track selection order if ( not mc.selectPref(trackSelectionOrder=1, q=1)): mc.selectPref(trackSelectionOrder=True) sel = mc.ls(orderedSelection=True) if(sel): ctrl = sel.pop() verts = sel print("verts: ", verts) if(len(verts)==3 or len(verts)==6): #create helper plane/s. Find normals helper_plane_01 = mc.polyCreateFacet( p=[mc.pointPosition(verts[0]), mc.pointPosition(verts[1]), mc.pointPosition(verts[2])] ) plane01_str_normal = mc.polyInfo(fn=1)[0].split() mc.delete(helper_plane_01) plane01_normal = (float(plane01_str_normal[2]), float(plane01_str_normal[3]), float(plane01_str_normal[4])) vectorN = om.MVector(plane01_normal[0], plane01_normal[1], plane01_normal[2]) if (len(verts)==6): helper_plane_02 = mc.polyCreateFacet( p=[mc.pointPosition(verts[3]), mc.pointPosition(verts[4]), mc.pointPosition(verts[5])] ) plane02_str_normal = mc.polyInfo(fn=1)[0].split() mc.delete(helper_plane_02) plane02_normal = (float(plane02_str_normal[2]), float(plane02_str_normal[3]), float(plane02_str_normal[4])) vectorT = om.MVector(plane02_normal[0], plane02_normal[1], plane02_normal[2]) else: # if only one plane is provided, find which one of the world axes is orthogonal to the normal if (vectorN*om.MVector(1,0,0) == 0): vectorT = om.MVector(1,0,0) elif (vectorN*om.MVector(0,1,0) == 0): vectorT = om.MVector(0,1,0) elif (vectorN*om.MVector(0,0,1) == 0): vectorT = om.MVector(0,0,1) else: #if none of the axes are aligned with a world axis, ask for more verts to define a 2nd plane warning_msg("No axes are aligned with a world axis. You'll need to select 6 vertices and then ctrl.") return #find 3rd vector vectorX = vectorN^vectorT #create orient grp with same pivot as ctrl then parent ctrl orientGrp = mc.group(n=str(ctrl).replace('_Ctrl', '_')+'orientGrp', em=1) constraint = mc.parentConstraint( ctrl, orientGrp) mc.delete(constraint) mc.parent(ctrl, orientGrp) #make rotation matrix from vectors #keep position and assign rotation matrix to orientGrp orientGrp_matrix = mc.xform(orientGrp,q=1, m=1) mc.xform(orientGrp, m=(vectorX.x, vectorX.y, vectorX.z, 0, vectorN.x, vectorN.y, vectorN.z, 0, vectorT.x, vectorT.y, vectorT.z, 0,orientGrp_matrix[12],orientGrp_matrix[13],orientGrp_matrix[14],orientGrp_matrix[15] )) #freeze transforms mc.makeIdentity(orientGrp, apply=1, t=1, n=0) else: warning_msg("Please select 3 or 6 vertices and then ctrl") return else: warning_msg("Please select 3 or 6 vertices and then ctrl") return
def setup_scene(): #manually create a simple tetrahedron p1 = cmds.polyCreateFacet(p=[(0, 0, 0), (1, 0, 0), (0, 0, 1)]) p2 = cmds.polyCreateFacet(p=[(0, 0, 0), (0, 1, 0), (1, 0, 0)]) p3 = cmds.polyCreateFacet(p=[(0, 0, 0), (0, 0, 1), (0, 1, 0)]) p4 = cmds.polyCreateFacet(p=[(0, 0, 1), (1, 0, 0), (0, 1, 0)]) cmds.polyMergeVertex(cmds.polyUnite(p1, p2, p3, p4, ch=0, name="cage"), ch=0) poly_map = [[ "cage.vtx[0]", [ ("cage.vtx[0]", "cage.vtx[2]", "cage.vtx[3]"), ("cage.vtx[0]", "cage.vtx[3]", "cage.vtx[1]"), ("cage.vtx[0]", "cage.vtx[1]", "cage.vtx[2]"), ] ], [ "cage.vtx[1]", [ ("cage.vtx[1]", "cage.vtx[0]", "cage.vtx[3]"), ("cage.vtx[1]", "cage.vtx[3]", "cage.vtx[2]"), ("cage.vtx[1]", "cage.vtx[2]", "cage.vtx[0]"), ] ], [ "cage.vtx[2]", [ ("cage.vtx[2]", "cage.vtx[3]", "cage.vtx[0]"), ("cage.vtx[2]", "cage.vtx[1]", "cage.vtx[3]"), ("cage.vtx[2]", "cage.vtx[0]", "cage.vtx[1]"), ] ], [ "cage.vtx[3]", [ ("cage.vtx[3]", "cage.vtx[2]", "cage.vtx[1]"), ("cage.vtx[3]", "cage.vtx[1]", "cage.vtx[0]"), ("cage.vtx[3]", "cage.vtx[0]", "cage.vtx[2]"), ] ]] #debug tetra """ for p in poly_map: tris = p[1] for t in tris: pnts = [] for vert in t: pnt = utils.pnt(vert) pnts.append([pnt.x, pnt.y, pnt.z]) cmds.polyCreateFacet(p=pnts) """ cage = MayaPolyWrapper(poly_map) loc = utils.loc([.1, .1, .1]) return cage, loc
def makeTetra(size): pointA = [0, 0, 0] pointB = [size, 0, 0] pointC = [size/2.0, 0, 0] # set the Z position for C pointC[2] = math.sqrt((size*size) - (size/2.0 * size/2.0)) pointE = [0, 0, 0] # average the A, B, and C to get E # first add all the values for i in range(0,3): pointE[i] += pointA[i] pointE[i] += pointB[i] pointE[i] += pointC[i] # now divide by 3 for i in range(0,3): pointE[i] = pointE[i] / 3.0 # start point D with the X and Z coordinates of point E pointD = [0, 0, 0] pointD[0] = pointE[0] pointD[2] = pointE[2] distanceAE = math.sqrt((pointE[0] * pointE[0]) + (pointE[2] * pointE[2])) # set the Y coordinate of point D pointD[1] = math.sqrt((size*size) - (distanceAE * distanceAE)) faces = [] faces.append(cmds.polyCreateFacet(p=[pointA, pointB, pointC], texture=1)) faces.append(cmds.polyCreateFacet(p=[pointA, pointD, pointB], texture=1)) faces.append(cmds.polyCreateFacet(p=[pointB, pointD, pointC], texture=1)) faces.append(cmds.polyCreateFacet(p=[pointC, pointD, pointA], texture=1)) cmds.select(faces[0], replace=True) for i in range(1, len(faces)): cmds.select(faces[i], add=True) obj = cmds.polyUnite() cmds.select(obj[0] + ".vtx[:]") cmds.polyMergeVertex(distance=0.0001) cmds.select(obj[0]) cmds.move(-pointE[0], 0, -pointE[2]) cmds.xform(pivots=(pointE[0], 0, pointE[2])) cmds.makeIdentity(apply=True) cmds.delete(ch=True)
def generate(pts): """Takes in a list of tuples (set of 3D points) and generates a polygon model""" cmds.polyCreateFacet(name="shirt", p=points) cmds.polyTriangulate() cmds.polyQuad(angle=90) cmds.polySubdivideFacet(dv=SUBDIVISIONS) cmds.polyTriangulate() # Center shirt on origin centerX = cmds.objectCenter("shirt", x = True, gl = True) centerY = cmds.objectCenter("shirt", y = True, gl = True) centerZ = cmds.objectCenter("shirt", z = True, gl = True) cmds.move(-centerX, -centerY, -centerZ, "shirt", absolute=True)
def generate(pts): """Takes in a list of tuples (set of 3D points) and generates a polygon model""" cmds.polyCreateFacet(name="shirt", p=points) cmds.polyTriangulate() cmds.polyQuad(angle=90) cmds.polySubdivideFacet(dv=SUBDIVISIONS) cmds.polyTriangulate() # Center shirt on origin centerX = cmds.objectCenter("shirt", x=True, gl=True) centerY = cmds.objectCenter("shirt", y=True, gl=True) centerZ = cmds.objectCenter("shirt", z=True, gl=True) cmds.move(-centerX, -centerY, -centerZ, "shirt", absolute=True)
def buildPoly(polyName, polyVtx1, polyVtx2, polyVtx3, polyVtx4): print('attempting to build poly') print(polyName) print(polyVtx1) print(polyVtx2) print(polyVtx3) print(polyVtx4) cmds.polyCreateFacet(p=[(polyVtx1[0], polyVtx1[1], polyVtx1[2]), (polyVtx2[0], polyVtx2[1], polyVtx2[2]), (polyVtx3[0], polyVtx3[1], polyVtx3[2]), (polyVtx4[0], polyVtx4[1], polyVtx4[2])], name=polyName) cmds.parent(polyName, 'bridgePolys_grp')
def mainFunc(self): original_height = float(self.float_height.value()) #define values verts = cmds.ls(os = True) verts_pos = cmds.xform(verts, q=True, ws = True, t = True) v0 = cmds.xform(verts[0], q=True, ws = True, t = True) v1 = cmds.xform(verts[1], q=True, ws = True, t = True) v2 = cmds.xform(verts[2], q=True, ws = True, t = True) v3 = cmds.xform(verts[3], q=True, ws = True, t = True) print v0, v1, v2, v3 """not using numpy """ cp_x = (v0[0]+v1[0]+v2[0]+v3[0])/4 cp_y = (v0[1]+v1[1]+v2[1]+v3[1])/4 cp_z = (v0[2]+v1[2]+v2[2]+v3[2])/4 cp = [cp_x, cp_y, cp_z] """ using numpy verts_pos = np.reshape(np.array(verts_pos), (len(verts_pos)/3,3)) cp = np.average(verts_pos, axis = 0) """ object = verts[0].split('.vtx')[0] plane = 'bottom_plane' #create plane for alignment cmds.polyCreateFacet(p =(v0,v1,v2,v3), n = plane) self.movePivot(cp, object) self.movePivot(cp, plane) cmds.parent(object, plane) cmds.move(-cp[0],-cp[1],-cp[2], plane) self.align_plane(plane) #clean up the aid objects cmds.parent(plane + '|' + object, world = True) #cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=2) cmds.delete(plane) cmds.delete('locator_center') cmds.delete('locator_normal_aim') cmds.delete('locator_for_z') bb = cmds.exactWorldBoundingBox() height = bb[4] - bb[1] print height s = original_height/height print s cmds.scale(s,s,s, object)
def pointFaceMesh(pointList, scale=0.05, combine=True, prefix='pointFace'): ''' ''' # Get encoded point list ptList = [] for point in pointList: ptList.append(glTools.utils.base.getPosition(point)) # Create face for each point faceList = [] vscale = scale * 0.5 hscale = scale * 0.866 for pt in ptList: face = mc.polyCreateFacet( p=[(pt[0], pt[1] + scale, pt[2]), (pt[0] + hscale, pt[1] - vscale, pt[2]), (pt[0] - hscale, pt[1] - vscale, pt[2])])[0] faceList.append(face) # Combine faces to single mesh if combine: mesh = mc.polyUnite(faceList, ch=False) mesh = mc.rename(mesh[0], prefix + '_mesh') # Return result return mesh
def axisPanelCreate(self , planeName , cur , axis): CurveEps = mc.ls(cur + '.ep[:]',fl = True) CurveCvs = mc.ls(cur + '.cv[:]',fl = True) cvworlds = [] if axis == 'auto': for i in range(len(CurveCvs)): cv = CurveCvs[i] cvworld = mc.xform(cv,q = True,ws = True,t = True) cvworlds.append(cvworld) axisFacet = mc.polyCreateFacet(p = cvworlds,ch = False,name = planeName + '_axis_Facet')[0] else: curOffsetGrp = mc.group(em = True,name = planeName + '_axisPanelOffset') curOffsetZero = mc.group(curOffsetGrp,name = curOffsetGrp + '_zero') axisCurve01 = mc.duplicate(cur)[0] axisCurve02 = mc.duplicate(cur)[0] mc.parent(axisCurve01,curOffsetGrp) mc.setAttr(curOffsetGrp + '.t' + axis,1) mc.parent(axisCurve01,w = True) mc.parent(axisCurve02,curOffsetGrp) mc.setAttr(curOffsetGrp + '.t' + axis,0) mc.parent(axisCurve02,w = True) axisFacet = mc.loft(axisCurve01,axisCurve02,ch = 1,u = 1,c = 0,ar = 1,d = 3,ss = 1,rn = 0,po = 1,rsn = True,name = planeName + '_axis_Facet')[0] mc.select(axisFacet) mc.DeleteHistory() mc.setAttr(curOffsetGrp + '.t' + axis,1) mc.delete(curOffsetZero,axisCurve01,axisCurve02) return axisFacet
def polytube(p1_x, p1_y, p1_z, p2_x, p2_y, p2_z, p0_x, p0_y, p0_z, p1_r, p2_r, polys): for i in range(0, polys): inc = math.pi * 2.0 / polys # points are being repositioned before rotation point1 = PointRotate3D(p0_x, p0_y, p0_z, p1_x, p1_y, p1_z, p1_x + p1_r, p1_y, p1_z, -(inc * i)) point2 = PointRotate3D(p0_x, p0_y, p0_z, p1_x, p1_y, p1_z, p1_x + p1_r, p1_y, p1_z, -(inc * i + inc)) point3 = PointRotate3D(p1_x, p1_y, p1_z, p2_x, p2_y, p2_z, p2_x + p2_r, p2_y, p2_z, -(inc * i)) point4 = PointRotate3D(p1_x, p1_y, p1_z, p2_x, p2_y, p2_z, p2_x + p2_r, p2_y, p2_z, -(inc * i + inc)) cmds.polyCreateFacet(p=[point2, point1, point3, point4])
def pointFaceMesh(pointList,scale=0.05,combine=True,prefix='pointFace'): ''' ''' # Get encoded point list ptList = [] for point in pointList: ptList.append(glTools.utils.base.getPosition(point)) # Create face for each point faceList = [] vscale = scale * 0.5 hscale = scale * 0.866 for pt in ptList: face = mc.polyCreateFacet(p=[(pt[0],pt[1]+scale,pt[2]),(pt[0]+hscale,pt[1]-vscale,pt[2]),(pt[0]-hscale,pt[1]-vscale,pt[2])])[0] face = mc.rename(face,prefix+'_mesh') faceList.append(face) # Define return list mesh = faceList # Combine faces to single mesh if combine: mesh = mc.polyUnite(faceList,ch=False) mesh = [mc.rename(mesh[0],prefix+'_mesh')] # Return result return mesh
def makePlane(*args): points = [] cmds.polyCreateFacetCtx(pc=False) sel = cmds.ls(sl=True, type="transform") for obj in sel: loc = cmds.pointPosition((obj + ".rotatePivot"), world=True) points.append(loc) poly = cmds.polyCreateFacet(p=points)
def surfaceToHairGroup(curve_num = 4): select_surfaces = mc.ls(sl = True) for mesh in select_surfaces: v_range = mc.getAttr('%s.mmv' % mesh)[0] v_step = v_range[1] / (curve_num - 1) # create curves curves = [] for i in range(curve_num): d_curve = mc.duplicateCurve('%s.v[%f]' % (mesh, (i * v_step)), ch = True, rn = False, local = False)[0] curves.append(d_curve) # create polygon p = [] for curve in curves: p.append(mc.xform('%s.cv[0]' % curve, q = True, t = True)) mc.polyCreateFacet(p = p)
def setup_scene(): #manually create a simple tetrahedron p1 = cmds.polyCreateFacet(p=[(0,0,0), (1,0,0), (0,0,1)]) p2 = cmds.polyCreateFacet(p=[(0,0,0), (0,1,0), (1,0,0)]) p3 = cmds.polyCreateFacet(p=[(0,0,0), (0,0,1), (0,1,0)]) p4 = cmds.polyCreateFacet(p=[(0,0,1), (1,0,0), (0,1,0)]) cmds.polyMergeVertex(cmds.polyUnite(p1,p2,p3,p4, ch=0, name = "cage"), ch=0) poly_map =[ ["cage.vtx[0]", [ ("cage.vtx[0]","cage.vtx[2]","cage.vtx[3]"), ("cage.vtx[0]","cage.vtx[3]","cage.vtx[1]"), ("cage.vtx[0]","cage.vtx[1]","cage.vtx[2]"), ] ], ["cage.vtx[1]", [ ("cage.vtx[1]","cage.vtx[0]","cage.vtx[3]"), ("cage.vtx[1]","cage.vtx[3]","cage.vtx[2]"), ("cage.vtx[1]","cage.vtx[2]","cage.vtx[0]"), ] ], ["cage.vtx[2]", [ ("cage.vtx[2]","cage.vtx[3]","cage.vtx[0]"), ("cage.vtx[2]","cage.vtx[1]","cage.vtx[3]"), ("cage.vtx[2]","cage.vtx[0]","cage.vtx[1]"), ] ], ["cage.vtx[3]", [ ("cage.vtx[3]","cage.vtx[2]","cage.vtx[1]"), ("cage.vtx[3]","cage.vtx[1]","cage.vtx[0]"), ("cage.vtx[3]","cage.vtx[0]","cage.vtx[2]"), ] ] ] #debug tetra """ for p in poly_map: tris = p[1] for t in tris: pnts = [] for vert in t: pnt = utils.pnt(vert) pnts.append([pnt.x, pnt.y, pnt.z]) cmds.polyCreateFacet(p=pnts) """ cage = MayaPolyWrapper(poly_map) loc = utils.loc([.1,.1,.1]) return cage, loc
def edo_setTriangleView(obj,vtx=[0,1,2]): #obj='O_002' if cmds.objExists('TRIANGLEVIWE_'+obj): cmds.delete('TRIANGLEVIWE_'+obj) Ttriangle=[cmds.xform(obj+'.vtx['+str(vtx[0])+']',q=1,ws=1,t=1),cmds.xform(obj+'.vtx['+str(vtx[1])+']',q=1,ws=1,t=1),cmds.xform(obj+'.vtx['+str(vtx[2])+']',q=1,ws=1,t=1)] vm=cmds.polyCreateFacet(n='TRIANGLEVIWE_'+obj,ch=1,tx=1,s=1,p=Ttriangle) cmds.parent(vm[0],obj) cmds.delete(vm[1]) cmds.polyColorPerVertex(vm[0],r=1,g=1,b=0,a=1,cdo=1) return vm[0]
def debugIKPlane(self, index): if cmds.objExists("DebugPlane"): cmds.delete("DebugPlane") planePoint = [] for Joint in self.IKGroups[index]: planePoint.append( cmds.xform(Joint, query=True, worldSpace=True, translation=True)) cmds.polyCreateFacet(name="DebugPlane", point=planePoint) shadeGroup = cmds.listConnections("DebugPlaneShape", type="shadingEngine") listConnected = cmds.listConnections(shadeGroup) material = cmds.ls(listConnected, materials=True)[0] cmds.setAttr(material + ".ambientColor", 0, 1, 0, 0) cmds.setAttr(material + ".transparency", 0.7, 0.7, 0.7, 0.7) cmds.setAttr("DebugPlane.overrideEnabled", 1) cmds.setAttr("DebugPlane.overrideDisplayType", 2)
def maya_mel_make_poly_geometry(mesh, verbose=False): first_triangle = True used = [False for _ in mesh.vertices] for triangle in mesh.triangles: i = triangle[0] j = triangle[1] k = triangle[2] pi = mesh.vertices[i] pj = mesh.vertices[j] pk = mesh.vertices[k] pattern = int(used[k]) << 2 | int(used[j]) << 1 | int(used[i]) << 0 if pattern == 0: if first_triangle: cmds.polyCreateFacet(constructionHistory=False, p=[pi, pj, pk], name=mesh.name) first_triangle = False else: cmds.polyAppendVertex(constructionHistory=False, a=[pi, pj, pk]) elif pattern == 1: cmds.polyAppendVertex(constructionHistory=False, a=[i, pj, pk]) elif pattern == 2: cmds.polyAppendVertex(constructionHistory=False, a=[pi, j, pk]) elif pattern == 3: cmds.polyAppendVertex(constructionHistory=False, a=[i, j, pk]) elif pattern == 4: cmds.polyAppendVertex(constructionHistory=False, a=[pi, pj, k]) elif pattern == 5: cmds.polyAppendVertex(constructionHistory=False, a=[i, pj, k]) elif pattern == 6: cmds.polyAppendVertex(constructionHistory=False, a=[pi, j, k]) elif pattern == 7: cmds.polyAppendVertex(constructionHistory=False, a=[i, j, k]) else: raise RuntimeError('Internal error, illegal pattern value detected') used[i] = True used[j] = True used[k] = True cmds.polySetToFaceNormal() if verbose: print 'Created maya poly mesh of', mesh.name
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 fn_createObject_PolyCreate(): global importedObj objList = [] for p in range(0, len(importedObj.polys), 1): facelist = [] for v in range(0, len(importedObj.polys[p]), 1): pVert = importedObj.vertices[importedObj.polys[p][v]] facelist.append(pVert) objList.append((cmds.polyCreateFacet(p=facelist, ch=False))[0]) cmds.polyUnite(objList, ch=False, n=importObjectName)
def build(self, file): print "start to build" osm = pooper.data() osm.castData(file) osm.freezePoints(100000) ct = 0 pro = self.progressBar(len(osm.buildings), 100) for key, val in osm.buildings.items(): if ct in pro: self.valueUpdated.emit(pro[ct]) ct += 1 if val.type and val.type.startswith("build"): tPoint = self.ps2tuple(osm.points, val.pID) if len(tPoint) <= 2: continue bid = "b" + str(key) cmds.polyCreateFacet(p=tPoint, n=bid) if cmds.polyInfo(fn=True)[0].split(' ')[-2][0] == "-": cmds.polyNormal(nm=0) if val.height: cmds.select(bid) cmds.xform(cp=True) cmds.polyExtrudeFacet(kft=False, ltz=val.height) elif len(val.pID) >= 3 and val.pID[0] == val.pID[-1]: tPoint = self.ps2tuple(osm.points, val.pID) if len(tPoint) <= 2: continue bid = "b" + str(key) cmds.polyCreateFacet(p=tPoint, n=bid) if cmds.polyInfo(fn=True)[0].split(' ')[-2][0] == "-": cmds.polyNormal(nm=0) if val.height: cmds.select(bid) cmds.xform(cp=True) cmds.polyExtrudeFacet(kft=False, ltz=val.height) elif "boundary" in val.tags: tPoint = self.ps2tuple(osm.points, val.pID) if len(tPoint) <= 2: continue cmds.curve(p=tPoint, d=1)
def get_normal(self): dplane = None if (".f[" in self.components[0]): face_verts = mc.polyListComponentConversion(self.components, ff=True, tv=True) verts = mc.ls(face_verts, fl=1) dplane = mc.polyCreateFacet(p=[ mc.pointPosition(verts[0]), mc.pointPosition(verts[1]), mc.pointPosition(verts[2]) ]) else: dplane = mc.polyCreateFacet(p=[ mc.pointPosition(self.components[0]), mc.pointPosition(self.components[1]), mc.pointPosition(self.components[2]) ]) str_normal = mc.polyInfo(dplane, fn=1)[0].split() mc.delete(dplane) normal_vector = om.MVector(float(str_normal[2]), float(str_normal[3]), float(str_normal[4])) normal_vector.normalize() return normal_vector
def transformFaceMesh(transformList, faceAxis='y', scale=0.05, combine=True, prefix='transformFace'): """ @param transformList: @param faceAxis: @param scale: @param combine: @param prefix: """ # Checks faceAxis = faceAxis.lower() if not ['x', 'y', 'z'].count(faceAxis): raise Exception('Invalid axis "' + faceAxis + '"! Enter "x", "y" or "z".') # Define face vertex list if faceAxis == 'x': vtxList = [OpenMaya.MPoint(0, -scale, scale, 1), OpenMaya.MPoint(0, scale, scale, 1), OpenMaya.MPoint(0, scale, -scale, 1), OpenMaya.MPoint(0, -scale, -scale, 1)] elif faceAxis == 'y': vtxList = [OpenMaya.MPoint(-scale, 0, scale, 1), OpenMaya.MPoint(scale, 0, scale, 1), OpenMaya.MPoint(scale, 0, -scale, 1), OpenMaya.MPoint(-scale, 0, -scale, 1)] elif faceAxis == 'z': vtxList = [OpenMaya.MPoint(-scale, scale, 0, 1), OpenMaya.MPoint(scale, scale, 0, 1), OpenMaya.MPoint(scale, -scale, 0, 1), OpenMaya.MPoint(-scale, -scale, 0, 1)] # Create face for each transform faceList = [] for i in range(len(transformList)): # Get world space matrix tMatrix = glTools.utils.transform.getMatrix(transformList[i]) # Create face vtx = [v * tMatrix for v in vtxList] pts = [(vtx[0][0], vtx[0][1], vtx[0][2]), (vtx[1][0], vtx[1][1], vtx[1][2]), (vtx[2][0], vtx[2][1], vtx[2][2]), (vtx[3][0], vtx[3][1], vtx[3][2])] face = cmds.polyCreateFacet(p=pts)[0] face = cmds.rename(face, prefix + '_' + str(i) + '_mesh') faceList.append(face) # Define return list mesh = faceList # Combine faces to single mesh if combine: mesh = cmds.polyUnite(faceList, ch=False) mesh = [cmds.rename(mesh[0], prefix + '_mesh')] # Return result return mesh
def ruCreateLocator(args): selection = mc.ls(sl=True) vertices = mc.polyListComponentConversion(selection,tv=True) verticesPos = mc.xform(q=True, ws=True, translation=True ) temp = [] for i in range(0,len(verticesPos),3): temp.append((verticesPos[i],verticesPos[i+1],verticesPos[i+2])) tempFace = mc.polyCreateFacet(p=temp) mc.xform(cp=True) tempFacePivotPos = mc.xform(q=True, ws=True, rp = True) nameLoc = mc.spaceLocator(name="jointHolder",position=(tempFacePivotPos[0],tempFacePivotPos[1],tempFacePivotPos[2])) mc.xform(nameLoc, cp = True) mc.delete(tempFace) mc.select(clear=True)
def create_plane(self , planeName , CvNumOfSpans , cur): selCurve = mc.rebuildCurve(cur,ch=1,rpo=0,rt=0,end=1,kr=0,kcp=0,kep=0,kt=0,s=CvNumOfSpans,d=3,tol=0.01)[0] mc.select(selCurve) mc.DeleteHistory() CurveEps = mc.ls(selCurve + '.ep[:]',fl = True) worlds = [] txs = [] tys = [] tzs = [] jnts = [] for ep in CurveEps: world = mc.xform(ep,q = True,ws = True,t = True) mc.select(cl = True) jnt = mc.joint(p = world) worlds.append(world) tx = ('%.3f'%world[0]) ty = ('%.3f'%world[0]) tz = ('%.3f'% world[0]) jnts.append(jnt) #print txs,tys,tzs mc.select(cl = True) axisLocateJnt = mc.joint(name = planeName + 'axisLocateJnt') #mc.group() mc.delete(mc.parentConstraint(jnts,axisLocateJnt,mo = False)) Facet = mc.polyCreateFacet(p = worlds,ch = False)[0] FacetShape = mc.listRelatives(Facet,s = True)[0] UV = self.closestPointOnModel(FacetShape,axisLocateJnt) U = UV[0] V = UV[1] follic = self.follicCreate(FacetShape,planeName,U,V) offsetGrp = mc.group(em = True,name = planeName + '_cv_offset') offsetZero = mc.group(offsetGrp,name = offsetGrp + '_zero') mc.delete(mc.parentConstraint(follic,offsetZero,mo = False)) Curve01 = mc.duplicate(selCurve)[0] Curve02 = mc.duplicate(selCurve)[0] mc.parent(Curve01,offsetGrp) mc.setAttr(offsetGrp + '.tz',1) mc.parent(Curve01,w = True) mc.parent(Curve02,offsetGrp) mc.setAttr(offsetGrp + '.tz',0) mc.parent(Curve02,w = True) mc.delete(jnts,axisLocateJnt,Facet,follic,offsetZero) Plane = mc.loft(Curve01,Curve02,ch = True,u = True,c = False,ar = True,d = 3,ss = True,rn = False,po = False,rsn = True,name = planeName) mc.select(Plane) mc.DeleteHistory() mc.delete(selCurve,Curve01,Curve02) return Plane
def buildMesh(mesh): """ builds the ModlMesh mesh in scene """ meshes = [] for face in mesh.faces: verts = [mesh.vertices[i] for i in face.vertex_indices] newMesh = cmds.polyCreateFacet(p=verts, ch=False)[0] # Apply vertex normals # for i,orig_i in enumerate(face.vertex_indices): # vertNormal = mesh.vertex_normals[orig_i] # cmds.select( newMesh+'.vtxFace[0][%d]'%i, r=True ) # cmds.polyNormalPerVertex(xyz=vertNormal) meshes.append(newMesh) finalMesh = cmds.polyUnite(*meshes, ch=False, name=mesh.name) return finalMesh
def interactive_plane( aJnt ): try: bJnt = cmds.listRelatives( aJnt, children = True, type = 'joint' )[0] except TypeError: raise RuntimeError( 'You must pass a joint as the parent, %s doesn\'t seem to be a joint.' % hierarchy_parent ) cJnt = cmds.listRelatives( bJnt, children = True, type = 'joint' )[0] aPos, bPos, cPos = cmds.xform( aJnt, ws = True, q = True, t = True), cmds.xform( bJnt, ws=True, q=True, t=True ), cmds.xform( cJnt, ws=True, q=True, t=True ) aVec, bVec, cVec = om.MVector( aPos ), om.MVector( bPos ), om.MVector( cPos ) polyFacet = cmds.polyCreateFacet( ch=True, tx=True, p=[aVec, bVec, cVec] )[0] plane = cmds.plane( s=10, p=[(aVec.x + bVec.x + cVec.x)/3, (aVec.y+bVec.y+cVec.y)/3, (aVec.z+bVec.z+cVec.z)/3] ) cmds.delete( cmds.normalConstraint( polyFacet, plane, aimVector=[0,0,1], upVector=[0,1,0] ) ) return polyFacet
def build(self): """ Build the osm file """ print 'Building' # first get a group to put everything in bld_group = '_buildings' if not cmds.ls(bld_group): cmds.group(empty=True, n=bld_group) # create a something to store the number of the building we are on num_buildings = 0 # go through our ways and find the buildings for way in self.ways: if 'building' in way.tags: positions = [] for node_id in way.nodes: node = self.nodes[node_id] pos_xy = self.get_relative_coordinates( [float(node.lat), float(node.lon)]) positions.append((pos_xy[0], pos_xy[1], 0)) building = cmds.polyCreateFacet(p=positions) centre_pos = self.get_centre_pos(positions) cmds.xform(building[0], ws=True, piv=centre_pos) # make sure all the vertices have the correct normals for i in range(cmds.polyEvaluate(building[0], vertex=True)): cmds.select('{}.vtx[{}]'.format(building[0], i)) cmds.polyNormalPerVertex(xyz=(0, 0, 1)) new_building = cmds.rename( building[0], 'building_{0:03d}'.format(num_buildings + 1)) cmds.parent(new_building, bld_group) num_buildings += 1 print 'Build {} buildings!'.format(num_buildings)
def off_translation(filename): print("Debut du parsing") f = open(filename, 'r') # On passe les lignes inutiles line = f.readline() line = f.readline() if line[0] == '#': line = f.readline() if line[0] == '#': line = f.readline() # On considere la ligne comme une liste de string separes par des espaces line = line.split(' ') nb_vert = int(line[0]) nb_faces = int(line[1]) list_vert = [] list_faces = [] # On remplit la liste des sommets for i in range(0, nb_vert): line = f.readline() line = line.split(' ') coord = [float(line[0]), float(line[1]), float(line[2])] list_vert.append(coord) line = f.readline() line = line.split(' ') # On remplit la liste des faces for i in range(0, nb_faces): index1, index2, index3 = int(line[1]), int(line[2]), int(line[3]) points = [list_vert[index1], list_vert[index2], list_vert[index3]] list_faces.append(points) line = f.readline() line = line.split(' ') f.close() print("Parsing fini, debut de la creation du maillage") print(list_faces[0]) # print(list_faces[1]) obj = cm.polyCreateFacet(ch=False, p=list_faces[0]) cm.select(obj) for i in range(1, nb_faces): cm.polyAppendVertex(a=list_faces[i]) print("Maillage cree")
def createPolygon(self, tis, *a): self.executeCondition() tis = cmds.treeView('tree_apsbPL', q=1, children=1) # tree items if len(tis) < 3: cmds.warning('Position List most more than 3.') return 0 sl = cmds.ls(selection=1) cpl = [] # created polygon name list for mn in sl: # mesh name if (cmds.nodeType(mn) == 'transform'): c = cmds.listRelatives(mn, shapes=1, noIntermediate=1) if (len(c) == 0): cmds.warning('Selection most be polygon.') else: mn = c[0] elif (cmds.nodeType(mn) == 'mesh'): mns = mn.split('.') if len(mns) > 1: mn = mns[0] else: cmds.warning('Selection most be polygon.') pl = [] # position list for ti in tis: # tree item xList = ti.split(',') xx = 0.0 xy = 0.0 xz = 0.0 for sti in xList: # splited tree item vn = mn + '.' + sti # vertex name if cmds.objExists(vn): yPos = cmds.xform(vn, q=1, translation=1, worldSpace=1) xx = xx + yPos[0] xy = xy + yPos[1] xz = xz + yPos[2] xx = xx / len(xList) xy = xy / len(xList) xz = xz / len(xList) pl.append([xx, xy, xz]) cpl.append(cmds.polyCreateFacet(point=[pl[0], pl[1], pl[2]])[0]) for i in range(3, len(tis)): cmds.polyAppendVertex(a=[i - 2, i - 1, pl[i]]) cmds.select(cpl, replace=1)
def createPolyFromPosList(posList): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Creates a poly from position list ARGUMENTS: posList(string) - list of positions RETURNS: Nothin >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ polyBuffer = mc.polyCreateFacet(p = posList,hole = False) newFaceVerts = (mc.ls ([polyBuffer[0]+'.vtx[*]'],flatten=True)) for vert in newFaceVerts: cnt = newFaceVerts.index(vert) pos = posList[cnt] mc.xform(vert,t = [pos[0],pos[1],pos[2]],ws=True) return polyBuffer[0]
def createPolyFromPosList(posList): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Creates a poly from position list ARGUMENTS: posList(string) - list of positions RETURNS: Nothin >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ polyBuffer = mc.polyCreateFacet(p=posList, hole=False) newFaceVerts = (mc.ls([polyBuffer[0] + '.vtx[*]'], flatten=True)) for vert in newFaceVerts: cnt = newFaceVerts.index(vert) pos = posList[cnt] mc.xform(vert, t=[pos[0], pos[1], pos[2]], ws=True) return polyBuffer[0]
def makeFaceWithHole(): points = [] # create the inital square points.append((-5, -5, 0)) points.append((5, -5, 0)) points.append((5, 5, 0)) points.append((-5, 5, 0)) # add empty point to start a hole points.append(()) for i in range(32): theta = (math.pi * 2) / 32 * i x = math.cos(theta) * 2 y = math.sin(theta) * 2 points.append((x, y, 0)) newFace = cmds.polyCreateFacet(p=points)
def jntChainPlane(cls, jntLs): ''' Create a plane conform to joint chain. ''' # Get start, mid, end joint. startJnt = jntLs[0] midJnt = jntLs[int(len(jntLs) / 2)] endJnt = jntLs[-1] # Get world position of joints. startJntPos = cmds.xform(startJnt, q=True, t=True, ws=True) midJntPos = cmds.xform(midJnt, q=True, t=True, ws=True) endJntPos = cmds.xform(endJnt, q=True, t=True, ws=True) # Create a plane. plane = cmds.polyCreateFacet(n='jntUpVecPlane_geo', p=[startJntPos, midJntPos, endJntPos])[0] return plane
def makeFaceWithHole(): points = [] # Create the initial square points.append((-5, -5, 0)) points.append((5, -5, 0)) points.append((5, 5, 0)) points.append((-5, 5, 0)) # Add empty point to start a hole points.append(()) for i in range(32): theta = (math.pi * 2) / 32 * i x = math.cos(theta) y = math.sin(theta) points.append((2 * x, 2 * y, 0)) newFace = cmds.polyCreateFacet(p=points) cmds.polyTriangulate() cmds.polyQuad() # Generally doesn't hurt anything
def positionPoleVectorControl(startJoint, endJoint, poleVectorNode, distance): """NOTE: If each joint in your chain has more than 1 joint, make sure the joint that will be part of the IK chain, are the first children, otherwise you will get bad results.""" #figure out all the joints between startJoint and endJoint jointChainList = [] jointChainList.append(startJoint) j = 0 currentJoint = startJoint while j==0: currentJointChildren = cmds.listRelatives(currentJoint, c=1, type="joint") if len(currentJointChildren) > 1: cmds.warning("whoo, the specified start joint has more than 1 children, please choose another start joint") nextJoint = currentJointChildren[0] if nextJoint == endJoint: j=1 else: jointChainList.append(nextJoint) currentJoint = nextJoint jointChainList.append(endJoint) #get position in space of each joint so we can create the polygon coordinatesList = [] for j in jointChainList: jCoord = cmds.xform(j, q=1, ws=1, rp=1) coord = tuple(jCoord) coordinatesList.append(coord) polyPlane = cmds.polyCreateFacet( p=coordinatesList )[0] alignNodes(poleVectorNode, jointChainList[1]) cmds.delete(cmds.geometryConstraint(polyPlane, poleVectorNode)) cmds.delete(cmds.normalConstraint(polyPlane, poleVectorNode, upVector=[1, 0, 0], aimVector=[0, 0, 1])) cmds.xform(poleVectorNode, objectSpace=1, relative=1, t=[distance, distance, 0]) cmds.delete(polyPlane)
def convexHull(pointList): """ from maya import cmds import sys sys.path.insert(0, '/Users/jarlske/Documents/scripts/python/jm_maya/mesh/') import delaunay reload(delaunay) sel = cmds.ls(sl=1) pointList = [] for each in sel: vtxLen = cmds.polyEvaluate(each, vertex=1) for i in range(0, vtxLen): pointList.append(cmds.xform('{0}.vtx[{1}]'.format(each, str(i)), q=1, t=1 ,ws=1)) geo = delaunay.convexHull(pointList) """ points = numpy.array(pointList) hull = ConvexHull(points) facetList = [] for each in hull.simplices: indexList = each.tolist() xpoint = [ pointList[indexList[0]][0], pointList[indexList[0]][1], pointList[indexList[0]][2] ] ypoint = [ pointList[indexList[1]][0], pointList[indexList[1]][1], pointList[indexList[1]][2] ] zpoint = [ pointList[indexList[2]][0], pointList[indexList[2]][1], pointList[indexList[2]][2] ] facetList.append( cmds.polyCreateFacet(ch=False, p=[xpoint, ypoint, zpoint])[0]) poly = cmds.polyUnite(facetList, ch=False, mergeUVSets=True) cmds.polyMergeVertex(poly, ch=False) cmds.polyNormal(poly, normalMode=2, userNormalMode=0, ch=False) cmds.select(cl=True) return poly
def alignKneeVectors(self, *args): sides = ["_L_", "_R_"] for i in sides: kneeCon = cmds.ls(self.prefix + i + "Knee_Con") cmds.parent(kneeCon, w=True) heelPos = cmds.xform(cmds.ls(self.prefix + i + "INV_Heel_Jnt", type='joint'), q=True, t=True, ws=True) hipPos = cmds.xform(cmds.ls(self.prefix + i + "Hip_Jnt", type='joint'), q=True, t=True, ws=True) kneePos = cmds.xform(cmds.ls(self.prefix + i + "Knee_Jnt", type='joint'), q=True, t=True, ws=True) createPolyPoint = cmds.polyCreateFacet(p=[(hipPos), (kneePos), (heelPos)], ch=False) conPointConstraint = cmds.pointConstraint( cmds.ls(self.prefix + i + "Knee_Jnt", type='joint'), kneeCon) nConstraint = cmds.normalConstraint(createPolyPoint[0], kneeCon) cmds.delete(conPointConstraint) cmds.delete(nConstraint) cmds.delete(createPolyPoint) cmds.move(0, 0, 0.3 * self.conRadius, kneeCon, os=True, r=True)
def createSurface( self , name , side , modular , *point ): pointPos = [] clusterList = [] shaderName = name+side+modular+'surface_shader' for x in point: pos = self.getSpace(x,type='translate') pointPos.append(pos) # create surface. surfaceObj = mc.rename( mc.polyCreateFacet(p=pointPos)[0] , name+side+modular+'_surface') mc.setAttr(surfaceObj+'.overrideEnabled' , 1) mc.setAttr(surfaceObj+'.overrideDisplayType' , 2) if mc.objExists('worldPos_loc'): mc.parent(surfaceObj , 'worldPos_loc') else: pass mc.select(surfaceObj ) mel.eval('DeleteHistory') mc.setAttr(surfaceObj +'.inheritsTransform' , 0) mc.select(cl=1) # connect surface with points..... for i in range( len(pointPos) ): clusterObj = mc.rename( mc.cluster(surfaceObj+'.vtx[%s]'%(i) )[1] , name+side+modular+'_%scluster'%(i) ) mc.parent(clusterObj , point[i]) mc.setAttr(clusterObj+'.visibility' , 0) clusterList.append(clusterObj) #set surface shader. self.appointShader( name, side , modular , shaderName , surfaceObj ) mc.setAttr(shaderName +'.color' , 0.324643,0.686275,0.29604 , type='double3' , ) mc.setAttr(shaderName +'.transparency' , 0.422766 ,0.422766 ,0.422766 , type='double3' , ) return surfaceObj , clusterList
def lsOrientJointsToPlane(jntList, downVector=[1,0,0], normalVector=[0,0,1]): ''' arguments: jntList - [startJnt, midJnt, endJnt] downVector (optional) - vector that points to the child joint, defaults to +X normalVector (optional) - vector for axis of rotation, defaults to +Z todo: 1. options for orienting startJnt and endJnt when necessary 2. use API for calculating vectors, instead of creating arbitrary polys and constraints... though this should work for now... ''' # get joint positions startJntPos = mc.xform(jntList[0], q=1, ws=1, t=1) midJntPos = mc.xform(jntList[1], q=1, ws=1, t=1) endJntPos = mc.xform(jntList[2], q=1, ws=1, t=1) # create poly to act as rotate plane tempPoly = mc.polyCreateFacet(ch=0, p=[startJntPos, midJntPos, endJntPos], n="tempPoly_getNormal") # create locator to get normal vector tempLoc = mc.spaceLocator(n="tempLoc_getNormal")[0] mc.xform(tempLoc, ws=1, t=midJntPos) normalCons = mc.normalConstraint(tempPoly, tempLoc) # default: X-axis aligns with normal vector mc.delete(normalCons) # orient midJnt (jntList[1]) mc.move(1,0,0, tempLoc, os=1, r=1) mc.parent(jntList[2], w=1) aimCons = mc.aimConstraint(jntList[2], jntList[1], aim=downVector, u=normalVector, wuo=tempLoc, wut=2, wu=[1,0,0]) mc.delete(aimCons) mc.makeIdentity(jntList[1], a=1, r=1) mc.parent(jntList[2],jntList[1]) # cleanup mc.delete(tempPoly, tempLoc)
def fill_cylinder_with_guides(mesh, follicle_grid=4, pattern_shrink=0.0): vloops = mesh_utils.get_cylinder_vert_loops(mesh) first_vloop = vloops[0] #print first_vloop b_positions = [] for vl in first_vloop: b_positions.append( cmds.pointPosition( vl )) # I get an ordered array of positions to access later. tube_ordered_pos = [] for i,vert_loop in enumerate(vloops): tube_ordered_pos.append([]) for vid in vert_loop: #lx.out(vid) pos= cmds.pointPosition( vid ) tube_ordered_pos[i].extend(pos) #b_positions.extend(tube_ordered_pos[0]) root_disc = cmds.polyCreateFacet(ch=False, tx=1, s=1, p=b_positions) #print root_disc ### I will find the normal of the "face" described by the vertices in the first border/edgeloop # Create list of border Point(s) b_points = [] for bpos in b_positions: b_points.append(Point(bpos)) # Calculate average point av_point = Point() for pt in b_points: av_point = av_point+pt av_point.div_by_value(len(b_points)) #print av_point.get_list() # Calculate average normal t_normals = [] av_normal = Point() for i in range(len(b_points)): # Get triangle normal nm = get_triangle_normal(av_point, b_points[i] , b_points[(i+1)%len(b_points)]) t_normals.append(nm) for tn in t_normals: av_normal = av_normal+tn av_normal.div_by_value(len(b_points)) av_normal.normalize() #print av_normal.get_list() #cmds.create loc_nrm = cmds.spaceLocator(name='cylinder_base_nrm') cmds.xform(loc_nrm, ws=True, t=av_normal.get_list() ) loc_base = cmds.spaceLocator(name='cylinder_disc_rotator') ac = cmds.aimConstraint(loc_nrm[0], loc_base[0], mo=False, aimVector=[0,1,0], upVector=[0,1,0], worldUpType="scene" ) rot = cmds.xform(loc_base, q=True, ws=True, rotation=True) #print rot cmds.delete(ac) #cmds.delete(loc_base) cmds.delete(loc_nrm) # Move the cylinder base disc to the origin, and unrotate it # The disc will have the average point at [0,0,0], and its normal pointing Y av_pos = av_point.get_list() cmds.xform(root_disc, relative=True, t=[-av_pos[0], -av_pos[1], -av_pos[2]]) cmds.xform(root_disc, ws=True, absolute=True, rp=[0,0,0], sp=[0,0,0]) cmds.parent(root_disc, loc_base) cmds.xform(loc_base, ws=True, absolute=True, rotation=[0,0,0]) # Finally get the disc position on the xz plane n_disc_verts = cmds.polyEvaluate(root_disc, vertex=True) xz_disc_positions = cmds.xform('%s.vtx[0:%s]' % (root_disc[0],(n_disc_verts-1)), q=True, ws=True, t=True) ### CALCULATE BARICENTRIC COORDS unrot_bbox = cmds.exactWorldBoundingBox( root_disc[0] ) #print unrot_bbox # calculate the candidate curve roots (follicle) positions candidate_follicles= pattern_honeycomb_points(unrot_bbox, shrink=pattern_shrink, grid_size=follicle_grid) #DEBUG follicles ''' for fc in candidate_follicles: fol = cmds.spaceLocator() cmds.xform(fol, ws=True, t=fc) ''' # From now on, I have to test if the candidate follicle positions hit the triangles of the unrotated face # ...and retrieve thei baricentric coords # I assume that the baricenter of the unrotated face is ath the origin (0,0,0) n_triangles = len(first_vloop) # bc_coords will containa a list of list # every list will contain the bc coords for every triangle describig the section of a tube bcoords = [] for i in range(n_triangles): # I initialiaze the list for every triangle bcoords.append([]) for counter, cf in enumerate(candidate_follicles): # I test that my current candidate point is inside the unrotated face cf_pt = Point(cf) #print('Candidate follicle: %s | %s, %s, %s' % (counter, cf_pt.x, cf_pt.y, cf_pt.z)) for i in range(n_triangles): j = (i+1)%n_triangles # This ensure that the second vert will be 0 when i=n_triangles-1 first_vert_pt = Point(xz_disc_positions[i*3],xz_disc_positions[i*3+1],xz_disc_positions[i*3+2]) secnd_vert_pt = Point(xz_disc_positions[j*3],xz_disc_positions[j*3+1],xz_disc_positions[j*3+2]) u,v,w,hit_test = bc.point_in_a_triangle_test(cf_pt, first_vert_pt, secnd_vert_pt, Point(0.0,0.0,0.0)) if hit_test: bcoords[i].append([u,v,w]) #print('HIT TEST TRIANGLE %s | u:%s v:%s w:%s' % (i,u,v,w)) ###DEBUG HIT TEST #fol = cmds.spaceLocator() #cmds.xform(fol, ws=True, t=cf) break # I find the baricenters of every loop baricenters = [] for i in range(len(vloops)): baricenter = Point() for j in range(len(first_vloop)): xx=(tube_ordered_pos[i][j*3]) yy=(tube_ordered_pos[i][j*3+1]) zz=(tube_ordered_pos[i][j*3+2]) baricenter.add_point(Point(xx,yy,zz)) baricenter.div_by_value(float(len(first_vloop))) baricenters.append(baricenter.get_list()) # I fill the triangles with the curves, according the baricentric coords out_curves = [] for i in range(n_triangles): for uvw in bcoords[i]: curve_vert_pos = [] for j in range(len(vloops)): s = (i+1)%n_triangles first_vert_pt= Point(tube_ordered_pos[j][i*3], tube_ordered_pos[j][i*3+1], tube_ordered_pos[j][i*3+2]) secnd_vert_pt= Point(tube_ordered_pos[j][s*3], tube_ordered_pos[j][s*3+1], tube_ordered_pos[j][s*3+2]) third_vert_pt= Point(baricenters[j]) pos = bc.triangle_point_coords(first_vert_pt,secnd_vert_pt,third_vert_pt,uvw[0],uvw[1],uvw[2]).get_list() curve_vert_pos.append(pos) out_curves.append(curve_vert_pos) cmds.delete(loc_base) gen_curves = [] for ocp in out_curves: gen_crv = createCurve(2, ocp) gen_curves.append(gen_crv) # Group the curves curve_prefix_grp= mesh if "|" in mesh: curve_prefix_grp = curve_prefix_grp.rpartition('|')[2] cmds.group(gen_curves, name="%s_curves" % curve_prefix_grp) return(gen_curves)
""" Author: Jennifer Conley Date Modified: 9/10/11 Description: A script used to quickly create a plane for the correct placement of ik pv icons from a joint chain selection. How to run: import ik_pv reload (ik_pv) """ import maya.cmds as cmds cmds.select(hierarchy=True) sel = cmds.ls(sl=True) position_list = [] for each in sel: space = cmds.xform(each, q=True, t=True, ws=True) position_list.append(space) print position_list cmds.polyCreateFacet(ch=True, tx=1, s=1, p=position_list)
def pointSampleWeight(samplePt, pntList, weightCalc=[True, True, True], prefix=''): """ """ # Check prefix if not prefix: prefix = 'triSampleWeight' # Get tri points posList = [cmds.xform(pntList[0], q=True, ws=True, rp=True), cmds.xform(pntList[1], q=True, ws=True, rp=True), cmds.xform(pntList[2], q=True, ws=True, rp=True)] # Build pntFace mesh pntFace = cmds.polyCreateFacet(p=posList, n=prefix + '_sample_mesh')[0] cmds.setAttr(pntFace + '.inheritsTransform', 0, l=True) # Attach triPt locator to pntFace mesh pntLoc = glTools.utils.mesh.locatorMesh(pntFace, prefix=prefix) # Attach follow pt followLoc = cmds.spaceLocator(n=prefix + '_follow_locator')[0] followGeoCon = cmds.geometryConstraint(pntFace, followLoc) followPntCon = cmds.pointConstraint(samplePt, followLoc) # Calculate triArea triEdge1_pma = cmds.createNode('plusMinusAverage', n=prefix + '_triEdge1Vec_plusMinusAverage') triEdge2_pma = cmds.createNode('plusMinusAverage', n=prefix + '_triEdge2Vec_plusMinusAverage') cmds.setAttr(triEdge1_pma + '.operation', 2) # Subtract cmds.setAttr(triEdge2_pma + '.operation', 2) # Subtract cmds.connectAttr(pntLoc[1] + '.worldPosition[0]', triEdge1_pma + '.input3D[0]', f=True) cmds.connectAttr(pntLoc[0] + '.worldPosition[0]', triEdge1_pma + '.input3D[1]', f=True) cmds.connectAttr(pntLoc[2] + '.worldPosition[0]', triEdge2_pma + '.input3D[0]', f=True) cmds.connectAttr(pntLoc[0] + '.worldPosition[0]', triEdge2_pma + '.input3D[1]', f=True) triArea_vpn = cmds.createNode('vectorProduct', n=prefix + '_triArea_vectorProduct') cmds.setAttr(triArea_vpn + '.operation', 2) # Cross Product cmds.connectAttr(triEdge1_pma + '.output3D', triArea_vpn + '.input1', f=True) cmds.connectAttr(triEdge2_pma + '.output3D', triArea_vpn + '.input2', f=True) triArea_dist = cmds.createNode('distanceBetween', n=prefix + '_triArea_distanceBetween') cmds.connectAttr(triArea_vpn + '.output', triArea_dist + '.point1', f=True) # Calculate triPt weights for i in range(3): # Check weight calculation (bool) if weightCalc[i]: # Calculate triArea pntEdge1_pma = cmds.createNode('plusMinusAverage', n=prefix + '_pt' + str(i) + 'Edge1Vec_plusMinusAverage') pntEdge2_pma = cmds.createNode('plusMinusAverage', n=prefix + '_pt' + str(i) + 'Edge2Vec_plusMinusAverage') cmds.setAttr(pntEdge1_pma + '.operation', 2) # Subtract cmds.setAttr(pntEdge2_pma + '.operation', 2) # Subtract cmds.connectAttr(pntLoc[(i + 1) % 3] + '.worldPosition[0]', pntEdge1_pma + '.input3D[0]', f=True) cmds.connectAttr(followLoc + '.worldPosition[0]', pntEdge1_pma + '.input3D[1]', f=True) cmds.connectAttr(pntLoc[(i + 2) % 3] + '.worldPosition[0]', pntEdge2_pma + '.input3D[0]', f=True) cmds.connectAttr(followLoc + '.worldPosition[0]', pntEdge2_pma + '.input3D[1]', f=True) pntArea_vpn = cmds.createNode('vectorProduct', n=prefix + '_pt' + str(i) + 'Area_vectorProduct') cmds.setAttr(pntArea_vpn + '.operation', 2) # Cross Product cmds.connectAttr(pntEdge1_pma + '.output3D', pntArea_vpn + '.input1', f=True) cmds.connectAttr(pntEdge2_pma + '.output3D', pntArea_vpn + '.input2', f=True) pntArea_dist = cmds.createNode('distanceBetween', n=prefix + '_pt' + str(i) + 'Area_distanceBetween') cmds.connectAttr(pntArea_vpn + '.output', pntArea_dist + '.point1', f=True) # Divide ptArea by triArea to get weight pntWeight_mdn = cmds.createNode('multiplyDivide', n=prefix + '_pt' + str(i) + 'Weight_multiplyDivide') cmds.setAttr(pntWeight_mdn + '.operation', 2) # Divide cmds.connectAttr(pntArea_dist + '.distance', pntWeight_mdn + '.input1X', f=True) cmds.connectAttr(triArea_dist + '.distance', pntWeight_mdn + '.input2X', f=True) # Add weight attribute to pntLoc cmds.addAttr(pntLoc[i], ln='weight', min=0.0, max=1.0, dv=0.0) cmds.connectAttr(pntWeight_mdn + '.outputX', pntLoc[i] + '.weight', f=True) # Group mesh locators pntLoc_grp = cmds.group(pntLoc, n=prefix + '_3Point_grp') cmds.parent(pntFace, pntLoc_grp) # Return result return [pntLoc, pntFace, pntLoc_grp]
if len(cubeList) > 0: cmds.delete(cubeList) all_poly = [] for lst in buildings_xy: tmp = [] for i in lst[0]: (x, z) = i x /= -100 z /= 100 y = 0 tmp.append((x, y, z)) h = lst[1] res = cmds.polyCreateFacet(p=tmp, name='buildingpoly#') all_poly.append(res) thickness = random.uniform(0.1, 0.2) assert h >= 0 normals = cmds.polyInfo(res[0], fn=1) normal = float(normals[0].split(":")[1].split()[1]) # For reversed normals, Just redraw in anticlockwise if normal < 0: cmds.delete(res[0]) tmp.reverse() res = cmds.polyCreateFacet(p=tmp, name='buildingpoly#') normals = cmds.polyInfo(res[0], fn=1) normal = float(normals[0].split(":")[1].split()[1])
def pointSampleWeight(samplePt, pntList, weightCalc=[True, True, True], prefix=""): """ """ # Check prefix if not prefix: prefix = "triSampleWeight" # Get tri points posList = [ mc.xform(pntList[0], q=True, ws=True, rp=True), mc.xform(pntList[1], q=True, ws=True, rp=True), mc.xform(pntList[2], q=True, ws=True, rp=True), ] # Build pntFace mesh pntFace = mc.polyCreateFacet(p=posList, n=prefix + "_sample_mesh")[0] mc.setAttr(pntFace + ".inheritsTransform", 0, l=True) # Attach triPt locator to pntFace mesh pntLoc = glTools.utils.mesh.locatorMesh(pntFace, prefix=prefix) # Attach follow pt followLoc = mc.spaceLocator(n=prefix + "_follow_locator")[0] followGeoCon = mc.geometryConstraint(pntFace, followLoc) followPntCon = mc.pointConstraint(samplePt, followLoc) # Calculate triArea triEdge1_pma = mc.createNode("plusMinusAverage", n=prefix + "_triEdge1Vec_plusMinusAverage") triEdge2_pma = mc.createNode("plusMinusAverage", n=prefix + "_triEdge2Vec_plusMinusAverage") mc.setAttr(triEdge1_pma + ".operation", 2) # Subtract mc.setAttr(triEdge2_pma + ".operation", 2) # Subtract mc.connectAttr(pntLoc[1] + ".worldPosition[0]", triEdge1_pma + ".input3D[0]", f=True) mc.connectAttr(pntLoc[0] + ".worldPosition[0]", triEdge1_pma + ".input3D[1]", f=True) mc.connectAttr(pntLoc[2] + ".worldPosition[0]", triEdge2_pma + ".input3D[0]", f=True) mc.connectAttr(pntLoc[0] + ".worldPosition[0]", triEdge2_pma + ".input3D[1]", f=True) triArea_vpn = mc.createNode("vectorProduct", n=prefix + "_triArea_vectorProduct") mc.setAttr(triArea_vpn + ".operation", 2) # Cross Product mc.connectAttr(triEdge1_pma + ".output3D", triArea_vpn + ".input1", f=True) mc.connectAttr(triEdge2_pma + ".output3D", triArea_vpn + ".input2", f=True) triArea_dist = mc.createNode("distanceBetween", n=prefix + "_triArea_distanceBetween") mc.connectAttr(triArea_vpn + ".output", triArea_dist + ".point1", f=True) # Calculate triPt weights for i in range(3): # Check weight calculation (bool) if weightCalc[i]: # Calculate triArea pntEdge1_pma = mc.createNode("plusMinusAverage", n=prefix + "_pt" + str(i) + "Edge1Vec_plusMinusAverage") pntEdge2_pma = mc.createNode("plusMinusAverage", n=prefix + "_pt" + str(i) + "Edge2Vec_plusMinusAverage") mc.setAttr(pntEdge1_pma + ".operation", 2) # Subtract mc.setAttr(pntEdge2_pma + ".operation", 2) # Subtract mc.connectAttr(pntLoc[(i + 1) % 3] + ".worldPosition[0]", pntEdge1_pma + ".input3D[0]", f=True) mc.connectAttr(followLoc + ".worldPosition[0]", pntEdge1_pma + ".input3D[1]", f=True) mc.connectAttr(pntLoc[(i + 2) % 3] + ".worldPosition[0]", pntEdge2_pma + ".input3D[0]", f=True) mc.connectAttr(followLoc + ".worldPosition[0]", pntEdge2_pma + ".input3D[1]", f=True) pntArea_vpn = mc.createNode("vectorProduct", n=prefix + "_pt" + str(i) + "Area_vectorProduct") mc.setAttr(pntArea_vpn + ".operation", 2) # Cross Product mc.connectAttr(pntEdge1_pma + ".output3D", pntArea_vpn + ".input1", f=True) mc.connectAttr(pntEdge2_pma + ".output3D", pntArea_vpn + ".input2", f=True) pntArea_dist = mc.createNode("distanceBetween", n=prefix + "_pt" + str(i) + "Area_distanceBetween") mc.connectAttr(pntArea_vpn + ".output", pntArea_dist + ".point1", f=True) # Divide ptArea by triArea to get weight pntWeight_mdn = mc.createNode("multiplyDivide", n=prefix + "_pt" + str(i) + "Weight_multiplyDivide") mc.setAttr(pntWeight_mdn + ".operation", 2) # Divide mc.connectAttr(pntArea_dist + ".distance", pntWeight_mdn + ".input1X", f=True) mc.connectAttr(triArea_dist + ".distance", pntWeight_mdn + ".input2X", f=True) # Add weight attribute to pntLoc mc.addAttr(pntLoc[i], ln="weight", min=0.0, max=1.0, dv=0.0) mc.connectAttr(pntWeight_mdn + ".outputX", pntLoc[i] + ".weight", f=True) # Group mesh locators pntLoc_grp = mc.group(pntLoc, n=prefix + "_3Point_grp") mc.parent(pntFace, pntLoc_grp) # Return result return [pntLoc, pntFace, pntLoc_grp]
def generate(pts): """Takes in a list of tuples (set of 3D points) and generates a polygon model""" cmds.polyCreateFacet(name="shirt", p=points) cmds.polyTriangulate() cmds.polySubdivideFacet(dv=SUBDIVISIONS) cmds.polyTriangulate()
def drawTriangle(mesh, v1, v2, v3): p1 = getVertexPosition(mesh, v1) p2 = getVertexPosition(mesh, v2) p3 = getVertexPosition(mesh, v3) cmds.polyCreateFacet(p =(p1,p2,p3), n = 'triangle_' + mesh) cmds.parent(mesh, 'triangle_' + mesh)