dwtobj.cpp

This code demonstrate Fast Wavelet Transform. Executable and can be run on Visual C++ platform

  {
    cgGLLoadProgram(m_fillProg);
    m_fill_Tex_Param = cgGetNamedParameter(m_fillProg, "texture");
    assert(m_fill_Tex_Param != NULL);

  }


  //*******************************************************
  //****            forward dwt programs               ****
  //*******************************************************
  if (mode == forward || mode == both)
  {
    // Horizontal 1D forward DWT 
    m_dwtrowProg = cgCreateProgram(cgContext,
                                   CG_SOURCE,
                                   dwtsource, m_fpProfile, NULL, NULL);
    if (m_dwtrowProg != NULL)
    {
      cgGLLoadProgram(m_dwtrowProg);
      m_dwtrow_imageTex_Param  = cgGetNamedParameter(m_dwtrowProg, "dwt");
      assert(m_dwtrow_imageTex_Param != NULL);
      m_dwtrow_filterTex_Param = cgGetNamedParameter(m_dwtrowProg, "filter");
      assert(m_dwtrow_filterTex_Param != NULL);
      m_dwtrow_lookup_Param    = cgGetNamedParameter(m_dwtrowProg, "lut");
      assert(m_dwtrow_lookup_Param != NULL);
      m_dwtrow_level_Param     = cgGetNamedParameter(m_dwtrowProg, "level");
      assert(m_dwtrow_level_Param != NULL);

    }

    // Vertical 1D forward DWT 
    m_dwtcolProg = cgCreateProgram(cgContext,
                                   CG_SOURCE,
                                   dwtcolsource,
                                   m_fpProfile, NULL, NULL);
    if (m_dwtcolProg != NULL)
    {
      cgGLLoadProgram(m_dwtcolProg);
      m_dwtcol_imageTex_Param  = cgGetNamedParameter(m_dwtcolProg, "dwt");
      assert(m_dwtcol_imageTex_Param != NULL);
      m_dwtcol_filterTex_Param = cgGetNamedParameter(m_dwtcolProg, "filter");
      assert(m_dwtcol_filterTex_Param != NULL);
      m_dwtcol_lookup_Param    = cgGetNamedParameter(m_dwtcolProg, "lut");
      assert(m_dwtcol_lookup_Param != NULL);
      m_dwtcol_level_Param     = cgGetNamedParameter(m_dwtcolProg, "level");
      assert(m_dwtcol_level_Param != NULL);
    }
  }



  //*******************************************************
  //****            inverse dwt programs                ***
  //*******************************************************
  if (mode == inverse || mode == both)
  {

    // Horizontal 1D inverse DWT
    m_invdwtrowProg = cgCreateProgram(cgContext,
                                      CG_SOURCE,
                                      invdwtsource,
                                      m_fpProfile, NULL, NULL);
    if (m_invdwtrowProg != NULL)
    {
      cgGLLoadProgram(m_invdwtrowProg);
      m_invdwtrow_imageTex_Param  = cgGetNamedParameter(m_invdwtrowProg, "dwt");
      assert(m_invdwtrow_imageTex_Param != NULL);
      m_invdwtrow_filterTex_Param = cgGetNamedParameter(m_invdwtrowProg, "filter");
      assert(m_invdwtrow_filterTex_Param != NULL);
      m_invdwtrow_lookup_Param    = cgGetNamedParameter(m_invdwtrowProg, "lut");
      assert(m_invdwtrow_lookup_Param != NULL);
      m_invdwtrow_level_Param     = cgGetNamedParameter(m_invdwtrowProg, "level");
      assert(m_invdwtrow_level_Param != NULL);
    }


    // Vertical 1D inverse DWT
    m_invdwtcolProg = cgCreateProgram(cgContext,
                                      CG_SOURCE,
                                      invdwtcolsource,                                      
                                      m_fpProfile, NULL, NULL);
    if (m_invdwtcolProg != NULL)
    {
      cgGLLoadProgram(m_invdwtcolProg);
      m_invdwtcol_imageTex_Param  = cgGetNamedParameter(m_invdwtcolProg, "dwt");
      assert(m_invdwtcol_imageTex_Param != NULL);
      m_invdwtcol_filterTex_Param = cgGetNamedParameter(m_invdwtcolProg, "filter");
      assert(m_invdwtcol_filterTex_Param != NULL);
      m_invdwtcol_lookup_Param    = cgGetNamedParameter(m_invdwtcolProg, "lut");
      assert(m_invdwtcol_lookup_Param != NULL);
      m_invdwtcol_level_Param     = cgGetNamedParameter(m_invdwtcolProg, "level");
      assert(m_invdwtcol_level_Param != NULL);
      m_invdwtcol_texwidth_Param  = cgGetNamedParameter(m_invdwtcolProg, "texwidth");
      assert(m_invdwtcol_texwidth_Param != NULL);
      m_invdwtcol_texheight_Param = cgGetNamedParameter(m_invdwtcolProg, "texheight");
      assert(m_invdwtcol_texheight_Param != NULL);
    }
  }

  return true;
}




//------------------------------------------------------------------------------
// Function         : CDwtObj::get_buffer
// Description      : retrieve the transformed buffer
//------------------------------------------------------------------------------
// [in,out] myfloatbuffer-- pointer to USER ALLOCATED buffer for storing the result
//
void CDwtObj::getbuffer(float *myfloatbuffer)
{
  if ( m_busefbo )
  {
    //select the last operated colorbuffer and readback the pixel values       
    if(m_iReadBuffer == 0) 
      glReadBuffer(GL_COLOR_ATTACHMENT1_EXT); 
    else 
      glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);    
    glReadPixels(0, 0, m_imageWidth, m_imageHeight, GL_RGB, GL_FLOAT, myfloatbuffer);
    // Disable the FBO
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  }
  else  
  {
    //select the last operated buffer and readback the pixel values         
    m_rt[1 - m_iReadBuffer]->BeginCapture();
    glReadPixels(0, 0, m_imageWidth, m_imageHeight, GL_RGB, GL_FLOAT, myfloatbuffer);
    PrintGLerror("readbuffer");
    m_rt[1 - m_iReadBuffer]->EndCapture();
  }
}




//------------------------------------------------------------------------------
// Function         : CDwtObj::createFilterTex
// Description      : create the high/low pass filter texture
//------------------------------------------------------------------------------
// [in] mode--dwt mode ( forward, backward ,both)
//
bool CDwtObj::createFilterTex(dwtmode mode)
{

  DELTEXTURES(1, &m_decomFilterTexID);
  DELTEXTURES(1, &m_reconFilterTexID);
  glGenTextures(1, &m_decomFilterTexID);
  glGenTextures(1, &m_reconFilterTexID);

  // create the filter textures
  if (mode == forward || mode == both)
  {
    glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_decomFilterTexID);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_R32_NV, 18, 1, 0, GL_RED, GL_FLOAT, decomp_filter);
  }

  if (mode == inverse || mode == both)
  {
    glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_reconFilterTexID);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_R32_NV, 18, 1, 0, GL_RED, GL_FLOAT, recon_filter);
  }

  return true;
}


//------------------------------------------------------------------------------
// Function         : CDwtObj::forward_dwt
// Description      : do forward dwt
//------------------------------------------------------------------------------
// [in] level-- level 0 for whole image, level 1 for upper left 1/4 image, and so on
// [in] startx, endx, starty, endy -- the indices of x and y direction
//
// Modification history
//
// 15 March 2006 (by Liang Wan)
// -- Use Framebuffer objects in place of pbuffer
// 
#define RASTER_QUAD    { glBegin(GL_QUADS);                                        \
                           glTexCoord2f(             0.0f,               0.0f);    \
                           glVertex2f  (             0.0f,               0.0f);    \
                           glTexCoord2f((float) quadWidth,               0.0f);    \
                           glVertex2f  ((float) quadWidth,               0.0f);    \
                           glTexCoord2f((float) quadWidth, (float) quadHeight);    \
                           glVertex2f  ((float) quadWidth, (float) quadHeight);    \
                           glTexCoord2f(0.0f,              (float) quadHeight);    \
                           glVertex2f  (0.0f,              (float) quadHeight);    \
                         glEnd(); }

bool CDwtObj::forwarddwt(int level, int startx, int starty, int endx, int endy)
{

  int quadWidth, quadHeight, tmp;

  calLength(startx, endx, level, &quadWidth, &tmp);
  calLength(starty, endy, level, &quadHeight, &tmp);

  // Vertical Decomposition

  if (quadHeight > 1)
  {
    if ( m_busefbo ) 
    {
      if ( m_iReadBuffer == 0 ) 
        glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
      else 
        glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);      
    } 
    else 
      m_rt[m_iReadBuffer]->BeginCapture();
    

    cgGLBindProgram   (m_dwtcolProg);
    cgGLEnableProfile(m_fpProfile);
    cgGLSetParameter1f(m_dwtcol_level_Param, level);
    if ( m_busefbo ) 
      cgGLSetTextureParameter    (m_dwtcol_imageTex_Param,  m_fbort[1-m_iReadBuffer]);
    else 
      cgGLSetTextureParameter    (m_dwtcol_imageTex_Param,  m_rt[1 - m_iReadBuffer]->GetTextureID());
    
    cgGLEnableTextureParameter (m_dwtcol_imageTex_Param);
    cgGLSetTextureParameter    (m_dwtcol_filterTex_Param, m_decomFilterTexID);
    cgGLEnableTextureParameter (m_dwtcol_filterTex_Param);
    cgGLSetTextureParameter    (m_dwtcol_lookup_Param,    m_colLookupTexID);
    cgGLEnableTextureParameter (m_dwtcol_lookup_Param);

    // Draw the quad or actually perform vertical decomposition
    RASTER_QUAD;

    cgGLDisableTextureParameter(m_dwtcol_imageTex_Param);
    cgGLDisableTextureParameter(m_dwtcol_filterTex_Param);
    cgGLDisableTextureParameter(m_dwtcol_lookup_Param);
    cgGLDisableProfile(m_fpProfile);

    if ( !m_busefbo ) 
      m_rt[m_iReadBuffer]->EndCapture();
    
    m_iReadBuffer = (m_iReadBuffer + 1) % 2;
  }
  else   // pass through if not enough length
  {
    if ( m_busefbo ) 
    {
      if ( m_iReadBuffer == 0 ) 
        glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
      else 
        glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);
    } 
    else 
      m_rt[m_iReadBuffer]->BeginCapture();

    cgGLBindProgram(m_fillProg);
    cgGLEnableProfile(m_fpProfile);
    if ( m_busefbo ) 
      cgGLSetTextureParameter   (m_fill_Tex_Param, m_fbort[1 - m_iReadBuffer]);
    else 
      cgGLSetTextureParameter   (m_fill_Tex_Param, m_rt[1 - m_iReadBuffer]->GetTextureID());    
    cgGLEnableTextureParameter(m_fill_Tex_Param);

    RASTER_QUAD;

    cgGLDisableTextureParameter(m_fill_Tex_Param);
    cgGLDisableProfile(m_fpProfile);

    if ( !m_busefbo ) 
      m_rt[m_iReadBuffer]->EndCapture();
    
    m_iReadBuffer = (m_iReadBuffer + 1) % 2;
  }



  // Horizontal  Decomposition
  if (quadWidth > 1)
  {
    if ( m_busefbo ) 
    {
      if ( m_iReadBuffer == 0 ) 
        glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
      else 
        glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);      
    }
    else 
      m_rt[m_iReadBuffer]->BeginCapture();
    
    cgGLBindProgram   (m_dwtrowProg);
    cgGLEnableProfile(m_fpProfile);
    cgGLSetParameter1f(m_dwtrow_level_Param, (float) level);
    if ( m_busefbo ) 
      cgGLSetTextureParameter(m_dwtrow_imageTex_Param,  m_fbort[1-m_iReadBuffer]);
    else 
      cgGLSetTextureParameter(m_dwtrow_imageTex_Param,  m_rt[1 - m_iReadBuffer]->GetTextureID());    
    cgGLEnableTextureParameter(m_dwtrow_imageTex_Param);
    cgGLSetTextureParameter   (m_dwtrow_filterTex_Param, m_decomFilterTexID);
    cgGLEnableTextureParameter(m_dwtrow_filterTex_Param);
    cgGLSetTextureParameter   (m_dwtrow_lookup_Param,    m_rowLookupTexID);
    cgGLEnableTextureParameter(m_dwtrow_lookup_Param);

    RASTER_QUAD;

    cgGLDisableTextureParameter(m_dwtrow_imageTex_Param);
    cgGLDisableTextureParameter(m_dwtrow_filterTex_Param);
    cgGLDisableTextureParameter(m_dwtrow_lookup_Param);
    cgGLDisableProfile(m_fpProfile);
    if ( !m_busefbo ) 
      m_rt[m_iReadBuffer]->EndCapture();
    m_iReadBuffer = (m_iReadBuffer + 1) % 2;
  }
  else   // pass through if not enough length
  {
    if ( m_busefbo ) 
    {
      if ( m_iReadBuffer == 0 ) 
        glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
      else 
        glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);      
    } 
    else 
      m_rt[m_iReadBuffer]->BeginCapture();
    cgGLBindProgram  (m_fillProg);
    cgGLEnableProfile(m_fpProfile);
    if ( m_busefbo ) 
      cgGLSetTextureParameter   (m_fill_Tex_Param, m_fbort[1 - m_iReadBuffer]);
    else 
      cgGLSetTextureParameter   (m_fill_Tex_Param, m_rt[1 - m_iReadBuffer]->GetTextureID());    
    cgGLEnableTextureParameter(m_fill_Tex_Param);

    RASTER_QUAD;

    cgGLDisableTextureParameter(m_fill_Tex_Param);
    cgGLDisableProfile(m_fpProfile);
    if ( !m_busefbo ) 
      m_rt[m_iReadBuffer]->EndCapture();
    m_iReadBuffer = (m_iReadBuffer + 1) % 2;
  }

  return true;
}





//------------------------------------------------------------------------------
// Function         : CDwtObj::OneTimeDWT2
// Description      : one-stop solution for dwt,  
//------------------------------------------------------------------------------
// [in] mode    -- boundary extension mode (symper, per)
// [in] imagewidth,  imageheight  -- image dimension
// [in out]  imagebuffer        --  pointer for input buffer, when returned it holds the output
// [in]  beg_level, end_level -- begin level and end level for dwt
// [in]  isforward      -- ture for forward transform , false for inverse
// [in]  initGL -- initialize opengl? ( in opengl app, usually false)
// [in] initGLEW -- initialize glew, the extension libary
// [in] startx, endx, starty, endy -- the indices of x and y direction
//
bool CDwtObj::dwtallinone(extmode mode, int imagewidth, int imageheight, float *imagebuffer, int beg_level, int end_level,
                          bool isforward, bool initGL, bool initGLEW, int startx, int starty, int endx, int endy)
{