def refineSearch(self): for a in self.curveGrp: if cm.listRelatives(a, p=True): self.curveGrp.remove(a) for a in self.follicleGrp: cm.group(n='group_2_' + str(a), em=True, w=True) x1, y1, z1, x2, y2, z2 = cm.exactWorldBoundingBox(a) x1 = (x1 + x2) / 2 y1 = (y1 + y2) / 2 z1 = (z1 + z2) / 2 x1 = abs(x1) y1 = abs(y1) z1 = abs(z1) for b in self.curveGrp: x1c, y1c, z1c, x2c, y2c, z2c = cm.exactWorldBoundingBox(b) x1c = abs(x1c) y1c = abs(y1c) z1c = abs(z1c) diffx1 = x1c - x1 diffy1 = y1c - y1 diffz1 = z1c - z1 if diffx1 < self.Dist and diffx1 > -self.Dist and diffy1 < self.Dist and diffy1 > -self.Dist and diffz1 < self.Dist and diffz1 > -self.Dist: if cm.listRelatives(b, p=False): print b, 'has no parent' cm.parent(b, 'group_2_' + str(a)) else: pass
def refineSearch(self): for a in self.curveGrp: if cm.listRelatives(a, p=True): self.curveGrp.remove(a) for a in self.follicleGrp: cm.group(n='group_2_'+str(a), em=True, w=True) x1, y1, z1, x2, y2, z2 = cm.exactWorldBoundingBox(a) x1 = (x1+x2)/2 y1 = (y1+y2)/2 z1 = (z1+z2)/2 x1 = abs(x1) y1 = abs(y1) z1 = abs(z1) for b in self.curveGrp: x1c, y1c, z1c, x2c, y2c, z2c = cm.exactWorldBoundingBox(b) x1c = abs(x1c) y1c = abs(y1c) z1c = abs(z1c) diffx1=x1c-x1 diffy1=y1c-y1 diffz1=z1c-z1 if diffx1<self.Dist and diffx1>-self.Dist and diffy1<self.Dist and diffy1>-self.Dist and diffz1<self.Dist and diffz1>-self.Dist: if cm.listRelatives(b, p=False): print b, 'has no parent' cm.parent(b, 'group_2_'+str(a)) else: pass
def search(self): for a in self.follicleGrp: cm.group(n='group_'+str(a), em=True, w=True) x1, y1, z1, x2, y2, z2 = cm.exactWorldBoundingBox(a) x1 = (x1+x2)/2 y1 = (y1+y2)/2 z1 = (z1+z2)/2 x1 = abs(x1) y1 = abs(y1) z1 = abs(z1) for b in self.curveGrp: x1c, y1c, z1c, x2c, y2c, z2c = cm.exactWorldBoundingBox(b) x1c = abs(x1c) y1c = abs(y1c) z1c = abs(z1c) diffx1=x1c-x1 diffy1=y1c-y1 diffz1=z1c-z1 if diffx1<self.Dist and diffx1>-self.Dist and diffy1<self.Dist and diffy1>-self.Dist and diffz1<self.Dist and diffz1>-self.Dist: if cm.listRelatives(b, p=False): print b, 'Has no parent' cm.parent(b, 'group_'+str(a)) more = 0 for c in self.curveGrp: if cm.listRelatives(c, p=False): more = 1 if more==1: self.Dist += (self.Dist*.8) print '***Refining search.' new.refineSearch()
def search(self): for a in self.follicleGrp: cm.group(n='group_' + str(a), em=True, w=True) x1, y1, z1, x2, y2, z2 = cm.exactWorldBoundingBox(a) x1 = (x1 + x2) / 2 y1 = (y1 + y2) / 2 z1 = (z1 + z2) / 2 x1 = abs(x1) y1 = abs(y1) z1 = abs(z1) for b in self.curveGrp: x1c, y1c, z1c, x2c, y2c, z2c = cm.exactWorldBoundingBox(b) x1c = abs(x1c) y1c = abs(y1c) z1c = abs(z1c) diffx1 = x1c - x1 diffy1 = y1c - y1 diffz1 = z1c - z1 if diffx1 < self.Dist and diffx1 > -self.Dist and diffy1 < self.Dist and diffy1 > -self.Dist and diffz1 < self.Dist and diffz1 > -self.Dist: if cm.listRelatives(b, p=False): print b, 'Has no parent' cm.parent(b, 'group_' + str(a)) more = 0 for c in self.curveGrp: if cm.listRelatives(c, p=False): more = 1 if more == 1: self.Dist += (self.Dist * .8) print '***Refining search.' new.refineSearch()
def find_center(centerOp): #If the evaluation is true or 1 then the script adds all the selections to an array and if (centerOp == 1): #Find the items you want to select sel = cmds.ls(sl=True) for i in range(len(sel)): cmds.select(str(sel[i])) #Find the bounding box of the selection by using the command exactWorldBoundingBox bBox = cmds.exactWorldBoundingBox() #Use the formula (x1 + x2)/2), y, and z respectivly to find the center of the min and max points xPosWldLoct = ((bBox[0] + bBox[3]) / 2) yPosWldLoct = ((bBox[1] + bBox[4]) / 2) zPosWldLoct = ((bBox[2] + bBox[5]) / 2) #Make a locator at the found points cmds.select(cl=True) cmds.spaceLocator(p=(0, 0, 0)) cmds.xform(t=(xPosWldLoct, yPosWldLoct, zPosWldLoct)) #If it evaluates false or 0 then the selected objects are evaluated with one bounding box elif (centerOp == 0): #Find the bounding box of the selection by using the command exactWorldBoundingBox bBox = cmds.exactWorldBoundingBox() #Use the formula (x1 + x2)/2), y, and z respectivly to find the center of the min and max points xPosWldLoct = ((bBox[0] + bBox[3]) / 2) yPosWldLoct = ((bBox[1] + bBox[4]) / 2) zPosWldLoct = ((bBox[2] + bBox[5]) / 2) #Make a locator at the found points cmds.select(cl=True) cmds.spaceLocator(p=(0, 0, 0)) cmds.xform(t=(xPosWldLoct, yPosWldLoct, zPosWldLoct))
def BBintersection(obj1, obj2): #derive the bounding box that is the intersection of two bounding boxes #coords returned as MVector BB1 = mc.exactWorldBoundingBox(obj1) BB2 = mc.exactWorldBoundingBox(obj2) BB1min = om.MVector(BB1[0],BB1[1],BB1[2]) BB1max = om.MVector(BB1[3],BB1[4],BB1[5]) BB2min = om.MVector(BB2[0],BB2[1],BB2[2]) BB2max = om.MVector(BB2[3],BB2[4],BB2[5]) if BB1min.x >= BB2min.x: outMinX = BB1min.x if BB1min.x <= BB2min.x: outMinX = BB2min.x if BB1min.y >= BB2min.y: outMinY = BB1min.y if BB1min.y <= BB2min.y: outMinY = BB2min.y if BB1min.z >= BB2min.z: outMinZ = BB1min.z if BB1min.z <= BB2min.z: outMinZ = BB2min.z outMin = om.MVector(outMinX,outMinY,outMinZ) if BB1max.x <= BB2max.x: outMaxX = BB1max.x if BB1max.x >= BB2max.x: outMaxX = BB2max.x if BB1max.y <= BB2max.y: outMaxY = BB1max.y if BB1max.y >= BB2max.y: outMaxY = BB2max.y if BB1max.z <= BB2max.z: outMaxZ = BB1max.z if BB1max.z >= BB2max.z: outMaxZ = BB2max.z outMax = om.MVector(outMaxX,outMaxY,outMaxZ) return outMin,outMax
def BBintersection(obj1, obj2): #derive the bounding box that is the intersection of two bounding boxes #coords returned as MVector BB1 = mc.exactWorldBoundingBox(obj1) BB2 = mc.exactWorldBoundingBox(obj2) BB1min = om.MVector(BB1[0], BB1[1], BB1[2]) BB1max = om.MVector(BB1[3], BB1[4], BB1[5]) BB2min = om.MVector(BB2[0], BB2[1], BB2[2]) BB2max = om.MVector(BB2[3], BB2[4], BB2[5]) if BB1min.x >= BB2min.x: outMinX = BB1min.x if BB1min.x <= BB2min.x: outMinX = BB2min.x if BB1min.y >= BB2min.y: outMinY = BB1min.y if BB1min.y <= BB2min.y: outMinY = BB2min.y if BB1min.z >= BB2min.z: outMinZ = BB1min.z if BB1min.z <= BB2min.z: outMinZ = BB2min.z outMin = om.MVector(outMinX, outMinY, outMinZ) if BB1max.x <= BB2max.x: outMaxX = BB1max.x if BB1max.x >= BB2max.x: outMaxX = BB2max.x if BB1max.y <= BB2max.y: outMaxY = BB1max.y if BB1max.y >= BB2max.y: outMaxY = BB2max.y if BB1max.z <= BB2max.z: outMaxZ = BB1max.z if BB1max.z >= BB2max.z: outMaxZ = BB2max.z outMax = om.MVector(outMaxX, outMaxY, outMaxZ) return outMin, outMax
def inWorld(car): """Checks if the car is still in the map. Returns True if it is still within the bounds of the world / map.""" bbox1 = cmds.exactWorldBoundingBox('streetMap') bbox2 = cmds.exactWorldBoundingBox(car) if (bbox2[2] >= bbox1[2] and bbox2[2] <= bbox1[5] or bbox2[5] >= bbox1[2] and bbox2[5] <= bbox1[5]) and ( bbox2[0] >= bbox1[0] and bbox2[0] <= bbox1[3] or bbox2[3] >= bbox1[0] and bbox2[3] <= bbox1[3]): return True
def hitBuilding(car, buildingIndex): """Checks if the car has hit a building set. Returns True if collision between car and a building set is detected.""" bbox1 = cmds.exactWorldBoundingBox(buildingList[buildingIndex]) bbox2 = cmds.exactWorldBoundingBox(car) if (bbox2[2] >= bbox1[2] and bbox2[2] <= bbox1[5] or bbox2[5] >= bbox1[2] and bbox2[5] <= bbox1[5]) and ( bbox2[0] >= bbox1[0] and bbox2[0] <= bbox1[3] or bbox2[3] >= bbox1[0] and bbox2[3] <= bbox1[3]): return True
def placeTreesInSquare(squareBbox, shaders): ''' Places trees randomly in a given square. squareBbox: A list of two tuples containing the x- and z-coordinates for the bounding box of a square. shaders: A list of shaders for the tree crowns. On exit: A cube of the same size as the square been created and assigned a green shader in order to make it look like grass. Trees have created using makeTree(...), and placed randomly using a dart throwing algorithm which gives up after six failed attempts. Everything is united into one object which is returned as a tuple with the object name and the node name. ''' treeList = [] width = squareBbox[1][0] - squareBbox[0][0] depth = squareBbox[1][1] - squareBbox[0][1] grass = cmds.polyCube(name = "grass", h = 0.3, w = width, d = depth) cmds.xform(grass, translation = (squareBbox[0][0] + 0.5 * width,0.15,squareBbox[0][1] + 0.5 * depth)) cmds.sets(grass[0], edit=True, forceElement="grassMaterialGroup") while True: failCount = 0 tree = makeTree(shaders) treeList.append(tree) bbox1 = cmds.exactWorldBoundingBox(tree[0]) radius = (bbox1[3] - bbox1[0]) / 2.0 coorx = random.uniform(squareBbox[0][0] + radius, squareBbox[1][0] - radius) coorz = random.uniform(squareBbox[0][1] + radius, squareBbox[1][1] - radius) cmds.xform(tree[0], translation = (coorx, 0, coorz)) while True: failed = False for j in treeList: bbox1 = cmds.exactWorldBoundingBox(tree[0]) bbox2 = cmds.exactWorldBoundingBox(j[0]) # Check if the tree intersects with element j in treeList. xinters = (bbox1[0] < bbox2[3] and bbox1[0] > bbox2[0])\ or (bbox2[0] < bbox1[3] and bbox2[0] > bbox1[0]) zinters = (bbox1[2] < bbox2[5] and bbox1[2] > bbox2[2])\ or (bbox2[2] < bbox1[5] and bbox2[2] > bbox1[2]) if xinters and zinters: coorx = random.uniform(squareBbox[0][0] + radius, squareBbox[1][0] - radius) coorz = random.uniform(squareBbox[0][1] + radius, squareBbox[1][1] - radius) cmds.xform(tree[0], translation = (coorx, 0, coorz)) failCount = failCount + 1 failed = True break if (failed == False) or (failCount > 5): break if (failCount > 5) or (len(treeList) == 10): break cmds.delete(tree[0]) # Delete the last tree that was not successfully placed. treeList.pop() for i in treeList: grass = cmds.polyUnite(grass[0], i[0]) return grass
def inJunction(car, juncIndex): """Checks bounding box of car and junction defining plane. Returns True if collision between car and junction is detected.""" bbox1 = cmds.exactWorldBoundingBox(juncList[juncIndex][0]) bbox2 = cmds.exactWorldBoundingBox(car) if (bbox2[2] >= bbox1[2] and bbox2[2] <= bbox1[5] or bbox2[5] >= bbox1[2] and bbox2[5] <= bbox1[5]) and ( bbox2[0] >= bbox1[0] and bbox2[0] <= bbox1[3] or bbox2[3] >= bbox1[0] and bbox2[3] <= bbox1[3]): return True
def detectCollision(car1, car2): """Checks bounding box of two cars. Returns True if collision between car bounding boxes is detected""" bbox1 = cmds.exactWorldBoundingBox(car1) bbox2 = cmds.exactWorldBoundingBox(car2) if (bbox2[2] >= bbox1[2] and bbox2[2] <= bbox1[5] or bbox2[5] >= bbox1[2] and bbox2[5] <= bbox1[5]) and ( bbox2[0] >= bbox1[0] and bbox2[0] <= bbox1[3] or bbox2[3] >= bbox1[0] and bbox2[3] <= bbox1[3]): return True else: return False
def findScaleFactor(ctrl, selection, buffer=5): '''Find by how much to scale the selected control to fit selection''' sel_bb = cmds.exactWorldBoundingBox(selection) ctrl_bb = cmds.exactWorldBoundingBox(ctrl) factorX_raw = sel_bb[3] / ctrl_bb[3] factorY_raw = sel_bb[4] / ctrl_bb[4] factorZ_raw = sel_bb[5] / ctrl_bb[5] factorX = buffer + factorX_raw factorY = buffer + factorY_raw factorZ = buffer + factorZ_raw return factorX, factorY, factorZ
def get_bbox_center(obj): shapes = mc.listRelatives( obj, s=True) # obten objeto de el shape en caso de tener hijos cvs = [] for shape in shapes: num_of_cvs = mc.getAttr(shape + ".controlPoints", size=True) cvs.append("{}.cv[0:{}]".format(shape, num_of_cvs - 1)) bbmin = mc.exactWorldBoundingBox(cvs)[:3] bbmax = mc.exactWorldBoundingBox(cvs)[3:7] mid_point = [(b_max + b_min) / 2 for b_min, b_max in izip(bbmin, bbmax)] return mid_point
def initFunc(*args): """This function creates the locators""" # Get user's selection selection = cmds.ls(selection=True, transforms=True) # Create and scale locators data.firstLocator = cmds.spaceLocator(name="CircleLocator001")[0] cmds.scale(4,4,4) data.secondLocator = cmds.spaceLocator(name="CircleLocator002")[0] cmds.scale(4,4,4) # If there was a selection, use it as bounding box for locators if selection: # Get dimensions # exactWorldBoundingBox command returns a list of values representing the limits of the object # [minXCoordinate, minYCoordinate, minZCoordinate, maxXCoordinate, maxYCoordinate, maxZCoordinate] selectionBbox = cmds.exactWorldBoundingBox(selection) # Using both x's to calculate the middle point midX = (selectionBbox[3]+selectionBbox[0])/2.0 # Using both y's to calculate the middle point midY = (selectionBbox[4]+selectionBbox[1])/2.0 # Select and move first locator to minimum Z on bounding box cmds.select(data.firstLocator) cmds.move(midX,midY,selectionBbox[2]) # Select and move first locator to maximum Z on bounding box cmds.select(data.secondLocator) cmds.move(midX,midY,selectionBbox[5])
def jntForEach(): geolist = cmds.ls(sl=1) for each in geolist: jntname = '' for prfx in prefixlist: if prfx in each: jntname = each.replace(prfx, '') print jntname break else: jntname = each if 'jnt_' + jntname == each: jntname = increment(jntname) print jntname if 'geo_' in each or 'geom_' in each: cmds.select(cl=1) boxarray = cmds.exactWorldBoundingBox(each) jnt = cmds.joint(name='jnt_' + jntname, p=((boxarray[0] + boxarray[3]) / 2, (boxarray[1] + boxarray[4]) / 2, (boxarray[2] + boxarray[5]) / 2)) else: cmds.select(each) jnt = cmds.joint(name='jnt_' + jntname) try: cmds.skinCluster(each, jnt, tsb=1) except Exception: pass
def dropToFloor(nodes = None, offset = 0): #no object is selected, return error if not nodes: nodes = cmds.ls(sl = True) if not nodes: cmds.error("No object is selected") #for loop for each object for node in nodes: #get the bouding box bbox = cmds.exactWorldBoundingBox(node) #store minimum y value minValue = bbox[1] #get wordl coordinate of the object ws = cmds.xform(node, q = True, t = True, ws = True) #calculate the difference between the floor with offset distance = ws[1] - bbox[1] + float(offset) ws[1] = distance #move the object cmds.xform(node, translation = ws, ws = True)
def get_pos(obj): if pm.PyNode(obj).type() == 'camera': obj_pos = pm.xform(obj, q=1, t=1, ws=1) else: obj_bb = mc.exactWorldBoundingBox(obj) obj_pos = [mix(obj_bb[0 + x], obj_bb[3 + x]) for x in range(3)] return obj_pos
def setLocs(mesh): global voxelSize, cubeSize, xmin, xmax, ymin, ymax, zmin, zmax, xLocs, yLocs, zLocs bb = cmds.exactWorldBoundingBox(mesh) xmin = bb[0] ymin = bb[1] zmin = bb[2] xmax = bb[3] ymax = bb[4] zmax = bb[5] # make 3 arrays of ray start points, one for each axis xLocs = [] yLocs = [] zLocs = [] fac = 1/voxelSize for y in range(int(ymin*fac), int(ymax*fac+1)): for z in range(int(zmin*fac), int(zmax*fac+1)): loc = (xmax, y*voxelSize, z*voxelSize) xLocs.append(loc) for z in range(int(zmin*fac), int(zmax*fac+1)): for x in range(int(xmin*fac), int(xmax*fac+1)): loc = (x*voxelSize, ymax, z*voxelSize) yLocs.append(loc) for x in range(int(xmin*fac), int(xmax*fac+1)): for y in range(int(ymin*fac), int(ymax*fac+1)): loc = (x*voxelSize, y*voxelSize, zmax) zLocs.append(loc)
def animatedVoxelization(self, name, res): time = cmds.currentTime(q=True) cmds.currentTime(time, e=True, u=False) cmds.currentTime(time, e=True, u=True) cmds.showHidden(name) voxelGroupName = name + 'VoxelGroup' if cmds.objExists(voxelGroupName): cmds.delete(voxelGroupName) meshDuplicate = cmds.duplicate(name) cmds.makeIdentity(meshDuplicate[0], a=True, t=True, r=True, s=True, n=0) meshBbox = cmds.exactWorldBoundingBox(meshDuplicate[0]) cmds.delete(meshDuplicate) cmds.voxelMesh(name, meshBbox, res) cmds.hide(name)
def createBuilding(position, blockSize, buildingSize): building = cmd.polyCube(sx=1, sy=1, sz=1, w=buildingSize[0], h=buildingSize[1], d=buildingSize[2]) buildingBlock = cmd.polyPlane(sx=1, sy=1, w=blockSize[0], h=blockSize[1]) #lamp = cmd.pointLight(decayRate=2, intensity=50, useRayTraceShadows=True) #cmd.move(6,2,0, lamp) buildingRig = cmd.circle(center=[0,0,0], normal=[0,1,0], radius=10, n='buildingRig') cmd.addAttr(buildingRig, longName='buildingHeight', shortName='bh', defaultValue=1, minValue=1, maxValue=20, attributeType='long') bbox = cmd.exactWorldBoundingBox(building) cmd.xform(building, piv=[0, bbox[1], 0], ws=True) cmd.move(0, -bbox[1], 0, building) cmd.makeIdentity(building, apply=True, t=True, r=True, s=True) cmd.delete(building, constructionHistory=True) cmd.delete(buildingBlock, constructionHistory=True) cmd.delete(buildingRig, constructionHistory=True) buildingGroup = cmd.group(em=True, name='building_1') buildingRig_group = cmd.parent(buildingRig[0], buildingGroup) cmd.parent(building[0], buildingGroup) cmd.parent(buildingBlock[0], buildingGroup) #cmd.parent(lamp, buildingGroup) cmd.connectAttr(buildingRig_group[0]+'.bh', building[0]+'.scaleY') x = position[0] * blockSize[0] y = position[1] * blockSize[1] cmd.move(x, 0, y, buildingGroup) height = math.floor(r.uniform(1, 10)) cmd.setAttr(buildingRig_group[0]+'.bh', height) cmd.setAttr(buildingRig_group[0]+'.visibility', False) return buildingGroup
def __init__(self, parent=None, geometry='', curve='', up_curve=''): """Initialization method. and set global variables :Keywords: parent : `QtGui.QWidget` or `None` The parent widget to embed this dialog within. If None do not embed this widget into another. geometry : `string` name of the last geometry selected curve : `string` name of the first curve selected up_curve : `string` name of the last curve selected """ super(DuplicateGeoUI, self).__init__(parent=parent) self.geometry = geometry self._geo_height = 0 if self.geometry: self._geo_height = cmds.exactWorldBoundingBox(self.geometry)[4] self.curve = curve self.up_curve = up_curve self.setWindowTitle('Duplicate Geo Along Curve') self.setModal(False) self.setWindowModality(QtCore.Qt.NonModal) self.create_widgets() self.build_layout() self.connect_buttons() self.pre_fill_widget()
def doPress(self): # print "PRESS" self.isMouseDown = True am = self.activeManip() m = Mom() m.strandsSelected( self.helicesNames, (am is self.fDistanceFrontManip, am is self.fDistanceBackManip)) self.createHelixDragMarker() selectedItems = cmds.ls(Mom().helixTransformName + "*", selection=True) bbox = cmds.exactWorldBoundingBox(selectedItems) cmds.setAttr(helixManip.transformName + ".scale", bbox[3] - bbox[0], 0, bbox[4] - bbox[1], type="double3") z = 0 if am is self.fDistanceFrontManip: z = bbox[5] elif am is self.fDistanceBackManip: z = bbox[2] self.moveHelixDragMarkerTo( ((bbox[0] + bbox[3]) / 2, (bbox[1] + bbox[4]) / 2, z)) cmds.showHidden(helixManip.transformName) self.calculateDeltaBounds() return OpenMaya.kUnknownParameter
def convert_joint(curr_joint, group_name, root_jnt=True): scale_size = mc.jointDisplayScale(q=True) * 2.0 _children = mc.listRelatives(curr_joint, c=True) if _children is not None: for node in _children: if mc.nodeType(node) == 'joint': convert_joint(node, group_name, root_jnt=False) parent = mc.listRelatives(curr_joint, p=True) if parent is None or root_jnt: return _name_ball = curr_joint + group_name + "_ball" new_ball = mc.sphere(n=_name_ball) _name_cone = curr_joint + group_name + "_joint" new_cone = mc.cone(p=(0, 0, 0), ax=(1, 0, 0), ssw=0, esw=360, r=0.5, hr=4, d=1, ut=0, tol=0.01, s=8, nsp=4, ch=1, n=_name_cone) mc.move(-1, 0, 0, _name_cone + ".scalePivot", _name_cone + ".rotatePivot", r=True) mc.parent(new_cone, group_name) mc.parent(new_ball, group_name) xform1 = mc.xform(curr_joint, q=True, ws=True, t=True) xform2 = mc.xform(parent[0], q=True, ws=True, t=True) dist = 0.0 for i in range(len(xform1)): dist += (xform1[i] - xform2[i]) * (xform1[i] - xform2[i]) dist = (dist**0.5) / 2.0 mc.scale(scale_size, scale_size, scale_size, new_ball, r=True) bbox = mc.exactWorldBoundingBox(new_ball) bbox_size = ((((bbox[3] - bbox[0])**2 + (bbox[4] - bbox[1])**2 + (bbox[5] - bbox[2])**2)**0.5) / 4.0) * 2.0 mc.scale(dist, bbox_size, bbox_size, new_cone, r=True) mc.pointConstraint(parent[0], new_cone, weight=1) mc.pointConstraint(parent[0], new_ball, weight=1) mc.aimConstraint(curr_joint, new_cone, aim=(1, 0, 0), u=(0, 1, 0), wu=(0, 1, 0), weight=1) create_node(group_name, new_ball[0], 'ball') create_node(group_name, new_cone[0], 'edge')
def createABranch(rotAxis, angle): global prevRot, prevPos '''Extract Euler angles from constructed quaternion''' euAngles = EulerAnglesFromAxisQuat(rotAxis, angle) #print toDegrees(euAngles[0])#x #print toDegrees(euAngles[1])#y #print toDegrees(euAngles[2])#z '''Create Cylinder''' branch = mc.polyCylinder( n='cy1', r=0.1, height=branchLength) #axis=(dirx[0],diry[0],dirz[0]), #time.sleep(1) '''Set pivot to botton so as to rotate properly''' bbox = mc.exactWorldBoundingBox(branch) bottom = [(bbox[0] + bbox[3]) / 2, bbox[1], (bbox[2] + bbox[5]) / 2] #(xmin,xmax)/2 , (zmin,zmax)/2 #now set pivot to the bottom of the cylinder mc.xform(branch[0], piv=bottom, ws=True, r=True) cmds.refresh() #time.sleep(1) print "branchStackPos=%s" % (branchStackPos) #print "myposUsed=%s"%(prevPos) mypos = prevPos myrot = prevRot #mypos=branchStackPos.pop() #myrot=branchStackRot.pop() '''Move cylinder to the current position & the current rotation''' mc.xform(rotation=myrot, translation=mypos) cmds.refresh() #time.sleep(1) cylHeight = mc.polyCylinder(branch[0], height=True, query=True) '''move towards direction- push it up on the local y Axis''' mc.move(0, cylHeight, 0, r=True, os=True) #step forward - move up in local Y '''Store this new branch position''' prevPos = mc.xform(query=True, translation=True, worldSpace=True) #keeps the previous position cmds.refresh() #time.sleep(1) '''Rotate and Store rotation''' mc.rotate(toDegrees(euAngles[0]), toDegrees(euAngles[1]), toDegrees(euAngles[2]), branch[0], r=True) #perform relative rotation prevRot = mc.xform( query=True, rotation=True, worldSpace=True) #keeps the previous rotated degree angles cmds.refresh() #time.sleep(1) setAngle(0)
def get_selection_center(selection=None): """Bounding box center that is.""" selection = selection or mc.ls(selection=True, flatten=True) if not selection: raise Exception('Nothing is selected.') if len(selection) == 1: return mc.xform(selection[0], query=True, translation=True, worldSpace=True) minx = miny = minz = float('inf') maxx = maxy = maxz = -float('inf') for item in selection: if '.' in item: # Components (vertex, edge, ...) x1, y1, z1 = mc.xform(item, query=True, translation=True, worldSpace=True) x2, y2, z2 = x1, y1, z1 else: # Geo/transform x1, y1, z1, x2, y2, z2 = mc.exactWorldBoundingBox(item) minx = min(x1, minx) maxx = max(x2, maxx) miny = min(y1, miny) maxy = max(y2, maxy) minz = min(z1, minz) maxz = max(z2, maxz) return average([minx, maxx]), average([miny, maxy]), average([minz, maxz])
def CreateJoints(): SelectedObject = cmds.ls(sl=True) for item in SelectedObject: bbox = cmds.exactWorldBoundingBox(calculateExactly=True) cmds.joint() cmds.parent('SelectedObject|joint', removeObject=True) cmds.joint()
def create_main_controls(self): """ Function that creates main rig controls """ xmin, ymin, zmin, xmax, ymax, zmax = mc.exactWorldBoundingBox( self._geo['model']) a = [xmin, 0, 0] b = [xmax, 0, 0] radius = (math.sqrt( pow(a[0] - b[0], 2) + pow(a[1] - b[1], 2) + pow(a[2] - b[2], 2))) self._root_ctrl = control.Circle('root', normal=[0, 1, 0], radius=radius, color_index=29) self._main_ctrl = control.Circle('main', normal=[0, 1, 0], radius=radius - 6, color_index=16) self._main_ctrl.translate_control_shapes(0, 1, 0) mc.addAttr(self._main_grp, ln='root_ctrl', at='message') mc.addAttr(self._main_grp, ln='main_ctrl', at='message') mc.setAttr(self._main_grp + '.root_ctrl', lock=False) mc.setAttr(self._main_grp + '.main_ctrl', lock=False) mc.connectAttr(self._root_ctrl.node + '.message', self._main_grp + '.root_ctrl') mc.connectAttr(self._main_ctrl.node + '.message', self._main_grp + '.main_ctrl')
def Action_UnFreezeScale(self): maya_cmds.undoInfo(openChunk=True) try: transforms = self.window.Text_Transforms.toPlainText().strip( ).split('\n') isConsiderRot = self.window.Check_ConsiderRot.isChecked() selection = [] if isConsiderRot: selection = maya_cmds.ls(selection=True) duplicates = maya_cmds.duplicate(transforms) for i in xrange(len(duplicates)): maya_cmds.setAttr(duplicates[i] + '.rotateX', 0) maya_cmds.setAttr(duplicates[i] + '.rotateY', 0) maya_cmds.setAttr(duplicates[i] + '.rotateZ', 0) else: duplicates = transforms for i in xrange(len(transforms)): boundaries = maya_cmds.exactWorldBoundingBox( duplicates[i], calculateExactly=True) maya_cmds.ToolSeq_Freeze_Apply( transforms=transforms[i], isScaX=True, isScaY=True, isScaZ=True, scaX=boundaries[3] - boundaries[0], scaY=boundaries[4] - boundaries[1], scaZ=boundaries[5] - boundaries[2]) if isConsiderRot: maya_cmds.delete(duplicates) maya_cmds.select(selection) except Exception as e: print >> stderr, str(e) maya_cmds.undoInfo(closeChunk=True)
def duplicate_button( self, *args ): self.original_selected_objects = cmds.ls( selection=True ) if( len(self.original_selected_objects) == 0 ): print "Nothing selected" return 0 elif( len(self.original_selected_objects) == 1 ): self.relatives = cmds.listRelatives( children=True ) if( len(self.relatives) == 1 ): print "Skip combine" cmds.duplicate( self.original_selected_objects, name=self.original_selected_objects[0] + "_Copy" ) cmds.delete( constructionHistory=True ) the_parent = cmds.listRelatives( parent=True ) if( the_parent != None ): cmds.parent( self.original_selected_objects[0] + "_Copy", world=True ) else: self.combine() else: self.combine() self.newOriginCopy = cmds.ls( selection=True )[0] self.bbox = cmds.exactWorldBoundingBox( self.newOriginCopy ) cmds.move((self.bbox[0] + self.bbox[3])/2, self.bbox[1], (self.bbox[2] + self.bbox[5])/2, self.newOriginCopy + ".scalePivot", self.newOriginCopy + ".rotatePivot", absolute=True) cmds.move( 0, 0, 0, self.newOriginCopy, rpr=True ) cmds.makeIdentity( apply=True, t=1, r=1, s=1 ) cmds.delete( constructionHistory=True )
def bulge_button( self, *args ): if( cmds.objExists( "ZBend" ) ): cmds.confirmDialog( title="Error", message="First delete the bulge history on the previously\ndeformed object before bulging another.", button="Okie Dokie" ) return 0 latestSelection = cmds.ls( selection=True ) if( len( latestSelection ) == 0 ): return 0 if( len( latestSelection ) == 1 ): self.relatives = cmds.listRelatives( children=True ) if( len(self.relatives) == 1 ): self.bbox = cmds.exactWorldBoundingBox( latestSelection ) cmds.nonLinear( type='bend', curvature=cmds.intSliderGrp( "x_bulge_slider", value=True, query=True ) ) cmds.rename( "XBend" ) cmds.move((self.bbox[0] + self.bbox[3])/2, self.bbox[1], (self.bbox[2] + self.bbox[5])/2, "XBend", rpr=True ) cmds.setAttr( "XBend.rotateZ", -90 ) cmds.select( latestSelection ) cmds.nonLinear( type='bend', curvature=cmds.intSliderGrp( "z_bulge_slider", value=True, query=True ) ) cmds.rename( "ZBend" ) cmds.move((self.bbox[0] + self.bbox[3])/2, self.bbox[1], (self.bbox[2] + self.bbox[5])/2, "ZBend", rpr=True ) cmds.setAttr( "ZBend.rotateZ", -90 ) cmds.setAttr( "ZBend.rotateX", 90 ) cmds.connectControl( "x_bulge_slider", "bend1.curvature" ) cmds.connectControl( "z_bulge_slider", "bend2.curvature" ) cmds.select( latestSelection )
def trailmouth(crv, partname, jnt_up, jnt_low, smlfrn_l, smlfrn_r): mthbnd = cmds.exactWorldBoundingBox(crv) size = (mthbnd[3] - mthbnd[0]) * 1.4 centerfortrail = [ round(((mthbnd[3] + mthbnd[0]) / 2), 2), round(((mthbnd[4] + mthbnd[1]) / 2), 2), round(((mthbnd[5] + mthbnd[2]) / 2), 2) ] trail = 'trail_' + partname cmds.circle(r=size, n=trail, nrz=0, nry=1, sw=180, cx=size * 0.92) cmds.xform(trail, t=centerfortrail, ro=(0, 90, 0)) cmds.circle(r=size, n='smlfrn_' + trail, nrz=0, nry=1, sw=180, cx=size * 0.5, cy=-size * 0.5) cmds.xform('smlfrn_' + trail, t=centerfortrail, ro=(90, 0, 90)) cmds.duplicate(trail, n=trail + '_up') cmds.duplicate(trail, n=trail + '_mid') cmds.duplicate(trail, n=trail + '_low') cmds.delete(trail) cmds.skinCluster(jnt_up, smlfrn_l, smlfrn_r, trail + '_up', tsb=1) cmds.skinCluster(jnt_low, smlfrn_l, smlfrn_r, trail + '_low', tsb=1) cmds.skinCluster(jnt_low, jnt_up, smlfrn_l, smlfrn_r, trail + '_mid', tsb=1)
def init(): # create group _group = cmds.group(n='Group', em=True) cmds.group(n='geometry', em=True, parent=_group) _rig_group = cmds.group(n='rig', em=True, parent=_group) _master_group = cmds.group(n='master', em=True, parent=_rig_group) # create circle modellist = cmds.ls(type='mesh') if modellist: boxlist = cmds.exactWorldBoundingBox(modellist) radius = max(boxlist[3], boxlist[5]) _main_circle = cmds.circle(n='Main', nr=(0, 1, 0), r=radius * 1.6) _first_circle = cmds.circle(n='First', nr=(0, 1, 0), r=radius * 1.3) _second_circle = cmds.circle(n='Second', nr=(0, 1, 0), r=radius) else: _main_circle = cmds.circle(n='Main', nr=(0, 1, 0), r=5) _first_circle = cmds.circle(n='First', nr=(0, 1, 0), r=3.8) _second_circle = cmds.circle(n='Second', nr=(0, 1, 0), r=2.5) # set circle parent cmds.parent(_second_circle, _first_circle) cmds.parent(_first_circle, _main_circle) cmds.parent(_main_circle, _master_group) # color&history _set_color('Main', color=(1, 0, 0)) cmds.delete('Main', constructionHistory=True) _set_color('First', color=(0, 1, 0)) _set_color('Second', color=(0, 0, 1)) # create joint cmds.group(n='joint', em=True, parent=_rig_group) cmds.joint(n='Root_M') cmds.group(n='deform', em=True, parent=_rig_group)
def _get_recommended_pivot_bank(self, geometries, tm_ref, tm_ref_dir, pos_toes, direction=1): """ Determine recommended position using ray-cast from the toes. TODO: If the ray-case fail, use a specified default value. return: The recommended position as a world pymel.datatypes.Vector """ # Sanity check, ensure that at least one point is in the bounds of geometries. # This can prevent rays from being fired from outside a geometry. # TODO: Make it more robust. filtered_geometries = [] for geometry in geometries: xmin, ymin, zmin, xmax, ymax, zmax = cmds.exactWorldBoundingBox(geometry.__melobject__()) bound = pymel.datatypes.BoundingBox((xmin, ymin, zmin), (xmax, ymax, zmax)) if bound.contains(pos_toes): filtered_geometries.append(geometry) dir = pymel.datatypes.Point(direction, 0, 0) * tm_ref_dir pos = libRigging.ray_cast_nearest(pos_toes, dir, filtered_geometries) if not pos: cmds.warning("Can't automatically solve FootRoll bank inn pivot.") pos = pos_toes pos.y = 0 return pos
def dispatchObjects(): sel = cmds.ls(sl=True, l=True) Xvalues = [] Zvalues = [] if len(sel) <= 1: cmds.warning('Select at least 2 objects') else: for s in sel: cmds.xform(s, a=True, t=(0, 0, 0)) bbox = cmds.exactWorldBoundingBox(s) Xvalues.append(abs(bbox[0]) + abs(bbox[3])) Zvalues.append(abs(bbox[2]) + abs(bbox[5])) columnIndex = int(math.sqrt(len(sel))) + 1 moveValueX = max(Xvalues) * 1.1 moveValueZ = max(Zvalues) * 1.1 for s in sel: index = sel.index(s) rowIndex = int(index / columnIndex) cmds.xform(s, a=True, t=(index * moveValueX, 0, rowIndex * moveValueZ)) cmds.xform(s, r=True, t=(-(rowIndex * moveValueX * columnIndex), 0, 0))
def center_selection(): """Creates locator at bounding box center of objects or components Note: Uses function "convert_joint_selection_to_loc()" to "convert" any selected joints to locators temporarily. Joints don't work with bbox calculations accurately for this use Tested with transforms, joints, vertices, edges *Does not center locator on polygon "faces" """ selection = cmds.ls(selection=True) if selection: filter_sel = convert_joint_selection_to_loc() if filter_sel: bbx = cmds.exactWorldBoundingBox(filter_sel[0]) centerX = (bbx[0] + bbx[3]) / 2.0 centerY = (bbx[1] + bbx[4]) / 2.0 centerZ = (bbx[2] + bbx[5]) / 2.0 bbox_center = [centerX, centerY, centerZ] loc = cmds.spaceLocator()[0] cmds.setAttr('{}.translate'.format(loc), *bbox_center) if filter_sel[1]: cmds.delete(filter_sel[1]) cmds.select(loc) return loc
def exactLocalBoundingBox(*args,**keywords): if len(args)==0: args=mc.ls(sl=True) obj=args[0] r=False #relative to the rotate pivot for k in keywords: if k=='r' or k=='relative': r=keywords[k] if k in locals(): exec(k+'=keywords[k]') t,r,s=mc.getAttr(obj+'.t')[0],mc.getAttr(obj+'.r')[0],mc.getAttr(obj+'.s')[0] mc.setAttr(obj+'.t',0,0,0) mc.setAttr(obj+'.r',0,0,0) mc.setAttr(obj+'.s',1,1,1) if r: rp=mc.xform(obj,q=True,ws=True,rp=True) mc.xform(obj,ws=True,t=(-rp[0],-rp[1],-rp[2])) returnVal=mc.exactWorldBoundingBox(obj) mc.setAttr(obj+'.t',*t) mc.setAttr(obj+'.r',*r) mc.setAttr(obj+'.s',*s) return returnVal
def bounding_by_frame(frame_range=[], path=[]): if len(frame_range) == 2: if path is not None: path = mc.ls(path) boundingbox = [ 999999999, 999999999, 999999999, -999999999, -999999999, -999999999 ] for frame in range(frame_range[0], frame_range[1] + 1): mc.currentTime(frame) temp = mc.exactWorldBoundingBox(path) if boundingbox[0] > temp[0]: boundingbox[0] = temp[0] if boundingbox[1] > temp[1]: boundingbox[1] = temp[1] if boundingbox[2] > temp[2]: boundingbox[2] = temp[2] if boundingbox[3] < temp[3]: boundingbox[3] = temp[3] if boundingbox[4] < temp[4]: boundingbox[4] = temp[4] if boundingbox[5] < temp[5]: boundingbox[5] = temp[5] return boundingbox
def BBoxToCurve( obj, autoParent = False ): bbinfo = mc.exactWorldBoundingBox( obj ) # xmin, ymin, zmin, xmax, ymax, zmax point1 = [bbinfo[0],bbinfo[1],bbinfo[2]] point2 = [bbinfo[3],bbinfo[4],bbinfo[5]] coords = ([point1[0], point2[1], point2[2] ], point2, [ point2[0], point2[1], point1[2] ], [ point1[0], point2[1], point1[2] ], [ point1[0], point2[1], point2[2] ], [ point1[0], point1[1], point2[2] ], point1, [ point2[0], point1[1], point1[2] ], [ point2[0], point1[1], point2[2] ], [ point1[0], point1[1], point2[2] ], [ point2[0], point1[1], point2[2] ], point2, [ point2[0], point2[1], point1[2] ], [ point2[0], point1[1], point1[2] ], point1, [ point1[0], point2[1], point1[2] ]) bbox = mc.curve( d = 1, p = coords, k = [ a for a in range(len(coords))], n = "cube#" ) if autoParent: shape = mc.listRelatives( bbox, f = True, s = True ) mc.select( shape, obj ) mc.parent( add = True, shape = True ) mc.delete( bbox ) return bbox
def failUnlessCubeWidthEqual(self, timeValueList): for time, value in timeValueList: MayaCmds.currentTime(time, update = True) bbox = MayaCmds.exactWorldBoundingBox('cube') width = bbox[3] - bbox[0] self.failUnlessAlmostEqual( value, width, 3, 'Time: %f, Width: %f (expected) != %f' % (time, value, width))
def isBoundingBoxCross( firstObj, secondObj ): bboxFirst = cmds.exactWorldBoundingBox( firstObj ) bboxSecond = cmds.exactWorldBoundingBox( secondObj ) firstMin = bboxFirst[:3] firstMax = bboxFirst[3:] secondMin = bboxSecond[:3] secondMax = bboxSecond[3:] isCross = True for dimantion in [ [0,1], [1,2], [2,0] ]: for i in dimantion: if firstMax[i] < secondMin[i] or firstMin[i] > secondMax[i]: isCross = False break return isCross
def make_origin_target(): o = cmds.polySphere() # create a sphere cmds.select(o) # select the sphere bbox = cmds.exactWorldBoundingBox() # create bounding box around it bottom = [(bbox[0] + bbox[3])/2, bbox[1], (bbox[2] + bbox[5])/2] # define the bottom of the bounding box cmds.xform(piv=bottom, ws=True) # move the sphere to the bottom of the bounding box cmds.move(rpr=True) cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) # freeze transforms
def create_guide(): if cmds.objExists('loc_guide_deformer'): cmds.delete('loc_guide_deformer') bound_centre = [0,0,0] if len(cmds.ls(sl=True)) is not 0: bound = cmds.exactWorldBoundingBox(cmds.ls (sl = True)) bound_centre = [(bound[0] + bound[3])/2, (bound[1] + bound[4])/2, (bound[2] + bound[5])/2] cmds.spaceLocator (n="loc_guide_deformer", a = True, p = (bound_centre[0], bound_centre[1], bound_centre[2])) cmds.CenterPivot()
def run(): """Measure the scene bounding box for geometric objects in centimeters. --- units, bounding box, center and dimensions for scene sceneboundingbox() -> (string, float, float, float, float, float, float, float, float, float, float, float, float) """ t0 = float(time.time()) verbose = cmds.optionVar(query='checkmateVerbosity') units = cmds.currentUnit(query=True, linear=True) if units != 'cm' : cmds.currentUnit(linear='cm') #raise InvalidLinearUnits, "current linear unit is not centimeters" transforms = cmds.ls(transforms=True) geometry = cmds.ls(geometry=True) try: bbox = cmds.exactWorldBoundingBox(geometry) except TypeError: return (units, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) (bbMinX, bbMinY, bbMinZ, bbMaxX, bbMaxY, bbMaxZ) = cmds.exactWorldBoundingBox(geometry) width = bbMaxX - bbMinX height = bbMaxY - bbMinY depth = bbMaxZ - bbMinZ centerX = ( bbMaxX + bbMinX ) / 2.0 centerY = ( bbMaxY + bbMinY ) / 2.0 centerZ = ( bbMaxZ + bbMinZ ) / 2.0 print '%-24s : %.6f seconds' % ('stats.bbox.run()', float(time.time())-t0 ) return (units, bbMinX, bbMinY, bbMinZ, bbMaxX, bbMaxY, bbMaxZ, centerX, centerY, centerZ, width, height, depth)
def moveToOrigin(): # group and move all geo to origin cmds.select(cmds.listRelatives(cmds.ls(geometry=True), p=True, path=True), r=True) cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) cmds.group(n='tempGroup') bbox = cmds.exactWorldBoundingBox() bottom = [(bbox[0] + bbox[3])/2, bbox[1], (bbox[2] + bbox[5])/2] cmds.xform(piv=bottom, ws=True) cmds.move(rpr=True) cmds.ungroup('tempGroup')
def create_world_button( self, *args ): if( cmds.objExists( "OurSampleWorld" ) ): return 0 else: cmds.sphere( r=10, sections=40, spans=30, name="OurSampleWorld" ) cmds.setAttr( "OurSampleWorld.scale", 9.599, 9.599, 9.599 ) cmds.makeIdentity( apply=True, t=1, r=1, s=1 ) self.wbbox = cmds.exactWorldBoundingBox( "OurSampleWorld" ) cmds.move((self.wbbox[0] + self.wbbox[3])/2, self.wbbox[4], (self.wbbox[2] + self.wbbox[5])/2, "OurSampleWorld.scalePivot", "OurSampleWorld.rotatePivot", absolute=True) cmds.move( 0, 0, 0, "OurSampleWorld", rpr=True ) cmds.connectControl( "world_size_slider", "OurSampleWorld.scaleX", "OurSampleWorld.scaleY", "OurSampleWorld.scaleZ" )
def createBirail(curveGrp) : eachCrvGrp = cmds.listRelatives(curveGrp) shapeEachCrvGrp = cmds.listRelatives(eachCrvGrp, children=True) meshInGrp = cmds.ls(shapeEachCrvGrp, type='mesh') if len(eachCrvGrp)>3 and len(meshInGrp)==0 : #checking if curves are in right order intersect1 = cmds.curveIntersect(eachCrvGrp[0], eachCrvGrp[1]) intersect2 = cmds.curveIntersect(eachCrvGrp[0], eachCrvGrp[2]) intersect3 = cmds.curveIntersect(eachCrvGrp[0], eachCrvGrp[3]) curveOrder = [] if str(intersect1)=='None' : curveOrder = [eachCrvGrp[0], eachCrvGrp[2], eachCrvGrp[1], eachCrvGrp[3]] elif str(intersect3)=='None' : curveOrder = [eachCrvGrp[0], eachCrvGrp[1], eachCrvGrp[3], eachCrvGrp[2]] else : curveOrder = eachCrvGrp # crv1shape = cmds.listRelatives(curveOrder[1], children=True) crv1spans = cmds.getAttr(crv1shape[0]+'.spans') crv2shape = cmds.listRelatives(curveOrder[0], children=True) crv2spans = cmds.getAttr(crv2shape[0]+'.spans') #creating birail if crv1spans<crv2spans : mesh = cmds.doubleProfileBirailSurface([curveOrder[1], curveOrder[3], curveOrder[0] ,curveOrder[2]], bl = 0.5 ,tp2 = 0 , ch = True , po = 1 ,tm = 1 , tp1 = 0) else : mesh = cmds.doubleProfileBirailSurface([curveOrder[0] ,curveOrder[2], curveOrder[1], curveOrder[3]], bl = 0.5 ,tp2 = 0 , ch = True , po = 1 ,tm = 1 , tp1 = 0) shape = cmds.listRelatives(mesh, children = True)[0] tess = cmds.listConnections(shape + '.inMesh') density = 12 bboxGrp = cmds.exactWorldBoundingBox(curveGrp) cmds.setAttr(tess[0] + '.polygonType', 1) cmds.setAttr(tess[0] + '.uType', 1) cmds.setAttr(tess[0] + '.vType', 1) cmds.setAttr(tess[0] + '.format', 2) #check the order of u and v for tesselation to be homogeneous if ((bboxGrp[3] - bboxGrp[0])*density)>((bboxGrp[4] - bboxGrp[1])*density) : cmds.setAttr(tess[0] + '.uNumber', int((bboxGrp[3] - bboxGrp[0])*density)) cmds.setAttr(tess[0] + '.vNumber', int((bboxGrp[4] - bboxGrp[1])*density)) else : cmds.setAttr(tess[0] + '.vNumber', int((bboxGrp[3] - bboxGrp[0])*density)) cmds.setAttr(tess[0] + '.uNumber', int((bboxGrp[4] - bboxGrp[1])*density)) cmds.parent(mesh[0], curveGrp)
def bbMinMaxMVector(obj): #returns the vector values of the BB of an object objBB = mc.exactWorldBoundingBox(obj) objBBmin = om.MVector(objBB[0],objBB[1],objBB[2]) objBBmax = om.MVector(objBB[3],objBB[4],objBB[5]) centre = (objBBmin + objBBmax )/2 outmin = objBBmin - centre outmax = objBBmax - centre return outmin, outmax
def buildBoundingBoxGeo(objectName, noChildren, ignoreInv): ''' Builds a bounding box from the selected object. ''' # as a workaround to a Maya bug duplicate said object to use to evaluate the box size (I know it's messy) duplicatedObject = cmds.duplicate(objectName, rc=True, un=False, ic=False, n='duplicated_'+objectName) dupObjChildren = cmds.listRelatives(duplicatedObject, children=True, typ='transform') # unlock attributes so we can freeze the duped geo for piece in duplicatedObject: cmds.setAttr(piece+".translateX", lock=False) cmds.setAttr(piece+".translateY", lock=False) cmds.setAttr(piece+".translateZ", lock=False) cmds.setAttr(piece+".translate", lock=False) cmds.setAttr(piece+".rotateX", lock=False) cmds.setAttr(piece+".rotateY", lock=False) cmds.setAttr(piece+".rotateZ", lock=False) cmds.setAttr(piece+".rotate", lock=False) cmds.setAttr(piece+".scaleX", lock=False) cmds.setAttr(piece+".scaleY", lock=False) cmds.setAttr(piece+".scaleZ", lock=False) cmds.setAttr(piece+".scale", lock=False) # delete children if we want only the one object if noChildren: cmds.select(dupObjChildren, r=True) cmds.delete() # unparent and freeze the geo (cause maya doesn't calculate the box properly otherwise) if cmds.listRelatives(duplicatedObject[0], p=True): newName = cmds.parent(duplicatedObject[0], w=True) cmds.makeIdentity(duplicatedObject[0], apply=True,translate=True, rotate=True, scale=True) # get the bounding box then blow away the duped geo boundingBoxDims = cmds.exactWorldBoundingBox(duplicatedObject[0], ii=ignoreInv) cmds.delete(duplicatedObject[0]) # calculate the dimensions and centre of the box boxWidth = boundingBoxDims[3] - boundingBoxDims[0] boxHeight = boundingBoxDims[4] - boundingBoxDims[1] boxDepth = boundingBoxDims[5] - boundingBoxDims[2] boxCentreX = (boxWidth/2)+boundingBoxDims[0] boxCentreY = (boxHeight/2)+boundingBoxDims[1] boxCentreZ = (boxDepth/2)+boundingBoxDims[2] # build the box and put in the right place cubeName = cmds.polyCube(w=boxWidth, h=boxHeight, d=boxDepth, ch=False, n=objectName+'_bBox') cmds.xform(cubeName, ws=True, t=(boxCentreX, boxCentreY, boxCentreZ)) return cubeName
def cubeCell(obj,parent,mat,aPos): mc.setAttr(obj + '.visibility', False) BB = mc.exactWorldBoundingBox(obj) activeShard = mc.polyCube( ch = False, sx=1, sy=1, sz=1, w = ((BB[3]-BB[0])*2), h=((BB[4]-BB[1])*2), d = ((BB[5]-BB[2])*2)) activeShard = activeShard[0] mc.move(aPos[0], aPos[1], aPos[2], activeShard, a = True) mc.setAttr(activeShard + '.visibility', True) mc.sets( activeShard, forceElement = ('%sSG' % (mat)), e = True) dupe = mc.duplicate(obj, rr = True) cutShard = dupe[0] mc.delete (cutShard, ch = True) mc.setAttr(cutShard + '.visibility', True) return activeShard, cutShard
def volumeScatter(name, count): a=[] bbox = cmds.exactWorldBoundingBox(name) for i in range(count): x = random.uniform(bbox[0], bbox[3]) y = random.uniform(bbox[1], bbox[4]) z = random.uniform(bbox[2], bbox[5]) newObj = cmds.polyCone()[0] a.append(newObj) cmds.move(x,y,z,newObj) return a
def createBoundingBox(): for i in cmds.ls(sl=True): print i cube = cmds.polyCube()[0] x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(i, calculateExactly=True) cmds.move(x1, '%s.f[5]' % cube, x=True) cmds.move(y1, '%s.f[3]' % cube, y=True) cmds.move(z1, '%s.f[2]' % cube, z=True) cmds.move(x2, '%s.f[4]' % cube, x=True) cmds.move(y2, '%s.f[1]' % cube, y=True) cmds.move(z2, '%s.f[0]' % cube, z=True) cmds.rename(i+"_BBox")
def returnBoundingBoxSize (meshGrp,objOnly = False): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Pass an object, mesh group or whatever into it, it calculates it's bounding box info and returns list ARGUMENTS: meshGrp(string) - mesh or mesh group RETURNS: returnList(list) - [xLength,yLength,zLength] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ if type(meshGrp) is list: for o in meshGrp: assert mc.objExists(o),"returnBoundingBoxSize: meshGrp object doesn't exist: '%s'"%o else: assert mc.objExists(meshGrp),"returnBoundingBoxSize: meshGrp doesn't exist: '%s'"%meshGrp returnList = [] boundingBoxSize = [] if objOnly: buffer= mc.duplicate(meshGrp,returnRootsOnly=True) l_relatives = mc.listRelatives(buffer[0],allDescendents = True,fullPath = True,type = 'transform') if l_relatives:mc.delete(l_relatives) box = mc.exactWorldBoundingBox (buffer[0]) if buffer:mc.delete(buffer) #box = mc.exactWorldBoundingBox (meshGrp) else: box = mc.exactWorldBoundingBox (meshGrp) rawBuffer = [(box[3] - box[0]), (box[4] - box[1]), (box[5] - box[2])] for number in rawBuffer: if mayaVersion >= 2010: returnList.append(float('{0:f}'.format(number))) else: returnList.append(float(number)) return returnList
def shortDistance(self): if len(self.follicleGrp)<2: print "***ERROR: Select 2 or more follicles." return i=-1 for a in self.follicleGrp: i+=1 x1, y1, z1, x2, y2, z2 = cm.exactWorldBoundingBox(a) self.FolBBoxGrp.append((x1, y1, z1)) for b in reversed(self.follicleGrp): x2, y2, z2, x3, y3, z3 = cm.exactWorldBoundingBox(b) tempDist = math.sqrt(((x1-x2)**2)+((y1-y2)**2)+((z1-z2)**2)) if tempDist < self.Dist: if b==a: pass else: self.Dist = tempDist self.Dist/=2 print 'Shortest distance:', self.Dist if self.Dist<.5: print '***WARNING: Range is <0.5. May create empty groups.'
def voroLocal(): density = cmds.intSliderGrp( 'localDensity', query = True, value = True) density = density * 10 selectedVerts = cmds.ls( sl = True ) selectedMesh = selectedVerts[0].split('.') seeds = [] if len( selectedVerts ) == 1: shape = selectedVerts[0] bbox = cmds.exactWorldBoundingBox( selectedMesh[0] ) for i in range( density ): vtx = cmds.xform( selectedVerts[0], q = True, ws = True, t = True ) seed = cmds.spaceLocator( p = ( 0, 0, 0), a = True )[0] cmds.move( random.uniform( vtx[0] - 0.1, vtx[0] + 0.1 ), random.uniform( vtx[1] - 0.1, vtx[1] + 0.1 ), random.uniform( vtx[2] - 0.1, vtx[2] + 0.1 ), a = True ) cmds.scale( 0.1, 0.1, 0.1, a = True, ocp = True ) seedL = cmds.xform( seed, q = True, ws = True, t = True ) if( seedL[0] > bbox[0] and seedL[0] < bbox[3] and seedL[1] > bbox[1] and seedL[1] < bbox[4] and seedL[2] > bbox[2] and seedL[2] < bbox[5] ): seeds.append( seed ) else: cmds.select( seed ) cmds.delete() print(len(seeds)) for i in range ( 0, len(seeds)): meshCopy = cmds.duplicate( selectedMesh[0] ) for j in range ( 0, len(seeds)): if i != j: voronoiFracture( i, j, seeds, meshCopy ) cmds.select( selectedMesh[0] ) cmds.delete() cmds.select( *seeds ) cmds.delete() elif( len( selection ) > 1 ): print( 'error: please select only 1 vertex' ) else: print( 'error: please select a vertex' )
def createBBoxFromSelected(): import maya.cmds as cmds sel = cmds.ls(sl=True) x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(sel, calculateExactly=True) cube = cmds.polyCube()[0] cmds.move(x1, '%s.f[5]' % cube, x=True) cmds.move(y1, '%s.f[3]' % cube, y=True) cmds.move(z1, '%s.f[2]' % cube, z=True) cmds.move(x2, '%s.f[4]' % cube, x=True) cmds.move(y2, '%s.f[1]' % cube, y=True) cmds.move(z2, '%s.f[0]' % cube, z=True)
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 makebb(parent): children = cmds.listRelatives(parent) if children == None: return print parent for rn in children: x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(parent + "|" + rn, calculateExactly=True) cube = cmds.polyCube()[0] cmds.move(x1, "%s.f[5]" % cube, x=True) cmds.move(y1, "%s.f[3]" % cube, y=True) cmds.move(z1, "%s.f[2]" % cube, z=True) cmds.move(x2, "%s.f[4]" % cube, x=True) cmds.move(y2, "%s.f[1]" % cube, y=True) cmds.move(z2, "%s.f[0]" % cube, z=True) makebb(rn)
def fix (): geoSource = cmds.ls(selection=True) for g in geoSource: print 'category name = ' + str(g) geometry = cmds.listRelatives(g) for i in geometry: print 'found = ' + str(i) cmds.select(i) # bounding box & center each object bbox = cmds.exactWorldBoundingBox() bottom = [(bbox[0] + bbox[3])/2, bbox[1], (bbox[2] + bbox[5])/2] cmds.xform(piv=bottom, ws=True) cmds.move(rpr=True) # freeze transforms cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)