def createSceneGraph(arguments): node = osgDB.readNodeFiles(arguments) if not node : return 0 group = osg.Group() spacing = node.getBound().radius() * 2.0 position = osg.Vec3d(0.0,0.0,0.0) sa1 = NULL stateset = group.getOrCreateStateSet() sa = osg.ShaderAttribute() sa.setType(osg.StateAttribute.Type(10000)) sa1 = sa stateset.setAttribute(sa) vertex_shader = osg.Shader(osg.Shader.VERTEX) vertex_shader.addCodeInjection(-1,"varying vec4 color\n") vertex_shader.addCodeInjection(-1,"varying vec4 texcoord\n") vertex_shader.addCodeInjection(0,"color = gl_Color\n") vertex_shader.addCodeInjection(0,"texcoord = gl_MultiTexCoord0\n") vertex_shader.addCodeInjection(0,"gl_Position = ftransform()\n") sa.addShader(vertex_shader) fragment_shader = osg.Shader(osg.Shader.FRAGMENT) fragment_shader.addCodeInjection(-1,"varying vec4 color\n") fragment_shader.addCodeInjection(-1,"varying vec4 texcoord\n") fragment_shader.addCodeInjection(-1,"uniform sampler2D baseTexture \n") fragment_shader.addCodeInjection(0,"gl_FragColor = color * texture2DProj( baseTexture, texcoord )\n") sa.addShader(fragment_shader)
def main(argv): viewer = osgViewer.Viewer() wm = osgWidget.WindowManager( viewer, WINDOW_WIDTH, WINDOW_HEIGHT, MASK_2D ) menu = osgWidget.Box("menu", osgWidget.Box.HORIZONTAL) menu.addWidget(ColorLabelMenu("Choose EaseMotion")) menu.getBackground().setColor(1.0, 1.0, 1.0, 1.0) menu.setPosition(15.0, 15.0, 0.0) wm.addChild(menu) group = osg.Group() geode = osg.Geode() mt = osg.MatrixTransform() geode.addDrawable(osg.ShapeDrawable(osg.Sphere(osg.Vec3(), 4.0))) EASE_MOTION_SAMPLER = EaseMotionSampler(osg.Vec3(50.0, 0.0, 0.0)) EASE_MOTION_GEODE = osg.Geode() mt.addChild(geode) mt.setUpdateCallback(EASE_MOTION_SAMPLER) mt.setNodeMask(MASK_3D) viewer.setCameraManipulator(osgGA.TrackballManipulator()) viewer.getCameraManipulator().setHomePosition( osg.Vec3d(0.0, 0.0, 200.0), osg.Vec3d(20.0, 0.0, 0.0), osg.Vec3d(0.0, 1.0, 0.0) ) viewer.home() group.addChild(mt) group.addChild(EASE_MOTION_GEODE) return osgWidget.createExample(viewer, wm, group)
def computeViewMatrixOnEarth(camera, scene, latLongHeight, hpr): csn = findTopMostNodeOfType<osg.CoordinateSystemNode>(scene) if not csn : return # Compute eye point in world coordiantes eye = osg.Vec3d() csn.getEllipsoidModel().convertLatLongHeightToXYZ( latLongHeight.x(), latLongHeight.y(), latLongHeight.z(), eye.x(), eye.y(), eye.z() ) # Build matrix for computing target vector target_matrix = osg.Matrixd.rotate( -hpr.x(), osg.Vec3d(1,0,0), -latLongHeight.x(), osg.Vec3d(0,1,0), latLongHeight.y(), osg.Vec3d(0,0,1) ) # Compute tangent vector tangent = target_matrix.preMult( osg.Vec3d(0,0,1) ) # Compute non-inclined, non-rolled up vector up = osg.Vec3d( eye ) up.normalize() # Incline by rotating the target- and up vector around the tangent/up-vector # cross-product up_cross_tangent = up ^ tangent incline_matrix = osg.Matrixd.rotate( hpr.y(), up_cross_tangent ) target = incline_matrix.preMult( tangent ) # Roll by rotating the up vector around the target vector roll_matrix = incline_matrix * osg.Matrixd.rotate( hpr.z(), target ) up = roll_matrix.preMult( up ) camera.setViewMatrixAsLookAt( eye, eye+target, up )
def traverse(nv): if _dragger.valid() : if _active and nv.getVisitorType()==osg.NodeVisitor.CULL_VISITOR : cv = static_cast<osgUtil.CullVisitor*>(nv) pixelSize = cv.pixelSize(_dragger.getBound().center(), 0.48) if pixelSize not =_draggerSize : pixelScale = _draggerSize/pixelSize if (pixelSize>0.0) else 1.0 scaleFactor = osg.Vec3d(pixelScale, pixelScale, pixelScale) trans = _dragger.getMatrix().getTrans() _dragger.setMatrix( osg.Matrix.scale(scaleFactor) * osg.Matrix.translate(trans) )
def main(argv): # use an ArgumentParser object to manage the program arguments. arguments = osg.ArgumentParser(argv) # construct the viewer. viewer = osgViewer.Viewer() # add the state manipulator viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) ) # add stats viewer.addEventHandler( osgViewer.StatsHandler() ) needToSetHomePosition = False # read the scene from the list of file specified commandline args. scene = osgDB.readNodeFiles(arguments) # if one hasn't been loaded create an earth and sun test model. if not scene : scene = createScene() needToSetHomePosition = True # pass the loaded scene graph to the viewer. viewer.setSceneData(scene) viewer.setCameraManipulator(osgGA.TrackballManipulator)() if needToSetHomePosition : viewer.getCameraManipulator().setHomePosition(osg.Vec3d(0.0,-5.0*r_earth,0.0),osg.Vec3d(0.0,0.0,0.0),osg.Vec3d(0.0,0.0,1.0)) zNear = 1.0, zMid=10.0, zFar=1000.0 if arguments.read("--depth-partition",zNear, zMid, zFar) : # set up depth partitioning dps = osgViewer.DepthPartitionSettings() dps._mode = osgViewer.DepthPartitionSettings.FIXED_RANGE dps._zNear = zNear dps._zMid = zMid dps._zFar = zFar viewer.setUpDepthPartition(dps) else: # set up depth partitioning with default settings viewer.setUpDepthPartition() return viewer.run()
def createScene(): # Create the Earth, in blue earth_sd = osg.ShapeDrawable() earth_sphere = osg.Sphere() earth_sphere.setName("EarthSphere") earth_sphere.setRadius(r_earth) earth_sd.setShape(earth_sphere) earth_sd.setColor(osg.Vec4(0, 0, 1.0, 1.0)) earth_geode = osg.Geode() earth_geode.setName("EarthGeode") earth_geode.addDrawable(earth_sd) # Create the Sun, in yellow sun_sd = osg.ShapeDrawable() sun_sphere = osg.Sphere() sun_sphere.setName("SunSphere") sun_sphere.setRadius(r_sun) sun_sd.setShape(sun_sphere) sun_sd.setColor(osg.Vec4(1.0, 0.0, 0.0, 1.0)) sun_geode = osg.Geode() sun_geode.setName("SunGeode") sun_geode.addDrawable(sun_sd) # Move the sun behind the earth pat = osg.PositionAttitudeTransform() pat.setPosition(osg.Vec3d(0.0, AU, 0.0)) pat.addChild(sun_geode) unitCircle = osg.Geometry() colours = osg.Vec4Array(1) (*colours)[0] = osg.Vec4d(1.0,1.0,1.0,1.0) unitCircle.setColorArray(colours, osg.Array.BIND_OVERALL) n_points = 1024 coords = osg.Vec3Array(n_points) dx = 2.0*osg.PI/n_points double s,c for (unsigned int j=0 j<n_points ++j)
for(unsigned int i=0 i<hat.getNumPoints() i++) print " point = ", hat.getPoint(i), " hat = ", hat.getHeightAboveTerrain(i) print "Completed in ", osg.Timer.instance().delta_s(startTick,endTick) #endif # now do a second traversal to test performance of cache. startTick = osg.Timer.instance().tick() print "Computing ElevationSlice" es = osgSim.ElevationSlice() es.setDatabaseCacheReadCallback(los.getDatabaseCacheReadCallback()) es.setStartPoint(bs.center()+osg.Vec3d(bs.radius(),0.0,0.0) ) es.setEndPoint(bs.center()+osg.Vec3d(0.0,0.0, bs.radius()) ) es.computeIntersections(scene) endTick = osg.Timer.instance().tick() print "Completed in ", osg.Timer.instance().delta_s(startTick,endTick) typedef osgSim.ElevationSlice.DistanceHeightList DistanceHeightList dhl = es.getDistanceHeightIntersections() print "Number of intersections =", dhl.size() for(DistanceHeightList.const_iterator dhitr = dhl.begin() not = dhl.end() ++dhitr) std.cout.precision(10)
def test_quat(self): "Adapted from examples/osgunittests/osgunittests.cpp" q1 = osg.Quat() q1.makeRotate(osg.DegreesToRadians(30.0), 0.0, 0.0, 1.0) q2 = osg.Quat() q2.makeRotate(osg.DegreesToRadians(133.0), 0.0, 1.0, 1.0) q1_2 = q1 * q2 q2_1 = q2 * q1 m1 = osg.Matrix.rotate(q1) m2 = osg.Matrix.rotate(q2) m1_2 = m1 * m2 m2_1 = m2 * m1 qm1_2 = osg.Quat() qm1_2.set(m1_2) qm2_1 = osg.Quat() qm2_1.set(m2_1) print "q1*q2 = ", q1_2 print "q2*q1 = ", q2_1 print "m1*m2 = ", qm1_2 print "m2*m1 = ", qm2_1 testQuatRotate(osg.Vec3d(1.0, 0.0, 0.0), osg.Vec3d(0.0, 1.0, 0.0)) testQuatRotate(osg.Vec3d(0.0, 1.0, 0.0), osg.Vec3d(1.0, 0.0, 0.0)) testQuatRotate(osg.Vec3d(0.0, 0.0, 1.0), osg.Vec3d(0.0, 1.0, 0.0)) testQuatRotate(osg.Vec3d(1.0, 1.0, 1.0), osg.Vec3d(1.0, 0.0, 0.0)) testQuatRotate(osg.Vec3d(1.0, 0.0, 0.0), osg.Vec3d(1.0, 0.0, 0.0)) testQuatRotate(osg.Vec3d(1.0, 0.0, 0.0), osg.Vec3d(-1.0, 0.0, 0.0)) testQuatRotate(osg.Vec3d(-1.0, 0.0, 0.0), osg.Vec3d(1.0, 0.0, 0.0)) testQuatRotate(osg.Vec3d(0.0, 1.0, 0.0), osg.Vec3d(0.0, -1.0, 0.0)) testQuatRotate(osg.Vec3d(0.0, -1.0, 0.0), osg.Vec3d(0.0, 1.0, 0.0)) testQuatRotate(osg.Vec3d(0.0, 0.0, 1.0), osg.Vec3d(0.0, 0.0, -1.0)) testQuatRotate(osg.Vec3d(0.0, 0.0, -1.0), osg.Vec3d(0.0, 0.0, 1.0)) # Test a range of rotations testGetQuatFromMatrix(quat_scale) # This is a specific test case for a matrix containing scale and rotation matrix = osg.Matrix(0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 1.0, 1.0, 1.0, 1.0) quat = osg.Quat() matrix.get(quat) print "Matrix = ", matrix, "rotation = ", quat, ", expected quat = (0,0,0,1)"
def createDomeDistortionMesh(origin, widthVector, heightVector, arguments): sphere_radius = 1.0 if arguments.read("--radius", sphere_radius) : collar_radius = 0.45 if arguments.read("--collar", collar_radius) : center = osg.Vec3d(0.0,0.0,0.0) eye = osg.Vec3d(0.0,0.0,0.0) distance = sqrt(sphere_radius*sphere_radius - collar_radius*collar_radius) if arguments.read("--distance", distance) : centerProjection = False projector = eye - osg.Vec3d(0.0,0.0, distance) osg.notify(osg.NOTICE), "Projector position = ", projector osg.notify(osg.NOTICE), "distance = ", distance # create the quad to visualize. geometry = osg.Geometry() geometry.setSupportsDisplayList(False) xAxis = osg.Vec3(widthVector) width = widthVector.length() xAxis /= width yAxis = osg.Vec3(heightVector) height = heightVector.length() yAxis /= height noSteps = 50 vertices = osg.Vec3Array() texcoords = osg.Vec3Array() colors = osg.Vec4Array() bottom = origin dx = xAxis*(width/((float)(noSteps-1))) dy = yAxis*(height/((float)(noSteps-1))) screenCenter = origin + widthVector*0.5 + heightVector*0.5 screenRadius = heightVector.length() * 0.5 int i,j if centerProjection : for(i=0i<noSteps++i) cursor = bottom+dy*(float)i for(j=0j<noSteps++j) delta = osg.Vec2(cursor.x() - screenCenter.x(), cursor.y() - screenCenter.y()) theta = atan2(-delta.y(), delta.x()) phi = osg.PI_2 * delta.length() / screenRadius if phi > osg.PI_2 : phi = osg.PI_2 phi *= 2.0 # osg.notify(osg.NOTICE), "theta = ", theta, "phi=", phi texcoord = osg.Vec3(sin(phi) * cos(theta), sin(phi) * sin(theta), cos(phi)) vertices.push_back(cursor) colors.push_back(osg.Vec4(1.0,1.0,1.0,1.0)) texcoords.push_back(texcoord) cursor += dx
from osgpypp import osg import unittest from numpy import arange # osg.Matrix = osg.Matrixd quat_scale = osg.Vec3d(1, 1, 1) class TestQuat(unittest.TestCase): def test_quat(self): "Adapted from examples/osgunittests/osgunittests.cpp" q1 = osg.Quat() q1.makeRotate(osg.DegreesToRadians(30.0), 0.0, 0.0, 1.0) q2 = osg.Quat() q2.makeRotate(osg.DegreesToRadians(133.0), 0.0, 1.0, 1.0) q1_2 = q1 * q2 q2_1 = q2 * q1 m1 = osg.Matrix.rotate(q1) m2 = osg.Matrix.rotate(q2) m1_2 = m1 * m2 m2_1 = m2 * m1 qm1_2 = osg.Quat() qm1_2.set(m1_2) qm2_1 = osg.Quat() qm2_1.set(m2_1)
def testGetQuatFromMatrix(scale): # Options # acceptable error range eps = 1e-6 # scale matrix # To not test with scale, use 1,1,1 # Not sure if 0's or negative values are acceptable scalemat = osg.Matrixd() scalemat.makeScale(scale) # range of rotations if True: # wide range rol1start = 0.0 rol1stop = 360.0 rol1step = 20.0 pit1start = 0.0 pit1stop = 90.0 pit1step = 20.0 yaw1start = 0.0 yaw1stop = 360.0 yaw1step = 20.0 rol2start = 0.0 rol2stop = 360.0 rol2step = 20.0 pit2start = 0.0 pit2stop = 90.0 pit2step = 20.0 yaw2start = 0.0 yaw2stop = 360.0 yaw2step = 20.0 else: # focussed range rol1start = 0.0 rol1stop = 0.0 rol1step = 0.1 pit1start = 0.0 pit1stop = 5.0 pit1step = 5.0 yaw1start = 89.0 yaw1stop = 91.0 yaw1step = 0.0 rol2start = 0.0 rol2stop = 0.0 rol2step = 0.0 pit2start = 0.0 pit2stop = 0.0 pit2step = 0.1 yaw2start = 89.0 yaw2stop = 91.0 yaw2step = 0.1 #endif print "Starting testGetQuatFromMatrix, it can take a while ..." tstart = osg.Timer.instance().tick() count = 0 for rol1 in arange(rol1start, rol1stop + 1, rol1step): # for (double pit1 = pit1start pit1 <= pit1stop pit1 += pit1step) for pit1 in arange(pit1start, pit1stop + 1, pit1step): # for (double yaw1 = yaw1start yaw1 <= yaw1stop yaw1 += yaw1step) for yaw1 in arange(yaw1start, yaw1stop + 1, yaw1step): # for (double rol2 = rol2start rol2 <= rol2stop rol2 += rol2step) for rol2 in arange(rol2start, rol2stop + 1, rol2step): # for (double pit2 = pit2start pit2 <= pit2stop pit2 += pit2step) for pit2 in arange(pit2start, pit2stop, pit2step): # for (double yaw2 = yaw2start yaw2 <= yaw2stop yaw2 += yaw2step) for yaw2 in arange(yaw2start, yaw2stop + 1, yaw2step): count += 1 # create two quats based on the roll, pitch and yaw values rot_quat1 = osg.Quat(osg.DegreesToRadians(rol1), osg.Vec3d(1, 0, 0), osg.DegreesToRadians(pit1), osg.Vec3d(0, 1, 0), osg.DegreesToRadians(yaw1), osg.Vec3d(0, 0, 1)) rot_quat2 = osg.Quat(osg.DegreesToRadians(rol2), osg.Vec3d(1, 0, 0), osg.DegreesToRadians(pit2), osg.Vec3d(0, 1, 0), osg.DegreesToRadians(yaw2), osg.Vec3d(0, 0, 1)) # create an output quat using quaternion math out_quat1 = rot_quat2 * rot_quat1 # create two matrices based on the input quats # osg.Matrixd mat1,mat2 mat1 = osg.Matrixd() mat2 = osg.Matrixd() mat1.makeRotate(rot_quat1) mat2.makeRotate(rot_quat2) # create an output quat by matrix multiplication and getRotate out_mat = mat2 * mat1 # add matrix scale for even more nastiness out_mat = out_mat * scalemat out_quat2 = out_mat.getRotate() # If the quaternion W is <0, then we should reflect # to get it into the positive W. # Unfortunately, when W is very small (close to 0), the sign # does not really make sense because of precision problems # and the reflection might not work. if out_quat1.w() < 0: out_quat1 = out_quat1 * -1.0 if out_quat2.w() < 0: out_quat2 = out_quat2 * -1.0 # if the output quat length is not one # or if the components do not match, # something is amiss componentsOK = False if (((abs(out_quat1.x() - out_quat2.x())) < eps) and ((abs(out_quat1.y() - out_quat2.y())) < eps) and ((abs(out_quat1.z() - out_quat2.z())) < eps) and ((abs(out_quat1.w() - out_quat2.w())) < eps)): componentsOK = True # We should also test for q = -q which is valid, so reflect # one quat. out_quat2 = out_quat2 * -1.0 if (((abs(out_quat1.x() - out_quat2.x())) < eps) and ((abs(out_quat1.y() - out_quat2.y())) < eps) and ((abs(out_quat1.z() - out_quat2.z())) < eps) and ((abs(out_quat1.w() - out_quat2.w())) < eps)): componentsOK = True lengthOK = False if (abs(1.0 - out_quat2.length()) < eps): lengthOK = True if (not lengthOK) or (not componentsOK): print[ "testGetQuatFromMatrix problem at: \n", " r1=", rol1, " p1=", pit1, " y1=", yaw1, " r2=", rol2, " p2=", pit2, " y2=", yaw2 ] print "quats: ", out_quat1, " length: ", out_quat1.length( ), "\n" print "mats and get: ", out_quat2, " length: ", out_quat2.length( ), "\n\n" tstop = osg.Timer.instance().tick() duration = osg.Timer.instance().delta_s(tstart, tstop) print "Time for testGetQuatFromMatrix with ", count, " iterations: ", duration
DepthPeeling.CullCallback.CullCallback(unsigned int texUnit, unsigned int texWidth, unsigned int texHeight, unsigned int offsetValue) : _texUnit(texUnit), _texWidth(texWidth), _texHeight(texHeight), _offsetValue(offsetValue) void DepthPeeling.CullCallback.operator()(osg.Node* node, osg.NodeVisitor* nv) cullVisitor = static_cast<osgUtil.CullVisitor*>(nv) renderStage = cullVisitor.getCurrentRenderStage() viewport = renderStage.getViewport() m = osg.Matrixd(*cullVisitor.getProjectionMatrix()) m.postMultTranslate(osg.Vec3d(1, 1, 1)) m.postMultScale(osg.Vec3d(0.5, 0.5, 0.5)) # scale the texture coordinates to the viewport #ifdef USE_TEXTURE_RECTANGLE m.postMultScale(osg.Vec3d(viewport.width(), viewport.height(), 1)) #else: #ifndef USE_NON_POWER_OF_TWO_TEXTURE m.postMultScale(osg.Vec3d(viewport.width()/double(_texWidth), viewport.height()/double(_texHeight), 1)) #endif #endif if _texUnit not = 0 and _offsetValue : # Kind of polygon offset: note this way, we can also offset lines and points. # Whereas with the polygon offset we could only handle surface primitives. m.postMultTranslate(osg.Vec3d(0, 0, -ldexp(double(_offsetValue), -24)))
_image = osg.Image*() #define NUM_TEXTURES 4 # The quad geometry is used by the render to texture camera to generate multiple textures. def createRTTQuad(tex_width, tex_height, useHDR): top_group = osg.Group() quad_geode = osg.Geode() quad_coords = osg.Vec3Array() # vertex coords # counter-clockwise quad_coords.push_back(osg.Vec3d(0, 0, -1)) quad_coords.push_back(osg.Vec3d(1, 0, -1)) quad_coords.push_back(osg.Vec3d(1, 1, -1)) quad_coords.push_back(osg.Vec3d(0, 1, -1)) quad_tcoords = osg.Vec2Array() # texture coords quad_tcoords.push_back(osg.Vec2(0, 0)) quad_tcoords.push_back(osg.Vec2(tex_width, 0)) quad_tcoords.push_back(osg.Vec2(tex_width, tex_height)) quad_tcoords.push_back(osg.Vec2(0, tex_height)) quad_geom = osg.Geometry() quad_da = osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4) quad_colors = osg.Vec4Array() quad_colors.push_back(osg.Vec4(1.0,1.0,1.0,1.0))
class #OSGTEXT_EXPORT TextNode : public osg.Group TextNode() TextNode( TextNode text, osg.CopyOp copyop=osg.CopyOp.SHALLOW_COPY) META_Node(osgText, TextNode) traverse = virtual void(osg.NodeVisitor nv) def setFont(font): _font = font def getFont(): return _font def getFont(): return _font def getActiveFont(): return _font : Font: if (_font.valid()) else getDefaultFont() def getActiveFont(): return _font : Font: if (_font.valid()) else getDefaultFont() def setStyle(style): _style = style def getStyle(): return _style def getStyle(): return _style def getActiveStyle(): return _style : Style: if (_style.valid()) else getDefaultStyle() def getActiveStyle(): return _style : Style: if (_style.valid()) else getDefaultStyle() def setLayout(layout): _layout = layout def getLayout(): return _layout def getLayout(): return _layout def getActiveLayout(): return _layout : Layout: if (_layout.valid()) else getDefaultLayout() setTextTechnique = void(TextTechnique* technique) def getTextTechnique(): return _technique def getTextTechnique(): return _technique setText = void( str str) def setText(str): _string = str def getText(): return _string def getText(): return _string def setPosition(position): _position = position def getPosition(): return _position def setRotation(rotation): _rotation = rotation def getRotation(): return _rotation def setCharacterSize(characterSize): _characterSize = characterSize def getCharacterSize(): return _characterSize #/ force a regeneration of the rendering backend required to represent the text. update = virtual void() virtual ~TextNode() _font = Font() _style = Style() _layout = Layout() _technique = TextTechnique() _string = String() _position = osg.Vec3d() _rotation = osg.Quat() _characterSize = float()
static TextTechnique s_defaultTextTechnique = TextTechnique() return s_defaultTextTechnique void TextTechnique.start() OSG_NOTICE, "TextTechnique.start()" void TextTechnique.addCharacter( osg.Vec3 position, osg.Vec3 size, Glyph* glyph, Style* style) OSG_NOTICE, "TextTechnique.addCharacter 2D(", position, ", ", size, ", ", glyph, ", ", style, ")" void TextTechnique.addCharacter( osg.Vec3 position, osg.Vec3 size, Glyph3D* glyph, Style* style) OSG_NOTICE, "TextTechnique.addCharacter 3D(", position, ", ", size, ", ", glyph, ", ", style, ")" transform = osg.PositionAttitudeTransform() transform.setPosition(position) transform.setAttitude(osg.Quat(osg.inDegrees(90.0),osg.Vec3d(1.0,0.0,0.0))) transform.setScale(size) geode = osg.Geode() bevel = style.getBevel() if (style) else 0 outline = style.getOutlineRatio()>0.0 if (style) else False width = style.getThicknessRatio() creaseAngle = 30.0 smooth = True if bevel : thickness = bevel.getBevelThickness() glyphGeometry = osgText.computeGlyphGeometry(glyph, thickness, width) textGeometry = osgText.computeTextGeometry(glyphGeometry, *bevel, width)
def main(argv): # use an ArgumentParser object to manage the program arguments. arguments = osg.ArgumentParser(argv) scene = osgDB.readNodeFiles(arguments) if not scene : print "No model loaded, please specify a valid model on the command line." return 0 print "Intersection " bs = scene.getBound() useIntersectorGroup = True useLineOfSight = True #osg.CoordinateSystemNode* csn = dynamic_cast<osg.CoordinateSystemNode*>(scene) #osg.EllipsoidModel* em = csn.getEllipsoidModel() if (csn) else 0 if useLineOfSight : start = bs.center() + osg.Vec3d(0.0,bs.radius(),0.0) end = bs.center() - osg.Vec3d(0.0, bs.radius(),0.0) deltaRow = osg.Vec3d( 0.0, 0.0, bs.radius()*0.01) deltaColumn = osg.Vec3d( bs.radius()*0.01, 0.0, 0.0) los = osgSim.LineOfSight() #if 1 numRows = 20 numColumns = 20 hat = osgSim.HeightAboveTerrain() hat.setDatabaseCacheReadCallback(los.getDatabaseCacheReadCallback()) for(unsigned int r=0 r<numRows ++r) for(unsigned int c=0 c<numColumns ++c) s = start + deltaColumn * double(c) + deltaRow * double(r) e = end + deltaColumn * double(c) + deltaRow * double(r) los.addLOS(s,e) hat.addPoint(s) print "Computing LineOfSight" startTick = osg.Timer.instance().tick() los.computeIntersections(scene) endTick = osg.Timer.instance().tick() print "Completed in ", osg.Timer.instance().delta_s(startTick,endTick) for(unsigned int i=0 i<los.getNumLOS() i++) intersections = los.getIntersections(i) for(osgSim.LineOfSight.Intersections.const_iterator itr = intersections.begin() not = intersections.end() ++itr) print " point ", *itr
switch(ea.getEventType()) case(osgGA.GUIEventAdapter.PUSH): view = dynamic_cast<osgViewer.View*>(aa) if view : pick(view,ea) return False case(osgGA.GUIEventAdapter.KEYUP): if ea.getKey() == ord("t") : user_event = osgGA.GUIEventAdapter() user_event.setEventType(osgGA.GUIEventAdapter.USER) user_event.setUserValue("vec2f", osg.Vec2f(1.0,2.0)) user_event.setUserValue("vec3f", osg.Vec3f(1.0,2.0, 3.0)) user_event.setUserValue("vec4f", osg.Vec4f(1.0,2.0, 3.0, 4.0)) user_event.setUserValue("vec2d", osg.Vec2d(1.0,2.0)) user_event.setUserValue("vec3d", osg.Vec3d(1.0,2.0, 3.0)) user_event.setUserValue("vec4d", osg.Vec4d(1.0,2.0, 3.0, 4.0)) user_event.setName("osc_test_1") _device.sendEvent(*user_event) default: return False void PickHandler.pick(osgViewer.View* view, osgGA.GUIEventAdapter ea) intersections = osgUtil.LineSegmentIntersector.Intersections() gdlist = "" x = ea.getX()
pat = osg.PositionAttitudeTransform() pat.setPosition(osg.Vec3d(0.0, AU, 0.0)) pat.addChild(sun_geode) unitCircle = osg.Geometry() colours = osg.Vec4Array(1) (*colours)[0] = osg.Vec4d(1.0,1.0,1.0,1.0) unitCircle.setColorArray(colours, osg.Array.BIND_OVERALL) n_points = 1024 coords = osg.Vec3Array(n_points) dx = 2.0*osg.PI/n_points double s,c for (unsigned int j=0 j<n_points ++j) s = sin(dx*j) c = cos(dx*j) (*coords)[j].set(osg.Vec3d(c,s,0.0)) unitCircle.setVertexArray(coords) unitCircle.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) unitCircle.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINE_LOOP,0,n_points)) axes = osg.Geometry() colours = osg.Vec4Array(1) (*colours)[0] = osg.Vec4d(1.0,0.0,0.0,1.0) axes.setColorArray(colours, osg.Array.BIND_OVERALL) coords = osg.Vec3Array(6) (*coords)[0].set(osg.Vec3d(0.0, 0.0, 0.0)) (*coords)[1].set(osg.Vec3d(0.5, 0.0, 0.0)) (*coords)[2].set(osg.Vec3d(0.0, 0.0, 0.0)) (*coords)[3].set(osg.Vec3d(0.0, 0.5, 0.0)) (*coords)[4].set(osg.Vec3d(0.0, 0.0, 0.0)) (*coords)[5].set(osg.Vec3d(0.0, 0.0, 0.5))
class IntersectionUpdateCallback (osg.NodeCallback) : virtual void operator()(osg.Node* #node, osg.NodeVisitor* nv) if not root_ or not terrain_ or not ss_ or not intersectionGroup_ : osg.notify(osg.NOTICE), "IntersectionUpdateCallback not set up correctly." return #traverse(node,nv) frameCount_++ if frameCount_ > 200 : # first we need find the transformation matrix that takes # the terrain into the coordinate frame of the sphere segment. terrainLocalToWorld = osg.Matrixd() terrain_worldMatrices = terrain_.getWorldMatrices(root_) if terrain_worldMatrices.empty() : terrainLocalToWorld.makeIdentity() elif terrain_worldMatrices.size()==1 : terrainLocalToWorld = terrain_worldMatrices.front() else: osg.notify(osg.NOTICE), "IntersectionUpdateCallback: warning cannot interestect with multiple terrain instances, just uses first one." terrainLocalToWorld = terrain_worldMatrices.front() # sphere segment is easier as this callback is attached to the node, so the node visitor has the unique path to it already. ssWorldToLocal = osg.computeWorldToLocal(nv.getNodePath()) # now we can compute the terrain to ss transform possie = terrainLocalToWorld*ssWorldToLocal lines = ss_.computeIntersection(possie, terrain_) if not lines.empty() : if intersectionGroup_.valid() : # now we need to place the intersections which are in the SphereSegmenet's coordinate frame into # to the final position. mt = osg.MatrixTransform() mt.setMatrix(osg.computeLocalToWorld(nv.getNodePath())) intersectionGroup_.addChild(mt) # print "matrix = ", mt.getMatrix() geode = osg.Geode() mt.addChild(geode) geode.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) for(osgSim.SphereSegment.LineList.iterator itr=lines.begin() not = lines.end() ++itr) geom = osg.Geometry() geode.addDrawable(geom) vertices = itr geom.setVertexArray(vertices) geom.addPrimitiveSet(osg.DrawArrays(GL_LINE_STRIP, 0, vertices.getNumElements())) else: osg.notify(osg.NOTICE), "No intersections found" frameCount_ = 0 root_ = osg.observer_ptr<osg.Group>() terrain_ = osg.observer_ptr<osg.Geode>() ss_ = osg.observer_ptr<osgSim.SphereSegment>() intersectionGroup_ = osg.observer_ptr<osg.Group>() frameCount_ = unsigned() class RotateUpdateCallback (osg.NodeCallback) : RotateUpdateCallback() i=0 virtual void operator()(osg.Node* node, osg.NodeVisitor* nv) ss = dynamic_cast<osgSim.SphereSegment *>(node) if ss : ss.setArea(osg.Vec3(cos(i/(2*osg.PI)),sin(i/(2*osg.PI)),0), osg.PI_2, osg.PI_2) i += 0.1 i = float() def createMovingModel(center, radius, terrainGeode, root, createMovingRadar): animationLength = 10.0 animationPath = createAnimationPath(center,radius,animationLength) model = osg.Group() glider = osgDB.readNodeFile("glider.osgt") if glider : bs = glider.getBound() size = radius/bs.radius()*0.3 positioned = osg.MatrixTransform() positioned.setDataVariance(osg.Object.STATIC) positioned.setMatrix(osg.Matrix.translate(-bs.center())* osg.Matrix.scale(size,size,size)* osg.Matrix.rotate(osg.inDegrees(-90.0),0.0,0.0,1.0)) positioned.addChild(glider) xform = osg.PositionAttitudeTransform() xform.getOrCreateStateSet().setMode(GL_NORMALIZE, osg.StateAttribute.ON) xform.setUpdateCallback(osg.AnimationPathCallback(animationPath,0.0,1.0)) xform.addChild(positioned) model.addChild(xform) if createMovingRadar : # The IntersectionUpdateCallback has to have a safe place to put all its generated geometry into, # and this group can't be in the parental chain of the callback otherwise we will end up invalidating # traversal iterators. intersectionGroup = osg.Group() root.addChild(intersectionGroup) xform = osg.PositionAttitudeTransform() xform.setUpdateCallback(osg.AnimationPathCallback(animationPath,0.0,1.0)) ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(135.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) iuc = IntersectionUpdateCallback() iuc.frameCount_ = 0 iuc.root_ = root iuc.terrain_ = terrainGeode iuc.ss_ = ss iuc.intersectionGroup_ = intersectionGroup ss.setUpdateCallback(iuc) ss.setAllColors(osg.Vec4(1.0,1.0,1.0,0.5)) ss.setSideColor(osg.Vec4(0.5,1.0,1.0,0.1)) xform.addChild(ss) model.addChild(xform) cessna = osgDB.readNodeFile("cessna.osgt") if cessna : bs = cessna.getBound() text = osgText.Text() size = radius/bs.radius()*0.3 text.setPosition(bs.center()) text.setText("Cessna") text.setAlignment(osgText.Text.CENTER_CENTER) text.setAxisAlignment(osgText.Text.SCREEN) text.setCharacterSize(40.0) text.setCharacterSizeMode(osgText.Text.OBJECT_COORDS) geode = osg.Geode() geode.addDrawable(text) lod = osg.LOD() lod.setRangeMode(osg.LOD.PIXEL_SIZE_ON_SCREEN) lod.setRadius(cessna.getBound().radius()) lod.addChild(geode,0.0,100.0) lod.addChild(cessna,100.0,10000.0) positioned = osg.MatrixTransform() positioned.getOrCreateStateSet().setMode(GL_NORMALIZE, osg.StateAttribute.ON) positioned.setDataVariance(osg.Object.STATIC) positioned.setMatrix(osg.Matrix.translate(-bs.center())* osg.Matrix.scale(size,size,size)* osg.Matrix.rotate(osg.inDegrees(180.0),0.0,0.0,1.0)) #positioned.addChild(cessna) positioned.addChild(lod) xform = osg.MatrixTransform() xform.setUpdateCallback(osg.AnimationPathCallback(animationPath,0.0,2.0)) xform.addChild(positioned) model.addChild(xform) return model def createOverlay(center, radius): group = osg.Group() # create a grid of lines. geom = osg.Geometry() num_rows = 10 left = center+osg.Vec3(-radius,-radius,0.0) right = center+osg.Vec3(radius,-radius,0.0) delta_row = osg.Vec3(0.0,2.0*radius/float(num_rows-1),0.0) top = center+osg.Vec3(-radius,radius,0.0) bottom = center+osg.Vec3(-radius,-radius,0.0) delta_column = osg.Vec3(2.0*radius/float(num_rows-1),0.0,0.0) vertices = osg.Vec3Array() for(unsigned int i=0 i<num_rows ++i) vertices.push_back(left) vertices.push_back(right) left += delta_row right += delta_row vertices.push_back(top) vertices.push_back(bottom) top += delta_column bottom += delta_column geom.setVertexArray(vertices) color = *(osg.Vec4ubArray(1)) color[0].set(0,0,0,255) geom.setColorArray(color, osg.Array.BIND_OVERALL) geom.addPrimitiveSet(osg.DrawArrays(GL_LINES,0,vertices.getNumElements())) geom.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) geode = osg.Geode() geode.addDrawable(geom) group.addChild(geode) return group def computeTerrainIntersection(subgraph, x, y): bs = subgraph.getBound() zMax = bs.center().z()+bs.radius() zMin = bs.center().z()-bs.radius() intersector = osgUtil.LineSegmentIntersector(osg.Vec3(x,y,zMin),osg.Vec3(x,y,zMax)) iv = osgUtil.IntersectionVisitor(intersector) subgraph.accept(iv) if intersector.containsIntersections() : return intersector.getFirstIntersection().getWorldIntersectPoint() return osg.Vec3(x,y,0.0) ####################################### # MAIN SCENE GRAPH BUILDING FUNCTION ####################################### def build_world(root, testCase, useOverlay, technique): # create terrain terrainGeode = 0 terrainGeode = osg.Geode() stateset = osg.StateSet() image = osgDB.readImageFile("Images/lz.rgb") if image : texture = osg.Texture2D() texture.setImage(image) stateset.setTextureAttributeAndModes(0,texture,osg.StateAttribute.ON) terrainGeode.setStateSet( stateset ) numColumns = 38 numRows = 39 unsigned int r, c origin = osg.Vec3(0.0,0.0,0.0) size = osg.Vec3(1000.0,1000.0,250.0) geometry = osg.Geometry() v = *(osg.Vec3Array(numColumns*numRows)) tc = *(osg.Vec2Array(numColumns*numRows)) color = *(osg.Vec4ubArray(1)) color[0].set(255,255,255,255) rowCoordDelta = size.y()/(float)(numRows-1) columnCoordDelta = size.x()/(float)(numColumns-1) rowTexDelta = 1.0/(float)(numRows-1) columnTexDelta = 1.0/(float)(numColumns-1) # compute z range of z values of grid data so we can scale it. min_z = FLT_MAX max_z = -FLT_MAX for(r=0r<numRows++r) for(c=0c<numColumns++c) min_z = osg.minimum(min_z,vertex[r+c*numRows][2]) max_z = osg.maximum(max_z,vertex[r+c*numRows][2]) scale_z = size.z()/(max_z-min_z) pos = origin tex = osg.Vec2(0.0,0.0) vi = 0 for(r=0r<numRows++r) pos.x() = origin.x() tex.x() = 0.0 for(c=0c<numColumns++c) v[vi].set(pos.x(),pos.y(),pos.z()+(vertex[r+c*numRows][2]-min_z)*scale_z) tc[vi] = tex pos.x()+=columnCoordDelta tex.x()+=columnTexDelta ++vi pos.y() += rowCoordDelta tex.y() += rowTexDelta geometry.setVertexArray(v) geometry.setTexCoordArray(0, tc) geometry.setColorArray(color, osg.Array.BIND_OVERALL) for(r=0r<numRows-1++r) drawElements = *(osg.DrawElementsUShort(GL_QUAD_STRIP,2*numColumns)) geometry.addPrimitiveSet(drawElements) ei = 0 for(c=0c<numColumns++c) drawElements[ei++] = (r+1)*numColumns+c drawElements[ei++] = (r)*numColumns+c smoother = osgUtil.SmoothingVisitor() smoother.smooth(*geometry) terrainGeode.addDrawable(geometry) # create sphere segment ss = 0 terrainToSS = osg.Matrix() switch(testCase) case(0): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(135.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(1): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(45.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(2): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(5.0), osg.DegreesToRadians(355.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(3): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(0.0), osg.DegreesToRadians(360.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(4): ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(135.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) mt = osg.MatrixTransform() mt.setMatrix(osg.Matrix(-0.851781, 0.156428, -0.5, 0, -0.180627, -0.983552, -6.93889e-18, 0, -0.491776, 0.0903136, 0.866025, 0, 598.217, 481.957, 100, 1)) mt.addChild(ss) terrainToSS.invert(mt.getMatrix()) root.addChild(mt) break case(5): ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(35.0), osg.DegreesToRadians(135.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) mt = osg.MatrixTransform() mt.setMatrix(osg.Matrix(-0.851781, 0.156428, -0.5, 0, -0.180627, -0.983552, -6.93889e-18, 0, -0.491776, 0.0903136, 0.866025, 0, 598.217, 481.957, 100, 1)) mt.addChild(ss) terrainToSS.invert(mt.getMatrix()) root.addChild(mt) break case(6): ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(-45.0), osg.DegreesToRadians(45.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) mt = osg.MatrixTransform() mt.setMatrix(osg.Matrix(-0.851781, 0.156428, -0.5, 0, -0.180627, -0.983552, -6.93889e-18, 0, -0.491776, 0.0903136, 0.866025, 0, 598.217, 481.957, 100, 1)) mt.addChild(ss) terrainToSS.invert(mt.getMatrix()) root.addChild(mt) break case(7): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(-240.0), osg.DegreesToRadians(-135.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) ss.setUpdateCallback(RotateUpdateCallback()) root.addChild(ss) break if ss.valid() : ss.setAllColors(osg.Vec4(1.0,1.0,1.0,0.5)) ss.setSideColor(osg.Vec4(0.0,1.0,1.0,0.1)) if not ss.getParents().empty() : ss.getParent(0).addChild(ss.computeIntersectionSubgraph(terrainToSS, terrainGeode)) if useOverlay : overlayNode = osgSim.OverlayNode(technique) overlayNode.getOrCreateStateSet().setTextureAttribute(1, osg.TexEnv(osg.TexEnv.DECAL)) bs = terrainGeode.getBound() overlaySubgraph = createOverlay(bs.center(), bs.radius()*0.5) overlaySubgraph.addChild(ss) overlayNode.setOverlaySubgraph(overlaySubgraph) overlayNode.setOverlayTextureSizeHint(1024) overlayNode.setOverlayBaseHeight(0.0) overlayNode.addChild(terrainGeode) root.addChild(overlayNode) else: root.addChild(terrainGeode) # create particle effects position = computeTerrainIntersection(terrainGeode,100.0,100.0) explosion = osgParticle.ExplosionEffect(position, 10.0) smoke = osgParticle.SmokeEffect(position, 10.0) fire = osgParticle.FireEffect(position, 10.0) root.addChild(explosion) root.addChild(smoke) root.addChild(fire) # create particle effects position = computeTerrainIntersection(terrainGeode,200.0,100.0) explosion = osgParticle.ExplosionEffect(position, 1.0) smoke = osgParticle.SmokeEffect(position, 1.0) fire = osgParticle.FireEffect(position, 1.0) root.addChild(explosion) root.addChild(smoke) root.addChild(fire) createMovingRadar = True # create the moving models. root.addChild(createMovingModel(osg.Vec3(500.0,500.0,500.0),100.0, terrainGeode, root, createMovingRadar)) ####################################### # main() ####################################### def main(argv): # use an ArgumentParser object to manage the program arguments. arguments = osg.ArgumentParser(argv) # set up the usage document, in case we need to print out how to use this program. arguments.getApplicationUsage().setDescription(arguments.getApplicationName()+" is the example which demonstrates use of particle systems.") arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] image_file_left_eye image_file_right_eye") arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information") # construct the viewer. viewer = osgViewer.Viewer(arguments) # if user request help write it out to cout. testCase = 0 while arguments.read("-t", testCase) : useOverlay = False technique = osgSim.OverlayNode.OBJECT_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY while arguments.read("--object") : useOverlay = True technique = osgSim.OverlayNode.OBJECT_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY while arguments.read("--ortho") or arguments.read("--orthographic") : useOverlay = True technique = osgSim.OverlayNode.VIEW_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY while arguments.read("--persp") or arguments.read("--perspective") : useOverlay = True technique = osgSim.OverlayNode.VIEW_DEPENDENT_WITH_PERSPECTIVE_OVERLAY # if user request help write it out to cout. if arguments.read("-h") or arguments.read("--help") : arguments.getApplicationUsage().write(std.cout) return 1 # any option left unread are converted into errors to write out later. arguments.reportRemainingOptionsAsUnrecognized() # report any errors if they have occurred when parsing the program arguments. if arguments.errors() : arguments.writeErrorMessages(std.cout) return 1 root = osg.Group() build_world(root, testCase, useOverlay, technique) # add a viewport to the viewer and attach the scene graph. viewer.setSceneData(root) return viewer.run() if __name__ == "__main__": main(sys.argv)
#if 1 if node.getName().find("Presentation")==str.npos : screenWidth = osg.DisplaySettings.instance().getScreenWidth() screenHeight = osg.DisplaySettings.instance().getScreenHeight() screenDistance = osg.DisplaySettings.instance().getScreenDistance() vfov = atan2(screenHeight/2.0,screenDistance)*2.0 hfov = atan2(screenWidth/2.0,screenDistance)*2.0 viewAngle = vfov if (vfov<hfov) else hfov dist = bs.radius() / sin(viewAngle*0.5) #endif _center = bs.center() _eye = _center - osg.Vec3d(0.0, dist, 0.0) _up = osg.Vec3d(0.0, 0.0, 1.0) _rotationCenter = _center _rotationAxis = osg.Vec3d(0.0, 0.0, 1.0) _rotationSpeed = 0.0 void CameraProperty.update(osgViewer.View* view) camera = view.getCamera() fs = view.getFrameStamp() matrix = osg.Matrixd() matrix.makeLookAt(_eye, _center, _up) if _rotationSpeed not =0.0 :
def main(argv): arguments = osg.ArgumentParser( argc, argv ) usage = arguments.getApplicationUsage() usage.setDescription( arguments.getApplicationName() + " is the example which demonstrates how to render high-resolution images (posters).") usage.setCommandLineUsage( arguments.getApplicationName() + " [options] scene_file" ) usage.addCommandLineOption( "-h or --help", "Display this information." ) usage.addCommandLineOption( "--color <r> <g> <b>", "The background color." ) usage.addCommandLineOption( "--ext <ext>", "The output tiles' extension (Default: bmp)." ) usage.addCommandLineOption( "--poster <filename>", "The output poster's name (Default: poster.bmp)." ) usage.addCommandLineOption( "--tilesize <w> <h>", "Size of each image tile (Default: 640 480)." ) usage.addCommandLineOption( "--finalsize <w> <h>", "Size of the poster (Default: 6400 4800)." ) usage.addCommandLineOption( "--enable-output-poster", "Output the final poster file (Default)." ) usage.addCommandLineOption( "--disable-output-poster", "Don't output the final poster file." ) #usage.addCommandLineOption( "--enable-output-tiles", "Output all tile files." ) #usage.addCommandLineOption( "--disable-output-tiles", "Don't output all tile files (Default)." ) usage.addCommandLineOption( "--use-fb", "Use Frame Buffer for rendering tiles (Default, recommended).") usage.addCommandLineOption( "--use-fbo", "Use Frame Buffer Object for rendering tiles.") usage.addCommandLineOption( "--use-pbuffer","Use Pixel Buffer for rendering tiles.") usage.addCommandLineOption( "--use-pbuffer-rtt","Use Pixel Buffer RTT for rendering tiles.") usage.addCommandLineOption( "--inactive", "Inactive capturing mode." ) usage.addCommandLineOption( "--camera-eye <x> <y> <z>", "Set eye position in inactive mode." ) usage.addCommandLineOption( "--camera-latlongheight <lat> <lon> <h>", "Set eye position on earth in inactive mode." ) usage.addCommandLineOption( "--camera-hpr <h> <p> <r>", "Set eye rotation in inactive mode." ) if arguments.read("-h") or arguments.read("--help") : usage.write( std.cout ) return 1 # Poster arguments activeMode = True outputPoster = True #bool outputTiles = False tileWidth = 640, tileHeight = 480 posterWidth = 640*2, posterHeight = 480*2 posterName = "poster.bmp", extName = "bmp" bgColor = osg.Vec4(0.2, 0.2, 0.6, 1.0) renderImplementation = osg.Camera.FRAME_BUFFER_OBJECT while arguments.read("--inactive") : activeMode = False while arguments.read("--color", bgColor.r(), bgColor.g(), bgColor.b()) : while arguments.read("--tilesize", tileWidth, tileHeight) : while arguments.read("--finalsize", posterWidth, posterHeight) : while arguments.read("--poster", posterName) : while arguments.read("--ext", extName) : while arguments.read("--enable-output-poster") : outputPoster = True while arguments.read("--disable-output-poster") : outputPoster = False #while arguments.read("--enable-output-tiles") : outputTiles = True #while arguments.read("--disable-output-tiles") : outputTiles = False while arguments.read("--use-fbo") : renderImplementation = osg.Camera.FRAME_BUFFER_OBJECT while arguments.read("--use-pbuffer") : renderImplementation = osg.Camera.PIXEL_BUFFER while arguments.read("--use-pbuffer-rtt") : renderImplementation = osg.Camera.PIXEL_BUFFER_RTT while arguments.read("--use-fb") : renderImplementation = osg.Camera.FRAME_BUFFER # Camera settings for inactive screenshot useLatLongHeight = True eye = osg.Vec3d() latLongHeight = osg.Vec3d( 50.0, 10.0, 2000.0 ) hpr = osg.Vec3d( 0.0, 0.0, 0.0 ) if arguments.read("--camera-eye", eye.x(), eye.y(), eye.z()) : useLatLongHeight = False activeMode = False elif arguments.read("--camera-latlongheight", latLongHeight.x(), latLongHeight.y(), latLongHeight.z()) : activeMode = False latLongHeight.x() = osg.DegreesToRadians( latLongHeight.x() ) latLongHeight.y() = osg.DegreesToRadians( latLongHeight.y() ) if arguments.read("--camera-hpr", hpr.x(), hpr.y(), hpr.z()) : activeMode = False hpr.x() = osg.DegreesToRadians( hpr.x() ) hpr.y() = osg.DegreesToRadians( hpr.y() ) hpr.z() = osg.DegreesToRadians( hpr.z() ) # Construct scene graph scene = osgDB.readNodeFiles( arguments ) if not scene : scene = osgDB.readNodeFile( "cow.osgt" ) if not scene : print arguments.getApplicationName(), ": No data loaded" return 1 # Create camera for rendering tiles offscreen. FrameBuffer is recommended because it requires less memory. camera = osg.Camera() camera.setClearColor( bgColor ) camera.setClearMask( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) camera.setReferenceFrame( osg.Transform.ABSOLUTE_RF ) camera.setRenderOrder( osg.Camera.PRE_RENDER ) camera.setRenderTargetImplementation( renderImplementation ) camera.setViewport( 0, 0, tileWidth, tileHeight ) camera.addChild( scene ) # Set the printer printer = PosterPrinter() printer.setTileSize( tileWidth, tileHeight ) printer.setPosterSize( posterWidth, posterHeight ) printer.setCamera( camera ) posterImage = 0 if outputPoster : posterImage = osg.Image() posterImage.allocateImage( posterWidth, posterHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE ) printer.setFinalPoster( posterImage ) printer.setOutputPosterName( posterName ) #if 0 # While recording sub-images of the poster, the scene will always be traversed twice, from its two # parent node: root and camera. Sometimes this may not be so comfortable. # To prevent this behaviour, we can use a switch node to enable one parent and disable the other. # However, the solution also needs to be used with care, as the window will go blank while taking # snapshots and recover later. root = osg.Switch() root.addChild( scene, True ) root.addChild( camera, False ) #else: root = osg.Group() root.addChild( scene ) root.addChild( camera ) #endif viewer = osgViewer.Viewer() viewer.setSceneData( root ) viewer.getDatabasePager().setDoPreCompile( False ) if renderImplementation==osg.Camera.FRAME_BUFFER : # FRAME_BUFFER requires the window resolution equal or greater than the to-be-copied size viewer.setUpViewInWindow( 100, 100, tileWidth, tileHeight ) else: # We want to see the console output, so just render in a window viewer.setUpViewInWindow( 100, 100, 800, 600 ) if activeMode : viewer.addEventHandler( PrintPosterHandler(printer) ) viewer.addEventHandler( osgViewer.StatsHandler )() viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) ) viewer.setCameraManipulator( osgGA.TrackballManipulator )() viewer.run() else: camera = viewer.getCamera() if not useLatLongHeight : computeViewMatrix( camera, eye, hpr ) computeViewMatrixOnEarth = else( camera, scene, latLongHeight, hpr ) renderer = CustomRenderer( camera ) camera.setRenderer( renderer ) viewer.setThreadingModel( osgViewer.Viewer.SingleThreaded ) # Realize and initiate the first PagedLOD request viewer.realize() viewer.frame() printer.init( camera ) while not printer.done() : viewer.advance() # Keep updating and culling until full level of detail is reached renderer.setCullOnly( True ) while viewer.getDatabasePager().getRequestsInProgress() : viewer.updateTraversal() viewer.renderingTraversals() renderer.setCullOnly( False ) printer.frame( viewer.getFrameStamp(), viewer.getSceneData() ) viewer.renderingTraversals() return 0 # Translated from file 'PosterPrinter.cpp' #include <osg/ClusterCullingCallback> #include <osgDB/ReadFile> #include <osgDB/WriteFile> #include <string.h> #include <iostream> #include <sstream> #include "PosterPrinter.h" # PagedLoadingCallback: Callback for loading paged nodes while doing intersecting test class PagedLoadingCallback (osgUtil.IntersectionVisitor.ReadCallback) : def readNodeFile(filename): return osgDB.readNodeFile( filename ) static PagedLoadingCallback g_pagedLoadingCallback = PagedLoadingCallback() # LodCullingCallback: Callback for culling LODs and selecting the highest level class LodCullingCallback (osg.NodeCallback) : virtual void operator()( osg.Node* node, osg.NodeVisitor* nv ) lod = static_cast<osg.LOD*>(node) if lod and lod.getNumChildren()>0 : lod.getChild(lod.getNumChildren()-1).accept(*nv) static LodCullingCallback g_lodCullingCallback = LodCullingCallback() # PagedCullingCallback: Callback for culling paged nodes and selecting the highest level class PagedCullingCallback (osg.NodeCallback) : virtual void operator()( osg.Node* node, osg.NodeVisitor* nv ) pagedLOD = static_cast<osg.PagedLOD*>(node) if pagedLOD and pagedLOD.getNumChildren()>0 : numChildren = pagedLOD.getNumChildren() updateTimeStamp = nv.getVisitorType()==osg.NodeVisitor.CULL_VISITOR if nv.getFrameStamp() and updateTimeStamp : timeStamp = nv.getFrameStamp().getReferenceTime() if (nv.getFrameStamp()) else 0.0 frameNumber = nv.getFrameStamp().getFrameNumber() if (nv.getFrameStamp()) else 0 pagedLOD.setFrameNumberOfLastTraversal( frameNumber ) pagedLOD.setTimeStamp( numChildren-1, timeStamp ) pagedLOD.setFrameNumber( numChildren-1, frameNumber ) pagedLOD.getChild(numChildren-1).accept(*nv) # Request for child if not pagedLOD.getDisableExternalChildrenPaging() and nv.getDatabaseRequestHandler() and numChildren<pagedLOD.getNumRanges() : if pagedLOD.getDatabasePath().empty() : nv.getDatabaseRequestHandler().requestNodeFile( pagedLOD.getFileName(numChildren), nv.getNodePath(), 1.0, nv.getFrameStamp(), pagedLOD.getDatabaseRequest(numChildren), pagedLOD.getDatabaseOptions() ) else: nv.getDatabaseRequestHandler().requestNodeFile( pagedLOD.getDatabasePath()+pagedLOD.getFileName(numChildren), nv.getNodePath(), 1.0, nv.getFrameStamp(), pagedLOD.getDatabaseRequest(numChildren), pagedLOD.getDatabaseOptions() ) #node.traverse(*nv) static PagedCullingCallback g_pagedCullingCallback = PagedCullingCallback() # PosterVisitor: A visitor for adding culling callbacks to newly allocated paged nodes PosterVisitor.PosterVisitor() : osg.NodeVisitor(osg.NodeVisitor.TRAVERSE_ALL_CHILDREN), _appliedCount(0), _needToApplyCount(0), _addingCallbacks(True) void PosterVisitor.apply( osg.LOD node ) #if not hasCullCallback(node.getCullCallback(), g_lodCullingCallback) : # # if not node.getName().empty() : # # itr = _pagedNodeNames.find( node.getName() ) # if itr not =_pagedNodeNames.end() : # # insertCullCallback( node, g_lodCullingCallback ) # _appliedCount++ # # # # def if _addingCallbacks . # # node.removeCullCallback( g_lodCullingCallback ) # _appliedCount-- # traverse( node ) void PosterVisitor.apply( osg.PagedLOD node ) if not hasCullCallback(node.getCullCallback(), g_pagedCullingCallback) : for ( unsigned int i=0 i<node.getNumFileNames() ++i ) if node.getFileName(i).empty() : continue itr = _pagedNodeNames.find( node.getFileName(i) ) if itr not =_pagedNodeNames.end() : node.addCullCallback( g_pagedCullingCallback ) _appliedCount++ break
# any option left unread are converted into errors to write out later. arguments.reportRemainingOptionsAsUnrecognized() # report any errors if they have occurred when parsing the program arguments. if arguments.errors() : arguments.writeErrorMessages(std.cout) return 1 # Setup specified camera if camera_specified : csn = findTopMostNodeOfType<osg.CoordinateSystemNode>(loadedModel) if not csn : return 1 # Compute eye point in world coordiantes eye = osg.Vec3d() csn.getEllipsoidModel().convertLatLongHeightToXYZ(lat, lon, alt, eye.x(), eye.y(), eye.z()) # Build matrix for computing target vector target_matrix = osg.Matrixd.rotate(-heading, osg.Vec3d(1,0,0), -lat, osg.Vec3d(0,1,0), lon, osg.Vec3d(0,0,1)) # Compute tangent vector ... tangent = target_matrix.preMult(osg.Vec3d(0, 0, 1)) # Compute non-inclined, non-rolled up vector ... up = osg.Vec3d(eye) up.normalize() # Incline by rotating the target- and up vector around the tangent/up-vector