ScolConvert.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
 
-----------------------------------------------------------------------------
*/
 
#include <opencv2/opencv.hpp>
#include "ScolConvert.h"
#include "boost/thread.hpp"
 
class ConvertBuffer
  {
  public:
    ConvertBuffer(uchar* _srcBuff, void* _dstBuff, const int _width, const int _height, const int _sbpl, const int _dbpl, const int _bpp) :
      srcBuff(_srcBuff),
      dstBuff(_dstBuff),
      width(_width),
      height(_height),
      sbpl(_sbpl),
      abpl(0),
      dbpl(_dbpl),
      bpp(_bpp)
    {}
 
    ConvertBuffer(uchar* _srcBuff, uchar* _srcbuff8, void* _dstBuff, const int _width, const int _height, const int _sbpl, const int _abpl, const int _dbpl, const int _bpp) :
      srcBuff(_srcBuff),
      srcbuff8(_srcbuff8),
      dstBuff(_dstBuff),
      width(_width),
      height(_height),
      sbpl(_sbpl),
      abpl(_abpl),
      dbpl(_dbpl),
      bpp(_bpp)
    {}
 
    uchar* srcBuff;
    uchar* srcbuff8;
    void* dstBuff;
    const int width;
    const int height;
    const int sbpl;
    const int abpl;
    const int dbpl;
    const int bpp;
  };
 
ConversionTools::ConversionTools()
{
  // Forbiden (private). Use static functions instead.
}
 
class bitmapToMat : public cv::ParallelLoopBody
{
public:
    bitmapToMat(const ConvertBuffer _conv)
        : conv(_conv)
    {}
 
    void operator()(const cv::Range& range) const
    {
      const int start = range.start;
      const int end = range.end;
      unsigned int srcByte;
      unsigned int destByte;
      int x, y;
 
      for (y = start; y < end; y++)
      {
        for (x = 0; x < conv.width; x++)
        {
          srcByte = (x * conv.bpp) + (conv.sbpl * y);
          destByte = (x * conv.bpp) + (conv.dbpl * y);
 
          ((uchar*)conv.dstBuff)[destByte] = conv.srcBuff[srcByte];
          if (conv.bpp == 3)
          {
            ((uchar*)conv.dstBuff)[destByte + 1] = conv.srcBuff[srcByte + 1];
            ((uchar*)conv.dstBuff)[destByte + 2] = conv.srcBuff[srcByte + 2];
          }
        }
      }
    }
 
private:
    bitmapToMat& operator=(const bitmapToMat&); // to quiet MSVC
 
    const ConvertBuffer conv;
};
 
class bitmapToMatBGR : public cv::ParallelLoopBody
{
public:
  bitmapToMatBGR(const ConvertBuffer _conv)
  : conv(_conv)
  {}
  
  void operator()(const cv::Range& range) const
  {
    const int start = range.start;
    const int end = range.end;
    unsigned int srcByte;
    unsigned int destByte;
    int x, y;
    
    for (y = start; y < end; y++)
    {
      for (x = 0; x < conv.width; x++)
      {
        srcByte = (x * conv.bpp) + (conv.sbpl * y);
        destByte = (x * conv.bpp) + (conv.dbpl * y);
        
        ((uchar*)conv.dstBuff)[destByte] = conv.srcBuff[srcByte + 2];
        ((uchar*)conv.dstBuff)[destByte + 1] = conv.srcBuff[srcByte + 1];
        ((uchar*)conv.dstBuff)[destByte + 2] = conv.srcBuff[srcByte];
      }
    }
  }
  
private:
  bitmapToMat& operator=(const bitmapToMat&); // to quiet MSVC
  
  const ConvertBuffer conv;
};
 
class bitmapToMat4 : public cv::ParallelLoopBody
{
public:
    bitmapToMat4(const ConvertBuffer _conv)
        : conv(_conv)
    {}
 
    void operator()(const cv::Range& range) const
    {
      const int start = range.start;
      const int end = range.end;
      unsigned int srcByte;
      unsigned int srcByte8;
      unsigned int destByte;
      int x, y;
 
      for (y = start; y < end; y++)
      {
        for (x = 0; x < conv.width; x++)
        {
          srcByte = (x * conv.bpp) + (conv.sbpl * y);
          destByte = (x * 4) + (conv.dbpl * y);
          srcByte8 = x + (conv.abpl * y);
 
          ((uchar*)conv.dstBuff)[destByte] = conv.srcBuff[srcByte];
          ((uchar*)conv.dstBuff)[destByte + 1] = conv.srcBuff[srcByte + 1];
          ((uchar*)conv.dstBuff)[destByte + 2] = conv.srcBuff[srcByte + 2];
          ((uchar*)conv.dstBuff)[destByte + 3] = conv.srcbuff8[srcByte8];
        }
      }
    }
 
private:
    bitmapToMat4& operator=(const bitmapToMat4&); // to quiet MSVC
 
    const ConvertBuffer conv;
};
 
class matToBitmap4 : public cv::ParallelLoopBody
{
public:
    matToBitmap4(const ConvertBuffer _conv)
        : conv(_conv)
    {}
 
    void operator()(const cv::Range& range) const
    {
      const int start = range.start;
      const int end = range.end;
      unsigned int srcByte;
      unsigned int destByte;
      unsigned int destByte8;
 
      int x, y;
 
      for (y = start; y < end; y++)
      {
        for (x = 0; x < conv.width; x++)
        {
          srcByte = (x * 4) + (conv.sbpl * y);
          destByte = (x * conv.bpp) + (conv.dbpl * y);
          destByte8 = x + (conv.abpl * y);
 
          ((uchar*)conv.dstBuff)[destByte] = conv.srcBuff[srcByte];
          ((uchar*)conv.dstBuff)[destByte + 1] = conv.srcBuff[srcByte + 1];
          ((uchar*)conv.dstBuff)[destByte + 2] = conv.srcBuff[srcByte + 2];
          ((uchar*)conv.srcbuff8)[destByte8] = conv.srcBuff[srcByte + 3];
        }
      }
    }
 
private:
    matToBitmap4& operator=(const matToBitmap4&); // to quiet MSVC
 
    const ConvertBuffer conv;
};
 
void ConversionTools::ScolBitmapToMatRGB(PtrObjBitmap scolBitmap, cv::Mat &mat)
{
  if (scolBitmap == 0)
    return;
  
  mat = ScolBitmapToMat(scolBitmap);
}
 
void ConversionTools::ScolBitmapToMatRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap scolBitmap8, cv::Mat &mat)
{
  if (scolBitmap == 0 || scolBitmap8 == 0)
    return;
  
  cv::Mat mrgb = ScolBitmapToMat(scolBitmap);
  cv::Mat ma = ScolBitmapToMat(scolBitmap8);
 
  cv::Mat inmat[] = { mrgb, ma };
  int from_to[] = { 0,0, 1,1, 2,2, 3,3 };
  cv::mixChannels(inmat, 2, &mat, 1, from_to, 4);
 
  //Scol bitmap are 32bits aligned
  /*
  int sbpl = scolBitmap->BPL;
  int abpl = scolBitmap8->BPL;
  int dbpl = scolBitmap->TailleW * (scolBitmap->BytesPP + scolBitmap8->BytesPP);
 
  ConvertBuffer conv(scolBitmap->bits, scolBitmap8->bits, mat.data, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, abpl, dbpl, scolBitmap->BytesPP);
  
  //do it parrallel
  cv::parallel_for_(cv::Range(0, scolBitmap->TailleH), bitmapToMat4(conv));
  */
}
 
void ConversionTools::MatToScolBitmapRGB(cv::Mat mat, PtrObjBitmap scolBitmap)
{
  if (scolBitmap == 0)
    return;
 
  //Scol bitmap are 32bits aligned
  int sbpl = scolBitmap->TailleW * scolBitmap->BytesPP;
  int dbpl = scolBitmap->BPL;
 
  if (sbpl == dbpl)
    memcpy(scolBitmap->bits, mat.data, scolBitmap->TailleW * scolBitmap->TailleH * scolBitmap->BytesPP);
  else
  {
    ConvertBuffer conv(mat.data, scolBitmap->bits, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, dbpl, scolBitmap->BytesPP);
 
    //do it parrallel
    cv::parallel_for_(cv::Range(0, scolBitmap->TailleH), bitmapToMat(conv));
  }
}
 
void ConversionTools::MatToScolBitmapBGR(cv::Mat mat, PtrObjBitmap scolBitmap)
{
  if (scolBitmap == 0)
    return;
  
  //Scol bitmap are 32bits aligned
  int sbpl = scolBitmap->TailleW * scolBitmap->BytesPP;
  int dbpl = scolBitmap->BPL;
  
#ifndef APPLE_IOS
  if (sbpl == dbpl)
    memcpy(scolBitmap->bits, mat.data, scolBitmap->TailleW * scolBitmap->TailleH * scolBitmap->BytesPP);
  else
#endif
  {
    ConvertBuffer conv(mat.data, scolBitmap->bits, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, dbpl, scolBitmap->BytesPP);
    
    //do it parrallel
    cv::parallel_for_(cv::Range(0, scolBitmap->TailleH), bitmapToMatBGR(conv));
  }
}
 
void ConversionTools::MatToScolBitmapRGBA(cv::Mat mat, PtrObjBitmap scolBitmap, PtrObjBitmap scolBitmap8)
{
  if (scolBitmap == 0 || scolBitmap8== 0)
    return;
 
  cv::Mat mrgb = ScolBitmapToMat(scolBitmap);
  cv::Mat ma = ScolBitmapToMat(scolBitmap8);
 
  // forming an array of matrices is a quite efficient operation,
  // because the matrix data is not copied, only the headers
  cv::Mat out[] = { mrgb, ma };
  // bgra[0] -> bgr[2], bgra[1] -> bgr[1],
  // bgra[2] -> bgr[0], bgra[3] -> alpha[0]
  int from_to[] = { 0,0, 1,1, 2,2, 3,3 };
  cv::mixChannels(&mat, 1, out, 2, from_to, 4);
 
  //Scol bitmap are 32bits aligned
  /*
  int sbpl = scolBitmap->TailleW * (scolBitmap->BytesPP + scolBitmap8->BytesPP);
  int abpl = scolBitmap8->BPL;
  int dbpl = scolBitmap->BPL;
 
  ConvertBuffer conv(mat.data, scolBitmap8->bits, scolBitmap->bits, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
  //do it parrallel
  cv::parallel_for_(cv::Range(0, scolBitmap->TailleH), matToBitmap4(conv));
  */
}
 
struct BlendBuffer
{
  BlendBuffer(cv::Mat& mbase, const cv::Mat& mtop, float _mix)
  {
    base = &mbase;
    top = mtop;
    width = (int)mbase.cols;
    height = (int)mbase.rows;
    mix = MAX(MIN(_mix, 1.0f), 0.0f);
    bpp = mbase.channels();
  }
 
  cv::Mat* base;
  cv::Mat top;
  int width;
  int height;
  float mix;
  int bpp;
};
 
class blenderRGBA : public cv::ParallelLoopBody
{
public:
    blenderRGBA(const BlendBuffer _conv)
        : conv(_conv)
    {}
 
    void operator()(const cv::Range& range) const
    {
      const int start = range.start;
      const int end = range.end;
 
      if (conv.base->channels() == 4)
      {
        typedef cv::Vec<uchar, 4> VT;
        cv::MatIterator_<VT> it1 = conv.base->begin<VT>() + (start * conv.width);
        cv::MatConstIterator_<VT> it1_end = conv.base->begin<VT>() + (end * conv.width);
        cv::MatConstIterator_<VT> it2 = conv.top.begin<VT>() + (start * conv.width);
 
        float alpha_base;
        float alpha_top;
        float alpha_final;
        VT result;
 
        for (; it1 != it1_end; ++it1, ++it2)
        {
          VT pix1 = *it1;
          VT pix2 = *it2;
 
          // Compute Alpha values
          alpha_base = ((float)(pix1[3])) / 255.0f;
          alpha_top = conv.mix * ((float)(pix2[3])) / 255.0f;
          alpha_final = alpha_top + alpha_base * (1.0f - alpha_top);
 
          // Mix red value
          float r_base = (pix1[0] * alpha_base) * (1.0f - alpha_top);
          float g_base = (pix1[1] * alpha_base) * (1.0f - alpha_top);
          float b_base = (pix1[2] * alpha_base) * (1.0f - alpha_top);
 
          float r_top = pix2[0] * alpha_top;
          float g_top = pix2[1] * alpha_top;
          float b_top = pix2[2] * alpha_top;
 
          result[0] = (uchar)((r_top + r_base) / alpha_final);
          result[1] = (uchar)((g_top + g_base) / alpha_final);
          result[2] = (uchar)((b_top + b_base) / alpha_final);
          result[3] = (uchar)(alpha_final * 255.0f);
 
          *it1 = result;
        }
      }
      else if (conv.base->channels() == 3)
      {
        typedef cv::Vec<uchar, 3> VT;
        cv::MatIterator_<VT> it1 = conv.base->begin<VT>() + (start * conv.width);
        cv::MatConstIterator_<VT> it1_end = conv.base->begin<VT>() + (end * conv.width);
        cv::MatConstIterator_<VT> it2 = conv.top.begin<VT>() + (start * conv.width);
 
        float alpha_base;
        float alpha_top;
        float alpha_final;
        VT result;
 
        for (; it1 != it1_end; ++it1, ++it2)
        {
          VT pix1 = *it1;
          VT pix2 = *it2;
 
          // Compute Alpha values
          alpha_base = 1.0f;
          alpha_top = conv.mix;
          alpha_final = alpha_top + alpha_base * (1.0f - alpha_top);
 
          // Mix red value
          float r_base = (pix1[0] * alpha_base) * (1.0f - alpha_top);
          float r_top = pix2[0] * alpha_top;
          float g_base = (pix1[1] * alpha_base) * (1.0f - alpha_top);
          float b_base = (pix1[2] * alpha_base) * (1.0f - alpha_top);
          float g_top = pix2[1] * alpha_top;
          float b_top = pix2[2] * alpha_top;
 
          result[0] = (uchar)((r_top + r_base) / alpha_final);
          result[1] = (uchar)((g_top + g_base) / alpha_final);
          result[2] = (uchar)((b_top + b_base) / alpha_final);
 
          *it1 = result;
        }
      }
      else
      {
        typedef cv::Vec<uchar, 1> VT;
        cv::MatIterator_<VT> it1 = conv.base->begin<VT>() + (start * conv.width);
        cv::MatConstIterator_<VT> it1_end = conv.base->begin<VT>() + (end * conv.width);
        cv::MatConstIterator_<VT> it2 = conv.top.begin<VT>() + (start * conv.width);
 
        float alpha_base;
        float alpha_top;
        float alpha_final;
        VT result;
 
        for (; it1 != it1_end; ++it1, ++it2)
        {
          VT pix1 = *it1;
          VT pix2 = *it2;
 
          // Compute Alpha values
          alpha_base = 1.0f;
          alpha_top = conv.mix;
          alpha_final = alpha_top + alpha_base * (1.0f - alpha_top);
 
          // Mix red value
          float r_base = (pix1[0] * alpha_base) * (1.0f - alpha_top);
          float r_top = pix2[0] * alpha_top;
          result[0] = (uchar)((r_top + r_base) / alpha_final);
 
          *it1 = result;
        }
      }
    }
 
private:
  blenderRGBA& operator=(const blenderRGBA&);
  const BlendBuffer conv;
};
 
void ConversionTools::Blend(cv::Mat& base, const cv::Mat& top, float mix)
{
  if (base.rows != top.rows || base.cols != top.cols)
    return;
 
  BlendBuffer conv(base, top, mix);
  cv::parallel_for_(cv::Range(0, base.rows), blenderRGBA(conv));
}
 
 
struct BlendBufferSep
{
  BlendBufferSep(cv::Mat& mbase, cv::Mat& mabase, const cv::Mat& mtop, const cv::Mat& matop, float _mix)
  {
    base = &mbase;
    abase = &mabase;
    top = mtop;
    atop = matop;
    width = (int)mbase.cols;
    height = (int)mbase.rows;
    mix = MAX(MIN(_mix, 1.0f), 0.0f);
    bpp = mbase.channels();
  }
 
  cv::Mat* base;
  cv::Mat* abase;
  cv::Mat top;
  cv::Mat atop;
 
  int width;
  int height;
  float mix;
  int bpp;
};
 
class blenderRGBASep : public cv::ParallelLoopBody
{
public:
  blenderRGBASep(const BlendBufferSep _conv)
    : conv(_conv)
  {}
 
  void operator()(const cv::Range& range) const
  {
    const int start = range.start;
    const int end = range.end;
 
    typedef cv::Vec<uchar, 3> VT;
    cv::MatIterator_<VT> it1 = conv.base->begin<VT>() + (start * conv.width);
    cv::MatIterator_<uchar> it1a = conv.abase->begin<uchar>() + (start * conv.width);
    cv::MatConstIterator_<VT> it1_end = conv.base->begin<VT>() + (end * conv.width);
    cv::MatConstIterator_<VT> it2 = conv.top.begin<VT>() + (start * conv.width);
    cv::MatConstIterator_<uchar> it2a = conv.atop.begin<uchar>() + (start * conv.width);
 
    float alpha_base;
    float alpha_top;
    float alpha_final;
    VT result;
 
    for (; it1 != it1_end; ++it1, ++it2, ++it1a, ++it2a)
    {
      VT pix1 = *it1;
      VT pix2 = *it2;
      uchar pix1a = *it1a;
      uchar pix2a = *it2a;
 
      alpha_base = ((float)(pix1a)) / 255.0f;
      alpha_top = conv.mix * ((float)(pix2a)) / 255.0f;
      alpha_final = alpha_top + alpha_base * (1.0f - alpha_top);
 
      // Mix red value
      float r_base = (pix1[0] * alpha_base) * (1.0f - alpha_top);
      float r_top = pix2[0] * alpha_top;
      result[0] = (uchar)((r_top + r_base) / alpha_final);
 
      float g_base = (pix1[1] * alpha_base) * (1.0f - alpha_top);
      float b_base = (pix1[2] * alpha_base) * (1.0f - alpha_top);
      float g_top = pix2[1] * alpha_top;
      float b_top = pix2[2] * alpha_top;
 
      result[1] = (uchar)((g_top + g_base) / alpha_final);
      result[2] = (uchar)((b_top + b_base) / alpha_final);
 
      *it1 = result;
      *it1a = (uchar)(alpha_final * 255.0f);
    }
  }
 
private:
  blenderRGBASep& operator=(const blenderRGBASep&);
  const BlendBufferSep conv;
};
 
void ConversionTools::Blend(cv::Mat& base, cv::Mat& abase, const cv::Mat& top, const cv::Mat& atop, float mix)
{
  if (base.rows != top.rows || base.cols != top.cols || abase.cols != atop.cols || abase.cols != atop.cols)
    return;
 
  BlendBufferSep conv(base, abase, top, atop, mix);
  cv::parallel_for_(cv::Range(0, base.rows), blenderRGBASep(conv));
}
 
int ConversionTools::GetScolBitmapAlignment(int width, int nbcomponents)
{
  int align = width * nbcomponents;
  if (align % 4 != 0)
    align += 4 - (align % 4);
 
  return align;
}
 
cv::Mat ConversionTools::ScolBitmapToMat(PtrObjBitmap scolBitmap)
{
  if (scolBitmap->bits == 0)
    return cv::Mat();
 
  int align = GetScolBitmapAlignment(scolBitmap->TailleW, scolBitmap->BytesPP);
 
  int bitsType = CV_8UC3;
  switch (scolBitmap->BytesPP)
  {
  case 1:
    bitsType = CV_8UC1;
    break;
  case 3:
    bitsType = CV_8UC3;
    break;
  case 4:
    bitsType = CV_8UC4;
    break;
  default:
    return cv::Mat();
  }
 
  return cv::Mat(scolBitmap->TailleH, scolBitmap->TailleW, bitsType, (void*)scolBitmap->bits, align);
}
 
cv::Mat ConversionTools::ScolBitmapBufferToMat(void* buffer, int width, int height, int nbcomponents, bool align)
{
  int align32 = GetScolBitmapAlignment(width, nbcomponents);
 
  int bitsType = CV_8UC3;
  switch (nbcomponents)
  {
  case 1:
    bitsType = CV_8UC1;
    break;
  case 3:
    bitsType = CV_8UC3;
    break;
  case 4:
    bitsType = CV_8UC4;
    break;
  default:
    return cv::Mat();
  }
 
  if (align)
    return cv::Mat(height, width, bitsType, (void*)buffer, align32);
  else
    return cv::Mat(height, width, bitsType, (void*)buffer);
}
 
//(int dtaillew, int dtailleh, int staillew, int stailleh, int *dposx, int *dposy, int *sposx, int *sposy, int *taillew, int *tailleh)
bool ConversionTools::ClipBitmapRect(const cv::Mat src, cv::Rect &srect, const cv::Mat dst, cv::Rect &drect)
{
  int swidth = src.cols;
  int sheight = src.rows;
  int dwidth = dst.cols;
  int dheight = dst.rows;
 
  if ((swidth == 0) || (sheight == 0) || (dwidth == 0) || (dheight == 0))
    return false;
 
  if (drect.x < 0)
  {
    srect.x -= drect.x;
    srect.width += drect.x;
    drect.width += drect.x;
    drect.x = 0;
  }
  else if (drect.x >= dwidth)
    return false;
 
  if (drect.y < 0)
  {
    srect.y -= drect.y;
    srect.height += drect.y;
    drect.height += drect.y;
    drect.y = 0;
  }
  else if (drect.y >= dheight)
    return false;
 
  if (srect.x < 0)
  {
    srect.width += srect.x;
    drect.width += srect.x;
    drect.x -= srect.x;
    srect.x = 0;
  }
  else if (srect.x >= swidth)
    return false;
 
  if (srect.y < 0)
  {
    srect.height += srect.y;
    drect.height += srect.y;
    drect.y -= srect.y;
    srect.y = 0;
  }
  else if (srect.y >= sheight)
    return false;
 
  if ((srect.width <= 0) || (drect.width <= 0))
    return false;
 
  if (srect.width + srect.x > swidth)
  {
    drect.width -= (srect.width + srect.x) - swidth;
    srect.width -= (srect.width + srect.x) - swidth;
    if ((srect.width <= 0) || (drect.width <= 0))
      return false;
  }
 
  if (drect.width + drect.x > dwidth)
  {
    srect.width -= (drect.width + drect.x) - dwidth;
    drect.width -= (drect.width + drect.x) - dwidth;
    if ((srect.width <= 0) || (drect.width <= 0))
      return false;
  }
 
  if ((srect.height <= 0) || (drect.height <= 0))
    return false;
 
  if (srect.height + srect.y > sheight)
  {
    drect.height -= (srect.height + srect.y) - sheight;
    srect.height -= (srect.height + srect.y) - sheight;
    if ((srect.height <= 0) || (drect.height <= 0))
      return false;
  }
 
  if (drect.height + drect.y > dheight)
  {
    srect.height -= (drect.height + drect.y) - dheight;
    drect.height -= (drect.height + drect.y) - dheight;
    if ((srect.height <= 0) || (drect.height <= 0))
      return false;
  }
 
  return true;
}