def __init__(self, state_name, scene_viewer):
self.state_name = state_name
self.scene_viewer = scene_viewer
self.geometry_viewport = hou.SceneViewer.curViewport(self.scene_viewer)
self.geo_intersector = None
self.geometry = None
self.measurements = MeasurementContainer(self.geometry_viewport,
State.text_size)
self.current_node = None
self.curPlane = None
self.show(False)
self.angle_snapping = False
self.cur_angle = 0
point = createPointGeometry()
self.point_drawable = hou.GeometryDrawable(
scene_viewer, hou.drawableGeometryType.Point, "point", point)
self.point_params = {
'style': hou.drawableGeometryPointStyle.SmoothCircle,
'radius': 2,
'color2': hou.Vector4(0, 1, 1, 1),
'color1': hou.Vector4(.9, .8, .1, 1.),
'highlight_mode': hou.drawableHighlightMode.MatteOverGlow,
'glow_width': 20
}
self.active = False
self.angle_text_drawable = hou.TextDrawable(self.scene_viewer,
"angle_text")
self.angle_text_params = {
'text': "Fizz",
'translate': hou.Vector3(0.0, 0.0, 0.0),
'highlight_mode': hou.drawableHighlightMode.MatteOverGlow,
'glow_width': 10,
'color2': hou.Vector4(0, 0, 0, 0.5)
}
self.arc_drawable = hou.GeometryDrawable(self.scene_viewer,
hou.drawableGeometryType.Line,
"arc")
self.mode = Mode.idle
class Color(object):
green = 0
yellow = 1
purple = 2
pink = 3
colorMap = {
pink: (hou.Vector4(1.0, 0.4745, 0.77647, 1), "#ff79c6"),
yellow: (hou.Vector4(0.9450, 0.9804, 0.54902, 1), "#f1fa8c"),
purple: (hou.Vector4(0.74118, 0.57647, 0.97647, 1), "#bd93f9"),
green: (hou.Vector4(0.31372, 0.980392, 0.48235, 1), "#50fa7b"),
}
def __init__(self, color):
self.vector4, self.hex_str = Color.colorMap[color]
def getVec(self):
return self.vector4
def getVec3(self):
return hou.Vector3(self.vector4[0], self.vector4[1], self.vector4[2])
def getHexStr(self):
return self.hex_str
def center_on_item(item, panel=hou.ui.curDesktop()):
network_editor = panel.paneTabOfType(hou.paneTabType.NetworkEditor)
h_item = hou.nodeBySessionId(int(item.data().get("session_id")))
if h_item is None:
return
if item.data().get("category") == "stickynote":
h_item = hou.stickyNoteBySessionId(int(item.data().get("session_id")))
network_editor.cd(h_item.parent().path())
h_pos = h_item.position()
bounds = hou.BoundingRect()
bounds.setTo(
hou.Vector4(h_pos[0] + 1, h_pos[1] - 8, h_pos[0] + 8, h_pos[1] + 8))
h_item.setSelected(True, True, True)
network_editor.setVisibleBounds(bounds,
transition_time=.05,
set_center_when_scale_rejected=True)
def __init__(self, sceneviewer):
self.scene_viewer = sceneviewer
self.knob_geo = hou.Geometry()
self.knob_pt = self.knob_geo.createPoint()
self.knob_drawable = hou.GeometryDrawable(
self.scene_viewer,
hou.drawableGeometryType.Point,
"highlighter_knob",
params={
'style': hou.drawableGeometryPointStyle.SmoothCircle,
'color1': hou.Vector4(1.0, 1.0, 1.0, 1.0),
'radius': 8,
'fade_factor': 0.5
})
self.knob_drawable.setGeometry(self.knob_geo)
self.show(False)
def drawAngle(self, angle_snapping_on, handle):
if not angle_snapping_on:
return
if (self.curPlane == None):
return
plane_vec = State.planes[self.curPlane]
#rot = hou.Matrix4.extractRotationMatrix3(g_WorldXform)
#plane_vec = plane_vec * rot
arc_geo = createArcGeometry(self.cur_angle, 1)
hou.GeometryDrawable.setGeometry(self.arc_drawable, arc_geo)
color = hou.Vector4(plane_vec[0], plane_vec[1], plane_vec[2], 1)
scale = self.measurements.current().getLength() * .5
translate = hou.hmath.buildTranslate(
self.measurements.current().getTailPos())
rotate = hou.hmath.buildRotateZToAxis(plane_vec)
transform = g_WorldXform.inverted() * rotate * translate
self.arc_drawable.setTransform(transform)
self.arc_drawable.setParams({
'line_width': 3,
'color1': color,
'style': (5, 20),
'fade_factor': 0.5,
'scale': hou.Vector3(scale, scale, scale)
})
text = str(self.cur_angle) + u'\u00b0'
font_string = '<font size="{1}"<b> {0} </b></font>'.format(
text.encode('utf-8'), 30)
self.angle_text_params['text'] = font_string
self.angle_text_drawable.show(True)
self.arc_drawable.show(True)
self.arc_drawable.draw(handle)
self.angle_text_drawable.draw(handle, self.angle_text_params)
def create_cam():
seq = hou.ui.selectFile(title="Select first frame of EXR Sequence",
collapse_sequences=True,
pattern="*.exr",
width=800,
height=600)
if seq == "":
print "Cancelled..."
sys.exit()
seq = hou.expandString(seq)
fps = hou.ui.readInput("Set FPS for Image Sequence",
buttons=(
'OK',
'Cancel',
),
default_choice=0,
close_choice=1,
title=None,
initial_contents="60")
if fps[0] == 1:
print "Cancelled..."
sys.exit()
else:
fps = int(fps[1])
print "\nStart Camera creation from EXR Sequence..."
print "First Frame:"
print seq
print "\n"
#create copnet
img = hou.node("/img").createNode("img", "img")
cop = img.createNode("file", "read_seq")
cop.parm("nodename").set(0)
fileparm = cop.parm("filename1")
fileparm.set("")
split = os.path.split(seq)
dir = split[0]
start = split[1].split("_")[0]
temp = split[1].split("_")[-1]
mid = temp.split(".")[0]
end = temp.split(".")[-1]
pad = len(mid)
start_frame = int(mid)
num_frames = len(os.listdir(dir))
end_frame = num_frames - 1
print "Start Frame: {}".format(start_frame)
print "End Frame: {}".format(end_frame)
print "Number of Frames: {}".format(num_frames)
print "FPS: {}\n".format(fps)
#houdini scene setup
hou.hscript("fps {}".format(fps))
hou.hscript("tset {} {}".format(
float(-1) / float(fps),
float(end_frame) / float(fps)))
hou.hscript("frange {} {}".format(start_frame, end_frame))
hou.hscript("fcur 0")
#static metadata
fileparm.set(seq)
meta = cop.getMetaDataString("attributes")
meta = eval(meta)
width = cop.xRes()
height = cop.yRes()
aspect = float(height) / float(width)
perspective_type = meta[
"perspective_type"] #"persp_three_point", "persp_equirectangular",
stereo_enabled = meta["stereo_enabled"] #"yes", "no"
stereo_infinite_correction = int(
meta["stereo_infinite_correction"]) #[0, 1]
print "Perspective Type: {}".format(perspective_type)
print "Stereo Enabled: {}".format(stereo_enabled)
print "Stereo Infinite Correction: {}".format(stereo_infinite_correction)
print "Width: {}".format(width)
print "Height: {}".format(height)
print "Aspect: {}".format(aspect)
#create camera
cam = ""
vr_cam_typename_to_create = "vrcam"
cam_aperture_base = 36
cam_vr_focal = 18
def create_vr_cam():
cam = hou.node("/obj").createNode(vr_cam_typename_to_create)
cam.parm("vrmergemode").set(2)
cam.parm("vrmergeangle").set(90)
cam.parm("vreyetoneckdistance").set(0)
vr_layout_parm = cam.parm("vrlayout")
if aspect == 0.5:
vr_layout_parm.set(2)
if aspect == 1:
vr_layout_parm.set(1)
if aspect == 0.25:
vr_layout_parm.set(0)
return cam
if stereo_enabled == "yes":
if perspective_type == "persp_equirectangular":
cam = create_vr_cam()
elif perspective_type == "persp_three_point":
cam = hou.node("/obj").createNode("stereocamrig")
else:
raise Exception(
"Perspective Type '{}' not supported by Houdini.".format(
perspective_type))
if stereo_enabled == "no":
if perspective_type == "persp_equirectangular":
cam = create_vr_cam()
elif perspective_type == "persp_three_point":
cam = hou.node("/obj").createNode("cam")
else:
raise Exception(
"Perspective Type '{}' not supported by Houdini.".format(
perspective_type))
#set res
cam.parm("resx").set(width)
cam.parm("resy").set(height)
# start loop
print "\nStart iterating over frames...\n"
keys_tx = []
keys_ty = []
keys_tz = []
keys_rx = []
keys_ry = []
keys_rz = []
keys_targetx = []
keys_targety = []
keys_targetz = []
keys_topx = []
keys_topy = []
keys_topz = []
keys_focal = []
keys_stereo = []
for i in range(num_frames):
frame = str(i).zfill(pad)
file = "{}/{}_{}.{}".format(dir, start, frame, end)
#print "Current File: {}".format(file)
fileparm.set(file)
meta = cop.getMetaDataString("attributes")
meta = eval(meta)
#get values from metadata
#camera position
translate_x = float(meta["camera.x"])
translate_y = float(meta["camera.y"])
translate_z = float(meta["camera.z"])
translate = hou.Vector3(translate_x, translate_y, translate_z)
key_tx = hou.Keyframe(translate_x, hou.frameToTime(i))
keys_tx.append(key_tx)
key_ty = hou.Keyframe(translate_y, hou.frameToTime(i))
keys_ty.append(key_ty)
key_tz = hou.Keyframe(translate_z, hou.frameToTime(i))
keys_tz.append(key_tz)
#camera rotation / not correctly exported from mandelbulber
#thus cam xform matrix calculated from cam vectors
'''
#correct mandelbulber meta output
rotate_x = 90 - float(meta["camera_rotation.y"])
rotate_y = float(meta["camera_rotation.z"])
rotate_z = float(meta["camera_rotation.x"])
'''
#calculate rotations from cam vectors
#camera target
target_x = float(meta["target.x"])
target_y = float(meta["target.y"])
target_z = float(meta["target.z"])
target = hou.Vector3(target_x, target_y, target_z)
#camera top (up)
top_x = float(meta["top.x"])
top_y = float(meta["top.y"])
top_z = float(meta["top.z"])
top = hou.Vector3(top_x, top_y, top_z)
# calculate vectors
forward = (translate - target).normalized()
right = top.normalized().cross(forward)
up = forward.cross(right)
#build matrix
right_c = hou.Vector4(right.x(), right.y(), right.z(), 0)
up_c = hou.Vector4(up.x(), up.y(), up.z(), 0)
forward_c = hou.Vector4(forward.x(), forward.y(), forward.z(), 0)
translate_c = hou.Vector4(translate.x(), translate.y(), translate.z(),
1)
m = hou.Matrix4((right_c, up_c, forward_c, translate_c))
#extract rotations
pivot_v = hou.Vector3(0, 0, 0)
pivot_rotate_v = hou.Vector3(0, 0, 0)
rotate = m.extractRotates(transform_order='srt',
rotate_order='xyz',
pivot=pivot_v,
pivot_rotate=pivot_rotate_v)
rotate_x = rotate.x()
rotate_y = rotate.y()
rotate_z = rotate.z()
key_rx = hou.Keyframe(rotate_x, hou.frameToTime(i))
keys_rx.append(key_rx)
key_ry = hou.Keyframe(rotate_y, hou.frameToTime(i))
keys_ry.append(key_ry)
key_rz = hou.Keyframe(rotate_z, hou.frameToTime(i))
keys_rz.append(key_rz)
fov = float(meta["fov"])
#calulate focal length based on fov and "cam_aperture_base"
focal = cam_aperture_base / (2 * math.tan(math.radians(fov) / 2))
key_focal = hou.Keyframe(focal, hou.frameToTime(i))
keys_focal.append(key_focal)
stereo_eye_distance = 2 * float(meta["stereo_eye_distance"])
key_stereo = hou.Keyframe(stereo_eye_distance, hou.frameToTime(i))
keys_stereo.append(key_stereo)
#print "\nFrame: {}".format(frame)
#print "Translate: ({}, {}, {})".format(translate_x, translate_y, translate_z)
#print "Rotate: ({}, {}, {})".format(rotate_x, rotate_y, rotate_z)
#print "Stereo Distance: {}".format(stereo_eye_distance)
#set keyframes
parm_tx = cam.parm("tx")
parm_tx.setKeyframes(keys_tx)
parm_ty = cam.parm("ty")
parm_ty.setKeyframes(keys_ty)
parm_tz = cam.parm("tz")
parm_tz.setKeyframes(keys_tz)
parm_rx = cam.parm("rx")
parm_rx.setKeyframes(keys_rx)
parm_ry = cam.parm("ry")
parm_ry.setKeyframes(keys_ry)
parm_rz = cam.parm("rz")
parm_rz.setKeyframes(keys_rz)
parm_aperture = cam.parm("aperture")
parm_aperture.set(cam_aperture_base)
parm_focal = cam.parm("focal")
if perspective_type == "persp_equirectangular":
parm_focal.set(cam_vr_focal)
parm_stereo = cam.parm("vreyeseparation")
if stereo_enabled == "yes":
parm_stereo.setKeyframes(keys_stereo)
else:
parm_stereo.set(0)
else:
parm_focal.setKeyframes(keys_focal)
if stereo_enabled == "yes":
parm_stereo = cam.parm("interaxial")
parm_stereo.setKeyframes(keys_stereo)
#delete img node
img.destroy()
#select camera
cam.setSelected(1, 1)
print "\nCamera successfully created from Mandelbulber EXR Image Sequence.\n\n"
def test_v3IsNan(self):
nan = float('nan')
v4 = hou.Vector4(-4, 5, -0, nan)
self.assertTrue(v4.isNan())
