ChildView.cpp

Go to the documentation of this file.

#include "../common/standard.h"
#include "stdafx.h"

#include <windows.h>
#include <GL/glu.h>
#include "GLutils.h" // printBitmapString
#include "Archimedes.h"
#include "MainFrm.h"
#include "ChildView.h"
#include "VoxelParamDialog.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// CChildView

CChildView::CChildView()
{
    m_bFileLoaded = false;
    m_hglrc = NULL;
    m_bShowSmooth = false;
}

CChildView::~CChildView()
{
}


BEGIN_MESSAGE_MAP(CChildView,CWnd )
        //{{AFX_MSG_MAP(CChildView)
        ON_WM_PAINT()
        ON_UPDATE_COMMAND_UI(ID_FILE_OPEN, OnUpdateFileOpen)
        ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
        ON_WM_SIZE()
        ON_WM_ERASEBKGND()
        ON_WM_LBUTTONDOWN()
        ON_WM_LBUTTONUP()
        ON_WM_MOUSEMOVE()
        ON_BN_CLICKED(IDC_SNAPSHOT_BUTTON, OnSnapshotButton)
        ON_CBN_SELCHANGE(IDC_VOXELSMOOTH_COMBO, OnSelchangeVoxelsmoothCombo)
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()


// CChildView message handlers

BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs) 
{
        if (!CWnd::PreCreateWindow(cs))
                return FALSE;

        cs.dwExStyle |= WS_EX_CLIENTEDGE;
        cs.style &= ~WS_BORDER;
        cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS, 
                ::LoadCursor(NULL, IDC_ARROW), HBRUSH(COLOR_WINDOW+1), NULL);

        return TRUE;
}


BOOL InitPixelFormat(CDC *pDC)
{
    
    static PIXELFORMATDESCRIPTOR pfd = 
    {
        sizeof(PIXELFORMATDESCRIPTOR),      // size of this pfd
            1,                              // version number
            PFD_DRAW_TO_WINDOW |            // support window
            PFD_SUPPORT_OPENGL |            // support OpenGL
            PFD_DOUBLEBUFFER,               // double buffered
            PFD_TYPE_RGBA,                  // RGBA type
            24,                             // 24-bit color depth
            0, 0, 0, 0, 0, 0,               // color bits ignored
            0,                              // no alpha buffer
            0,                              // shift bit ignored
            0,                              // no accumulation buffer
            0, 0, 0, 0,                     // accum bits ignored
            32,                             // 32-bit z-buffer
            0,                              // no stencil buffer
            0,                              // no auxiliary buffer
            PFD_MAIN_PLANE,                 // main layer
            0,                              // reserved
            0, 0, 0                         // layer masks ignored
    };

    int pixelformat;
    
    if ( (pixelformat = ChoosePixelFormat(pDC->GetSafeHdc(), &pfd)) == 0 )
    {
        AfxMessageBox("ChoosePixelFormat failed");
        return FALSE;
    }
    
    
    if (SetPixelFormat(pDC->GetSafeHdc(), pixelformat, &pfd) == FALSE)
    {
        AfxMessageBox("SetPixelFormat failed");
        return FALSE;
    }
    
    return TRUE;
}

static HGLRC InitOpenGL(CDC *pDC, const CRect &clientRect)
{
        HGLRC hrc;

        // Set up DC
        ASSERT(pDC != NULL);
        if (!InitPixelFormat(pDC))
        {
                AfxMessageBox("InitOpenGL couldn't initialize the pixel format, bailing...");
                assert(0);
 
                exit(0);
        }

        // Set up GL context
        hrc = wglCreateContext(pDC->GetSafeHdc());
        wglMakeCurrent(pDC->GetSafeHdc(), hrc);

        return hrc;
}

void CChildView::OnPaint() 
{

    Draw();
}


void CChildView::OnUpdateFileOpen(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable();
}

/*
 * Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet
 * if we are away from the center of the sphere.
 *
 * @author Gavin Bell
 */
static float
tb_project_to_sphere(float r, float x, float y)
{
    float d, t, z;

    d = sqrt(x*x + y*y);
    if (d < r * 0.70710678118654752440) {    /* Inside sphere */
        z = sqrt(r*r - d*d);
    } else {           /* On hyperbola */
        t = r / 1.41421356237309504880;
        z = t*t / d;
    }
    return z;
}


#define TRACKBALLSIZE (0.6)

void getRotation(ColVector2d mouseOld, ColVector2d mouseNew, float &phi, ColVector3 &a)
{
    float t;

    if (mouseOld == mouseNew)
        return;

    /*
     * First, figure out z-coordinates for projection of P1 and P2 to
     * deformed sphere
     */

    ColVector3d p1 (mouseOld[0], mouseOld[1], tb_project_to_sphere(TRACKBALLSIZE,mouseOld[0],mouseOld[1]));
    ColVector3d p2 (mouseNew[0], mouseNew[1], tb_project_to_sphere(TRACKBALLSIZE,mouseNew[0],mouseNew[1]));

    /*
     *  Now, we want the cross product of P1 and P2
     */
    // axis of rotation
    a = p2.crossProduct(p1);

    /*
     *  Figure out how much to rotate around that axis.
     */
    ColVector3 d = p1 - p2;
    t = d.getLength() / (2.0*TRACKBALLSIZE);

    /*
     * Avoid problems with out-of-control values...
     */
    if (t > 1.0) t = 1.0;
    if (t < -1.0) t = -1.0;
    phi = 2.0 * asin(t);
}


static void doResize (int w, int h)
{
        // don't divide by zero
        if (h == 0 || w == 0)
                return;
    
    glViewport(0, 0, w, h);

        glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

        if (w > h)
                gluPerspective(30, (float)w/h, 0.5f, 200);
        else
                gluPerspective(30*h/w, (float)w/h, 0.5f, 200);

        glMatrixMode(GL_MODELVIEW);
}

void CChildView::Draw()
{
        CPaintDC dc(this); // device context for painting       
/*
 * Initialize OpenGL, if it hasn't been already
 */
    CRect clientRect;
    GetClientRect(&clientRect);

    static bool bInit = false;
    if (!bInit)
    {
        m_hglrc = InitOpenGL(&dc, clientRect);
        bInit = true;
    }

    wglMakeCurrent (dc.m_hDC, m_hglrc);

    glClearColor (0,0,1,1);;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    if (m_bFileLoaded)
    {
        glEnable(GL_DEPTH_TEST);
        
        glMatrixMode (GL_PROJECTION);
        glLoadIdentity();
        
        doResize(clientRect.Width(), clientRect.Height());
        glMatrixMode (GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(0,0,-1, 0,0,0, 0,1,0);
        
        CRect r;
        this->GetClientRect(r);
        
        ColVector2d oldPos (
            RESCALE (m_oldMousePos.x, 0, r.Width(), -1., 1.),
            RESCALE (m_oldMousePos.y, 0, r.Height(), -1., 1.));
        ColVector2d newPos (
            RESCALE (m_newMousePos.x, 0, r.Width(), -1., 1.),
            RESCALE (m_newMousePos.y, 0, r.Height(), -1., 1.));
        
        float phi=0;
        ColVector3d amt(0,0,0);
        getRotation(oldPos, newPos, phi, amt);
        
        if (m_bShowSmooth)
            glDisable (GL_CULL_FACE);
        else
            glEnable (GL_CULL_FACE);

        m_scanner.drawWithAngle(m_bShowSmooth, (180.)*newPos[1], -(180.)*newPos[0]);
    }

    if (stringToDraw.GetLength() > 0)
    {
        try
        {
            printBitmapString(stringToDraw.GetBuffer(0), dc.m_hDC);
        }
        catch (exception &e)
        {
            Message(e.what());
        }
    }

    assert(!glGetError());

    SwapBuffers(wglGetCurrentDC());
}


void updateCallback (char *str, float pct, void *data)
{
    CChildView *_this = (CChildView *)data;

    if (strlen(str) > 0)
    {
        char stringWithPct[256];
        sprintf (stringWithPct, "%s (%.1f%% of voxels carved)", str, pct*100);
        _this->stringToDraw = stringWithPct;
    }
    else
        _this->stringToDraw="";

    _this->Invalidate();
    _this->UpdateWindow();
}

bool CChildView::openFile(const char *filename)
{
    try {
        m_scanner.loadImages(filename, 
            25,   // default # voxels/side
            30);  // default width of the whole cube of voxels
    }
    catch (exception &e)
    {
        Message("Unable to load file %s: %s", filename, e.what());
        return false;
    }
    
    AfxGetApp()->AddToRecentFileList(filename);

    char *ext = strrchr (filename, '.');
    if (!ext) throw RuntimeError ("OnOpenDocument(): Your file must have a .scn or a .col extension.");

    Vertex center;
    int voxelsPerSide;
    double voxelCubeSize;

    if (0 == _stricmp(ext, ".scn"))
    {
        m_scanner.getVoxelParamsFromScnFile (filename, center, voxelsPerSide, voxelCubeSize);
    }
    else
    {
        voxelsPerSide = 25;
        voxelCubeSize = 30;
        center = m_scanner.guessVoxelcubeCenter();
    }

    VoxelParamDialog d;
 
    d.m_voxelcubeWidth = voxelCubeSize;
    d.m_voxelsPerSide = voxelsPerSide;
    d.m_threshold = 50;
    d.m_bEnableSilhouetteCheckbox = m_scanner.hasSilhouettes();

    m_scanner.setProgressCallback (updateCallback, 1, this);
    if (IDOK == d.DoModal ())
    {         
        VoxelCube &cube = m_scanner.voxelCube;
        cube.setVoxelSize (d.m_voxelcubeWidth / d.m_voxelsPerSide);
        cube.setVoxelsPerSide (d.m_voxelsPerSide);
        cube.setCenter (center);
        
        m_bFileLoaded = true;
        m_scanner.carveVoxels (d.m_threshold, d.m_bUseSilhouettes?true:false);
        m_scanner.setProgressCallback (NULL, 0, NULL);
        
        Invalidate(false);
        CMainFrame *mf = (CMainFrame *)GetParentFrame();
        mf->m_wndStatusBar.SetPaneText(
            1, fmtString("%d voxels (cube view), %d polygons (smooth mesh view)", m_scanner.voxelCube.svl.size(), m_scanner.mesh.getNumFacesVisible()),
            TRUE);
        return true;
    }
    else
    {
        m_scanner.setProgressCallback (NULL, 0, NULL);
        return false;
    }    
}

void CChildView::OnFileOpen() 
{
        CFileDialog f(
                TRUE,           // open file dialog
                ".scn",         // default extension
                NULL,           // initial filename
                OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, // flags
                "All Files (*.col, *.scn)|*.col;*.scn|Archimedes XML files (*.scn)|*.scn|MERL files (*.col)|*.col||");  // extension filter                     

        if (IDOK != f.DoModal()) // user cancelled
                return;

    CString filename = f.GetPathName();

    if (!openFile (filename))
        return;
}

void CChildView::OnSize(UINT nType, int cx, int cy) 
{
        CWnd ::OnSize(nType, cx, cy);
        
    doResize(cx, cy);
}

BOOL CChildView::OnEraseBkgnd(CDC* pDC)  { return true; }

void CChildView::OnLButtonDown(UINT nFlags, CPoint point) 
{
    m_bMouseDown = true;
    m_oldMousePos = point;

    SetCapture();

    CWnd::OnLButtonDown(nFlags, point);
}

void CChildView::OnLButtonUp(UINT nFlags, CPoint point) 
{
    ReleaseCapture();
    m_bMouseDown = false;
        
        CWnd::OnLButtonUp(nFlags, point);
}

void CChildView::OnMouseMove(UINT nFlags, CPoint point) 
{
    if (!m_bMouseDown)
        return;

    m_newMousePos = point;
    Invalidate();
        
        CWnd::OnMouseMove(nFlags, point);
}
#ifndef BIF_NEWDIALOGSTYLE
#define BIF_NEWDIALOGSTYLE 0x0040
#endif 

bool getDirectoryNameFromDialog(HWND hwnd, const char *messageToDisplay, std::string &dirName)
{
    bool rtn = false;
    CoInitialize(NULL);
    LPMALLOC pMalloc;

    if (::SHGetMalloc(&pMalloc) == NOERROR)
    {
        BROWSEINFO info;
        char pszBuffer[MAX_PATH];
        LPITEMIDLIST pidl;

        memset (&info, 0, sizeof(BROWSEINFO));
        
        info.hwndOwner = hwnd;
        info.pszDisplayName = pszBuffer;
        info.lpszTitle = _T(messageToDisplay);
        info.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;

        if ((pidl = ::SHBrowseForFolder(&info)) != NULL)
        {
            if (::SHGetPathFromIDList(pidl, pszBuffer))
            { 
                dirName = pszBuffer;
                rtn = true;
            }
            else
            {
                dirName = "";
            }

            pMalloc->Free(pidl);
        }

        pMalloc->Release();
    }
    
    return rtn;
} 

void CChildView::OnSnapshotButton() 
{
    if (!m_bFileLoaded)
    {
        Message("Can't take snapshots (no file loaded yet!)");
        return;
    }

    std::string dirName;
    if (getDirectoryNameFromDialog (this->m_hWnd, "Where would you like to save your snapshots?", dirName))
    {
        try 
        {
            m_scanner.takeSnapshots(dirName.c_str());
        }
        catch (exception &e)
        {
            Message(e.what());
        }   
    }
}

void CChildView::OnSelchangeVoxelsmoothCombo() 
{
    CMainFrame *mf = (CMainFrame *)GetParentFrame();
        CComboBox *bSmooth = (CComboBox *)mf->m_wndDlgBar.GetDlgItem(IDC_VOXELSMOOTH_COMBO);

    if (bSmooth->GetCurSel() == 1)
        m_bShowSmooth = true;
    else
        m_bShowSmooth = false;
    Invalidate();
}

---