def setThreePanelLayout(): shotCamera = animMod.getShotCamera() if not shotCamera: shotCamera = "persp" mel.eval("toolboxChangeQuickLayoutButton \"Persp/Graph/Hypergraph\" 2;"+\ #"ThreeTopSplitViewArrangement;"+\ "lookThroughModelPanel %s hyperGraphPanel2;"%shotCamera+\ "lookThroughModelPanel persp modelPanel4;") #"scriptedPanel -e -rp modelPanel2 graphEditor1;") viewports = [view for view in cmds.getPanel(type='modelPanel') if view in cmds.getPanel(visiblePanels=True)] defaultCameras = [u'front', u'persp', u'side', u'top'] for view in viewports: camera = utilMod.getCamFromSelection([cmds.modelEditor(view, query=True, camera=True)]) cameraTransform = camera[0] cameraShape = camera[1] if cameraTransform in defaultCameras: utilMod.animViewportViewMode(view) if cameraTransform == "persp": cmds.camera(cameraTransform, edit=True, orthographic=False) cmds.setAttr("%s.nearClipPlane"%cameraShape, 1000) cmds.setAttr("%s.farClipPlane"%cameraShape, 10000000) cmds.setAttr("%s.focalLength"%cameraShape, 3500) else: utilMod.cameraViewMode(view) cmds.setAttr("%s.displayFilmGate"%cameraShape, 1) cmds.setAttr("%s.overscan"%cameraShape, 1)
def __init__ (self): try: self.name = self.get_camera_from_selection() [0] except: self.name = self.get_camera_from_panel() try: self.shape = cmds.listRelatives (self.name, shapes = True) [0] except: self.shape = "" if self.shape != "": self.res_x = cmds.getAttr ("defaultResolution.width") self.res_y = cmds.getAttr ("defaultResolution.height") self.focal = cmds.camera (self.shape, query = True, focalLength = True) self.aperture_h = cmds.getAttr (self.shape + ".horizontalFilmAperture") self.aperture_h = cmds.camera (self.shape, query = True, horizontalFilmAperture = True) self.aperture_v = cmds.getAttr (self.shape + ".verticalFilmAperture") self.pixelAspect = cmds.getAttr ("defaultResolution.pixelAspect") self.deviceAspect = cmds.getAttr ("defaultResolution.deviceAspectRatio") cmds.getAttr ("defaultResolution.lockDeviceAspectRatio") cmds.camera (self.shape, edit = True, displayResolution = 1) cmds.camera (self.shape, edit = True, displayFilmGate = 1) cmds.camera (self.shape, edit = True, farClipPlane = 1000000) cmds.camera (self.shape, edit = True, nearClipPlane = 0.01) cmds.setAttr (self.shape + ".focalLength", channelBox = True) cmds.setAttr (self.shape + ".horizontalFilmAperture", channelBox = True) cmds.setAttr (self.shape + ".verticalFilmAperture", channelBox = True) cmds.setAttr (self.name+".sx", keyable=False, channelBox = True) cmds.setAttr (self.name+".sy", keyable=False, channelBox = True) cmds.setAttr (self.name+".sz", keyable=False, channelBox = True) cmds.setAttr (self.name+".v", keyable=False, channelBox = True) self.print_info() #self.add_imageplane() else: print ":: SELECT CAMERA"
def createPreviewCamera(objectName): """ create object preview camera, frame the object :param objectName: :return: """ cmds.camera() cmds.rename("preview") mel.eval("cameraMakeNode 2 \"\";") selList = cmds.ls(selection=True) # print(selList) previewCam = selList[0] previewAim = selList[1] boxMin = cmds.getAttr(objectName + ".boundingBoxMin")[0] boxMax = cmds.getAttr(objectName + ".boundingBoxMax")[0] ## move aim to bbx center aimPos = [(boxMax[0] + boxMin[0]) / 2, (boxMax[1] + boxMin[1]) / 2, (boxMax[2] + boxMin[2]) / 2] # print(aimPos) cmds.move(aimPos[0], aimPos[1], aimPos[2], previewAim) camPosy = boxMax[1] * 1.7 camPosx = boxMin[0] + camPosy * 1.2 camPosz = boxMin[2] + camPosy * 1.2 cmds.move(camPosx, camPosy, camPosz, previewCam) preCamShape = cmds.listRelatives(previewCam, children=True)[0] cmds.lookThru(preCamShape, "perspView")
def nuke_track_node(): """ creates a nuke track node for the selected transform. selection order: trasnform, camera """ selection = cmds.ls( selection = True ) point = selection[0] camera = selection[1] cameraShape = cmds.listRelatives( shapes = True )[0] aperture_h = cmds.camera( camera, hfa=1, q=1) aperture_v = cmds.camera( camera, vfa=1, q=1) trackNode = 'Tracker3 { track1 {{curve x1 ' tx = '' ty = '' endframe = 48 for frame in range( 1, endframe + 1 ): cmds.currentTime( frame ) fov_h = cmds.camera( camera, hfv=1, q=1) fov_v = cmds.camera( camera, vfv=1, q=1) track = get_normalized_screen_position( point, camera, fov_h, fov_v, aperture_h, aperture_v ) tx += str( track[0] * 1280 ) + ' ' ty += str( track[1] * 720 ) + ' ' trackNode += tx + '} {curve x1 ' + ty + '}}}' print '#' * 50 print '>>> tracker node, copy paste to nuke:' print trackNode
def camCreator(*args): import maya.cmds as cmds #select Perspective camera cmds.select('persp') perspCam = cmds.ls(sl=True)[0] #records the perspective camera's values into variables perspCam_TX = cmds.getAttr(perspCam + '.translateX') perspCam_TY = cmds.getAttr(perspCam + '.translateY') perspCam_TZ = cmds.getAttr(perspCam + '.translateZ') perspCam_RX = cmds.getAttr(perspCam + '.rotateX') perspCam_RY = cmds.getAttr(perspCam + '.rotateY') perspCam_RZ = cmds.getAttr(perspCam + '.rotateZ') perspCam_FCP = cmds.getAttr(perspCam + '.fcp') perspCam_NCP = cmds.getAttr(perspCam + '.ncp') #creates new camera and renames it, then saves the new name into a variable cmds.camera(dfg=True, jc=True) cmds.rename('camera1', 'render_cam_01') camName = cmds.ls(sl=True)[0] #applies the perspective camera's attributes to the newly created camera cmds.setAttr(camName + '.translateX', perspCam_TX) cmds.setAttr(camName + '.translateY', perspCam_TY) cmds.setAttr(camName + '.translateZ', perspCam_TZ) cmds.setAttr(camName + '.rotateX', perspCam_RX) cmds.setAttr(camName + '.rotateY', perspCam_RY) cmds.setAttr(camName + '.rotateZ', perspCam_RZ) cmds.setAttr(camName + '.fcp', perspCam_FCP) cmds.setAttr(camName + '.ncp', perspCam_NCP)
def onActivateButtonClick(self,param): if self.isActive is True: self.isActive = False if self.cameraOrigin is not None : cmds.camera(self.currentCamera, edit=True, position=self.cameraOrigin["translate"], rotation=self.cameraOrigin["rotation"]) self.setConsoleText("Rigging desactive.") for p in self.pointsMap : self.onStateButtonClick(p) return self.isActive = True self.cameraOrigin = { "translate" : cmds.xform(self.currentCamera, query=1, ws=1,rp=1), "rotation" : cmds.xform(self.currentCamera, query=1, ws=1,ro=1), } cmds.camera(self.currentCamera, edit=True, position=[0,0,self.cameraZ],rotation=[0,0,0]) self.setConsoleText("Rigging actif, choisissez un point.", color=[0,0.4,0])
def process_reference(self, context, name, namespace, data): import maya.cmds as cmds # Get family type from the context cmds.loadPlugin("AbcImport.mll", quiet=True) nodes = cmds.file(self.fname, namespace=namespace, sharedReferenceFile=False, groupReference=True, groupName="{}:{}".format(namespace, name), reference=True, returnNewNodes=True) cameras = cmds.ls(nodes, type="camera") # Check the Maya version, lockTransform has been introduced since # Maya 2016.5 Ext 2 version = int(cmds.about(version=True)) if version >= 2016: for camera in cameras: cmds.camera(camera, edit=True, lockTransform=True) else: self.log.warning("This version of Maya does not support locking of" " transforms of cameras.") self[:] = nodes return nodes
def createPreviewCamera(objectName): cmds.camera() cmds.rename("preview") mel.eval("cameraMakeNode 2 \"\";") selList = cmds.ls(selection=True) print(selList) previewCam = selList[0] previewAim = selList[1] boxMin = cmds.getAttr(objectName + ".boundingBoxMin")[0] boxMax = cmds.getAttr(objectName + ".boundingBoxMax")[0] ## move aim to bbx center aimPos = [(boxMax[0] + boxMin[0]) / 2, (boxMax[1] + boxMin[1]) / 2, (boxMax[2] + boxMin[2]) / 2] print(aimPos) cmds.move(aimPos[0], aimPos[1], aimPos[2], previewAim) camPosy = boxMax[1] * 1.7 camPosx = boxMin[0] + camPosy * 1.2 camPosz = boxMin[2] + camPosy * 1.2 cmds.move(camPosx, camPosy, camPosz, previewCam) preCamShape = cmds.listRelatives(previewCam, children=True)[0] cmds.lookThru(preCamShape, "perspView")
def toggleGate(item): selCamera = cmds.modelEditor('editor', query=True, camera=True) if item: cmds.camera(selCamera, edit=True, displayGateMask=True, displayResolution=True, overscan=1.3) cmds.modelEditor('editor', edit=True, nurbsCurves=False, cameras=False, joints=False, ikHandles=False, grid=False) else: cmds.camera(selCamera, edit=True, displayGateMask=False, displayResolution=False, overscan=1.0) cmds.modelEditor('editor', edit=True, nurbsCurves=True, cameras=True, joints=True, ikHandles=True, grid=True)
def set_clip_plane_vals(near_val, far_val): cams = cmds.ls(cameras=True) for curr_cam in cams: try: cmds.camera (curr_cam, edit=True, cp=True, ncp=near_val, fcp=far_val) except RuntimeError, err: print 'Error: Camera clipping planes not set correctly for camera %s. (%s)' % (curr_cam, err[0][:-1])
def creatStereo(): camL = mc.ls(sl=1) if camL == []: mc.confirmDialog(title="Missing", message="Please select a camera!", button=["Ok"]) return cam = camL[0] camShape = mc.listRelatives(cam, s=1)[0] FL = mc.camera(cam, q=1, fl=1) NCP = mc.camera(cam, q=1, ncp=1) FCP = mc.camera(cam, q=1, fcp=1) cam3d = maya.app.stereo.stereoCameraRig.createStereoCameraRig() mc.parent(cam3d[0], cam) mc.setAttr(cam3d[0] + ".translate", 0, 0, 0, lock=1) mc.setAttr(cam3d[0] + ".rotate", 0, 0, 0, lock=1) mc.setAttr(cam3d[0] + ".scale", 1, 1, 1, lock=1) cam3dShape = mc.listRelatives(cam3d[0], s=1)[0] mc.connectControl("interaxialSleder", stereoShape + ".interaxialSeparation") mc.connectControl("zeroSleder", stereoShape + ".zeroParallax") mc.setAttr(cam3dShape + ".focalLength", FL) mc.setAttr(cam3dShape + ".nearClipPlane", NCP) mc.setAttr(cam3dShape + ".farClipPlane", FCP) mc.setAttr(cam3dShape + ".zeroParallaxPlane", 1) mc.setAttr(cam3dShape + ".safeViewingVolume", 1) for i in cam3d: mc.rename(i, cam + "_" + i) camListStereo = mc.ls(type="stereoRigTransform") if camListStereo == []: mc.floatSliderGrp(interaxialSleder, e=1, enable=False) mc.floatSliderGrp(zeroSleder, e=1, enable=False) else: stereoShape = mc.listRelatives(camListStereo[0], s=1)[0] mc.floatSliderGrp(interaxialSleder, e=1, enable=True) mc.floatSliderGrp(zeroSleder, e=1, enable=True) mc.connectControl(interaxialSleder, cam3dShape + ".interaxialSeparation") mc.connectControl(zeroSleder, cam3dShape + ".zeroParallax")
def get_depth_rect(self, depth): """Get points defining a depth plane. Each point is a corner of the view: top left, bottom left, top right, bottom right. Args: depth (float): depth of plane Returns: (HPoint list): 4 points """ _mtx = self.get_m() _hfv = math.radians( cmds.camera(self, query=True, horizontalFieldOfView=True)) _vfv = math.radians( cmds.camera(self, query=True, verticalFieldOfView=True)) _corners = [] for _x_mult in [1, -1]: _x_len = depth * math.tan(_hfv/2) for _y_mult in [1, -1]: _y_len = depth * math.tan(_vfv/2) _x_cpnt = _mtx.lx_() * _x_mult * _x_len _y_cpnt = _mtx.ly_() * _y_mult * _y_len _z_cpnt = -_mtx.lz_() * depth _corner = _mtx.pos() + _x_cpnt + _y_cpnt + _z_cpnt _corners.append(_corner) _tl, _bl, _tr, _br = _corners return _tl, _bl, _tr, _br
def save_image_with_camera_pos(csv_writer, mesh_name, file_ext, dest_dir, camera_pos, camera_interest_pos): camera_name, camera_shape = cmd.camera(p=camera_pos, wci=camera_interest_pos) cmd.setAttr(camera_shape + '.backgroundColor', back_color[0], back_color[1], back_color[2], type="double3") cmd.setAttr(camera_shape + ".renderable", 1) focal_length = cmd.camera(camera_shape, q=True, fl=True) inches_to_mm = 25.4 app_horiz = cmd.camera(camera_shape, q=True, hfa=True) * inches_to_mm app_vert = cmd.camera(camera_shape, q=True, vfa=True) * inches_to_mm pixel_width = cmd.getAttr("defaultResolution.width") pixel_height = cmd.getAttr("defaultResolution.height") focal_length_x_pixel = pixel_width * focal_length / app_horiz focal_length_y_pixel = pixel_height * focal_length / app_vert # print cmd.camera(camera_shape, q=True, fs=True) # print focal_length # print app_horiz, app_vert # print focal_length_x_pixel, focal_length_y_pixel image_file = mesh_name + "." + file_ext image_src = cmd.render(camera_shape) image_dest = path.join(dest_dir, image_file) shutil.move(image_src, image_dest) save_camera_data_to_writer(csv_writer, mesh_name, camera_pos, camera_interest_pos, focal_length)
def twoK1152Cam(self): camName= "fin_05_shotCAM_01" camMake = cmds.camera(name=camName) camShape = camMake[1] cmds.camera( camShape, e=True, ff='horizontal', hfa=0.98, vfa=0.551 ) twoK1152(self) del camName, camMake, camShape
def highDefCam(self): camName= "fin_06_shotCAM_01" camMake = cmds.camera(name=camName) camShape = camMake[1] cmds.camera( camShape, e=True, ff='horizontal', hfa=0.792, vfa=0.446 ) highDef(self) del camName, camMake, camShape
def Playblastfunction(self): self.showHUD() folder = self.GetFolder() qualityNum = self.GetQuality() scale = self.GetScale() camShape = self.GetCurrentCam().split('|')[-1] camTrans = cmds.listRelatives(camShape, parent=1)[0].replace(':', '_') judgeArg = cmds.camera(camShape, q=1, overscan=1) cmds.camera(camShape, edit=1, overscan=1.0) movPath = cmds.playblast(format='avi', filename=folder + camTrans + '.avi', forceOverwrite=1, sequenceTime=0, clearCache=1, viewer=0, showOrnaments=1, offScreen=1, fp=4, percent=scale * 100, compression='none', quality=qualityNum, w=cmds.getAttr('defaultResolution.width'), h=cmds.getAttr('defaultResolution.height')) self.setUploadB(True) if judgeArg == 1.3: cmds.camera(camShape, edit=1, overscan=1.3) self.movPath = movPath self.setOpenB() self.LocalPlayblastPath = folder #~ 拍屏文件本地路径 self.playblastFile = camTrans + '.avi' #~ 拍屏文件名称
def _setCameraDefaults(camera=''): """ Sets the base defaults for the camera @param camera: The name of the camera transform node NOT the shape node! @type camera: String """ if not camera: camera = utils.getShotCamera() if camera: camName = camera camShape = cmds.listRelatives(camera, shapes=True)[0] cmds.camera(camName, e=True, displayFilmGate=0, displayResolution=1, overscan=1.19) cmds.setAttr("%s.displayGateMask" % camShape, 1) cmds.setAttr('%s.displayGateMaskOpacity' % camShape, 1) cmds.setAttr('%s.displayGateMaskColor' % camShape, 0, 0, 0, type='double3') cmds.setAttr("%s.displayResolution" % camShape, 1) cmds.setAttr("%s.displaySafeAction" % camShape, 1) cmds.setAttr("%s.journalCommand" % camShape, 0) cmds.setAttr("%s.nearClipPlane" % camShape, 0.05) cmds.setAttr("%s.overscan" % camShape, 1)
def formLayout_Edit(self, form): count = len(self.camViewInfo) sumHor = 0 maxVer = 0 for [hor, ver] in self.camFilmAperture.values(): sumHor += hor maxVer = max(maxVer, ver) perHor = 100 / sumHor camPanelLeftDistance = 0 for num in xrange(count): camName = self.camViewInfo[int(num) + 1] panelHorNum = int(self.camFilmAperture[camName][0] * perHor) panelName = '%s_panel' % camName mc.camera(camName, e=True, dr=False, ovr=1, displayFilmGate=False) mc.formLayout(form, e=True, attachForm=[(panelName, 'top', 1), (panelName, 'bottom', 1)], attachPosition=[ (panelName, 'left', 0, camPanelLeftDistance), (panelName, 'right', 0, (camPanelLeftDistance + panelHorNum)) ]) camPanelLeftDistance += panelHorNum return (sumHor, maxVer)
def save_image_with_camera_pos(csv_writer, mesh_name, file_ext, dest_dir, camera_pos, camera_interest_pos): camera_name, camera_shape = cmd.camera(p=camera_pos, wci=camera_interest_pos) cmd.setAttr(camera_shape+'.backgroundColor', back_color[0], back_color[1], back_color[2], type="double3") cmd.setAttr(camera_shape+".renderable", 1) focal_length = cmd.camera(camera_shape, q=True, fl=True) inches_to_mm = 25.4 app_horiz = cmd.camera(camera_shape, q=True, hfa=True) * inches_to_mm app_vert = cmd.camera(camera_shape, q=True, vfa=True) * inches_to_mm pixel_width = cmd.getAttr("defaultResolution.width") pixel_height = cmd.getAttr("defaultResolution.height") focal_length_x_pixel = pixel_width * focal_length / app_horiz focal_length_y_pixel = pixel_height * focal_length / app_vert # print cmd.camera(camera_shape, q=True, fs=True) # print focal_length # print app_horiz, app_vert # print focal_length_x_pixel, focal_length_y_pixel image_file = mesh_name+"."+file_ext image_src = cmd.render(camera_shape) image_dest = path.join(dest_dir, image_file) shutil.move(image_src, image_dest) save_camera_data_to_writer(csv_writer, mesh_name, camera_pos, camera_interest_pos, focal_length)
def CreateCamera(self): print "Creating camera" #Array to store all objects in the scene cmds.select(None) #Copy from the current active camera cmds.duplicate( self.GetActiveCamera(), name = self.Camera) try:cmds.delete(self.Camera + "|CMForegroundPlane") except:pass try:cmds.delete(self.Camera + "|CMBackgroundPlane") except:pass i = 0 while(cmds.objExists("shot_" + str(i))): try:cmds.delete(self.Camera + "|" + "shot_" + str(i) + "_ImagePlane") except:pass i = i + 1 #Make the camera startup so that the user may not delete it directly #Enable the resolution gate cmds.camera(self.Camera, edit = True, startupCamera = True, displayResolution = True) #Make the camera hidden cmds.setAttr(self.Camera + ".visibility", False) #Add the attributes to define range and renderability cmds.select(self.Camera) cmds.addAttr(longName = 'CMRenderable', attributeType = 'bool', defaultValue = True) cmds.addAttr(longName = 'StartRange', attributeType = 'short', defaultValue = 0, min = 0, max = 35) cmds.addAttr(longName = 'StopRange' , attributeType = 'short', defaultValue = 35, min = 0, max = 35) cmds.select(None)
def setThreePanelLayout(): shotCamera = animMod.getShotCamera() if not shotCamera: shotCamera = "persp" mel.eval("toolboxChangeQuickLayoutButton \"Persp/Graph/Hypergraph\" 2;"+\ #"ThreeTopSplitViewArrangement;"+\ "lookThroughModelPanel %s hyperGraphPanel2;"%shotCamera+\ "lookThroughModelPanel persp modelPanel4;") #"scriptedPanel -e -rp modelPanel2 graphEditor1;") viewports = [ view for view in cmds.getPanel(type='modelPanel') if view in cmds.getPanel(visiblePanels=True) ] defaultCameras = [u'front', u'persp', u'side', u'top'] for view in viewports: camera = utilMod.getCamFromSelection( [cmds.modelEditor(view, query=True, camera=True)]) cameraTransform = camera[0] cameraShape = camera[1] if cameraTransform in defaultCameras: utilMod.animViewportViewMode(view) if cameraTransform == "persp": cmds.camera(cameraTransform, edit=True, orthographic=False) cmds.setAttr("%s.nearClipPlane" % cameraShape, 1000) cmds.setAttr("%s.farClipPlane" % cameraShape, 10000000) cmds.setAttr("%s.focalLength" % cameraShape, 3500) else: utilMod.cameraViewMode(view) cmds.setAttr("%s.displayFilmGate" % cameraShape, 1) cmds.setAttr("%s.overscan" % cameraShape, 1)
def export2DPointData(path,pt,cam,start,end,width=2348,height=1152): ''' Export raw 2D (screen space) point position data based on the specified camera to an ascii text file @param path: Directory to save the 2D data export file to @type path: str @param pt: The point to export 2D position data for @type pt: str @param cam: The camera used to calculate the 2D screen space from @type cam: str @param start: The first frame of the data sequence @type start: int @param end: The last frame of the data sequence @type end: int @param width: Maximum output screen space width @type width: int @param height: Maximum output screen space height @type height: int ''' # Check path dirpath = path.replace(path.split('/')[-1],'') if not os.path.isdir(dirpath): os.makedirs(dirpath) # Open file for writing file = open(path,"w") # ----------------------- # - Write Position Data - # ----------------------- # Cycle through frame range for f in range(start,end+1): # Set current frame mc.currentTime(f) # Get point world space position pos = glTools.utils.base.getMPoint(pt) # Get camera details cam_hfv = mc.camera(cam,q=True,hfv=True) cam_vfv = mc.camera(cam,q=True,vfv=True) cam_mat = glTools.utils.matrix.getMatrix(cam).inverse() # Calculate 2D point ssPt = pos * cam_mat ptx = ( ( ( ssPt.x / -ssPt.z ) / math.tan( math.radians(cam_hfv / 2) ) ) / 2.0) + 0.5 pty = ( ( ( ssPt.y / -ssPt.z ) / math.tan( math.radians(cam_vfv / 2) ) ) / 2.0) + 0.5 # Write data to file file.write(str(ptx * width) + ' ' + str(pty * height) + '\n') # End file with new line file.write('') # Close file file.close() # Print result print('2D point data exported to '+path)
def get_toplevel_node(): toplevel_nodes = cmds.ls(assemblies=True) # Filter out default cameras for toplevel_node in toplevel_nodes: try: cmds.camera(toplevel_node, q=True, startupCamera=True) except RuntimeError: return toplevel_node
def AurTDOverscan(self): view = OpenMayaUI.M3dView.active3dView() cam = OpenMaya.MDagPath() view.getCamera(cam) camPath = cam.fullPathName() # if cmds.camera(camPath, q=True, displayResolution=1): cmds.camera(camPath, e=True, overscan=1.05) print ("set current camera's overscan to 1.05")
def place_cameras(points): for i in points: cmds.camera(centerOfInterest=5, focalLength=35, lensSqueezeRatio=1, cameraScale=1, horizontalFilmAperture=1.41732, horizontalFilmOffset=0, verticalFilmAperture=0.94488, verticalFilmOffset=0, filmFit="fill", overscan=1, motionBlur=0, shutterAngle=144, nearClipPlane=0.1, farClipPlane=10000, orthographic=0, orthographicWidth=30, panZoomEnabled=0, horizontalPan=0, verticalPan=0, zoom=1) cmds.move(i[0], 5.0, i[1]) #cmds.rotate(0.0, i[2]+90, 0.0, absolute=True, objectSpace=True, forceOrderXYZ=True) cmds.viewPlace(lookAt=[0, 3.0, 0])
def CREATE_MAIN_SEQ_CAM_DB(): global selectedCamera_DB selectedCamera_DB = "None" sT = 'startShotRange' eT = 'endShotRange' MC = "sequenceCameraMain" parMC = "sequenceCameraMain_parentConstraint1" if not selectedCamera_DB is None: if (selectedCamera_DB == -1): startTime = cm.getAttr("{}.{}".format(listShotsCamera_DB[0], sT)) endTime = cm.getAttr("{}.{}".format(listShotsCamera_DB[0], eT)) cm.playbackOptions(min=startTime, max=endTime) selectedCamera_DB = 0 #------------------------------------------------------- if (len(listShotsCamera_DB) == 0): return if cm.objExists(MC): cm.setAttr("{}.v".format(MC), 0) checkAttr = cm.attributeQuery("currentFrame", n=MC, ex=1) if (checkAttr == 0): cm.addAttr(MC, ln="currentFrame", at='double', dv=0, keyable=1) LOCK_TRANSLATE_ROTATE_CAMERA_DB(MC, 0) if cm.objExists(parMC): for i in range(len(listShotsCamera_DB)): testCam = 0 checkAttr = cm.attributeQuery("{}W{}".format( listShotsCamera_DB[i], i), n=parMC, ex=1) if (checkAttr == 1): testCam = cm.getAttr("{}.{}W{}".format( parMC, listShotsCamera_DB[i], i)) if (testCam == 1): selectedCamera_DB = i cm.delete(parMC) CAMERA_SEQ_PARENT_DB(MC, parMC) cm.setAttr( "{}.{}W{}".format(parMC, listShotsCamera_DB[selectedCamera_DB], selectedCamera_DB), 1) LOCK_TRANSLATE_ROTATE_CAMERA_DB(MC, 1) else: cm.camera() cm.rename("aaaabbbb") cm.rename("aaaabbbb", MC) cm.addAttr(MC, ln="currentFrame", at='double', dv=0, keyable=1) CAMERA_SEQ_PARENT_DB(MC, parMC) cm.setAttr("{}.{}W{}".format(parMC, listShotsCamera_DB[0], 0), 1) LOCK_TRANSLATE_ROTATE_CAMERA_DB(MC, 1) cm.setAttr("{}.v".format(MC), 0)
def HotKey_SetUI(): oSel = [str(o) for o in cmds.ls(sl = True, o = True)] # Timeline setting : Display Key Ticks to : 'selected' oPlayBackSlider = mel.eval('$tmpVar=$gPlayBackSlider') cmds.timeControl(oPlayBackSlider, edit = True, animLayerFilterOptions = 'selected') # ANIM camera creation iRecreateAnimCam = 0 # 1 = Re-create ANIM_CAM everytime. 0 = Only create when there is no cam. sCamName = 'ANIM_CAM' if iRecreateAnimCam: aList = ['focalLength', 'focusDistance', 'centerOfInterest', 'locatorScale', 'nearClipPlane', 'farClipPlane'] aTransform = [] aAttr = [] if cmds.objExists(sCamName): aTransform.append(cmds.xform(sCamName, q = True, ws = True, t = True)) aTransform.append(cmds.xform(sCamName, q = True, ws = True, ro = True)) for a in aList: aAttr.append(cmds.getAttr('%sShape.%s'%(sCamName,a))) cmds.delete(sCamName) oCamera = cmds.camera() cmds.rename(oCamera[0], '%s'%sCamName) if aTransform: cmds.xform(sCamName, ws = True, t = aTransform[0]) cmds.xform(sCamName, ws = True, ro = aTransform[1]) for i, v in enumerate(aAttr): cmds.setAttr('%sShape.%s'%(sCamName,aList[i]),v) else: if not cmds.objExists(sCamName): oCamera = cmds.camera() cmds.rename(oCamera[0], '%s'%sCamName) # Visibility Layer creation aLayer = ['Hidden', 'NonSelect'] aLayerSetting = [ [28,2,False, True], [28,2,True, False],] for i, a in enumerate(aLayer): if not cmds.objExists(a): cmds.createDisplayLayer(e = True, name = a) for v, s in enumerate(['color', 'displayType', 'visibility', 'hideOnPlayback']): cmds.setAttr('%s.%s'%(aLayer[i], s),aLayerSetting[i][v]) # Set panel to custom. mel.eval('setNamedPanelLayout "Custom_Anim";') # CUSTOM TOOL - project based ProjectCustom_SetUI() # Custom tool for this proj # Selection - Back to what was selected first. cmds.select(oSel, r = True)
def run_app(self): """ Callback from when the menu is clicked. """ ## Tell the artist to be patient... eg not genY cmds.headsUpMessage("Building shotCam...", time = 1) inprogressBar = pbui.ProgressBarUI(title = 'Building Shotcam:') inprogressBar.show() ## Instantiate the API tk = sgtk.sgtk_from_path("T:/software/bubblebathbay") debug(app = self, method = 'run_app', message = 'API instanced...\n%s' % tk, verbose = False) debug(app = self, method = 'run_app', message = 'Fetch Shot Assets launched...', verbose = False) context = self.context ## To get the step debug(app = self, method = 'run_app', message = 'Context Step...\n%s' % context.step['name'], verbose = False) if context.step['name'] == 'Anm' or context.step['name'] == 'Blocking': inprogressBar.updateProgress(percent = 10, doingWhat = 'processing scene info...') cmds.cycleCheck(e = 1) ## Build an entity type to get some values from. entity = self.context.entity ## returns {'type': 'Shot', 'name': 'ep100_sh010', 'id': 1166} debug(app = self, method = 'run_app', message = 'entity... %s' % entity, verbose = False) ## Set the template to the maya publish folder shot_root_template = tk.templates[self.get_setting('shot_root_template')] debug(app = self, method = 'run_app', message = 'shot_root_template...\n%s' % shot_root_template, verbose = False) ## Now build the camera shotName = entity['name'] cameraName = '%s_shotCam' % shotName if self.doesAssetAlreadyExistInScene(cameraName): inprogressBar.updateProgress(percent = 100, doingWhat = 'Camera found...') inprogressBar.close() cmds.warning("Scene currently has a valid shotCamera in it! Aborting ...") QtGui.QMessageBox.information(None, "Scene currently has a valid shotCamera in it! Aborting ...") raise tank.TankError("Scene currently has a valid shotCamera in it! Aborting ...") else: inprogressBar.updateProgress(percent = 50, doingWhat = 'Building camera...') cmds.camera() cmds.rename('camera1', cameraName) self.tagShotCam(cameraName) ## Now set the default camera stuff up settings._setCameraDefaults(cameraName) settings._createCamGate(cameraName) ## Now set the renderGlobals up width = self.get_setting('movie_width') height = self.get_setting('movie_height') inprogressBar.updateProgress(percent = 90, doingWhat = 'Setting render globals...') settings._setRenderGlobals(width = width, height = height, animation = True) inprogressBar.updateProgress(percent = 100, doingWhat = 'Finished...') inprogressBar.close() cmds.headsUpMessage("shotCam built successfully...", time = 1) else: cmds.headsUpMessage("Current context is not a valid Shot context. Please make sure you are under a valid shotgun Shot context!", time = 2) cmds.warning("Current context is not a valid Shot context. Please make sure you are under a valid shotgun Shot context!") QtGui.QMessageBox.information(None, "Current context is not a valid Shot context. Please make sure you are under a valid shotgun Shot context!") raise tank.TankError("Current context is not a valid Shot context. Please make sure you are under a valid shotgun Shot context!")
def export2DPointData(path, pt, cam, start, end, width=2348, height=1152): """ Export raw 2D (screen space) point position data based on the specified camera to an ascii text file @param path: Directory to save the 2D data export file to @type path: str @param pt: The point to export 2D position data for @type pt: str @param cam: The camera used to calculate the 2D screen space from @type cam: str @param start: The first frame of the data sequence @type start: int @param end: The last frame of the data sequence @type end: int @param width: Maximum output screen space width @type width: int @param height: Maximum output screen space height @type height: int """ # Check path dirpath = path.replace(path.split('/')[-1], '') if not os.path.isdir(dirpath): os.makedirs(dirpath) # Open file for writing file = open(path, "w") # ----------------------- # - Write Position Data - # ----------------------- # Cycle through frame range for f in range(start, end + 1): # Set current frame cmds.currentTime(f) # Get point world space position pos = glTools.utils.base.getMPoint(pt) # Get camera details cam_hfv = cmds.camera(cam, q=True, hfv=True) cam_vfv = cmds.camera(cam, q=True, vfv=True) cam_mat = glTools.utils.matrix.getMatrix(cam).inverse() # Calculate 2D point ssPt = pos * cam_mat ptx = (((ssPt.x / -ssPt.z) / math.tan(math.radians(cam_hfv / 2))) / 2.0) + 0.5 pty = (((ssPt.y / -ssPt.z) / math.tan(math.radians(cam_vfv / 2))) / 2.0) + 0.5 # Write data to file file.write(str(ptx * width) + ' ' + str(pty * height) + '\n') # End file with new line file.write('') # Close file file.close() # Print result print('2D point data exported to ' + path)
def make(self, _make, **kwargs): """Can make a node in maya using this command. Valid things to make are, group, circle, scriptNode, customCurve. If customcurve, format type is sObjName..make(what = 'customCurve', curveType = 'validCurveType', orientation = 'Y') The list of valid types: triangle worldMove angledCompass worldRotate straightCompass twoDirRotate square fourDirRotate sphere moveRotate plus worldMove02 halfDiamond toe cube spineType01 cross jawEgg bulb hand star foot eyes """ if cmds.objExists(self.name): raise Exception, 'Object with name already exists in scene, you can not have duplicate names in scenes.' else: if _make == 'group': #print 'Making group %s now.' % self.name objects = kwargs.get('objects') if objects: cmds.group(objects, name = self.name, em = False) else: cmds.group(name = self.name, em = True) elif _make == 'locator': #print 'Building spacelocator %s now' % self.name cmds.spaceLocator(n = self.name, **kwargs) elif _make == 'circle': cmds.circle(n = self.name, **kwargs) self.name = '%s_ctrl' % self.name elif _make == 'scriptNode': cmds.scriptNode(n = self.name, **kwargs) elif _make == 'customCurve': ## Curve options are ### curveType = 'circle', snapTo = False, cstTo = False, orientation = 'Y', grouped = False, scaleFactor = 1, color = 15, boundingBox = True, dest = '', suffix = True, addGeoShowHide = True myNewCurve = BD_CurveBuilder.buildControlCurve(curveName = self.name, **kwargs) if kwargs.get('suffix'): self.name = '%s_ctrl' % myNewCurve else: self.name = '%s' % myNewCurve elif _make == 'nurbsPlane': cmds.nurbsPlane(n = '%s' % self.name, **kwargs) elif _make == 'camera': cmds.camera() cmds.rename('camera1', '%s' % self.name)
def getScreenshot(self): #takes a screenshot of the current viewport if self.tempFile is None: filename = str(uuid.uuid4()) self.tempFile = tempfile.gettempdir()+os.sep+filename+".png" cam = cmds.optionMenuGrp("frw_camera",q=True,value=True) #if not cam == "": # cmds.lookThru(cam) panel = cmds.getPanel( withFocus=True ) camera = "" if "modelPanel" == cmds.getPanel(typeOf=panel): camera = cmds.modelEditor(panel, q=True, camera=True)#`modelEditor -q -camera $panel`; else: return "screenshot" filmGate = cmds.camera(camera, q=True, displayFilmGate=True) resolutionGate = cmds.camera(camera, q=True, displayResolution=True) cmds.camera(camera,e=True, displayFilmGate=False) cmds.camera(camera,e=True, displayResolution=False) format = cmds.getAttr("defaultRenderGlobals.imageFormat") cmds.setAttr("defaultRenderGlobals.imageFormat", 32) modelWidth = cmds.layout(panel, q = True, width=True) modelHeight = cmds.layout(panel, q = True, height=True) renderWidth = cmds.getAttr("defaultResolution.width") renderHeight = cmds.getAttr("defaultResolution.height") if renderWidth < modelWidth and renderHeight<modelHeight: self.usingWidth = renderWidth self.usingHeight = renderHeight else: renderRatio = renderWidth/(renderHeight+0.0) widthRatio = renderWidth/(modelWidth+0.0) heightRatio = renderHeight/(modelHeight+0.0) if widthRatio<=1 and heightRatio<=1: usingWidth = renderWidth usingHeight = renderHeight elif widthRatio > heightRatio: self.usingWidth = int(modelWidth) self.usingHeight = int(modelWidth/renderRatio) else: self.usingWidth = int(modelHeight*renderRatio) self.usingHeight = int(modelHeight) time = cmds.currentTime( query=True ) cmds.playblast(frame=time, format="image",cf=self.tempFile, v =0,orn=0,w=self.usingWidth, h=self.usingHeight, p = 100) cmds.setAttr("defaultRenderGlobals.imageFormat",format) cmds.camera(camera, e=True, displayFilmGate=filmGate) cmds.camera(camera, e=True, displayResolution=resolutionGate) return "screenshot="+self.tempFile
def _createCam(self): #create the turntable camera group it to a null node if self.mPreset: turn = cmds.camera( p=[self.mPreset.tx, self.mPreset.ty, self.mPreset.tz], o=True, n="turntablecam") else: turn = cmds.camera(p=[0, 0, 0], o=True, n="turntablecam") return turn
def setCamera(): cmds.camera() #sets the angle of the camera cmds.setAttr('persp.translateX', 50) cmds.setAttr('persp.translateY', 5.372) cmds.setAttr('persp.translateZ', 1.949) #sets the rotation of the camera cmds.setAttr('persp.rotateX', 351.700) cmds.setAttr('persp.rotateY', 92.000) cmds.setAttr('persp.rotateZ', 360.000)
def w09_playblast_cmd(self, *args): #Clamp resolution to view port import maya.OpenMayaUI as omui curView = omui.M3dView.active3dView() portWidth = curView.portWidth() portHeight = curView.portHeight() resWidth = cmds.getAttr('defaultResolution.width') resHeight = cmds.getAttr('defaultResolution.height') resAspect = float(resWidth) / resHeight if resWidth > portWidth or resHeight > portHeight: if portWidth < portHeight: resWidth, resHeight = portWdith, int(portWidth / resAspect) else: #protHeight<portWidth resWidth, resHeight = int(portHeight * resAspect), portHeight #Get model panel for mPanel in cmds.getPanel(vis=True): if cmds.modelPanel(mPanel, exists=True): break else: raise IOError('No found modelPanel!') sceneName = cmds.file(q=True, sn=True, shortName=True).split('.')[0] for ca in cmds.textScrollList('w09_uiCameras', q=True, si=True): camShortName = ca.split('|')[-1].replace(":", '_') #Set Model panel camera cameraShape = cmds.listRelatives(ca, shapes=True, typ='camera', f=True)[0] cmds.modelPanel(mPanel, e=True, camera=cameraShape) cmds.camera(cameraShape, e=True, displayResolution=False, displayGateMask=False, displayFilmGate=False) filenameV = 'playblast/%s/%s/%s' % (sceneName, camShortName, camShortName) cmds.playblast(format='iff', filename=filenameV, sequenceTime=False, viewer=False, clearCache=True, showOrnaments=True, fp=4, percent=100, compression="jpg", quality=100, wh=[resWidth, resHeight]) imDir = cmds.workspace(q=True, rd=True) imDir = os.path.join(imDir, 'images/playblast/%s' % (sceneName)) if os.path.exists(imDir): os.startfile(imDir)
def replaceDefaultPersp(): """ delete the default persp and recreate a new fresh one """ # find the default startup persp and delete it defaultPersp = mel.eval('findStartUpCamera( "persp");') cmds.camera(defaultPersp, e=True, sc=False) cmds.delete(defaultPersp) # create new persp, hide it and set it as default startup persp newPersp = cmds.camera(n='persp', hc="viewSet -p %camera") cmds.setAttr(newPersp[0]+'.visibility', False) cmds.rename(newPersp[0], 'persp') cmds.camera('persp', e=True, sc=True)
def __init__(self, logger): self.logger = logger self.cam_right = cmds.camera()[0] cmds.move(1, 0, 0, self.cam_right) self.cam_left = cmds.camera()[0] cmds.move(-1, 0, 0, self.cam_left) self.mpx_thread = cmds.createNode("transformServer", n="VRTransform") cmds.connectAttr(self.mpx_thread + ".outputRotate", self.cam_right + ".rotate") cmds.connectAttr(self.mpx_thread + ".outputRotate", self.cam_left + ".rotate") mel.eval('setNamedPanelLayout("VR")') mel.eval("lookThroughModelPanel " + self.cam_left + " modelPanel4;") mel.eval("lookThroughModelPanel " + self.cam_right + " modelPanel1;")
def silMode(self): ''' Turns silhouette mode on ''' cmds.modelEditor( self.editor, edit=True, displayLights="selected" ) cmds.modelEditor( self.editor, edit=True,grid=False ) cmds.modelEditor( self.editor, edit=True,selectionHiliteDisplay=False ) cmds.modelEditor( self.editor, edit=True, displayAppearance='smoothShaded') cmds.modelEditor( self.editor, edit=True, manipulators=False) cmds.modelEditor( self.editor, edit=True, headsUpDisplay=False) self.hideAll() cmds.camera(self.camera, e=True, displayResolution=True )
def ConvertCamerasToStartUp(self): #Convert the snapshot cameras to startup i = 0 while(cmds.objExists( "shot_" + str(i))): cmds.camera("shot_" + str(i), edit = True, startupCamera = True) i = i + 1 #Convert the turntable cameras to startup i = 0 while(cmds.objExists( "CM_Turntable_Camera_" + str(i) )): cmds.camera("CM_Turntable_Camera_" + str(i), edit = True, startupCamera = True) i = i + 1
def creatStereo(): global interaxialSleder global zeroSleder global interFloatField global interFloatSlider global zeroFloatField global zeroFloatSlider camL = mc.ls(sl=1) camListStereo = mc.ls( type='stereoRigTransform' ) if camListStereo != []: mc.confirmDialog( title='Error', message='The scene have being a 3D camera, do not create again!', button=['Ok']) return if camL == []: mc.confirmDialog( title='Missing', message='Please select a camera!', button=['Ok']) return cam = camL[0] camShape = mc.listRelatives(cam,s=1)[0] FL = mc.camera(cam,q=1,fl=1) NCP = mc.camera(cam,q=1,ncp=1) FCP = mc.camera(cam,q=1,fcp=1) cam3d = maya.app.stereo.stereoCameraRig.createStereoCameraRig() mc.parent(cam3d[0],cam) mc.setAttr(cam3d[0]+'.translate',0,0,0,lock=1) mc.setAttr(cam3d[0]+'.rotate',0,0,0,lock=1) mc.setAttr(cam3d[0]+'.scale',1,1,1,lock=1) cam3dShape = mc.listRelatives(cam3d[0],s=1)[0] mc.setAttr(cam3dShape+'.focalLength',FL) mc.setAttr(cam3dShape+'.nearClipPlane',NCP) mc.setAttr(cam3dShape+'.farClipPlane',FCP) mc.setAttr( cam3dShape+'.zeroParallaxPlane', 1 ) mc.setAttr( cam3dShape+'.safeViewingVolume', 1 ) mc.floatField( interFloatField, e=1, enable=True ) mc.floatSlider( interFloatSlider, e=1, enable=True ) mc.floatField( zeroFloatField, e=1, enable=True ) mc.floatSlider( zeroFloatSlider, e=1, enable=True ) #mc.floatSliderGrp( interaxialSleder, e=1, enable=True ) #mc.floatSliderGrp( zeroSleder, e=1, enable=True ) mc.connectControl( interFloatField, cam3dShape+'.interaxialSeparation' ) mc.connectControl( interFloatSlider, cam3dShape+'.interaxialSeparation' ) mc.connectControl( zeroFloatField, cam3dShape+'.zeroParallax' ) mc.connectControl( zeroFloatSlider, cam3dShape+'.zeroParallax' ) #mc.floatSliderGrp( interaxialSleder, e=1, enable=True ) #mc.floatSliderGrp( zeroSleder, e=1, enable=True ) #mc.connectControl( interaxialSleder, cam3dShape+'.interaxialSeparation' ) #mc.connectControl( zeroSleder, cam3dShape+'.zeroParallax' ) for i in cam3d: mc.rename(i,cam+'_'+i)
def CreateCamera(self): print "Creating new camera" #Create Camera cmds.select(None) #Copy from the current active camera cmds.duplicate( self.GetActiveCamera(), name = self.Camera) try:cmds.delete(self.Camera + "|CMForegroundPlane") except:pass try:cmds.delete(self.Camera + "|CMBackgroundPlane") except:pass for i in SnapShotClass.SnapShots: try:cmds.delete(self.Camera + "|" + i.Camera + "_ImagePlane") except:pass #Make the camera startup so that the user may not delete it directly #Enable the resolution gate cmds.camera(self.Camera, edit = True, startupCamera = True, displayResolution = True) #Make the camera hidden cmds.setAttr(self.Camera + ".visibility", False) #Add render attributes try: cmds.select(self.Camera) cmds.addAttr(longName='CMRenderProductShot', attributeType='bool', defaultValue = True) cmds.addAttr(longName='CMRenderWireFrame', attributeType='bool', defaultValue = True) cmds.addAttr(longName='CMSignature', attributeType='bool', defaultValue = self.Signature) cmds.select(None) except: pass #Default values cmds.setAttr(self.Camera + '.CMRenderProductShot', True) cmds.setAttr(self.Camera + '.CMRenderWireFrame', True) cmds.setAttr(self.Camera + '.CMSignature', self.Signature) #Assign the foreground plane to this camera if it is the signature camera if self.Signature: SnapShotClass.UpdateImagePlane("CMForegroundPlane", self.Camera) #Create the background plane for the camera CopyPlane = cmds.duplicate("CMBackgroundPlane") CopyPlane = cmds.rename(CopyPlane, self.Camera + "_ImagePlane") SnapShotClass.UpdateImagePlane(CopyPlane, self.Camera, False) cmds.setAttr(CopyPlane +".sizeX", 50) cmds.setAttr(CopyPlane +".sizeY", 50) #Adjust render layer adjustments RenderLayerManagerFile.RenderLayerManagerClass.assignSnapShots(self.Camera) print "Camera created"
def getdata(camList=[]): if len(camList) == 0: cam = cmds.ls(ca=1) for i in cam: c = cmds.listRelatives(i, p=1)[0] camList.append(c) global camDataDic camDataDic = {} global meshDataDic meshDataDic = {} min = cmds.playbackOptions(q=1, min=1) max = cmds.playbackOptions(q=1, max=1) + 1 camDataDic['timeRange'] = [min, max] for cam in camList: camDataDic[cam] = { 'translate': [[], [], []], 'rotate': [[], [], []], 'focal': [[]], 'haperture': [[]], 'vaperture': [[]] } gMainProgressBar = maya.mel.eval('$tmp = $gMainProgressBar') cmds.progressBar(gMainProgressBar, edit=True, beginProgress=True, isInterruptable=True, status='Camera Calculation ...', maxValue=(max - min + 1)) for time in range(min, max): cmds.currentTime(time, e=1) if cmds.progressBar(gMainProgressBar, query=True, isCancelled=True): break cmds.progressBar(gMainProgressBar, edit=True, step=1) for cam in camList: t = cmds.xform(cam, q=1, ws=1, t=1) r = cmds.xform(cam, q=1, ws=1, ro=1) f = cmds.camera(cam, q=1, fl=1) hfa = cmds.camera(cam, q=1, hfa=1) * MODULUS vfa = cmds.camera(cam, q=1, vfa=1) * MODULUS ## nukeFocalLength = DNCVA/2/math.tan(math.atan(vfa*MODULUS/(2*f))) for i in range(len(t)): camDataDic[cam]['translate'][i].append(' %s' % t[i]) for i in range(len(r)): camDataDic[cam]['rotate'][i].append(' %s' % r[i]) camDataDic[cam]['focal'][0].append(' %s' % f) camDataDic[cam]['haperture'][0].append(' %s' % hfa) camDataDic[cam]['vaperture'][0].append(' %s' % vfa) cmds.progressBar(gMainProgressBar, edit=True, endProgress=True)
def render_image(self, camera_pos, camera_interest_pos, obj_key=None, mesh_filename=None): """ Creates a rendered image object for the mesh in |mesh_filename| """ # setup camera camera_name, camera_shape = cmd.camera(p=camera_pos, wci=camera_interest_pos, wup=[0, 0, 1], fl=self.focal_length_, hfa=self.app_horiz_, vfa=self.app_vert_) cmd.setAttr(camera_shape + '.backgroundColor', self.back_color_['r'], self.back_color_['g'], self.back_color_['b'], type="double3") cmd.setAttr(camera_shape + ".renderable", 1) camera_rot = cmd.camera(camera_shape, q=True, rotation=True) pixel_width = cmd.getAttr("defaultResolution.width") pixel_height = cmd.getAttr("defaultResolution.height") # render the image image_src = cmd.render(camera_shape) im = Image.open(image_src) im_arr = np.array(im) # optionally normalize the rendered image if self.normalize_: im_arr = self.normalize_image(im_arr) # crop the rendered images center = np.array(im_arr.shape) / 2.0 start_i = center[0] - self.output_image_height_ / 2.0 end_i = center[0] + self.output_image_height_ / 2.0 start_j = center[1] - self.output_image_width_ / 2.0 end_j = center[1] + self.output_image_width_ / 2.0 im_arr = im_arr[start_i:end_i, start_j:end_j] # optional save if mesh_filename is not None: image_filename = mesh_filename + self.file_type_ image_dest = path.join(self.dest_dir_, obj_key, image_filename) im = Image.fromarray(np.uint8(im_arr)) im.save(image_dest) # create rendered image rendered_image = ri.RenderedImage(im_arr, camera_pos, camera_rot, camera_interest_pos) return rendered_image
def makeCamera(name_, environment): ''' Creates a camera with the given background colour. name_: The name the camera is given. environment: The colour the backround for the camera will have. On exit: A camera with the given background colour has been created and made active. ''' camera_ = cmds.camera(n = name_) cmds.setAttr(camera_[1] + ".backgroundColor", environment[0], environment[1],environment[2]) cmds.camera(camera_[0], edit = True, position = [0,100,250], rotation = [-23,0,0]) cmds.lookThru(camera_[0])
def setDisplay(self): cmds.modelEditor(self.curPanel, e=True, displayAppearance='smoothShaded', displayTextures=False, allObjects=False, polymeshes=True, locators=False, grid=False, manipulators=False, hud=True) cam = cmds.modelEditor(self.curPanel, q=True, camera=True) cmds.camera(cam, e=True, dr=1, dfg=0, dsa=0, ovr=1.2)
def restore_overscan(self): """Restore the original overscan value for the TRACKCAM camera (both the camera and its original overscan value have been stored). """ try: cmds.camera(self.orig_cam, e=True, overscan=self.orig_cam_overscan) m = '>> Restored {0} overscan > {1}'.format( self.orig_cam, self.orig_cam_overscan) self.logger.info(m) except Exception as e: m = '>> Failed to restore {0} overscan > {1}'.format( self.orig_cam, str(e)) self.logger.info(m)
def SCENE_unlock_orthographic_cameras(): ''' unlock orthographic camera so it can be deleted ''' sel = cmds.ls(sl=True) if not len(sel): return 'Select cameras first!', 0 for cam in sel: try: cmds.camera(cam, e=True, startupCamera=False) except RuntimeError: pass return ("Selected orthographic cameras can be deleted now."), 1
def __init__(self, logger): self.logger = logger self.cam_right = cmds.camera()[0] cmds.move(1, 0, 0, self.cam_right) self.cam_left = cmds.camera()[0] cmds.move(-1, 0, 0, self.cam_left) self.mpx_thread = cmds.createNode('transformServer', n='VRTransform') cmds.connectAttr(self.mpx_thread + '.outputRotate', self.cam_right + '.rotate') cmds.connectAttr(self.mpx_thread + '.outputRotate', self.cam_left + '.rotate') mel.eval('setNamedPanelLayout("VR")') mel.eval("lookThroughModelPanel " + self.cam_left + " modelPanel4;") mel.eval("lookThroughModelPanel " + self.cam_right + " modelPanel1;")
def create_camera(self): for i in range(0, 1): cmds.camera() camera_id = str(1) cmds.setAttr('cameraShape' + camera_id + '.focalLength', 45) cmds.setAttr('camera' + camera_id + '.translateX', 2) cmds.setAttr('camera' + camera_id + '.translateY', 159.764) cmds.setAttr('camera' + camera_id + '.translateZ', 71.535) cmds.setAttr('camera' + camera_id + '.rotateX', 0) cmds.setAttr('camera' + camera_id + '.rotateY', i * 30) cmds.setAttr('camera' + camera_id + '.rotateZ', 0) cmds.setAttr("perspShape.renderable", False) for i in range(1, 2): cmds.setAttr("cameraShape" + str(i) + ".renderable", True)
def city2DSetPlayblastCam( cam='persp' ) : camShp = mc.listRelatives( cam , s=True )[0] mc.setAttr( 'defaultResolution.width' , 450 ) mc.setAttr( 'defaultResolution.height' , 300 ) mc.setAttr( '%s.focalLength' % camShp , 60 ) mc.camera( cam , e=True , displayFilmGate=False , displayResolution=True , filmFit='overscan' )
def cameraTool(self, category = 'NA'): if category == 'frostbite': frostbiteCam = cmds.camera(dr = 1, dgm = 1, ncp = .1, fcp = 10000 ) cmds.addAttr( frostbiteCam [0], longName = 'isCamera', attributeType = 'bool' ) cmds.setAttr( str(frostbiteCam [0]) + '.horizontalFilmAperture', 1.4173228346472 ) cmds.setAttr( str(frostbiteCam [0]) + '.verticalFilmAperture', 0.79724409448905 ) cmds.setAttr( str(frostbiteCam [0]) + ".isCamera", True ) cmds.addAttr( longName = 'animPath', dataType = 'string' ) cmds.setAttr( str(frostbiteCam [0]) + ".animPath" , type = 'string' ) cmds.addAttr( frostbiteCam [0], longName = 'FOV' ) cmds.setAttr( str(frostbiteCam [0]) +'.FOV', keyable = True ) cmds.color( frostbiteCam[0], ud=2 ) elif category == 'NA': cmds.camera(dr = 1, dgm = 1, ncp = .01, fcp = 10000 ) self.setAttributes()
def getCameraFOV(camDag): """Return camera fov angles in degrees""" ''' aptX = camMFn.horizontalFilmAperture() aptY = camMFn.verticalFilmAperture() ''' camera = camDag.fullPathName() fov = type('obj', (object,), {'h': 0, 'v': 0}) fov.h = math.radians(cmds.camera(camera, q=True, hfv=True)) fov.v = math.radians(cmds.camera(camera, q=True, vfv=True)) return fov
def testCamera(self): # create an animated camera and write out name = MayaCmds.camera() MayaCmds.setAttr(name[1]+'.horizontalFilmAperture', 0.962) MayaCmds.setAttr(name[1]+'.verticalFilmAperture', 0.731) MayaCmds.setAttr(name[1]+'.focalLength', 50) MayaCmds.setAttr(name[1]+'.focusDistance', 5) MayaCmds.setAttr(name[1]+'.shutterAngle', 144) # animate the camera MayaCmds.currentTime(1, update=True) MayaCmds.setKeyframe(name[1], attribute='horizontalFilmAperture') MayaCmds.setKeyframe(name[1], attribute='focalLength') MayaCmds.setKeyframe(name[1], attribute='focusDistance') MayaCmds.setKeyframe(name[1], attribute='shutterAngle') MayaCmds.currentTime(6, update=True) MayaCmds.setKeyframe(name[1], attribute='horizontalFilmAperture', value=0.95) MayaCmds.setKeyframe(name[1], attribute='focalLength', value=40) MayaCmds.setKeyframe(name[1], attribute='focusDistance', value=5.4) MayaCmds.setKeyframe(name[1], attribute='shutterAngle', value=174.94) self.__files.append(util.expandFileName('testCameraInterpolation.abc')) MayaCmds.AbcExport(j='-fr 1 6 -root %s -f %s' % (name[0], self.__files[-1])) MayaCmds.AbcImport(self.__files[-1], mode='import') camList = MayaCmds.ls(type='camera') t = 1.004 MayaCmds.currentTime(t, update=True) self.failUnlessAlmostEqual(MayaCmds.getAttr(camList[0]+'.horizontalFilmAperture'), 0.962, 3) setTime = MayaCmds.currentTime(1.422, update=True) alpha = (setTime - 1) / (2 - 1) if not util.compareCamera(camList[0], camList[1]): self.fail('%s and %s are not the same at frame %d' % (camList[0], camList[1], t))
def shotCam(camName, parentGroup): shotCam = mc.camera()[0] mc.parent(shotCam, parentGroup) shotCam = mc.rename(shotCam, camName) # setup camera gate camShape = mc.listRelatives(shotCam, shapes=True)[0] mc.setAttr(camShape + ".displayGateMask", 1) mc.setAttr(camShape + ".displayResolution", 1) mc.setAttr(camShape + ".overscan", 1.2) # setup clippingPlane mc.setAttr(camShape + ".nearClipPlane", 5) mc.setAttr(camShape + ".farClipPlane", 5000) # add extra channel mc.addAttr(shotCam, shortName="focalLength", attributeType="double", minValue=2.5, keyable=True) mc.setAttr(shotCam + ".focalLength", 35) mc.connectAttr(shotCam + ".focalLength", camShape + ".focalLength") # lock channels channelLock = [".sx", ".sy", ".sz", ".v"] for i in channelLock: mc.setAttr(shotCam + i, lock=True) mc.setAttr(camShape + ".focalLength", lock=True) return shotCam
def __preCreateUI(self): self.grp = cmds.createNode('transform', name="CURVE_TOOLS_NULL", ss=True) self.ns = 'curve_tools' try: self.ns = cmds.namespace(add=self.ns) except: pass cmds.lockNode(self.grp, l=True) tmp = cmds.ls(sl=True) self.viewport_cam = cmds.camera( name="Curve_Tools_CAM", p=[-15, 15, 21], wci=[0,0,0] )[0] cmds.parent(self.viewport_cam, self.grp) if tmp: cmds.select(tmp) else: cmds.select(clear=True)
def bake_camera(node): print 'baking camera '+str(node)+'...', camera_info = get_camera_info(node) newCamera = cmds.camera() for frame in camera_info['frames']: cmds.currentTime(frame) # set matrix cmds.xform(newCamera[0], m=camera_info['matrix.'+str(frame)]) cmds.setAttr(newCamera[1]+'.focalLength', camera_info['focal.'+str(frame)]) cmds.setAttr(newCamera[1]+'.horizontalFilmAperture', camera_info['hap.'+str(frame)]) cmds.setAttr(newCamera[1]+'.verticalFilmAperture', camera_info['vap.'+str(frame)]) cmds.setAttr(newCamera[1]+'.horizontalFilmOffset', camera_info['hfo.'+str(frame)]) cmds.setAttr(newCamera[1]+'.verticalFilmOffset', camera_info['vfo.'+str(frame)]) # set keyframes cmds.setKeyframe(newCamera[0]+'.tx') cmds.setKeyframe(newCamera[0]+'.ty') cmds.setKeyframe(newCamera[0]+'.tz') cmds.setKeyframe(newCamera[0]+'.rx') cmds.setKeyframe(newCamera[0]+'.ry') cmds.setKeyframe(newCamera[0]+'.rz') cmds.setKeyframe(newCamera[1]+'.focalLength') cmds.setKeyframe(newCamera[1]+'.horizontalFilmAperture') cmds.setKeyframe(newCamera[1]+'.verticalFilmAperture') cmds.setKeyframe(newCamera[1]+'.horizontalFilmOffset') cmds.setKeyframe(newCamera[1]+'.verticalFilmOffset') print 'created '+str(newCamera)+',',