source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/histogram.cpp @ 983

#include <stdio.h>
#include <stdlib.h>

#include "../include/GL/glew.h"
#ifdef _WIN32
#include "../include/GL/wglew.h"
#endif
#include "../include/global.h"
#include "../include/histogram.h"
#include "../include/metrics.h"

using namespace VMI;

void VMI::printHistogram(GLuint histoGram[][4]) {
    int i;
   
    printf("\n");
    for (i=0; i<HISTOGRAM_SIZE; i++) {
        printf("H: %d RGBA(%d, %d, %d, %d)\n",i, histoGram[i][0], histoGram[i][1], histoGram[i][2], histoGram[i][3]);
    }
}

void VMI::plotHistogram(GLuint histoGram[][4]) {
    int i;
    GLuint iLargest = 0;  // Largest histogram value
    GLfloat maxHeight = height / 2.0f;
        
    setOrthographicProjection();
    
    // Find largest value for scaling graph down
    for (i=0; i<HISTOGRAM_SIZE; i++) {
        if(iLargest < histoGram[i][0])
            iLargest = histoGram[i][0];
        if(iLargest < histoGram[i][1])
            iLargest = histoGram[i][1];
        if(iLargest < histoGram[i][2])
            iLargest = histoGram[i][2];
        if(iLargest < histoGram[i][3])
            iLargest = histoGram[i][3];
    }
    printf("%d\n", iLargest);
    glBegin(GL_LINE_STRIP);
    glColor3f(1.0f, 0.0f, 0.0f);
    for (i=0; i < HISTOGRAM_SIZE; i++)
        //glVertex2s(i, histoGram[i][0]);
        glVertex2f((GLfloat)i, ((GLfloat)histoGram[i][0] / maxHeight) * maxHeight); 
    glEnd();
    
    glBegin(GL_LINE_STRIP);
    glColor3f(0.0f, 1.0f, 0.0f);
    for (i=0; i < HISTOGRAM_SIZE; i++)
        //glVertex2s(i, histoGram[i][1]);
        glVertex2f((GLfloat)i, ((GLfloat)histoGram[i][0] / maxHeight) * maxHeight); 
    glEnd();
    
    glBegin(GL_LINE_STRIP);
    glColor3f(0.0f, 0.0f, 1.0f);
    for (i=0; i < HISTOGRAM_SIZE; i++)
        //glVertex2s(i, histoGram[i][2]);
        glVertex2f((GLfloat)i, ((GLfloat)histoGram[i][0] / maxHeight) * maxHeight); 
    glEnd();
    glBegin(GL_LINE_STRIP);
    glColor3f(0.5f, 0.5f, 0.5f); // Grey color represents the alpha channel
    for (i=0; i < HISTOGRAM_SIZE; i++)
        //glVertex2s(i, histoGram[i][3]);
        glVertex2f((GLfloat)i, ((GLfloat)histoGram[i][0] / maxHeight) * maxHeight); 
    glEnd();
    
    resetPerspectiveProjection();
}

GLuint **VMI::initHistogram(GLuint numTriangles, GLuint numCameras) {
    GLuint i;
    GLuint **histogram;

    histogram = (GLuint **)malloc(sizeof(GLuint *) * numCameras);

    if (histogram == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }

    for (i=0; i<numCameras; i++)
    histogram[i] = (GLuint *)malloc(sizeof(GLuint) * (numTriangles + 1)); // + 1 because the last is the numPixels of the background

    // Fill the histogram buffer with 0
    for (i=0; i<numCameras; i++)
    memset(histogram[i], 0, sizeof(GLuint) * (numTriangles + 1));

    return histogram;
}

void VMI::deleteHistogram(GLuint **histogram, GLuint numCameras) {
    GLuint i;
    
    for (i=0;i<numCameras;i++)
        if (histogram[i] != NULL) free(histogram[i]);
        
    free(histogram);
}

void VMI::printFullHistogram(GLuint **histogram, GLuint numCameras, GLuint numTriangles) {
    GLuint i, j;
    
    printf("\n");
    for (i=0; i<numCameras; i++) {
        printf("c%d [t%d(%d) ", i, 0, histogram[i][0]);
        for (j=1; j<=numTriangles; j++) {
            printf(",t%d(%d) ", j, histogram[i][j]);
        }
        printf("]\n");
    }
    printf("Total image area: %d\n", width * height);
}

void VMI::getSubHistogram(GLuint subHistoGram[][4]) {
    //printf("Computing histogram...\n");
    // Define the histogram
    
    glEnable(GL_HISTOGRAM);
    //glEnable(GL_TEXTURE_2D);
    glHistogram(GL_HISTOGRAM, HISTOGRAM_SIZE, GL_RGBA, GL_TRUE);

    // Perform a pixel operation
    glCopyPixels(0, 0, width, height, GL_COLOR);

    // Get the histogram
    glGetHistogram(GL_HISTOGRAM, GL_FALSE, GL_RGBA, GL_UNSIGNED_INT, subHistoGram);
    glResetHistogram(GL_HISTOGRAM);
    glDisable(GL_HISTOGRAM);
    //glDisable(GL_TEXTURE_2D);
    
    //printHistogram(subHistoGram);
    //plotHistogram(subHistoGram);
}

void VMI::copySubHistogram(Color *colors, GLuint *histogram, GLuint begin, GLuint end, GLuint subHistoGram[][4]) {
    GLuint i;
    GLubyte r, g, b, a;
    GLuint h = 0;

    for (i=begin; i<end; i++) {

        r = colors[i].r;
        g = colors[i].g;
        b = colors[i].b;
        a = colors[i].a;

        if (r != 0) 
            h = subHistoGram[r][0];
        
        if (g != 0) 
            h = subHistoGram[g][1];
        
        if (b != 0) 
            h = subHistoGram[b][2];
        
        if (a != 0) 
            h = subHistoGram[a][3];

        histogram[i] = h;
    }
}

void VMI::getSWHistogram(GLuint *histogram, GLubyte *pixels) {
    GLubyte r, g, b, a;
    GLuint i, t, p, numPixels = width * height;

    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

    for (i=0; i<numPixels; i++) { // pixel i
        p = i << 2; // 4 * i
        r = pixels[p];
        g = pixels[p + 1];
        b = pixels[p + 2];
        a = pixels[p + 3];

        t = r + (g << 8) + (b << 16) + (a << 24); // triangle color

        //printf("pixel:%d (%d,%d,%d,%d) t %d\n", i, r, g, b, a, t);

        histogram[t]++;   
    }
    //getchar();
}

void VMI::getSWHistoByOcclusionQuery(Mesh *mesh, Color *colors, GLuint *histogram) {
    GLuint i, v1, v2, v3;
    GLint area;

    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    glDepthMask(GL_FALSE);
    
    for (i=0; i<mesh->numTriangles; i++) { // For every triangle
        if (mesh->triangles[i].enable == TRUE) {
            glBeginQueryARB(GL_SAMPLES_PASSED_ARB, queries[i]);
            
            // Render triangle i
            glBegin(GL_TRIANGLES);
            v1= mesh->triangles[i].indices[0];
            v2= mesh->triangles[i].indices[1];
            v3= mesh->triangles[i].indices[2];
            
            glColor4ub(colors[i].r, colors[i].g, colors[i].b, colors[i].a);
            
            glVertex3f(mesh->vertices[v1].x, mesh->vertices[v1].y, mesh->vertices[v1].z);
            glVertex3f(mesh->vertices[v2].x, mesh->vertices[v2].y, mesh->vertices[v2].z);
            glVertex3f(mesh->vertices[v3].x, mesh->vertices[v3].y, mesh->vertices[v3].z);
            glEnd();
            
            glEndQueryARB(GL_SAMPLES_PASSED_ARB);
        }
    }
    glFlush();

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    glDepthMask(GL_TRUE);

    for (i=0; i<mesh->numTriangles; i++) { // For every triangle
        if (mesh->triangles[i].enable == TRUE) {
            glGetQueryObjectivARB(queries[i], GL_QUERY_RESULT_ARB, &area);
            
            if (area <  0) {
                printf("    t:%d a:%d\n", i, histogram[i + 1]);
                histogram[i + 1] = 0;
            } else {
                histogram[i + 1] = area;
            }
        }
    }
    histogram[0] = computeBackgroundArea(mesh, histogram); // Compute area of the background

}

void VMI::resetSWHistogram(GLuint *histogram, GLuint numTriangles) {

    // Fill the histogram buffer with 0
    memset(histogram, 0, sizeof(GLuint) * (numTriangles + 1));
}