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

Go to the documentation of this file.

#ifndef OPENTISSUE_UTILITY_VOLUME_RENDERING_VOLUME_RENDERING_TILE_RENDER_H
#define OPENTISSUE_UTILITY_VOLUME_RENDERING_VOLUME_RENDERING_TILE_RENDER_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/utility/gl/gl_matrix_util.h>
#include <OpenTissue/utility/gl/gl_frustum.h>
#include <OpenTissue/gpu/texture/texture_create_texture3D.h>
#include <OpenTissue/utility/volume_rendering/volume_rendering_texture3d_tile.h>

#include <list>
#include <cassert>

namespace OpenTissue
{
  namespace volume_rendering
  {

    template< 
      typename math_types
      , template <typename> class volume_shader_class_   
    >
    class TileRender
    {
    public:

      typedef typename math_types::real_type         real_type;
      typedef typename math_types::vector3_type      vector3_type;
      typedef Texture3DTile<math_types>              tile_type;
      typedef std::list<tile_type>                   tile_container;
      typedef typename tile_container::iterator      tile_iterator;
      typedef volume_shader_class_<math_types>       volume_shader_type;

    protected:

      real_type                 m_image_min_x;            
      real_type                 m_image_min_y;            
      real_type                 m_image_min_z;            
      real_type                 m_image_width;            
      real_type                 m_image_height;           
      real_type                 m_image_depth;            
      volume_shader_type        m_shader;                 
      tile_container            m_tiles;                  
      gl::Frustum<math_types>   m_frustum;                
      vector3_type              m_vertices[8];            

    public:

      TileRender()
        : m_image_min_x()
        , m_image_min_y()
        , m_image_min_z()
        , m_image_width()
        , m_image_height()
        , m_image_depth()
        , m_shader()
        , m_tiles()
        , m_frustum()
      { }

    public:

      template< typename grid_type >
      void init( grid_type & volume )
      {
        typedef typename grid_type::value_type  T;

        m_tiles.clear();

        real_type dx   = volume.dx();
        real_type dy   = volume.dy();
        real_type dz   = volume.dz();
        unsigned int I = volume.I();
        unsigned int J = volume.J();
        unsigned int K = volume.K();

        m_image_min_x         = volume.min_coord(0) - dx*.5;
        m_image_min_y         = volume.min_coord(1) - dy*.5;
        m_image_min_z         = volume.min_coord(2) - dz*.5;
        real_type image_max_x = volume.max_coord(0) + dx*.5;
        real_type image_max_y = volume.max_coord(1) + dy*.5;
        real_type image_max_z = volume.max_coord(2) + dz*.5;
        m_image_width         = image_max_x - m_image_min_x;
        m_image_height        = image_max_y - m_image_min_y;
        m_image_depth         = image_max_z - m_image_min_z;

        m_vertices[ 0 ] = vector3_type( m_image_min_x , m_image_min_y,  m_image_min_z );
        m_vertices[ 1 ] = vector3_type(   image_max_x , m_image_min_y,  m_image_min_z );
        m_vertices[ 2 ] = vector3_type(   image_max_x ,   image_max_y,  m_image_min_z );
        m_vertices[ 3 ] = vector3_type( m_image_min_x ,   image_max_y,  m_image_min_z );
        m_vertices[ 4 ] = vector3_type( m_image_min_x , m_image_min_y,    image_max_z );
        m_vertices[ 5 ] = vector3_type(   image_max_x , m_image_min_y,    image_max_z );
        m_vertices[ 6 ] = vector3_type(   image_max_x ,   image_max_y,    image_max_z );
        m_vertices[ 7 ] = vector3_type( m_image_min_x ,   image_max_y,    image_max_z );

        //--- Pick fixed power of two sized tiles1!!! More tiles
        //--- but easier to generate tiles and handle borders.
        unsigned int di = 30;         //--- tile dims without borders
        unsigned int dj = 30;
        unsigned int dk = 30;
        unsigned int i_width = di+2;  //--- texture dims with borders
        unsigned int j_width = dj+2;
        unsigned int k_width = dk+2;

        //--- A one-voxel large border is created around the entire volume
        //--- by shrinking it by two voxels in each axis direction.
        for(unsigned int i_first = 1; i_first<(I-1); i_first += di)
          for(unsigned int j_first = 1; j_first<(J-1); j_first += dj)
            for(unsigned int k_first = 1; k_first < (K-1); k_first += dk)
            {
              //--- compute the rest of the volume, before we hit the border
              unsigned int i_rest = (I - 1) - i_first;
              unsigned int j_rest = (J - 1) - j_first;
              unsigned int k_rest = (K - 1) - k_first;

              tile_type tile;

              //--- Params needed for loading sub region of volume image into a 3D texture
              tile.m_image_skip_i   = (i_first-1);
              tile.m_image_skip_j   = (j_first-1);
              tile.m_image_skip_k   = (k_first-1);
              tile.m_image_size_i   = I;
              tile.m_image_size_j   = J;
              tile.m_image_size_k   = K;
              tile.m_texture_size_i = i_width;
              tile.m_texture_size_j = j_width;
              tile.m_texture_size_k = k_width;
              tile.m_texture_fill_i = (i_rest > i_width)?di:i_rest; //--- texutre dims are power of two, but we might not need to fill the entire texture with the volume image.
              tile.m_texture_fill_j = (j_rest > j_width)?dj:j_rest;
              tile.m_texture_fill_k = (k_rest > k_width)?dk:k_rest;

              //--- Empty space skipping!
              T max_val = *(std::max_element(volume.begin(),volume.end()));
              T threshold = static_cast<T>(0.2*max_val); //--- hmm, may this should be user controllable???
              bool empty = true;
              for( int i=0;i<tile.m_texture_fill_i;++i)
              {
                for( int j=0;j<tile.m_texture_fill_j;++j)
                {
                  for( int k=0;k<tile.m_texture_fill_k;++k)
                  {
                    if( volume(i+i_first,j+j_first,k+k_first) > threshold)
                    {
                      empty = false;
                      break;
                    }
                  }
                }
              }
              if(empty)
                continue;

              //--- Needed for drawing AABB of tile without drawing the borders
              real_type width    = tile.m_texture_fill_i*dx;
              real_type height   = tile.m_texture_fill_j*dy;
              real_type depth    = tile.m_texture_fill_k*dz;
              real_type min_x    = m_image_min_x + i_first*dx;
              real_type min_y    = m_image_min_y + j_first*dy;
              real_type min_z    = m_image_min_z + k_first*dz;            
              real_type max_x    = min_x + width;
              real_type max_y    = min_y + height;
              real_type max_z    = min_z + depth;
              tile.m_aabb_width  = width;
              tile.m_aabb_height = height;
              tile.m_aabb_depth  = depth;
              tile.m_aabb_min_x  = min_x;
              tile.m_aabb_min_y  = min_y;
              tile.m_aabb_min_z  = min_z;
              tile.m_vertices[ 0 ] = vector3_type(   min_x ,   min_y,    min_z );
              tile.m_vertices[ 1 ] = vector3_type(   max_x ,   min_y,    min_z );
              tile.m_vertices[ 2 ] = vector3_type(   max_x ,   max_y,    min_z );
              tile.m_vertices[ 3 ] = vector3_type(   min_x ,   max_y,    min_z );
              tile.m_vertices[ 4 ] = vector3_type(   min_x ,   min_y,    max_z );
              tile.m_vertices[ 5 ] = vector3_type(   max_x ,   min_y,    max_z );
              tile.m_vertices[ 6 ] = vector3_type(   max_x ,   max_y,    max_z );
              tile.m_vertices[ 7 ] = vector3_type(   min_x ,   max_y,    max_z );
              tile.m_aabb.set( min_x, min_y, min_z, max_x, max_y, max_z);

              tile.m_volume_texture = OpenTissue::texture::create_texture3D<T>(
                tile.m_texture_size_i
                , tile.m_texture_size_j
                , tile.m_texture_size_k
                );

              tile.m_volume_texture->load_sub_image_into_texture(
                tile.m_image_skip_i
                , tile.m_image_skip_j
                , tile.m_image_skip_k
                , tile.m_image_size_i
                , tile.m_image_size_j
                , tile.m_image_size_k
                , 0, 0 ,0 //--- texture offset
                , tile.m_texture_fill_i + 2   //--- Add border
                , tile.m_texture_fill_j + 2
                , tile.m_texture_fill_k + 2
                , volume.data()
                );
              tile.m_volume_texture->set_repeating(false);

              //--- Needed for texture coordinate generation...
              tile.m_tile_width     = i_width* dx;
              tile.m_tile_height    = j_width* dy;
              tile.m_tile_depth     = k_width* dz;
              tile.m_tile_min_x     = m_image_min_x + (i_first-1)*dx;
              tile.m_tile_min_y     = m_image_min_y + (j_first-1)*dy;
              tile.m_tile_min_z     = m_image_min_z + (k_first-1)*dz;

              m_tiles.push_back(tile);
            }

            std::cout << "|tiles| = " << m_tiles.size() << std::endl;

            m_shader.init();
      }

      template<typename texture2d_pointer>
      void display( texture2d_pointer color_table_texture)
      {
        using std::fabs;
        using std::min;
        using std::max;

        if(m_tiles.empty() || !color_table_texture)
          return;

        GLfloat model2eye_matrix[16];
        GLfloat eye2model_matrix[16];
        glGetFloatv( GL_MODELVIEW_MATRIX, model2eye_matrix );      
        gl::invert( model2eye_matrix, eye2model_matrix );

        real_type min_depth = math::detail::highest<real_type>();
        real_type max_depth = math::detail::lowest<real_type>();
        {
          tile_iterator begin = m_tiles.begin();
          tile_iterator end   = m_tiles.end();
          for(tile_iterator tile=begin;tile!=end;++tile)
          {
            tile->m_min_depth = math::detail::highest<real_type>();
            tile->m_max_depth = math::detail::lowest<real_type>();
            for(unsigned int i=0;i<8;++i)
            {
              tile->m_eye_vertices[i] = gl::xform( model2eye_matrix, tile->m_vertices[i]);
              tile->m_min_depth = min(tile->m_eye_vertices[i](2), tile->m_min_depth);
              tile->m_max_depth = max(tile->m_eye_vertices[i](2), tile->m_max_depth);      
              min_depth = min(min_depth, tile->m_min_depth);
              max_depth = max(max_depth, tile->m_max_depth);      
              vector3_type eye_center = gl::xform( model2eye_matrix, (tile->m_vertices[0]+tile->m_vertices[6])*.5 );
              //--- Squared distance from origo of eye to center of tile, we ignore sign!!!
              tile->m_z_depth = eye_center*eye_center;
            }
          }
        }

        //--- depth sort tiles....
        if(m_shader.front2back())
          m_tiles.sort(std::less<tile_type>( )); 
        else
          m_tiles.sort(std::greater<tile_type>( )); 

        m_frustum.update(); //--- update frustum so we can use it for culling

        m_shader.pre_render(  color_table_texture  );

        tile_iterator begin = m_tiles.begin();
        tile_iterator end   = m_tiles.end();
        for(tile_iterator tile=begin;tile!=end;++tile)
        {
          //--- Trivial rejection, tile is behind us
          if(tile->m_max_depth>0)
            continue;
          //--- Frustum culling, tile is not in our field of view
          if(!m_frustum.contains( tile->m_aabb ) )
            continue;                 
          m_shader.render(*tile);
        }
        m_shader.post_render();
      }

    };

  } // namespace volume_rendering
} // namespace OpenTissue

// OPENTISSUE_UTILITY_VOLUME_RENDERING_VOLUME_RENDERING_TILE_RENDER_H
#endif