BitmapToolkitText.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2015 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include <algorithm>
#include "freetypeFont.h"
#include "Prerequisites.h"
#include "BitmapToolkitText.h"
#include "ScolConvert.h"
 
// btfonts
bool btfonts::initialized = false;
std::map<std::string, btfonts::type> btfonts::font_to_cv;
btfonts::type& btfonts::get(std::string name)
{
  if (!initialized)
    initialize();
  return font_to_cv[name];
}
 
void btfonts::initialize()
{
  font_to_cv["arial"] = type(BT_FONT_SANS);
  font_to_cv["arial black"] = type(BT_FONT_SANS, true, true, false);
  font_to_cv["helvetica"] = type(BT_FONT_SANS);
  font_to_cv["calibri"] = type(BT_FONT_SANS);
  font_to_cv["system"] = type(BT_FONT_SANS);
  font_to_cv["times new roman"] = type(BT_FONT_SERIF);
  font_to_cv["times"] = type(BT_FONT_SERIF);
  font_to_cv["georgia"] = type(BT_FONT_SERIF);
  font_to_cv["sans"] = type(BT_FONT_SANS);
  font_to_cv["serif"] = type(BT_FONT_SERIF);
  font_to_cv["script"] = type(BT_FONT_SCRIPT);
}
 
bool btfonts::has(std::string name)
{
  return font_to_cv.count(name) != 0;
}
 
// CV font destruction callback
int destroyCVFont(mmachine m, SCOL_PTR_TYPE handsys, int obj)
{
  PtrObjBTFont obj_font = MMgetPointer<PtrObjBTFont>(m, MTOP(obj));
  if (obj_font)
    SAFE_DELETE(obj_font);
 
  MMsetPointer<PtrObjBTFont>(m, MTOP(obj), 0);
 
  MMechostr(MSKDEBUG, "ObjBTFont destroyed.\n");
  return 0;
}
 
std::string ReplaceAll(std::string str, const std::string& from, const std::string& to)
{
  size_t start_pos = 0;
  while ((start_pos = str.find(from, start_pos)) != std::string::npos)
  {
    str.replace(start_pos, from.length(), to);
    start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
  }
  return str;
}
 
// Takes a text as input, with opencv font parameters, and spits back lines within <max_width>
std::vector<std::string> word_wrap(std::string input, PtrObjBTFont obj_font, int max_width, int splitlines)
{
  // Split text into words
  std::vector<std::vector<std::string> > words;
  max_width = std::max(max_width, 1);
 
  // Clean text, replace all newlines to \n
  input = ReplaceAll(input, "\r\n", "\n");
  input = ReplaceAll(input, "\r", "\n");
  std::istringstream is_line(input);
  std::string line;
 
  while (getline(is_line, line, '\n'))
  {
    words.push_back(std::vector<std::string>());
    std::istringstream is_word(line);
    std::string word;
    while (getline(is_word, word, ' '))
    {
      word = ReplaceAll(word, "\t", "  ");
      words.back().push_back(word);
    }
  }
 
  std::vector<std::string> output;
 
  for (unsigned line_index = 0; line_index < words.size(); line_index++)
  {
    bool done = false;
    unsigned int word_index = 0;
    if (splitlines)
    {
      while (!done)
      {
        std::string text_line = "";
        cv::Size line_size;
        unsigned int local_word_index = word_index;
        unsigned int word_count = 0;
 
        // stack words until it gets wider than max_width
        while (line_size.width <= max_width)
        {
          // there's no more words, text and line is over
          if (local_word_index >= words[line_index].size())
          {
            done = true;
            break;
          }
 
          if (word_count == 0)
            text_line += words[line_index][local_word_index];
          else
            text_line += " " + words[line_index][local_word_index];
 
#ifdef BT_USE_FREETYPE
          if (obj_font->mode)
            line_size = obj_font->ft2->getTextSize(text_line, obj_font->size, obj_font->thickness, NULL);
          else
#endif
            line_size = cv::getTextSize(text_line, obj_font->face, obj_font->scale, obj_font->thickness, NULL);
 
          local_word_index++; // goto next word
          word_count++;
        }
 
 
        if (local_word_index >= words[line_index].size() && (words[line_index].size() <= 1))
          done = true;
 
        // revert to last word and trailing space if text is not done
        if (!done && word_count > 1)
        {
          word_index = local_word_index - 1;
          text_line = text_line.substr(0, text_line.length() - words[line_index][local_word_index - 1].length() - 1);
        }
        else
        {
          word_index++;
          text_line = text_line.substr(0, text_line.length());
        }
 
        output.push_back(text_line);
      }
    }
    else
    {
      std::string text_line = "";
      unsigned int local_word_index = word_index;
      unsigned int word_count = 0;
 
      // stack words until it gets wider than max_width
      while (local_word_index < words[line_index].size())
      {
        if (word_count == 0)
          text_line += words[line_index][local_word_index];
        else
          text_line += " " + words[line_index][local_word_index];
 
        local_word_index++; // goto next word
        word_count++;
      }
 
      word_index++;
      text_line = text_line.substr(0, text_line.length());
 
      output.push_back(text_line);
    }
  }
  return output;
}
 
int _CRBTfont(mmachine m)
{
  int ilineoffset = MMpull(m);
  int iflags = MMpull(m);
  int isize = MMpull(m);
  int iface = MMpull(m);
 
  // Defaults (everything is defaulted)
  // ------------
  std::string font_name = "";
  int scol_font_face = BT_FONT_SANS;
  int scol_font_flags = BT_FONT_ANTIALIAS | BT_FONT_FILLED;
  int scol_font_size = 16;
 
  PtrObjBTFont font = new ObjBTFont();
 
  // Parse args
  // ------------
  if (iface != NIL)
    font_name = MMstartstr(m, MTOP(iface));
 
  if (isize != NIL)
    scol_font_size = MTOI(isize);
 
  if (iflags != NIL)
    scol_font_flags = MTOI(iflags);
 
  if (ilineoffset != NIL)
    font->lineOffset = MTOF(ilineoffset) + 0.4f;
 
  // Opencv font selection
  // --------------------
  std::transform(font_name.begin(), font_name.end(), font_name.begin(), ::tolower);
  if (btfonts::has(font_name))
    scol_font_face = btfonts::get(font_name).face;
  switch (scol_font_face)
  {
  case BT_FONT_SANS:
  {
    if (scol_font_flags & BT_FONT_BOLD)
      font->face = cv::FONT_HERSHEY_DUPLEX;
    else
      font->face = cv::FONT_HERSHEY_SIMPLEX;
  }
  break;
  case BT_FONT_SERIF:
  {
    if (scol_font_flags & BT_FONT_BOLD)
      font->face = cv::FONT_HERSHEY_TRIPLEX;
    else
      font->face = cv::FONT_HERSHEY_COMPLEX;
  }
  break;
  case BT_FONT_SCRIPT:
  {
    if (scol_font_flags & BT_FONT_BOLD)
      font->face = cv::FONT_HERSHEY_SCRIPT_COMPLEX;
    else
      font->face = cv::FONT_HERSHEY_SCRIPT_SIMPLEX;
  }
  break;
  default:
    font->face = cv::FONT_HERSHEY_SIMPLEX;
    break;
  }
 
  // Other parameters
  // ------------
  if (scol_font_flags & BT_FONT_ITALIC)
    font->face |= cv::FONT_ITALIC;
 
  if (scol_font_flags & BT_FONT_ANTIALIAS)
    font->linetype = cv::LINE_AA;
  else
    font->linetype = 8;
 
  // Font scale
  // ------------
  cv::Size cv_font_size = cv::getTextSize(BT_CHARSETREF, font->face, 1.0, 1, NULL);
  font->scale = ((float)scol_font_size / (float)cv_font_size.height);
 
  font->size = scol_font_size;
 
  // xoffset
  switch (scol_font_face)
  {
  case BT_FONT_SANS:
  {
    font->xoffset = 2;
  }
  break;
  case BT_FONT_SERIF:
  {
    font->xoffset = 2;
    if (scol_font_flags & BT_FONT_ITALIC)
      font->xoffset = (int)(font->scale * 2.0f) + 2;
  }
  break;
  case BT_FONT_SCRIPT:
  {
    font->xoffset = (int)(font->scale * 4.0f) + 2;
  }
  break;
  default:
    break;
  }
 
  if (btfonts::get(font_name).bold)
  {
    font->thickness += 1;
    if (btfonts::get(font_name).extra_bold)
      font->thickness += 1;
  }
 
  if (!(scol_font_flags & BT_FONT_HOLLOW))
  {
    font->thickness += (int)((font->scale * 1.55f) - 1.0f);
  }
 
  font->thickness = std::max(1, font->thickness);
 
  if (btfonts::get(font_name).italic)
    font->face |= cv::FONT_ITALIC;
 
  font->baseSize = cv::getTextSize(BT_CHARSET, font->face, font->scale, font->thickness, NULL);
 
  // Store to tuple
  // ----------------
  if ((MMpushPointer(m, font) != 0))
  {
    if (font)
      SAFE_DELETE(font);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, SObjBTFont, SCOL_PTR font, NIL, 0);
}
 
int _CRBTfontFromFile(mmachine m)
{
  int ilineoffset = MMpull(m);
  int iflags = MMpull(m);
  int isize = MMpull(m);
  int ipath = MMpull(m);
 
  if (ipath == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
#ifndef BT_USE_FREETYPE
 
  MMset(m, 0, NIL);
  return 0;
 
#else
 
  // Defaults (everything is defaulted)
  // ------------
  int scol_font_flags = BT_FONT_ANTIALIAS | BT_FONT_FILLED;
  int scol_font_size = 16;
 
  PtrObjBTFont font = new ObjBTFont(1);
 
  if (isize != NIL)
    scol_font_size = MTOI(isize);
 
  if (iflags != NIL)
    scol_font_flags = MTOI(iflags);
 
  if (ilineoffset != NIL)
    font->lineOffset = MTOF(ilineoffset) + 0.4f;
 
  // Parse args
  // ------------
  boost::filesystem::path fontPathBase = MMstartstr(m, MTOP(ipath));
  
  //bool found = false;
  //int index = ((scol_font_flags & BT_FONT_BOLD) && (scol_font_flags & BT_FONT_ITALIC)) ? 3 : (scol_font_flags & BT_FONT_ITALIC) ? 2 : (scol_font_flags & BT_FONT_BOLD) ? 1 : 0;
  //if (index != 0)
  //{
  //  if (!font->ft2->loadFontData(fontPathBase.generic_string(), index))
  //  {
  //    MMechostr(MSKDEBUG, "Warning on _CRBTfontFromFile : %s, not face for flags", fontPathBase.generic_string().c_str());
  //    index = 0;
  //  }
  //  else
  //    found = true;
  //}
  //
  //if (!found)
  {
    boost::filesystem::path fontPath;
    //check if file with font flags exist
    //if (index != 0)
    {
      std::string path = fontPathBase.parent_path().generic_string();
      std::string fname = fontPathBase.stem().generic_string();
      std::string ext = fontPathBase.extension().generic_string();
 
#if defined(ANDROID)
      FILE* fcheck = 0;
      if ((scol_font_flags & BT_FONT_BOLD) && (scol_font_flags & BT_FONT_ITALIC))
        if ((fcheck = SCfopen((path + "/" + fname + "bi" + ext).c_str(), "rb")) != 0)
        {
          fclose(fcheck);
          fontPath = boost::filesystem::path(path + "/" + fname + "bi" + ext);
        }
      if (fontPath.empty() && (scol_font_flags & BT_FONT_BOLD))
        if ((fcheck = SCfopen((path + "/" + fname + "b" + ext).c_str(), "rb")) != 0)
        {
          fclose(fcheck);
          fontPath = boost::filesystem::path(path + "/" + fname + "b" + ext);
        }
 
      if (fontPath.empty() && scol_font_flags & BT_FONT_ITALIC)
        if ((fcheck = SCfopen((path + "/" + fname + "i" + ext).c_str(), "rb")) != 0)
        {
          fclose(fcheck);
          fontPath = boost::filesystem::path(path + "/" + fname + "i" + ext);
        }
#else
      if ((scol_font_flags & BT_FONT_BOLD) && (scol_font_flags & BT_FONT_ITALIC))
        if (boost::filesystem::exists(path + "/" + fname + "bi" + ext))
          fontPath = boost::filesystem::path(path + "/" + fname + "bi" + ext);
 
      if (fontPath.empty() && (scol_font_flags & BT_FONT_BOLD))
        if (boost::filesystem::exists(path + "/" + fname + "b" + ext))
          fontPath = boost::filesystem::path(path + "/" + fname + "b" + ext);
 
      if (fontPath.empty() && scol_font_flags & BT_FONT_ITALIC)
        if (boost::filesystem::exists(path + "/" + fname + "i" + ext))
          fontPath = boost::filesystem::path(path + "/" + fname + "i" + ext);
 
#endif
    }
 
    if (fontPath.empty())
      fontPath = fontPathBase;
 
    if (!font->ft2->loadFontData(fontPath.generic_string(), 0))
    {
      MMechostr(MSKDEBUG, "Warning on _CRBTfontFromFile : %s, not found", fontPath.generic_string().c_str());
      SAFE_DELETE(font);
      MMset(m, 0, NIL);
      return 0;
    }
  }
  
  // Other parameters
  // ------------
  if (scol_font_flags & BT_FONT_ITALIC)
    font->face |= cv::FONT_ITALIC;
 
  if (scol_font_flags & BT_FONT_ANTIALIAS)
    font->linetype = cv::LINE_AA;
  else
    font->linetype = 8;
 
  font->thickness = -1;
 
  // Font scale
  // ------------
  cv::Size cv_font_size = font->ft2->getTextSize(BT_CHARSETREF, 16, 1, NULL);
  font->scale = (float)(cv_font_size.height) / 11.0f;
  font->size = (int)((float)scol_font_size * font->scale);
 
  if (scol_font_flags & BT_FONT_HOLLOW)
    font->thickness = 1 + (int)((font->scale * 1.55f) - 1.0f);
  
  font->xoffset = 2;
  font->baseSize = font->ft2->getTextSize(BT_CHARSETREF, font->size, font->thickness, NULL);
 
  // Store to tuple
  // ----------------
  if ((MMpushPointer(m, font) != 0))
  {
    if (font)
      SAFE_DELETE(font);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, SObjBTFont, SCOL_PTR font, NIL, 0);
#endif
}
 
int _DSBTfont(mmachine m)
{
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, SObjBTFont, obj);
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
// TO TEST WITH ObjBTFont
int _BTDRAWtextBitmap(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTDRAWtextBitmap");
#endif
 
  // Stack parameters
  int itext = MMpull(m);
  int icolor = MMpull(m);
  int ialignmentFlags = MMpull(m);
  int icoordinates = MMpull(m);
  int ifont = MMpull(m);
  int ibitmap = MMget(m, 0);
  if (ibitmap == NIL || itext == NIL || icoordinates == NIL || ifont == NIL)
  {
    MMechostr(MSKDEBUG, "input bitmap, text or coordinates are NIL");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Mandatory parameters
  // --------------------
  // bitmap
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(ibitmap));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
 
  cv::Mat bitmap = ConversionTools::ScolBitmapToMat(obj_bitmap);
  if (bitmap.empty())
  {
    MMechostr(MSKDEBUG, "input bitmap, is empty");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // coordinates
  int iposx = MMfetch(m, MTOP(icoordinates), 0);
  int iposy = MMfetch(m, MTOP(icoordinates), 1);
  if (iposx == NIL || iposy == NIL)
  {
    MMechostr(MSKDEBUG, "coordinates x or y are NIL");
    MMset(m, 0, NIL);
    return 0;
  }
  int posx = MTOI(iposx);
  int posy = MTOI(iposy);
 
  cv::Scalar color(0);
  if (icolor != NIL)
  {
    int c = MTOI(icolor) & 0xffffff;
    color = cv::Scalar((c >> 16) & 255, (c >> 8) & 255, c & 255);
  }
 
  // text
  std::string text = MMstartstr(m, MTOP(itext));
 
  if (text.empty())
  {
    return 0;
  }
 
  text = ReplaceAll(text, "\r\n", " ");
  text = ReplaceAll(text, "\r", " ");
  text = ReplaceAll(text, "\n", " ");
 
  PtrObjBTFont obj_font = MMgetPointer<PtrObjBTFont>(m, MTOP(ifont));
  if (!obj_font)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int alignment = BT_TEXT_HORIZ_LEFT | BT_TEXT_VERT_TOP;
  if (ialignmentFlags != NIL)
    alignment = MTOI(ialignmentFlags);
 
  // Alignment to coords
  // --------------------
  cv::Point cv_position;
  cv::Size line_size;
  
#ifdef BT_USE_FREETYPE
  if (obj_font->mode)
    line_size = obj_font->ft2->getTextSize(text, obj_font->size, obj_font->thickness, NULL);
  else
#endif
    line_size = cv::getTextSize(text, obj_font->face, obj_font->scale, obj_font->thickness, NULL);
 
  // Horizontal alignment
  switch (alignment & BT_TEXT_HORIZ_MASK)
  {
  case BT_TEXT_HORIZ_LEFT:
    cv_position.x = posx;
    break;
  case BT_TEXT_HORIZ_RIGHT:
    cv_position.x = posx - line_size.width;
    break;
  case BT_TEXT_HORIZ_CENTERED:
    cv_position.x = posx - line_size.width / 2;
    break;
  case BT_TEXT_HORIZ_JUSTIFIED:
    cv_position.x = posx - line_size.width / 2;
    break;
  default:
    cv_position.x = posx;
    break;
  }
 
  // Vertical alignment
  switch (alignment & BT_TEXT_VERT_MASK)
  {
  case BT_TEXT_VERT_TOP:
    cv_position.y = posy + line_size.height;
    break;
  case BT_TEXT_VERT_CENTER:
    cv_position.y = posy + line_size.height / 2;
    break;
  case BT_TEXT_VERT_BOTTOM:
    cv_position.y = posy;
    break;
  default:
    cv_position.y = posy + line_size.height;
    break;
  }
 
  // Draw to cv::Mat
  try
  {
#ifdef BT_USE_FREETYPE
    if (obj_font->mode)
      obj_font->ft2->putText(bitmap, text, cv_position, obj_font->size, color, obj_font->thickness, obj_font->linetype, true);
    else
#endif
      cv::putText(bitmap, text, cv_position, obj_font->face, obj_font->scale, color, obj_font->thickness, obj_font->linetype);
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "error on cv::putText : %s in %s:%s:%d", e.msg.c_str(), e.file.c_str(), e.func.c_str(), e.line);
  }
 
#ifdef SCOL_DEBUG
  cv::line(bitmap, cv::Point(cv_position.x - 4, cv_position.y), cv::Point(cv_position.x, cv_position.y), cv::Scalar(0, 125, 255));
  cv::line(bitmap, cv::Point(cv_position.x, cv_position.y), cv::Point(cv_position.x, cv_position.y + 4), cv::Scalar(0, 125, 255));
  cv::line(bitmap, cv::Point(posx - 4, posy), cv::Point(posx + 4, posy), cv::Scalar(0, 255, 125));
  cv::line(bitmap, cv::Point(posx, posy - 4), cv::Point(posx, posy + 4), cv::Scalar(0, 255, 125));
#endif
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTDRAWtextBitmap");
#endif
  return 0;
}
 
// FIX THE COPY PASTA
int _BTDRAWtextAreaBitmap(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTDRAWtextAreaBitmap");
#endif
 
  // Stack parameters
  int itext = MMpull(m);
  int icolor = MMpull(m);
  int ialignmentFlags = MMpull(m);
  int ioffset = MMpull(m);
  int icoordinates = MMpull(m);
  int ifont = MMpull(m);
  int ibitmap = MMget(m, 0);
  if (ibitmap == NIL || itext == NIL || icoordinates == NIL || ifont == NIL)
  {
    MMechostr(MSKDEBUG, "input bitmap, text or coordinates are NIL");
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Scalar color(0);
  if (icolor != NIL)
  {
    int c = MTOI(icolor) & 0xffffff;
    color = cv::Scalar((c >> 16) & 255, (c >> 8) & 255, c & 255);
  }
 
  // Mandatory parameters
  // --------------------
  // bitmap
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(ibitmap));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
 
  cv::Mat bitmap = ConversionTools::ScolBitmapToMat(obj_bitmap);
  if (bitmap.empty())
  {
    MMechostr(MSKDEBUG, "input bitmap, is empty");
    MMset(m, 0, NIL);
    return 0;
  }
 
  //offset
  cv::Point offset(0, 0);
  if (ioffset != NIL)
  {
    int ioffx = MMfetch(m, MTOP(ioffset), 0);
    int ioffy = MMfetch(m, MTOP(ioffset), 1);
 
    if (ioffx != NIL)
      offset.x = MTOI(ioffx);
 
    if (ioffy != NIL)
      offset.y = MTOI(ioffy);
  }
 
  // coordinates
  int iposx = MMfetch(m, MTOP(icoordinates), 0);
  int iposy = MMfetch(m, MTOP(icoordinates), 1);
  int iwidth = MMfetch(m, MTOP(icoordinates), 2);
  int iheight = MMfetch(m, MTOP(icoordinates), 3);
  if (iposx == NIL || iposy == NIL || iwidth == NIL || iheight == NIL)
  {
    MMechostr(MSKDEBUG, "coordinates x, y, or size width, height are NIL");
    MMset(m, 0, NIL);
    return 0;
  }
  int rect_posx = MTOI(iposx);
  int rect_posy = MTOI(iposy);
  int rect_width = MTOI(iwidth);
  int rect_height = MTOI(iheight);
 
  // check bounds
  if (rect_posx >= obj_bitmap->TailleW || rect_posy >= obj_bitmap->TailleH)
  {
    MMechostr(MSKRUNTIME, "_BTDRAWtextAreaAlphaBitmap : error, tried to write text outside the bitmap");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (rect_width <= 0 || rect_height <= 0)
  {
    MMechostr(MSKRUNTIME, "_BTDRAWtextAreaAlphaBitmap : error, negative rect bounds");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (rect_posx < 0)
    rect_posx = 0;
 
  if (rect_posy < 0)
    rect_posy = 0;
 
  if ((rect_posx + rect_width) > obj_bitmap->TailleW)
    rect_width = obj_bitmap->TailleW - rect_posx;
 
  if ((rect_posy + rect_height) > obj_bitmap->TailleH)
    rect_height = obj_bitmap->TailleH - rect_posy;
 
  // Rect to draw to
  cv::Rect brect(rect_posx, rect_posy, rect_width, rect_height);
 
  cv::Mat subBitmap = bitmap(brect);
 
  // text
  std::string text = MMstartstr(m, MTOP(itext));
 
  if (text.empty())
  {
    return 0;
  }
 
  // font
  PtrObjBTFont obj_font = MMgetPointer<PtrObjBTFont>(m, MTOP(ifont));
  if (!obj_font)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int alignment = BT_TEXT_HORIZ_LEFT | BT_TEXT_VERT_TOP;
  if (ialignmentFlags != NIL)
    alignment = MTOI(ialignmentFlags);
 
  // Alignment to coords
  // --------------------
  cv::Point cv_position;
  cv::Size line_size;
  int line_shiftSize;
  cv::Size base_size = obj_font->baseSize;
 
  line_shiftSize = (int)((float)base_size.height * obj_font->lineOffset) + abs(obj_font->thickness);
  std::vector<std::string> lines = word_wrap(text, obj_font, rect_width - (2 * obj_font->xoffset), (alignment & BT_TEXT_WORD_WRAP));
 
  switch (alignment & BT_TEXT_VERT_MASK)
  {
  case BT_TEXT_VERT_TOP:
    cv_position.y = line_shiftSize - (line_shiftSize - base_size.height) + obj_font->xoffset;
    break;
  case BT_TEXT_VERT_CENTER:
  {
    if (line_shiftSize * (int)lines.size() < rect_height)
    {
      cv_position.y = (rect_height / 2) - (((line_shiftSize * lines.size()) / 2) - base_size.height);
    }
    else
      cv_position.y = line_shiftSize;
  }
  break;
  case BT_TEXT_VERT_BOTTOM:
  {
    if (line_shiftSize * (int)lines.size() < rect_height)
    {
      cv_position.y = rect_height - (line_shiftSize * lines.size()) + base_size.height - obj_font->xoffset;
    }
    else
      cv_position.y = line_shiftSize;
  }
  break;
  default:
    cv_position.y = 0;
    break;
  }
  cv_position.y += offset.y;
 
  for (unsigned i = 0; i < lines.size(); i++)
  {
    if (!lines[i].empty())
    {
#ifdef BT_USE_FREETYPE
      if (obj_font->mode)
        line_size = obj_font->ft2->getTextSize(lines[i], obj_font->size, obj_font->thickness, NULL);
      else
#endif
        line_size = cv::getTextSize(lines[i], obj_font->face, obj_font->scale, obj_font->thickness, NULL);      
    }
 
    line_size.height = line_shiftSize;
 
    switch (alignment & BT_TEXT_HORIZ_MASK)
    {
    case BT_TEXT_HORIZ_LEFT:
      cv_position.x = obj_font->xoffset;
      break;
    case BT_TEXT_HORIZ_RIGHT:
      cv_position.x = rect_width - line_size.width - obj_font->xoffset;
      break;
    case BT_TEXT_HORIZ_CENTERED:
      cv_position.x = (rect_width / 2) - (line_size.width / 2);
      break;
    case BT_TEXT_HORIZ_JUSTIFIED:
      cv_position.x = obj_font->xoffset;
      break;
    default:
      cv_position.x = obj_font->xoffset;
      break;
    }
    cv_position.x += offset.x;
 
    // nothing different yet
    if (!lines[i].empty() && (cv_position.y < rect_height))
    {
#ifdef SCOL_DEBUG
      cv::line(subBitmap, cv::Point(cv_position.x - 4, cv_position.y), cv::Point(cv_position.x, cv_position.y), cv::Scalar(0, 125, 255));
      cv::line(subBitmap, cv::Point(cv_position.x, cv_position.y), cv::Point(cv_position.x, cv_position.y + 4), cv::Scalar(0, 125, 255));
#endif
 
      try
      {
#ifdef BT_USE_FREETYPE
        if (obj_font->mode)
          obj_font->ft2->putText(bitmap, lines[i], cv_position, obj_font->size, color, obj_font->thickness, obj_font->linetype, true);
        else
#endif
          cv::putText(subBitmap, lines[i], cv_position, obj_font->face, obj_font->scale, color, obj_font->thickness, obj_font->linetype);
      }
      catch (cv::Exception e)
      {
        MMechostr(MSKDEBUG, "error on cv::putText : %s in %s:%s:%d", e.msg.c_str(), e.file.c_str(), e.func.c_str(), e.line);
        break;
      }
    }
    cv_position.y += line_shiftSize;
 
    // no word wrap, draw only first line
    if ((alignment& BT_TEXT_WORD_WRAP) == 0)
      break;
  }
 
#ifdef SCOL_DEBUG
  cv::rectangle(subBitmap, cv::Rect(0, 0, rect_width, rect_height), cv::Scalar(255, 0, 0));
#endif
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTDRAWtextAreaBitmap");
#endif
  return 0;
}
 
int _BTDRAWtextAlphaBitmap(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTDRAWtextAlphaBitmap");
#endif
 
  // Stack parameters
  int itext = MMpull(m);
  int iopacity = MMpull(m);
  int icolor = MMpull(m);
  int ialignmentFlags = MMpull(m);
  int icoordinates = MMpull(m);
  int ifont = MMpull(m);
  int ibitmap = MMget(m, 0);
  if (ibitmap == NIL || itext == NIL || icoordinates == NIL || ifont == NIL)
  {
    MMechostr(MSKDEBUG, "input bitmap, text or coordinates are NIL");
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Scalar color(0);
  if (icolor != NIL)
  {
    int c = MTOI(icolor) & 0xffffff;
    color = cv::Scalar((c >> 16) & 255, (c >> 8) & 255, c & 255);
  }
 
  int opacity = 255;
  if (iopacity != NIL)
    opacity = MTOI(iopacity) & 0xff;
 
  cv::Scalar alpha = cv::Scalar(opacity);
 
  // Mandatory parameters
  // --------------------
  // bitmap
  int bmp24 = MMfetch(m, MTOP(ibitmap), 0);
  int bmp8 = MMfetch(m, MTOP(ibitmap), 1);
 
  // Get scol bitmaps
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(bmp24));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
 
  PtrObjVoid ptr_bitmap8 = (PtrObjVoid)MMstart(m, MTOP(bmp8));
  PtrObjBitmap obj_bitmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap8->Buffer));
 
  cv::Mat bitmap = ConversionTools::ScolBitmapToMat(obj_bitmap);
  if (bitmap.empty())
  {
    MMechostr(MSKDEBUG, "input bitmap, is empty");
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat bitmap8 = ConversionTools::ScolBitmapToMat(obj_bitmap8);
  if (bitmap8.empty())
  {
    MMechostr(MSKDEBUG, "input bitmap8, is empty");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // coordinates
  int iposx = MMfetch(m, MTOP(icoordinates), 0);
  int iposy = MMfetch(m, MTOP(icoordinates), 1);
  if (iposx == NIL || iposy == NIL)
  {
    MMechostr(MSKDEBUG, "coordinates x or y are NIL");
    MMset(m, 0, NIL);
    return 0;
  }
  int posx = MTOI(iposx);
  int posy = MTOI(iposy);
 
  // text
  std::string text = MMstartstr(m, MTOP(itext));
 
  if (text.empty())
  {
    return 0;
  }
 
  text = ReplaceAll(text, "\r\n", " ");
  text = ReplaceAll(text, "\r", " ");
  text = ReplaceAll(text, "\n", " ");
 
  // font
  PtrObjBTFont obj_font = MMgetPointer<PtrObjBTFont>(m, MTOP(ifont));
  if (!obj_font)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int alignment = BT_TEXT_HORIZ_LEFT | BT_TEXT_VERT_TOP;
  if (ialignmentFlags != NIL)
    alignment = MTOI(ialignmentFlags);
 
  // Alignment to coords
  // --------------------
  cv::Point cv_position;
  cv::Size line_size;
#ifdef BT_USE_FREETYPE
  if (obj_font->mode)
    line_size = obj_font->ft2->getTextSize(text, obj_font->size, obj_font->thickness, NULL);
  else
#endif
    line_size = cv::getTextSize(text, obj_font->face, obj_font->scale, obj_font->thickness, NULL);
 
  // Horizontal alignment
  switch (alignment & BT_TEXT_HORIZ_MASK)
  {
  case BT_TEXT_HORIZ_LEFT:
    cv_position.x = posx;
    break;
  case BT_TEXT_HORIZ_RIGHT:
    cv_position.x = posx - line_size.width;
    break;
  case BT_TEXT_HORIZ_CENTERED:
    cv_position.x = posx - line_size.width / 2;
    break;
  case BT_TEXT_HORIZ_JUSTIFIED:
    cv_position.x = posx - line_size.width / 2;
    break;
  default:
    cv_position.x = posx;
    break;
  }
 
  // Vertical alignment
  switch (alignment & BT_TEXT_VERT_MASK)
  {
  case BT_TEXT_VERT_TOP:
    cv_position.y = posy + line_size.height;
    break;
  case BT_TEXT_VERT_CENTER:
    cv_position.y = posy + line_size.height / 2;
    break;
  case BT_TEXT_VERT_BOTTOM:
    cv_position.y = posy;
    break;
  default:
    cv_position.y = posy + line_size.height;
    break;
  }
 
  // Draw to cv::Mat
  try
  {
#ifdef BT_USE_FREETYPE
    if (obj_font->mode)
    {
      obj_font->ft2->putText(bitmap, text, cv_position, obj_font->size, color, obj_font->thickness, obj_font->linetype, true);
      obj_font->ft2->putText(bitmap8, text, cv_position, obj_font->size, alpha, obj_font->thickness, obj_font->linetype, true);
    }
    else
#endif
    {
      cv::putText(bitmap, text, cv_position, obj_font->face, obj_font->scale, color, obj_font->thickness, obj_font->linetype);
      cv::putText(bitmap8, text, cv_position, obj_font->face, obj_font->scale, alpha, obj_font->thickness, obj_font->linetype);
    }
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "error on cv::putText : %s in %s:%s:%d", e.msg.c_str(), e.file.c_str(), e.func.c_str(), e.line);
  }
 
#ifdef SCOL_DEBUG
  cv::line(bitmap, cv::Point(cv_position.x - 4, cv_position.y), cv::Point(cv_position.x, cv_position.y), cv::Scalar(0, 125, 255));
  cv::line(bitmap, cv::Point(cv_position.x, cv_position.y), cv::Point(cv_position.x, cv_position.y + 4), cv::Scalar(0, 125, 255));
  cv::line(bitmap, cv::Point(posx - 4, posy), cv::Point(posx + 4, posy), cv::Scalar(0, 255, 125));
  cv::line(bitmap, cv::Point(posx, posy - 4), cv::Point(posx, posy + 4), cv::Scalar(0, 255, 125));
#endif
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTDRAWtextAlphaBitmap");
#endif
  return 0;
}
 
int _BTDRAWtextAreaAlphaBitmap(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTDRAWtextAreaAlphaBitmap\n");
#endif
 
  // Stack parameters
  int itext = MMpull(m);
  int iopacity = MMpull(m);
  int icolor = MMpull(m);
  int ialignmentFlags = MMpull(m);
  int ioffset = MMpull(m);
  int icoordinates = MMpull(m);
  int ifont = MMpull(m);
  int ibitmap = MMget(m, 0);
  if (ibitmap == NIL || itext == NIL || icoordinates == NIL || ifont == NIL)
  {
    MMechostr(MSKDEBUG, "input bitmap, text or coordinates are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // text
  std::string text = MMstartstr(m, MTOP(itext));
  if (text.empty())
  {
    MMechostr(MSKRUNTIME, "_BTDRAWtextAreaAlphaBitmap : text is nil\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Scalar color(0);
  if (icolor != NIL)
  {
    int c = MTOI(icolor) & 0xffffff;
    color = cv::Scalar((c >> 16) & 255, (c >> 8) & 255, c & 255);
  }
 
  int opacity = 255;
  if (iopacity != NIL)
    opacity = MTOI(iopacity) & 0xff;
 
  cv::Scalar alpha = cv::Scalar(opacity);
 
  // Mandatory parameters
  // --------------------
  // bitmap
  int bmp24 = MMfetch(m, MTOP(ibitmap), 0);
  int bmp8 = MMfetch(m, MTOP(ibitmap), 1);
 
  // Get scol bitmaps
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(bmp24));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
 
  PtrObjVoid ptr_bitmap8 = (PtrObjVoid)MMstart(m, MTOP(bmp8));
  PtrObjBitmap obj_bitmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap8->Buffer));
 
  cv::Mat bitmap = ConversionTools::ScolBitmapToMat(obj_bitmap);
  if (bitmap.empty())
  {
    MMechostr(MSKDEBUG, "input bitmap, is empty");
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat bitmap8 = ConversionTools::ScolBitmapToMat(obj_bitmap8);
  if (bitmap8.empty())
  {
    MMechostr(MSKDEBUG, "input bitmap8, is empty");
    MMset(m, 0, NIL);
    return 0;
  }
 
  //offset
  cv::Point offset(0, 0);
  if (ioffset != NIL)
  {
    int ioffx = MMfetch(m, MTOP(ioffset), 0);
    int ioffy = MMfetch(m, MTOP(ioffset), 1);
 
    if (ioffx != NIL)
      offset.x = MTOI(ioffx);
 
    if (ioffy != NIL)
      offset.y = MTOI(ioffy);
  }
 
  // coordinates
  int iposx = MMfetch(m, MTOP(icoordinates), 0);
  int iposy = MMfetch(m, MTOP(icoordinates), 1);
  int iwidth = MMfetch(m, MTOP(icoordinates), 2);
  int iheight = MMfetch(m, MTOP(icoordinates), 3);
  if (iposx == NIL || iposy == NIL || iwidth == NIL || iheight == NIL)
  {
    MMechostr(MSKDEBUG, "coordinates x, y, or size width, height are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int rect_posx = MTOI(iposx);
  int rect_posy = MTOI(iposy);
  int rect_width = MTOI(iwidth);
  int rect_height = MTOI(iheight);
 
  // check bounds
  if (rect_posx >= obj_bitmap->TailleW || rect_posy >= obj_bitmap->TailleH)
  {
    MMechostr(MSKRUNTIME, "_BTDRAWtextAreaAlphaBitmap : error, tried to write text outside the bitmap\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (rect_width <= 0 || rect_height <= 0)
  {
    MMechostr(MSKRUNTIME, "_BTDRAWtextAreaAlphaBitmap : error, negative rect bounds\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (rect_posx < 0)
    rect_posx = 0;
 
  if (rect_posy < 0)
    rect_posy = 0;
 
  if ((rect_posx + rect_width) > obj_bitmap->TailleW)
    rect_width = obj_bitmap->TailleW - rect_posx;
 
  if ((rect_posy + rect_height) > obj_bitmap->TailleH)
    rect_height = obj_bitmap->TailleH - rect_posy;
 
  // Rect to draw to
  cv::Rect brect(rect_posx, rect_posy, rect_width, rect_height);
 
  cv::Mat subBitmap = bitmap(brect);
  cv::Mat subBitmap8 = bitmap8(brect);
 
  // font
  PtrObjBTFont obj_font = MMgetPointer<PtrObjBTFont>(m, MTOP(ifont));
  if (!obj_font)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int alignment = BT_TEXT_HORIZ_LEFT | BT_TEXT_VERT_TOP;
  if (ialignmentFlags != NIL)
    alignment = MTOI(ialignmentFlags);
 
  // Alignment to coords
  // --------------------
  cv::Point cv_position;
  cv::Size line_size;  
  cv::Size base_size = obj_font->baseSize;
 
  int line_shiftSize = (int)((float)base_size.height * obj_font->lineOffset) + abs(obj_font->thickness);
  std::vector<std::string> lines = word_wrap(text, obj_font, rect_width - (2 * obj_font->xoffset), (alignment & BT_TEXT_WORD_WRAP));
 
  switch (alignment & BT_TEXT_VERT_MASK)
  {
  case BT_TEXT_VERT_TOP:
    cv_position.y = line_shiftSize - (line_shiftSize - base_size.height) + obj_font->xoffset;
    break;
  case BT_TEXT_VERT_CENTER:
  {
    if (line_shiftSize * (int)lines.size() < rect_height)
      cv_position.y = (rect_height / 2) - (((line_shiftSize * lines.size()) / 2) - base_size.height);
    else
      cv_position.y = line_shiftSize;
  }
  break;
  case BT_TEXT_VERT_BOTTOM:
  {
    if (line_shiftSize * (int)lines.size() < rect_height)
      cv_position.y = rect_height - (line_shiftSize * lines.size()) + base_size.height - obj_font->xoffset;
    else
      cv_position.y = line_shiftSize;
  }
  break;
  default:
    cv_position.y = 0;
    break;
  }
  cv_position.y += offset.y;
 
  for (unsigned i = 0; i < lines.size(); i++)
  {
    if (!lines[i].empty())
    {
#ifdef BT_USE_FREETYPE
      if (obj_font->mode)
        line_size = obj_font->ft2->getTextSize(lines[i], obj_font->size, obj_font->thickness, NULL);
      else
#endif
        line_size = cv::getTextSize(lines[i], obj_font->face, obj_font->scale, obj_font->thickness, NULL);
    }
 
    line_size.height = line_shiftSize;
 
    switch (alignment & BT_TEXT_HORIZ_MASK)
    {
    case BT_TEXT_HORIZ_LEFT:
      cv_position.x = obj_font->xoffset;
      break;
    case BT_TEXT_HORIZ_RIGHT:
      cv_position.x = rect_width - line_size.width - obj_font->xoffset;
      break;
    case BT_TEXT_HORIZ_CENTERED:
      cv_position.x = (rect_width / 2) - (line_size.width / 2);
      break;
    case BT_TEXT_HORIZ_JUSTIFIED:
      cv_position.x = obj_font->xoffset;
      break;
    default:
      cv_position.x = obj_font->xoffset;
      break;
    }
    cv_position.x += offset.x;
 
    if (!lines[i].empty() && (cv_position.y < rect_height))
    {
#ifdef SCOL_DEBUG
      cv::line(subBitmap, cv::Point(cv_position.x - 4, cv_position.y), cv::Point(cv_position.x, cv_position.y), cv::Scalar(0, 125, 255));
      cv::line(subBitmap, cv::Point(cv_position.x, cv_position.y), cv::Point(cv_position.x, cv_position.y + 4), cv::Scalar(0, 125, 255));
      cv::rectangle(subBitmap, cv::Rect(cv_position.x, cv_position.y - base_size.height, line_size.width, line_shiftSize), cv::Scalar(0, 125, 255));
#endif
 
      if (!lines[i].empty())
      {
        try
        {
#ifdef BT_USE_FREETYPE
          if (obj_font->mode)
          {
            obj_font->ft2->putText(subBitmap, lines[i], cv_position, obj_font->size, color, obj_font->thickness, obj_font->linetype, true);
            obj_font->ft2->putText(subBitmap8, lines[i], cv_position, obj_font->size, alpha, obj_font->thickness, obj_font->linetype, true);
          }
          else
#endif
          {
            cv::putText(subBitmap, lines[i], cv_position, obj_font->face, obj_font->scale, color, obj_font->thickness, obj_font->linetype);
            cv::putText(subBitmap8, lines[i], cv_position, obj_font->face, obj_font->scale, alpha, obj_font->thickness, obj_font->linetype);
          }
        }
        catch (cv::Exception e)
        {
          MMechostr(MSKDEBUG, "error on cv::putText : %s in %s:%s:%d", e.msg.c_str(), e.file.c_str(), e.func.c_str(), e.line);
          break;
        }
      }
    }
    cv_position.y += line_shiftSize;
 
    // no word wrap, draw only first line
    if ((alignment & BT_TEXT_WORD_WRAP) == 0)
      break;
  }
 
#ifdef SCOL_DEBUG
  cv::rectangle(subBitmap, cv::Rect(0, 0, rect_width, rect_height), cv::Scalar(255, 0, 0));
#endif
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTDRAWtextAreaAlphaBitmap\n");
#endif
  return 0;
}
 
int _BTGETtextSize(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTGETtextSize\n");
#endif
 
  int itext = MMpull(m);
  int ifont = MMget(m, 0);
 
  if (ifont == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string text = (itext == NIL) ? "" : MMstartstr(m, MTOP(itext));
 
  std::vector<std::string> lines;
 
  text = ReplaceAll(text, "\r\n", "\n");
  text = ReplaceAll(text, "\r", "\n");
  std::istringstream is_line(text);
  std::string line;
 
  while (getline(is_line, line, '\n'))
  {
    lines.push_back(line);
  }
 
  // font
  PtrObjBTFont obj_font = MMgetPointer<PtrObjBTFont>(m, MTOP(ifont));
  if (!obj_font)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int line_shiftSize = (int)((float)obj_font->baseSize.height * obj_font->lineOffset) + abs(obj_font->thickness);
  cv::Size linesize;
  cv::Size textsize(0, 0);
 
  for (unsigned i = 0; i < lines.size(); i++)
  {
    if (!lines[i].empty())
    {
#ifdef BT_USE_FREETYPE
      if (obj_font->mode)
        linesize = obj_font->ft2->getTextSize(lines[i], obj_font->size, obj_font->thickness, NULL);
      else
#endif
        linesize = cv::getTextSize(lines[i], obj_font->face, obj_font->scale, obj_font->thickness, NULL);
    }
    else
      linesize.width = 0;
    linesize.height = line_shiftSize;
 
    if (textsize.width < linesize.width)
      textsize.width = linesize.width;
    textsize.height += linesize.height;
  }
 
  textsize.width += obj_font->xoffset * 2;
  textsize.height += obj_font->xoffset * 2;
 
  int itextsize = MMmalloc(m, 2, TYPETAB);
  if (itextsize == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMstore(m, itextsize, 0, ITOM(textsize.width));
  MMstore(m, itextsize, 1, ITOM(textsize.height));
  MMset(m, 0, PTOM(itextsize));
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTGETtextSize\n");
#endif
  return 0;
}
 
int _BTGETtextAreaHeight(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTGETtextAreaHeight\n");
#endif
 
  int iwidth = MMpull(m);
  int ialignmentFlags = MMpull(m);
  int itext = MMpull(m);
  int ifont = MMget(m, 0);
 
  if (ifont == NIL || iwidth == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string text = (itext == NIL) ? "" : MMstartstr(m, MTOP(itext));
 
  // font
  PtrObjBTFont obj_font = MMgetPointer<PtrObjBTFont>(m, MTOP(ifont));
  if (!obj_font)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int width = MTOI(iwidth);
 
  cv::Size linesize;
  linesize.height = (int)((float)obj_font->baseSize.height * obj_font->lineOffset) + abs(obj_font->thickness);
 
  //should calc the size with the formated text ? (\r\n ...)
  if (!text.empty())
  {
    int alignment = BT_TEXT_HORIZ_LEFT | BT_TEXT_VERT_TOP;
    if (ialignmentFlags != NIL)
      alignment = MTOI(ialignmentFlags);
 
    // Alignment to coords
    // --------------------
    cv::Point cv_position;
    int line_shiftSize = (int)((float)obj_font->baseSize.height * obj_font->lineOffset) + abs(obj_font->thickness);
    std::vector<std::string> lines = word_wrap(text, obj_font, width - (2 * obj_font->xoffset), (alignment &BT_TEXT_WORD_WRAP));
 
    cv_position.y = obj_font->xoffset;
    for (unsigned i = 0; i < lines.size(); i++)
    {
      if (!lines[i].empty())
      {
#ifdef BT_USE_FREETYPE
        if (obj_font->mode)
          linesize = obj_font->ft2->getTextSize(lines[i], obj_font->size, obj_font->thickness, NULL);
        else
#endif
          linesize = cv::getTextSize(lines[i], obj_font->face, obj_font->scale, obj_font->thickness, NULL);
      }
 
      linesize.height = line_shiftSize;
 
      switch (alignment & BT_TEXT_HORIZ_MASK)
      {
      case BT_TEXT_HORIZ_LEFT:
        cv_position.x = obj_font->xoffset;
        break;
      case BT_TEXT_HORIZ_RIGHT:
        cv_position.x = width - linesize.width - obj_font->xoffset;;
        break;
      case BT_TEXT_HORIZ_CENTERED:
        cv_position.x = (width / 2) - (linesize.width / 2);
        break;
      case BT_TEXT_HORIZ_JUSTIFIED:
        cv_position.x = obj_font->xoffset;
        break;
      default:
        cv_position.x = obj_font->xoffset;
        break;
      }
 
      cv_position.y += line_shiftSize;
 
      // no word wrap, draw only first line
      if ((alignment & BT_TEXT_WORD_WRAP) == 0)
        break;
    }
    linesize.height = cv_position.y + obj_font->xoffset;
  }
 
  MMset(m, 0, ITOM(linesize.height));
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTGETtextAreaHeight\n");
#endif
  return 0;
}