MEImage.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#include "MEDefs.hpp"

#include <MCTypes.hpp>

#include <boost/shared_ptr.hpp>

#include <string>

class _IplImage;
class MCBinaryData;
class MEColor;
class MEImage;

typedef struct _IplImage IplImage;

namespace ME
{
typedef boost::shared_ptr<MEImage> ImageSPtr;

typedef enum
{
  RGBtoXYZCIED65 = 0,      
  XYZCIED65toRGB,          
  RGBtoHSV,                
  HSVtoRGB,                
  RGBtoHLS,                
  HLStoRGB,                
  RGBtoCIELab,             
  CIELabtoRGB,             
  RGBtoCIELuv,             
  CIELuvtoRGB,             
  RGBtoYUV,                
  RGBtoYIQ,                
  RGBtorgI                 
} ColorSpaceType;

typedef enum
{
  NormalLBP = 0,   
  SpecialLBP       
} LBPType;

typedef enum
{
  NormalSubtraction = 0,   
  AbsolutSubtraction       
} SubtractionType;

typedef enum
{
  AverageAddition = 0,   
  UnionAddition,         
  MaskAddition,          
} AdditionType;

typedef enum
{
  BlurSmoothing = 0,   
  GaussianSmoothing,   
  MedianSmoothing,     
} SmoothType;

typedef enum
{
  JpegFormat = 0,   
  PngFormat,        
  TiffFormat,       
  PpmFormat,        
} ImageFormatType;

extern const MC::StringList ImageFormatTypeStrs;
}

class MEImage
{
public:
  MEImage();

  MEImage(int width, int height, int layers);

  MEImage(const MEImage& other);

  ~MEImage();

#ifndef __AIBO_BUILD__

  bool LoadFromFile(const std::string& file_name);

  bool SaveToFile(const std::string& file_name) const;
#endif

  void Clear();

  MEImage* GetLayer(int layer_index) const;

  void SetLayer(const MEImage& new_layer, int layer_index);

  const IplImage* GetIplImage() const;

  void SetIplImage(const IplImage* other);

  void SetRawImageData(const MCBinaryData& image_data, int width, int height, int layer_count);

  MCBinaryData* ExportRawImageData() const;

  MCBinaryData* Compress(ME::ImageFormatType format = ME::JpegFormat) const;

  bool Decompress(const MCBinaryData& data);

  bool operator==(const MEImage& other);

  bool operator!=(const MEImage& other);

  MEImage& operator=(const MEImage& other);

  int GetWidth() const;

  int GetHeight() const;

  int GetRowWidth() const;

  int GetLayerCount() const;

  int GetImageDataSize() const;

  float GetRatio() const;

  void Realloc(int width, int height);

  void Realloc(int width, int height, int layer_count);

  void Resize(int width, int height);

  void ResizeScaleX(int width);

  void ResizeScaleY(int height);

  void MirrorHorizontal();

  void MirrorVertical();

  void Crop(int x1, int y1, int x2, int y2);

  void PasteImageInside(int x, int y, MEImage& other);

  void CopyImagePart(int x1, int y1, int x2, int y2, MEImage& other);

  void DrawLine(int x0, int y0, int x1, int y1, const MEColor& color);

  void DrawRectangle(int x0, int y0, int x1, int y1, const MEColor& color, bool fill = true);

  void DrawCircle(int x, int y, int radius, const MEColor& color, bool fill = true);

  void DrawText(int x, int y, const std::string& text, float scale, const MEColor& color);

  void Erode(int iteration_count);

  void Dilate(int iteration_count);

  void Smooth();

  void SmoothAdvanced(ME::SmoothType filter_mode, int matrix_size);

  void Canny(double threshold1 = 800, double threshold2 = 1100, int aperture_size = 5);

  void Laplace();

  void Quantize(int level_count);

  void Threshold(int threshold_limit);

  void AdaptiveThreshold();

  void Mask(MEImage& other);

  void ConvertToColorSpace(ME::ColorSpaceType transformation);

  void ConvertToGrayscale();

  void ConvertToRGB();

  void ConvertBGRToRGB();

  void LBP(ME::LBPType mode = ME::SpecialLBP);

  void Binarize(int threshold);

  void Subtract(const MEImage& other, ME::SubtractionType mode);

  void Multiple(MEImage& other);

  void Addition(MEImage& other, ME::AdditionType mode);

  void EliminateSinglePixels();

  float DifferenceAreas(MEImage& reference, int difference) const;

  int AverageDifference(MEImage& reference) const;

  void Minimum(MEImage& other);

  float AverageBrightnessLevel() const;

  void Rotate(int x, int y, float degree);

  bool Equal(const MEImage& other) const;

  bool Equal(const MEImage& other, int max_diff) const;

  unsigned char GrayscalePixel(int x, int y) const;

  unsigned int GetWhitePixelCount();

  void FillHoles();

  void Invert();

  void GammaCorrection(float gamma_level);

private:

  bool _Copy(const MEImage& other);

  void _Init(int width, int height, int layer_count);

  void ComputeColorSpace(ME::ColorSpaceType mode);

private:
  IplImage* Image;
};