/***************************************************************************

 * Copyright (c) 2009 Enrico Ros                                           *

 *         2009 Enrico Ros <enrico.ros@email.it>                           *

 *         2009 Alberto Scarpa <skaal.sl@gmail.com>                        *

 *                                                                         *

 * Permission is hereby granted, free of charge, to any person             *

 * obtaining a copy of this software and associated documentation          *

 * files (the "Software"), to deal in the Software without                 *

 * restriction, including without limitation the rights to use,            *

 * copy, modify, merge, publish, distribute, sublicense, and/or sell       *

 * copies of the Software, and to permit persons to whom the               *

 * Software is furnished to do so, subject to the following                *

 * conditions:                                                             *

 *                                                                         *

 * The above copyright notice and this permission notice shall be          *

 * included in all copies or substantial portions of the Software.         *

 *                                                                         *

 ***************************************************************************/

#include "Ocr.h"

#include <QFontMetrics>

#include <QPainter>

#include <QBitmap>

#include <QTransform>

#include <QPixmap>

#include <math.h>

#include <QDebug>

#include <QLabel>

struct OcrGlyph {

    QChar character;

    QImage image;

    int width;

    int height;

    double ratio;

    // ADD more and more properties ...

};

// CORE FUNCTIONS

static QImage trimImage( const QImage & image )

{

    // find TOP

    int W = image.width();

    int H = image.height();

    int left = 0, top = 0, right = W - 1, bottom = H - 1;

    // find -left- margin

    bool blank = true;

    while ( blank && left < W ) {

        for ( int y = 0; y < H; y++ ) {

            if ( qGray( image.pixel( left, y ) ) < 32 ) {

                blank = false;

                break;

            }

        }

        if ( blank )

            left++;

    }

    // find -top- margin

    blank = true;

    while ( blank && top < H ) {

        for ( int x = 0; x < W; x++ ) {

            if ( qGray( image.pixel( x, top ) ) < 32 ) {

                blank = false;

                break;

            }

        }

        if ( blank )

            top++;

    }

    // find -right- margin

    blank = true;

    while ( blank && right >= 0 ) {

        for ( int y = 0; y < H; y++ ) {

            if ( qGray( image.pixel( right, y ) ) < 32 ) {

                blank = false;

                break;

            }

        }

        if ( blank )

            right--;

    }

    // find -bottom- margin

    blank = true;

    while ( blank && bottom >= 0 ) {

        for ( int x = 0; x < W; x++ ) {

            if ( qGray( image.pixel( x, bottom ) ) < 32 ) {

                blank = false;

                break;

            }

        }

        if ( blank )

            bottom--;

    }

    // ok: return cropped image

    W = right - left + 1;

    H = bottom - top + 1;

    if ( W > 0 && H > 0 )

        return image.copy( left, top, W, H );

    // invalid: return the same image

    qWarning( "trimImage: invalid image of size %dx%d", image.width(), image.height() );

    return image;

}

static OcrResult compareGlyph( const QImage & image, OcrGlyph * glyph )

{

    OcrResult result;

    result.character = glyph->character;

    result.confidence = 0.0;

    // bail out if ratios are too different

    double ratio = (float)image.width() / (float)image.height();

    double k2 = (ratio / glyph->ratio + glyph->ratio / ratio) / 2;

    if ( k2 > 1.5 )

        return result;

    // ALGO

    // scale glyph image size to image size

#if 0

    QTransform t;

    t.scale( (float)glyph->image.width() / (float)image.width(), (float)glyph->image.height() / (float)image.height() );

    QImage glyphImage = glyph->image.transformed( t.inverted(0), Qt::SmoothTransformation );

#endif

    QImage glyphImage = glyph->image.scaled( image.width(), image.height() );

    int width = glyphImage.width();

    int height = glyphImage.height();

    //int pixels = width * height;

    unsigned int error = 0;

    unsigned int analyzed = 0;

    for ( int y = 0; y < height; y++ ) {

        for ( int x = 0; x < width; x++ ) {

            int v1 = qGray( image.pixel( x, y ) );

            int v2 = qGray( glyphImage.pixel( x, y ) );

            if ( v1 >= 254 && v2 >= 254 )

                continue;

            analyzed++;

            int diff = (v1 > v2 ? v1 - v2 : v2 - v1);

            error += (diff * diff) >> 8;

        }

    }

    if ( !analyzed )

        return result;

    float KX = sqrt( (float)error / (254.0 * (float)analyzed) );

#if 0

    if ( glyph->character == 'R' ) {

        QLabel * label = new QLabel();

        label->setPixmap( QPixmap::fromImage( image ) );

        label->show();

        label = new QLabel();

        label->setPixmap( QPixmap::fromImage( glyphImage ) );

        label->show();

    }

#endif

    result.confidence = 1.0 - KX;

    //qWarning() << result.confidence << result.character << pixels << analyzed;

    return result;

}

Ocr::Ocr()

{

}

Ocr::~Ocr()

{

    clearTraning();

}

void Ocr::trainFont( const QFont & font, QFontDatabase::WritingSystem writingSystem )

{

    // checks

    if ( writingSystem != QFontDatabase::Latin ) {

        qWarning( "Ocr::trainFont: unsupported writing system" );

        return;

    }

    // add chars

    QList<QChar> chars;

    // symbols !"#$%&'()*+,-./

    //for ( int i = 33; i <= 47; i++ )

    //    chars.append( QChar( i ) );

    // numbers

    //for ( int i = 48; i <= 57; i++ )

    //    chars.append( QChar( i ) );

    // symbols :;<=>?@

    //for ( int i = 58; i <= 64; i++ )

    //    chars.append( QChar( i ) );

    // uppercase letters

    for ( int i = 65; i <= 90; i++ )

        chars.append( QChar( i ) );

    // symbols [\]^_`

    //for ( int i = 91; i <= 96; i++ )

    //    chars.append( QChar( i ) );

    // lowercase letters

    //for ( int i = 97; i <= 122; i++ )

    //    chars.append( QChar( i ) );

    // symbols {|}~

    //for ( int i = 123; i <= 126; i++ )

    //    chars.append( QChar( i ) );

    // generate glyphs for Latin1 and train the system

    QFontMetrics metrics( font );

    foreach ( const QChar & character, chars ) {

        QRect rect = metrics.boundingRect( character ).adjusted( -5, -5, 5, 5 );

        if ( !rect.isValid() ) {

            qWarning( "Ocr::trainFont: invalid rect for font" );

            continue;

        }

        // draw glyph

        QImage image( rect.width(), rect.height(), QImage::Format_ARGB32 );

        image.fill( 0xFFFFFFFF );

        QPainter imgPainter( &image );

        imgPainter.setFont( font );

        imgPainter.setPen( Qt::black );

        imgPainter.drawText( 0, 0, rect.width(), rect.height(), Qt::AlignCenter, character );

        imgPainter.end();

        // recognize glyph

        trainGlyph( image, character );

    }

}

void Ocr::trainGlyph( const QImage & sourceImage, const QChar & character )

{

#if 0

    QLabel * label = new QLabel();

    label->setPixmap( QPixmap::fromImage( sourceImage ) );

    label->setWindowTitle( character );

    label->show();

#endif

    // checks

    if ( sourceImage.isNull() || sourceImage.width() < 4 || sourceImage.height() < 4 || character.isNull() ) {

        qWarning( "Ocr::trainGlyph: invalid input" );

        return;

    }

    // prepare image for processing

    QImage image = trimImage( sourceImage );

    // append glyph description

    OcrGlyph * glyph = new OcrGlyph();

    glyph->character = character;

    glyph->image = image;

    glyph->width = image.width();

    glyph->height = image.height();

    glyph->ratio = (float)image.width() / (float)image.height();

    m_glyphs.append( glyph );

}

void Ocr::clearTraning()

{

    qDeleteAll( m_glyphs );

    m_glyphs.clear();

}

OcrResult Ocr::recognizeGlyph( const QImage & sourceImage, const QRect & __rect ) const

{

    // checks

    OcrResult result;

    result.character = '?'; // FIXME: REMOVE THIS

    result.confidence = 0.0;

    if ( sourceImage.isNull() )

        return result;

    // prepare image for processing

    QRect rect = __rect.isValid() ? __rect : QRect( 0, 0, sourceImage.width(), sourceImage.height() );

    QImage image = trimImage( sourceImage.copy( rect ) );

    // match all glyphs

    foreach ( OcrGlyph * glyph, m_glyphs ) {

        OcrResult comparison = compareGlyph( image, glyph );

        if ( comparison.confidence > result.confidence ) {

            result.character = comparison.character;

            result.confidence = comparison.confidence;

        }

    }

    // done!

    return result;

}