SO3ConversionTools.h

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
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3CONVERSIONTOOLS_H__
#define __SO3CONVERSIONTOOLS_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
 
#include "OGRE/OgreImage.h"
#include <boost/filesystem.hpp>
 
//STBI
#define STB_IMAGE_WRITE_IMPLEMENTATION
#define STB_IMAGE_WRITE_STATIC
#include "External/stbi/stb_image_write.h"
 
namespace SO3
{
 
class ConversionTools
{
public:
  static std::string GetValidImageExtension(std::string ext);
  static bool SaveOgreImage(Ogre::Image &image, boost::filesystem::path &path);
  static bool SaveImage(const std::string &filename, int w, int h, int comp, const void *data, int quality = 90);
 
public:
  class SConvertBuffer
  {
  public:
    SConvertBuffer(const uchar* _srcBuff, const uchar* _srcBuffa, void* _dstBuff, const int &_width, const int &_height, const int &_sbpl, const int &_abpl, const int &_dbpl, const int &_bpp) :
      srcBuff(_srcBuff),
      srcBuffa(_srcBuffa),
      dstBuff(_dstBuff),
      width(_width),
      height(_height),
      sbpl(_sbpl),
      abpl(_abpl),
      dbpl(_dbpl),
      bpp(_bpp)
    {}
    
    ~SConvertBuffer(){}
    
    const uchar* srcBuff;
    const uchar* srcBuffa;
    void* dstBuff;
    const int width;
    const int height;
    const int sbpl;
    const int abpl;
    const int dbpl;
    const int bpp;
  };
protected:
private:
 
public:
  static int OgreToScolColorRGBA(const Ogre::ColourValue& ogreColor);
 
  static Ogre::ColourValue ScolToOgreColorRGBA(const int& scolColor);
 
  static int OgreToScolColorRGB(const Ogre::ColourValue& ogreColor);
 
  static Ogre::ColourValue ScolToOgreColorRGB(const int& scolColor);
 
  static void bitmapToBuff(const int start, const int end, const SConvertBuffer &conv);
 
  static void bitmapsToBuffPf(const int start, const int end, const SConvertBuffer &conv, const Ogre::PixelFormat format);
 
  static void bitmapsToScaleBuffNearest(const int start, const int end, const SConvertBuffer &conv, const Ogre::PixelFormat format, const int x_ratio, const int y_ratio);
 
  static void bitmapsToScaleBuffBilinear(const int start, const int end, const SConvertBuffer &conv, const Ogre::PixelFormat format, const float x_ratio, const float y_ratio);
 
  static void ScolBitmapGetRGB(PtrObjBitmap scolBitmap, unsigned char* buff);
 
  static void ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, const Ogre::PixelBox& pixelbox);
 
  static void ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, void* buff);
 
  static void ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, Ogre::PixelFormat format, void* buff);
 
  static void ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, unsigned int nwidth, unsigned int nheight, Ogre::PixelFormat format, void* buff);
  
  static void 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);
  
  static float formatFloat(float val);
 
  static std::string formatFloatToString(double val);
 
  static std::string formatFloatToString(float val);
 
  static double formatFloat(double val);
 
  static double Roundn(double dValue,int nDecimales);
 
  static bool fequal(float a, float b);
 
protected:
private:
  ConversionTools();
  static double GetDecExp(int nDec);
};
 
}
 
#endif