Scanner.cpp

Go to the documentation of this file.

#include "../common/standard.h"
#include <windows.h>
#include <GL/glu.h>

#include "GLutils.h"
#include "Scanner.h"
#include "GLBitmapBuffer.h"
#include "XmlNode.h"



void Scanner::getVoxelParamsFromScnFile(const char *filename, Vertex &center, int &voxelsPerSide, double &voxelCubeSize)
{
    XmlNode d;
    d.loadFile(filename);

    d.getAttrib (center[0],     "scanner/voxel_parameters/voxelcube_center/@x");
    d.getAttrib (center[1],     "scanner/voxel_parameters/voxelcube_center/@y");
    d.getAttrib (center[2],     "scanner/voxel_parameters/voxelcube_center/@z");

    d.getAttrib (voxelsPerSide, "scanner/voxel_parameters/voxels_per_side/@value");
    d.getAttrib (voxelCubeSize,     "scanner/voxel_parameters/voxelcube_size/@value");
}



void Scanner::drawItemBufferForImage (Viewpoint &image)
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    assert(image.getWidth() && image.getHeight());
    image.imageBuffer.resize (image.getWidth() * image.getHeight());

    voxelCube.fillItemBufferArray(image);
}



bool Scanner::getColorsForVoxel (SurfaceVoxelList::iterator &svl_iter,  std::vector< RgbByte > &colorsToAgreeOn, std::vector< int > &numPixelsFound, bool bUseSilhouettes) const
{
    VoxelPos pos = *svl_iter;

    unsigned int x,y,z;
    x = pos[0];
    y = pos[1];
    z = pos[2];

    std::vector< Vertex > vertices = voxelCube.calculateVoxelCorners(x,y,z);
    assert (vertices.size() == 8);

/*
 * For each image...
 */

    ViewpointList::const_iterator view_iter;
    for (view_iter = images.begin(); view_iter != images.end(); view_iter++)
    {
        bool bSeen = false;
        const Viewpoint &view = *view_iter;
        std::vector< RgbByte > colorsToAverage;
    
        GLint viewport[4];
        viewport[0] = 0; viewport[1] = 0;
        viewport[2] = view.getWidth(); viewport[3] = view.getHeight();

        Rect< double > bounds = voxelCube.getBoundingRect(vertices, view.getModelviewMatrix(), view.getProjectionMatrix(), viewport);
    
        // if the voxel projects completely off the image, the area of the
        // bounding rectangle may be negative
        if (!bounds.hasPositiveArea())
            continue; // go to next image
    
     /*
      * Okay, we have a bounding rectangle defined by (xmin->xmax, ymin->ymax).
      * Let's see which pixels are visible in the item buffer
      */
        int nMatchesWeShouldFind = 0;
        int nMatchesFound = 0;
    
        unsigned int curVoxelID = voxelCube.PosToIdentifier (x,y,z);
    
        int nPixelsChecked = 0;
        int nPixelsTransparentSilhouette = 0;
        for (int u = bounds.left; u <= bounds.right; u++)
        {
            for (int v = bounds.bottom; v <= bounds.top; v++)
            {
                nPixelsChecked++;
                unsigned int ibuf_color = view.imageBuffer[v * view.getWidth() + u];
            
                RGBQUAD *ic = (RGBQUAD*)&ibuf_color;
                ic->rgbReserved = 0;
            
                if (ibuf_color == curVoxelID)
                {
                    if (bUseSilhouettes && view.pixelIsTransparent(u,v))
                        nPixelsTransparentSilhouette++;

                    bSeen = true;
                    nMatchesWeShouldFind++;
                    RgbByte &img_color = view.colorAt(u,v);
            
                    nMatchesFound++;
                    colorsToAverage.push_back (img_color);
                }
            }
        }

        double pctTransparentViaSilhouette = (double)nPixelsTransparentSilhouette / nMatchesWeShouldFind;
        if (pctTransparentViaSilhouette > .5)
            return false;


        if (bSeen)
        {
            RgbDouble avg = averageColor (colorsToAverage);
            colorsToAgreeOn.push_back (RgbByte (avg[0], avg[1], avg[2]));
            numPixelsFound.push_back (nMatchesWeShouldFind);
        }
    }
    return true;

}


void Scanner::drawFromImagePerspective (bool bSmooth, int imgIndex)
{
    if (imgIndex > images.size())
        throw LogicError("Scanner::drawFromImagePerspective(): no such image index");

    Viewpoint &image = images[imgIndex];
    
    glMatrixMode (GL_PROJECTION);
    glLoadMatrixd(image.getProjectionMatrix());
    glMatrixMode (GL_MODELVIEW);
    glLoadMatrixd (image.getModelviewMatrix());

    drawModel (bSmooth, false /* no wire frame */);
}



void Scanner::drawModel(bool bSmooth, bool bDrawWireFrame)
{
    glMatrixMode (GL_MODELVIEW);
    if (bSmooth)
    {
        Vertex center = voxelCube.getCenter();
        double halfVoxelSize = voxelCube.getVoxelSize() / 2.;
        double halfCubeSize = voxelCube.getVoxelsPerSide() * halfVoxelSize;

        // translate to center
        glTranslated(center[0], center[1], center[2]);

        glPushMatrix();
            glTranslated(-halfCubeSize, -halfCubeSize, -halfCubeSize);
            glTranslated(halfVoxelSize, halfVoxelSize, halfVoxelSize);

            mesh.draw();
        glPopMatrix();

        if (bDrawWireFrame) 
        {
            glColor3f(1,1,1);
            drawCube(voxelCube.getVoxelSize()*voxelCube.getVoxelsPerSide(), GL_LINE_LOOP);
        }
    }
    else
    {
        voxelCube.draw (true /*bTranslateToCenter*/);
        if (bDrawWireFrame) 
        {
            glPushMatrix();
            
                // translate to center
                Vertex center = voxelCube.getCenter();
                glTranslated(center[0], center[1], center[2]);
            
                // draw the cube
                glColor3f(1,1,1);
                drawCube(voxelCube.getVoxelSize()*voxelCube.getVoxelsPerSide(), GL_LINE_LOOP);

            glPopMatrix();
        }
    }
}



void Scanner::drawWithAngle(bool bSmooth, double latitude, double longitude)
{
    Viewpoint &image = images[0];

    Vertex cop = image.getCenterOfProjection();
    ColVector3 up = image.getUpVector();
    Vertex center = voxelCube.getCenter();

    ModelviewMatrix m;
    m.setToIdentity();
    m.lookAtWithOffset (cop, center, up, latitude, longitude);

    glMatrixMode (GL_MODELVIEW);
    glLoadMatrixd (&m[0]);

    drawModel(bSmooth, true /* draw wire frame */);    
}



bool Scanner::isConsistent (SurfaceVoxelList::iterator &svl_iter, bool bUseSilhouettes) const
{
    std::vector< RgbByte > colorsToAgreeOn;

    std::vector< int > numPixelsSeen;

    // if this returns false, then the silhouette has told us to carve the voxel
    if (!getColorsForVoxel (svl_iter, colorsToAgreeOn, numPixelsSeen, bUseSilhouettes))
        return false;

    int numImagesThatCanSeeIt = colorsToAgreeOn.size();
    
    if (numImagesThatCanSeeIt < 2)
        return true;

    // if no images can theoretically "see" the voxel, then 
    // we would leave this voxel uncarved.
    if (colorsToAgreeOn.size() == 0)
        return true;

    if (!colorsAgree (colorsToAgreeOn, numPixelsSeen))
        return false;

    return true;
}



void Scanner::carveVoxels (double threshold, bool bUseSilhouettes)
{
    thresholdSquared = threshold*threshold;
    if (images.empty())
        throw LogicError ("Scanner::carveVoxels(): Please load some images before you construct a voxel list.");
    
    int nVoxelsRemoved;
    mesh.clear();

    // the voxel cube has a surface voxel list, which is a list of opaque
    // voxels that are not completely surrounded by other opaque voxels
    SurfaceVoxelList &svl = voxelCube.svl;

    int nVoxelsPerSide = voxelCube.getVoxelsPerSide();
    int nTotalNumVoxels = pow(nVoxelsPerSide, 3);
    int nTotalNumVoxelsRemoved = 0;

    do // ...while (nVoxelsRemoved > 0)
    {
        nVoxelsRemoved = 0;
        
        // For each input image, calculate per-pixel voxel visibility.
        // This is done by making an item buffer.
        ViewpointList::iterator view_iter;


        int curImg = 0;
        for (view_iter = images.begin(); view_iter != images.end(); view_iter++)
        {
            Viewpoint &image = *view_iter;

            drawItemBufferForImage(image);

            if (0 == curImg % 8)
            {
                doProgressUpdate(
                    false, 
                    (float)nTotalNumVoxelsRemoved/nTotalNumVoxels,
                    "Drawing item buffers");
            }
            curImg++;
        }      


        SurfaceVoxelList::iterator svl_iter = svl.begin();
    
        int startingNumberOfVoxels = svl.size();

        //  For each voxel in the surface voxel list...
        while (svl_iter != svl.end())
        {                
            // if the voxel isn't consistent between images...
            VoxelPos &p = *svl_iter;
            if (!isConsistent (svl_iter, bUseSilhouettes))
            {
                // ...expose surrounding voxels, and remove this voxel
                voxelCube.exposeSurroundingVoxels (svl_iter);

                assert (!voxelCube.isTransparent (p[0],p[1],p[2]));
                voxelCube.setTransparent (svl_iter);
                svl_iter = svl.erase(svl_iter); // go to next voxel

                nVoxelsRemoved++;
                nTotalNumVoxelsRemoved++;
            }
            else
            {
                svl_iter++; // go to next voxel
            }

            doProgressUpdate (false,  (float)nTotalNumVoxelsRemoved/nTotalNumVoxels, "Carving voxels");
            
        } // looping through voxels

        MTRACE ("%d voxels removed this time around\n", nVoxelsRemoved);
        
    } while (nVoxelsRemoved);

    for (SurfaceVoxelList::iterator svl_iter = svl.begin(); svl_iter != svl.end(); svl_iter++)
    {
        std::vector< RgbByte > colors;

        std::vector< int > numPixelsSeen;
        getColorsForVoxel (svl_iter, colors, numPixelsSeen, bUseSilhouettes);
        RgbDouble avgFloat = weightedAverageColor (colors, numPixelsSeen);
        RgbByte avg;
        avg.r() = avgFloat.r();
        avg.b() = avgFloat.b();
        avg.g() = avgFloat.g();
        
        voxelCube.setFinalColor (svl_iter, avg);
    }

    voxelCube.makeMesh(.5, this->mesh);

    doProgressUpdate (true,  1., "");


//    mesh.recalculateCosts();
//    mesh.doCollapse(mesh.getNumFacesTotal() / 2);
}



void Scanner::doProgressUpdate(bool bForce, float pctDone, const char *format, ...)
{
    if (!progressReportCB) return;


    if (bForce || (time(NULL) - lastTime) > updateInterval)
    {
            va_list args; 
            char    buffer[512];
            va_start(args,format);
            _vsnprintf(buffer,sizeof(buffer)-1,format,args);
        va_end(args);

        progressReportCB(buffer, pctDone, progressUpdateData);
        lastTime = time(NULL);
    }
}


RgbDouble Scanner::averageColor (std::vector< RgbByte > &colors) const
{
    RgbDouble avgColorPrecise;
    avgColorPrecise.setToZero();

    for (int i = 0; i < colors.size(); i++)
    {
        avgColorPrecise.r() += (float)colors[i].r();
        avgColorPrecise.g() += (float)colors[i].g();
        avgColorPrecise.b() += (float)colors[i].b();
    }

    avgColorPrecise.r() /= colors.size();
    avgColorPrecise.g() /= colors.size();
    avgColorPrecise.b() /= colors.size();
    return avgColorPrecise;
}



void Scanner::setProgressCallback (void (*updateCB)(char *str, float pctDone, void *data), int intervalInSeconds, void *data)
{
    progressReportCB = updateCB;
    updateInterval = intervalInSeconds;
    progressUpdateData = data;
}




RgbDouble Scanner::weightedAverageColor (std::vector< RgbByte > &colors, std::vector< int > &numPixelsSeen) const
{
    assert (colors.size() == numPixelsSeen.size());

    int totalPixelsSeen = std::accumulate (numPixelsSeen.begin(), numPixelsSeen.end(), 0);

    RgbColor< double > avgColor;
    avgColor.setToZero();

    for (int i = 0; i < colors.size(); i++)
    {
        double ratio = (double)numPixelsSeen[i] / totalPixelsSeen;
        avgColor.r() += colors[i].r() * ratio;
        avgColor.g() += colors[i].g() * ratio;
        avgColor.b() += colors[i].b() * ratio;
    }

    return avgColor;
}



bool Scanner::colorsAgree (std::vector< RgbByte > &colors, std::vector< int > numPixelsSeen) const
{
    RgbDouble avgColor = weightedAverageColor (colors, numPixelsSeen);

    int totalPixelsSeen = std::accumulate (numPixelsSeen.begin(),numPixelsSeen.end(),0);

    double dist = 0.;
    for (int i = 0; i < colors.size(); i++)
    {
        RgbDouble color;
        color.r() = colors[i].r();
        color.g() = colors[i].g();
        color.b() = colors[i].b();

        RgbDouble diff =  avgColor - color;
        double difflength = diff.getLengthSquared();

        double ratio = (double)numPixelsSeen[i] / totalPixelsSeen;
        dist += ratio * difflength;
    }

    return (dist < thresholdSquared);
}



void Scanner::takeSnapshots(const char *directoryName) 
{
    int curImage = 0;
    for (ViewpointList::iterator i = images.begin(); i != images.end(); i++)
    {
        Viewpoint &img = *i;
        int width = img.getWidth()/2;
        int height = img.getHeight()/2;

        // create our bitmap buffer
        GLBitmapBuffer bitbuff;
        bitbuff.create(width*3,height);
        bitbuff.select();

            glEnable (GL_DEPTH_TEST);
            glClear (GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

        /*
         * Draw original image
         */
            glViewport (0,0,width,height);
            glPixelZoom(.5,.5);
            glDrawPixels(img.getWidth(), img.getHeight(), GL_RGB, GL_UNSIGNED_BYTE, &img.photo[0][0]);
            printBitmapString("Original Image", bitbuff.getHDC());
            glPixelZoom(2,2);

        /*
         * Draw voxel-cube version
         */
            glViewport (width,0,width,height);
            drawFromImagePerspective(false, curImage);
            printBitmapString("Voxel-cubes", bitbuff.getHDC());

        /*
         * Draw smooth version
         */
            glViewport (width*2,0,width,height);
            drawFromImagePerspective(true, curImage);
            printBitmapString("Polygonized with Marching Cubes", bitbuff.getHDC());

            glFinish();
            bitbuff.saveAs (fmtString("%s\\snapshot%.4d.ppm", directoryName, curImage));

        bitbuff.unselect();
        curImage++;
    }
}

Vertex Scanner::guessVoxelcubeCenter ()
{
    Vertex center(0,0,0);
    ViewpointList::iterator view_iter;
    for (view_iter = images.begin(); view_iter != images.end(); view_iter++)
    {
        Viewpoint &view = *view_iter;
        center = center + view.getLookatPoint();
    }

    return center / (double)images.size();
}

void Scanner::loadImages (const char *filename, int defaultVoxelsPerSide, float defaultVoxelCubeSize)
{
    doProgressUpdate(true, 0., "Loading files");
    images.loadFromFile (filename);
    mesh.clear();
}


bool Scanner::hasSilhouettes() const
{     
    ViewpointList::const_iterator view_iter;
    for (view_iter = images.begin(); view_iter != images.end(); view_iter++)
    {
        const Viewpoint &view = *view_iter;
        if (view.hasSilhouette())
            return true;
    }

    return false;
}

---