canola-card-scanner/main.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011, 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/stdio.h>
#include <lib/ac/stdlib.h>
#include <lib/ac/string.h>
#include <lib/ac/unistd.h>
#include <libexplain/output.h>
#include <libexplain/program_name.h>

#include <lib/calculator/asm.h>
#include <lib/image.h>
#include <lib/image/invert.h>
#include <lib/image/monochrome.h>
#include <lib/image/threshold.h>
#include <lib/opcode.h>
#include <lib/polyfit.h>
#include <lib/print_version.h>
#include <lib/sizeof.h>


// #define FUZZY 1


static void
usage(void)
{
    const char *prog = explain_program_name_get();
    fprintf(stderr, "Usage: %s [ <option>... ] <card-image-file> "
        "<binary-code-file>\n", prog);
    fprintf(stderr, "       %s -V\n", prog);
    exit(1);
}


#ifdef FUZZY

static bool
is_black(const image::pointer &img, int x, int y)
{
    icon_pixel p;
    img->get_pixel(x, y, p);
    return (p.get_red_short() < 0x8000);
}

#endif


static bool
is_white(const image::pointer &img, int x, int y)
{
    icon_pixel p;
    img->get_pixel(x, y, p);
    return (p.get_red_short() >= 0x8000);
}


#ifdef FUZZY

static bool
hole_inner(const image::pointer &img, int x, int y, int hx, int hy)
{
    //           0 | 0 | 0      y + hy * 0.6
    //        -+---+---+---+
    //             |   |
    //             | 1 |        y + hy * 0.2
    //           0 | 1 | 0      y
    //             | 1 |        y - hy * 0.2
    //             |   |
    //        -+---+---+---+
    //           0 | 0 | 0      y - hy * 0.6
    //
    //           |   |   ^--- x + hx * 0.6
    //           |   `------- x
    //           `------------x - hx * 0.6
    icon_pixel p;

    int x1 = x - hx * 3/5;
    int x2 = x;
    int x3 = x + hx * 3/5;

    int y1 = y - hy * 7/10;
    int y2 = y - hy / 5;
    int y3 = y;
    int y4 = y + hy / 5;
    int y5 = y + hy * 7/10;

    return
        (
            is_black(img, x1, y1)
        &&
            is_black(img, x2, y1)
        &&
            is_black(img, x3, y1)
        &&
            is_white(img, x2, y2)
        &&
            is_black(img, x1, y3)
        &&
            is_white(img, x2, y3)
        &&
            is_black(img, x3, y3)
        &&
            is_white(img, x2, y4)
        &&
            is_black(img, x1, y5)
        &&
            is_black(img, x2, y5)
        &&
            is_black(img, x3, y5)
        );
}


static bool
hole_fuzzy(const image::pointer &img, int x, int y, int hx, int hy)
{
    for (int sdy = 1; sdy < hy; ++sdy)
    {
        int dy = (sdy >> 1) * ((sdy & 1) ? 1 : -1);
        for (int sdx = 1; sdx < hx; ++sdx)
        {
            int dx = (sdx >> 1) * ((sdx & 1) ? 1 : -1);
            if (hole_inner(img, x + dx, y + dy, hx, hy))
                return true;
        }
    }
    return false;
}

#endif

static bool invert;

static void
box(const image::pointer &img, int xlo, int ylo, int xhi, int yhi)
{
    icon_pixel green(0., 1., 0.);
    for (int x = xlo; x < xhi; ++x)
    {
        img->set_pixel(x, ylo, green);
        img->set_pixel(x, yhi, green);
    }
    for (int y = ylo; y < yhi; ++y)
    {
        img->set_pixel(xlo, y, green);
        img->set_pixel(xhi, y, green);
    }
}

static bool debug;

//
// Referencing http://www.quadibloc.com/comp/cardint.htm
//
// IBM card width 7.75 inch by 3.25 inch
// at 600dpi that would be 4650 (wider than our cards)
//                         1950 (higher than our cards)
// row pitch 0.25 inch @ 600dpi = 150 pixels which very close to the
// calculated row pitch of 151.666 pixels.
//
//                  13/150 = 0.08666... @600 dpi = 52.0
// column pitch is stated as 0.087 inch @600 dpi = 52.2 pixels which is
// very close to half of the calulated pitch of 104.641 pixels
// (alternatively 0.0885 @ 600 dpi = 53.1 compared to 104.641 (52.32) less good)
//
// vertical height of holes stated as 0.125 inch @ 600dpi = 75 pixels,
// horizontal width of holes not stated
//
// also 0.375 inch unpunched top and bottom @ 600dpi = 225 pixels
// which is significantly different than the 310 calculated.
//

static void
process_image(const char *filename, const calculator::pointer &data)
{
    // The ideal image is the card image measured to figure out where
    // the holes are.
    const int ideal_image_width = 4433;
    const int ideal_image_height = 1370;

    // open image.png as greyscale
    image::pointer img = image::create_from_file(filename);

    // verify proportions look right
    {
        double ratio = img->get_width() / (double)img->get_height();
        // We want approximately 4432x1375
        double want = (double)ideal_image_width / (double)ideal_image_height;
        if (ratio < want * 0.98 || ratio > want * 1.02)
        {
            explain_output_error_and_die
            (
                "%s: file has proportions %dx%d (%g:1) but was expecting %g:1",
                filename,
                img->get_width(),
                img->get_height(),
                ratio,
                want
            );
        }
    }

    // we only want gray
    img = image_monochrome::create(img);

    // threshold based on averages
    if (debug)
        fprintf(stderr, "averaging...\n");
    icon_pixel avg = img->average();

    img = image_threshold::create(img, (1. + avg.get_red()) / 2);

    if (invert)
        img = image_invert::create(img);

    // debug: write the image out so I can look at it
    if (debug)
    {
        fprintf(stderr, "writing debug1.png\n");
        {
            const char *fn2 = "debug1.png";
            image::pointer img2 =
                image::create_blank_from_file
                (
                    fn2,
                    img->get_width(),
                    img->get_height()
                );
            img2->copy(img);
            img2->save_to_file(fn2);
        }
    }

    double scale = img->get_width() / (double)ideal_image_width;
    if (debug)
        fprintf(stderr, "scale = %g\n", scale);

    // punched holes are 48x79
    // (1/12 inch x 1/8 inch = 50x75)
    // (2mm x 3.5mm = 47x83)
    int hx = 34 * scale + 0.5;
    int hy = 75 * scale + 0.5;

    // Get a bit smarter about detecting each row of holes.
    int row_centre[40];
    int nrows = 0;
    {
        int w = img->get_width();
        int h = img->get_height();
        int *pixel_column_total = new int [w];
        for (int x = 0; x < w; ++x)
        {
            int sum = 0;
            for (int y = 0; y < h; ++y)
            {
                if (is_white(img, x, y))
                {
                    ++sum;
                }
            }
            pixel_column_total[x] = (2 * sum > hy) ? sum : 0;
        }

        int x = 0;
        while (x < w)
        {
            while (x < w && pixel_column_total[x] == 0)
                ++x;
            // start of row
            int x2 = x + 1;
            while (x2 < w && pixel_column_total[x2] != 0)
                ++x2;
            int rw = x2 - x;
            if (2 * rw >= hx)
            {
                row_centre[nrows++] = (x + x2) / 2;
                if (debug)
                {
                    fprintf(stderr, "row%3d, at%5d,%3d pixels wide\n", nrows,
                        row_centre[nrows - 1], rw);
                }
            }
            x = x2;
        }
        delete [] pixel_column_total;
    }

    // now we look for each column of bits
    int col_centre[20];
    {
        int ncols = 0;
        int w = img->get_width();
        int h = img->get_height();
        int *pixel_row_total = new int [h];
        for (int y = 0; y < h; ++y)
        {
            if (y < 240 * scale || y >= 1285 * scale)
            {
                pixel_row_total[y] = 0;
                continue;
            }
            int sum = 0;
            // only scan the row centres, not the whole image
            for (int x = 0; x < w; ++x)
            {
                if (is_white(img, x, y))
                    ++sum;
            }
            pixel_row_total[y] = (2 * sum > hx) ? sum : 0;
        }

        int y = 0;
        while (y < h && ncols < (int)SIZEOF(col_centre))
        {
            while (y < h && pixel_row_total[y] == 0)
                ++y;
            // start of row
            int y2 = y + 1;
            while (y2 < h && pixel_row_total[y2] != 0)
                ++y2;
            int rh = y2 - y;
            if (2 * rh >= hy)
            {
                col_centre[ncols++] = (y + y2) / 2;
                if (debug)
                {
                    fprintf(stderr, "col %d, at %3d, %2d pixels high\n",
                        ncols - 1, col_centre[ncols - 1], rh);
                }
            }
            y = y2;
        }
        if (ncols == 1)
        {
            // assuming ~150 pixels between columns
            int c = (col_centre[0]/scale - 310 + 75) / 150;
            int offset = col_centre[0] - c * 150 * scale;
            for (int j = 0; j < 7; ++j)
                col_centre[j] = offset + j * 150 * scale;
            ncols = 7;
        }
        else if (ncols < 7)
        {
            // fit a line to the available data
            polyfit p(2);
            for (int j = 0; j < ncols; ++j)
            {
                int x = (col_centre[j]/scale - 310 + 75) / 150;
                int y = col_centre[j];
                p.enter(x, y);
            }
            if (p.solve() != polyfit::solve_ok)
                goto yuck;
            for (int j = 0; j < 7; ++j)
            {
                col_centre[j] = p.evaluate(j);
                if (debug)
                    fprintf(stderr, "col %d, at %3d\n", j, col_centre[j]);
            }
            ncols = 7;
        }
        if (ncols != 7)
        {
            yuck:
            fprintf(stderr, "found %d bit columns, expected 7\n", ncols);
            exit(1);
        }
        delete [] pixel_row_total;
    }
    // debug: write the image out so I can look at it
    image::pointer img2;
    if (debug)
    {
        fprintf(stderr, "write debug2.png\n");
        const char *fn2 = "debug2.png";
        img2 =
            image::create_blank_from_file
            (
                fn2,
                img->get_width(),
                img->get_height()
            );
        img2->copy(img);

        icon_pixel red(1., 0., 0.);
        unsigned dy = col_centre[1] - col_centre[0];
        unsigned ylo = col_centre[0] - dy / 2;
        unsigned yhi = col_centre[6] + dy / 2;
        for (int row = 0; row < 40 && row < nrows; ++row)
        {
            // int x = scale * (203 + 104.641025641 * row);
            // int x = scale * (203 + 104 * row);
            unsigned x = row_centre[row];
            for (unsigned y = ylo; y < yhi; ++y)
                if (!is_white(img2, x, y))
                    img2->set_pixel(x, y, red);
        }
        unsigned dx = (nrows > 1 ? row_centre[1] - row_centre[0] : 104*scale);
        unsigned xlo = row_centre[0] - dx / 2;
        unsigned xhi = row_centre[nrows - 1] + dx / 2;
        for (int col = 6; col >= 0; --col)
        {
            // int y = scale * (310 + 151.666666667 * col);
            // int y = scale * (310 + 150 * col);
            int y = col_centre[col];
            for (unsigned x = xlo; x < xhi; ++x)
                if (!is_white(img2, x, y))
                    img2->set_pixel(x, y, red);
        }
        img2->save_to_file(fn2);
    }

    // interpret holes as data
    bool something = false;
    data->program_mode_set(calculator::program_mode_learn);
    for (int row = 0; row < 40 && row < nrows; ++row)
    {
        // int x = scale * (203 + 104.641025641 * row);
        // int x = scale * (203 + 104 * row);
        int x = row_centre[row];
        int code = 0;
        for (int col = 6; col >= 0; --col)
        {
            // int y = scale * (310 + 151.666666667 * col);
            // int y = scale * (310 + 150 * col);
            int y = col_centre[col];
#ifdef FUZZY
            if (hole_fuzzy(img, x, y, hx, hy))
#else
            if (is_white(img, x, y))
#endif
            {
                code |= 1 << col;
                if (debug)
                    box(img2, x - 7, y - 10, x + 7, y + 10);
            }
        }
        if (code != 0 && code != 0x7F)
        {
            data->on_opcode_lrn(opcode_t(code), location::pointer());
            something = true;
        }
    }

    if (!something)
        explain_output_error_and_die("%s: could not find any data", filename);
    if (debug)
    {
        fprintf(stderr, "writing debug3.png\n");
        img2->save_to_file("debug3.png");
    }
}


int
main(int argc, char **argv)
{
    bool binary = false;
    for (;;)
    {
        int c = getopt(argc, argv, "bdiV");
        if (c == EOF)
            break;
        switch (c)
        {
        case 'b':
            binary = true;
            break;

        case 'd':
            debug = true;
            break;

        case 'i':
            invert = true;
            break;

        case 'V':
            print_version();
            return 0;

        default:
            usage();
        }
    }
    if (optind + 2 != argc)
        usage();
    const char *input_file_name = argv[optind];
    const char *output_file_name = argv[optind + 1];

    // read the data on the card
    calculator::pointer data = calculator_asm::create();
    process_image(input_file_name, data);

    // write the code out.
    data->save_program_as(output_file_name, binary);

    return 0;
}