writePpm/main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Program that writes a PPM file, given the raw data in text form on stdin.
 */

// includes --------------------------------------------------------------------
#include <fstream>

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "pgmppm/pgmppm.h"
#include "util/parsing.h"



////////////////////////////////////////////////////////////////////////////////
///
/// \ingroup wave_tool
/// \defgroup tool_write_ppm writePpm
///
/// Simple command-line tool to write PPM files.
////////////////////////////////////////////////////////////////////////////////


// statics and typedefs --------------------------------------------------------
struct context_t {
        context_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        width = 0;
                        height = 0;
                        array = NULL;
                }

        // data fields
        int                     width;
        int                     height;
        pgmppm::color_t *       array;
};



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

static pgmppm::color_t
getPixel
(
IN void * context,
IN int x,
IN int y
)
{
        context_t * ctx = (context_t *) context;
        ASSERT(ctx, "null");
        ASSERT(ctx->array, "null");
        ASSERT(x >= 0 && x < ctx->width, "bad x: %d", x);
        ASSERT(y >= 0 && y < ctx->height, "bad y: %d", y);

        int idx = (y * ctx->width) + x;
        return ctx->array[idx];
}



static void
writePpm
(
IO std::istream& stream,
IN const char * filename
)
{
        ASSERT(stream.good(), "bad?");
        ASSERT(filename, "null");

        // in general, strip out comments and bogus characters (see parsing.h)
        eParseBehavior parseFlags = eParse_Strip;

        // parse PPM data from input stream
        std::string line = getNextLineFromStream(stream, parseFlags);
        std::string token;

        // first line: width and height
        dictionary_t dict;
        getDictionaryFromString(line.c_str(), "first line of PPM input", dict);
        int width = atoi(getRequiredValue(dict, "width"));
        int height = atoi(getRequiredValue(dict, "height"));
        if (width < 2 || height < 2) {
                WAVE_EX(wex);
                wex << "Bad width or height: " << width << " x " << height;
        }

        // allocate memory for gray values
        context_t ctx;
        ctx.width = width;
        ctx.height = height;
        ctx.array = new pgmppm::color_t[width * height];
        ASSERT(ctx.array, "out of memory");

        // now parse xy values
        int max_color = 255;            // hard-coded
        pgmppm::color_t * p = ctx.array;
        int expectX = 0;
        int expectY = 0;
        while (!stream.eof()) {
                line = getNextLineFromStream(stream, parseFlags);
                //DPRINTF("line: %s", line.c_str());
                getDictionaryFromString(line.c_str(), "PPM data line", dict);
                int x = atoi(getRequiredValue(dict, "x"));
                int y = atoi(getRequiredValue(dict, "y"));
                int r = atoi(getRequiredValue(dict, "r"));
                int g = atoi(getRequiredValue(dict, "g"));
                int b = atoi(getRequiredValue(dict, "b"));

                if (x != expectX || y != expectY) {
                        WAVE_EX(wex);
                        wex << "unexpected or out of order x,y values?\n";
                        wex << "  expected: (" << expectX << ", " << expectY << ")\n";
                        wex << "  read: (" << x << ", " << y << ")";
                }
                if (r < 0 || r > max_color ||
                    g < 0 || g > max_color ||
                    b < 0 || b > max_color) {
                        WAVE_EX(wex);
                        wex << "invalid color value:\n";
                        wex << "  red  : " << r << "\n";
                        wex << "  green: " << g << "\n";
                        wex << "  blue : " << b << "\n";
                }

                pgmppm::color_t c;
                c.red = r;
                c.blue = b;
                c.green = g;
                *p = c;
                ++p;

                ++expectX;
                if (expectX >= width) {
                        expectX = 0;
                        ++expectY;
                }

                if (expectY >= height) {
                        break;
                }
        }

        // write PPM file
        std::ofstream outfile(filename);
        if (!outfile.good()) {
                WAVE_EX(wex);
                wex << "Failed to open file for writing: " << filename;
        }
        pgmppm::writePpm(outfile, width, height, max_color, getPixel,
            (void *) &ctx);
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "usage: writePpm <ppm-filename>");
        const char * filename = argv[1];

        int retval = 0;

        try {
                perf::Timer timer("overall timer");
                writePpm(std::cin, filename);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                retval = 1;
        }

        // dump timers and leave
        perf::dumpTimingSummary(std::cerr);
        return retval;
}