SO3ConversionTools.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 <boost/thread/thread.hpp>
#include "SO3Utils/SO3ConversionTools.h"
 
#include <iostream>
#include <iomanip> 
 
namespace SO3
{
 
  std::string ConversionTools::GetValidImageExtension(std::string ext)
  {
    if ((ext == "png") || (ext == "bmp") || (ext == "tga") || (ext == "jpg") || (ext == "hdr"))
      return ext;
    else
      return std::string("png");
  }
 
  bool ConversionTools::SaveOgreImage(Ogre::Image &image, boost::filesystem::path &path)
  {
    std::string ext = boost::filesystem::extension(path).substr(1);
 
    int channels = (int)Ogre::PixelUtil::getComponentCount(image.getFormat());
    int stride = image.getWidth() * (int)Ogre::PixelUtil::getNumElemBytes(image.getFormat());
 
    if (ext == "png")
    {
      image.save(path.generic_string());
      return true;
      //return (bool)stbi_write_png(path.generic_string().c_str(), image.getWidth(), image.getHeight(), channels, image.getData(), stride);
    }
    else if (ext == "bmp")
    {
      return (bool)stbi_write_bmp(path.generic_string().c_str(), image.getWidth(), image.getHeight(), channels, image.getData());
    }
    else if (ext == "tga")
    {
      return (bool)stbi_write_tga(path.generic_string().c_str(), image.getWidth(), image.getHeight(), channels, image.getData());
    }
    else if (ext == "jpg")
    {
      return (bool)stbi_write_jpg(path.generic_string().c_str(), image.getWidth(), image.getHeight(), channels, image.getData(), 90);
    }
    else if (ext == "hdr")
    {
      return (bool)stbi_write_hdr(path.generic_string().c_str(), image.getWidth(), image.getHeight(), channels, (const float*)image.getData());
    }
 
    return false;
  }
 
  bool ConversionTools::SaveImage(const std::string &filename, int w, int h, int channels, const void *data, int quality)
  {
    std::string::size_type index_of_extension = filename.find_last_of('.');
    std::string ext = filename.substr(index_of_extension + 1);
 
    if (ext == "png")
    {
      return (bool)stbi_write_png(filename.c_str(), w, h, channels, data, w * channels);
    }
    else if (ext == "bmp")
    {
      return (bool)stbi_write_bmp(filename.c_str(), w, h, channels, data);
    }
    else if (ext == "tga")
    {
      return (bool)stbi_write_tga(filename.c_str(), w, h, channels, data);
    }
    else if (ext == "jpg")
    {
      return (bool)stbi_write_jpg(filename.c_str(), w, h, channels, data, quality);
    }
    else if (ext == "hdr")
    {
      return (bool)stbi_write_hdr(filename.c_str(), w, h, channels, (const float*)data);
    }
 
    return false;
  }
 
#define FLOATEPSILON std::numeric_limits<double>::epsilon()
 
  ConversionTools::ConversionTools()
  {
    // Forbiden (private). Use static functions instead.
  }
 
  int ConversionTools::OgreToScolColorRGBA(const Ogre::ColourValue& ogreColor)
  {
    // ATTENTION! RGB and RGBA values are encoded in a different way!
    // RGBA colour are encoded by scol as "RR GG BB 0A << 1" in memory ("see SCOLParticle.cpp" of the ZooEngine (!)).
    int a = static_cast<int>(ogreColor.a * CONST_COLOR_ALPHA);
    int b = static_cast<int>(ogreColor.b * CONST_COLOR);
    int g = static_cast<int>(ogreColor.g * CONST_COLOR);
    int r = static_cast<int>(ogreColor.r * CONST_COLOR);
    return 0x0 + ((a & 0x0000007E) + ((b & 0x000000ff) << 7) + ((g & 0x000000ff) << 15) + ((r & 0x000000ff) << 23));
  }
 
  Ogre::ColourValue ConversionTools::ScolToOgreColorRGBA(const int& scolColor)
  {
    // ATTENTION! RGB and RGBA values are encoded in a different way!
    // RGBA colour are encoded by scol as "RR GG BB 0A << 1" in memory ("see SCOLParticle.cpp" of the ZooEngine (!)).
    float r = ((scolColor >> 23) & 0x000000ff) / CONST_COLOR;
    float g = ((scolColor >> 15) & 0x000000ff) / CONST_COLOR;
    float b = ((scolColor >> 7) & 0x000000ff) / CONST_COLOR;
    float a = ((scolColor) & 0x0000007E) / CONST_COLOR_ALPHA;
    return Ogre::ColourValue(r, g, b, a);
  }
 
  int ConversionTools::OgreToScolColorRGB(const Ogre::ColourValue& ogreColor)
  {
    // ATTENTION! RGB and RGBA values are encoded in a different way!
    // RGB colour are encoded by scol as "00 BB GG RR" in memory (see make_rgb bind, "CSTmakeRGB" in "utils.c" of the scol VM).
    int b = static_cast<int>(ogreColor.b * CONST_COLOR);
    int g = static_cast<int>(ogreColor.g * CONST_COLOR);
    int r = static_cast<int>(ogreColor.r * CONST_COLOR);
    return 0x0 + (r & 0x000000ff) + ((g & 0x000000ff) << 8) + ((b & 0x000000ff) << 16);
  }
 
  Ogre::ColourValue ConversionTools::ScolToOgreColorRGB(const int& scolColor)
  {
    // ATTENTION! RGB and RGBA values are encoded in a different way!
    // RGB colour are encoded by scol as "00 BB GG RR" in memory (see make_rgb bind, "CSTmakeRGB" in "utils.c" of the scol VM).
    float b = ((scolColor >> 16) & 0x000000ff) / CONST_COLOR;
    float g = ((scolColor >> 8) & 0x000000ff) / CONST_COLOR;
    float r = ((scolColor) & 0x000000ff) / CONST_COLOR;
    return Ogre::ColourValue(r, g, b, 1.0f);
  }
 
  void ConversionTools::bitmapToBuff(const int start, const int end, const SConvertBuffer &conv)
  {
    size_t srcByte;
    size_t 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);
 
        ((Ogre::uint8*)conv.dstBuff)[destByte] = conv.srcBuff[srcByte];
        ((Ogre::uint8*)conv.dstBuff)[destByte + 1] = conv.srcBuff[srcByte + 1];
        ((Ogre::uint8*)conv.dstBuff)[destByte + 2] = conv.srcBuff[srcByte + 2];
      }
    }
  }
 
  void ConversionTools::bitmapsToBuffPf(const int start, const int end, const SConvertBuffer &conv, Ogre::PixelFormat format)
  {
    size_t srcByte;
    size_t destByte;
    int x, y;
    Ogre::uint8 r, g, b, a;
 
    size_t pixelSize = Ogre::PixelUtil::getNumElemBytes(format);
    for (y = start; y < end; y++)
    {
      for (x = 0; x < conv.width; x++)
      {
        srcByte = (x * conv.bpp) + (conv.sbpl * y);
        destByte = (x * pixelSize) + (conv.dbpl * y);
        r = conv.srcBuff[srcByte];
        g = conv.srcBuff[srcByte + 1];
        b = conv.srcBuff[srcByte + 2];
        a = (conv.srcBuffa != 0) ? conv.srcBuffa[(x + (conv.abpl * y))] : 255;
 
        Ogre::PixelUtil::packColour(b, g, r, a, format, &((Ogre::uint8*)conv.dstBuff)[destByte]);
      }
    }
  }
 
  void ConversionTools::bitmapsToScaleBuffNearest(const int start, const int end, const SConvertBuffer &conv, Ogre::PixelFormat format, const int x_ratio, const int y_ratio)
  {
    int x, y, i, j;
    Ogre::uint8 r, g, b, a;
    size_t destByte;
 
    unsigned char pixelSize = Ogre::PixelUtil::getNumElemBytes(format);
    for (i = start; i < end; i++)
    {
      for (j = 0; j < conv.width; j++)
      {
        destByte = pixelSize * ((i * conv.width) + j);
        y = (i * y_ratio) >> 16;
        x = (j * x_ratio) >> 16;
        r = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp)];
        g = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + 1];
        b = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + 2];
        if (conv.bpp == 4)
          a = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + 3];
        else
          a = (conv.srcBuffa != 0) ? conv.srcBuffa[(conv.abpl * y) + x] : 255;
 
        Ogre::PixelUtil::packColour(b, g, r, a, format, &((Ogre::uint8*)conv.dstBuff)[destByte]);
      }
    }
  }
 
  void ConversionTools::bitmapsToScaleBuffBilinear(const int start, const int end, const SConvertBuffer &conv, Ogre::PixelFormat format, const float x_ratio, const float y_ratio)
  {
    int x, y, i, j;
    float w, h;
    Ogre::uint8 r, g, b, a;
    Ogre::uint A[4];
    Ogre::uint B[4];
    Ogre::uint C[4];
    Ogre::uint D[4];
 
    unsigned char pixelSize = Ogre::PixelUtil::getNumElemBytes(format);
    for (i = start; i < end; i++)
    {
      for (j = 0; j < conv.width; j++)
      {
        y = (int)(y_ratio * i);
        x = (int)(x_ratio * j);
        w = (x_ratio * j) - x;
        h = (y_ratio * i) - y;
 
        A[0] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp)];
        B[0] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + conv.bpp];
        C[0] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp)];
        D[0] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp) + conv.bpp];
 
        A[1] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + 1];
        B[1] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + conv.bpp + 1];
        C[1] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp) + 1];
        D[1] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp) + conv.bpp + 1];
 
        A[2] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + 2];
        B[2] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + conv.bpp + 2];
        C[2] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp) + 2];
        D[2] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp) + conv.bpp + 2];
 
        if (conv.bpp == 4)
        {
          A[3] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + 3];
          B[3] = conv.srcBuff[(y * conv.sbpl) + (x * conv.bpp) + conv.bpp + 3];
          C[3] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp) + 3];
          D[3] = conv.srcBuff[((y + 1) * conv.sbpl) + (x * conv.bpp) + conv.bpp + 3];
        }
        else
        {
          A[3] = (conv.srcBuffa != 0) ? conv.srcBuffa[(y * conv.abpl) + x] : 255;
          B[3] = (conv.srcBuffa != 0) ? conv.srcBuffa[(y * conv.abpl) + x + 1] : 255;
          C[3] = (conv.srcBuffa != 0) ? conv.srcBuffa[((y + 1) * conv.abpl) + x] : 255;
          D[3] = (conv.srcBuffa != 0) ? conv.srcBuffa[((y + 1) * conv.abpl) + x + 1] : 255;
        }
 
        r = (Ogre::uint8)(A[0] * (1 - w) * (1 - h) + B[0] * (w)* (1 - h) + C[0] * (h)* (1 - w) + D[0] * (w * h));
        g = (Ogre::uint8)(A[1] * (1 - w) * (1 - h) + B[1] * (w)* (1 - h) + C[1] * (h)* (1 - w) + D[1] * (w * h));
        b = (Ogre::uint8)(A[2] * (1 - w) * (1 - h) + B[2] * (w)* (1 - h) + C[2] * (h)* (1 - w) + D[2] * (w * h));
        a = (Ogre::uint8)(A[3] * (1 - w) * (1 - h) + B[3] * (w)* (1 - h) + C[3] * (h)* (1 - w) + D[3] * (w * h));
 
        Ogre::PixelUtil::packColour(b, g, r, a, format, &((Ogre::uint8*)conv.dstBuff)[pixelSize * ((i * conv.width) + j)]);
      }
    }
  }
 
  void ConversionTools::ScolBitmapGetRGB(PtrObjBitmap scolBitmap, unsigned char* buff)
  {
    if ((scolBitmap == 0) || (buff == 0))
      return;
 
    //Scol bitmap are 32bits aligned
    int sbpl = scolBitmap->BPL;
    int dbpl = scolBitmap->TailleW * 3;
 
    if (sbpl == dbpl)
      memcpy(buff, scolBitmap->bits, scolBitmap->TailleW * scolBitmap->TailleH * scolBitmap->BytesPP);
    else
    {
      int numthreads = (scolBitmap->TailleH <= 8) ? 1 : std::thread::hardware_concurrency();
      int rows = scolBitmap->TailleH / numthreads;
      int extra = scolBitmap->TailleH % numthreads;
      int start = 0;
      int end = rows;
 
      ConversionTools::SConvertBuffer conv(scolBitmap->bits, 0, buff, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, 1, dbpl, scolBitmap->BytesPP);
 
      std::vector<std::thread> thgroup;
      for (int t = 1; t <= numthreads; t++)
      {
        if (t == numthreads) // last thread does extra rows:
          end += extra;
 
        thgroup.emplace_back(std::bind(ConversionTools::bitmapToBuff, start, end, conv));
 
        start = end;
        end = start + rows;
      }
 
      for (auto& thread : thgroup)
        thread.join();
    }
  }
 
  void ConversionTools::ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, const Ogre::PixelBox& pixelbox)
  {
    if ((scolBitmap == 0) || (pixelbox.data == 0))
      return;
 
    unsigned char pixelSize = Ogre::PixelUtil::getNumElemBytes(pixelbox.format);
 
    //Scol bitmap are 32bits aligned
    int sbpl = scolBitmap->BPL;
    int abpl = (alphaBitmap != 0) ? alphaBitmap->BPL : 0;
    int dbpl = pixelSize * pixelbox.rowPitch;
    uchar* alphaBuff = (alphaBitmap != 0) ? alphaBitmap->bits : 0;
 
    //no scale needed
    if ((scolBitmap->TailleW == pixelbox.getWidth()) && ((scolBitmap->TailleH == pixelbox.getHeight())))
    {
      if (!alphaBitmap && (sbpl == dbpl) && (pixelbox.format == Ogre::PF_BYTE_BGR))
      {
        memcpy(pixelbox.data, scolBitmap->bits, scolBitmap->TailleW * scolBitmap->TailleH * scolBitmap->BytesPP);
      }
      else
      {
        int numthreads = (scolBitmap->TailleH <= 8) ? 1 : std::thread::hardware_concurrency();
        int rows = scolBitmap->TailleH / numthreads;
        int extra = scolBitmap->TailleH % numthreads;
        int start = 0;
        int end = rows;
 
        ConversionTools::SConvertBuffer conv(scolBitmap->bits, alphaBuff, pixelbox.data, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
        std::vector<std::thread> thgroup;
        for (int t = 1; t <= numthreads; t++)
        {
          if (t == numthreads) // last thread does extra rows:
            end += extra;
 
          thgroup.emplace_back(std::bind(ConversionTools::bitmapsToBuffPf, start, end, conv, pixelbox.format));
 
          start = end;
          end = start + rows;
        }
 
        for (auto& thread : thgroup)
          thread.join();
      }
    }
    else
    {
#if defined(ANDROID)// || defined(APPLE_IOS)
      //nearest pixel fast but crappy
      int x_ratio = (int)(((scolBitmap->TailleW - 1) << 16) / pixelbox.getWidth());
      int y_ratio = (int)(((scolBitmap->TailleH - 1) << 16) / pixelbox.getHeight());
 
      int numthreads = (pixelbox.getHeight() <= 8) ? 1 : std::thread::hardware_concurrency();
      int rows = pixelbox.getHeight() / numthreads;
      int extra = pixelbox.getHeight() % numthreads;
      int start = 0;
      int end = rows;
 
      ConversionTools::SConvertBuffer conv(scolBitmap->bits, alphaBuff, pixelbox.data, pixelbox.getWidth(), pixelbox.getHeight(), sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
      std::vector<std::thread> thgroup;
      for (int t = 1; t <= numthreads; t++)
      {
        if (t == numthreads) // last thread does extra rows:
          end += extra;
 
        thgroup.emplace_back(std::bind(ConversionTools::bitmapsToScaleBuffNearest, start, end, conv, pixelbox.format, x_ratio, y_ratio));
 
        start = end;
        end = start + rows;
      }
 
      for (auto& thread : thgroup)
        thread.join();
#else
      //bilinear pixel
      float x_ratio = (float)(scolBitmap->TailleW - 1) / (float)pixelbox.getWidth();
      float y_ratio = (float)(scolBitmap->TailleH - 1) / (float)pixelbox.getHeight();
 
      int numthreads = (pixelbox.getHeight() <= 8) ? 1 : std::thread::hardware_concurrency();
      int rows = pixelbox.getHeight() / numthreads;
      int extra = pixelbox.getHeight() % numthreads;
      int start = 0;
      int end = rows;
 
      ConversionTools::SConvertBuffer conv(scolBitmap->bits, alphaBuff, pixelbox.data, pixelbox.getWidth(), pixelbox.getHeight(), sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
      std::vector<std::thread> thgroup;
      for (int t = 1; t <= numthreads; t++)
      {
        if (t == numthreads) // last thread does extra rows:
          end += extra;
 
        thgroup.emplace_back(std::bind(ConversionTools::bitmapsToScaleBuffBilinear, start, end, conv, pixelbox.format, x_ratio, y_ratio));
 
        start = end;
        end = start + rows;
      }
 
      for (auto& thread : thgroup)
        thread.join();
#endif
    }
  }
 
  void ConversionTools::ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, void* buff)
  {
    if ((scolBitmap == 0) || (buff == 0))
      return;
 
    //Scol bitmap are 32bits aligned
    int sbpl = scolBitmap->BPL;
    int abpl = (alphaBitmap != 0) ? alphaBitmap->BPL : 0;
    int dbpl = scolBitmap->TailleW;
    uchar* alphaBuff = (alphaBitmap != 0) ? alphaBitmap->bits : 0;
 
    int numthreads = (scolBitmap->TailleH <= 8) ? 1 : std::thread::hardware_concurrency();
    int rows = scolBitmap->TailleH / numthreads;
    int extra = scolBitmap->TailleH % numthreads;
    int start = 0;
    int end = rows;
 
    Ogre::PixelFormat format = Ogre::PF_BYTE_BGRA;
    ConversionTools::SConvertBuffer conv(scolBitmap->bits, alphaBuff, buff, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
    std::vector<std::thread> thgroup;
    for (int t = 1; t <= numthreads; t++)
    {
      if (t == numthreads) // last thread does extra rows:
        end += extra;
 
      thgroup.emplace_back(std::bind(ConversionTools::bitmapsToBuffPf, start, end, conv, format));
 
      start = end;
      end = start + rows;
    }
 
    for (auto& thread : thgroup)
      thread.join();
  }
 
  void ConversionTools::ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, Ogre::PixelFormat format, void* buff)
  {
    if ((scolBitmap == 0) || (buff == 0))
      return;
 
    unsigned char pixelSize = Ogre::PixelUtil::getNumElemBytes(format);
 
    //Scol bitmap are 32bits aligned
    int sbpl = scolBitmap->BPL;
    int abpl = (alphaBitmap != 0) ? alphaBitmap->BPL : 0;
    int dbpl = pixelSize * scolBitmap->TailleW;
    uchar* alphaBuff = (alphaBitmap != 0) ? alphaBitmap->bits : 0;
 
    if (!alphaBitmap && (sbpl == dbpl) && (format == Ogre::PF_BYTE_BGR))
    {
      memcpy(buff, scolBitmap->bits, scolBitmap->TailleW * scolBitmap->TailleH * scolBitmap->BytesPP);
    }
    else
    {
      int numthreads = (scolBitmap->TailleH <= 8) ? 1 : std::thread::hardware_concurrency();
      int rows = scolBitmap->TailleH / numthreads;
      int extra = scolBitmap->TailleH % numthreads;
      int start = 0;
      int end = rows;
 
      ConversionTools::SConvertBuffer conv(scolBitmap->bits, alphaBuff, buff, scolBitmap->TailleW, scolBitmap->TailleH, sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
      std::vector<std::thread> thgroup;
      for (int t = 1; t <= numthreads; t++)
      {
        if (t == numthreads) // last thread does extra rows:
          end += extra;
 
        thgroup.emplace_back(std::bind(ConversionTools::bitmapsToBuffPf, start, end, conv, format));
 
        start = end;
        end = start + rows;
      }
 
      for (auto& thread : thgroup)
        thread.join();
    }
  }
 
  void ConversionTools::ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, unsigned int nwidth, unsigned int nheight, Ogre::PixelFormat format, void* buff)
  {
    if ((scolBitmap == 0) || (buff == 0))
      return;
 
    //no scale needed
    if ((scolBitmap->TailleW == nwidth) && ((scolBitmap->TailleH == nheight)))
      return ScolBitmapGetRGBA(scolBitmap, alphaBitmap, format, buff);
 
    unsigned char pixelSize = Ogre::PixelUtil::getNumElemBytes(format);
 
    //Scol bitmap are 32bits aligned
    int sbpl = scolBitmap->BPL;
    int abpl = (alphaBitmap != 0) ? alphaBitmap->BPL : 0;
    int dbpl = nwidth * pixelSize;
    uchar* alphaBuff = (alphaBitmap != 0) ? alphaBitmap->bits : 0;
 
#if defined(ANDROID)// || defined(APPLE_IOS)
    //nearest pixel fast but crappy
    int x_ratio = (int)(((scolBitmap->TailleW - 1) << 16) / nwidth);
    int y_ratio = (int)(((scolBitmap->TailleH - 1) << 16) / nheight);
 
    int numthreads = (nheight <= 8) ? 1 : std::thread::hardware_concurrency();
    int rows = nheight / numthreads;
    int extra = nheight % numthreads;
    int start = 0;
    int end = rows;
 
    ConversionTools::SConvertBuffer conv(scolBitmap->bits, alphaBuff, buff, nwidth, nheight, sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
    std::vector<std::thread> thgroup;
    for (int t = 1; t <= numthreads; t++)
    {
      if (t == numthreads) // last thread does extra rows:
        end += extra;
 
      thgroup.emplace_back(std::bind(ConversionTools::bitmapsToScaleBuffNearest, start, end, conv, format, x_ratio, y_ratio));
 
      start = end;
      end = start + rows;
  }
 
    for (auto& thread : thgroup)
      thread.join();
#else
    //bilinear pixel
    float x_ratio = (float)(scolBitmap->TailleW - 1) / (float)nwidth;
    float y_ratio = (float)(scolBitmap->TailleH - 1) / (float)nheight;
 
    int numthreads = (nheight <= 8) ? 1 : std::thread::hardware_concurrency();
    int rows = nheight / numthreads;
    int extra = nheight % numthreads;
    int start = 0;
    int end = rows;
 
    ConversionTools::SConvertBuffer conv(scolBitmap->bits, alphaBuff, buff, nwidth, nheight, sbpl, abpl, dbpl, scolBitmap->BytesPP);
 
    std::vector<std::thread> thgroup;
    for (int t = 1; t <= numthreads; t++)
    {
      if (t == numthreads) // last thread does extra rows:
        end += extra;
 
      thgroup.emplace_back(std::bind(ConversionTools::bitmapsToScaleBuffBilinear, start, end, conv, format, x_ratio, y_ratio));
 
      start = end;
      end = start + rows;
    }
 
    for (auto& thread : thgroup)
      thread.join();
#endif
}
 
 
  void ConversionTools::ScolBitmapGetRGBA(const uchar* sbuff, const int swidth, const int sheight, const int sbpp, const int sbpl, unsigned int nwidth, unsigned int nheight, Ogre::PixelFormat format, void* buff)
  {
    if ((sbuff == 0) || (buff == 0))
      return;
 
    unsigned char pixelSize = Ogre::PixelUtil::getNumElemBytes(format);
    int dbpl = nwidth * pixelSize;
 
#if defined(ANDROID)// || defined(APPLE_IOS)
    //nearest pixel fast but crappy
    int x_ratio = (int)(((swidth - 1) << 16) / nwidth);
    int y_ratio = (int)(((sheight - 1) << 16) / nheight);
 
    int numthreads = (nheight <= 8) ? 1 : std::thread::hardware_concurrency();
    int rows = nheight / numthreads;
    int extra = nheight % numthreads;
    int start = 0;
    int end = rows;
 
    ConversionTools::SConvertBuffer conv(sbuff, 0, buff, nwidth, nheight, sbpl, 0, dbpl, sbpp);
 
    std::vector<std::thread> thgroup;
    for (int t = 1; t <= numthreads; t++)
    {
      if (t == numthreads) // last thread does extra rows:
        end += extra;
 
      thgroup.emplace_back(std::bind(ConversionTools::bitmapsToScaleBuffNearest, start, end, conv, format, x_ratio, y_ratio));
 
      start = end;
      end = start + rows;
  }
 
    for (auto& thread : thgroup)
      thread.join();
#else
    //bilinear pixel
    float x_ratio = (float)(swidth - 1) / (float)nwidth;
    float y_ratio = (float)(sheight - 1) / (float)nheight;
 
    int numthreads = (nheight <= 8) ? 1 : std::thread::hardware_concurrency();
    int rows = nheight / numthreads;
    int extra = nheight % numthreads;
    int start = 0;
    int end = rows;
 
    ConversionTools::SConvertBuffer conv(sbuff, 0, buff, nwidth, nheight, sbpl, 0, dbpl, sbpp);
 
    std::vector<std::thread> thgroup;
    for (int t = 1; t <= numthreads; t++)
    {
      if (t == numthreads) // last thread does extra rows:
        end += extra;
 
      thgroup.emplace_back(std::bind(ConversionTools::bitmapsToScaleBuffBilinear, start, end, conv, format, x_ratio, y_ratio));
 
      start = end;
      end = start + rows;
    }
 
    for (auto& thread : thgroup)
      thread.join();
#endif
  }
 
  bool ConversionTools::fequal(float a, float b)
  {
    return (fabs(a - b) < FLOATEPSILON);
  }
 
  double ConversionTools::GetDecExp(int nDec)
  {
    double dRet;
    double ad[6] = { 1.,10.,100.,1000.,10000.,100000. };
 
    if (nDec >= 0 && nDec <= 5) return(ad[nDec]);
    dRet = ad[5];
    for (int i = 1; i < nDec - 4; i++) dRet *= 10.;
    return floor(dRet);
  }
 
  double ConversionTools::Roundn(double dValue, int nDecimales)
  {
    if (nDecimales < 0 || dValue == 0.) return(dValue);
 
    double dSeuil = (dValue < 0. ? -.5 : .5);
    double dExp = GetDecExp(nDecimales);
    double dCalc = (((dValue*dExp) + dSeuil));
 
    if (dValue < 0.)
      return(ceil(dCalc) / dExp);
    else
      return(floor(dCalc) / dExp);
  }
 
  float ConversionTools::formatFloat(float val)
  {
    return static_cast<float>(Roundn((double)val, 6));
  }
 
  double ConversionTools::formatFloat(double val)
  {
    return Roundn(val, 6);
  }
 
  std::string ConversionTools::formatFloatToString(float val)
  {
    float ret = static_cast<float>(Roundn((double)val, 6));
    std::stringstream stream;
    stream << std::fixed << std::setprecision(6) << ret;
    return stream.str();
  }
 
  std::string ConversionTools::formatFloatToString(double val)
  {
    double ret = Roundn(val, 6);
    std::stringstream stream;
    stream << std::fixed << std::setprecision(6) << ret;
    return stream.str();
  }
}