TAPsOpenGLCtrlTransferFn.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLCtrlTransferFn.cpp

Transfer Fn Control via OpenGL

SUKITTI PUNAK   (05/02/2007)
UPDATE          (05/09/2007)
******************************************************************************/
#include "TAPsOpenGLCtrlTransferFn.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
// Constructor(s) and Destructor
//-----------------------------------------------------------------------------
OpenGLCtrlTransferFn::OpenGLCtrlTransferFn ()
    : OpenGLCtrl(), m_RGBA_1DTexture( 0 )
{
    Default();
}
//-----------------------------------------------------------------------------
//OpenGLCtrlTransferFn::OpenGLCtrlTransferFn (
//{
//}
//-----------------------------------------------------------------------------
OpenGLCtrlTransferFn::~OpenGLCtrlTransferFn ()
{
    glDeleteTextures( 1, &m_RGBA_1DTexture );
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Get/Set Function(s)
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::Default ()
{
    SetSize( 256, 256 );
    m_BorderSize = 8;
    m_BackgroundColor[0] = 0.7;
    m_BackgroundColor[1] = 0.7;
    m_BackgroundColor[2] = 0.7;
    m_BackgroundColor[3] = 0.3;
    //
    SetButtons();
    //
    SetDefaultLUT();
    //
    SetHistogramColor( 0.9f, 0.6f, 0.0f, 0.4f );
    //
    GLubyte zero[256];
    for ( int i = 0; i < 256; ++i ) {
        zero[i] = 0;
    }
    LoadFreqsToHistogram( zero );
    SetClickXY( 0, 0 ); // for setting the click dot
                        // but this one make red button's status true
    m_ButtonRed.SetStatus( false ); // so set red button to false 
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::SetStartPos ( int x, int y )
{
    //x = x;
    //m_xyLowerLeftPt[0] = x;
    //m_xyLowerLeftPt[1] = y;
    //
    //int X = m_xyLowerLeftPt[0];
    m_ButtonRed.SetStartPos( x+10, y );
    m_ButtonGreen.SetStartPos( x+70, y );
    m_ButtonBlue.SetStartPos( x+130, y );
    m_ButtonAlpha.SetStartPos( x+190, y );
    //
    y += 30;
    OpenGLCtrl::SetStartPos( x, y );
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::SetButtons ()
{
    //
    m_ButtonRed.SetText( "Red" );
    m_ButtonGreen.SetText( "Green" );
    m_ButtonBlue.SetText( "Blue" );
    m_ButtonAlpha.SetText( "Alpha" );
    //
    m_ButtonRed.SetBackgroundActColor( 1, 0, 0, 0.8 );
    m_ButtonGreen.SetBackgroundActColor( 0, 1, 0, 0.7 );
    m_ButtonBlue.SetBackgroundActColor( 0.1, 0.1, 1, 0.9 );
    m_ButtonAlpha.SetBackgroundActColor( 1, 1, 1, 0.7 );
    //
    m_ButtonRed.SetForegroundActColor( 0.1, 0, 0, 0.7 );
    m_ButtonGreen.SetForegroundActColor( 0, 0.1, 0, 0.7 );
    m_ButtonBlue.SetForegroundActColor( 0.8, 0.8, 1, 0.7 );
    m_ButtonAlpha.SetForegroundActColor( 0, 0, 0, 0.7 );
    //
    m_ButtonRed.SetBackgroundColor( 0.15, 0, 0, 0.7 );
    m_ButtonGreen.SetBackgroundColor( 0, 0.1, 0, 0.7 );
    m_ButtonBlue.SetBackgroundColor( 0, 0, 0.3, 0.7 );
    m_ButtonAlpha.SetBackgroundColor( 0, 0, 0, 0.7 );
    //
    m_ButtonRed.SetForegroundColor( 1, 0, 0, 0.7 );
    m_ButtonGreen.SetForegroundColor( 0, 0.7, 0, 0.7 );
    m_ButtonBlue.SetForegroundColor( 0, 0, 1, 0.7 );
    m_ButtonAlpha.SetForegroundColor( 0.6, 0.6, 0.6, 0.7 );
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::SetDefaultLUT ()
{
    for ( int i = 0; i < 256; ++i ) {
        m_RGBA[i][0] = m_RGBA[i][1] = m_RGBA[i][2] = m_RGBA[i][3] = i;
    }
    if ( m_RGBA_1DTexture != 0 ) {
        glDeleteTextures( 1, &m_RGBA_1DTexture );
    }
    {
        //glEnable( GL_TEXTURE_1D );
        glGenTextures( 1, &m_RGBA_1DTexture );
        glBindTexture( GL_TEXTURE_1D, m_RGBA_1DTexture );
        glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP );
        glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
        glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
        glTexImage1D( GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, 
            GL_UNSIGNED_BYTE, m_RGBA );
        glBindTexture( GL_TEXTURE_1D, 0 );
    }
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::SetLUTToRampFn ()
{
    for ( int i = 0; i < 256; ++i ) {
        m_RGBA[i][0] = m_RGBA[i][1] = m_RGBA[i][2] = m_RGBA[i][3] = i;
    }
    UpdateRGBA();
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::SetLUTToRandomFn ()
{
    srand ( time(NULL) );
    for ( int i = 0; i < 256; ++i ) {
        m_RGBA[i][0] = rand() % 256;
        m_RGBA[i][1] = rand() % 256;
        m_RGBA[i][2] = rand() % 256;
        m_RGBA[i][3] = rand() % 256;
    }
    UpdateRGBA();
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::SetOpacity ( float alpha )
{
    OpenGLCtrl::SetOpacity( alpha );
    m_ButtonRed.SetOpacity( alpha );
    m_ButtonGreen.SetOpacity( alpha );
    m_ButtonBlue.SetOpacity( alpha );
    m_ButtonAlpha.SetOpacity( alpha );
}
//-----------------------------------------------------------------------------
bool OpenGLCtrlTransferFn::IsInside ( int x, int y )
{
    return 
         m_xyLowerLeftPt[0]-m_BorderSize <= x && x <= m_xyLowerLeftPt[0]+m_DrawSizeXY[0]+m_BorderSize
      && m_xyLowerLeftPt[1]-m_BorderSize <= y && y <= m_xyLowerLeftPt[1]+m_DrawSizeXY[1]+m_BorderSize;
}
//-----------------------------------------------------------------------------
bool OpenGLCtrlTransferFn::IsInsidePlusBorder ( int x, int y )
{
    return 
         m_xyLowerLeftPt[0]-m_BorderSize <= x && x <= m_xyLowerLeftPt[0]+m_DrawSizeXY[0]+m_BorderSize
      && m_xyLowerLeftPt[1]-m_BorderSize-30 <= y && y <= m_xyLowerLeftPt[1]+m_DrawSizeXY[1]+m_BorderSize;
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::UpdateRGBA ()
{
    //===============================================================
    // Write Transfer Function Look Up Table (Texture) to GPU
    //---------------------------------------------------------------
    glBindBuffer( GL_PIXEL_UNPACK_BUFFER, 0 );
    glBindTexture( GL_TEXTURE_1D, m_RGBA_1DTexture );
    //-------------------------------------------
    glTexImage1D( GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, 
        GL_UNSIGNED_BYTE, m_RGBA );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //-------------------------------------------
    glBindTexture( GL_TEXTURE_1D, 0 );
    //---------------------------------------------------------------
    //===============================================================
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCtrlTransferFn::LoadDataFrom ( T data[256*4], bool isDataNormalized )
{
    //-- Data is normalized [0.0,1.0]
    if ( isDataNormalized ) {
        int idx = 0;
        for( i = 0; i < 256; ++i ) {
            m_RGBA[idx] = (GLubyte) ( data[idx++] * 255 );
            m_RGBA[idx] = (GLubyte) ( data[idx++] * 255 );
            m_RGBA[idx] = (GLubyte) ( data[idx++] * 255 );
            m_RGBA[idx] = (GLubyte) ( data[idx++] * 255 );
        }
    }
    //-- Data is unnormalized [0,255]
    else {
        int idx = 0;
        for( i = 0; i < 256; ++i ) {
            m_RGBA[idx] = data[idx++];
            m_RGBA[idx] = data[idx++];
            m_RGBA[idx] = data[idx++];
            m_RGBA[idx] = data[idx++];
        }
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCtrlTransferFn::LoadFreqsToHistogram ( T freqs[256] )
{
    // Find max frequency and total frequencies
    int i = 0;
    m_Histogram.totalFreqs  =
    m_Histogram.maxFreq     = freqs[i];
    for ( i = 1; i < 256; ++i ) {
        m_Histogram.totalFreqs += freqs[i];
        if ( static_cast<unsigned long int>( freqs[i] ) > m_Histogram.maxFreq ) {
            m_Histogram.maxFreq = freqs[i];
        }
    }
    // Record normalized frequencies
    double normalizationFactor = (double) m_Histogram.maxFreq / 255.0;
    if ( normalizationFactor > 0 ) {
        for( i = 0; i < 256; ++i ) {
            m_Histogram.normalizedFreqs[i] = 
                static_cast<GLubyte>( (double) freqs[i] / normalizationFactor );
            //std::cout << i << ":\t" << (int)m_Histogram.normalizedFreqs[i] << "\t--> " << freqs[i] << "\n";
        }
        //std::cout << "normalizationFactor: " << normalizationFactor << "\n";
    }
    else {
        for( i = 0; i < 256; ++i ) {
            m_Histogram.normalizedFreqs[i] = 0.0;
            //std::cout << "i:\t" << (int)m_Histogram.normalizedFreqs[i] << "\t--> " << freqs[i] << "\n";
        }
    }
    //std::cout << "Max Freq: " << m_Histogram.maxFreq << "\n";
    //std::cout << "Tot Freq: " << m_Histogram.totalFreqs << "\n";
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::GetHistogramColor ( 
    float & r, float & g, float & b, float & a ) const
{
    r = m_Histogram.histogramColor[0];
    g = m_Histogram.histogramColor[1];
    b = m_Histogram.histogramColor[2];
    a = m_Histogram.histogramColor[3];
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::SetHistogramColor ( 
    float r, float g, float b, float a )
{
    m_Histogram.histogramColor[0] = r;
    m_Histogram.histogramColor[1] = g;
    m_Histogram.histogramColor[2] = b;
    m_Histogram.histogramColor[3] = a;
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Operation(s)
//-----------------------------------------------------------------------------
bool OpenGLCtrlTransferFn::SetClickXY ( int x, int y )
{
    //
    if ( !IsInsidePlusBorder( x, y ) )  return false;
    //
    // Check Button Click
    if ( GetRedButton().IsInside( x, y ) ) {
        GetRedButton().ToggleStatus();
        return true;
    }
    if ( GetGreenButton().IsInside( x, y ) ) {
        GetGreenButton().ToggleStatus();
        return true;
    }
    if ( GetBlueButton().IsInside( x, y ) ) {
        GetBlueButton().ToggleStatus();
        return true;
    }
    if ( GetAlphaButton().IsInside( x, y ) ) {
        GetAlphaButton().ToggleStatus();
        return true;
    }
    //
    x -= m_xyLowerLeftPt[0];
    y -= m_xyLowerLeftPt[1];
    //
    if      ( x <   0 ) x =   0;
    else if ( x > 255 ) x = 255;
    if      ( y <   0 ) y =   0;
    else if ( y > 255 ) y = 255;
    //
    m_clickX = m_old_x = x;
    m_clickY = m_old_y = y;
    //
    return true;
}
//-----------------------------------------------------------------------------
bool OpenGLCtrlTransferFn::ChangeLUTValues ( int x, int y )
{
    //
    if ( !IsInside( x, y ) )    return false;
    //
    x -= m_xyLowerLeftPt[0];
    y -= m_xyLowerLeftPt[1];
    //
    if      ( x <   0 ) x =   0;
    else if ( x > 255 ) x = 255;
    if      (   0 > y ) y =   0;
    else if ( 255 < y ) y = 255;
    //
    // Forward Changing
    if ( x >= m_old_x+1 ) {
        float yStep = (float)( y - m_old_y ) / (float)( x - m_old_x );
        float yVal = m_old_y;
        for ( int i = m_old_x; i <= x; ++i ) {
            if ( m_ButtonRed.GetStatus() ) {
                m_RGBA[i][0] = (unsigned int)yVal;
            }
            if ( m_ButtonGreen.GetStatus() ) {
                m_RGBA[i][1] = (unsigned int)yVal;
            }
            if ( m_ButtonBlue.GetStatus() ) {
                m_RGBA[i][2] = (unsigned int)yVal;
            }
            if ( m_ButtonAlpha.GetStatus() ) {
                m_RGBA[i][3] = (unsigned int)yVal;
            }
            yVal += yStep;
        }
    }
    //
    // Backward Changing
    else {
        float yStep = (float)( m_old_y - y ) / (float)( x - m_old_x );
        float yVal = m_old_y;
        for ( int i = m_old_x; i >= x; --i ) {
            if ( m_ButtonRed.GetStatus() ) {
                m_RGBA[i][0] = (unsigned int)yVal;
            }
            if ( m_ButtonGreen.GetStatus() ) {
                m_RGBA[i][1] = (unsigned int)yVal;
            }
            if ( m_ButtonBlue.GetStatus() ) {
                m_RGBA[i][2] = (unsigned int)yVal;
            }
            if ( m_ButtonAlpha.GetStatus() ) {
                m_RGBA[i][3] = (unsigned int)yVal;
            }
            yVal += yStep;
        }
    }
    //
    m_old_x = x;
    m_old_y = y;
    UpdateRGBA();
    //
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================


//=============================================================================
// Draw Function(s)
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::Draw ()
{
    DrawBackgroundScale();
    DrawHistogram ();
    DrawIntensities();
    DrawColors();
    m_ButtonRed.Draw();
    m_ButtonGreen.Draw();
    m_ButtonBlue.Draw();
    m_ButtonAlpha.Draw();
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::DrawHistogram ()
{
    GLfloat xStep = (m_DrawSizeXY[0]-1) / 255.0;
    GLfloat yStep = (m_DrawSizeXY[1]-1) / 255.0;
    //
    // Histogram
    GLfloat X = m_xyLowerLeftPt[0];
    glColor4fv( m_Histogram.histogramColor );
    glLineWidth( 1 );
    glBegin( GL_LINES );
    for ( int i = 0; i < 256; ++i ) {
        glVertex2i( X, m_xyLowerLeftPt[1] );
        glVertex2i( X, m_xyLowerLeftPt[1] + m_Histogram.normalizedFreqs[i]*yStep );
        X += xStep;
    }
    glEnd();
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::DrawColors ()
{
    glEnable( GL_TEXTURE_1D );
    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
    //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
    glBindTexture( GL_TEXTURE_1D, m_RGBA_1DTexture );
    glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP );
    glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    //-------------------------------------------
    int startX = m_xyLowerLeftPt[0];
    int endX   = startX + m_DrawSizeXY[0];
    int startY = m_xyLowerLeftPt[1] + m_DrawSizeXY[1] + m_BorderSize;
    int w, h;
    m_ButtonRed.GetSize( w, h );
    int endY   = startY + h;
    glDisable( GL_TEXTURE_1D );
    glBegin( GL_QUADS );
        int midY = ( endY + startY ) / 2;
        glColor4f( 0, 0, 0, 1 );
        glVertex2i( startX, midY );
        glVertex2i( startX, startY );
        glVertex2i( endX, startY );
        glVertex2i( endX, midY );
        //
        glColor4f( 1, 1, 1, 1 );
        glVertex2i( startX, endY );
        glVertex2i( startX, midY );
        glVertex2i( endX, midY );
        glVertex2i( endX, endY );
    glEnd();
    //
    glEnable( GL_TEXTURE_1D );
    glBegin( GL_QUADS );
        glTexCoord1i( 0 );
        glVertex2i( startX, endY );
        glVertex2i( startX, startY );
        glTexCoord1i( 1 );
        glVertex2i( endX, startY );
        glVertex2i( endX, endY );
    glEnd();
    //-------------------------------------------
    glBindTexture( GL_TEXTURE_1D, 0 );
    glDisable( GL_TEXTURE_1D );
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::DrawIntensities ()
{
    //glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
    //glBindTexture( GL_TEXTURE_1D, m_RGBA_1DTexture );
    //glGetTexImage( 
    //  GL_TEXTURE_1D,
    //  0,
    //  GL_RGBA,
    //  GL_UNSIGNED_BYTE,
    //  m_RGBA
    //);
    //TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //glBindTexture( GL_TEXTURE_1D, 0 );

    //===============================================================
    // Draw Mark Point
    //---------------------------------------------------------------
    glPointSize( 5 );
    glColor4f( 0.5, 0.5, 0.0, 0.7 );
    glBegin( GL_POINTS );
        glVertex2i( m_clickX + m_xyLowerLeftPt[0], m_clickY + m_xyLowerLeftPt[1] );
    glEnd();
    //---------------------------------------------------------------
    //===============================================================

    //===============================================================
    // Draw RGBA Lines
    //---------------------------------------------------------------
    GLfloat xStep = (m_DrawSizeXY[0]-1) / 255.0;
    GLfloat yStep = (m_DrawSizeXY[1]-1) / 255.0;
    //
    //
    // Red
    GLfloat X = m_xyLowerLeftPt[0];
    glColor4f( 1, 0, 0, 0.8 );
    if ( m_ButtonRed.GetStatus() )  glLineWidth( 3 );
    else                            glLineWidth( 1 );
    glBegin( GL_LINE_STRIP );
    for ( int i = 0; i < 256; ++i ) {
        glVertex2i( X, m_xyLowerLeftPt[1] + m_RGBA[i][0]*yStep + 2 );
        X += xStep;
    }
    glEnd();
    //
    // Green
    X = m_xyLowerLeftPt[0];
    glColor4f( 0, 1, 0, 0.7 );
    if ( m_ButtonGreen.GetStatus() )    glLineWidth( 3 );
    else                                glLineWidth( 1 );
    glBegin( GL_LINE_STRIP );
    for ( int i = 0; i < 256; ++i ) {
        glVertex2f( X, m_xyLowerLeftPt[1] + m_RGBA[i][1]*yStep + 1 );
        X += xStep;
    }
    glEnd();
    //
    // Blue
    X = m_xyLowerLeftPt[0];
    glColor4f( 0, 0, 1, 0.9 );
    if ( m_ButtonBlue.GetStatus() ) glLineWidth( 3 );
    else                            glLineWidth( 1 );
    glBegin( GL_LINE_STRIP );
    for ( int i = 0; i < 256; ++i ) {
        glVertex2f( X, m_xyLowerLeftPt[1] + m_RGBA[i][2]*yStep );
        X += xStep;
    }
    glEnd();
    //
    // Alpha
    X = m_xyLowerLeftPt[0];
    glColor4f( 0.25, 0.25, 0.25, 0.9 );
    if ( m_ButtonAlpha.GetStatus() )    glLineWidth( 3 );
    else                                glLineWidth( 1 );
    glBegin( GL_LINE_STRIP );
    for ( int i = 0; i < 256; ++i ) {
        glVertex2f( X, m_xyLowerLeftPt[1] + m_RGBA[i][3]*yStep - 1 );
        X += xStep;
    }
    glEnd();
    //---------------------------------------------------------------
    //===============================================================
}
//-----------------------------------------------------------------------------
void OpenGLCtrlTransferFn::DrawBackgroundScale ()
{
    DrawBackgroundAndBorder();
    //-----------------------------------------------------
    // Draw Big Scale Ticks
    {
        float stepX = (m_DrawSizeXY[0]) / 36.0;
        float stepY = (m_DrawSizeXY[1]) / 36.0;
        float startX = m_xyLowerLeftPt[0];
        float startY = m_xyLowerLeftPt[1];
        // Long Tick Length
        float endX0   = m_xyLowerLeftPt[0] + m_DrawSizeXY[0];
        float endY0   = m_xyLowerLeftPt[1] + m_DrawSizeXY[1];
        // Middle Tick Length
        float midTickLenX = m_DrawSizeXY[0]/28.0;
        float midTickLenY = m_DrawSizeXY[0]/28.0;
        float endX1   = m_xyLowerLeftPt[0] + midTickLenX;
        float endY1   = m_xyLowerLeftPt[1] + midTickLenY;
        float strX1   = endX0 - midTickLenX;
        float strY1   = endY0 - midTickLenY;
        // Short Tick Length
        float shortTickLenX = m_DrawSizeXY[0]/52.0;
        float shortTickLenY = m_DrawSizeXY[0]/52.0;
        float endX2   = m_xyLowerLeftPt[0] + shortTickLenX;
        float endY2   = m_xyLowerLeftPt[1] + shortTickLenY;
        float strX2   = endX0 - shortTickLenX;
        float strY2   = endY0 - shortTickLenY;
        glBegin( GL_LINES );
        //
        glColor4f( 0, 0, 0, m_BackgroundColor[3] );
        for ( int i = 0; i < 9; ++i ) {
            //
            // Vertical Long Tick
            glVertex2f( startX, m_xyLowerLeftPt[1] );
            glVertex2f( startX, endY0 );
            startX += stepX;
            // Vertical Short Tick
            glVertex2f( startX, m_xyLowerLeftPt[1] );
            glVertex2f( startX, endY2 );
            // Vertical Short Tick
            glVertex2f( startX, strY2 );
            glVertex2f( startX, endY0 );
            startX += stepX;
            // Vertical Middle Tick
            glVertex2f( startX, m_xyLowerLeftPt[1] );
            glVertex2f( startX, endY1 );
            // Vertical Middle Tick
            glVertex2f( startX, strY1 );
            glVertex2f( startX, endY0 );
            startX += stepX;
            // Vertical Short Tick
            glVertex2f( startX, m_xyLowerLeftPt[1] );
            glVertex2f( startX, endY2 );
            // Vertical Short Tick
            glVertex2f( startX, strY2 );
            glVertex2f( startX, endY0 );
            startX += stepX;
            //
            // Horizontal Long Tick
            glVertex2f( m_xyLowerLeftPt[0], startY );
            glVertex2f( endX0, startY );
            startY += stepY;
            // Horizontal Short Tick
            glVertex2f( m_xyLowerLeftPt[0], startY );
            glVertex2f( endX2, startY );
            // Horizontal Short Tick
            glVertex2f( strX2, startY );
            glVertex2f( endX0, startY );
            startY += stepY;
            // Horizontal Middle Tick
            glVertex2f( m_xyLowerLeftPt[0], startY );
            glVertex2f( endX1, startY );
            // Horizontal Middle Tick
            glVertex2f( strX1, startY );
            glVertex2f( endX0, startY );
            startY += stepY;
            // Horizontal Short Tick
            glVertex2f( m_xyLowerLeftPt[0], startY );
            glVertex2f( endX2, startY );
            // Horizontal Short Tick
            glVertex2f( strX2, startY );
            glVertex2f( endX0, startY );
            startY += stepY;
            //
        }
        // Vertical Long Tick
        glVertex2f( startX, m_xyLowerLeftPt[1] );
        glVertex2f( startX, endY0 );
        // Horizontal Long Tick
        glVertex2f( m_xyLowerLeftPt[0], startY );
        glVertex2f( endX0, startY );
        //
        glEnd();
    }
}
//-----------------------------------------------------------------------------
//=============================================================================

//*
//=============================================================================
// Copy to/from 1D texture
//-----------------------------------------------------------------------------
bool OpenGLCtrlTransferFn::CopyTo1DTexture ( 
    GLuint to1DTex, bool isDataNormalized ) const
{
    //---------------------------------------------------------------
    // DEBUG: Check texture compatability
#ifdef TAPs_DEBUG_MODE
    //glGetTexLevelParameteriv( GL_TEXTURE_1D, ...
    // if ... return false
#endif
    if ( to1DTex == NULL )  return false;
    //===============================================================
    // Write Transfer Function Look Up Table (Texture) to GPU
    //---------------------------------------------------------------
    // Normalized Data
    if ( isDataNormalized ) {
        GLfloat dataRGBA[256][4];
        for ( int i = 0; i < 256; ++i ) {
            dataRGBA[i][0] = (GLfloat) ( m_RGBA[i][0] / 255.0f );
            dataRGBA[i][1] = (GLfloat) ( m_RGBA[i][1] / 255.0f );
            dataRGBA[i][2] = (GLfloat) ( m_RGBA[i][2] / 255.0f );
            dataRGBA[i][3] = (GLfloat) ( m_RGBA[i][3] / 255.0f );
        }
        //-------------------------------------------
        glBindBuffer( GL_PIXEL_UNPACK_BUFFER, 0 );
        glBindTexture( GL_TEXTURE_1D, to1DTex );
        //-------------------------------------------
        glTexImage1D( GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, 
            GL_FLOAT, dataRGBA );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //-------------------------------------------
        glBindTexture( GL_TEXTURE_1D, 0 );
    }
    //---------------------------------------------------------------
    // Unnormalized Data
    else {
        glBindBuffer( GL_PIXEL_UNPACK_BUFFER, 0 );
        glBindTexture( GL_TEXTURE_1D, to1DTex );
        //-------------------------------------------
        glTexImage1D( GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, 
            GL_UNSIGNED_BYTE, m_RGBA );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //-------------------------------------------
        glBindTexture( GL_TEXTURE_1D, 0 );
    }
    //---------------------------------------------------------------
    //===============================================================
    /*
    // DEBUG
    for ( int i = 0; i < 6; ++i ) {
        std::cout << i << ": " 
            << (int)m_RGBA[i][0] << " " 
            << (int)m_RGBA[i][1] << " " 
            << (int)m_RGBA[i][2] << " " 
            << (int)m_RGBA[i][3] << "\n";
    }
    std::cout << "-----\n";
    for ( int i = 250; i < 256; ++i ) {
        std::cout << i << ": " 
            << (int)m_RGBA[i][0] << " " 
            << (int)m_RGBA[i][1] << " " 
            << (int)m_RGBA[i][2] << " " 
            << (int)m_RGBA[i][3] << "\n";
    }
    //*/
    //---------------------------------------------------------------
    return true;
}
//-----------------------------------------------------------------------------
bool OpenGLCtrlTransferFn::CopyFrom1DTexture ( 
    GLuint from1DTex, bool isDataNormalized )
{
    //---------------------------------------------------------------
    // DEBUG: Check texture compatability
#ifdef TAPs_DEBUG_MODE
    //glGetTexLevelParameteriv( GL_TEXTURE_1D, ...
    // if ... return false
#endif
    if ( from1DTex == NULL )    return false;
    //===============================================================
    // Read Transfer Function Look Up Table (Texture) from GPU
    //---------------------------------------------------------------
    // Normalized Data
    if ( isDataNormalized ) {
        GLfloat dataRGBA[256][4];
        //-------------------------------------------
        glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        glBindTexture( GL_TEXTURE_1D, from1DTex );
        //---------------------------------------
        glGetTexImage( 
            GL_TEXTURE_1D,
            0,
            GL_RGBA,
            GL_FLOAT,
            dataRGBA
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //---------------------------------------
        glBindTexture( GL_TEXTURE_1D, 0 );
        //---------------------------------------
        for ( int i = 0; i < 256; ++i ) {
            m_RGBA[i][0] = (GLubyte) ( dataRGBA[i][0] * 255 );
            m_RGBA[i][1] = (GLubyte) ( dataRGBA[i][1] * 255 );
            m_RGBA[i][2] = (GLubyte) ( dataRGBA[i][2] * 255 );
            m_RGBA[i][3] = (GLubyte) ( dataRGBA[i][3] * 255 );
        }
    }
    //---------------------------------------------------------------
    // Unnormalized Data
    else {
        glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        glBindTexture( GL_TEXTURE_1D, from1DTex );
        //---------------------------------------
        glGetTexImage( 
            GL_TEXTURE_1D,
            0,
            GL_RGBA,
            GL_UNSIGNED_BYTE,
            m_RGBA
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //---------------------------------------
        glBindTexture( GL_TEXTURE_1D, 0 );
    }
    //---------------------------------------------------------------
    //===============================================================
    UpdateRGBA();
    //---------------------------------------------------------------
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
//*/

//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----