CCanvas.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "img-precomp.h"  // Precompiled headers
 
#include <mrpt/img/CCanvas.h>
#include <mrpt/img/CImage.h>
#include <mrpt/system/os.h>
#include <mrpt/system/string_utils.h>
#include <mrpt/core/round.h>
#include <mrpt/io/zip.h>
#include <map>
 
// Include the MRPT bitmap fonts:
#include "mrpt_font_5x7.h"
#include "mrpt_font_6x13.h"
#include "mrpt_font_6x13B.h"
#include "mrpt_font_6x13O.h"
#include "mrpt_font_9x15.h"
#include "mrpt_font_9x15B.h"
#include "mrpt_font_10x20.h"
 
// Japanese fonts?
#if MRPT_HAS_ASIAN_FONTS
#include "mrpt_font_18x18ja.h"
#endif
 
// Each font has a block a data with this header (It's actually zip-compressed
// since mrpt >0.6.5)
//      const uint32_t mrpt_font_9x15B [] = {
//      9,15, /* width, height */
//      0x0000,0x00FF, /* UNICODE characters range: */
 
using namespace mrpt;
using namespace mrpt::img;
using namespace std;
 
// map<string,const uint32_t*>   list_registered_fonts;
map<string, std::vector<uint8_t>>
        list_registered_fonts;  // Each vector is the target
// place where to uncompress
// each font.
bool list_fonts_init = false;
 
void init_fonts_list()
{
        if (!list_fonts_init)
        {
                list_registered_fonts.clear();
 
// This was used only once
#if 0
#define SAVE_COMPRESSED(ARR)                                                  \
        {                                                                         \
                list_registered_fonts[#ARR].resize(sizeof(mrpt_font_##ARR));          \
                memcpy(                                                               \
                        &list_registered_fonts[#ARR][0], mrpt_font_##ARR,                 \
                        sizeof(mrpt_font_##ARR));                                         \
                cout << #ARR << " -> " << sizeof(mrpt_font_##ARR) << endl;            \
                CFileGZOutputStream f(                                                \
                        string("mrpt_font_") + string(#ARR) + string(".gz"));             \
                f.WriteBuffer(mrpt_font_##ARR, sizeof(mrpt_font_##ARR));              \
                /*mrpt::compress::zip::compress( list_registered_fonts[#ARR], f ); */ \
        }
 
        SAVE_COMPRESSED(5x7)
//      SAVE_COMPRESSED(6x13)
//      SAVE_COMPRESSED(6x13B)
//      SAVE_COMPRESSED(6x13O)
//      SAVE_COMPRESSED(9x15)
//      SAVE_COMPRESSED(9x15B)
//      SAVE_COMPRESSED(10x20)
 
#if MRPT_HAS_ASIAN_FONTS
//      SAVE_COMPRESSED(18x18ja)
#endif
 
#endif
 
#if 1  // Normal operation: Load fonts and uncompress them:
 
#define LOAD_FONT(FONTNAME)                                           \
        {                                                                 \
                std::vector<uint8_t> tmpBuf(sizeof(mrpt_font_gz_##FONTNAME)); \
                memcpy(                                                       \
                        &tmpBuf[0], mrpt_font_gz_##FONTNAME,                      \
                        sizeof(mrpt_font_gz_##FONTNAME));                         \
                mrpt::io::zip::decompress_gz_data_block(                      \
                        tmpBuf, list_registered_fonts[#FONTNAME]);                \
        }
 
                LOAD_FONT(5x7)
                LOAD_FONT(6x13)
                LOAD_FONT(6x13B)
                LOAD_FONT(6x13O)
                LOAD_FONT(9x15)
                LOAD_FONT(9x15B)
                LOAD_FONT(10x20)
#if MRPT_HAS_ASIAN_FONTS
                LOAD_FONT(18x18ja)
#endif
 
#endif
 
                list_fonts_init = true;
        }
}
 
/*---------------------------------------------------------------
                                                Constructor
---------------------------------------------------------------*/
CCanvas::CCanvas() : m_selectedFont("9x15"), m_selectedFontBitmaps(nullptr) {}
/*---------------------------------------------------------------
                                                line
---------------------------------------------------------------*/
void CCanvas::line(
        int x0, int y0, int x1, int y1, const mrpt::img::TColor color,
        unsigned int width, TPenStyle penStyle)
{
        MRPT_UNUSED_PARAM(width);
        MRPT_UNUSED_PARAM(penStyle);
 
        /*      // JL: worthy annoying so much?
                static bool warningFirst = true;
                if (warningFirst)
                {
                        warningFirst=false;
                        printf("[CCanvas::line] WARNING: Using default drawing method,
           ignoring 'width' and 'penStyle'!!\n");
                }*/
 
        float x, y;
 
        float Ax = (float)(x1 - x0);
        float Ay = (float)(y1 - y0);
 
        // In this cases, there is nothing to do!
        if (Ax == 0 && Ay == 0) return;
        if (x0 < 0 && x1 < 0) return;
        if (y0 < 0 && y1 < 0) return;
        if (x0 >= (int)getWidth() && x1 >= (int)getWidth()) return;
        if (y0 >= (int)getHeight() && y1 >= (int)getHeight()) return;
 
        float dist = sqrt(square(Ax) + square(Ay));
        int i, N = (int)ceil(dist);
 
        // The N steps to perform next:
        Ax /= N;
        Ay /= N;
        x = (float)x0;
        y = (float)y0;
 
        for (i = 0; i < N; i++)
        {
                x += Ax;
                y += Ay;
                setPixel((int)x, (int)y, color);
        }  // end for i
}
 
/*---------------------------------------------------------------
                                                rectangle
---------------------------------------------------------------*/
void CCanvas::rectangle(
        int x0, int y0, int x1, int y1, const mrpt::img::TColor color,
        unsigned int width)
{
        int w_min = (int)-ceil(((float)width) / 2);
        int w_max = (int)floor(((float)width) / 2);
        // Draw "width" rectangles one into another:
        for (int w = w_min; w <= w_max; w++)
        {
                line(x0 - w, y0 - w, x1 + w, y0 - w, color);
                line(x1 + w, y0 - w, x1 + w, y1 + w, color);
                line(x1 + w, y1 + w, x0 - w, y1 + w, color);
                line(x0 - w, y1 + w, x0 - w, y0 - w, color);
        }  // end for "w"
}
 
/*****************************************************AJOGD***************************************************/
/*---------------------------------------------------------------
                                                triangle
---------------------------------------------------------------*/
void CCanvas::triangle(
        int x0, int y0, int size, const mrpt::img::TColor color, bool inferior,
        unsigned int width)
{
        int ts = round(0.866 * size);
        int tc = round(0.5 * size);
        if (inferior)
        {
                line(x0, y0 + size, x0 + ts, y0 - tc, color, width);
                line(x0, y0 + size, x0 - ts, y0 - tc, color, width);
                line(x0 + ts, y0 - tc, x0 - ts, y0 - tc, color, width);
        }
        else
        {
                line(x0, y0 - size, x0 + ts, y0 + tc, color, width);
                line(x0, y0 - size, x0 - ts, y0 + tc, color, width);
                line(x0 + ts, y0 + tc, x0 - ts, y0 + tc, color, width);
        }
}
/************************************************************************************************************/
 
/*---------------------------------------------------------------
                                                filledRectangle
---------------------------------------------------------------*/
void CCanvas::filledRectangle(
        int x0, int y0, int x1, int y1, const mrpt::img::TColor color)
{
        int x_min = max(x0, 0);
        int x_max = min(x1, (int)getWidth() - 1);
        int y_min = max(y0, 0);
        int y_max = min(y1, (int)getHeight() - 1);
 
        for (int y = y_min; y <= y_max; y++)
                for (int x = x_min; x <= x_max; x++) setPixel(x, y, color);
}
 
/*---------------------------------------------------------------
                                        selectTextFont
---------------------------------------------------------------*/
void CCanvas::selectTextFont(const std::string& fontName)
{
        init_fonts_list();
 
        // Assure list name is in the list:
        map<string, std::vector<uint8_t>>::const_iterator it =
                list_registered_fonts.find(fontName);
        if (it == list_registered_fonts.end())
        {
                // Error
                cerr << "[CCanvas::selectTextFont] Warning: Unknown font: " << fontName
                         << endl;
                return;
        }
        else
        {
                m_selectedFontBitmaps =
                        reinterpret_cast<const uint32_t*>(&it->second[0]);
                m_selectedFont = fontName;
        }
}
 
/*---------------------------------------------------------------
                                                drawImage
---------------------------------------------------------------*/
void CCanvas::drawImage(int x, int y, const mrpt::img::CImage& img)
{
        MRPT_START
 
        int img_lx = img.getWidth();
        int img_ly = img.getHeight();
 
        if (img.isColor())
        {
                for (int xx = 0; xx < img_lx; xx++)
                        for (int yy = 0; yy < img_ly; yy++)
                                setPixel(x + xx, y + yy, *((int*)img(xx, yy)));
        }
        else
        {
                unsigned char c;
                int col;
                for (int xx = 0; xx < img_lx; xx++)
                        for (int yy = 0; yy < img_ly; yy++)
                        {
                                c = *((unsigned char*)img(xx, yy));
                                col = c | (c << 8) | (c << 16);
                                setPixel(x + xx, y + yy, col);
                        }
        }
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                drawImage
---------------------------------------------------------------*/
void CCanvas::drawImage(
        int x, int y, const mrpt::img::CImage& img, float rotation, float scale)
{
        MRPT_UNUSED_PARAM(x);
        MRPT_UNUSED_PARAM(y);
        MRPT_UNUSED_PARAM(img);
        MRPT_UNUSED_PARAM(rotation);
        MRPT_UNUSED_PARAM(scale);
 
        MRPT_START
 
        THROW_EXCEPTION("Not implemented yet!! Try yourself! ;-)");
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                cross
---------------------------------------------------------------*/
void CCanvas::cross(
        int x0, int y0, const mrpt::img::TColor color, char type, unsigned int size,
        unsigned int width)
{
        switch (type)
        {
                case '+':
                        line(x0 - size, y0, x0 + size, y0, color, width);
                        line(x0, y0 - size, x0, y0 + size, color, width);
                        break;
                case 'x':
                        line(x0 - size, y0 - size, x0 + size, y0 + size, color, width);
                        line(x0 + size, y0 - size, x0 - size, y0 + size, color, width);
                        break;
                case ':':
                        line(x0 - size, y0, x0 - 2, y0, color, width);
                        line(x0 + 2, y0, x0 + size, y0, color, width);
                        line(x0, y0 - size, x0, y0 - 2, color, width);
                        line(x0, y0 + 2, x0, y0 + size, color, width);
                        break;
                default:
                        THROW_EXCEPTION("Unexpected 'type' of cross to be drawn");
        }
}
 
/*---------------------------------------------------------------
                                                drawCircle
---------------------------------------------------------------*/
void CCanvas::drawCircle(
        int x, int y, int radius, const mrpt::img::TColor& color,
        unsigned int width)
{
        if (radius < 0) radius = -radius;
 
        int nSegments;
 
        if (radius == 0)
        {
                nSegments = 2;
        }
        else
        {
                nSegments = int(M_2PI * radius);
        }
 
        int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
        double ang, Aa = M_2PI / (nSegments - 1);
        int i;
 
        for (i = 0, ang = 0; i < nSegments; i++, ang += Aa)
        {
                x2 = round(x + radius * cos(ang));
                y2 = round(y + radius * sin(ang));
 
                if (i > 0) line(x1, y1, x2, y2, color, width);
 
                x1 = x2;
                y1 = y2;
        }  // end for points on ellipse
}
 
/*---------------------------------------------------------------
                                                textOut
---------------------------------------------------------------*/
void CCanvas::textOut(
        int x0, int y0, const std::string& str, const mrpt::img::TColor color)
{
        MRPT_START
 
        if (!m_selectedFontBitmaps)  // First call: load fonts
                this->selectTextFont("9x15");
 
        // Am I an image?
        bool y_axis_reversed = false;
        CImage* im_image = dynamic_cast<CImage*>(this);
        if (im_image) y_axis_reversed = !im_image->isOriginTopLeft();
 
        // Decode UNICODE string:
        std::vector<uint16_t> uniStr;
        mrpt::system::decodeUTF8(str, uniStr);
 
        int px = x0;
        int py = y0;
 
        // Char size:
        uint32_t char_w = m_selectedFontBitmaps[0];
        uint32_t char_h = m_selectedFontBitmaps[1];
 
        for (size_t i = 0; i < uniStr.size(); i++)
        {
                const uint16_t& unichar = uniStr[i];
 
                // look for the character in the table:
                const uint32_t* table_ptr = m_selectedFontBitmaps + 2;
                uint32_t charset_ini = table_ptr[0];
                uint32_t charset_end = table_ptr[1];
 
                while (charset_end)
                {
                        // Is in this range?
                        if (unichar <= charset_end && unichar >= charset_ini)
                        {
                                // Draw this character:
                                unsigned pyy = y_axis_reversed ? (py + char_h - 1) : py;
                                unsigned pxx;
 
                                const uint32_t* char_bitmap =
                                        table_ptr + 2 + char_h * (unichar - charset_ini);
 
                                for (unsigned y = 0; y < char_h;
                                         y++, pyy += y_axis_reversed ? -1 : 1)
                                {
                                        pxx = px;
                                        const uint32_t& row = *char_bitmap++;
                                        for (unsigned x = 0; x < char_w; x++, pxx++)
                                                if (row & (1 << x)) setPixel(pxx, pyy, color);
                                }
 
                                // Advance the raster cursor:
                                px += char_w;
 
                                // Next char!
                                break;
                        }
                        else
                        {
                                // No: Move to the next block and keep searching:
                                uint32_t n_chars = charset_end - charset_ini + 1;
                                table_ptr += 2 /* Header */ + n_chars * char_h;
 
                                // get new block header:
                                charset_ini = table_ptr[0];
                                charset_end = table_ptr[1];
                        }
                }
                // Char not in the font!
        }
 
        MRPT_END
}