/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/utility/volume_rendering/ray_cast_shader/volume_rendering_ray_cast_shader.h

Go to the documentation of this file.

#ifndef OPENTISSUE_UTILITY_VOLUME_RENDERING_RAY_CAST_SHADER_VOLUME_RENDERING_RAY_CAST_SHADER_H
#define OPENTISSUE_UTILITY_VOLUME_RENDERING_RAY_CAST_SHADER_VOLUME_RENDERING_RAY_CAST_SHADER_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>

#include <OpenTissue/gpu/cg/cg_program.h>
#include <OpenTissue/utility/gl/gl_matrix_util.h>
#include <OpenTissue/gpu/texture/texture_create_texture3D.h>
#include <OpenTissue/gpu/texture/texture_create_texture2D.h>
#include <OpenTissue/gpu/texture/texture_show_texture2D.h>
#include <OpenTissue/core/geometry/geometry_aabb.h>
#include <OpenTissue/utility/volume_rendering/volume_rendering_volume_shader.h>
#include <OpenTissue/utility/gl/gl_frame_buffer_object.h>

#include <string>


namespace OpenTissue
{
  namespace volume_rendering
  {
    template<typename math_types>
    class RayCastShader 
      : public VolumeShader< RayCastShader<math_types> >
    {
    public:

      typedef typename math_types::real_type      real_type;
      typedef typename math_types::vector3_type   vector3_type;
      typedef          geometry::AABB<math_types> aabb_type;

    protected:

      OpenTissue::texture::texture3D_pointer     m_volume_texture;   
      OpenTissue::texture::texture2D_pointer     m_texture[4];       
      gl::FramebufferObject m_fbo;              

      cg::Program           m_main_pass_program; 
      cg::Program           m_ray_direction_program;
      cg::Program           m_pass_through_program; 

      real_type           m_delta_t;
      unsigned int        m_iterations;
      unsigned int        m_inner_iterations;
      unsigned int        m_outer_iterations;

      int m_write;
      int m_read;
      int m_ray_map;
      int m_entry_map;

    public:

      unsigned int total_iterations() { return m_iterations; }
      unsigned int const & total_iterations() const { return m_iterations; }
      unsigned int inner_iterations() { return m_inner_iterations; }
      unsigned int const & inner_iterations() const { return m_inner_iterations; }

    protected:

      template<typename tile_type>
      void draw_aabb(tile_type const & tile, real_type delta_t, real_type t) 
      {
        real_type min_x = tile.m_aabb_min_x;
        real_type min_y = tile.m_aabb_min_y;
        real_type min_z = tile.m_aabb_min_z;

        real_type max_x = min_x + tile.m_aabb_width;
        real_type max_y = min_y + tile.m_aabb_height;
        real_type max_z = min_z + tile.m_aabb_depth;

        real_type min_r = (min_x - tile.m_tile_min_x)/tile.m_tile_width;
        real_type max_r = (max_x - tile.m_tile_min_x)/tile.m_tile_width;      
        real_type min_g = (min_y - tile.m_tile_min_y)/tile.m_tile_height;
        real_type max_g = (max_y - tile.m_tile_min_y)/tile.m_tile_height;
        real_type min_b = (min_z - tile.m_tile_min_z)/tile.m_tile_depth;
        real_type max_b = (max_z - tile.m_tile_min_z)/tile.m_tile_depth;

        glBegin(GL_POLYGON);
        glTexCoord2f(delta_t, t); glColor3f( min_r, min_g, max_b); glNormal3f( 0, 0, 1); glVertex3f( min_x, min_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, min_g, max_b); glNormal3f( 0, 0, 1); glVertex3f( max_x, min_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, max_g, max_b); glNormal3f( 0, 0, 1); glVertex3f( max_x, max_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( min_r, max_g, max_b); glNormal3f( 0, 0, 1); glVertex3f( min_x, max_y, max_z);
        glEnd();
        glBegin(GL_POLYGON);
        glTexCoord2f(delta_t, t); glColor3f( max_r, min_g, max_b); glNormal3f( 1, 0, 0); glVertex3f( max_x, min_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, min_g, min_b); glNormal3f( 1, 0, 0); glVertex3f( max_x, min_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, max_g, min_b); glNormal3f( 1, 0, 0); glVertex3f( max_x, max_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, max_g, max_b); glNormal3f( 1, 0, 0); glVertex3f( max_x, max_y, max_z);
        glEnd();
        glBegin(GL_POLYGON);
        glTexCoord2f(delta_t, t); glColor3f( min_r, max_g, max_b); glNormal3f( 0, 1, 0); glVertex3f( min_x, max_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, max_g, max_b); glNormal3f( 0, 1, 0); glVertex3f( max_x, max_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, max_g, min_b); glNormal3f( 0, 1, 0); glVertex3f( max_x, max_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( min_r, max_g, min_b); glNormal3f( 0, 1, 0); glVertex3f( min_x, max_y, min_z);
        glEnd();
        glBegin(GL_POLYGON);
        glTexCoord2f(delta_t, t); glColor3f( min_r, min_g, min_b); glNormal3f( 0, 0,-1); glVertex3f( min_x, min_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( min_r, max_g, min_b); glNormal3f( 0, 0,-1); glVertex3f( min_x, max_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, max_g, min_b); glNormal3f( 0, 0,-1); glVertex3f( max_x, max_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, min_g, min_b); glNormal3f( 0, 0,-1); glVertex3f( max_x, min_y, min_z);
        glEnd();
        glBegin(GL_POLYGON);
        glTexCoord2f(delta_t, t); glColor3f( min_r, min_g, min_b); glNormal3f( 0,-1, 0); glVertex3f( min_x, min_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, min_g, min_b); glNormal3f( 0,-1, 0); glVertex3f( max_x, min_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( max_r, min_g, max_b); glNormal3f( 0,-1, 0); glVertex3f( max_x, min_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( min_r, min_g, max_b); glNormal3f( 0,-1, 0); glVertex3f( min_x, min_y, max_z);
        glEnd();
        glBegin(GL_POLYGON);
        glTexCoord2f(delta_t, t); glColor3f( min_r, min_g, min_b); glNormal3f(-1, 0, 0); glVertex3f( min_x, min_y, min_z);
        glTexCoord2f(delta_t, t); glColor3f( min_r, min_g, max_b); glNormal3f(-1, 0, 0); glVertex3f( min_x, min_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( min_r, max_g, max_b); glNormal3f(-1, 0, 0); glVertex3f( min_x, max_y, max_z);
        glTexCoord2f(delta_t, t); glColor3f( min_r, max_g, min_b); glNormal3f(-1, 0, 0); glVertex3f( min_x, max_y, min_z);
        glEnd();
      };

    public:

      RayCastShader() 
        : m_iterations(32) 
      {}

      ~RayCastShader() 
      { 
        gl::FramebufferObject::disable(); 
      }

      void init()
      {
        static const GLenum buffer[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT };
        using std::sqrt;
        GLfloat viewport[4];
        glGetFloatv( GL_VIEWPORT, viewport );
        int width  = static_cast<int>( viewport[ 2 ] );
        int height = static_cast<int>( viewport[ 3 ] );
        for(unsigned int i=0;i<4;++i)
          m_texture[i] = OpenTissue::texture::create_float_texture_rectangle( width, height, 4, 0 );
        m_fbo.bind();
        for(unsigned int i=0;i<4;++i)
          m_fbo.attach_texture( buffer[i], m_texture[i] );
        m_fbo.is_valid();
        gl::FramebufferObject::disable();
      }

      bool front2back()const{ return true; }

      template<typename texture2d_pointer>
      void pre_render(texture2d_pointer color_table_texture)
      {
        glPushAttrib( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT );

        static const GLenum buffer[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT };
        m_fbo.bind();
        glDisable( GL_LIGHTING );
        glDisable( GL_ALPHA_TEST );
        glDisable( GL_SCISSOR_TEST );
        glDisable( GL_STENCIL_TEST );
        glDisable( GL_BLEND );
        glDisable( GL_DEPTH_TEST );
        glEnable( GL_CULL_FACE );
        glClearColor( 0, 0, 0, 0 );

        m_write     = 0;
        m_read      = 1;
        m_entry_map = 2;
        m_ray_map   = 3;

        glDrawBuffer( buffer[m_write] );
        glClear( GL_COLOR_BUFFER_BIT );
        glDrawBuffer( buffer[m_read] );
        glClear( GL_COLOR_BUFFER_BIT );

        static std::string path = opentissue_path + "/OpenTissue/utility/volume_rendering/ray_cast_shader";
        if(!m_pass_through_program.is_program_loaded())
          m_pass_through_program.load_from_file(cg::Program::fragment_program,path + "/fp_pass_through.cg");
        if(!m_ray_direction_program.is_program_loaded())
          m_ray_direction_program.load_from_file(cg::Program::fragment_program,path + "/fp_ray_direction.cg");
        if(!m_main_pass_program.is_program_loaded())
          m_main_pass_program.load_from_file(cg::Program::fragment_program,path + "/fp_main_pass.cg");
        m_main_pass_program.set_input_texture( "color_table"     ,  color_table_texture );
      }

      template<typename tile_type>
      void render(tile_type const & tile)
      {
        using std::ceil;

        static const GLenum buffer[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT };

        float diagonal = sqrt(3.0);
        m_delta_t = diagonal / m_iterations;
        m_inner_iterations = 8;
        m_outer_iterations = static_cast<unsigned int> ( ceil( 1.f * m_iterations / m_inner_iterations ) );
        real_type delta = m_delta_t * m_inner_iterations; //--- ray length increase over each outer iteration

        glDrawBuffer( buffer[m_entry_map] );
        glClear( GL_COLOR_BUFFER_BIT );
        glCullFace( GL_BACK );
        m_pass_through_program.enable();
        draw_aabb(tile,0,0);
        m_pass_through_program.disable();

        glDrawBuffer(buffer[m_ray_map]);
        glClear( GL_COLOR_BUFFER_BIT );
        glCullFace( GL_FRONT );
        m_ray_direction_program.set_input_texture( "entry_map",  m_texture[m_entry_map]     );
        m_ray_direction_program.enable();
        draw_aabb(tile,0,0);
        m_ray_direction_program.disable();

        glCullFace( GL_BACK );
        m_main_pass_program.set_input_texture( "ray_map",  m_texture[m_ray_map] );
        m_main_pass_program.set_input_texture( "volume",  tile.m_volume_texture );
        m_main_pass_program.enable();
        for ( unsigned int i = 0; i < m_outer_iterations; ++i )
        {
          glDrawBuffer (buffer[m_write]);
          m_main_pass_program.set_input_texture( "image",  m_texture[m_read] );
          draw_aabb(tile,m_delta_t, i*delta);
          std::swap(m_write,m_read);
        }
        m_main_pass_program.disable();

        //--- for debugging purpose, just ignore it!
        //glDisable(GL_TEXTURE_2D);
        //glDisable(GL_TEXTURE_3D);
        //glDisable( GL_LIGHTING );
        //draw_aabb(tile, 0, 0);
      }

      void post_render()
      {
        gl::FramebufferObject::disable();
        glPopAttrib();
        show_texture2D(m_texture[m_read]);
      }
    };

  } // namespace volume_rendering
} // namespace OpenTissue

// OPENTISSUE_UTILITY_VOLUME_RENDERING_RAY_CAST_SHADER_VOLUME_RENDERING_RAY_CAST_SHADER_H
#endif