BitmapToolkit.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) 2012 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
 
-----------------------------------------------------------------------------
*/
 
/*
 Toolkit based on OpenCV library
 First version : dec 2010
 Author : Bastien BOURINEAU
 */
 
#include <boost/filesystem.hpp>
#include "Prerequisites.h"
#include "BitmapToolkitText.h"
#include "ScolConvert.h"
 
int SObjBTFont;
int SObjBTMat;
 
// CV mat destruction callback
int destroyCVMat(mmachine m, SCOL_PTR_TYPE handsys, int obj)
{
  cv::Mat* obj_mat = MMgetPointer<cv::Mat*>(m, MTOP(obj));
  SAFE_DELETE(obj_mat);
  MMsetPointer<cv::Mat*>(m, MTOP(obj), 0);
 
  MMechostr(MSKDEBUG, "ObjBTMat destroyed.\n");
  return 0;
}
 
int _CRBTmat(mmachine m)
{
  int srcbitmap = MMpull(m);
  int channel = MMget(m, 0);
  if ((srcbitmap == NIL) || (channel == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int src_bmp24 = MMfetch(m, MTOP(srcbitmap), 0);
  int src_bmp8 = MMfetch(m, MTOP(srcbitmap), 1);
 
  if (src_bmp24 == NIL || src_bmp8 == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Get scol bitmaps
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(src_bmp24));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
  PtrObjVoid ptr_bitmap8 = (PtrObjVoid)MMstart(m, MTOP(src_bmp8));
  PtrObjBitmap obj_bitmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap8->Buffer));
 
  if ((obj_bitmap->bits == 0) || (obj_bitmap8->bits == 0))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat* mat = new cv::Mat(obj_bitmap->TailleH, obj_bitmap->TailleW, CV_8UC4);
  ConversionTools::ScolBitmapToMatRGBA(obj_bitmap, obj_bitmap8, *mat);
 
  // Store to tuple
  // ----------------
  if ((MMpushPointer(m, mat) != 0))
  {
    if (mat)
      SAFE_DELETE(mat);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, SObjBTMat, SCOL_PTR mat, NIL, 0);
}
 
int _DSBTmat(mmachine m)
{
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, SObjBTMat, obj);
  MMset(m, 0, ITOM(0));
  return 0;
}
 
int _BTGETmatBuffer(mmachine m)
{
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  cv::Mat* mat = MMgetPointer<cv::Mat*>(m, MTOP(obj));
 
  MMpull(m);
  if ((MMpushPointer(m, mat->data) != 0))
  {
    MMpush(m, NIL);
    return 0;
  }
  return 0;
}
 
int _BTBLURbitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTBLURbitmap\n");
#endif
 
  /* Get stack data*/
  int blurY = MMpull(m);
  int blurX = MMpull(m);
  int bitmap = MMget(m, 0);
 
  if ((bitmap == NIL) || ((blurY == NIL) && (blurX == NIL)))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  blurX = MTOI(blurX);
  blurY = MTOI(blurY);
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  try
  {
    cv::Size blursize(blurX, blurY);
    cv::blur(imagesrc, imagesrc, blursize);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTBLURbitmap error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTBLURbitmapBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTBLURbitmapBuffer\n");
#endif
 
  /* Get stack data*/
  int blurY = MMpull(m);
  int blurX = MMpull(m);
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
 
  if ((iBuff == NIL) || (iheight == NIL) || (iwidth == NIL) || (ibytesperpixel == NIL) || ((blurY == NIL) && (blurX == NIL)))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  blurX = MTOI(blurX);
  blurY = MTOI(blurY);
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    cv::Size blursize(blurX, blurY);
    cv::blur(imagesrc, imagesrc, blursize);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTBLURbitmapBuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTFILTERbitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTFILTERbitmap\n");
#endif
 
  /* Get stack data*/
  int itab = MMpull(m);
  int bitmap = MMget(m, 0);
 
  if ((bitmap == NIL) || (itab == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int s = MMsize(m, MTOP(itab));
  cv::Mat kernel = cv::Mat::ones(s, s, CV_32F) / (float)(s*s);
 
  float val = 0.0f;
  for (int i = 0; i < s; i++)
  {
    int jpp = MMfetch(m, MTOP(itab), i);
    if (jpp != NIL)
    {
      int sj = MMsize(m, MTOP(jpp));
      for (int j = 0; j < sj && j < s; j++)
      {
        val = MTOF(MMfetch(m, MTOP(jpp), j));
        kernel.at<float>(i, j) = val;
      }
    }
  }
  //normalize
  //kernel /= (float)(s*s);
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  try
  {
    cv::filter2D(imagesrc, imagesrc, -1, kernel);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTFILTERbitmap error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTFILTERbitmapBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTFILTERbitmapBuffer\n");
#endif
 
  /* Get stack data*/
  int itab = MMpull(m);
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
 
  if ((iBuff == NIL) || (iheight == NIL) || (iwidth == NIL) || (ibytesperpixel == NIL) || (itab == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int s = MMsize(m, MTOP(itab));
  cv::Mat kernel = cv::Mat::ones(s, s, CV_32F) / (float)(s*s);
 
  float val = 0.0f;
  for (int i = 0; i < s; i++)
  {
    int jpp = MMfetch(m, MTOP(itab), i);
    if (jpp != NIL)
    {
      int sj = MMsize(m, MTOP(jpp));
      for (int j = 0; j < sj && j < s; j++)
      {
        val = MTOF(MMfetch(m, MTOP(jpp), j));
        kernel.at<float>(i, j) = val;
      }
    }
  }
  //normalize
  //kernel /= (float)(s*s);
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    cv::filter2D(imagesrc, imagesrc, -1, kernel);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTFILTERbitmapBuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTBRIGHTNESSbitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTBRIGHTNESSbitmap\n");
#endif
 
  /* Get stack data*/
  int icoef = MMpull(m);
  int bitmap = MMget(m, 0);
 
  if ((bitmap == NIL) || (icoef == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  icoef = MTOI(icoef);
  float coef = (float)icoef / 100.0f;
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  cv::Mat hsv;
  try
  {
    cvtColor(imagesrc, hsv, cv::COLOR_BGR2HSV);
    cv::Mat channels[3];
    split(hsv, channels);
    cv::Mat H = channels[0];
    H.convertTo(H, CV_32F);
    cv::Mat S = channels[1];
    S.convertTo(S, CV_32F);
    cv::Mat V = channels[2];
    V.convertTo(V, CV_32F);
 
    for (int i = 0; i < H.size().height; i++)
    {
      for (int j = 0; j < H.size().width; j++)
      {
        // scale pixel values up or down for channel 1(Saturation)
        S.at<float>(i, j) *= coef;
        if (S.at<float>(i, j) > 255)
          S.at<float>(i, j) = 255;
        // scale pixel values up or down for channel 2(Value)
        V.at<float>(i, j) *= coef;
        if (V.at<float>(i, j) > 255)
          V.at<float>(i, j) = 255;
      }
    }
    H.convertTo(H, CV_8U);
    S.convertTo(S, CV_8U);
    V.convertTo(V, CV_8U);
    std::vector<cv::Mat> hsvChannels{ H,S,V };
    cv::Mat hsvNew;
    cv::merge(hsvChannels, hsvNew);
    cvtColor(hsvNew, imagesrc, cv::COLOR_HSV2BGR);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTBRIGHTNESSbitmap error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTBRIGHTNESSbitmapBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTBRIGHTNESSbitmapBuffer\n");
#endif
 
  /* Get stack data*/
  int icoef = MMpull(m);
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
 
  if ((iBuff == NIL) || (iheight == NIL) || (iwidth == NIL) || (ibytesperpixel == NIL) || (icoef == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  icoef = MTOI(icoef);
  float coef = (float)icoef / 100.0f;
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat hsv;
  try
  {
    cvtColor(imagesrc, hsv, cv::COLOR_BGR2HSV);
    cv::Mat channels[3];
    split(hsv, channels);
    cv::Mat H = channels[0];
    H.convertTo(H, CV_32F);
    cv::Mat S = channels[1];
    S.convertTo(S, CV_32F);
    cv::Mat V = channels[2];
    V.convertTo(V, CV_32F);
 
    for (int i = 0; i < H.size().height; i++)
    {
      for (int j = 0; j < H.size().width; j++)
      {
        // scale pixel values up or down for channel 1(Saturation)
        S.at<float>(i, j) *= coef;
        if (S.at<float>(i, j) > 255)
          S.at<float>(i, j) = 255;
        // scale pixel values up or down for channel 2(Value)
        V.at<float>(i, j) *= coef;
        if (V.at<float>(i, j) > 255)
          V.at<float>(i, j) = 255;
      }
    }
    H.convertTo(H, CV_8U);
    S.convertTo(S, CV_8U);
    V.convertTo(V, CV_8U);
    std::vector<cv::Mat> hsvChannels{ H,S,V };
    cv::Mat hsvNew;
    cv::merge(hsvChannels, hsvNew);
    cvtColor(hsvNew, imagesrc, cv::COLOR_HSV2BGR);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTBRIGHTNESSbitmapBuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTLAPLACEbitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTLAPLACEbitmap\n");
#endif
 
  /* Get stack data*/
  int iksize = MMpull(m);
  int iddepth = MMpull(m);
  int bitmap = MMget(m, 0);
 
  if ((bitmap == NIL) || (iddepth == NIL) || (iksize == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int ksize = MTOI(iksize);
  int ddepth = MTOI(iddepth);
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  try
  {
    cv::Laplacian(imagesrc, imagesrc, ddepth, ksize);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTLAPLACEbitmap error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTLAPLACEbitmapBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTLAPLACEbitmapBuffer\n");
#endif
 
  /* Get stack data*/
  int iksize = MMpull(m);
  int iddepth = MMpull(m);
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
 
  if ((iBuff == NIL) || (iheight == NIL) || (iwidth == NIL) || (ibytesperpixel == NIL) || (iksize == NIL) || (iddepth == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int ksize = MTOI(iksize);
  int ddepth = MTOI(iddepth);
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    cv::Laplacian(imagesrc, imagesrc, ddepth, ksize);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTLAPLACEbitmapBuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTFLIPbitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTFLIPbitmap\n");
#endif
 
  /* Get stack data*/
  int bitmap = MMget(m, 0);
 
  if (bitmap == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  try
  {
    cv::flip(imagesrc, imagesrc, 1);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTFLIPbitmap error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTFLIPbuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTFLIPbuffer\n");
#endif
 
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
  if ((iBuff == NIL) || (iwidth == NIL) || (iheight == NIL) || (ibytesperpixel == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel, false);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    cv::flip(imagesrc, imagesrc, 1);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTFLIPbuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
#define ROW_PTR(img, y) ((uchar*)((img).data + (img).step * y))
int _BTNORMALbitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTNORMALbitmap\n");
#endif
 
  /* Get stack data*/
  int iblur = MMpull(m);
  int istrength = MMpull(m);
  int bitmap = MMget(m, 0);
 
  if (bitmap == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float strength = 1.0f;
  if (istrength != NIL)
    strength = MTOF(istrength);
 
  float blur = 0.0f;
  if (iblur != NIL)
    blur = MTOF(iblur);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  try
  {
    double scale = 1.0;
    int delta = 127;
 
    cv::Mat bwTexture;
    if (imagesrc.channels() != 1)
      cv::cvtColor(imagesrc, bwTexture, cv::COLOR_BGR2GRAY);
    else
      imagesrc.copyTo(bwTexture);
 
    cv::Mat sobelZ, sobelX, sobelY;
    cv::Sobel(bwTexture, sobelX, CV_8U, 1, 0, 3, scale, delta, cv::BORDER_DEFAULT);
    cv::Sobel(bwTexture, sobelY, CV_8U, 0, 1, 3, scale, delta, cv::BORDER_DEFAULT);
    cv::convertScaleAbs(sobelX, sobelX, 0.125, 127.5);
    cv::convertScaleAbs(sobelY, sobelY, 0.125, 127.5);
 
    sobelZ = cv::Mat(bwTexture.rows, bwTexture.cols, CV_8UC1);
 
    for (int y = 0; y < bwTexture.rows; y++)
    {
      uchar *sobelXPtr = ROW_PTR(sobelX, y);
      uchar *sobelYPtr = ROW_PTR(sobelY, y);
      uchar *sobelZPtr = ROW_PTR(sobelZ, y);
 
      for (int x = 0; x < bwTexture.cols; x++)
      {
        double Gx = ((double(sobelXPtr[x]) * 2.0) / 255.0) - 1.0;
        double Gy = -(((double(sobelYPtr[x]) * 2.0) / 255.0) - 1.0);
        
        cv::Vec3d dx = cv::Vec3d{ 1.0, 0.0, Gx };
        cv::Vec3d dy = cv::Vec3d{ 0.0, 1.0, Gy };
        dx = cv::normalize(dx);
        dy = cv::normalize(dy);
 
        cv::Vec3d nm = dx.cross(dy) * strength;
        nm = cv::normalize(nm);
        nm = (nm * 128.0) + cv::Vec3d{ 128.0, 128.0, 128.0 };
        sobelXPtr[x] = uchar(nm[2]);
        sobelYPtr[x] = uchar(nm[1]);
        sobelZPtr[x] = uchar(nm[0]);
      }
    }
 
    std::vector<cv::Mat>planes;
    planes.push_back(sobelX);
    planes.push_back(sobelY);
    planes.push_back(sobelZ);
 
    cv::Mat normalMap;
    cv::merge(planes, normalMap);
 
    if (blur > 0.0f)
    {
      cv::Mat originalNormalMap = normalMap.clone();
      cv::Mat normalMapBlurred;
 
      for (int i = 0; i < 3; i++)
      {
        cv::GaussianBlur(normalMap, normalMapBlurred, cv::Size(13, 13), 5.0f * blur, 5.0f * blur);
        addWeighted(normalMap, 0.4, normalMapBlurred, 0.6, 0, normalMap);
      }
      addWeighted(originalNormalMap, 0.3, normalMapBlurred, 0.7, 0, normalMap);
    }
    else if (blur < 0.0f)
    {
      float sharp = std::min(abs(blur), 1.0f);
      cv::Mat originalNormalMap = normalMap.clone();
      cv::Mat normalMapSharpen;
      cv::Mat kernel(3, 3, CV_32F, cv::Scalar(0));
      // sharpen
      kernel.at<float>(1, 1) = 5.0;
      kernel.at<float>(0, 1) = -1.0;
      kernel.at<float>(2, 1) = -1.0;
      kernel.at<float>(1, 0) = -1.0;
      kernel.at<float>(1, 2) = -1.0;
      cv::filter2D(normalMap, normalMapSharpen, -1, kernel);
 
      addWeighted(originalNormalMap, 1.0f - sharp, normalMapSharpen, sharp, 0.0, normalMap);
    }
    normalMap.copyTo(imagesrc);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTNORMALbitmap error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTNORMALbitmapBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTNORMALbitmapBuffer\n");
#endif
 
  int iblur = MMpull(m);
  int istrength = MMpull(m);
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
  if ((iBuff == NIL) || (iwidth == NIL) || (iheight == NIL) || (ibytesperpixel == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel, false);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float strength = 1.0f;
  if (istrength != NIL)
    strength = MTOF(istrength);
 
  float blur = 0.0f;
  if (iblur != NIL)
    blur = MTOF(iblur);
  
  try
  {
    double scale = 1.0;
    int delta = 127;
    cv::Mat bwTexture;
    if (imagesrc.channels() != 1)
      cv::cvtColor(imagesrc, bwTexture, cv::COLOR_BGR2GRAY);
    else
      imagesrc.copyTo(bwTexture);
 
    cv::Mat sobelZ, sobelX, sobelY;
    cv::Sobel(bwTexture, sobelX, CV_8U, 1, 0, 3, scale, delta, cv::BORDER_DEFAULT);
    cv::Sobel(bwTexture, sobelY, CV_8U, 0, 1, 3, scale, delta, cv::BORDER_DEFAULT);
    cv::convertScaleAbs(sobelX, sobelX, 0.125, 127.5);
    cv::convertScaleAbs(sobelY, sobelY, 0.125, 127.5);
 
    sobelZ = cv::Mat(bwTexture.rows, bwTexture.cols, CV_8UC1);
 
    for (int y = 0; y < bwTexture.rows; y++)
    {
      uchar *sobelXPtr = ROW_PTR(sobelX, y);
      uchar *sobelYPtr = ROW_PTR(sobelY, y);
      uchar *sobelZPtr = ROW_PTR(sobelZ, y);
 
      for (int x = 0; x < bwTexture.cols; x++)
      {
        double Gx = ((double(sobelXPtr[x]) * 2.0) / 255.0) - 1.0;
        double Gy = -(((double(sobelYPtr[x]) * 2.0) / 255.0) - 1.0);
 
        cv::Vec3d dx = cv::Vec3d{ 1.0, 0.0, Gx };
        cv::Vec3d dy = cv::Vec3d{ 0.0, 1.0, Gy };
        dx = cv::normalize(dx);
        dy = cv::normalize(dy);
 
        cv::Vec3d nm = dx.cross(dy) * strength;
        nm = cv::normalize(nm);
        nm = (nm * 128.0) + cv::Vec3d{ 128.0, 128.0, 128.0 };
        sobelXPtr[x] = uchar(nm[2]);
        sobelYPtr[x] = uchar(nm[1]);
        sobelZPtr[x] = uchar(nm[0]);
      }
    }
 
    std::vector<cv::Mat>planes;
    planes.push_back(sobelX);
    planes.push_back(sobelY);
    planes.push_back(sobelZ);
 
    cv::Mat normalMap;
    cv::merge(planes, normalMap);
 
    if (blur > 0.0f)
    {
      cv::Mat originalNormalMap = normalMap.clone();
      cv::Mat normalMapBlurred;
 
      for (int i = 0; i < 3; i++)
      {
        cv::GaussianBlur(normalMap, normalMapBlurred, cv::Size(13, 13), 5.0f * blur, 5.0f * blur);
        addWeighted(normalMap, 0.4, normalMapBlurred, 0.6, 0, normalMap);
      }
      addWeighted(originalNormalMap, 0.3, normalMapBlurred, 0.7, 0, normalMap);
    }
    else if (blur < 0.0f)
    {
      float sharp = std::min(abs(blur), 1.0f);
      cv::Mat originalNormalMap = normalMap.clone();
      cv::Mat normalMapSharpen;
      cv::Mat kernel(3, 3, CV_32F, cv::Scalar(0));
      // sharpen
      kernel.at<float>(1, 1) = 5.0;
      kernel.at<float>(0, 1) = -1.0;
      kernel.at<float>(2, 1) = -1.0;
      kernel.at<float>(1, 0) = -1.0;
      kernel.at<float>(1, 2) = -1.0;
      cv::filter2D(normalMap, normalMapSharpen, -1, kernel);
 
      addWeighted(originalNormalMap, 1.0f - sharp, normalMapSharpen, sharp, 0.0, normalMap);
    }
    normalMap.copyTo(imagesrc);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTNORMALbitmapBuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTDRAWcircle(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWcircle\n");
#endif
 
  /* Get stack data*/
  int ifill_color = MMpull(m);
  int ifilled = MMpull(m);
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int iradius = MMpull(m);
  int ipos = MMpull(m);
  int bitmap = MMget(m, 0);
 
  if ((bitmap == NIL) || (ipos == NIL) || (iradius == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // bitmap
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
 
  if (obj_bitmap->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(obj_bitmap);
 
  // position
  int iposX = MMfetch(m, MTOP(ipos), 0);
  int iposY = MMfetch(m, MTOP(ipos), 1);
  if (iposX == NIL || iposY == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  //stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (obj_bitmap->BytesPP == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
 
  // fill
  bool filled = false;
  if (ifilled != NIL)
    filled = (MTOI(ifilled) != 0);
 
  // draw filled
  if (filled)
  {
    cv::Scalar fill_color(0);
    if (ifill_color != NIL)
    {
      int color = MTOI(ifill_color);
      if (obj_bitmap->BytesPP == 1)
        fill_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
      else
        fill_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
    }
    try
    {
      cv::circle(imagesrc, cv::Point(MTOI(iposX), MTOI(iposY)), MTOI(iradius), fill_color, -1, 8);
    }
    catch (cv::Exception e)
    {
      MMechostr(MSKDEBUG, "%s", e.err.c_str());
    }
  }
 
  // draw stroke
  try
  {
    cv::circle(imagesrc, cv::Point(MTOI(iposX), MTOI(iposY)), MTOI(iradius), stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTDRAWcircle error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTDRAWcircleBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWcircleBuffer\n");
#endif
 
  int ifill_color = MMpull(m);
  int ifilled = MMpull(m);
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int iradius = MMpull(m);
  int ipos = MMpull(m);
 
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
  if ((iBuff == NIL) || (iwidth == NIL) || (iheight == NIL) || (ibytesperpixel == NIL) || (ipos == NIL) || (iradius == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // position
  int iposX = MMfetch(m, MTOP(ipos), 0);
  int iposY = MMfetch(m, MTOP(ipos), 1);
  if (iposX == NIL || iposY == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  //stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (ibytesperpixel == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
 
  // fill
  bool filled = false;
  if (ifilled != NIL)
    filled = (MTOI(ifilled) != 0);
 
  // draw filled
  if (filled)
  {
    cv::Scalar fill_color(0);
    if (ifill_color != NIL)
    {
      int color = MTOI(ifill_color);
      if (ibytesperpixel == 1)
        fill_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
      else
        fill_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
    }
    try
    {
      cv::circle(imagesrc, cv::Point(MTOI(iposX), MTOI(iposY)), MTOI(iradius), fill_color, -1, 8);
    }
    catch (cv::Exception e)
    {
      MMechostr(MSKDEBUG, "%s", e.err.c_str());
    }
  }
 
  // draw stroke
  try
  {
    cv::circle(imagesrc, cv::Point(MTOI(iposX), MTOI(iposY)), MTOI(iradius), stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTDRAWcircleBuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTDRAWrect(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWrect\n");
#endif
 
  int ifill_color = MMpull(m);
  int ifilled = MMpull(m);
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int irect = MMpull(m);
  int ibitmap = MMget(m, 0);
 
  if (ibitmap == NIL || irect == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // bitmap
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(ibitmap));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(obj_bitmap);
 
  // rect
  int iposx = MMfetch(m, MTOP(irect), 0);
  int iposy = MMfetch(m, MTOP(irect), 1);
  int iwidth = MMfetch(m, MTOP(irect), 2);
  int iheight = MMfetch(m, MTOP(irect), 3);
  if (iposx == NIL || iposy == NIL || iwidth == NIL || iheight == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int posx = MTOI(iposx);
  int posy = MTOI(iposy);
  int width = MTOI(iwidth);
  int height = MTOI(iheight);
  cv::Rect rect(posx, posy, width, height);
 
  if (rect.width < 0)
  {
    rect.width = abs(rect.width);
    rect.x = rect.x - rect.width;
  }
 
  if (rect.height < 0)
  {
    rect.height = abs(rect.height);
    rect.y = rect.y - rect.height;
  }
 
  // stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (obj_bitmap->BytesPP == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
 
  // fill
  bool filled = false;
  if (ifilled != NIL)
    filled = (MTOI(ifilled) != 0);
 
  // draw filled
  if (filled)
  {
    cv::Scalar fill_color(0);
    if (ifill_color != NIL)
    {
      int color = MTOI(ifill_color);
      if (obj_bitmap->BytesPP == 1)
        fill_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
      else
        fill_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
    }
    try
    {
      cv::rectangle(imagesrc, rect, fill_color, -1, 8);
    }
    catch (cv::Exception e)
    {
      MMechostr(MSKDEBUG, "%s", e.err.c_str());
    }
  }
 
  // draw stroke
  try
  {
    cv::rectangle(imagesrc, rect, stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "%s", e.err.c_str());
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "end _BTDRAWrect\n");
#endif
 
  return 0;
}
 
int _BTDRAWrectBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWrectBuffer\n");
#endif
 
  int ifill_color = MMpull(m);
  int ifilled = MMpull(m);
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int irect = MMpull(m);
 
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
  if ((iBuff == NIL) || (iwidth == NIL) || (iheight == NIL) || (ibytesperpixel == NIL) || (irect == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // rect
  int iposx = MMfetch(m, MTOP(irect), 0);
  int iposy = MMfetch(m, MTOP(irect), 1);
  int irwidth = MMfetch(m, MTOP(irect), 2);
  int irheight = MMfetch(m, MTOP(irect), 3);
  if (iposx == NIL || iposy == NIL || irwidth == NIL || irheight == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int rposx = MTOI(iposx);
  int rposy = MTOI(iposy);
  int rwidth = MTOI(irwidth);
  int rheight = MTOI(irheight);
  cv::Rect rect(rposx, rposy, rwidth, rheight);
 
  if (rect.width < 0)
  {
    rect.width = abs(rect.width);
    rect.x = rect.x - rect.width;
  }
 
  if (rect.height < 0)
  {
    rect.height = abs(rect.height);
    rect.y = rect.y - rect.height;
  }
 
  // stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (ibytesperpixel == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
 
  // fill
  bool filled = false;
  if (ifilled != NIL)
    filled = (MTOI(ifilled) != 0);
 
  // draw filled
  if (filled)
  {
    cv::Scalar fill_color(0);
    if (ifill_color != NIL)
    {
      int color = MTOI(ifill_color);
      if (ibytesperpixel == 1)
        fill_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
      else
        fill_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
    }
    try
    {
      cv::rectangle(imagesrc, rect, fill_color, -1, 8);
    }
    catch (cv::Exception e)
    {
      MMechostr(MSKDEBUG, "%s", e.err.c_str());
    }
  }
 
  // draw stroke
  try
  {
    cv::rectangle(imagesrc, rect, stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "%s", e.err.c_str());
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "end _BTDRAWrectBuffer\n");
#endif
 
  return 0;
}
 
 
int _BTDRAWline(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWline\n");
#endif
 
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int iend = MMpull(m);
  int istart = MMpull(m);
  int ibitmap = MMget(m, 0);
 
  if ((ibitmap == NIL) || (istart == NIL) || (iend == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // bitmap
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(ibitmap));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(obj_bitmap);
 
  // line coords
  int istartx = MMfetch(m, MTOP(istart), 0);
  int istarty = MMfetch(m, MTOP(istart), 1);
  int idestx = MMfetch(m, MTOP(iend), 0);
  int idesty = MMfetch(m, MTOP(iend), 1);
  if (istartx == NIL || istarty == NIL || idestx == NIL || idesty == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Point stpoint(MTOI(istartx), MTOI(istarty));
  cv::Point dstpoint(MTOI(idestx), MTOI(idesty));
 
  // stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (obj_bitmap->BytesPP == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
  
  // draw line
  try
  {
    cv::line(imagesrc, stpoint, dstpoint, stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "%s", e.err.c_str());
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "end _BTDRAWline\n");
#endif
 
  return 0;
}
 
int _BTDRAWlineBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWlineBuffer\n");
#endif
 
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int iend = MMpull(m);
  int istart = MMpull(m);
 
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
  if ((iBuff == NIL) || (iwidth == NIL) || (iheight == NIL) || (ibytesperpixel == NIL) || (istart == NIL) || (iend == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // line coords
  int istartx = MMfetch(m, MTOP(istart), 0);
  int istarty = MMfetch(m, MTOP(istart), 1);
  int idestx = MMfetch(m, MTOP(iend), 0);
  int idesty = MMfetch(m, MTOP(iend), 1);
  if (istartx == NIL || istarty == NIL || idestx == NIL || idesty == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Point stpoint(MTOI(istartx), MTOI(istarty));
  cv::Point dstpoint(MTOI(idestx), MTOI(idesty));
 
  // stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (ibytesperpixel == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
 
  // draw line
  try
  {
    cv::line(imagesrc, stpoint, dstpoint, stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "%s", e.err.c_str());
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "end _BTDRAWlineBuffer\n");
#endif
 
  return 0;
}
 
 
int _BTDRAWpath(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWpath\n");
#endif
 
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int ilist = MMpull(m);
  int ibitmap = MMget(m, 0);
 
  if ((ibitmap == NIL) || (ilist == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // bitmap
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(ibitmap));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(obj_bitmap);
 
  std::vector<cv::Point2i> linepath;
  // Load points
  if (ilist != NIL)
  {
    // Iterate through the recursive tuple
    int pointTuple;
    int x, y;
    ilist = MTOP(ilist);
    while (ilist != NIL)
    {
      // Get point coordinate
      pointTuple = MTOP(MMfetch(m, ilist, 0));
      x = MTOI(MMfetch(m, pointTuple, 0));
      y = MTOI(MMfetch(m, pointTuple, 1));
      ilist = MTOP(MMfetch(m, ilist, 1));
 
      // Add point
      linepath.push_back(cv::Point2i(x, y));
    }
  }
 
  // stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (obj_bitmap->BytesPP == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
 
  // draw line
  try
  {
    cv::polylines(imagesrc, linepath, false, stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "%s", e.err.c_str());
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "end _BTDRAWpath\n");
#endif
 
  return 0;
}
 
int _BTDRAWpathBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTDRAWpathBuffer\n");
#endif
 
  int istroke_thickness = MMpull(m);
  int istroke_color = MMpull(m);
  int ilist = MMpull(m);
 
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMget(m, 0);
  if ((iBuff == NIL) || (iwidth == NIL) || (iheight == NIL) || (ibytesperpixel == NIL) || (ilist == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::vector<cv::Point2i> linepath;
  // Load points
  if (ilist != NIL)
  {
    // Iterate through the recursive tuple
    int pointTuple;
    int x, y;
    ilist = MTOP(ilist);
    while (ilist != NIL)
    {
      // Get point coordinate
      pointTuple = MTOP(MMfetch(m, ilist, 0));
      x = MTOI(MMfetch(m, pointTuple, 0));
      y = MTOI(MMfetch(m, pointTuple, 1));
      ilist = MTOP(MMfetch(m, ilist, 1));
 
      // Add point
      linepath.push_back(cv::Point2i(x, y));
    }
  }
 
  // stroke
  cv::Scalar stroke_color(0);
  int stroke_thickness = 1;
  if (istroke_color != NIL)
  {
    int color = MTOI(istroke_color);
    if (ibytesperpixel == 1)
      stroke_color = cv::Scalar(color & 255, color & 255, color & 255, 255);
    else
      stroke_color = cv::Scalar((color >> 16) & 255, (color >> 8) & 255, color & 255, 255);
  }
 
  if (istroke_thickness != NIL)
    stroke_thickness = MTOI(istroke_thickness);
 
  // draw line
  try
  {
    cv::polylines(imagesrc, linepath, false, stroke_color, stroke_thickness, 8);
  }
  catch (cv::Exception e)
  {
    MMechostr(MSKDEBUG, "%s", e.err.c_str());
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "end _BTDRAWpathBuffer\n");
#endif
 
  return 0;
}
 
int _BTMOTIONdetect(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTMOTIONdetect\n");
#endif
 
  /* Get stack data*/
  int sensivity = MMpull(m);
  int threshold = MMpull(m);
  int cbitmap = MMpull(m);
  int pbitmap = MMget(m, 0);
 
  if ((pbitmap == NIL) || (cbitmap == NIL) || (threshold == NIL) || (sensivity == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid pOB = (PtrObjVoid)MMstart(m, MTOP(pbitmap));
  PtrObjBitmap pB = (PtrObjBitmap)MMstart(m, MTOP(pOB->Buffer));
 
  PtrObjVoid cOB = (PtrObjVoid)MMstart(m, MTOP(cbitmap));
  PtrObjBitmap cB = (PtrObjBitmap)MMstart(m, MTOP(cOB->Buffer));
 
  if ((pB->TailleW != cB->TailleW) || (pB->TailleH != cB->TailleH))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat diff(cB->TailleH, cB->TailleW, CV_8UC3);
  cv::Mat tmp(cB->TailleH, cB->TailleW, CV_8UC3);
  try
  {
    cv::Mat prevImage = ConversionTools::ScolBitmapToMat(pB);
    cv::Mat curImage = ConversionTools::ScolBitmapToMat(cB);
    cv::absdiff(prevImage, curImage, diff);
 
    //Convert the image to grayscale.
    cv::cvtColor(diff, tmp, cv::COLOR_RGB2GRAY);
 
    //Convert the image to black and white.
    cv::threshold(tmp, tmp, MTOI(threshold), 255, cv::THRESH_BINARY);
 
 
    //Dilate and erode to get people blobs
    //cv::dilate(tmp, tmp, 0, 18);
    //cv::dilate(tmp, tmp, 0, 10);
 
    //Find the contours of the moving images in the frame.
    //std::vector< std::vector<cv::Point> > contour;
    //cv::findContours(tmp, contour, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
 
    //cv::cvtColor(tmp, curImage, CV_GRAY2RGB);
    //ConversionTools::MatToScolBitmapRGB(curImage, cB);
    int count = cv::countNonZero(tmp);
    float percent = ((float)count / (float)(cB->TailleH * cB->TailleW)) * 100.0f;
 
    MMset(m, 0, ITOM(percent >= ((100.0f - (float)MTOI(sensivity)) / 100.0f) ? 1 : 0));
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTMOTIONdetect error %s\n", e.what());
    MMset(m, 0, NIL);
  }
 
  tmp.release();
  diff.release();
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTCompBitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTCompBitmap\n");
#endif
 
  /* Get stack data*/
  int ifactor = MMpull(m);
  int bitmap = MMget(m, 0);
 
  if (bitmap == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int factor = 1;
  if ((ifactor != NIL) && (MTOI(ifactor) > 0))
    factor = MTOI(ifactor);
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::vector<int> p;
  p.push_back(cv::IMWRITE_JPEG_QUALITY);
  p.push_back(factor);
  std::vector<unsigned char> buf;
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  try
  {
    imencode(".jpg", imagesrc, buf, p);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTCompBitmap error %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (buf.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  char* scolbuf = 0;
  int res = MMmalloc(m, STR_SIZE(buf.size()), TYPEBUF);
  if (res == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, res, 0, buf.size());
  char* buffer = MMstartstr(m, res);
  std::vector<unsigned char>::iterator it;
  int i = 0;
  for (it = buf.begin(); it < buf.end(); it++)
  {
    buffer[i] = *it;
    i++;
  }
  buffer[buf.size()] = 0;
  MMset(m, 0, PTOM(res));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTUnCompBitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTUnCompBitmap\n");
#endif
 
  /* Get stack data*/
  int bitmap = MMpull(m);
  int idata = MMget(m, 0);
 
  if ((bitmap == NIL) || (idata == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int msize = MMsizestr(m, MTOP(idata));
  char* smess = (char*)MMstart(m, MTOP(idata) + 1);
 
  //fill the buffer
  std::vector<char> data(smess, smess + msize);
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(B);
  try
  {
    cv::imdecode(cv::Mat(data), 1, &imagesrc);
    MMset(m, 0, bitmap);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTUnCompBitmap error %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTSCALEbitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTSCALEbitmap\n");
#endif
 
  /* Get stack data*/
  int method = MMpull(m);
  int srcbitmap = MMpull(m);
  int dstbitmap = MMget(m, 0);
 
  if ((srcbitmap == NIL) || (dstbitmap == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  switch (method)
  {
  case 0:
    method = cv::INTER_NEAREST;
    break;
 
  case 1:
    method = cv::INTER_LINEAR;
    break;
 
  case 2:
    method = cv::INTER_CUBIC;
    break;
 
  case 3:
    method = cv::INTER_AREA;
    break;
 
  case 4:
    method = cv::INTER_LANCZOS4;
    break;
 
  case 5:
    method = cv::INTER_MAX;
    break;
 
  case 6:
    method = cv::WARP_INVERSE_MAP;
    break;
 
  default:
    method = cv::INTER_LINEAR;
  }
 
  PtrObjVoid OBs = (PtrObjVoid)MMstart(m, MTOP(srcbitmap));
  PtrObjBitmap Bs = (PtrObjBitmap)MMstart(m, MTOP(OBs->Buffer));
 
  PtrObjVoid OBd = (PtrObjVoid)MMstart(m, MTOP(dstbitmap));
  PtrObjBitmap Bd = (PtrObjBitmap)MMstart(m, MTOP(OBd->Buffer));
 
 
  if (Bs->bits == 0 || Bd->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat imgdest = ConversionTools::ScolBitmapToMat(Bd);
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(Bs);
  try
  {
    cv::resize(imagesrc, imgdest, cv::Size(Bd->TailleW, Bd->TailleH), 0, 0, method);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTSCALEbitmap error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTSCALEalphaBitmap(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTSCALEbitmap\n");
#endif
 
  /* Get stack data*/
  int method = MMpull(m);
  int srcbitmap = MMpull(m);
  int dstbitmap = MMget(m, 0);
 
  if ((srcbitmap == NIL) || (dstbitmap == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int src_bmp24 = MMfetch(m, MTOP(srcbitmap), 0);
  int src_bmp8 = MMfetch(m, MTOP(srcbitmap), 1);
  int dst_bmp24 = MMfetch(m, MTOP(dstbitmap), 0);
  int dst_bmp8 = MMfetch(m, MTOP(dstbitmap), 1);
 
  if ((src_bmp24 == NIL) || (dst_bmp24 == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool hasBmp8 = ((src_bmp8 != NIL) && (dst_bmp8 != NIL)) ? true : false;
 
  //BMP24
  // Get scol bitmaps
  PtrObjVoid ptr_src_bitmap = (PtrObjVoid)MMstart(m, MTOP(src_bmp24));
  PtrObjBitmap obj_src_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bitmap->Buffer));
  PtrObjVoid ptr_dst_bitmap = (PtrObjVoid)MMstart(m, MTOP(dst_bmp24));
  PtrObjBitmap obj_dst_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bitmap->Buffer));
 
  if ((obj_src_bitmap->bits == 0) || (obj_dst_bitmap->bits == 0))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  switch (method)
  {
  case 0:
    method = cv::INTER_NEAREST;
    break;
 
  case 1:
    method = cv::INTER_LINEAR;
    break;
 
  case 2:
    method = cv::INTER_CUBIC;
    break;
 
  case 3:
    method = cv::INTER_AREA;
    break;
 
  case 4:
    method = cv::INTER_LANCZOS4;
    break;
 
  case 5:
    method = cv::INTER_MAX;
    break;
 
  case 6:
    method = cv::WARP_INVERSE_MAP;
    break;
 
  default:
    method = cv::INTER_LINEAR;
  }
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapToMat(obj_src_bitmap);
  cv::Mat imgdest = ConversionTools::ScolBitmapToMat(obj_dst_bitmap);
  try
  {
    cv::resize(imagesrc, imgdest, cv::Size(obj_dst_bitmap->TailleW, obj_dst_bitmap->TailleH), 0, 0, method);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTSCALEbitmap error %s\n", e.what());
    return 0;
  }
 
  //BMP8
  if (hasBmp8)
  {
    PtrObjVoid ptr_src_bitmap8 = (PtrObjVoid)MMstart(m, MTOP(src_bmp8));
    PtrObjBitmap obj_src_bitmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bitmap8->Buffer));
    PtrObjVoid ptr_dst_bitmap8 = (PtrObjVoid)MMstart(m, MTOP(dst_bmp8));
    PtrObjBitmap obj_dst_bitmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bitmap8->Buffer));
 
    if ((obj_src_bitmap8->bits == 0) || (obj_dst_bitmap8->bits == 0))
    {
      MMset(m, 0, NIL);
      return 0;
    }
 
    cv::Mat imagesrc8 = ConversionTools::ScolBitmapToMat(obj_src_bitmap8);
    cv::Mat imgdest8 = ConversionTools::ScolBitmapToMat(obj_dst_bitmap8);
    try
    {
      cv::resize(imagesrc8, imgdest8, cv::Size(obj_dst_bitmap8->TailleW, obj_dst_bitmap8->TailleH), 0, 0, method);
    }
    catch (cv::Exception& e)
    {
      MMechostr(MSKDEBUG, "_BTSCALEbitmap error %s\n", e.what());
      return 0;
    }
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTSCALEbitmapBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTSCALEbitmapBuffer\n");
#endif
 
  /* Get stack data*/
  int method = MMpull(m);
  int isbitsperpixel = MMpull(m);
  int isheight = MMpull(m);
  int iswidth = MMpull(m);
  int isBuff = MMpull(m);
 
  int idbitsperpixel = MMpull(m);
  int idheight = MMpull(m);
  int idwidth = MMpull(m);
  int idBuff = MMget(m, 0);
 
  if ((isBuff == NIL) || (iswidth == NIL) || (isheight == NIL) || (isbitsperpixel == NIL) ||
    (idBuff == NIL) || (idwidth == NIL) || (idheight == NIL) || (idbitsperpixel == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  switch (method)
  {
  case 0:
    method = cv::INTER_NEAREST;
    break;
 
  case 1:
    method = cv::INTER_LINEAR;
    break;
 
  case 2:
    method = cv::INTER_CUBIC;
    break;
 
  case 3:
    method = cv::INTER_AREA;
    break;
 
  case 4:
    method = cv::INTER_LANCZOS4;
    break;
 
  case 5:
    method = cv::INTER_MAX;
    break;
 
  case 6:
    method = cv::WARP_INVERSE_MAP;
    break;
 
  default:
    method = cv::INTER_LINEAR;
  }
 
  unsigned char* sbuffer = MMgetPointer<unsigned char*>(m, MTOP(isBuff));
  if (sbuffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  isbitsperpixel = MTOI(isbitsperpixel);
  isheight = MTOI(isheight);
  iswidth = MTOI(iswidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)sbuffer, iswidth, isheight, isbitsperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* dbuffer = MMgetPointer<unsigned char*>(m, MTOP(idBuff));
  if (dbuffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  idbitsperpixel = MTOI(idbitsperpixel);
  idheight = MTOI(idheight);
  idwidth = MTOI(idwidth);
 
  cv::Mat imgdest = ConversionTools::ScolBitmapBufferToMat((void*)dbuffer, idwidth, idheight, idbitsperpixel);
  if (imgdest.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    cv::resize(imagesrc, imgdest, cv::Size(idwidth, idheight), 0, 0, method);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "_BTSCALEbitmapBuffer error %s\n", e.what());
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _BTSAVEbitmap(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTSAVEbitmap\n");
#endif
 
  int ipath = MMpull(m);
  int ibitmap = MMget(m, 0);
 
  if (ibitmap == NIL || ipath == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTSAVEbitmap error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Scol path to boost::filesystem::path
  boost::filesystem::path path = MMstartstr(m, MTOP(ipath));
 
  // Get scol bitmaps
  PtrObjVoid ptr_bitmap = (PtrObjVoid)MMstart(m, MTOP(ibitmap));
  PtrObjBitmap obj_bitmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_bitmap->Buffer));
 
  if (obj_bitmap->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Convert to cv::Mat
  cv::Mat bitmap = ConversionTools::ScolBitmapToMat(obj_bitmap);
  
  // Save to path
  try
  {
    if (boost::filesystem::exists(path))
      boost::filesystem::remove(path);
 
    imwrite(path.generic_string(), bitmap);
  }
  catch (cv::Exception& ex)
  {
    MMechostr(MSKRUNTIME, "_BTSAVEbitmap Exception writing image in %s : %s\n", path.generic_string().c_str(), ex.what());
    return 0;
  }
 
  // return path
  MMpull(m);
  Mpushstrbloc(m, (char*)path.generic_string().c_str());
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTSAVEbitmap\n");
#endif
  return 0;
}
 
 
int _BTSAVEalphaBitmap(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTSAVEbitmapWithAlpha\n");
#endif
  int ipath = MMpull(m);
  int ialphabitmap = MMget(m, 0);
 
  if (ialphabitmap == NIL || ipath == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTSAVEalphaBitmap error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Scol path to boost::filesystem::path
  boost::filesystem::path path = MMstartstr(m, MTOP(ipath));
 
  int bmp24 = MMfetch(m, MTOP(ialphabitmap), 0);
  int bmp8 = MMfetch(m, MTOP(ialphabitmap), 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));
 
  if (obj_bitmap->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Convert to cv::Mat
  cv::Mat bitmap(obj_bitmap->TailleH, obj_bitmap->TailleW, CV_8UC4);
  ConversionTools::ScolBitmapToMatRGBA(obj_bitmap, obj_bitmap8, bitmap);
 
  // Save to path
  try
  {
    if (boost::filesystem::exists(path))
      boost::filesystem::remove(path);
 
    imwrite(path.generic_string(), bitmap);
  }
  catch (cv::Exception& ex)
  {
    MMechostr(MSKRUNTIME, "_BTSAVEalphaBitmap Exception writing image in %s : %s\n", path.generic_string().c_str(), ex.what());
    return 0;
  }
 
  // return path
  MMpull(m);
  Mpushstrbloc(m, (char*)path.generic_string().c_str());
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTSAVEbitmapWithAlpha\n");
#endif
  return 0;
}
 
 
int _BTLOADbitmap(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG, "_BTLOADbitmap\n");
        #endif
 
        int ipath = MMpull(m);
 
        if (ipath == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
        }
 
  boost::filesystem::path path = MMstartstr(m, MTOP(ipath));
 
  cv::Mat lbitmap = cv::imread(path.generic_string(), cv::IMREAD_COLOR);
  if (!lbitmap.data)
  {
    MMechostr(MSKRUNTIME, "_BTLOADbitmap : Could not read the image file > %s\n", path.generic_string().c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
        //create scol bitmap
        //stack : channel
 
        //push the size w h
  MMpush(m, ITOM(lbitmap.cols));
        MMpush(m, ITOM(lbitmap.rows));
 
        //stack : channel sizew sizeh
        //push _CRbitmap
        if ((MMpush(m, Msearchinsyspak(m, "_CRbitmap"))) < 0)
        {
                MMechostr(0, "\n_GETarMarkerBitmap : error interpreting _CRbitmap\n");
                MMpull(m);
                MMpull(m);
                MMset(m, 0, NIL);
                return 0;
        }
 
        //execute scol cmd
        Minterpreter(m);
 
        int objbmp = MMget(m, 0);
        if (objbmp == NIL)
        {
    MMechostr(MSKRUNTIME, "_BTLOADbitmap : Could not create the bitmap from file > %s\n", path.generic_string().c_str());
                MMset(m, 0, NIL);
                return 0;
        }
 
        PtrObjVoid OB = (PtrObjVoid) MMstart(m, MTOP(objbmp));
  PtrObjBitmap B = (PtrObjBitmap) MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  ConversionTools::MatToScolBitmapRGB(lbitmap, B);
 
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG, "ok\n");
        #endif
                return 0;
}
 
int _BTBLENDbitmaps(mmachine m)
{
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTBLENDbitmaps\n");
#endif
 
  int imix = MMpull(m);
  int isrcrect = MMpull(m);
  int isrcbmap = MMpull(m);
  int idstrect = MMpull(m);
  int idstbmap = MMget(m, 0);
 
  if (imix == NIL || isrcrect == NIL || isrcbmap == NIL || idstrect == NIL || idstbmap == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmaps error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float mix = MAX(MIN(MTOF(imix), 1.0f), 0.0f);
 
  int idstrectx = MMfetch(m, MTOP(idstrect), 0);
  int idstrecty = MMfetch(m, MTOP(idstrect), 1);
  int idstrectw = MMfetch(m, MTOP(idstrect), 2);
  int idstrecth = MMfetch(m, MTOP(idstrect), 3);
  if (idstrectx == NIL || idstrecty == NIL || idstrectw == NIL || idstrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmaps error: some dest rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isrcrectx = MMfetch(m, MTOP(isrcrect), 0);
  int isrcrecty = MMfetch(m, MTOP(isrcrect), 1);
  int isrcrectw = MMfetch(m, MTOP(isrcrect), 2);
  int isrcrecth = MMfetch(m, MTOP(isrcrect), 3);
  if (isrcrectx == NIL || isrcrecty == NIL || isrcrectw == NIL || isrcrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmaps error: some src rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parsing rect
  // -----------
  cv::Rect dst_rect(MTOI(idstrectx), MTOI(idstrecty), MTOI(idstrectw), MTOI(idstrecth));
  cv::Rect src_rect(MTOI(isrcrectx), MTOI(isrcrecty), MTOI(isrcrectw), MTOI(isrcrecth));
 
  // Parsing bitmaps
  // -----------
 
  PtrObjVoid ptr_dst_bmap = (PtrObjVoid)MMstart(m, MTOP(idstbmap));
  PtrObjVoid ptr_src_bmap = (PtrObjVoid)MMstart(m, MTOP(isrcbmap));
 
  PtrObjBitmap obj_dst_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bmap->Buffer));
  PtrObjBitmap obj_src_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bmap->Buffer));
 
  if ((obj_dst_bmap->bits == 0) || (obj_src_bmap->bits == 0))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat dst_bmap = ConversionTools::ScolBitmapToMat(obj_dst_bmap);
  cv::Mat src_bmap = ConversionTools::ScolBitmapToMat(obj_src_bmap);
 
  // Check bounds
  // --------------
  if (!(ConversionTools::ClipBitmapRect(src_bmap, src_rect, dst_bmap, dst_rect)))
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmaps error: src rect size <= 0\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting subbitmaps
  // -----------------
  cv::Mat dst_subbmap = dst_bmap(dst_rect);
  cv::Mat src_subbmap = src_bmap(src_rect);
 
  // Resize src subbitmap to dst subbitmap
  if (src_subbmap.cols != dst_subbmap.cols || src_subbmap.rows != dst_subbmap.rows)
    cv::resize(src_subbmap, src_subbmap, dst_subbmap.size(), 0, 0, cv::INTER_CUBIC);
 
  ConversionTools::Blend(dst_subbmap, src_subbmap, mix);
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTBLENDbitmaps\n");
#endif
 
  return 0;
}
 
int _BTBLENDalphaBitmaps(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTBLENDalphaBitmaps\n");
#endif
 
  int imix = MMpull(m);
  int isrcrect = MMpull(m);
  int isrcbmap = MMpull(m);
  int idstrect = MMpull(m);
  int idstbmap = MMget(m, 0);
 
  if (isrcrect == NIL || isrcbmap == NIL || idstrect == NIL || idstbmap == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDalphaBitmaps error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float mix = 0.5f;
  if (imix != NIL)
    mix = MTOF(imix);
 
  int idstrectx = MMfetch(m, MTOP(idstrect), 0);
  int idstrecty = MMfetch(m, MTOP(idstrect), 1);
  int idstrectw = MMfetch(m, MTOP(idstrect), 2);
  int idstrecth = MMfetch(m, MTOP(idstrect), 3);
  if (idstrectx == NIL || idstrecty == NIL || idstrectw == NIL || idstrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDalphaBitmaps error: some dest rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isrcrectx = MMfetch(m, MTOP(isrcrect), 0);
  int isrcrecty = MMfetch(m, MTOP(isrcrect), 1);
  int isrcrectw = MMfetch(m, MTOP(isrcrect), 2);
  int isrcrecth = MMfetch(m, MTOP(isrcrect), 3);
  if (isrcrectx == NIL || isrcrecty == NIL || isrcrectw == NIL || isrcrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDalphaBitmaps error: some src rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parsing rect
  // -----------
  cv::Rect dst_rect(MTOI(idstrectx), MTOI(idstrecty), MTOI(idstrectw), MTOI(idstrecth));
  cv::Rect src_rect(MTOI(isrcrectx), MTOI(isrcrecty), MTOI(isrcrectw), MTOI(isrcrecth));
 
  // Parsing bitmaps
  // -----------
  int idstbmap24 = MMfetch(m, MTOP(idstbmap), 0);
  int idstbmap8 = MMfetch(m, MTOP(idstbmap), 1);
  int isrcbmap24 = MMfetch(m, MTOP(isrcbmap), 0);
  int isrcbmap8 = MMfetch(m, MTOP(isrcbmap), 1);
 
  if (idstbmap24 == NIL || idstbmap8 == NIL || isrcbmap24 == NIL || isrcbmap8 == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDalphaBitmaps error: AlphaBitmaps miscreated or alpha part is missing\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid ptr_dst_bmap = (PtrObjVoid)MMstart(m, MTOP(idstbmap24));
  PtrObjVoid ptr_dst_bmap8 = (PtrObjVoid)MMstart(m, MTOP(idstbmap8));
  PtrObjVoid ptr_src_bmap = (PtrObjVoid)MMstart(m, MTOP(isrcbmap24));
  PtrObjVoid ptr_src_bmap8 = (PtrObjVoid)MMstart(m, MTOP(isrcbmap8));
 
  PtrObjBitmap obj_dst_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bmap->Buffer));
  PtrObjBitmap obj_dst_bmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bmap8->Buffer));
  PtrObjBitmap obj_src_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bmap->Buffer));
  PtrObjBitmap obj_src_bmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bmap8->Buffer));
 
  if ((obj_dst_bmap->bits == 0) || (obj_src_bmap->bits == 0) || (obj_dst_bmap8->bits == 0) || (obj_src_bmap8->bits == 0))
  {
    MMechostr(MSKRUNTIME, "_BTBLENDalphaBitmaps error: empty alpha channel\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat dst_bmap = ConversionTools::ScolBitmapToMat(obj_dst_bmap);
  cv::Mat src_bmap = ConversionTools::ScolBitmapToMat(obj_src_bmap);
  cv::Mat dst_bmap8 = ConversionTools::ScolBitmapToMat(obj_dst_bmap8);
  cv::Mat src_bmap8 = ConversionTools::ScolBitmapToMat(obj_src_bmap8);
 
  // Check bounds
  // --------------
  if (!(ConversionTools::ClipBitmapRect(src_bmap, src_rect, dst_bmap, dst_rect)))
  {
    MMechostr(MSKRUNTIME, "_BTBLENDalphaBitmaps error: src rect size <= 0\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting subbitmaps
  // -----------------
  cv::Mat dst_subbmap = dst_bmap(dst_rect);
  cv::Mat src_subbmap = src_bmap(src_rect);
  cv::Mat dst_subbmap8 = dst_bmap8(dst_rect);
  cv::Mat src_subbmap8 = src_bmap8(src_rect);
 
  // Resize src subbitmap to dst subbitmap
  if (src_subbmap.cols != dst_subbmap.cols || src_subbmap.rows != dst_subbmap.rows)
    cv::resize(src_subbmap, src_subbmap, dst_subbmap.size(), 0, 0, cv::INTER_CUBIC);
 
  if (src_subbmap8.cols != dst_subbmap8.cols || src_subbmap8.rows != dst_subbmap8.rows)
    cv::resize(src_subbmap8, src_subbmap8, dst_subbmap8.size(), 0, 0, cv::INTER_CUBIC);
 
  ConversionTools::Blend(dst_subbmap, dst_subbmap8, src_subbmap, src_subbmap8, mix);
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTBLENDalphaBitmaps\n");
#endif
 
  return 0;
}
 
int _BTBLENDbitmapsBuffer(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTBLENDbitmapsBuffer\n");
#endif
 
  int imix = MMpull(m);
  int isrcrect = MMpull(m);
 
  int isbitsperpixel = MMpull(m);
  int isheight = MMpull(m);
  int iswidth = MMpull(m);
  int isBuff = MMpull(m);
  
  int idstrect = MMpull(m);
  int idbitsperpixel = MMpull(m);
  int idheight = MMpull(m);
  int idwidth = MMpull(m);
  int idBuff = MMget(m, 0);
  
  if ((isBuff == NIL) || (iswidth == NIL) || (isheight == NIL) || (isbitsperpixel == NIL) ||
      (idBuff == NIL) || (idwidth == NIL) || (idheight == NIL) || (idbitsperpixel == NIL) ||
      (imix == NIL) || (isrcrect == NIL) || (idstrect == NIL))
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmapsBuffer error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float mix = MAX(MIN(MTOF(imix), 1.0f), 0.0f);
 
  int idstrectx = MMfetch(m, MTOP(idstrect), 0);
  int idstrecty = MMfetch(m, MTOP(idstrect), 1);
  int idstrectw = MMfetch(m, MTOP(idstrect), 2);
  int idstrecth = MMfetch(m, MTOP(idstrect), 3);
  if (idstrectx == NIL || idstrecty == NIL || idstrectw == NIL || idstrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmapsBuffer error: some dest rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isrcrectx = MMfetch(m, MTOP(isrcrect), 0);
  int isrcrecty = MMfetch(m, MTOP(isrcrect), 1);
  int isrcrectw = MMfetch(m, MTOP(isrcrect), 2);
  int isrcrecth = MMfetch(m, MTOP(isrcrect), 3);
  if (isrcrectx == NIL || isrcrecty == NIL || isrcrectw == NIL || isrcrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmapsBuffer error: some src rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parsing rect
  // -----------
  cv::Rect dst_rect(MTOI(idstrectx), MTOI(idstrecty), MTOI(idstrectw), MTOI(idstrecth));
  cv::Rect src_rect(MTOI(isrcrectx), MTOI(isrcrecty), MTOI(isrcrectw), MTOI(isrcrecth));
 
  // Parsing bitmaps
  // -----------
  unsigned char* sbuffer = MMgetPointer<unsigned char*>(m, MTOP(isBuff));
  if (sbuffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  isbitsperpixel = MTOI(isbitsperpixel);
  isheight = MTOI(isheight);
  iswidth = MTOI(iswidth);
 
  cv::Mat src_bmap = ConversionTools::ScolBitmapBufferToMat((void*)sbuffer, iswidth, isheight, isbitsperpixel);
  if (src_bmap.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* dbuffer = MMgetPointer<unsigned char*>(m, MTOP(idBuff));
  if (dbuffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  idbitsperpixel = MTOI(idbitsperpixel);
  idheight = MTOI(idheight);
  idwidth = MTOI(idwidth);
 
  cv::Mat dst_bmap = ConversionTools::ScolBitmapBufferToMat((void*)dbuffer, idwidth, idheight, idbitsperpixel);
  if (dst_bmap.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check bounds
  // --------------
  if (!(ConversionTools::ClipBitmapRect(src_bmap, src_rect, dst_bmap, dst_rect)))
  {
    MMechostr(MSKRUNTIME, "_BTBLENDbitmapsBuffer error: src rect size <= 0\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting subbitmaps
  // -----------------
  cv::Mat dst_subbmap = dst_bmap(dst_rect);
  cv::Mat src_subbmap = src_bmap(src_rect);
 
  // Resize src subbitmap to dst subbitmap
  if (src_subbmap.cols != dst_subbmap.cols || src_subbmap.rows != dst_subbmap.rows)
    cv::resize(src_subbmap, src_subbmap, dst_subbmap.size(), 0, 0, cv::INTER_CUBIC);
 
  ConversionTools::Blend(dst_subbmap, src_subbmap, mix);
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTBLENDbitmapsBuffer\n");
#endif
 
  return 0;
}
 
int _BTCPbitmapRect(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTCPbitmapRect\n");
#endif
 
  int isrcrect = MMpull(m);
  int isrcbmap = MMpull(m);
  int idstrect = MMpull(m);
  int idstbmap = MMget(m, 0);
 
  if (isrcrect == NIL || isrcbmap == NIL || idstrect == NIL || idstbmap == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapRect error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int idstrectx = MMfetch(m, MTOP(idstrect), 0);
  int idstrecty = MMfetch(m, MTOP(idstrect), 1);
  int idstrectw = MMfetch(m, MTOP(idstrect), 2);
  int idstrecth = MMfetch(m, MTOP(idstrect), 3);
  if (idstrectx == NIL || idstrecty == NIL || idstrectw == NIL || idstrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapRect error: some dest rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isrcrectx = MMfetch(m, MTOP(isrcrect), 0);
  int isrcrecty = MMfetch(m, MTOP(isrcrect), 1);
  int isrcrectw = MMfetch(m, MTOP(isrcrect), 2);
  int isrcrecth = MMfetch(m, MTOP(isrcrect), 3);
  if (isrcrectx == NIL || isrcrecty == NIL || isrcrectw == NIL || isrcrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapRect error: some src rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parsing rect
  // -----------
  cv::Rect dst_rect(MTOI(idstrectx), MTOI(idstrecty), MTOI(idstrectw), MTOI(idstrecth));
  cv::Rect src_rect(MTOI(isrcrectx), MTOI(isrcrecty), MTOI(isrcrectw), MTOI(isrcrecth));
 
  // Parsing bitmaps
  // -----------
 
  PtrObjVoid ptr_dst_bmap = (PtrObjVoid)MMstart(m, MTOP(idstbmap));
  PtrObjVoid ptr_src_bmap = (PtrObjVoid)MMstart(m, MTOP(isrcbmap));
 
  PtrObjBitmap obj_dst_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bmap->Buffer));
  PtrObjBitmap obj_src_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bmap->Buffer));
 
  if ((obj_dst_bmap->bits == 0) || (obj_src_bmap->bits == 0))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat dst_bmap = ConversionTools::ScolBitmapToMat(obj_dst_bmap);
  cv::Mat src_bmap = ConversionTools::ScolBitmapToMat(obj_src_bmap);
 
  // Check bounds
  // --------------
  if (!(ConversionTools::ClipBitmapRect(src_bmap, src_rect, dst_bmap, dst_rect)))
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapRect error: src rect size <= 0\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting subbitmaps
  // -----------------
  cv::Mat dst_subbmap = dst_bmap(dst_rect);
  cv::Mat src_subbmap = src_bmap(src_rect);
 
  // Resize src subbitmap to dst subbitmap
  if (src_subbmap.cols != dst_subbmap.cols || src_subbmap.rows != dst_subbmap.rows)
    cv::resize(src_subbmap, dst_subbmap, dst_subbmap.size(), 0, 0, cv::INTER_CUBIC);
  else
    src_subbmap.copyTo(dst_bmap(dst_rect));
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTCPbitmapRect\n");
#endif
 
  return 0;
}
 
int _BTCPalphaBitmapRect(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTCPalphaBitmapRect\n");
#endif
 
  int isrcrect = MMpull(m);
  int isrcbmap = MMpull(m);
  int idstrect = MMpull(m);
  int idstbmap = MMget(m, 0);
 
  if (isrcrect == NIL || isrcbmap == NIL || idstrect == NIL || idstbmap == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPalphaBitmapRect error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int idstrectx = MMfetch(m, MTOP(idstrect), 0);
  int idstrecty = MMfetch(m, MTOP(idstrect), 1);
  int idstrectw = MMfetch(m, MTOP(idstrect), 2);
  int idstrecth = MMfetch(m, MTOP(idstrect), 3);
  if (idstrectx == NIL || idstrecty == NIL || idstrectw == NIL || idstrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPalphaBitmapRect error: some dest rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isrcrectx = MMfetch(m, MTOP(isrcrect), 0);
  int isrcrecty = MMfetch(m, MTOP(isrcrect), 1);
  int isrcrectw = MMfetch(m, MTOP(isrcrect), 2);
  int isrcrecth = MMfetch(m, MTOP(isrcrect), 3);
  if (isrcrectx == NIL || isrcrecty == NIL || isrcrectw == NIL || isrcrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPalphaBitmapRect error: some src rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parsing rect
  // -----------
  cv::Rect dst_rect(MTOI(idstrectx), MTOI(idstrecty), MTOI(idstrectw), MTOI(idstrecth));
  cv::Rect src_rect(MTOI(isrcrectx), MTOI(isrcrecty), MTOI(isrcrectw), MTOI(isrcrecth));
 
  // Parsing bitmaps
  // -----------
  int idstbmap24 = MMfetch(m, MTOP(idstbmap), 0);
  int idstbmap8 = MMfetch(m, MTOP(idstbmap), 1);
  int isrcbmap24 = MMfetch(m, MTOP(isrcbmap), 0);
  int isrcbmap8 = MMfetch(m, MTOP(isrcbmap), 1);
 
  if ((idstbmap24 == NIL) || (isrcbmap24 == NIL))
  {
    MMechostr(MSKRUNTIME, "_BTCPalphaBitmapRect error: AlphaBitmaps miscreated\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool hasBmp8 = ((isrcbmap8 != NIL) && (idstbmap8 != NIL)) ? true : false;
 
  //BMP24
  PtrObjVoid ptr_dst_bmap = (PtrObjVoid)MMstart(m, MTOP(idstbmap24));
  PtrObjVoid ptr_src_bmap = (PtrObjVoid)MMstart(m, MTOP(isrcbmap24));
  PtrObjBitmap obj_dst_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bmap->Buffer));
  PtrObjBitmap obj_src_bmap = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bmap->Buffer));
 
  cv::Mat dst_bmap = ConversionTools::ScolBitmapToMat(obj_dst_bmap);
  cv::Mat src_bmap = ConversionTools::ScolBitmapToMat(obj_src_bmap);
  
  if (!(ConversionTools::ClipBitmapRect(src_bmap, src_rect, dst_bmap, dst_rect)))
  {
    MMechostr(MSKRUNTIME, "_BTCPalphaBitmapRect error: src rect size <= 0\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting subbitmaps
  // -----------------
  cv::Mat dst_subbmap = dst_bmap(dst_rect);
  cv::Mat src_subbmap = src_bmap(src_rect);
 
  // Resize src subbitmap to dst subbitmap
  if (src_subbmap.cols != dst_subbmap.cols || src_subbmap.rows != dst_subbmap.rows)
    cv::resize(src_subbmap, dst_subbmap, dst_subbmap.size(), 0, 0, cv::INTER_AREA);
  else
    src_subbmap.copyTo(dst_bmap(dst_rect));  
 
  PtrObjVoid ptr_dst_bmap8 = (PtrObjVoid)MMstart(m, MTOP(idstbmap8));
  PtrObjVoid ptr_src_bmap8 = (PtrObjVoid)MMstart(m, MTOP(isrcbmap8));
  PtrObjBitmap obj_dst_bmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_dst_bmap8->Buffer));
  PtrObjBitmap obj_src_bmap8 = (PtrObjBitmap)MMstart(m, MTOP(ptr_src_bmap8->Buffer));
 
  //BMP8
  if (hasBmp8)
  {
    if ((obj_dst_bmap8->bits == 0) || (obj_src_bmap8->bits == 0))
    {
      MMset(m, 0, NIL);
      return 0;
    }
 
    cv::Mat dst_bmap8 = ConversionTools::ScolBitmapToMat(obj_dst_bmap8);
    cv::Mat src_bmap8 = ConversionTools::ScolBitmapToMat(obj_src_bmap8);
    cv::Mat dst_subbmap8 = dst_bmap8(dst_rect);
    cv::Mat src_subbmap8 = src_bmap8(src_rect);
 
    // Resize src subbitmap to dst subbitmap
    if (src_subbmap8.cols != dst_subbmap8.cols || src_subbmap8.rows != dst_subbmap8.rows)
      cv::resize(src_subbmap8, dst_subbmap8, dst_subbmap8.size(), 0, 0, cv::INTER_AREA);
    else
      src_subbmap8.copyTo(dst_bmap8(dst_rect));
  }
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTCPalphaBitmapRect\n");
#endif
 
  return 0;
}
 
int _BTCPbitmapBufferRect(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "_BTCPbitmapBufferRect");
#endif
 
  int isrcrect = MMpull(m);
 
  int isbitsperpixel = MMpull(m);
  int isheight = MMpull(m);
  int iswidth = MMpull(m);
  int isBuff = MMpull(m);
 
  int idstrect = MMpull(m);
  int idbitsperpixel = MMpull(m);
  int idheight = MMpull(m);
  int idwidth = MMpull(m);
  int idBuff = MMget(m, 0);
 
  if ((isBuff == NIL) || (iswidth == NIL) || (isheight == NIL) || (isbitsperpixel == NIL) ||
    (idBuff == NIL) || (idwidth == NIL) || (idheight == NIL) || (idbitsperpixel == NIL) || (isrcrect == NIL) || (idstrect == NIL))
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapBufferRect error: some arguments are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int idstrectx = MMfetch(m, MTOP(idstrect), 0);
  int idstrecty = MMfetch(m, MTOP(idstrect), 1);
  int idstrectw = MMfetch(m, MTOP(idstrect), 2);
  int idstrecth = MMfetch(m, MTOP(idstrect), 3);
  if (idstrectx == NIL || idstrecty == NIL || idstrectw == NIL || idstrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapBufferRect error: some dest rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isrcrectx = MMfetch(m, MTOP(isrcrect), 0);
  int isrcrecty = MMfetch(m, MTOP(isrcrect), 1);
  int isrcrectw = MMfetch(m, MTOP(isrcrect), 2);
  int isrcrecth = MMfetch(m, MTOP(isrcrect), 3);
  if (isrcrectx == NIL || isrcrecty == NIL || isrcrectw == NIL || isrcrecth == NIL)
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapBufferRect error: some src rect parameters are NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Parsing rect
  // -----------
  cv::Rect dst_rect(MTOI(idstrectx), MTOI(idstrecty), MTOI(idstrectw), MTOI(idstrecth));
  cv::Rect src_rect(MTOI(isrcrectx), MTOI(isrcrecty), MTOI(isrcrectw), MTOI(isrcrecth));
 
  // Parsing bitmaps
  // -----------
  unsigned char* sbuffer = MMgetPointer<unsigned char*>(m, MTOP(isBuff));
  if (sbuffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  isbitsperpixel = MTOI(isbitsperpixel);
  isheight = MTOI(isheight);
  iswidth = MTOI(iswidth);
 
  cv::Mat src_bmap = ConversionTools::ScolBitmapBufferToMat((void*)sbuffer, iswidth, isheight, isbitsperpixel);
  if (src_bmap.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* dbuffer = MMgetPointer<unsigned char*>(m, MTOP(idBuff));
  if (dbuffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  idbitsperpixel = MTOI(idbitsperpixel);
  idheight = MTOI(idheight);
  idwidth = MTOI(idwidth);
 
  cv::Mat dst_bmap = ConversionTools::ScolBitmapBufferToMat((void*)dbuffer, idwidth, idheight, idbitsperpixel);
  if (dst_bmap.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!(ConversionTools::ClipBitmapRect(src_bmap, src_rect, dst_bmap, dst_rect)))
  {
    MMechostr(MSKRUNTIME, "_BTCPbitmapBufferRect error: src rect size <= 0\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting subbitmaps
  // -----------------
  cv::Mat dst_subbmap = dst_bmap(dst_rect);
  cv::Mat src_subbmap = src_bmap(src_rect);
 
  if (idbitsperpixel != isbitsperpixel)
  {
    if ((idbitsperpixel == 3) && (isbitsperpixel == 4))
      cv::cvtColor(src_subbmap, src_subbmap, cv::COLOR_RGBA2RGB);
    else if ((idbitsperpixel == 4) && (isbitsperpixel == 3))
      cv::cvtColor(src_subbmap, src_subbmap, cv::COLOR_RGB2RGBA);
    else if ((idbitsperpixel == 1) && (isbitsperpixel == 3))
      cv::cvtColor(src_subbmap, src_subbmap, cv::COLOR_RGB2GRAY);
    else if ((idbitsperpixel == 1) && (isbitsperpixel == 4))
      cv::cvtColor(src_subbmap, src_subbmap, cv::COLOR_RGBA2GRAY);
  }
 
  // Resize src subbitmap to dst subbitmap
  if (src_subbmap.cols != dst_subbmap.cols || src_subbmap.rows != dst_subbmap.rows)
    cv::resize(src_subbmap, dst_subbmap, dst_subbmap.size(), 0, 0, cv::INTER_CUBIC);
  else
    src_subbmap.copyTo(dst_bmap(dst_rect));
 
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "end _BTCPbitmapBufferRect\n");
#endif
 
  return 0;
}
 
int _BTGETbitmapBuffer(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTGETbitmapBuffer\n");
#endif
 
  /* Get stack data*/
  int bitmap = MMget(m, 0);
 
  if (bitmap == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  if ((MMpushPointer(m, B->bits) != 0))
  {
    MMpush(m, NIL);
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
 
int _BTGETbitmapBufferExt(mmachine m)
{
#ifdef _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BTGETbitmapBufferExt\n");
#endif
 
  /* Get stack data*/
  int bitmap = MMget(m, 0);
 
  if (bitmap == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid OB = (PtrObjVoid)MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap)MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  if ((MMpushPointer(m, B->bits) != 0))
  {
    MMpush(m, NIL);
    return 0;
  }
 
  MMpush(m, ITOM(B->TailleW));
  MMpush(m, ITOM(B->TailleH));
  MMpush(m, ITOM(B->BytesPP));
  MMpush(m, ITOM(4));
  MBdeftab(m);
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
/*
*********************************************
* SCOL PART
*********************************************
*/
 
NativeDefinition bitmapToolkitEngine[] =
{
  { "_BTBLURbitmap", 3, "fun [ObjBitmap I I] ObjBitmap", _BTBLURbitmap },
  { "_BTBLURbitmap8", 3, "fun [ObjBitmap8 I I] ObjBitmap8", _BTBLURbitmap },
  { "_BTBLURbitmapBuffer", 6, "fun [ObjBuff I I I I I] ObjBitmap", _BTBLURbitmapBuffer },
 
  { "_BTFILTERbitmap", 2, "fun [ObjBitmap tab tab F] ObjBitmap", _BTFILTERbitmap },
  { "_BTFILTERbitmap8", 2, "fun [ObjBitmap8 tab tab F] ObjBitmap8", _BTFILTERbitmap },
  { "_BTFILTERbitmapBuffer", 5, "fun [ObjBuff I I I tab tab F] ObjBitmap", _BTFILTERbitmapBuffer },
 
  { "_BTBRIGHTNESSbitmap", 2, "fun [ObjBitmap I] ObjBitmap", _BTBRIGHTNESSbitmap },
  { "_BTBRIGHTNESSbitmap8", 2, "fun [ObjBitmap8 I] ObjBitmap8", _BTBRIGHTNESSbitmap },
  { "_BTBRIGHTNESSbitmapBuffer", 5, "fun [ObjBuff I I I I] ObjBitmap", _BTBRIGHTNESSbitmapBuffer },
 
  { "_BTLAPLACEbitmap", 3, "fun [ObjBitmap I I] ObjBitmap", _BTLAPLACEbitmap },
  { "_BTLAPLACEbitmap8", 3, "fun [ObjBitmap8 I I] ObjBitmap8", _BTLAPLACEbitmap },
  { "_BTLAPLACEbitmapBuffer", 6, "fun [ObjBuff I I I I I] ObjBitmap", _BTLAPLACEbitmapBuffer },
 
  { "_BTFLIPbitmap", 1, "fun [ObjBitmap] ObjBitmap", _BTFLIPbitmap },
  { "_BTFLIPbitmap8", 1, "fun [ObjBitmap8] ObjBitmap8", _BTFLIPbitmap },
  { "_BTFLIPbuffer", 4, "fun [ObjBuff I I I] ObjBuff", _BTFLIPbuffer },
 
  { "_BTNORMALbitmap", 3, "fun [ObjBitmap F F] ObjBitmap", _BTNORMALbitmap },
  { "_BTNORMALbitmapBuffer", 6, "fun [ObjBuff I I I F F] ObjBitmap", _BTNORMALbitmapBuffer },
 
  { "_BTDRAWcircle", 5, "fun [ObjBitmap [I I] I I I I I] ObjBitmap", _BTDRAWcircle },
  { "_BTDRAWcircle8", 5, "fun [ObjBitmap8 [I I] I I I I I] ObjBitmap8", _BTDRAWcircle },
  { "_BTDRAWcircleBuffer", 8, "fun [ObjBuff I I I [I I] I I I I I] ObjBuff", _BTDRAWcircleBuffer },
  
  { "_BTDRAWrect", 6, "fun [ObjBitmap [I I I I] I I I I] ObjBitmap", _BTDRAWrect },
  { "_BTDRAWrect8", 6, "fun [ObjBitmap8 [I I I I] I I I I] ObjBitmap8", _BTDRAWrect },
  { "_BTDRAWrectBuffer", 9, "fun [ObjBuff I I I [I I I I] I I I I] ObjBuff", _BTDRAWrectBuffer },
 
  { "_BTDRAWline", 5, "fun [ObjBitmap [I I] [I I] I I] ObjBitmap", _BTDRAWline },
  { "_BTDRAWline8", 5, "fun [ObjBitmap8 [I I] [I I] I I] ObjBitmap8", _BTDRAWline },
  { "_BTDRAWlineBuffer", 8, "fun [ObjBuff I I I [I I] [I I] I I] ObjBuff", _BTDRAWlineBuffer },
 
  { "_BTDRAWpath", 4, "fun [ObjBitmap [[I I] r1] I I] ObjBitmap", _BTDRAWpath },
  { "_BTDRAWpath8", 4, "fun [ObjBitmap8 [[I I] r1] I I] ObjBitmap8", _BTDRAWpath },
  { "_BTDRAWpathBuffer", 7, "fun [ObjBuff I I I [[I I] r1] I I] ObjBuff", _BTDRAWpathBuffer },
 
  { "_BTCompBitmap", 2, "fun [ObjBitmap I] S", _BTCompBitmap },
  { "_BTUnCompBitmap", 2, "fun [S ObjBitmap] ObjBitmap", _BTUnCompBitmap },
 
  { "_BTMOTIONdetect", 4, "fun [ObjBitmap ObjBitmap I I] I", _BTMOTIONdetect },
 
  { "_BTSCALEbitmap", 3, "fun [ObjBitmap ObjBitmap I] ObjBitmap", _BTSCALEbitmap },
  { "_BTSCALEalphaBitmap", 3, "fun [AlphaBitmap AlphaBitmap I] AlphaBitmap", _BTSCALEalphaBitmap },
  { "_BTSCALEbitmap8", 3, "fun [ObjBitmap8 ObjBitmap8 I] ObjBitmap8", _BTSCALEbitmap },
  { "_BTSCALEbitmapBuffer", 9, "fun [ObjBuff I I I ObjBuff I I I I] ObjBuff", _BTSCALEbitmapBuffer },
 
  { "_BTSAVEbitmap", 2, "fun [ObjBitmap W] P", _BTSAVEbitmap },
  { "_BTSAVEbitmap8", 2, "fun [ObjBitmap8 W] P", _BTSAVEbitmap },
  { "_BTSAVEalphaBitmap", 2, "fun [AlphaBitmap W] P", _BTSAVEalphaBitmap },
 
  { "_BTLOADbitmap", 2, "fun [Chn P] ObjBitmap", _BTLOADbitmap },
 
  { "_BTBLENDbitmaps", 5, "fun [ObjBitmap [I I I I] ObjBitmap [I I I I] F] ObjBitmap", _BTBLENDbitmaps },
  { "_BTBLENDbitmaps8", 5, "fun [ObjBitmap8 [I I I I] ObjBitmap8 [I I I I] F] ObjBitmap8", _BTBLENDbitmaps },
  { "_BTBLENDalphaBitmaps", 5, "fun [AlphaBitmap [I I I I] AlphaBitmap [I I I I] F] AlphaBitmap", _BTBLENDalphaBitmaps },
  { "_BTBLENDbitmapsBuffer", 11, "fun [ObjBuff I I I [I I I I] ObjBuff I I I [I I I I] F] ObjBuff", _BTBLENDbitmapsBuffer },
 
  { "_BTCPbitmapRect", 4, "fun [ObjBitmap [I I I I] ObjBitmap [I I I I]] ObjBitmap", _BTCPbitmapRect },
  { "_BTCPbitmapRect8", 4, "fun [ObjBitmap8 [I I I I] ObjBitmap8 [I I I I]] ObjBitmap8", _BTCPbitmapRect },
  { "_BTCPalphaBitmapRect", 4, "fun [AlphaBitmap [I I I I] AlphaBitmap [I I I I]] AlphaBitmap", _BTCPalphaBitmapRect },
  { "_BTCPbitmapBufferRect", 10, "fun [ObjBuff I I I [I I I I] ObjBuff I I I [I I I I]] ObjBuff", _BTCPbitmapBufferRect },
 
  { "_BTGETbitmapBuffer", 1, "fun [ObjBitmap] ObjBuff", _BTGETbitmapBuffer },
  { "_BTGETbitmapBuffer8", 1, "fun [ObjBitmap8] ObjBuff", _BTGETbitmapBuffer },
 
  { "_BTGETbitmapBufferExt", 1, "fun [ObjBitmap] [ObjBuff I I I]", _BTGETbitmapBufferExt },
  { "_BTGETbitmapBuffer8Ext", 1, "fun [ObjBitmap8] [ObjBuff I I I]", _BTGETbitmapBufferExt },
 
  { "ObjBTMat", TYPTYPE, NULL, NULL },
  { "_CRBTmat", 2, "fun [Chn AlphaBitmap] ObjBTMat", _CRBTmat },
  { "_DSBTmat", 1, "fun [ObjBTMat] I", _DSBTmat },
  { "_BTGETmatBuffer", 1, "fun [ObjBTMat] ObjBuff", _BTGETmatBuffer },
 
  { "ObjBTFont", TYPTYPE, NULL, NULL },
  { "_CRBTfont", 5, "fun [Chn S I I F] ObjBTFont", _CRBTfont },
  { "_CRBTfontFromFile", 5, "fun [Chn P I I F] ObjBTFont", _CRBTfontFromFile },  
  { "_DSBTfont", 1, "fun [ObjBTFont] I", _DSBTfont },
 
  { "BT_FONT_BOLD", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_BOLD) },
  { "BT_FONT_ITALIC", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_ITALIC) },
  { "BT_FONT_ANTIALIAS", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_ANTIALIAS) },
  { "BT_FONT_FILLED", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_FILLED) },
  { "BT_FONT_HOLLOW", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_HOLLOW) },
  { "BT_FONT_SANS", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_SANS) },
  { "BT_FONT_SERIF", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_SERIF) },
  { "BT_FONT_SCRIPT", TYPVAR, "I", SCOL_TYPTYPE(BT_FONT_SCRIPT) },
  { "BT_TEXT_HORIZ_MASK", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_HORIZ_MASK) },
  { "BT_TEXT_HORIZ_LEFT", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_HORIZ_LEFT) },
  { "BT_TEXT_HORIZ_RIGHT", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_HORIZ_RIGHT) },
  { "BT_TEXT_HORIZ_CENTERED", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_HORIZ_CENTERED) },
  { "BT_TEXT_HORIZ_JUSTIFIED", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_HORIZ_JUSTIFIED) },
  { "BT_TEXT_VERT_MASK", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_VERT_MASK) },
  { "BT_TEXT_VERT_TOP", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_VERT_TOP) },
  { "BT_TEXT_VERT_CENTER", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_VERT_CENTER) },
  { "BT_TEXT_VERT_BOTTOM", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_VERT_BOTTOM) },
  { "BT_TEXT_WORD_WRAP", TYPVAR, "I", SCOL_TYPTYPE(BT_TEXT_WORD_WRAP) },
 
  { "_BTDRAWtextBitmap", 6, "fun [ObjBitmap ObjBTFont [I I] I I S] ObjBitmap", _BTDRAWtextBitmap },
  { "_BTDRAWtextBitmap8", 6, "fun [ObjBitmap8 ObjBTFont [I I] I I S] ObjBitmap8", _BTDRAWtextBitmap },
  { "_BTDRAWtextAreaBitmap", 7, "fun [ObjBitmap ObjBTFont [I I I I] [I I] I I S] ObjBitmap", _BTDRAWtextAreaBitmap },
  { "_BTDRAWtextAreaBitmap8", 7, "fun [ObjBitmap8 ObjBTFont [I I I I] [I I] I I S] ObjBitmap8", _BTDRAWtextAreaBitmap },
  { "_BTDRAWtextAlphaBitmap", 7, "fun [AlphaBitmap ObjBTFont [I I] I I I S] AlphaBitmap", _BTDRAWtextAlphaBitmap },
  { "_BTDRAWtextAreaAlphaBitmap", 8, "fun [AlphaBitmap ObjBTFont [I I I I] [I I] I I I S] AlphaBitmap", _BTDRAWtextAreaAlphaBitmap },
  { "_BTGETtextSize", 2, "fun [ObjBTFont S] [I I]", _BTGETtextSize },
  { "_BTGETtextAreaHeight", 4, "fun [ObjBTFont S I I] I", _BTGETtextAreaHeight }
  
};
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int LoadBitmapToolKit(mmachine m)
{
  int k;
  MMechostr(MSKDEBUG, " > Loading BitmapToolkit\n");
  SObjBTFont = OBJregister(0, 0, destroyCVFont, "ObjBTFont");
  SObjBTMat = OBJregister(0, 0, destroyCVMat, "ObjBTMat");
  k = PKhardpak2(m, "BitmapToolkitEngine", sizeof(bitmapToolkitEngine) / sizeof(bitmapToolkitEngine[0]), bitmapToolkitEngine);
  MMechostr(MSKDEBUG, " > Successfully Loaded\n\n");
  return k;
}