def main():
global base, render, taskMgr, loader, model_iter
model_iter = iter(getModel(int(sys.argv[1])))
base = MyBase()
render = base.render
taskMgr = base.taskMgr
loader = base.loader
base.disableMouse()
pandacore.attachLights(render)
render.setShaderAuto()
render.setTransparency(TransparencyAttrib.MDual, 1)
base.cam.setPos(0, 30000, 10000)
base.cam.lookAt(0, 0, 0.0)
KeyboardMovement()
MouseCamera()
base.win.setClearColor(VBase4(0.9,0.9,0.9,1))
render.setAntialias(AntialiasAttrib.MAuto)
taskMgr.add(nextModelTask, 'nextModelTask')
base.run()
def main():
global base, render, taskMgr, loader, model_iter
model_iter = iter(getModel(int(sys.argv[1])))
base = MyBase()
render = base.render
taskMgr = base.taskMgr
loader = base.loader
base.disableMouse()
pandacore.attachLights(render)
render.setShaderAuto()
render.setTransparency(TransparencyAttrib.MDual, 1)
base.cam.setPos(0, 30000, 10000)
base.cam.lookAt(0, 0, 0.0)
KeyboardMovement()
MouseCamera()
base.win.setClearColor(VBase4(0.9, 0.9, 0.9, 1))
render.setAntialias(AntialiasAttrib.MAuto)
taskMgr.add(nextModelTask, 'nextModelTask')
base.run()
def __init__(self, mesh_path, progressive_texture_path):
resolutions = []
f = tarfile.open(progressive_texture_path)
for resolution_name in f.getnames():
toset = {
'size': resolution_name[:-4],
'contents': f.extractfile(resolution_name).read()
}
texpnm = PNMImage()
texpnm.read(StringStream(toset['contents']), 'something.jpg')
newtex = Texture()
newtex.load(texpnm)
toset['texture'] = newtex
resolutions.append(toset)
self.resolutions = resolutions
def aux_loader(fname):
return resolutions[0]['contents']
mesh = collada.Collada(mesh_path, aux_file_loader=aux_loader)
scene_members = getSceneMembers(mesh)
base = ShowBase()
rotateNode = GeomNode("rotater")
rotatePath = render.attachNewNode(rotateNode)
matrix = numpy.identity(4)
if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
r = collada.scene.RotateTransform(0, 1, 0, 90)
matrix = r.matrix
elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
r = collada.scene.RotateTransform(1, 0, 0, 90)
matrix = r.matrix
rotatePath.setMat(Mat4(*matrix.T.flatten().tolist()))
geom, renderstate, mat4 = scene_members[0]
node = GeomNode("primitive")
node.addGeom(geom)
if renderstate is not None:
node.setGeomState(0, renderstate)
self.geomPath = rotatePath.attachNewNode(node)
self.geomPath.setMat(mat4)
wrappedNode = ensureCameraAt(self.geomPath, base.camera)
base.disableMouse()
attachLights(render)
render.setShaderAuto()
render.setTransparency(TransparencyAttrib.MDual, 1)
base.render.analyze()
KeyboardMovement()
MouseDrag(wrappedNode)
MouseScaleZoom(wrappedNode)
MouseCamera()
num_resolutions = len(resolutions) - 1
self.slider = DirectSlider(range=(0, num_resolutions),
value=0,
pageSize=1,
command=self.sliderMoved,
pos=(0, 0, -.9),
scale=1)
for key, val in uiArgs.iteritems():
self.slider.thumb[key] = val
self.triText = OnscreenText(text="",
pos=(-1, 0.85),
scale=0.15,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ALeft,
mayChange=1)
base.run()
def __init__(self, scenefile, capturefile=None, showstats=False, screenshot_dir=None):
self.scenefile = scenefile
self.capturefile = capturefile
self.scene = scene.Scene.fromfile(scenefile)
self.unique_models = set(m.slug for m in self.scene)
self.multiplexer = pool.MultiplexPool()
self.screenshot_dir = screenshot_dir
print '%d objects in scene, %d unique' % (len(self.scene), len(self.unique_models))
# turns on lazy loading of textures
p3d.loadPrcFileData('', 'preload-textures 0')
p3d.loadPrcFileData('', 'preload-simple-textures 1')
p3d.loadPrcFileData('', 'compressed-textures 1')
p3d.loadPrcFileData('', 'allow-incomplete-render 0')
# window size to 1024x768
p3d.loadPrcFileData('', 'win-size 1024 768')
ShowBase.ShowBase.__init__(self)
# background color sky blue
self.win.setClearColorActive(True)
self.win.setClearColor(p3d.VBase4(0.5294, 0.8078, 0.9215, 0))
# create a nodepath for each unique model
self.unique_nodepaths = dict((m, p3d.NodePath(m)) for m in self.unique_models)
self.rigid_body_combiners = {}
self.rigid_body_combiner_np = {}
for m in self.unique_models:
#rbc = p3d.RigidBodyCombiner(m)
rbc = p3d.NodePath(m)
self.rigid_body_combiners[m] = rbc
np = p3d.NodePath(rbc)
np.reparentTo(self.render)
self.rigid_body_combiner_np[m] = np
# find out how many objects are going to be instanced for each node
self.instance_count = collections.defaultdict(int)
for model in self.scene:
self.instance_count[model.slug] += 1
# then instance each unique model to its instantiation in the actual scene
self.nodepaths = {}
self.obj_bounds = {}
self.nodepaths_byslug = collections.defaultdict(list)
for model in self.scene:
unique_np = self.unique_nodepaths[model.slug]
node_name = model.slug + "_%.7g_%.7g_%.7g" % (model.x, model.y, model.z)
if self.instance_count[model.slug] == 1:
unique_np.setName(node_name)
unique_np.reparentTo(self.render)
np = unique_np
else:
np = self.rigid_body_combiner_np[model.slug].attachNewNode(node_name)
self.nodepaths[model] = np
self.nodepaths_byslug[model.slug].append(np)
np.setPos(model.x, model.y, model.z)
np.setScale(model.scale, model.scale, model.scale)
q = p3d.Quat()
q.setI(model.orient_x)
q.setJ(model.orient_y)
q.setK(model.orient_z)
q.setR(model.orient_w)
np.setQuat(q)
self.obj_bounds[np] = p3d.BoundingSphere(np.getPos(), np.getScale()[0])
#for rbc in self.rigid_body_combiners.itervalues():
# rbc.collect()
self.waiting = []
self.pm_waiting = collections.defaultdict(list)
self.models_loaded = set()
self.loading_priority = 2147483647
for m in self.unique_models:
t = metadata.MetadataDownloadTask(m)
self.multiplexer.add_task(t)
self.disableMouse()
pcore.attachLights(self.render)
self.render.setShaderAuto()
self.render.setTransparency(p3d.TransparencyAttrib.MNone)
self.camLens.setFar(sys.maxint)
self.camLens.setNear(8.0)
self.render.setAntialias(p3d.AntialiasAttrib.MAuto)
self.showstats = showstats
if showstats:
self.num_metadata_loaded = 0
self.num_models_loaded = 0
self.num_texture_updates = 0
self.num_mesh_refinements = 0
self.total_texture_updates = 0
self.total_mesh_refinements = 0
self.txtMetadataLoaded = gui.OnscreenText.OnscreenText(text='', style=1, pos=(0.01, -0.05),
parent=self.a2dTopLeft, align=p3d.TextNode.ALeft,
scale=0.05, fg=(0.1, 0.1, 0.1, 1), shadow=(0.9, 0.9, 0.9, 1))
self.txtUniqueLoaded = gui.OnscreenText.OnscreenText(text='', style=1, pos=(0.01, -0.11),
parent=self.a2dTopLeft, align=p3d.TextNode.ALeft,
scale=0.05, fg=(0.1, 0.1, 0.1, 1), shadow=(0.9, 0.9, 0.9, 1))
self.txtTextureUpdates = gui.OnscreenText.OnscreenText(text='', style=1, pos=(0.01, -0.17),
parent=self.a2dTopLeft, align=p3d.TextNode.ALeft,
scale=0.05, fg=(0.1, 0.1, 0.1, 1), shadow=(0.9, 0.9, 0.9, 1))
self.txtMeshRefinements = gui.OnscreenText.OnscreenText(text='', style=1, pos=(0.01, -0.23),
parent=self.a2dTopLeft, align=p3d.TextNode.ALeft,
scale=0.05, fg=(0.1, 0.1, 0.1, 1), shadow=(0.9, 0.9, 0.9, 1))
self.update_stats()
self.globalClock = p3d.ClockObject.getGlobalClock()
self.smooth_mover = SmoothMover()
self.smooth_mover.setPredictionMode(SmoothMover.PMOn)
self.smooth_mover.setSmoothMode(SmoothMover.SMOn)
self.smooth_mover.setMaxPositionAge(10.0)
self.smooth_mover.setAcceptClockSkew(False)
self.smooth_mover.setDelay(0)
self.pandastate = katasked.panda.PandaState(self.cam,
self.unique_nodepaths,
self.nodepaths,
self.smooth_mover,
self.globalClock,
self.obj_bounds)
if self.capturefile is not None:
self.capturedata = json.load(self.capturefile)
self.duration = self.capturedata['duration']
self.positions = self.capturedata['positions']
self.rotations = self.capturedata['rotations']
self.curve_creator = motioncap.CreateNurbsCurve()
for pos, rot in zip(self.positions, self.rotations):
self.curve_creator.addPoint(pos, rot)
self.mopath = self.curve_creator.getMotionPath()
self.interval = MopathInterval.MopathInterval(self.mopath, self.cam, duration=self.duration, name="Camera Replay")
else:
controls.KeyboardMovement()
controls.MouseCamera()
self.update_camera_predictor_task = self.taskMgr.doMethodLater(0.1, self.update_camera_predictor, 'update_camera_predictor')
self.update_priority_task = self.taskMgr.doMethodLater(0.5, self.check_pool, 'check_pool')
self.load_waiting_task = self.taskMgr.doMethodLater(0.1, self.load_waiting, 'load_waiting')
def visualize(centers, corners, edges):
from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, MouseCamera
from panda3d.core import GeomPoints, GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs, VBase3
from direct.showbase.ShowBase import ShowBase
format = GeomVertexFormat.getV3c4()
vdata = GeomVertexData('pts', format, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
vertex_index = 0
center_vertex_indices = {}
corner_vertex_indices = {}
for key, center in centers.iteritems():
vertex.addData3f(center.x * X_SCALE, center.y * Y_SCALE,
center.elevation * Z_SCALE)
curcolor = hex2rgb(COLORS[center.biome])
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
center_vertex_indices[key] = vertex_index
vertex_index += 1
for corner in center.corners:
vertex.addData3f(corner.x * X_SCALE, corner.y * Y_SCALE,
corner.elevation * Z_SCALE)
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
corner_vertex_indices[corner.id] = vertex_index
vertex_index += 1
tris = GeomTriangles(Geom.UHDynamic)
for edge in edges.itervalues():
corner0 = edge.corner0
corner1 = edge.corner1
center0 = edge.center0
center1 = edge.center1
if corner0 is None or corner1 is None:
continue
tris.addVertices(corner_vertex_indices[corner1.id],
corner_vertex_indices[corner0.id],
center_vertex_indices[center0.id])
tris.addVertices(center_vertex_indices[center1.id],
corner_vertex_indices[corner0.id],
corner_vertex_indices[corner1.id])
tris.closePrimitive()
pgeom = Geom(vdata)
pgeom.addPrimitive(tris)
node = GeomNode("primitive")
node.addGeom(pgeom)
p3dApp = ShowBase()
attachLights(render)
geomPath = render.attachNewNode(node)
#geomPath.setRenderModeThickness(6.0)
#geomPath.setRenderModeWireframe()
ensureCameraAt(geomPath, base.cam)
boundingSphere = geomPath.getBounds()
base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())
base.cam.lookAt(boundingSphere.getCenter())
geomPath.setScale(VBase3(50, 50, 50))
KeyboardMovement()
#MouseDrag(geomPath)
MouseCamera()
MouseScaleZoom(geomPath)
#render.setShaderAuto()
p3dApp.run()
def visualize(centers, corners, edges):
from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, MouseCamera
from panda3d.core import GeomPoints, GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs, VBase3
from direct.showbase.ShowBase import ShowBase
format = GeomVertexFormat.getV3c4()
vdata = GeomVertexData('pts', format, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
vertex_index = 0
center_vertex_indices = {}
corner_vertex_indices = {}
for key, center in centers.iteritems():
vertex.addData3f(center.x * X_SCALE, center.y * Y_SCALE, center.elevation * Z_SCALE)
curcolor = hex2rgb(COLORS[center.biome])
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
center_vertex_indices[key] = vertex_index
vertex_index += 1
for corner in center.corners:
vertex.addData3f(corner.x * X_SCALE, corner.y * Y_SCALE, corner.elevation * Z_SCALE)
color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
corner_vertex_indices[corner.id] = vertex_index
vertex_index += 1
tris = GeomTriangles(Geom.UHDynamic)
for edge in edges.itervalues():
corner0 = edge.corner0
corner1 = edge.corner1
center0 = edge.center0
center1 = edge.center1
if corner0 is None or corner1 is None:
continue
tris.addVertices(corner_vertex_indices[corner1.id],
corner_vertex_indices[corner0.id],
center_vertex_indices[center0.id])
tris.addVertices(center_vertex_indices[center1.id],
corner_vertex_indices[corner0.id],
corner_vertex_indices[corner1.id])
tris.closePrimitive()
pgeom = Geom(vdata)
pgeom.addPrimitive(tris)
node = GeomNode("primitive")
node.addGeom(pgeom)
p3dApp = ShowBase()
attachLights(render)
geomPath = render.attachNewNode(node)
#geomPath.setRenderModeThickness(6.0)
#geomPath.setRenderModeWireframe()
ensureCameraAt(geomPath, base.cam)
boundingSphere = geomPath.getBounds()
base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())
base.cam.lookAt(boundingSphere.getCenter())
geomPath.setScale(VBase3(50,50,50))
KeyboardMovement()
#MouseDrag(geomPath)
MouseCamera()
MouseScaleZoom(geomPath)
#render.setShaderAuto()
p3dApp.run()
def __init__(self, models):
ShowBase.ShowBase.__init__(self)
self.models = models
unique_meshes = set(m.mesh for m in models)
mesh2nodepath = {}
for mesh in unique_meshes:
scene_members = pcore.getSceneMembers(mesh)
rotateNode = p3d.GeomNode("rotater")
rotatePath = p3d.NodePath(rotateNode)
matrix = numpy.identity(4)
if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
r = collada.scene.RotateTransform(0, 1, 0, 90)
matrix = r.matrix
elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
r = collada.scene.RotateTransform(1, 0, 0, 90)
matrix = r.matrix
rotatePath.setMat(p3d.Mat4(*matrix.T.flatten().tolist()))
rbc = p3d.RigidBodyCombiner('combiner')
rbcPath = rotatePath.attachNewNode(rbc)
for geom, renderstate, mat4 in scene_members:
node = p3d.GeomNode("primitive")
node.addGeom(geom)
if renderstate is not None:
node.setGeomState(0, renderstate)
geomPath = rbcPath.attachNewNode(node)
geomPath.setMat(mat4)
rbc.collect()
mesh2nodepath[mesh] = centerAndScale(
rotatePath, print_bounds.getBoundsInfo(mesh))
scenepath = render.attachNewNode("scene")
for model in self.models:
np = mesh2nodepath[model.mesh]
instance = scenepath.attachNewNode("model")
np.instanceTo(instance)
instance.setPos(model.x, model.y, model.z)
instance.setScale(model.scale, model.scale, model.scale)
q = p3d.Quat()
q.setI(model.orient_x)
q.setJ(model.orient_y)
q.setK(model.orient_z)
q.setR(model.orient_w)
instance.setQuat(q)
base.camLens.setFar(sys.maxint)
base.camLens.setNear(8.0)
pcore.attachLights(render)
render.setShaderAuto()
render.setTransparency(p3d.TransparencyAttrib.MDual, 1)
render.setAntialias(p3d.AntialiasAttrib.MAuto)
controls.KeyboardMovement()
controls.ButtonUtils(scenepath)
controls.MouseDrag(scenepath)
controls.MouseCamera()
controls.MouseScaleZoom(scenepath)
def main():
parser = argparse.ArgumentParser(
description='Tool for displaying a scene from open3dhub')
parser.add_argument('--model-type',
choices=['progressive', 'optimized'],
default='progressive',
required=False,
help='Model type to use')
parser.add_argument('--model-subtype',
choices=['base', 'full'],
default='base',
required=False,
help='Model subtype (currently only for progressive)')
parser.add_argument('--force-model-download',
dest='force_model',
action='store_true',
help='Force re-downloading models')
parser.add_argument(
'scene_file',
help='Scene file to use, generated with scene_generator',
type=argparse.FileType('r'))
parser.add_argument('--screenshots',
required=False,
help='Directory to save screenshots',
type=str)
parser.add_argument('--exit-after-load',
required=False,
default=False,
action='store_true',
help='Exit the program after all models are loaded')
args = parser.parse_args()
global FORCE_MODEL_DOWNLOAD
global SAVE_SS
global START_TIME
global LAST_SCREENSHOT
global NUM_MODELS
global EXIT_AFTER
global MODEL_TYPE
global MODEL_SUBTYPE
global HASH_SIZES
EXIT_AFTER = args.exit_after_load
FORCE_MODEL_DOWNLOAD = args.force_model
SAVE_SS = args.screenshots
MODEL_TYPE = args.model_type
MODEL_SUBTYPE = args.model_subtype
if SAVE_SS is not None:
if os.path.isdir(SAVE_SS):
#yn = raw_input("Delete existing ss dir? ")
yn = 'y'
if yn == 'y':
shutil.rmtree(SAVE_SS)
else:
print 'Exiting then'
sys.exit(1)
if not os.path.isdir(SAVE_SS):
os.mkdir(SAVE_SS)
if not os.path.isdir(SAVE_SS):
print >> sys.stderr, 'Invalid screenshots directory'
parser.print_usage()
sys.exit(1)
START_TIME = time.clock()
LAST_SCREENSHOT = START_TIME
scene_dict = pickle.load(args.scene_file)
HASH_SIZES = scene_dict['sizes']
scene_models = scene_dict['models']
NUM_MODELS = len(scene_models)
global base, render, taskMgr, loader
base = MyBase()
render = base.render
taskMgr = base.taskMgr
loader = base.loader
#if FORCE_MODEL_DOWNLOAD:
# try:
# shutil.rmtree(TEMPDIR)
# except OSError:
# pass
try:
os.mkdir(TEMPDIR)
except OSError:
pass
base.disableMouse()
pandacore.attachLights(render)
base.cam.setPos(0, 30000, 10000)
base.cam.lookAt(0, 0, 2000)
t = LoadingThread(scene_models)
t.daemon = True
t.start()
taskMgr.add(checkForLoad, "checkForLoad")
if SAVE_SS is not None:
taskMgr.add(triggerScreenshot, "triggerScreenshot")
KeyboardMovement(scale=10.0)
MouseCamera()
#base.win.setClearColor(VBase4(0.9,0.9,0.9,1))
base.win.setClearColor(VBase4(0.529, 0.807, 0.98, 1))
environ = loader.loadModel("grass.egg")
environ.reparentTo(render)
minPt, maxPt = environ.getTightBounds()
xRange = math.fabs(minPt.getX() - maxPt.getX())
yRange = math.fabs(minPt.getY() - maxPt.getY())
zRange = math.fabs(minPt.getZ() - maxPt.getZ())
environ.setScale(500, 2500, 100)
environ.setPos(0, 1000, 0) #-1 * zRange / 2.0)
environ.setP(180)
#environ.lookAt(200, 200, 0)
#environ.lookAt(base.cam)
#environ.setTransparency(TransparencyAttrib.MAlpha)
#environ.setAlphaScale(0.3)
render.setShaderAuto()
render.setAntialias(AntialiasAttrib.MAuto)
environ.setShaderOff()
# effectively disable distance culling
base.camLens.setFar(sys.maxint)
base.camLens.setNear(8.0)
base.setFrameRateMeter(True)
base.run()
def main():
parser = argparse.ArgumentParser(description='Tool for displaying a scene from open3dhub')
parser.add_argument('--model-type', choices=['progressive', 'optimized'], default='progressive', required=False, help='Model type to use')
parser.add_argument('--model-subtype', choices=['base', 'full'], default='base', required=False, help='Model subtype (currently only for progressive)')
parser.add_argument('--force-model-download', dest='force_model', action='store_true', help='Force re-downloading models')
parser.add_argument('scene_file', help='Scene file to use, generated with scene_generator', type=argparse.FileType('r'))
parser.add_argument('--screenshots', required=False, help='Directory to save screenshots', type=str)
parser.add_argument('--exit-after-load', required=False, default=False, action='store_true', help='Exit the program after all models are loaded')
args = parser.parse_args()
global FORCE_MODEL_DOWNLOAD
global SAVE_SS
global START_TIME
global LAST_SCREENSHOT
global NUM_MODELS
global EXIT_AFTER
global MODEL_TYPE
global MODEL_SUBTYPE
global HASH_SIZES
EXIT_AFTER = args.exit_after_load
FORCE_MODEL_DOWNLOAD = args.force_model
SAVE_SS = args.screenshots
MODEL_TYPE = args.model_type
MODEL_SUBTYPE = args.model_subtype
if SAVE_SS is not None:
if os.path.isdir(SAVE_SS):
#yn = raw_input("Delete existing ss dir? ")
yn = 'y'
if yn == 'y':
shutil.rmtree(SAVE_SS)
else:
print 'Exiting then'
sys.exit(1)
if not os.path.isdir(SAVE_SS):
os.mkdir(SAVE_SS)
if not os.path.isdir(SAVE_SS):
print >> sys.stderr, 'Invalid screenshots directory'
parser.print_usage()
sys.exit(1)
START_TIME = time.clock()
LAST_SCREENSHOT = START_TIME
scene_dict = pickle.load(args.scene_file)
HASH_SIZES = scene_dict['sizes']
scene_models = scene_dict['models']
NUM_MODELS = len(scene_models)
global base, render, taskMgr, loader
base = MyBase()
render = base.render
taskMgr = base.taskMgr
loader = base.loader
#if FORCE_MODEL_DOWNLOAD:
# try:
# shutil.rmtree(TEMPDIR)
# except OSError:
# pass
try:
os.mkdir(TEMPDIR)
except OSError:
pass
base.disableMouse()
pandacore.attachLights(render)
base.cam.setPos(0, 30000, 10000)
base.cam.lookAt(0, 0, 2000)
t = LoadingThread(scene_models)
t.daemon = True
t.start()
taskMgr.add(checkForLoad, "checkForLoad")
if SAVE_SS is not None:
taskMgr.add(triggerScreenshot, "triggerScreenshot")
KeyboardMovement(scale=10.0)
MouseCamera()
#base.win.setClearColor(VBase4(0.9,0.9,0.9,1))
base.win.setClearColor(VBase4(0.529,0.807,0.98,1))
environ = loader.loadModel("grass.egg")
environ.reparentTo(render)
minPt, maxPt = environ.getTightBounds()
xRange = math.fabs(minPt.getX() - maxPt.getX())
yRange = math.fabs(minPt.getY() - maxPt.getY())
zRange = math.fabs(minPt.getZ() - maxPt.getZ())
environ.setScale(500, 2500, 100)
environ.setPos(0, 1000, 0) #-1 * zRange / 2.0)
environ.setP(180)
#environ.lookAt(200, 200, 0)
#environ.lookAt(base.cam)
#environ.setTransparency(TransparencyAttrib.MAlpha)
#environ.setAlphaScale(0.3)
render.setShaderAuto()
render.setAntialias(AntialiasAttrib.MAuto)
environ.setShaderOff()
# effectively disable distance culling
base.camLens.setFar(sys.maxint)
base.camLens.setNear(8.0)
base.setFrameRateMeter(True)
base.run()
def __init__(self, models):
ShowBase.ShowBase.__init__(self)
self.models = models
unique_meshes = set(m.mesh for m in models)
mesh2nodepath = {}
for mesh in unique_meshes:
scene_members = pcore.getSceneMembers(mesh)
rotateNode = p3d.GeomNode("rotater")
rotatePath = p3d.NodePath(rotateNode)
matrix = numpy.identity(4)
if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
r = collada.scene.RotateTransform(0,1,0,90)
matrix = r.matrix
elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
r = collada.scene.RotateTransform(1,0,0,90)
matrix = r.matrix
rotatePath.setMat(p3d.Mat4(*matrix.T.flatten().tolist()))
rbc = p3d.RigidBodyCombiner('combiner')
rbcPath = rotatePath.attachNewNode(rbc)
for geom, renderstate, mat4 in scene_members:
node = p3d.GeomNode("primitive")
node.addGeom(geom)
if renderstate is not None:
node.setGeomState(0, renderstate)
geomPath = rbcPath.attachNewNode(node)
geomPath.setMat(mat4)
rbc.collect()
mesh2nodepath[mesh] = centerAndScale(rotatePath, print_bounds.getBoundsInfo(mesh))
scenepath = render.attachNewNode("scene")
for model in self.models:
np = mesh2nodepath[model.mesh]
instance = scenepath.attachNewNode("model")
np.instanceTo(instance)
instance.setPos(model.x, model.y, model.z)
instance.setScale(model.scale, model.scale, model.scale)
q = p3d.Quat()
q.setI(model.orient_x)
q.setJ(model.orient_y)
q.setK(model.orient_z)
q.setR(model.orient_w)
instance.setQuat(q)
base.camLens.setFar(sys.maxint)
base.camLens.setNear(8.0)
pcore.attachLights(render)
render.setShaderAuto()
render.setTransparency(p3d.TransparencyAttrib.MDual, 1)
render.setAntialias(p3d.AntialiasAttrib.MAuto)
controls.KeyboardMovement()
controls.ButtonUtils(scenepath)
controls.MouseDrag(scenepath)
controls.MouseCamera()
controls.MouseScaleZoom(scenepath)
def __init__(self, mesh_path, progressive_texture_path):
resolutions = []
f = tarfile.open(progressive_texture_path)
for resolution_name in f.getnames():
toset = {'size': resolution_name[:-4],
'contents': f.extractfile(resolution_name).read()}
texpnm = PNMImage()
texpnm.read(StringStream(toset['contents']), 'something.jpg')
newtex = Texture()
newtex.load(texpnm)
toset['texture'] = newtex
resolutions.append(toset)
self.resolutions = resolutions
def aux_loader(fname):
return resolutions[0]['contents']
mesh = collada.Collada(mesh_path, aux_file_loader=aux_loader)
scene_members = getSceneMembers(mesh)
base = ShowBase()
rotateNode = GeomNode("rotater")
rotatePath = render.attachNewNode(rotateNode)
matrix = numpy.identity(4)
if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
r = collada.scene.RotateTransform(0,1,0,90)
matrix = r.matrix
elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
r = collada.scene.RotateTransform(1,0,0,90)
matrix = r.matrix
rotatePath.setMat(Mat4(*matrix.T.flatten().tolist()))
geom, renderstate, mat4 = scene_members[0]
node = GeomNode("primitive")
node.addGeom(geom)
if renderstate is not None:
node.setGeomState(0, renderstate)
self.geomPath = rotatePath.attachNewNode(node)
self.geomPath.setMat(mat4)
wrappedNode = ensureCameraAt(self.geomPath, base.camera)
base.disableMouse()
attachLights(render)
render.setShaderAuto()
render.setTransparency(TransparencyAttrib.MDual, 1)
base.render.analyze()
KeyboardMovement()
MouseDrag(wrappedNode)
MouseScaleZoom(wrappedNode)
MouseCamera()
num_resolutions = len(resolutions) - 1
self.slider = DirectSlider(range=(0, num_resolutions),
value=0, pageSize=1,
command=self.sliderMoved, pos=(0, 0, -.9), scale=1)
for key, val in uiArgs.iteritems():
self.slider.thumb[key] = val
self.triText = OnscreenText(text="", pos=(-1,0.85), scale = 0.15,
fg=(1, 0.5, 0.5, 1), align=TextNode.ALeft, mayChange=1)
base.run()
def getPmPerceptualError(mesh, pm_filebuf, mipmap_tarfilebuf):
perceptualdiff = which('perceptualdiff')
if perceptualdiff is None:
raise Exception("perceptualdiff exectuable not found on path")
pm_chunks = []
if pm_filebuf is not None:
data = pm_filebuf.read(PM_CHUNK_SIZE)
refinements_read = 0
num_refinements = None
while len(data) > 0:
(refinements_read, num_refinements, pm_refinements,
data_left) = pdae_utils.readPDAEPartial(data, refinements_read,
num_refinements)
pm_chunks.append(pm_refinements)
data = data_left + pm_filebuf.read(PM_CHUNK_SIZE)
tar = tarfile.TarFile(fileobj=mipmap_tarfilebuf)
texsizes = []
largest_tarinfo = (0, None)
for tarinfo in tar:
tarinfo.xsize = int(tarinfo.name.split('x')[0])
if tarinfo.xsize > largest_tarinfo[0]:
largest_tarinfo = (tarinfo.xsize, tarinfo)
if tarinfo.xsize >= 128:
texsizes.append(tarinfo)
if len(texsizes) == 0:
texsizes.append(largest_tarinfo[1])
texsizes = sorted(texsizes, key=lambda t: t.xsize)
texims = []
first_image_data = None
for tarinfo in texsizes:
f = tar.extractfile(tarinfo)
texdata = f.read()
if first_image_data is None:
first_image_data = texdata
texpnm = PNMImage()
texpnm.read(StringStream(texdata), 'something.jpg')
newtex = Texture()
newtex.load(texpnm)
texims.append(newtex)
mesh.images[0].setData(first_image_data)
scene_members = getSceneMembers(mesh)
# turn off panda3d printing to stdout
nout = MultiplexStream()
Notify.ptr().setOstreamPtr(nout, 0)
nout.addFile(Filename(os.devnull))
base = ShowBase()
rotateNode = GeomNode("rotater")
rotatePath = base.render.attachNewNode(rotateNode)
matrix = numpy.identity(4)
if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
r = collada.scene.RotateTransform(0, 1, 0, 90)
matrix = r.matrix
elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
r = collada.scene.RotateTransform(1, 0, 0, 90)
matrix = r.matrix
rotatePath.setMat(Mat4(*matrix.T.flatten().tolist()))
geom, renderstate, mat4 = scene_members[0]
node = GeomNode("primitive")
node.addGeom(geom)
if renderstate is not None:
node.setGeomState(0, renderstate)
geomPath = rotatePath.attachNewNode(node)
geomPath.setMat(mat4)
wrappedNode = ensureCameraAt(geomPath, base.camera)
base.disableMouse()
attachLights(base.render)
base.render.setShaderAuto()
base.render.setTransparency(TransparencyAttrib.MNone)
base.render.setColorScaleOff(9999)
controls.KeyboardMovement()
controls.MouseDrag(wrappedNode)
controls.MouseScaleZoom(wrappedNode)
controls.ButtonUtils(wrappedNode)
controls.MouseCamera()
error_data = []
try:
tempdir = tempfile.mkdtemp(prefix='meshtool-print-pm-perceptual-error')
triangleCounts = []
hprs = [(0, 0, 0), (0, 90, 0), (0, 180, 0), (0, 270, 0), (90, 0, 0),
(-90, 0, 0)]
for texim in texims:
np = base.render.find("**/rotater/collada")
np.setTextureOff(1)
np.setTexture(texim, 1)
for angle, hpr in enumerate(hprs):
wrappedNode.setHpr(*hpr)
takeScreenshot(tempdir, base, geomPath, texim, angle)
triangleCounts.append(getNumTriangles(geomPath))
for pm_chunk in pm_chunks:
pdae_panda.add_refinements(geomPath, pm_chunk)
for texim in texims:
np = base.render.find("**/rotater/collada")
np.setTextureOff(1)
np.setTexture(texim, 1)
for angle, hpr in enumerate(hprs):
wrappedNode.setHpr(*hpr)
takeScreenshot(tempdir, base, geomPath, texim, angle)
triangleCounts.append(getNumTriangles(geomPath))
full_tris = triangleCounts[-1]
full_tex = texims[-1]
for numtris in triangleCounts:
for texim in texims:
pixel_diff = 0
for angle, hpr in enumerate(hprs):
curFile = '%d_%d_%d_%d.png' % (numtris, texim.getXSize(),
texim.getYSize(), angle)
curFile = os.path.join(tempdir, curFile)
fullFile = '%d_%d_%d_%d.png' % (full_tris,
full_tex.getXSize(),
full_tex.getYSize(), angle)
fullFile = os.path.join(tempdir, fullFile)
try:
output = subprocess.check_output([
perceptualdiff, '-threshold', '1', fullFile,
curFile
])
except subprocess.CalledProcessError as ex:
output = ex.output
output = output.strip()
if len(output) > 0:
pixel_diff = max(pixel_diff,
int(output.split('\n')[1].split()[0]))
error_data.append({
'triangles': numtris,
'width': texim.getXSize(),
'height': texim.getYSize(),
'pixel_error': pixel_diff
})
finally:
shutil.rmtree(tempdir, ignore_errors=True)
return error_data
def getPmPerceptualError(mesh, pm_filebuf, mipmap_tarfilebuf):
perceptualdiff = which('perceptualdiff')
if perceptualdiff is None:
raise Exception("perceptualdiff exectuable not found on path")
pm_chunks = []
if pm_filebuf is not None:
data = pm_filebuf.read(PM_CHUNK_SIZE)
refinements_read = 0
num_refinements = None
while len(data) > 0:
(refinements_read, num_refinements, pm_refinements, data_left) = pdae_utils.readPDAEPartial(data, refinements_read, num_refinements)
pm_chunks.append(pm_refinements)
data = data_left + pm_filebuf.read(PM_CHUNK_SIZE)
tar = tarfile.TarFile(fileobj=mipmap_tarfilebuf)
texsizes = []
largest_tarinfo = (0, None)
for tarinfo in tar:
tarinfo.xsize = int(tarinfo.name.split('x')[0])
if tarinfo.xsize > largest_tarinfo[0]:
largest_tarinfo = (tarinfo.xsize, tarinfo)
if tarinfo.xsize >= 128:
texsizes.append(tarinfo)
if len(texsizes) == 0:
texsizes.append(largest_tarinfo[1])
texsizes = sorted(texsizes, key=lambda t: t.xsize)
texims = []
first_image_data = None
for tarinfo in texsizes:
f = tar.extractfile(tarinfo)
texdata = f.read()
if first_image_data is None:
first_image_data = texdata
texpnm = PNMImage()
texpnm.read(StringStream(texdata), 'something.jpg')
newtex = Texture()
newtex.load(texpnm)
texims.append(newtex)
mesh.images[0].setData(first_image_data)
scene_members = getSceneMembers(mesh)
# turn off panda3d printing to stdout
nout = MultiplexStream()
Notify.ptr().setOstreamPtr(nout, 0)
nout.addFile(Filename(os.devnull))
base = ShowBase()
rotateNode = GeomNode("rotater")
rotatePath = base.render.attachNewNode(rotateNode)
matrix = numpy.identity(4)
if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
r = collada.scene.RotateTransform(0,1,0,90)
matrix = r.matrix
elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
r = collada.scene.RotateTransform(1,0,0,90)
matrix = r.matrix
rotatePath.setMat(Mat4(*matrix.T.flatten().tolist()))
geom, renderstate, mat4 = scene_members[0]
node = GeomNode("primitive")
node.addGeom(geom)
if renderstate is not None:
node.setGeomState(0, renderstate)
geomPath = rotatePath.attachNewNode(node)
geomPath.setMat(mat4)
wrappedNode = ensureCameraAt(geomPath, base.camera)
base.disableMouse()
attachLights(base.render)
base.render.setShaderAuto()
base.render.setTransparency(TransparencyAttrib.MNone)
base.render.setColorScaleOff(9999)
controls.KeyboardMovement()
controls.MouseDrag(wrappedNode)
controls.MouseScaleZoom(wrappedNode)
controls.ButtonUtils(wrappedNode)
controls.MouseCamera()
error_data = []
try:
tempdir = tempfile.mkdtemp(prefix='meshtool-print-pm-perceptual-error')
triangleCounts = []
hprs = [(0, 0, 0),
(0, 90, 0),
(0, 180, 0),
(0, 270, 0),
(90, 0, 0),
(-90, 0, 0)]
for texim in texims:
np = base.render.find("**/rotater/collada")
np.setTextureOff(1)
np.setTexture(texim, 1)
for angle, hpr in enumerate(hprs):
wrappedNode.setHpr(*hpr)
takeScreenshot(tempdir, base, geomPath, texim, angle)
triangleCounts.append(getNumTriangles(geomPath))
for pm_chunk in pm_chunks:
pdae_panda.add_refinements(geomPath, pm_chunk)
for texim in texims:
np = base.render.find("**/rotater/collada")
np.setTextureOff(1)
np.setTexture(texim, 1)
for angle, hpr in enumerate(hprs):
wrappedNode.setHpr(*hpr)
takeScreenshot(tempdir, base, geomPath, texim, angle)
triangleCounts.append(getNumTriangles(geomPath))
full_tris = triangleCounts[-1]
full_tex = texims[-1]
for numtris in triangleCounts:
for texim in texims:
pixel_diff = 0
for angle, hpr in enumerate(hprs):
curFile = '%d_%d_%d_%d.png' % (numtris, texim.getXSize(), texim.getYSize(), angle)
curFile = os.path.join(tempdir, curFile)
fullFile = '%d_%d_%d_%d.png' % (full_tris, full_tex.getXSize(), full_tex.getYSize(), angle)
fullFile = os.path.join(tempdir, fullFile)
try:
output = subprocess.check_output([perceptualdiff, '-threshold', '1', fullFile, curFile])
except subprocess.CalledProcessError as ex:
output = ex.output
output = output.strip()
if len(output) > 0:
pixel_diff = max(pixel_diff, int(output.split('\n')[1].split()[0]))
error_data.append({'triangles': numtris,
'width': texim.getXSize(),
'height': texim.getYSize(),
'pixel_error': pixel_diff})
finally:
shutil.rmtree(tempdir, ignore_errors=True)
return error_data
def __init__(self, outfile, scenefile):
self.outfile = outfile
self.scenefile = scenefile
self.scene = scene.Scene.fromfile(scenefile)
terrain = [m for m in self.scene if m.model_type == 'terrain']
assert len(terrain) == 1
terrain = terrain[0]
mesh = terrain.mesh
boundsInfo = scene.SceneModel.extract_bounds_info(terrain.metadata, 'optimized')
terrain_np = katasked.panda.mesh_to_nodepath(mesh, boundsInfo)
ShowBase.ShowBase.__init__(self)
print
print '==================================='
print ' Controls '
print '==================================='
print ' W - move forward'
print ' S - move backward'
print ' A - strafe left'
print ' D - strafe right'
print ' left arrow - turn left'
print ' right arrow - turn right'
print ' right click drag - camera movement'
print ' [ - slow down'
print ' ] - speed up'
print
print '-----------------------------------------'
print 'Press enter when ready to start capturing'
print '-----------------------------------------'
print
np = self.render.attachNewNode("wrapnode")
terrain_np.reparentTo(np)
np.setPos(terrain.x, terrain.y, terrain.z)
np.setScale(terrain.scale, terrain.scale, terrain.scale)
q = p3d.Quat()
q.setI(terrain.orient_x)
q.setJ(terrain.orient_y)
q.setK(terrain.orient_z)
q.setR(terrain.orient_w)
np.setQuat(q)
self.disableMouse()
pcore.attachLights(self.render)
self.render.setShaderAuto()
self.render.setTransparency(p3d.TransparencyAttrib.MNone)
self.camLens.setFar(sys.maxint)
self.camLens.setNear(8.0)
self.render.setAntialias(p3d.AntialiasAttrib.MAuto)
controls.KeyboardMovement()
controls.MouseCamera()
self.positions = []
self.rotations = []
self.acceptOnce('enter', self.startCapture)
