//
// Created by Matthew on 2024/1/4.
//
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_OUTLINE_H
#include FT_STROKER_H
#include FT_IMAGE_H
#include FT_BBOX_H

#include <locale>
#include <codecvt>
#include "CvText.h"
#include <opencv2/imgproc.hpp>

namespace cv {
namespace ft {

    using namespace std;

    class FreeType2Impl : public FreeType2
    {
        public:
        FreeType2Impl();
        ~FreeType2Impl();
        void loadFontData(String fontFileName, int idx);
        void setSplitNumber( int num );
        void putText(
                InputOutputArray img, const String& text, Point org,
                int fontHeight, Scalar color,
                int thickness, int line_type, bool bottomLeftOrigin
        );
        Size getTextSize(
                const String& text, int fontHeight, int thickness,
                CV_OUT int* baseLine
        );

        private:
        FT_Library       mLibrary;
        FT_Face          mFace;
        FT_Outline_Funcs mFn;

        bool             mIsFaceAvailable;
        int              mCtoL;

        void putTextBitmapMono(
                InputOutputArray img, const String& text, Point org,
                int fontHeight, Scalar color,
                int thickness, int line_type, bool bottomLeftOrigin
        );

        void putTextBitmapBlend(
                InputOutputArray img, const String& text, Point org,
                int fontHeight, Scalar color,
                int thickness, int line_type, bool bottomLeftOrigin
        );

        void putTextOutline(
                InputOutputArray img, const String& text, Point org,
                int fontHeight, Scalar color,
                int thickness, int line_type, bool bottomLeftOrigin
        );

        typedef void (putPixel_mono_fn)( Mat& _dst, const int _py, const int _px, const uint8_t *_col);
        putPixel_mono_fn putPixel_8UC1_mono;
        putPixel_mono_fn putPixel_8UC3_mono;
        putPixel_mono_fn putPixel_8UC4_mono;

        typedef void (putPixel_blend_fn)( Mat& _dst, const int _py, const int _px, const uint8_t *_col, const uint8_t alpha);
        putPixel_blend_fn putPixel_8UC1_blend;
        putPixel_blend_fn putPixel_8UC3_blend;
        putPixel_blend_fn putPixel_8UC4_blend;

        static int mvFn( const FT_Vector *to, void * user);
        static int lnFn( const FT_Vector *to, void * user);
        static int coFn( const FT_Vector *cnt,
                         const FT_Vector *to,
                         void * user);
        static int cuFn( const FT_Vector *cnt1,
                         const FT_Vector *cnt2,
                         const FT_Vector *to,
                         void * user);

        /**
         * Convert from FT_F26Dot6 to int(coodinate of OpenCV)
         * (FT_F26Dot6 is signed 26.6 real)
         */
        static int ftd(FT_F26Dot6 fixedInt){
            if ( fixedInt > 0 ) {
                return ( fixedInt + 32 ) / 64 ;
            }else{
                return ( fixedInt - 32 ) / 64 ;
            }
        }

        class PathUserData{
        private:
        public:
            PathUserData( InputOutputArray _img) : mImg(_img) {};

            InputOutputArray mImg;
            Scalar mColor;
            int    mThickness;
            int    mLine_type;
            FT_Vector        mOldP;
            int              mCtoL;
            std::vector < Point > mPts;
        };
    };

    FreeType2Impl::FreeType2Impl()
    {
        FT_Init_FreeType(&(this->mLibrary) );

        mCtoL        = 16;
        mFn.shift    = 0;
        mFn.delta    = 0;
        mFn.move_to  = FreeType2Impl::mvFn;
        mFn.line_to  = FreeType2Impl::lnFn;
        mFn.cubic_to = FreeType2Impl::cuFn;
        mFn.conic_to = FreeType2Impl::coFn;

        mIsFaceAvailable = false;
    }

    FreeType2Impl::~FreeType2Impl()
    {
        if( mIsFaceAvailable  == true )
        {
#if 0
            hb_font_destroy (mHb_font);
#endif
            CV_Assert(!FT_Done_Face(mFace));
            mIsFaceAvailable = false;
        }
        CV_Assert(!FT_Done_FreeType(mLibrary));
    }

    void FreeType2Impl::loadFontData(String fontFileName, int idx)
    {
        CV_Assert( idx >= 0 );
        if( mIsFaceAvailable  == true )
        {
#if 0
            hb_font_destroy (mHb_font);
#endif
            CV_Assert(!FT_Done_Face(mFace));
        }

        mIsFaceAvailable = false;
        CV_Assert( !FT_New_Face( mLibrary, fontFileName.c_str(), static_cast<FT_Long>(idx), &(mFace) ) );

#if 0
        mHb_font = hb_ft_font_create (mFace, NULL);
        if ( mHb_font == NULL )
        {
            CV_Assert(!FT_Done_Face(mFace));
            return;
        }
        CV_Assert( mHb_font != NULL );
#endif
        mIsFaceAvailable = true;
    }

    void FreeType2Impl::setSplitNumber(int num ){
        CV_Assert( num > 0 );
        mCtoL        = num;
    }

    void FreeType2Impl::putText(
            InputOutputArray _img, const String& _text, Point _org,
            int _fontHeight, Scalar _color,
            int _thickness, int _line_type, bool _bottomLeftOrigin
    )
    {
        CV_Assert  ( mIsFaceAvailable == true );
        CV_Assert  ( _img.empty()    == false );
        CV_Assert  ( _img.isMat()    == true  );
        CV_Assert  ( _img.dims()     == 2     );
        CV_Assert( ( _img.type()     == CV_8UC1 ) ||
                   ( _img.type()     == CV_8UC3 ) ||
                   ( _img.type()     == CV_8UC4 ) );
        CV_Assert( ( _line_type == LINE_AA) ||
                   ( _line_type == LINE_4 ) ||
                   ( _line_type == LINE_8 ) );
        CV_Assert  ( _fontHeight >= 0 );

        if ( _text.empty() )
        {
            return;
        }
        if ( _fontHeight == 0 )
        {
            return;
        }

        CV_Assert(!FT_Set_Pixel_Sizes( mFace, _fontHeight, _fontHeight ));

        if( _thickness < 0 ) // CV_FILLED
        {
            if ( _line_type == LINE_AA ) {
                putTextBitmapBlend( _img, _text, _org, _fontHeight, _color,
                                    _thickness, _line_type, _bottomLeftOrigin );
            }else{
                putTextBitmapMono( _img, _text, _org, _fontHeight, _color,
                                   _thickness, _line_type, _bottomLeftOrigin );
            }
        }else{
            putTextOutline( _img, _text, _org, _fontHeight, _color,
                            _thickness, _line_type, _bottomLeftOrigin );
        }
    }

    void FreeType2Impl::putTextOutline(
            InputOutputArray _img, const String& _text, Point _org,
            int _fontHeight, Scalar _color,
            int _thickness, int _line_type, bool _bottomLeftOrigin )
    {
#if 0
        hb_buffer_t *hb_buffer = hb_buffer_create ();
        CV_Assert( hb_buffer != NULL );

        hb_buffer_add_utf8 (hb_buffer, _text.c_str(), -1, 0, -1);
        hb_buffer_guess_segment_properties (hb_buffer);
        hb_shape (mHb_font, hb_buffer, NULL, 0);

        unsigned int textLen = 0;
        hb_glyph_info_t *info =
                hb_buffer_get_glyph_infos(hb_buffer,&textLen );
        CV_Assert( info != NULL );
#else
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        wstring wstr = converter.from_bytes(_text);
#endif

        PathUserData *userData = new PathUserData( _img );
        userData->mColor     = _color;
        userData->mCtoL      = mCtoL;
        userData->mThickness = _thickness;
        userData->mLine_type = _line_type;

        // Initilize currentPosition ( in FreeType coordinates)
        FT_Vector currentPos = {0,0};
        currentPos.x = _org.x * 64;
        currentPos.y = _org.y * 64;

        // Update currentPosition with bottomLeftOrigin ( in FreeType coordinates)
        if( _bottomLeftOrigin != true ){
            currentPos.y += _fontHeight * 64;
        }

#if defined(USING_HB)
        for( unsigned int i = 0 ; i < textLen ; i ++ ){
            CV_Assert( !FT_Load_Glyph(mFace, info[i].codepoint, 0 ) );
#else
        for( unsigned int i = 0 ; i < wstr.size() ; i ++ ){
			CV_Assert(!FT_Load_Glyph(mFace, FT_Get_Char_Index(mFace, wstr[i]), 0 ));
#endif
            FT_GlyphSlot slot  = mFace->glyph;
            FT_Outline outline = slot->outline;

            // Flip ( in FreeType coordinates )
            FT_Matrix mtx = { 1 << 16 , 0 , 0 , -(1 << 16) };
            FT_Outline_Transform(&outline, &mtx);

            // Move to current position ( in FreeType coordinates )
            FT_Outline_Translate(&outline,
                                 currentPos.x,
                                 currentPos.y);

            // Draw ( in FreeType coordinates )
            CV_Assert( !FT_Outline_Decompose(&outline, &mFn, (void*)userData) );

            // Draw (Last Path) ( in FreeType coordinates )
            mvFn( NULL, (void*)userData );

            // Update current position ( in FreeType coordinates )
            currentPos.x += mFace->glyph->advance.x;
            currentPos.y += mFace->glyph->advance.y;
        }
        delete userData;
#if defined(USING_HB)
        hb_buffer_destroy (hb_buffer);
#endif 0
    }

    void FreeType2Impl::putPixel_8UC1_mono( Mat& _dst, const int _py, const int _px, const uint8_t *_col)
    {
        uint8_t* ptr = _dst.ptr<uint8_t>( _py, _px );
        (*ptr) = _col[0];
    }

    void FreeType2Impl::putPixel_8UC3_mono ( Mat& _dst, const int _py, const int _px, const uint8_t *_col)
    {
        cv::Vec3b* ptr = _dst.ptr<cv::Vec3b>( _py, _px );
        (*ptr)[0] = _col[0];
        (*ptr)[1] = _col[1];
        (*ptr)[2] = _col[2];
    }

    void FreeType2Impl::putPixel_8UC4_mono( Mat& _dst, const int _py, const int _px, const uint8_t *_col)
    {
        cv::Vec4b* ptr = _dst.ptr<cv::Vec4b>( _py, _px );
        (*ptr)[0] = _col[0];
        (*ptr)[1] = _col[1];
        (*ptr)[2] = _col[2];
        (*ptr)[3] = _col[3];
    }

    void FreeType2Impl::putTextBitmapMono(
            InputOutputArray _img, const String& _text, Point _org,
            int _fontHeight, Scalar _color,
            int _thickness, int _line_type, bool _bottomLeftOrigin )
    {
        CV_Assert( _thickness < 0 );
        CV_Assert( _line_type == LINE_4 || _line_type == LINE_8);

        Mat dst = _img.getMat();
#if defined(USING_HB)
        hb_buffer_t *hb_buffer = hb_buffer_create ();
        CV_Assert( hb_buffer != NULL );

        hb_buffer_add_utf8 (hb_buffer, _text.c_str(), -1, 0, -1);
        hb_buffer_guess_segment_properties (hb_buffer);
        hb_shape (mHb_font, hb_buffer, NULL, 0);

        unsigned int textLen = 0;
        hb_glyph_info_t *info =
                hb_buffer_get_glyph_infos(hb_buffer,&textLen );
        CV_Assert( info != NULL );
#else
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        wstring wstr = converter.from_bytes(_text);
#endif

        _org.y += _fontHeight;
        if( _bottomLeftOrigin == true ){
            _org.y -= _fontHeight;
        }

        const uint8_t _colorUC8n[4] = {
                static_cast<uint8_t>(_color[0]),
                static_cast<uint8_t>(_color[1]),
                static_cast<uint8_t>(_color[2]),
                static_cast<uint8_t>(_color[3]) };

        void (cv::ft::FreeType2Impl::*putPixel)( Mat&, const int, const int, const uint8_t*) =
        (_img.type() == CV_8UC4)?(&FreeType2Impl::putPixel_8UC4_mono):
        (_img.type() == CV_8UC3)?(&FreeType2Impl::putPixel_8UC3_mono):
        (&FreeType2Impl::putPixel_8UC1_mono);

#if defined(USING_HB)
        for( unsigned int i = 0 ; i < textLen ; i ++ ){
            CV_Assert( !FT_Load_Glyph(mFace, info[i].codepoint, 0 ) );
#else
        for( unsigned int i = 0 ; i < wstr.size() ; i ++ ){
            CV_Assert(!FT_Load_Glyph(mFace, FT_Get_Char_Index(mFace, wstr[i]), 0 ));
#endif
            CV_Assert( !FT_Render_Glyph( mFace->glyph, FT_RENDER_MODE_MONO ) );
            FT_Bitmap    *bmp = &(mFace->glyph->bitmap);

            Point gPos = _org;
            gPos.y -= ( mFace->glyph->metrics.horiBearingY >> 6) ;
            gPos.x += ( mFace->glyph->metrics.horiBearingX >> 6) ;

            for (int row = 0; row < (int)bmp->rows; row ++) {
                if( gPos.y + row < 0 ) {
                    continue;
                }
                if( gPos.y + row >= dst.rows ) {
                    break;
                }

                for (int col = 0; col < bmp->pitch; col ++) {
                    int cl = bmp->buffer[ row * bmp->pitch + col ];
                    if ( cl == 0 ) {
                        continue;
                    }
                    for(int bit = 7; bit >= 0; bit -- ){
                        if( gPos.x + col * 8 + (7 - bit) < 0 )
                        {
                            continue;
                        }
                        if( gPos.x + col * 8 + (7 - bit) >= dst.cols )
                        {
                            break;
                        }

                        if ( ( (cl >> bit) & 0x01 ) == 1 ) {
                            (this->*putPixel)( dst, gPos.y + row, gPos.x + col * 8 + (7 - bit), _colorUC8n );
                        }
                    }
                }
            }

            _org.x += ( mFace->glyph->advance.x ) >> 6;
            _org.y += ( mFace->glyph->advance.y ) >> 6;
        }
#if defined(USING_HB)
        hb_buffer_destroy (hb_buffer);
#endif
    }

// Alpha composite algorithm is porting from imgproc.
// See https://github.com/opencv/opencv/blob/4.6.0/modules/imgproc/src/drawing.cpp
// static void LineAA( Mat& img, Point2l pt1, Point2l pt2, const void* color )
// ICV_PUT_POINT Macro.

    void FreeType2Impl::putPixel_8UC1_blend( Mat& _dst, const int _py, const int _px, const uint8_t *_col, const uint8_t alpha)
    {
        const int a = alpha;
        const int cb = _col[0];
        uint8_t* tptr = _dst.ptr<uint8_t>( _py, _px );

        int _cb = static_cast<int>(tptr[0]);
        _cb += ((cb - _cb)*a + 127)>> 8;
        _cb += ((cb - _cb)*a + 127)>> 8;

        tptr[0] = static_cast<uint8_t>(_cb);
    }

    void FreeType2Impl::putPixel_8UC3_blend ( Mat& _dst, const int _py, const int _px, const uint8_t *_col, const uint8_t alpha)
    {
        const int a = alpha;
        const int cb = _col[0];
        const int cg = _col[1];
        const int cr = _col[2];
        uint8_t* tptr = _dst.ptr<uint8_t>( _py, _px );

        int _cb = static_cast<int>(tptr[0]);
        _cb += ((cb - _cb)*a + 127)>> 8;
        _cb += ((cb - _cb)*a + 127)>> 8;

        int _cg = static_cast<int>(tptr[1]);
        _cg += ((cg - _cg)*a + 127)>> 8;
        _cg += ((cg - _cg)*a + 127)>> 8;

        int _cr = static_cast<int>(tptr[2]);
        _cr += ((cr - _cr)*a + 127)>> 8;
        _cr += ((cr - _cr)*a + 127)>> 8;

        tptr[0] = static_cast<uint8_t>(_cb);
        tptr[1] = static_cast<uint8_t>(_cg);
        tptr[2] = static_cast<uint8_t>(_cr);
    }

    void FreeType2Impl::putPixel_8UC4_blend( Mat& _dst, const int _py, const int _px, const uint8_t *_col, const uint8_t alpha)
    {
        const uint8_t a = alpha;
        const int cb = _col[0];
        const int cg = _col[1];
        const int cr = _col[2];
        const int ca = _col[3];
        uint8_t* tptr = _dst.ptr<uint8_t>( _py, _px );

        int _cb = static_cast<int>(tptr[0]);
        _cb += ((cb - _cb)*a + 127)>> 8;
        _cb += ((cb - _cb)*a + 127)>> 8;

        int _cg = static_cast<int>(tptr[1]);
        _cg += ((cg - _cg)*a + 127)>> 8;
        _cg += ((cg - _cg)*a + 127)>> 8;

        int _cr = static_cast<int>(tptr[2]);
        _cr += ((cr - _cr)*a + 127)>> 8;
        _cr += ((cr - _cr)*a + 127)>> 8;

        int _ca = static_cast<int>(tptr[3]);
        _ca += ((ca - _ca)*a + 127)>> 8;
        _ca += ((ca - _ca)*a + 127)>> 8;

        tptr[0] = static_cast<uint8_t>(_cb);
        tptr[1] = static_cast<uint8_t>(_cg);
        tptr[2] = static_cast<uint8_t>(_cr);
        tptr[3] = static_cast<uint8_t>(_ca);
    }

    void FreeType2Impl::putTextBitmapBlend(
            InputOutputArray _img, const String& _text, Point _org,
            int _fontHeight, Scalar _color,
            int _thickness, int _line_type, bool _bottomLeftOrigin )
    {

        CV_Assert( _thickness < 0 );
        CV_Assert( _line_type == LINE_AA );

        Mat dst = _img.getMat();
#if defined(USING_HB)
        hb_buffer_t *hb_buffer = hb_buffer_create ();
        CV_Assert( hb_buffer != NULL );

        hb_buffer_add_utf8 (hb_buffer, _text.c_str(), -1, 0, -1);
        hb_buffer_guess_segment_properties (hb_buffer);
        hb_shape (mHb_font, hb_buffer, NULL, 0);

        unsigned int textLen = 0;
        hb_glyph_info_t *info =
                hb_buffer_get_glyph_infos(hb_buffer,&textLen );
        CV_Assert( info != NULL );
#else
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        wstring wstr = converter.from_bytes(_text);
#endif

        _org.y += _fontHeight;
        if( _bottomLeftOrigin == true ){
            _org.y -= _fontHeight;
        }

        const uint8_t _colorUC8n[4] = {
                static_cast<uint8_t>(_color[0]),
                static_cast<uint8_t>(_color[1]),
                static_cast<uint8_t>(_color[2]),
                static_cast<uint8_t>(_color[3]) };

        void (cv::ft::FreeType2Impl::*putPixel)( Mat&, const int, const int, const uint8_t*, const uint8_t) =
        (_img.type() == CV_8UC4)?(&FreeType2Impl::putPixel_8UC4_blend):
        (_img.type() == CV_8UC3)?(&FreeType2Impl::putPixel_8UC3_blend):
        (&FreeType2Impl::putPixel_8UC1_blend);

#if defined(USING_HB)
        for( unsigned int i = 0 ; i < textLen ; i ++ ){
            CV_Assert( !FT_Load_Glyph(mFace, info[i].codepoint, 0 ) );
#else
        for( unsigned int i = 0 ; i < wstr.size() ; i ++ ){
            CV_Assert(!FT_Load_Glyph(mFace, FT_Get_Char_Index(mFace, wstr[i]), 0 ));
#endif
            CV_Assert( !FT_Render_Glyph( mFace->glyph, FT_RENDER_MODE_NORMAL ) );
            FT_Bitmap    *bmp = &(mFace->glyph->bitmap);

            Point gPos = _org;
            gPos.y -= ( mFace->glyph->metrics.horiBearingY >> 6) ;
            gPos.x += ( mFace->glyph->metrics.horiBearingX >> 6) ;

            for (int row = 0; row < (int)bmp->rows; row ++) {
                if( gPos.y + row < 0 ) {
                    continue;
                }
                if( gPos.y + row >= dst.rows ) {
                    break;
                }

                for (int col = 0; col < bmp->pitch; col ++) {
                    uint8_t cl = bmp->buffer[ row * bmp->pitch + col ];
                    if ( cl == 0 ) {
                        continue;
                    }
                    if( gPos.x + col < 0 )
                    {
                        continue;
                    }
                    if( gPos.x + col >= dst.cols )
                    {
                        break;
                    }

                    (this->*putPixel)( dst, gPos.y + row, gPos.x + col, _colorUC8n, cl );
                }
            }
            _org.x += ( mFace->glyph->advance.x ) >> 6;
            _org.y += ( mFace->glyph->advance.y ) >> 6;
        }

#if defined(USING_HB)
        hb_buffer_destroy (hb_buffer);
#endif
    }

    Size FreeType2Impl::getTextSize(
            const String& _text,
            int _fontHeight,
            int _thickness,
            CV_OUT int* _baseLine)
    {
        if ( _text.empty() )
        {
            return Size(0,0);
        }

        CV_Assert( _fontHeight >= 0 ) ;
        if ( _fontHeight == 0 )
        {
            return Size(0,0);
        }

        CV_Assert(!FT_Set_Pixel_Sizes( mFace, _fontHeight, _fontHeight ));

        FT_Vector currentPos = {0,0};
#if defined(USING_HB)
        hb_buffer_t *hb_buffer = hb_buffer_create ();
        CV_Assert( hb_buffer != NULL );

        hb_buffer_add_utf8 (hb_buffer, _text.c_str(), -1, 0, -1);
        hb_buffer_guess_segment_properties (hb_buffer);
        hb_shape (mHb_font, hb_buffer, NULL, 0);

        unsigned int textLen = 0;
        hb_glyph_info_t *info =
                hb_buffer_get_glyph_infos(hb_buffer,&textLen );
        CV_Assert( info != NULL );
#else
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        wstring wstr = converter.from_bytes(_text);
#endif
        // Initilize BoundaryBox ( in OpenCV coordinates )
        int xMin = INT_MAX, yMin = INT_MAX;
        int xMax = INT_MIN, yMax = INT_MIN;

#if defined(USING_HB)
        for( unsigned int i = 0 ; i < textLen ; i ++ ){
            CV_Assert(!FT_Load_Glyph(mFace, info[i].codepoint, 0 ));
#else
        for( unsigned int i = 0 ; i < wstr.size() ; i ++ ){
            CV_Assert(!FT_Load_Glyph(mFace, FT_Get_Char_Index(mFace, wstr[i]), 0 ));
#endif
            FT_GlyphSlot slot  = mFace->glyph;
            FT_Outline outline = slot->outline;
            FT_BBox bbox ;

            // Flip ( in FreeType coordinates )
            FT_Matrix mtx = { 1 << 16 , 0 , 0 , -(1 << 16) };
            FT_Outline_Transform(&outline, &mtx);

            // Move to current position ( in FreeType coordinates )
            FT_Outline_Translate(&outline,
                                 currentPos.x,
                                 currentPos.y );

            // Get BoundaryBox ( in FreeType coordinatrs )
            CV_Assert( !FT_Outline_Get_BBox( &outline, &bbox ) );

            // If codepoint is space(0x20), it has no glyph.
            // A dummy boundary box is needed when last code is space.
            if(
                    (bbox.xMin == 0 ) && (bbox.xMax == 0 ) &&
                    (bbox.yMin == 0 ) && (bbox.yMax == 0 )
                    ){
                bbox.xMin = currentPos.x ;
                bbox.xMax = currentPos.x + ( mFace->glyph->advance.x );
                bbox.yMin = yMin;
                bbox.yMax = yMax;
            }

            // Update current position ( in FreeType coordinates )
            currentPos.x += mFace->glyph->advance.x;
            currentPos.y += mFace->glyph->advance.y;

            // Update BoundaryBox ( in OpenCV coordinates )
            xMin = cv::min ( xMin, ftd(bbox.xMin) );
            xMax = cv::max ( xMax, ftd(bbox.xMax) );
            yMin = cv::min ( yMin, ftd(bbox.yMin) );
            yMax = cv::max ( yMax, ftd(bbox.yMax) );
        }

#if defined(USING_HB)
        hb_buffer_destroy (hb_buffer);
#endif

        // Calcurate width/height/baseline ( in OpenCV coordinates )
        int width  = xMax - xMin ;
        int height = -yMin ;

        if ( _thickness > 0 ) {
            width  = cvRound(width  + _thickness * 2);
            height = cvRound(height + _thickness * 1);
        }else{
            width  = cvRound(width  + 1);
            height = cvRound(height + 1);
        }

        if ( _baseLine ) {
            *_baseLine = yMax;
        }

        return Size( width, height );
    }

    int FreeType2Impl::mvFn( const FT_Vector *to, void * user)
    {
        if(user == NULL ) { return 1; }
        PathUserData *p = (PathUserData*)user;

        // Draw polylines( in OpenCV coordinates ).
        if( p->mPts.size() > 0 ){
            Mat dst = p->mImg.getMat();
            const Point *ptsList[] = { &(p->mPts[0]) };
            int npt[1]; npt[0] = p->mPts.size();
            polylines(
                    dst,
                    ptsList,
                    npt,
                    1,
                    false,
                    p->mColor,
                    p->mThickness,
                    p->mLine_type,
                    0
            );
        }

        p->mPts.clear();

        if( to == NULL ) { return 1; }

        // Store points to draw( in OpenCV coordinates ).
        p->mPts.push_back( Point ( ftd(to->x), ftd(to->y) ) );
        p->mOldP = *to;
        return 0;
    }

    int FreeType2Impl::lnFn( const FT_Vector *to, void * user)
    {
        if(to   == NULL ) { return 1; }
        if(user == NULL ) { return 1; }

        PathUserData *p = (PathUserData *)user;

        // Store points to draw( in OpenCV coordinates ).
        p->mPts.push_back( Point ( ftd(to->x), ftd(to->y) ) );
        p->mOldP = *to;
        return 0;
    }

    int FreeType2Impl::coFn( const FT_Vector *cnt,
                             const FT_Vector *to,
                             void * user)
    {
        if(cnt  == NULL ) { return 1; }
        if(to   == NULL ) { return 1; }
        if(user == NULL ) { return 1; }

        PathUserData *p = (PathUserData *)user;

        // Bezier to Line
        for(int i = 0;i <= p->mCtoL; i++){
            // Split Bezier to lines ( in FreeType coordinates ).
            double u = (double)i * 1.0 / (p->mCtoL) ;
            double nu = 1.0 - u;
            double p0 =                  nu * nu;
            double p1 = 2.0 * u *        nu;
            double p2 =       u * u;

            double X = (p->mOldP.x) * p0 + cnt->x * p1 + to->x * p2;
            double Y = (p->mOldP.y) * p0 + cnt->y * p1 + to->y * p2;

            // Store points to draw( in OpenCV coordinates ).
            p->mPts.push_back( Point ( ftd(X), ftd(Y) ) );
        }
        p->mOldP = *to;
        return 0;
    }

    int FreeType2Impl::cuFn( const FT_Vector *cnt1,
                             const FT_Vector *cnt2,
                             const FT_Vector *to,
                             void * user)
    {
        if(cnt1 == NULL ) { return 1; }
        if(cnt2 == NULL ) { return 1; }
        if(to   == NULL ) { return 1; }
        if(user == NULL ) { return 1; }

        PathUserData *p = (PathUserData *)user;

        // Bezier to Line
        for(int i = 0; i <= p->mCtoL ;i++){
            // Split Bezier to lines ( in FreeType coordinates ).
            double u = (double)i * 1.0 / (p->mCtoL) ;
            double nu = 1.0 - u;
            double p0 =                  nu * nu * nu;
            double p1 = 3.0 * u *        nu * nu;
            double p2 = 3.0 * u * u *    nu;
            double p3 =       u * u * u;

            double X = (p->mOldP.x) * p0 + (cnt1->x)    * p1 +
                       (cnt2->x   ) * p2 + (to->x  )    * p3;
            double Y = (p->mOldP.y) * p0 + (cnt1->y)    * p1 +
                       (cnt2->y   ) * p2 + (to->y  )    * p3;

            // Store points to draw( in OpenCV coordinates ).
            p->mPts.push_back( Point ( ftd(X), ftd(Y) ) );
        }
        p->mOldP = *to;
        return 0;
    }

    CV_EXPORTS_W Ptr<FreeType2> createFreeType2()
    {
        return Ptr<FreeType2Impl> (new FreeType2Impl () );
    }


}} // namespace freetype2