Пример #1
0
GPU::Texture2D GPU::Texture2D::Clone() const
{
    glPushAttrib( GL_TEXTURE_BIT );

    GPU::Texture2D newTex;
    newTex.Create();
    newTex.m_Width = Width();
    newTex.m_Height = Height();

    if( m_Id )
    {
        GPU::FrameBuffer fbuffer( Width(), Height() );
        fbuffer.Attach( GL_COLOR_ATTACHMENT0_EXT, this );
        fbuffer.Bind();

        newTex.Bind();
        glCopyTexImage2D( GL_TEXTURE_2D, 0, InternalFormat(), 0, 0, Width(), Height(), 0 );
        newTex.Unbind();

        fbuffer.Unbind();
    }

    glPopAttrib();

    return newTex;
}
Пример #2
0
bool FBug96Test()
{
    Bug96Test::simpleStruct_6 si;

    si.en(Bug96Test::GREEN);

    // Create the serializer object.
    char *buffer = (char*)calloc(1, si.getMaxSerializedSize());
    eprosima::FastBuffer fbuffer(buffer, si.getMaxSerializedSize());
    EnumerationsSer serializer(fbuffer);

    // Serialize structure.
    try
    {
        serializer << si;
    }
    catch(eprosima::Exception &ex)
    {
        std::cout << "TEST FAILED<FBug96Test>: Serialization. " << ex.what() << std::endl;
        free(buffer);
        return false;
    }

    // Reset serializer object.
    serializer.reset();

    // Object used to deserialize the data.
    Bug96Test::simpleStruct_6 sires;

    // Deserialize structure.
    try
    {
        serializer >> sires;
    }
    catch(eprosima::Exception &ex)
    {
        std::cout << "TEST FAILED<FBug95Test>: Deserialization. " << ex.what() << std::endl;
        free(buffer);
        return false;
    }

    // Compare data.
    bool compareOK = true;

    compareOK &= si.en() == sires.en();

    if(!compareOK)
    {
        std::cout << "TEST FAILED<FBug96Test>: Wrong values" << std::endl;
        free(buffer);
        return false;
    }

    return true;
}
Пример #3
0
bool GPU::Texture2D::DumpTo( void *buffer,
                             const GLenum format,
                             const GLenum type,
                             const GLint level ) const
{
    if( m_Id )
    {
#if glGetTextureImageEXT    // Extension GL_EXT_direct_state_access is no supported by every common computer...
        glGetTextureImageEXT( m_Id, GL_TEXTURE_2D, level, format, type, buffer );
#else
        GPU::FrameBuffer fbuffer( m_Width, m_Height );
        fbuffer.Attach( GL_COLOR_ATTACHMENT0_EXT, this );
        fbuffer.DumpTo( GL_COLOR_ATTACHMENT0_EXT, buffer, format, type );
#endif
    }

    return m_Id != 0;
}
Пример #4
0
void snapshot(const std::string filename)
{
	GLenum buffer(GL_BACK);
	const int offset = 8;
	int w = glutGet(GLUT_WINDOW_WIDTH) - offset;
	int h = glutGet(GLUT_WINDOW_HEIGHT) - offset;

	std::vector<GLubyte> fbuffer(3 * w * h);

	glReadBuffer(buffer);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	display();
	glReadPixels(0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, &fbuffer[0]);


	std::vector<GLubyte> image(3 * w*h);
	unsigned int x, y, fbuffer_offset, image_offset;

	for (y = 0; y < h; ++y) {
		for (x = 0; x < w; ++x) {
			fbuffer_offset = 3 * (y * w + x);
			image_offset = 3 * ((h - y - 1)* w + x);
			for (int i = 0; i < 3; ++i)
				image[image_offset + i] = fbuffer[fbuffer_offset + i];
		}
	}

	std::string name = filename;
	name.append(".ppm");
	FILE *ppmFile = fopen(name.c_str(), "wb");

	fprintf(ppmFile, "P6\n");
	fprintf(ppmFile, "%d %d\n", w, h);
	fprintf(ppmFile, "255\n");
	fwrite(&image[0], 1, w * h * 3, ppmFile);

	fclose(ppmFile);
}
Пример #5
0
void FilterOutputOpticalFlowPlugin::paintShadowTexture( GPU::Texture2D &shadowMap,
                                                        vcg::Matrix44f &proj,
                                                        vcg::Matrix44f &pose )
{
    glPushAttrib( GL_CURRENT_BIT      |
                  GL_DEPTH_BUFFER_BIT |
                  GL_VIEWPORT_BIT     |
                  GL_POLYGON_BIT      |
                  GL_TRANSFORM_BIT    );

    glEnable( GL_DEPTH_TEST );
    glEnable( GL_POLYGON_OFFSET_FILL );
    glPolygonOffset( 2.0f, 2.0f );

    glMatrixMode( GL_PROJECTION );
    glPushMatrix();
    glLoadMatrixf( proj.V() );
    glMatrixMode( GL_MODELVIEW );
    glPushMatrix();
    glLoadMatrixf( pose.V() );

    GPU::FrameBuffer fbuffer( shadowMap.Width(), shadowMap.Height() );
    fbuffer.Attach( GL_DEPTH_ATTACHMENT, shadowMap );
    fbuffer.Bind();

    glClear( GL_DEPTH_BUFFER_BIT );
    m_MeshVBO.Bind();
    m_MeshVBO.DrawElements( GL_TRIANGLES, 0, 3*m_Mesh->fn );
    m_MeshVBO.Unbind();

    fbuffer.Unbind();

    glPopMatrix();
    glMatrixMode( GL_PROJECTION );
    glPopMatrix();

    glPopAttrib();
}
Пример #6
0
    v8::Handle<v8::Value> BufferWrap::filter_point_in_time(const v8::Arguments& args) {
        INSTANCE_CHECK(BufferWrap, "Buffer", "filter_point_in_time");
        v8::HandleScope scope;
        if (args.Length() != 1) {
            return ThrowException(v8::Exception::TypeError(v8::String::New("please provide a point in time as first and only argument")));
        }

        osmium::Timestamp point_in_time;
        if (args[0]->IsInt32()) {
            point_in_time = args[0]->Int32Value();
        } else if (args[0]->IsString()) {
            v8::String::Utf8Value time_string { args[0] };
            point_in_time = osmium::Timestamp(*time_string);
        } else if (args[0]->IsDate()) {
            point_in_time = osmium::Timestamp(static_cast<int32_t>(v8::Date::Cast(*args[0])->NumberValue() / 1000));
        }

        typedef osmium::DiffIterator<osmium::memory::Buffer::t_iterator<osmium::OSMObject>> diff_iterator;
        osmium::memory::Buffer& buffer = unwrap<BufferWrap>(args.This());
        osmium::memory::Buffer fbuffer(buffer.committed(), osmium::memory::Buffer::auto_grow::yes);
        {
            auto dbegin = diff_iterator(buffer.begin<osmium::OSMObject>(), buffer.end<osmium::OSMObject>());
            auto dend   = diff_iterator(buffer.end<osmium::OSMObject>(), buffer.end<osmium::OSMObject>());

            std::for_each(dbegin, dend, [point_in_time, &fbuffer](const osmium::DiffObject& d) {
                if (((d.end_time() == 0 || d.end_time() > point_in_time) &&
                        d.start_time() <= point_in_time) &&
                    d.curr().visible()) {
                    fbuffer.add_item(d.curr());
                    fbuffer.commit();
                }
            });
        }

        return scope.Close(new_external<BufferWrap>(std::move(fbuffer)));
    }
Пример #7
0
void FilterOutputOpticalFlowPlugin::retroProjection( RasterFaceMap &rpatches,
                                                     float coverageThreshold,
                                                     QMap<int,QVector<int>> &validPairs )
{
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glEnable( GL_CULL_FACE );
    glCullFace( GL_BACK );

    GPU::Texture2D shadowMap;
    GPU::Texture2D colorMap;
    GPU::Shader reprojShader;

    setupMeshVBO();
    setupShader( reprojShader );
    validPairs.clear();

    for( RasterFaceMap::iterator rproj=rpatches.begin(); rproj!=rpatches.end(); ++rproj )
    {
        vcg::Matrix44f proj, pose, shadowProj;
        shadowTextureMatrices( rproj.key(), proj, pose, shadowProj );
        setupShadowAndColorTextures( shadowMap, colorMap, rproj.key() );
        paintShadowTexture( shadowMap, proj, pose );

        for( RasterFaceMap::iterator rref=rpatches.begin(); rref!=rpatches.end(); ++rref )
            if( rref != rproj )
            {
                const vcg::Point2i vp = rref.key()->shot.Intrinsics.ViewportPx;

                // Create the framebuffer for the offscreen rendering.
                GPU::FrameBuffer fbuffer( vp.X(), vp.Y() );
                fbuffer.Attach( GL_COLOR_ATTACHMENT0, GL_RGBA );
                fbuffer.Attach( GL_DEPTH_ATTACHMENT, GL_DEPTH_COMPONENT );
                fbuffer.Bind();

                // Set up the OpenGL state and viewpoint matrices.
                glEnable( GL_DEPTH_TEST );
                glDisable( GL_POLYGON_OFFSET_FILL );

                float zNear, zFar;
                GlShot< vcg::Shot<float> >::GetNearFarPlanes( rref.key()->shot, m_Mesh->bbox, zNear, zFar );
                if( zNear < 0.0001f )
                    zNear = 0.1f;
                if( zFar < zNear )
                    zFar = zNear + 1000.0f;

                GlShot< vcg::Shot<float> >::SetView( rref.key()->shot, zNear, zFar );

                // Perform the rendering of the surface patch associated to the current reference view.
                // The other pictures are then reprojected onto it.
                glClearColor( 1.0f, 0.0f, 1.0f, 0.0f );
                glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

                shadowMap.Bind( 0 );
                colorMap.Bind( 1 );
                reprojShader.Bind();
                reprojShader.SetSampler( "u_ShadowMap" , 0 );
                reprojShader.SetSampler( "u_ColorMap"  , 1 );
                reprojShader.SetUniform( "u_ShadowProj", shadowProj.V() );
                m_MeshVBO.Bind();
                for( FaceVec::iterator f=rref->begin(); f!=rref->end(); ++f )
                    m_MeshVBO.DrawElements( GL_TRIANGLES, 3*(*f - &m_Mesh->face[0]), 3 );
                m_MeshVBO.Unbind();
                reprojShader.Unbind();
                colorMap.Unbind();
                shadowMap.Unbind();

                GlShot< vcg::Shot<float> >::UnsetView();
                fbuffer.Unbind();

                // Read back the content of the framebuffer.
                GLubyte *buffer = new GLubyte [ 4*vp.X()*vp.Y() ];
                glPixelStorei( GL_PACK_ALIGNMENT, 1 );
                fbuffer.DumpTo( GL_COLOR_ATTACHMENT0, buffer, GL_RGBA, GL_UNSIGNED_BYTE );

                // Counts the the number of pixels covered by the whole surface patch, and the number of pixels
                // covered by the reprojection of the other image onto this patch.
                unsigned int coverage = 0, reprojected = 0;
                for( int n=0; n<4*vp.X()*vp.Y(); n+=4 )
                    if( buffer[n+3] == 255 )
                    {
                        coverage ++;
                        if( buffer[n]!=255 && buffer[n+1]!=0 && buffer[n+2]!=255 )
                            reprojected ++;
                    }

                // If the ratio of reprojected pixels is below a given threshold, the current picture pair is ignored.
                if( (float)reprojected/coverage > coverageThreshold )
                {
                    QString filename = QString().sprintf("rectified_%03i_%03i.png", rproj.key()->id+1, rref.key()->id+1 );
                    QImage img( vp.X(), vp.Y(), QImage::Format_RGB888 );
                    for( int y=vp.Y()-1, n=0; y>=0; --y )
                        for( int x=0; x<vp.X(); ++x, n+=4 )
                            img.setPixel( x, y, qRgb(buffer[n],buffer[n+1],buffer[n+2]) );
                    img.save( filename );
                    validPairs[rref.key()->id+1].push_back( rproj.key()->id+1 );
                }

                delete [] buffer;
            }
    }

    m_MeshVBO.Release();
    glPopAttrib();
}
Пример #8
0
// This function performs visibility check and gathers weights for all mesh vertices with respect to the given raster,
// and update their dominant images accordingly.
// The computation is done by a shader that stores weight values in the frame buffer, with a negative weight for
// vertices that are not visible from the current raster's viewpoint. For each mesh vertex, a pixel is written,
// and pixel ordering in the framebuffer corresponds to vertex ordering in the mesh.
void DominancyClassifier::checkDominancy( OOCRaster &rr )
{
    // Save the previous OpenGL state.
    glPushAttrib( GL_VIEWPORT_BIT |
                  GL_ENABLE_BIT   |
                  GL_TEXTURE_BIT  );


    // Create a frambuffer with a viewport big enough to define one pixel per mesh vertex.
    vcg::Point2i vp;
    vp[0] = 2048;
    vp[1] = (int) std::ceil( (float)m_Mesh.vn / vp[0] );

    GPU::FrameBuffer fbuffer( vp[0], vp[1] );
    fbuffer.Attach( GL_COLOR_ATTACHMENT0, GL_LUMINANCE32F_ARB );
    fbuffer.Bind();


    // Set up the shader that will compute visibility check and weight gathering.
    m_VisCheckShader.Bind();
    m_ShadowMap.Bind( 0 );
    m_VisCheckShader.SetSampler( "u_ShadowMap"    , 0 );
    m_WeightMap.Bind( 1 );
    m_VisCheckShader.SetSampler( "u_WeightMap"    , 1 );
    if( m_WeightMask & W_SILHOUETTE )
    {
        m_WeightMapSilh.Bind( 2 );
        m_VisCheckShader.SetSampler( "u_WeightMapSilh", 2 );
    }
    m_VisCheckShader.SetUniform( "u_Viewport", vp.V() );
    m_VisCheckShader.SetUniform( "u_Viewpoint", rr.shot.GetViewPoint().V() );
    m_VisCheckShader.SetUniform( "u_ShadowProj", m_TexProj.V() );


    // Perform the rendering pass.
    glDisable( GL_DEPTH_TEST );
    m_MeshVBO.Bind();
    m_MeshVBO.DrawArrays( GL_POINTS, 0, m_Mesh.vn );
    m_MeshVBO.Unbind();


    // Restore the previous OpenGL state.
    m_ShadowMap.Unbind();
    m_WeightMap.Unbind();
    if( m_WeightMask & W_SILHOUETTE )
        m_WeightMapSilh.Unbind();
    m_VisCheckShader.Unbind();

    fbuffer.Unbind();

    glPopAttrib();


    // Read the content of the framebuffer and update the vertex dominancy accordingly.
    float *weightBuffer = new float [ vp[0]*vp[1] ];
    fbuffer.DumpTo( GL_COLOR_ATTACHMENT0, weightBuffer, GL_LUMINANCE, GL_FLOAT );

    for( int v=0; v<m_Mesh.vn; ++v )
        if( weightBuffer[v] > m_VertexDom[v].weight1 )
        {
            m_VertexDom[v].weight2   = m_VertexDom[v].weight1;
            m_VertexDom[v].dominant2 = m_VertexDom[v].dominant1;

            m_VertexDom[v].weight1   = weightBuffer[v];
            m_VertexDom[v].dominant1 = &rr;
        }
        else if( weightBuffer[v] > m_VertexDom[v].weight2 )
        {
            m_VertexDom[v].weight2   = weightBuffer[v];
            m_VertexDom[v].dominant2 = &rr;
        }

    delete [] weightBuffer;
}
Пример #9
0
void DominancyClassifier::generateWeightsAndShadowMap( OOCRaster &rr )
{
    // Backup the previous OpenGL states.
    glPushAttrib( GL_VIEWPORT_BIT     |
                  GL_COLOR_BUFFER_BIT |
                  GL_TRANSFORM_BIT    |
                  GL_ENABLE_BIT       |
                  GL_POLYGON_BIT      );


    // Set the OpenGL matrices so as to place the viewpoint on the given raster.
    glMatrixMode( GL_PROJECTION );
    glPushMatrix();
    glLoadMatrixf( m_Proj.V() );

    glMatrixMode( GL_MODELVIEW );
    glPushMatrix();
    glLoadMatrixf( m_Pose.V() );


    // Create the off-screen rendering context, using the shadow map texture as depth buffer.
    //m_WeightMap.Create( GL_LUMINANCE32F_ARB, m_ShadowMap.Width(), m_ShadowMap.Height() );
m_WeightMap.Create( GL_LUMINANCE, m_ShadowMap.Width(), m_ShadowMap.Height() );
    m_WeightMap.SetFiltering( GL_NEAREST );

    GPU::FrameBuffer fbuffer( m_ShadowMap.Width(), m_ShadowMap.Height() );
    fbuffer.Attach( GL_COLOR_ATTACHMENT0, m_WeightMap );
    fbuffer.Attach( GL_DEPTH_ATTACHMENT, m_ShadowMap );
    fbuffer.Bind();


    // Perform the rendering pass that computes the the shadow map used afterward for visibility checks
    // as well as the first weight map containing the orientation mask, the image border mask and
    // the distance masks (the silhouette mask is computed hereafter, using the depth gather in the shadow map).
    glEnable( GL_DEPTH_TEST );
    glEnable( GL_POLYGON_OFFSET_FILL );
    glPolygonOffset( 2.0f, 2.0f );

    glClearColor( 0.0f, 1.0f, 0.0f, 1.0f );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    m_WeightShader.Bind();
    m_MeshVBO.TexCoord.Disable();
    m_MeshVBO.Bind();
    m_MeshVBO.DrawElements( GL_TRIANGLES, 0, 3*m_Mesh.fn );
    m_MeshVBO.Unbind();
    m_MeshVBO.TexCoord.Enable();
    m_WeightShader.Unbind();

    fbuffer.Unbind();


    // Restore the previous OpenGL states.
    glMatrixMode( GL_PROJECTION );
    glPopMatrix();
    glMatrixMode( GL_MODELVIEW );
    glPopMatrix();

    glPopAttrib();
#if 0
unsigned char *b = new unsigned char [ fbuffer.Width()*fbuffer.Height() ];
fbuffer.DumpTo( GL_COLOR_ATTACHMENT0, b, GL_LUMINANCE, GL_UNSIGNED_BYTE );
QImage img( b, fbuffer.Width(), fbuffer.Height(), QImage::Format_Indexed8 );
img = img.convertToFormat( QImage::Format_RGB888 );
img.save( "test1.png" );
delete [] b;
#endif


    // Recover the depth of the scene and create the texture containing the step discontinuity mask, if required.
    if( m_WeightMask & W_SILHOUETTE )
    {
        glPushAttrib( GL_TEXTURE_BIT );

        // Read the depth normalized between 0 and 1 from the framebuffer.
        floatbuffer buffer1, buffer2;
        buffer1.init( fbuffer.Width(), fbuffer.Height() );
        buffer2.init( fbuffer.Width(), fbuffer.Height() );
        fbuffer.DumpTo( GL_DEPTH_ATTACHMENT, buffer1.data, GL_DEPTH_COMPONENT, GL_FLOAT );  // WARNING: leads to a GL error.


        float zNear, zFar;
        GlShot< vcg::Shot<float> >::GetNearFarPlanes( rr.shot, m_Mesh.bbox, zNear, zFar );
        if( zNear < 0.0001f )
            zNear = 0.1f;
        if( zFar < zNear )
            zFar = zNear + 1000.0f;

        float range = zFar - zNear;
        for( unsigned int i=0; i<fbuffer.Width()*fbuffer.Height(); ++i )
            if( buffer1.data[i] < 1.0f )
    	        buffer1.data[i] = zNear*zFar / ((zFar - buffer1.data[i]*range)*range);


        // Detect step discontinuities and compute the distance of each pixel to the closest one.
        buffer2.applysobel( &buffer1 );
        buffer2.initborder( &buffer1 );
        buffer2.distancefield();

        // Create the OpenGL texture containing the weight values.
        //m_WeightMapSilh.Create( GL_LUMINANCE32F_ARB, fbuffer.Width(), fbuffer.Height(), GL_LUMINANCE, GL_FLOAT, buffer2.data );
m_WeightMapSilh.Create( GL_LUMINANCE, fbuffer.Width(), fbuffer.Height(), GL_LUMINANCE, GL_FLOAT, buffer2.data );
        m_WeightMapSilh.SetFiltering( GL_NEAREST );

        glPopAttrib();
#if 0
unsigned char *b = new unsigned char [ fbuffer.Width()*fbuffer.Height() ];
for( unsigned int i=0; i<fbuffer.Width()*fbuffer.Height(); ++i )
    b[i] = (unsigned char)(255.0f*buffer2.data[i]);
QImage img( b, fbuffer.Width(), fbuffer.Height(), QImage::Format_Indexed8 );
img = img.convertToFormat( QImage::Format_RGB888 );
img.save( "test2.png" );
delete [] b;
#endif
    }
}