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 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 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)+',',
