root/pngdiff/cpp/pngdiff.cpp @ 488

// Copyright (c) 2009 Ben Karel. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE.txt file or at http://eschew.org/txt/bsd.txt

#include <png++/png.hpp>
#include <vector>
using namespace std;
typedef png::image<png::rgba_pixel> img;

#include <windows.h>
#include <boost/typeof/typeof.hpp>

void compute_histogram(img& a, int histout[4][256]) {
        int hist[4][256];
        png::rgba_pixel pa;
        const int nhistbytes = sizeof(int)*256*4;
        memset(hist, 0, nhistbytes);

        for (int j = 0; j < a.get_height(); ++j) {
                for (int i = 0; i < a.get_width(); ++i) {
                        pa = a[j][i];
                        hist[0][pa.red]++;
                        hist[1][pa.green]++;
                        hist[2][pa.blue]++;
                        hist[3][pa.alpha]++;
                }
        }
        memcpy(histout, hist, nhistbytes);
}

void compute_hists(img& a, img& b, int histdiffs[4][256]) {
        int hista[4][256];
        int histb[4][256];
        compute_histogram(a, hista);
        compute_histogram(b, histb);
}

void compute_mse(img& a, img& b, float* mses) {
        png::rgba_pixel pa, pb;
        for (int j = 0; j < a.get_height(); ++j) {
                int dr, dg, db, da;
                dr = dg = db = da = 0;
                std::vector<png::rgba_pixel>& aj = a[j];
                std::vector<png::rgba_pixel>& bj = b[j];
                for (int i = 0; i < a.get_width(); ++i) {
                        pa = aj[i];
                        pb = bj[i];
                        int x;
#define COMP_DIFF(comp, accum) \
        x = pa.comp - pb.comp; \
        accum += x*x
                        COMP_DIFF(red, dr);
                        COMP_DIFF(green, dg);
                        COMP_DIFF(blue, db);
                        COMP_DIFF(alpha, da);
#undef COMP_DIFF
                }
                mses[0] += dr;
                mses[1] += dg;
                mses[2] += db;
                mses[3] += da;
        }
        float npixels = a.get_width() * a.get_height();
        mses[0] /= npixels;
        mses[1] /= npixels;
        mses[2] /= npixels;
        mses[3] /= npixels;
}

struct CycleCounter {
        CycleCounter() {
                LARGE_INTEGER ifreq;
                QueryPerformanceFrequency(&ifreq);
                freq = double(ifreq.QuadPart);
                QueryPerformanceCounter(&start);
                last.QuadPart = start.QuadPart;
        }
        void split(const std::string& str) {
                LARGE_INTEGER now;      
                QueryPerformanceCounter(&now);
                double totalsecs = double(now.QuadPart - start.QuadPart) / freq;
                double lastsecs = double(now.QuadPart - last.QuadPart) / freq;

                std::cout << str << ": " << (lastsecs*1000)
                       << ", total: " << (totalsecs*1000) << std::endl;
                QueryPerformanceCounter(&last);
                start.QuadPart += (last.QuadPart - now.QuadPart) + 4;
        }
        LARGE_INTEGER start;
        LARGE_INTEGER last;
        double freq;
};

int main(int argc, char** argv) {
        if (argc < 3) {
                printf("Usage: %s <file1.png> <file2.png>\n", argv[0]);
                return 1;
        }
        CycleCounter cc;
        png::image<png::rgba_pixel> i1(argv[1]);
        png::image<png::rgba_pixel> i2(argv[2]);
        cc.split("image loading");

        float mses[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
        compute_mse(i1, i2, mses);
        cc.split("mses");

        bool verbose = true;
        if (verbose) printf("MSE:   ");
        printf("%f %f %f %f\n", mses[0], mses[1], mses[2], mses[3]);



        if (verbose) printf("dHIST: ");

        return 0;
}