C:/Users/thebigMuh/Documents/Visual Studio 2005/Projects/Volumizer/Volumizer/HistogramWnd.cpp

Go to the documentation of this file.

#include "Volumizer.h"

HGLRC   historc;        
HDC             histodc;        

histo_handle    *tf;    

ATOM RegisterHistogramClass(HINSTANCE hInstance 
                                                        )
{
        WNDCLASSEX wcex;

        wcex.cbSize = sizeof(WNDCLASSEX);

        wcex.style                      = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc        = HistogramProc;
        wcex.cbClsExtra         = 0;
        wcex.cbWndExtra         = 0;
        wcex.hInstance          = hInstance;
        wcex.hIcon                      = NULL;
        wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
        wcex.hbrBackground      = NULL; 
        wcex.lpszMenuName       = NULL;
        wcex.lpszClassName      = L"HistogramWnd";
        wcex.hIconSm            = NULL;

        return RegisterClassEx(&wcex);
}

void InitHistogramWnd(HWND hWnd)
{
        histodc = GetDC(hWnd);

        PIXELFORMATDESCRIPTOR pfd = { 
    sizeof(PIXELFORMATDESCRIPTOR),    
    1,                                
    PFD_DRAW_TO_WINDOW |              
    PFD_SUPPORT_OPENGL |              
    PFD_DOUBLEBUFFER,                 
    PFD_TYPE_RGBA,                    
    32,                               
    0, 0, 0, 0, 0, 0,                 
    0,                                
    0,                                
    0,                                
    0, 0, 0, 0,                       
    32,                               
    0,                                
    0,                                
    PFD_MAIN_PLANE,                   
    0,                                
    0, 0, 0                           
        }; 
        
        int  iPixelFormat; 

        iPixelFormat = ChoosePixelFormat(histodc, &pfd); 
 
        SetPixelFormat(histodc, iPixelFormat, &pfd); 

    if (historc = wglCreateContext( histodc ) ) 
        { 
        wglMakeCurrent(histodc, historc) ; 
    } 


        glDisable(GL_DEPTH_TEST);
        glEnable(GL_POINT_SMOOTH);
        glEnable(GL_LINE_SMOOTH);
        glEnable(GL_TEXTURE_2D);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
        glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

        glClearColor(0.44f,0.44f,0.44f,0.0f);

        
        HFONT neuro;

        neuro = CreateFontW(0, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_TT_ONLY_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_DONTCARE, L"Arial");

        SelectObject(histodc, neuro);

        wglUseFontOutlines(histodc, 0, 255, 1000, 0.0f, 0.0f,  
                WGL_FONT_LINES, NULL); 
}

void DeInitHistogramWnd(HWND hWnd)
{
    if(historc = wglGetCurrentContext()) 
        { 
        histodc = wglGetCurrentDC() ; 
 
        wglMakeCurrent(NULL, NULL) ; 
 
        ReleaseDC(hWnd, histodc) ; 
 
        wglDeleteContext(historc); 
    } 
}

void CalcHistogram()
{
        float classes[HISTOGRAM_SIZE];  
        float maxclass = 0;                             

        memset(classes, 0, sizeof(int)*HISTOGRAM_SIZE);

        if (voldat)     
        {
                int i = 0;

                for (unsigned int x = 0; x < volx; x++)
                {
                        for (unsigned int y = 0; y < voly; y++)
                        {
                                for (unsigned int z = 0; z < volz; z++)
                                {

                                        classes[(int)(voldat[i] * HISTOGRAM_SIZE)] += 1.0f;

                                        if (classes[(int)(voldat[i] * HISTOGRAM_SIZE)] > maxclass)
                                                maxclass = classes[(int)(voldat[i] / HISTOGRAM_SIZE)];

                                        i++;
                                }
                        }
                }

                for (i = 0; i < HISTOGRAM_SIZE; i++)
                {
                        classes[i] = (float)log((float)classes[i]);
                }

                maxclass = (float)log((float)maxclass);

                wglMakeCurrent(histodc, historc);

                float *histotex = new float[HISTOGRAM_SIZE*256];

                memset(histotex, 0, sizeof(float)*HISTOGRAM_SIZE*256);

                for (int x = 0; x < HISTOGRAM_SIZE; x++)
                {
                        for (int y = 0; y < 256; y++)
                        {
                                if (y < classes[x] * 256 / maxclass)
                                        histotex[y * HISTOGRAM_SIZE + x] = 1.0f;
                                else
                                        histotex[y * HISTOGRAM_SIZE + x] = 0.2f;
                        }
                }

                glBindTexture(GL_TEXTURE_2D, 1);

                glTexImage2D(GL_TEXTURE_2D,
                        0,
                        GL_LUMINANCE,
                        HISTOGRAM_SIZE,
                        256,
                        0,
                        GL_LUMINANCE,
                        GL_FLOAT,
                        histotex);

                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering

                delete [] histotex;
        }
}

void _drawBox(float x_pos,              
                          float y_pos,          
                          float delta           
                          )
{
        glLineWidth(1.5f);

        glBegin(GL_QUADS);
                glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
                glVertex2f(x_pos - delta, y_pos - delta); 
                glVertex2f(x_pos - delta, y_pos + delta); 
                glVertex2f(x_pos + delta, y_pos + delta); 
                glVertex2f(x_pos + delta, y_pos - delta);               
        glEnd();

        glBegin(GL_LINES);
                glColor3f(1.0f, 1.0f, 1.0f);
                glVertex2f(x_pos - delta, y_pos - delta); glVertex2f(x_pos - delta, y_pos + delta);
                glVertex2f(x_pos - delta, y_pos + delta); glVertex2f(x_pos + delta, y_pos + delta);
                glVertex2f(x_pos + delta, y_pos + delta); glVertex2f(x_pos + delta, y_pos - delta);
                glVertex2f(x_pos + delta, y_pos - delta); glVertex2f(x_pos - delta, y_pos - delta);
        glEnd();
}

void DrawHistogram(HWND hWnd)
{
        wglMakeCurrent(histodc, historc);

        RECT clientRect;
        GetClientRect(hWnd, &clientRect);

        glViewport(0, 0, clientRect.right, clientRect.bottom);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        float windowaspect = (float)clientRect.right / (float)clientRect.bottom;

        gluOrtho2D(0.0f, windowaspect, 0.0f, 1.0f);

        glMatrixMode(GL_MODELVIEW);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glEnable(GL_TEXTURE_2D);

        glBindTexture(GL_TEXTURE_2D, 1);

        glBegin(GL_QUADS);

                glColor3f(0.80f, 0.8f, 0.8f);
                glTexCoord2f(1.0f, 1.0f); glVertex2f(windowaspect, 1.0f);

                glColor3f(0.4f, 0.4f, 0.4f);
                glTexCoord2f(1.0f, 0.0f); glVertex2f(windowaspect, 0.0f);
                glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f);

                glColor3f(0.8f, 0.8f, 0.8f);
                glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 1.0f);

        glEnd();

        glDisable(GL_TEXTURE_2D);


        histo_handle *cur = tf;

        while (cur)
        {
                if (cur->next)
                {
                        glBegin(GL_QUADS);
                                glColor4f(cur->col_diffuse[0], cur->col_diffuse[1], cur->col_diffuse[2], 0.5f);
                                glVertex2f(cur->in_val * windowaspect, 0.0f);
                                glVertex2f(cur->in_val * windowaspect, cur->out_alpha);

                                glColor4f(cur->next->col_diffuse[0], cur->next->col_diffuse[1], cur->next->col_diffuse[2], 0.5f);
                                glVertex2f(cur->next->in_val * windowaspect, cur->next->out_alpha);
                                glVertex2f(cur->next->in_val * windowaspect, 0.0f);
                        glEnd();

                        glLineWidth(2.5f);
                        glBegin(GL_LINES);
                                glColor3f(1.0f, 1.0f, 1.0f);

                                glVertex2f(cur->in_val * windowaspect, cur->out_alpha);
                                glVertex2f(cur->next->in_val * windowaspect, cur->next->out_alpha);
                        glEnd();

                        glLineWidth(1.0f);
                        glBegin(GL_LINES);
                                glColor3f(0.0f, 0.0f, 0.0f);

                                glVertex2f(cur->in_val * windowaspect, cur->out_alpha);
                                glVertex2f(cur->next->in_val * windowaspect, cur->next->out_alpha);
                        glEnd();
                }

                _drawBox(cur->in_val * windowaspect, cur->out_alpha, HANDLE_SIZE);

                cur = cur->next;
        }

        glFinish();

        SwapBuffers(histodc);
}

void CreateDefaultHandle(histo_handle &handle   
                                                 )
{
        handle.prev = NULL;
        handle.next = NULL;

        handle.col_ambient[0] = 0.1f;
        handle.col_ambient[1] = 0.1f;
        handle.col_ambient[2] = 0.1f;

        handle.col_diffuse[0] = 0.5f;
        handle.col_diffuse[1] = 0.5f;
        handle.col_diffuse[2] = 0.5f;

        handle.col_specular[0] = 0.8f;
        handle.col_specular[1] = 0.8f;
        handle.col_specular[2] = 0.8f;

        handle.spec_exponent = 0.1f;

        handle.gradient = 0.0f;
}

void CreateInterpolatedHandle(histo_handle &newone,             
                                                          float new_pos                         
                                                          )
{
        CreateDefaultHandle(newone);

        histo_handle *pre, *post;

        pre = post = tf;

        while (post)
        {
                if (post->in_val >= new_pos)
                {
                        if (pre == post)
                                post = post->next;

                        break;
                }

                pre = post;

                post = post->next;
        }

        float dist = post->in_val - pre->in_val;

        float weight = (new_pos - pre->in_val) / dist;

        newone.col_ambient[0] = pre->col_ambient[0] * (1.0f - weight) + post->col_ambient[0] * weight;
        newone.col_ambient[1] = pre->col_ambient[1] * (1.0f - weight) + post->col_ambient[1] * weight;
        newone.col_ambient[2] = pre->col_ambient[2] * (1.0f - weight) + post->col_ambient[2] * weight;

        newone.col_diffuse[0] = pre->col_diffuse[0] * (1.0f - weight) + post->col_diffuse[0] * weight;
        newone.col_diffuse[1] = pre->col_diffuse[1] * (1.0f - weight) + post->col_diffuse[1] * weight;
        newone.col_diffuse[2] = pre->col_diffuse[2] * (1.0f - weight) + post->col_diffuse[2] * weight;

        newone.col_specular[0] = pre->col_specular[0] * (1.0f - weight) + post->col_specular[0] * weight;
        newone.col_specular[1] = pre->col_specular[1] * (1.0f - weight) + post->col_specular[1] * weight;
        newone.col_specular[2] = pre->col_specular[2] * (1.0f - weight) + post->col_specular[2] * weight;

        newone.spec_exponent = pre->spec_exponent * (1.0f - weight) + post->spec_exponent * weight;

        newone.out_alpha = pre->out_alpha * (1.0f - weight) + post->out_alpha * weight;

        newone.gradient = pre->gradient * (1.0f - weight) + post->gradient * weight;

        newone.in_val = new_pos;
}

histo_handle *GropeForHandle(HWND hWnd)
{
        POINT   cpos;

        GetCursorPos(&cpos);

        ScreenToClient(hWnd, &cpos);

        RECT clientRect;
        GetClientRect(hWnd, &clientRect);

        float windowaspect = (float)clientRect.right / (float)clientRect.bottom;

        wglMakeCurrent(histodc, historc);

        double mvm[16];
        glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
        double pm[16];
        glGetDoublev(GL_PROJECTION_MATRIX, pm);
        int view[4];
        glGetIntegerv(GL_VIEWPORT, view);

        double ox, oy, oz;

        gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

        oy = 1.0f - oy;

        histo_handle *cur = tf;

        while (cur)
        {
                if (ox > cur->in_val * windowaspect - HANDLE_SIZE &&
                        ox < cur->in_val * windowaspect + HANDLE_SIZE &&
                        oy > cur->out_alpha - HANDLE_SIZE &&
                        oy < cur->out_alpha + HANDLE_SIZE)
                {
                        SetCursor(LoadCursor(NULL, IDC_HAND));
                        return cur;
                }

                cur = cur->next;
        }

        return NULL;
}

void MoveHandle(HWND hWnd, histo_handle *handle)
{
        POINT   cpos;

        GetCursorPos(&cpos);

        ScreenToClient(hWnd, &cpos);

        RECT clientRect;
        GetClientRect(hWnd, &clientRect);

        float windowaspect = (float)clientRect.right / (float)clientRect.bottom;

        wglMakeCurrent(histodc, historc);

        double mvm[16];
        glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
        double pm[16];
        glGetDoublev(GL_PROJECTION_MATRIX, pm);
        int view[4];
        glGetIntegerv(GL_VIEWPORT, view);

        double ox, oy, oz;

        gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

        oy = 1.0f - oy;
        oy = (oy > 1.0f)?1.0f:((oy < 0.0f)?0.0f:oy);
        handle->out_alpha = (float)oy;

        ox /= windowaspect;

        if (handle->prev &&
                handle->next)
        {
                if (ox < handle->prev->in_val)
                        ox = handle->prev->in_val + 0.001f;

                if (ox > handle->next->in_val)
                        ox = handle->next->in_val - 0.001f;

                handle->in_val = (float)ox;
        }

        DrawHistogram(hWnd);
}

histo_handle *InsertHandle(HWND hWnd)
{
        POINT   cpos;

        GetCursorPos(&cpos);

        ScreenToClient(hWnd, &cpos);

        RECT clientRect;
        GetClientRect(hWnd, &clientRect);

        float windowaspect = (float)clientRect.right / (float)clientRect.bottom;

        wglMakeCurrent(histodc, historc);

        double mvm[16];
        glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
        double pm[16];
        glGetDoublev(GL_PROJECTION_MATRIX, pm);
        int view[4];
        glGetIntegerv(GL_VIEWPORT, view);

        double ox, oy, oz;

        gluUnProject(cpos.x, cpos.y, 0.0, mvm, pm, view, &ox, &oy, &oz);

        oy = 1.0f - oy;
        ox /= windowaspect;

        histo_handle *cur = tf;
        histo_handle *handle = NULL;

        while (cur)
        {
                if (cur->in_val > ox)
                {
                        handle = new histo_handle;
                        CreateInterpolatedHandle(*handle, (float)ox);

                        handle->prev = cur->prev;
                        handle->next = cur;

                        handle->prev->next = handle;
                        handle->next->prev = handle;

                        handle->in_val = (float)ox;
                        handle->out_alpha = (float)oy;

                        break;
                }

                cur = cur->next;
        }

        DrawHistogram(hWnd);

        return handle;
}

void CreateDefaultTransferFunction()
{
        // initialize the transfer function
        tf = new histo_handle;

        CreateDefaultHandle(*tf);
        tf->prev = NULL;
        tf->in_val = 0.0f;
        tf->out_alpha = 0.0f;

        tf->next = new histo_handle;

        CreateDefaultHandle(*(tf->next));
        tf->next->prev = tf;
        tf->next->next = NULL;
        tf->next->in_val = 1.0f;
        tf->next->out_alpha = 1.0f;
}

void LoadFunction()
{
        OPENFILENAME ofn;
        ofn.lStructSize = sizeof(OPENFILENAME);
        ofn.hwndOwner = wnd_histogram;
        ofn.hInstance = NULL;
        ofn.lpstrFilter = L"Transfer Function (*.tf)\0*.TF\0All Files\0*.*\0\0";
        ofn.lpstrCustomFilter = NULL;
        ofn.nMaxCustFilter = 0;
        ofn.nFilterIndex = 1;
        ofn.lpstrFile = new wchar_t[500]; ofn.lpstrFile[0] = '\0';
        ofn.nMaxFile = 500;
        ofn.lpstrFileTitle = NULL;
        ofn.nMaxFileTitle = 0;
        ofn.lpstrInitialDir = NULL;
        ofn.lpstrTitle = NULL;
        ofn.Flags = OFN_DONTADDTORECENT | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST; 
        ofn.lpstrDefExt = NULL;
        ofn.pvReserved = NULL;
        ofn.dwReserved = 0;
        ofn.FlagsEx = 0;

        // grab the filename from our user
        if (GetOpenFileName(&ofn))
        {
                // remove the current transfer function
                histo_handle    *cur = tf;

                while (cur->next)
                {
                        cur = cur->next;

                        delete cur->prev;
                }

                delete cur;

                // open input file handle
                int infile;
                _wsopen_s(&infile, ofn.lpstrFile, _O_BINARY | _O_SEQUENTIAL, _SH_DENYNO, 0);

                // create a new transfer function by first creating a new header
                tf = new histo_handle;

                // fill it
                _read(infile, tf, sizeof(histo_handle));

                cur = tf;

                // do as long as additional records are in the file
                while (cur->next)
                {
                        cur->next = new histo_handle;

                        _read(infile, cur->next, sizeof(histo_handle));
                        cur->next->prev = cur;

                        cur = cur->next;
                }

                // close input file
                _close(infile);
        }
}

void SaveFunction()
{
        OPENFILENAME ofn;

        ofn.lStructSize = sizeof(OPENFILENAME);
        ofn.hwndOwner = wnd_histogram;
        ofn.hInstance = NULL;
        ofn.lpstrFilter = L"Transfer Function (*.tf)\0*.TF\0All Files\0*.*\0\0";
        ofn.lpstrCustomFilter = NULL;
        ofn.nMaxCustFilter = 0;
        ofn.nFilterIndex = 1;
        ofn.lpstrFile = new wchar_t[500]; ofn.lpstrFile[0] = '\0';
        ofn.nMaxFile = 500;
        ofn.lpstrFileTitle = NULL;
        ofn.nMaxFileTitle = 0;
        ofn.lpstrInitialDir = NULL;
        ofn.lpstrTitle = NULL;
        ofn.Flags = OFN_DONTADDTORECENT; 
        ofn.lpstrDefExt = NULL;
        ofn.pvReserved = NULL;
        ofn.dwReserved = 0;
        ofn.FlagsEx = 0;

        // grab the filename from our user
        if (GetSaveFileName(&ofn))
        {
                // open output file handle
                int outfile;

                _wsopen_s(&outfile, ofn.lpstrFile, _O_BINARY | _O_SEQUENTIAL | _O_CREAT | _O_WRONLY | _O_TRUNC, _SH_DENYNO, _S_IWRITE | _S_IREAD);

                histo_handle *cur = tf;

                while (cur)
                {
                        _write(outfile, cur, sizeof(histo_handle));
                        cur = cur->next;
                }

                // close input file
                _close(outfile);
        }
}

LRESULT CALLBACK HistogramProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        PAINTSTRUCT ps;
        HDC hdc;
        
        static histo_handle *handle;
        HMENU pop;

        switch (message)
        {
        case WM_RBUTTONDOWN:
                handle = GropeForHandle(hWnd);

                if (handle)
                {
                        POINT cpos;

                        GetCursorPos(&cpos);

                        pop = LoadMenu(hInst, MAKEINTRESOURCE(IDC_RCLICKS));

                        if (handle->prev && handle->next)
                                EnableMenuItem(pop, ID_HANDLE_REMOVE, MF_ENABLED);
                        else
                                EnableMenuItem(pop, ID_HANDLE_REMOVE, MF_DISABLED);

                        UINT resp = TrackPopupMenuEx(GetSubMenu(pop, 0), TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, cpos.x, cpos.y, hWnd, NULL);

                        if (resp == ID_HANDLE_REMOVE)
                        {
                                handle->prev->next = handle->next;
                                handle->next->prev = handle->prev;
                                
                                delete handle;

                                DrawHistogram(hWnd);
                        }
                        else if (resp == ID_HANDLE_EDIT)
                        {
                                EditTransferHandle(handle, hWnd);
                        }
                }
                else
                {
                        POINT cpos;

                        GetCursorPos(&cpos);

                        pop = LoadMenu(hInst, MAKEINTRESOURCE(IDC_RCLICKS));
                        UINT resp = TrackPopupMenuEx(GetSubMenu(pop, 1), TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, cpos.x, cpos.y, hWnd, NULL);

                        if (resp == ID_BACK_LOADTRANSFERFUNCTION)
                        {
                                LoadFunction();
                                DrawHistogram(hWnd);
                                RayRender();
                        }
                        else if (resp == ID_BACK_SAVETRANSFERFUNCTION)
                        {
                                SaveFunction();
                        }
                }

                break;
        case WM_LBUTTONDOWN:
                handle = GropeForHandle(hWnd);
                SetCapture(hWnd);

                if (!handle)
                {
                        handle = InsertHandle(hWnd);
                }

                break;
        case WM_LBUTTONUP:
                ReleaseCapture();
        case WM_MOUSEMOVE:
                if (GetCapture() == hWnd)
                {
                        if (handle)
                        {
                                MoveHandle(hWnd, handle);
                        }
                }
                else
                {
                        GropeForHandle(hWnd);
                }
                break;
        case WM_PAINT:
                hdc = BeginPaint(hWnd, &ps);
                DrawHistogram(hWnd);
                EndPaint(hWnd, &ps);
                break;
        case WM_SHOWWINDOW:
                InitHistogramWnd(hWnd);
                break;
        case WM_DESTROY:
                DeInitHistogramWnd(hWnd);
                PostQuitMessage(0);
                break;
        default:
                return DefWindowProc(hWnd, message, wParam, lParam);
        }
        return 0;
}

---