The depth buffer is reversed when get depth buffer using osgearth

[shiner-chen]

I try to capture a depth image when render the 3dtiles model. I write a demo code that load a obj model and render the depth image. I can render a scene and view the depth buffer, but it's "reversed". That is, close objects are white and distance objects are black.
The following is my code:

#include <osgViewer/Viewer>
#include <osgEarth/Notify>
#include <osgEarth/EarthManipulator>
#include <osgEarth/MapNode>
#include <osgEarth/Threading>
#include <osgEarth/ShaderGenerator>
#include <osgDB/ReadFile>
#include <osgGA/TrackballManipulator>
#include <osgUtil/Optimizer>
#include <iostream>
#include <osgEarth/Metrics>
#include <osgEarth/GDAL>
#include <osgEarth/GeoTransform>
#include <osgEarth/TMS>
using namespace osgEarth;
using namespace osgEarth::Util;
#include <string>
#include <iostream>
using namespace std;

void createScene(osgViewer::Viewer* viewer)
{
        osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
        if (!wsi)
        {
                osg::notify(osg::NOTICE) << "Error, no WindowingSystemInterface available, cannot create windows." << std::endl;
                return;
        }

        unsigned int screenWidth;
        unsigned int screenHeight;

        wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), screenWidth, screenHeight);


        osg::ref_ptr<osg::Texture2D> mOsgExternalDepth = new osg::Texture2D;
        mOsgExternalDepth->setSourceFormat(GL_DEPTH_COMPONENT);
        mOsgExternalDepth->setSourceType(GL_FLOAT);
        mOsgExternalDepth->setInternalFormat(GL_DEPTH_COMPONENT32F);
        mOsgExternalDepth->setTextureWidth(screenWidth);
        mOsgExternalDepth->setTextureHeight(screenHeight);
        mOsgExternalDepth->setResizeNonPowerOfTwoHint(false);

        mOsgExternalDepth->setFilter(osg::Texture2D::MIN_FILTER, osg::Texture2D::NEAREST);
        mOsgExternalDepth->setFilter(osg::Texture2D::MAG_FILTER, osg::Texture2D::NEAREST);

        mOsgExternalDepth->setWrap(osg::Texture2D::WRAP_S, osg::Texture2D::CLAMP_TO_EDGE);
        mOsgExternalDepth->setWrap(osg::Texture2D::WRAP_T, osg::Texture2D::CLAMP_TO_EDGE);

        osg::ref_ptr<osg::Camera> mainCamera = viewer->getCamera();

        mainCamera->attach(osg::Camera::DEPTH_BUFFER, (osg::Texture*)mOsgExternalDepth);


        osg::ref_ptr<osg::Camera> camera = new osg::Camera;
        camera->setProjectionMatrix(osg::Matrixd::ortho2D(0, screenWidth, 0, screenHeight));
        camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
        camera->setViewMatrix(osg::Matrixd::identity());
        camera->setClearMask(GL_DEPTH_BUFFER_BIT);
        camera->setRenderOrder(osg::Camera::POST_RENDER);
        camera->setAllowEventFocus(false);

        viewer->getSceneData()->asGroup()->addChild(camera);

        osg::ref_ptr<osg::Geometry> quad = osg::createTexturedQuadGeometry(osg::Vec3(0, 0, 0), osg::Vec3(screenWidth / 4, 0, 0), osg::Vec3(0, screenHeight / 4, 0));
        quad->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
        quad->getOrCreateStateSet()->setTextureAttributeAndModes(0, mOsgExternalDepth);
#if 1
        const std::string vertShader = ""\
                "void main()                                                                                            "\
                "{                                                                                                                      "\
                "       gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; "\
                "       gl_TexCoord[0] = gl_TextureMatrix[0] *gl_MultiTexCoord0;"\
                "}";

        const std::string fragShader = ""\
                "uniform sampler2D texture0;                                                            "\
                "void main()                                                                                            "\
                "{                                                                                                                      "\
                "       float d = texture2D( texture0, gl_TexCoord[0].xy ).x;   "\
                "       gl_FragColor = vec4(d, d, d, 1);                                                "\
                "}";

        osg::ref_ptr<osg::Shader> vert = new osg::Shader(osg::Shader::VERTEX, vertShader);
        osg::ref_ptr<osg::Shader> frag = new osg::Shader(osg::Shader::FRAGMENT, fragShader);

        osg::ref_ptr<osg::Program> program = new osg::Program;
        program->addShader(vert);
        program->addShader(frag);

        quad->getOrCreateStateSet()->setAttributeAndModes(program);
        quad->getOrCreateStateSet()->addUniform(new osg::Uniform(osg::Uniform::SAMPLER_2D, "texture0", 0));
#endif


        camera->addChild(quad);
}

int main()
{
    osgEarth::initialize();
    //create a viewer
    osgViewer::Viewer viewer ;
    viewer.setUpViewInWindow(0, 100, 800, 600);
    viewer.setReleaseContextAtEndOfFrameHint(false);

    //set camera manipulator
    EarthManipulator* mp = new EarthManipulator;
    viewer.setCameraManipulator(mp);
    // Map is datamodel for collection of layers.
    osg::ref_ptr<osgEarth::Map> rootMap = new osgEarth::Map ;
#if 0
    osg::ref_ptr<TMSImageLayer> bgLayer = new TMSImageLayer();
    bgLayer->setURL(osgEarth::URI("http://readymap.org/readymap/tiles/1.0.0/22/"));
    rootMap->addLayer(bgLayer);
#endif
    //read the model
    osg::Node* treeNode = osgDB::readNodeFile("/home/chenx/osgearth/data/loopix/tree7.osgb");
    ShaderGenerator shader;
    treeNode->accept(shader);
   
    osg::MatrixTransform* scaleTransform = new osg::MatrixTransform;
    osg::Matrix scaleMatrix = osg::Matrix::scale(osg::Vec3(0.1, 0.1, 0.1));
    scaleTransform->setMatrix(scaleMatrix);
    
    scaleTransform->addChild(treeNode);

    osgEarth::GeoTransform* geoTransform = new GeoTransform;
    geoTransform->setPosition(GeoPoint(SpatialReference::get("wgs84"), -77.013, 38.91));
    geoTransform->addChild(scaleTransform);

    // MapNode is the render or visualization of Map.
    osg::ref_ptr<osgEarth::MapNode> rootMapNode = new osgEarth::MapNode(rootMap.get());
    rootMapNode->addChild(geoTransform);
    viewer.setSceneData(rootMapNode);
    createScene(&viewer);
    Viewpoint vp("Washington", -77.013, 38.91, 0, 0, -90, 1000);
    mp->setViewpoint(vp, 3);
    return Metrics::run(viewer);
}

The distance object is black:

The closed object is white:

So I guess there is no depth content in the following picture because the tree is very close.

How to fix this issue, could anyone give me some advice? Thanks a lot!

[gwaldron]

Hard to say. OSG automatically calculates near and far planes as you move the camera, so they will be different in your two screenshots. Just going by the coloration of the image can be misleading. A better test would be to manually set your near and far clipping planes, turn off the automatic calculating in OSG, and see if you get the same result.

camera->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);

[shiner-chen]

My target is that get the depth image when render the 3DTiles model, so I changed the code as follows:

#include <string>
#include <iostream>

#include <osgViewer/Viewer>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgGA/TrackballManipulator>
#include <osgUtil/Optimizer>

#include <osgEarth/Metrics>
#include <osgEarth/GDAL>
#include <osgEarth/GeoTransform>
#include <osgEarth/MapNode>
#include <osgEarth/ShaderGenerator>
#include <osgEarth/Viewpoint>
#include <osgEarth/GeoTransform>
#include <osgEarth/ModelLayer>
#include <osgEarthCesium/CesiumLayer>
#include <osgEarth/EarthManipulator>
#include <osgEarth/Notify>

using namespace osgEarth;
using namespace osgEarth::Util;
using namespace std;

osg::Texture* CreateRTTTexture(int width, int height)
{
    osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
    texture->setSourceFormat(GL_DEPTH_COMPONENT);
    texture->setSourceType(GL_FLOAT);
    texture->setInternalFormat(GL_DEPTH_COMPONENT32F);
    texture->setTextureSize(width, height);

    texture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
    texture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
    texture->setWrap(osg::Texture2D::WRAP_S, osg::Texture2D::CLAMP_TO_EDGE);
    texture->setWrap(osg::Texture2D::WRAP_T, osg::Texture2D::CLAMP_TO_EDGE);
    return texture.release();
}

//osg::Camera* CreateRTTCamera(int width, int height, const osg::BoundingSphere &bs)
osg::Camera* CreateRTTCamera(int width, int height)
{
    osg::ref_ptr<osg::Camera> rttCamera = new osg::Camera;
#if 1
    rttCamera->setProjectionMatrix(osg::Matrixd::ortho2D(0, width, 0, height));
    rttCamera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
    rttCamera->setViewMatrix(osg::Matrixd::identity());
    rttCamera->setClearMask(GL_DEPTH_BUFFER_BIT);
    rttCamera->setRenderOrder(osg::Camera::POST_RENDER);
    rttCamera->setAllowEventFocus(false);

#else
    double viewDistance = bs.radius() * 2.0;
    double znear = viewDistance - bs.radius();
    double zfar = viewDistance + bs.radius();
    float top = znear*0.6;
    float right = znear*0.8;
    rttCamera->setProjectionMatrixAsFrustum(-right, right, -top, top, znear, zfar);

    osg::Vec3d upDiection{0,0,1};
    osg::Vec3d viewDiection{0,-1,0};
    osg::Vec3d viewCenter = bs.center();
    osg::Vec3d eyePoint = viewCenter + viewDiection*viewDistance;
    rttCamera->setViewMatrixAsLookAt(eyePoint,viewCenter, upDiection);

#endif
    
    return rttCamera.release();
}

osg::Geometry* CreateQuad(int width, int height)
{
    osg::ref_ptr<osg::Geometry> quad = osg::createTexturedQuadGeometry(osg::Vec3(0, 0, 0), osg::Vec3(width / 4, 0, 0), osg::Vec3(0, height / 4, 0));
    const std::string vertShader = ""\
        "void main()		"\
        "{			"\
        "    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"\
        "    gl_TexCoord[0] = gl_TextureMatrix[0] *gl_MultiTexCoord0;"\
        "}";

    const std::string fragShader = ""\
        "uniform sampler2D texture0;"\
        "void main()		"\
        "{			"\
        "    float d = texture2D( texture0, gl_TexCoord[0].xy ).x;"\
        "    gl_FragColor = vec4(d, d, d, 1);			"\
        "}";

    osg::ref_ptr<osg::Shader> vert = new osg::Shader(osg::Shader::VERTEX, vertShader);
    osg::ref_ptr<osg::Shader> frag = new osg::Shader(osg::Shader::FRAGMENT, fragShader);
    
    osg::ref_ptr<osg::Program> program = new osg::Program;
    program->addShader(vert);
    program->addShader(frag);
    
    quad->getOrCreateStateSet()->setAttributeAndModes(program);
    quad->getOrCreateStateSet()->addUniform(new osg::Uniform(osg::Uniform::SAMPLER_2D, "texture0", 0));
    return quad.release();
}	

osg::Image* CreateRTTImage(int width, int height, int depth)
{	
    osg::ref_ptr<osg::Image> image = new osg::Image;
    image->allocateImage(width, height, depth, GL_RGBA, GL_UNSIGNED_BYTE);

    return image.release();
}


int main()
{
    int width=800, height=600;

    osgEarth::initialize();

    //create a viewer
    osgViewer::Viewer viewer ;
    viewer.setUpViewInWindow(0, 100, width, height);
    viewer.setReleaseContextAtEndOfFrameHint(false);

    // Map is datamodel for collection of layers.
    osg::ref_ptr<osgEarth::Map> map = new osgEarth::Map ;
    osg::ref_ptr<osgEarth::Cesium::CesiumNative3DTilesLayer> modelLayer = new osgEarth::Cesium::CesiumNative3DTilesLayer();
    // Set the URL of the 3D Tiles file.
    modelLayer->setURL("/v1/3dtiles/datasets/CgA/files/tileset.json");
    modelLayer->setName("3DTiles");
    map->addLayer(modelLayer);
    
    //create map node
    osg::ref_ptr<osgEarth::MapNode> mapNode = new osgEarth::MapNode(map);
    //turn off the lighting
    mapNode->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
    viewer.setSceneData(mapNode);
    
    // main camera bind to texture
    osg::Texture* rttTexture = CreateRTTTexture(width, height);
    osg::ref_ptr<osg::Camera> mainCamera = viewer.getCamera();
    mainCamera->setRenderOrder( osg::Camera::PRE_RENDER ); 
    mainCamera->attach(osg::Camera::DEPTH_BUFFER, (osg::Texture*)rttTexture);


    //rtt camera
    osg::Camera* rttCamera = CreateRTTCamera(width, height);
    mapNode->addChild(rttCamera);

    //quad geometry
    osg::Geometry* quad = CreateQuad(width, height);
    quad->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
    quad->getOrCreateStateSet()->setTextureAttributeAndModes(0, rttTexture);
    rttCamera->addChild(quad);

    //add EarthManipulator
    osg::ref_ptr< osgEarth::EarthManipulator> mainManipulator = new osgEarth::EarthManipulator;
    viewer.setCameraManipulator(mainManipulator);
    
    //go to the viewpoint
    osgEarth::Viewpoint vp;
    osgEarth::GeoPoint newPoint(map->getSRS(), 121.548056, 24.989444, 50);
    vp.focalPoint() = newPoint;
    vp.heading()->set(0, osgEarth::Units::DEGREES);
    vp.pitch()->set(-15, osgEarth::Units::DEGREES);
    vp.range()->set(150, osgEarth::Units::METERS);
    mainManipulator->setViewpoint(vp, 5);

    viewer.realize();
    while(!viewer.done()) {
        viewer.frame();

	double fovy, aspectRatio, zNear, zFar;
	viewer.getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio, zNear, zFar);
	std::cout<< "fovy: " << fovy << " " << "aspectRatio: " << aspectRatio<< " " << "zNear: "<< zNear << " " << "zFar: " <<zFar<<"\n";
    }

    return 0;
}

Now I can get the depth image, please the following image.

The parameter of projectMatrixAsPerspective are fovy: 29.1484 aspectRatio: 1.33333 zNear: 175.517 zFar: 358054
But I have another problem that the depth image disappeared when adjust the camera to to look down.

I get the parameter for projectMatrixAsPerspective as following
fovy: 29.1484 aspectRatio: 1.33333 zNear: 3.14266 zFar: 6411.03

I have tried camera->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);, and give a fixed value: fovy: 29.1484 aspectRatio: 1.33333 zNear: 1 zFar: 400000. This problem is still exist. @gwaldron Could you please give some advice? Thanks a lot!