OpenGL Color update problem

Color update problem

Hi,
I am new with OpenGL, and trying to build a Windows application that displays, modifies, and re-displays (as the image gets modified) a grayscale image (in PGM format). Upto now, I could load/display an image, and also could modify it, eg, say, drawing a circle in it (I checked where I saved the modified image to verify that the modification actually worked). After the modification, the circle should appear in 'white' as I drew it in the maximum grayscale intensity. But the problem is, it is appearing in 'black', instead of white. Any suggestion how to resolve this?
Actually I am re-using someone's code, so just making my best guess that the following fragment might be relevant to the problem:
Thanks!

Code:

---

// In main.cpp:

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){
    UINT idb;
    int iMarker, incdecflag;
    switch(msg){
        case WM_CLOSE:     
            DestroyWindow(hwnd);
            break;
        case WM_COMMAND:   
            switch(LOWORD(wParam)){
                case ID_CT_LOAD:
                    cw_LoadCT(hwnd);
                    if(cw_GlobalVar_ptr_CurrentCT != NULL){
                        cw_MarkerBoundaries_Initialize(&cw_GlobalVar_MarkerBoundaries, cw_GlobalVar_ptr_CurrentCT, 8);
                        cw_ThresholdInitialize(cw_GlobalVar_ptr_CurrentCT, &cw_GlobalVar_Threshhold, 8);
                    }
                    PostMessage(hwnd, WM_PAINT, 0, 0);
                    break;
                                case ID_CT_COMPUTE:                // This is the menu function that updates/ modifies my image, and I need to see the update once this is done.
                    if(cw_GlobalVar_ptr_CurrentCT != NULL){
                                                cw_ComputeCT(hwnd, cw_GlobalVar_ptr_CurrentCT);
                    }
                                        PostMessage(hwnd, WM_PAINT, 0, 0);       
                                        break;
...
...
case WM_PAINT:
                { 
                                        PAINTSTRUCT ps;
                    cw_Display();
                    BeginPaint( hwnd, &ps );
                    EndPaint( hwnd, &ps );
                }
            break;
      default:
            return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}

void EnableOpenGL(HWND hWnd, HDC * hDC, HGLRC * hRC)
{
        PIXELFORMATDESCRIPTOR pfd;
        int format;
       
        // get the device context (DC)
        *hDC = GetDC( hWnd );

        // set the pixel format for the DC
        ZeroMemory( &pfd, sizeof( pfd ) );
        pfd.nSize = sizeof( pfd );
        pfd.nVersion = 1;
        pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
        pfd.iPixelType = PFD_TYPE_RGBA;
        pfd.cColorBits = 24;
        pfd.cDepthBits = 16;
        pfd.iLayerType = PFD_MAIN_PLANE;
        format = ChoosePixelFormat( *hDC, &pfd );
        SetPixelFormat( *hDC, format, &pfd );

        // create and enable the render context (RC)
        *hRC = wglCreateContext( *hDC );
        wglMakeCurrent( *hDC, *hRC );
    glClearColor(0.875,0.875,0.875,1.0);
    glClear(GL_COLOR_BUFFER_BIT);
    SwapBuffers( hDCMain );
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow){
    WNDCLASSEX wc;
    HWND hwnd;
    MSG Msg;
    int quit = 0;
   
    //Step 1: Registering the Window Class
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style        = CS_OWNDC;
    wc.lpfnWndProc  = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance    = hInstance;
    wc.hIcon        = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor      = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszMenuName  = MAKEINTRESOURCE(IDR_MENU1);
    wc.lpszClassName = g_szClassName;
    wc.hIconSm      = LoadIcon(NULL, IDI_APPLICATION);

    if(!RegisterClassEx(&wc)){
        MessageBox(NULL, "Window Registration Failed!", "Error!",
            MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    // Step 2: Creating the Window
    hwnd = CreateWindowEx(
        WS_EX_OVERLAPPEDWINDOW,
        g_szClassName,
        "Simulator",
        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, hInstance, NULL);

    if(hwnd == NULL){
        MessageBox(NULL, "Window Creation Failed!", "Error!",
            MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    //ClientResize(hwnd, 642, 544);

    hWndMain = hwnd;
    ShowWindow(hwnd, nCmdShow);
    //ShowWindow(hwnd, SW_SHOWMAXIMIZED);
    UpdateWindow(hwnd);

    {
        //Create Push Buttons. First, Previous, Next, Last    -- set the currect slice index
        int iButton;
        HINSTANCE hInstance = (HINSTANCE)GetWindowLong(hwnd, GWL_HINSTANCE);
        for(iButton=0; iButton<4; iButton++){
            hWndPushButton[iButton] = CreateWindowEx(
                0,
                //WS_EX_CLIENTEDGE,
                "BUTTON",
                lpPushButtonName[iButton],
                //WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON |BS_NOTIFY ,
                WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON ,
                420 + iButton*80,
                4,
                70,
                24,
                hwnd,
                (HMENU)idPushButtonID[iButton],
                hInstance,
                NULL);
        }
    }

    if(SetTimer(hwnd, ID_TIMER, 50, NULL) == 0)
        MessageBox(hwnd, "Could not SetTimer()!", "Error", MB_OK | MB_ICONEXCLAMATION);

        // enable OpenGL for the window
        EnableOpenGL( hwnd, &hDCMain, &hRCMain );

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0){
        //SetWindowText(hWndStaticText, "ABCD");
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
   
    DisableOpenGL( hwnd, hDCMain, hRCMain );

#ifndef NDEBUG
    FreeConsole();
#endif

    return Msg.wParam;
}

void ClientResize(HWND hWnd, int nWidth, int nHeight){
    RECT rcClient, rcWindow;
    POINT ptDiff;
    GetClientRect(hWnd, &rcClient);
    GetWindowRect(hWnd, &rcWindow);
    ptDiff.x = (rcWindow.right - rcWindow.left) - rcClient.right;
    ptDiff.y = (rcWindow.bottom - rcWindow.top) - rcClient.bottom;
    MoveWindow(hWnd,rcWindow.left, rcWindow.top, nWidth + ptDiff.x, nHeight + ptDiff.y, TRUE);
}
...
...


// In my drawing-related cpp file:

void cw_drawCT(void)
// Draw CT images in the viewport
{
    if(cw_GlobalVar_ptr_CurrentCT != NULL){
        cw_CT_SLICE *ptr_slice;
        int irow, icol;
        GLubyte *SliceImage;
        ptr_slice = cw_GlobalVar_ptr_CurrentCT->ptr_Arr1D_ptr_CTSlice[cw_GlobalVar_CurrentSliceIndex];
        SliceImage = (GLubyte *)malloc(sizeof(GLubyte)*ptr_slice->nCols*ptr_slice->nRows*3);
        if(SliceImage==NULL){
            MessageBox(hWndMain, "Fail to allocate memory", "Error", MB_OK | MB_ICONEXCLAMATION);
            PostMessage(hWndMain, WM_CLOSE, 0, 0);
            return;
        }

        for(irow=0;irow<ptr_slice->nRows; irow++){
            for(icol=0; icol<ptr_slice->nCols; icol++){
                int grayscale = (ptr_slice->data[irow*ptr_slice->nCols+icol]*256)/ptr_slice->MaxGrayScale;
                SliceImage[(irow*ptr_slice->nCols+icol)*3] = (GLubyte) grayscale;
                SliceImage[(irow*ptr_slice->nCols+icol)*3+1] = (GLubyte) grayscale;
                SliceImage[(irow*ptr_slice->nCols+icol)*3+2] = (GLubyte) grayscale;
            }
        }
        {  //1 : 1 only
            glRasterPos2i(0, cw_GL_ViewPortHeight);
            glPixelZoom(1.0, -1.0);    //OPENGL line draw/scan from bottom to up.
            glDrawPixels(ptr_slice->nCols, ptr_slice->nRows, GL_RGB, GL_UNSIGNED_BYTE, SliceImage);
            glPixelZoom(1.0, 1.0);
        }
        free(SliceImage);
    }
}


void cw_Display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);

    //Setup GL viewport
    if(cw_GlobalVar_ptr_CurrentCT != NULL){
        cw_CT_SLICE *pslice;
        RECT rcClient;

        pslice = cw_GlobalVar_ptr_CurrentCT->ptr_Arr1D_ptr_CTSlice[cw_GlobalVar_CurrentSliceIndex];
        cw_GL_ViewPortOrigin_X = 280;
        cw_GL_ViewPortOrigin_Y = 30 + pslice->nRows;        //in client area coordinates
        cw_GL_ViewPortWidth = pslice->nCols;
        cw_GL_ViewPortHeight = pslice->nRows;

        GetClientRect(hWndMain, &rcClient);
        glViewport(cw_GL_ViewPortOrigin_X, rcClient.bottom - cw_GL_ViewPortOrigin_Y,                    cw_GL_ViewPortWidth, cw_GL_ViewPortHeight);
        //GL viewport has a coordinate system different client area coordinate
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0, (double)cw_GL_ViewPortWidth, 0.0, (double)cw_GL_ViewPortHeight);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glShadeModel(GL_FLAT);
        glPixelStorei(GL_UNPACK_ALIGNMENT,1);
    }

    //draw CT image
    cw_drawCT();
    SwapBuffers( hDCMain );
    return;
}

---