lib/pgmppm/test/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2008  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test the pgmppm library.
 */

// includes --------------------------------------------------------------------
#include "common/common.h"

#include <fstream>
#include <math.h>

#include "pgmppm/pgmppm.h"


static int s_width                      = -1;
static int s_height                     = -1;

static const int s_maxGray              = 255;
static const int s_maxColor             = 255;

struct hc_entry_t {
        int             height;
        pgmppm::color_t color;
};


static const hc_entry_t s_hcolors[] = {
        {   0,          {   0,   0, 128 } },
        {  32,          {   0,   0, 255 } },
        {  64,          { 192, 160,   0 } },
        {  96,          {   0, 255,   0 } },
        { 160,          {   0, 128,   0 } },
        { 192,          { 116, 116, 116 } },
        { 256,          { 255, 255, 255 } },

        // must be last!
        {  -1,          {   0,   0,   0 } }
};



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static int
mix
(
IN int v1,
IN int v2,
IN float q
)
{
        ASSERT(v1 >= 0 && v1 <= s_maxColor, "Bad v1: %d", v1);
        ASSERT(v2 >= 0 && v2 <= s_maxColor, "Bad v2: %d", v2);
        ASSERT(q >= 0.0 && q <= 1.0, "Bad q: %f", q);

        float r = 1.0 - q;

        float f1 = r * v1;
        float f2 = q * v2;

        return (int) (f1 + f2 + 0.49);
}



static pgmppm::color_t
getColorForHeight
(
IN byte_t h             // height
)
{
        int idx = 0;
        for (int i = 1; ; ++i) {
                const hc_entry_t& e = s_hcolors[i];
                ASSERT(e.height >= 0, "bad input height?");
                if (e.height > h) {
                        idx = i;
                        break;
                }
        }
        ASSERT(idx > 0, "bad index: %d", idx);

        // get prev + next color entries
        const hc_entry_t& prev = s_hcolors[idx - 1];
        const hc_entry_t& next = s_hcolors[idx];

        int denom = next.height - prev.height;
        ASSERT(denom > 0, "Bad diff? denom = %d", denom);

        int dh = h - prev.height;
        ASSERT(dh >= 0, "Bad diff? dh = %d", dh);

        float q = (1.0 * dh) / (denom);

        pgmppm::color_t c;
        c.red = mix(prev.color.red, next.color.red, q);
        c.green = mix(prev.color.green, next.color.green, q);
        c.blue = mix(prev.color.blue , next.color.blue , q);

        return c;
}



static int
getHeight
(
IN void * context,
IN int x,
IN int y
)
{
        ASSERT(x >= 0 && x < s_width, "bad x: %d", x);
        ASSERT(y >= 0 && y < s_width, "bad y: %d", y);

        float fx = x - (0.5 * s_width);
        float fy = y - (0.5 * s_height);

        float z1 = sin(0.05 * fx);
        float z2 = sin(0.05 * fy);

        float z = 128 + 127.0 * z1 * z2;

        int iz = (int) z;
        return iz % (s_maxGray + 1);
}



static pgmppm::color_t
getColor
(
IN void * context,
IN int x,
IN int y
)
{
        int z = getHeight(context, x, y);

        // randomize height for color effects
        float mag = 8.0;
        float dz = (1.0 * rand()) / RAND_MAX;
        z += (int) (mag * (dz - 0.5));
        if (z < 0) {
                z = 0;
        }
        if (z > s_maxColor) {
                z = s_maxColor;
        }

        byte_t b = (byte_t) (z % (s_maxColor + 1));

        return getColorForHeight(b);
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(4 == argc,
            "Usage: test_pgm <dimension> <pgm_file> <ppm_file>");

        int dim = atoi(argv[1]);
        ASSERT(dim > 1, "bad dimension: %d", dim);
        s_width = dim;
        s_height = dim;
        const char * pgm_file = argv[2];
        const char * ppm_file = argv[3];

        std::ofstream opgm(pgm_file);
        ASSERT(opgm.good(), "Failed to open pgm file for writing: %s",
            pgm_file);
        pgmppm::writePgm(opgm, s_width, s_height, s_maxGray, getHeight, NULL);

        std::ofstream oppm(ppm_file);
        ASSERT(oppm.good(), "Failed to open ppm file for writing: %s",
            ppm_file);
        pgmppm::writePpm(oppm, s_width, s_height, s_maxColor, getColor, NULL);

        return 0;
}