MEImage.cpp

/*
 *  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.
 *
 */

#include "MEImage.hpp"

#include <MCBinaryData.hpp>
#include <MCDefs.hpp>
#include <MCLog.hpp>
#include <MCSampleStatistics.hpp>

#include <opencv/cv.h>
#ifndef __AIBO_BUILD__
#include <opencv/highgui.h>
#endif

#include <jpeglib_aiboplus.h>
#include <jerror_aiboplus.h>

#include <boost/foreach.hpp>
#include <boost/scoped_ptr.hpp>

#define RELEASE_IPLIMAGE(image_ptr) \
  { \
    cvReleaseImage(&image_ptr); \
    image_ptr = nullptr; \
  }

namespace
{
// RGB to YUV transform
const float RGBtoYUVMatrix[3][3] =
  {{ 0.299, 0.587, 0.114 },
   { -0.147, -0.289, 0.436 },
   { 0.615, -0.515, -0.100 }};

// RGB to YIQ transform
const float RGBtoYIQMatrix[3][3] =
  {{ 0.299, 0.587, 0.114 },
   { 0.596, -0.274, -0.322 },
   { 0.212, -0.523, 0.311 }};

void AlternateExit(j_common_ptr cinfo)
{
  /* Always display the message */
  (*cinfo->err->output_message)(cinfo);
  /* Let the memory manager delete any temp files before we die */
  jpeg_destroy(cinfo);
  throw 0;
}


void AlternatePrint(j_common_ptr cinfo)
{
  char buffer[JMSG_LENGTH_MAX];

  /* Create the message */
  (*cinfo->err->format_message) (cinfo, buffer);
  MC_WARNING("%s", buffer);
}


void AlternatePrintNoEcho(j_common_ptr)
{
  // Nothing to do
}


void InitJpegBuffer(jpeg_compress_struct*)
{
  // Nothing to do
}


boolean EmptyJpegBuffer(jpeg_compress_struct*)
{
  // Nothing to do
  return true;
}


void FinalizeJpegBuffer(jpeg_compress_struct*)
{
}


int EncodeJpeg(unsigned char* input_buffer, int row_width, int width, int height,
               unsigned char* output_buffer, int output_buffer_size,
               int jpeg_quality, bool grayscale)
{
  int JpegSize = 0;

  MC_TRY_BEGIN
    struct jpeg_compress_struct CompressInfo;
    struct jpeg_error_mgr JErr;
    struct jpeg_destination_mgr DestManager;

    DestManager.init_destination = InitJpegBuffer;
    DestManager.empty_output_buffer = EmptyJpegBuffer;
    DestManager.term_destination = FinalizeJpegBuffer;
    DestManager.next_output_byte = (JOCTET*)output_buffer;
    DestManager.free_in_buffer = output_buffer_size;

    CompressInfo.err = jpeg_std_error(&JErr);
    CompressInfo.err->error_exit = AlternateExit;
    CompressInfo.err->output_message = AlternatePrint;
    jpeg_create_compress(&CompressInfo);
    CompressInfo.dest = &DestManager;
    CompressInfo.image_width = width;
    CompressInfo.image_height = height;
    if (grayscale)
    {
      CompressInfo.input_components = 1;
      CompressInfo.in_color_space = JCS_GRAYSCALE;
    } else {
      CompressInfo.input_components = 3;
      CompressInfo.in_color_space = JCS_RGB;
    }

    jpeg_set_defaults(&CompressInfo);
    jpeg_set_quality(&CompressInfo, jpeg_quality, true);
    jpeg_start_compress(&CompressInfo, true);

    JSAMPROW RowPointer;

    while (CompressInfo.next_scanline < CompressInfo.image_height)
    {
      RowPointer = (JSAMPROW)&input_buffer[CompressInfo.next_scanline*row_width];
      jpeg_write_scanlines(&CompressInfo, &RowPointer, 1);
    }
    jpeg_finish_compress(&CompressInfo);
    // cppcheck-suppress unreadVariable
    JpegSize = (unsigned char*)CompressInfo.dest->next_output_byte-output_buffer;
    jpeg_destroy_compress(&CompressInfo);
  MC_CATCH_BEGIN
    return 0;
  MC_CATCH_END
  return JpegSize;
}


void InitSource(j_decompress_ptr)
{
  // Nothing to do
}


boolean FillInputBuffer(j_decompress_ptr)
{
  // Nothing to do
  return true;
}

void SkipInputData(j_decompress_ptr CompressInfo, long NumBytes)
{
  CompressInfo->src->next_input_byte += NumBytes;
  CompressInfo->src->bytes_in_buffer -= NumBytes;
}


void TermSource(j_decompress_ptr)
{
  // Nothing to do
}


bool DecodeJpeg(const MCBinaryData& input_buffer, MCBinaryData& output_buffer,
                unsigned int& width, unsigned int& height)
{
  MC_TRY_BEGIN
    struct jpeg_decompress_struct CompressInfo;
    struct jpeg_error_mgr JErr;
    struct jpeg_source_mgr SourceManager;

    CompressInfo.err = jpeg_std_error(&JErr);
    CompressInfo.err->error_exit = AlternateExit;
    CompressInfo.err->output_message = AlternatePrint;
    jpeg_create_decompress(&CompressInfo);

    SourceManager.next_input_byte = (unsigned char*)input_buffer.GetData();
    SourceManager.bytes_in_buffer = input_buffer.GetSize();
    SourceManager.init_source = InitSource;
    SourceManager.fill_input_buffer = FillInputBuffer;
    SourceManager.skip_input_data = SkipInputData;
    SourceManager.resync_to_restart = jpeg_resync_to_restart;
    SourceManager.term_source = TermSource;
    CompressInfo.src = &SourceManager;

    // No echo for error message when the JPEG header is checked
    CompressInfo.err->output_message = AlternatePrintNoEcho;
    if (jpeg_read_header(&CompressInfo, true) != JPEG_HEADER_OK)
    {
      jpeg_destroy_decompress(&CompressInfo);
      return false;
    }
    CompressInfo.err->output_message = AlternatePrint;
    CompressInfo.out_color_space = JCS_RGB;
    width = CompressInfo.image_width;
    height = CompressInfo.image_height;
    output_buffer.Allocate(width*height*3);
    jpeg_start_decompress(&CompressInfo);

    while (CompressInfo.output_scanline < height)
    {
      unsigned char* Row = (unsigned char*)output_buffer.GetData()+CompressInfo.output_scanline*width*3;

      if (jpeg_read_scanlines(&CompressInfo, &Row, 1) == 0)
      {
        jpeg_finish_decompress(&CompressInfo);
        jpeg_destroy_decompress(&CompressInfo);
        return false;
      }
      for (unsigned int i = 0; i < width; ++i)
      {
        char Swap = Row[0];

        Row[0] = Row[2];
        Row[2] = Swap;
        Row += 3;
      }
    }
    jpeg_finish_decompress(&CompressInfo);
    jpeg_destroy_decompress(&CompressInfo);
  MC_CATCH_BEGIN
    return false;
  MC_CATCH_END
  return true;
}

const char* ImageFormatTypeStrsInit[] = {"jpeg", "png", "tiff", "ppm"};
}

const MC::StringList ME::ImageFormatTypeStrs(boost::begin(ImageFormatTypeStrsInit),
                                             boost::end(ImageFormatTypeStrsInit));

MEImage::MEImage() : Image(nullptr)
{
  _Init(16, 16, 1);
}

MEImage::MEImage(int width, int height, int layers) : Image(nullptr)
{
  _Init(width, height, layers);
}


MEImage::MEImage(const MEImage& other) : Image(nullptr)
{
  _Copy(other);
}


MEImage::~MEImage()
{
  if (Image)
  {
    cvReleaseImage(&Image);
    Image = nullptr;
  }
}


#ifndef __AIBO_BUILD__
bool MEImage::LoadFromFile(const std::string& file_name)
{
  if (!MCFileExists(file_name))
  {
    MC_WARNING("File does not exist: %s", file_name.c_str());
    return false;
  }
  IplImage* TempImg = cvLoadImage(file_name.c_str(), -1);

  if (!TempImg)
    return false;

  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
  // Correct the origin of the image
  if (Image && Image->origin == 1)
  {
    MirrorVertical();
    Image->origin = 0;
  }
  return true;
}


bool MEImage::SaveToFile(const std::string& file_name) const
{
  return cvSaveImage(file_name.c_str(), Image) > 0;
}
#endif


void MEImage::Clear()
{
  cvSetZero(Image);
}


MEImage* MEImage::GetLayer(int layer_index) const
{
  const int LayerIndex = MCBound(0, layer_index, Image->nChannels-1);
  MEImage* NewImage = new MEImage(Image->width, Image->height, 1);

  cvSetImageCOI(Image, LayerIndex);
  cvCopy(Image, NewImage->Image, nullptr);
  cvSetImageCOI(Image, 0);
  return NewImage;
}


void MEImage::SetLayer(const MEImage& layer, int layer_index)
{
  const int LayerIndex = MCBound(0, layer_index, Image->nChannels-1);

  if (layer.GetWidth() != Image->width || layer.GetHeight() != Image->height)
  {
    MC_WARNING("Wrong layer dimensions (%dx%d <> %dx%d)",
               layer.GetWidth(), layer.GetHeight(), Image->width, Image->height);
    return;
  }
  if (layer.GetLayerCount() != 1)
  {
    MC_WARNING("More layers in the layer image (1 != %d)", layer.GetLayerCount());
    return;
  }
  cvSetImageCOI(Image, LayerIndex);
  cvCopy(layer.GetIplImage(), Image, nullptr);
  cvSetImageCOI(Image, 0);
}


const IplImage* MEImage::GetIplImage() const
{
  return Image;
}


void MEImage::SetIplImage(const IplImage* other)
{
  if (!other)
    return;

  if (Image)
  {
    RELEASE_IPLIMAGE(Image);
  }
  Image = cvCloneImage(other);
  // Correct the origin of the image
  if (Image->origin == 1)
  {
    MirrorVertical();
    Image->origin = 0;
  }
}


void MEImage::SetRawImageData(const MCBinaryData& image_data, int width, int height, int layer_count)
{
  if (width*height*layer_count != image_data.GetSize())
  {
    MC_WARNING("No enough image data to be copied (%d != %d)",
               width*height*layer_count, image_data.GetSize());
    return;
  }
  _Init(width, height, layer_count);

  for (int y = 0; y < height; ++y)
  {
    int Start = GetRowWidth()*y;
    int Start2 = width*layer_count*y;

    memcpy(&Image->imageData[Start], &image_data.GetData()[Start2], width*layer_count);
  }
}


MCBinaryData* MEImage::ExportRawImageData() const
{
  MCBinaryData* RawData = new MCBinaryData(GetWidth()*GetHeight()*GetLayerCount());

  for (int y = 0; y < GetHeight(); ++y)
  {
    int Start = GetRowWidth()*y;
    int Start2 = GetWidth()*GetLayerCount()*y;

    memcpy(&RawData->GetData()[Start2], &Image->imageData[Start], GetWidth()*GetLayerCount());
  }
  return RawData;
}


MCBinaryData* MEImage::Compress(ME::ImageFormatType format) const
{
  // Note: The jpeg format must be handled differently because the OpenCV's
  // highgui module crashes when the colliding symbol of libjpeg library routes
  // the encoding call to the internal jpegturbo library.
  if (format == ME::JpegFormat)
  {
    MC::BinaryDataSPtr TempBuffer(new MCBinaryData(GetImageDataSize()));
    MCBinaryData* JpegData = nullptr;
    int FinalSize = 0;

    FinalSize = EncodeJpeg((unsigned char*)Image->imageData, Image->widthStep, GetWidth(), GetHeight(),
                           TempBuffer->GetData(), TempBuffer->GetSize(), 80, GetLayerCount() == 1);
    JpegData = new MCBinaryData(FinalSize);
    memcpy(JpegData->GetData(), TempBuffer->GetData(), FinalSize);
    return JpegData;
  }
#ifndef __AIBO_BUILD__
  MCBinaryData* CompressedData = nullptr;
  std::string FormatStr;
  std::vector<uchar> Buffer;

  if (format == ME::PngFormat)
    FormatStr = ".png";
  if (format == ME::TiffFormat)
    FormatStr = ".tiff";
  if (format == ME::PpmFormat)
    FormatStr = ".ppm";
  cv::imencode(FormatStr, cv::Mat(Image, false), Buffer);
  CompressedData = new MCBinaryData((int)Buffer.size());
  memcpy(CompressedData->GetData(), Buffer.data(), (int)Buffer.size());
  return CompressedData;
#else
  return nullptr;
#endif
}


bool MEImage::Decompress(const MCBinaryData& data)
{
  // Note: The jpeg format must be handled differently because the OpenCV's
  // highgui module crashes when the colliding symbol of libjpeg library routes
  // the decoding call to the internal jpegturbo library.
  MC::BinaryDataSPtr DecodedData(new MCBinaryData);
  unsigned int Width;
  unsigned int Height;

  if (DecodeJpeg(data, *DecodedData, Width, Height))
  {
    SetRawImageData(*DecodedData, Width, Height, 3);
    return true;
  }
#ifndef __AIBO_BUILD__
  cv::Mat Result;
  IplImage TempImg;
  std::vector<char> TempBuffer(data.GetSize());

  memcpy(TempBuffer.data(), data.GetData(), TempBuffer.size());
  Result = cv::imdecode(TempBuffer, CV_LOAD_IMAGE_UNCHANGED);
  if (Result.data == nullptr)
    return false;

  RELEASE_IPLIMAGE(Image);
  TempImg = (IplImage)Result;
  Image = cvCloneImage(&TempImg);
  return true;
#else
  return false;
#endif
}


bool MEImage::operator==(const MEImage& other)
{
  return Equal(other);
}


bool MEImage::operator!=(const MEImage& other)
{
  return !operator==(other);
}


MEImage& MEImage::operator=(const MEImage& other)
{
  if (&other == this)
    return *this;

  _Copy(other);
  return *this;
}


int MEImage::GetWidth() const
{
  return Image ? Image->width : 0;
}


int MEImage::GetRowWidth() const
{
  return Image ? Image->widthStep : 0;
}


int MEImage::GetHeight() const
{
  return Image ? Image->height : 0;
}


int MEImage::GetLayerCount() const
{
  return Image ? Image->nChannels : 0;
}


int MEImage::GetImageDataSize() const
{
  return Image ? GetWidth()*GetHeight()*GetLayerCount() : 0;
}


float MEImage::GetRatio() const
{
  return Image ? (float)Image->height / Image->width : 0;
}


void MEImage::Realloc(int width, int height)
{
  Realloc(width, height, Image->nChannels);
}


void MEImage::Realloc(int width, int height, int layer_count)
{
  _Init(width, height, layer_count);
}


void MEImage::Resize(int width, int height)
{
  if (GetWidth() == width && GetHeight() == height)
    return;

  const int Width = MCMax(width, 1);
  const int Height = MCMax(height, 1);
  IplImage* TempImg = cvCreateImage(cvSize(Width, Height), 8, Image->nChannels);

  cvResize(Image, TempImg, CV_INTER_NN);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::ResizeScaleX(int width)
{
  if (GetWidth() == width)
    return;

  Resize(width, (int)((float)width*GetRatio()));
}


void MEImage::ResizeScaleY(int height)
{
  if (GetHeight() == height)
    return;

  Resize((int)((float)height*1/GetRatio()), height);
}


void MEImage::MirrorHorizontal()
{
  cvFlip(Image, nullptr, 1);
}


void MEImage::MirrorVertical()
{
  cvFlip(Image, nullptr, 0);
}


void MEImage::Crop(int x1, int y1, int x2, int y2)
{
  const int X1 = MCBound(0, x1, GetWidth()-1);
  const int Y1 = MCBound(0, y1, GetHeight()-1);
  const int X2 = MCBound(0, x2, GetWidth()-1);
  const int Y2 = MCBound(0, y2, GetHeight()-1);

  if (X2-X1 <= 0 || Y2-Y1 <= 0)
    return;

  IplImage* TempImg = cvCreateImage(cvSize(X2-X1, Y2-Y1), 8, Image->nChannels);

  cvSetImageROI(Image, cvRect(X1, Y1, X2-X1, Y2-Y1));
  cvCopy(Image, TempImg);
  cvResetImageROI(Image);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::PasteImageInside(int x, int y, MEImage& other)
{
  const int X = MCBound(0, x, GetWidth()-1);
  const int Y = MCBound(0, y, GetHeight()-1);
  const int PasteWidth = (X+other.GetWidth() > GetWidth() ? GetWidth()-X : other.GetWidth());
  const int PasteHeight = (Y+other.GetHeight() > GetHeight() ? GetHeight()-Y : other.GetHeight());

  if (Image->nChannels != other.GetLayerCount())
  {
    if (other.GetLayerCount() == 1 && Image->nChannels == 3)
    {
      other.ConvertToRGB();
    }
    if (Image->nChannels == 1 && other.GetLayerCount() == 3)
    {
      other.ConvertToGrayscale();
    }
  }
  cvSetImageROI(Image, cvRect(X, Y, PasteWidth, PasteHeight));
  cvCopy(other.GetIplImage(), Image);
  cvResetImageROI(Image);
}


void MEImage::CopyImagePart(int x1, int y1, int x2, int y2, MEImage& other)
{
  const int X1 = MCBound(0, x1, GetWidth()-1);
  const int Y1 = MCBound(0, y1, GetHeight()-1);
  const int X2 = MCBound(0, x2, GetWidth()-1);
  const int Y2 = MCBound(0, y2, GetHeight()-1);

  if (X2-X1 <= 0 || Y2-Y1 <= 0)
    return;

  IplImage* TempImg = cvCreateImage(cvSize(X2-X1, Y2-Y1), 8, Image->nChannels);

  cvSetImageROI(Image, cvRect(X1, Y1, X2-X1, Y2-Y1));
  cvCopy(Image, TempImg);
  cvResetImageROI(Image);
  RELEASE_IPLIMAGE(other.Image);
  other.Image = TempImg;
}


void MEImage::DrawLine(int x0, int y0, int x1, int y1, const MEColor& color)
{
  const int X0 = MCBound(0, x0, GetWidth()-1);
  const int Y0 = MCBound(0, y0, GetHeight()-1);
  const int X1 = MCBound(0, x1, GetWidth()-1);
  const int Y1 = MCBound(0, y1, GetHeight()-1);
  CvPoint Point1, Point2;

  Point1.x = X0;
  Point1.y = Y0;
  Point2.x = X1;
  Point2.y = Y1;
  cvLine(Image, Point1, Point2, CV_RGB(color.Blue, color.Green, color.Red), 1, 8);
}


void MEImage::DrawRectangle(int x0, int y0, int x1, int y1, const MEColor& color, bool fill)
{
  const int X0 = MCBound(0, x0, GetWidth()-1);
  const int Y0 = MCBound(0, y0, GetHeight()-1);
  const int X1 = MCBound(0, x1, GetWidth()-1);
  const int Y1 = MCBound(0, y1, GetHeight()-1);
  CvPoint Point1, Point2;

  Point1.x = X0;
  Point1.y = Y0;
  Point2.x = X1;
  Point2.y = Y1;
  cvRectangle(Image, Point1, Point2, CV_RGB(color.Blue, color.Green, color.Red),
              (fill ? -1 : 1), 8);
}


void MEImage::DrawCircle(int x, int y, int radius, const MEColor& color, bool fill)
{
  const int X = MCBound(0, x, GetWidth()-1);
  const int Y = MCBound(0, y, GetHeight()-1);
  const int Radius = MCMax(radius, 1);
  CvPoint Point;

  Point.x = X;
  Point.y = Y;
  cvCircle(Image, Point, Radius, CV_RGB(color.Blue, color.Green, color.Red), (fill ? -1 : 1));
}


void MEImage::DrawText(int x, int y, const std::string& text, float scale, const MEColor& color)
{
  const int X = MCBound(0, x, GetWidth()-1);
  const int Y = MCBound(0, y, GetHeight()-1);
  cv::Mat TempImage(Image, false);

  cv::putText(TempImage, text.c_str(), cv::Point(X, Y), cv::FONT_HERSHEY_TRIPLEX,
              (double)scale, CV_RGB(color.Blue, color.Green, color.Red));
}


void MEImage::Erode(int iteration_count)
{
  if (iteration_count < 1)
    return;

  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);

  cvErode(Image, TempImg, nullptr, iteration_count);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::Dilate(int iteration_count)
{
  if (iteration_count < 1)
    return;

  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);

  cvDilate(Image, TempImg, nullptr, iteration_count);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::Smooth()
{
  SmoothAdvanced(ME::MedianSmoothing, 3);
}


void MEImage::SmoothAdvanced(ME::SmoothType filter_mode, int matrix_size)
{
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);
  int SmoothType = CV_MEDIAN;

  if (filter_mode == ME::BlurSmoothing)
    SmoothType = CV_BLUR;
  if (filter_mode == ME::MedianSmoothing)
    SmoothType = CV_MEDIAN;
  if (filter_mode == ME::GaussianSmoothing)
    SmoothType = CV_GAUSSIAN;

  cvSmooth(Image, TempImg, SmoothType, matrix_size, matrix_size, 0);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::Canny(double threshold1, double threshold2, int aperture_size)
{
  if (Image->nChannels > 1)
  {
    ConvertToGrayscale();
  }
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);

  cvCanny(Image, TempImg, threshold1, threshold2, aperture_size);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::Laplace()
{
  if (Image->nChannels != 1)
  {
    ConvertToGrayscale();
  }
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), IPL_DEPTH_16S, 1);

  cvLaplace(Image, TempImg, 3);
  cvConvertScale(TempImg, Image, 1, 0);
  RELEASE_IPLIMAGE(TempImg);
}


void MEImage::Quantize(int level_count)
{
  const int LevelCount = MCBound(1, level_count, 255);
  unsigned char* ImageData = (unsigned char*)Image->imageData;

  for (int i = Image->widthStep*Image->height-1; i >= 0; --i)
  {
    ImageData[i] = ImageData[i] / (256 / LevelCount)*(256 / LevelCount);
  }
}


void MEImage::Threshold(int threshold_limit)
{
  const int ThresholdLimit = MCBound(1, threshold_limit, 255);
  unsigned char* ImageData = (unsigned char*)Image->imageData;

  for (int i = Image->widthStep*Image->height-1; i >= 0; --i)
  {
    if (ImageData[i] < ThresholdLimit)
      ImageData[i] = 0;
  }
}


void MEImage::AdaptiveThreshold()
{
  if (Image->nChannels != 1)
  {
    ConvertToGrayscale();
  }
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);

  cvAdaptiveThreshold(Image, TempImg, 25,
                      CV_ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, 7, -7);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::Mask(MEImage& other)
{
  if (other.GetWidth() != Image->width || other.GetHeight() != Image->height)
  {
    MC_WARNING("Image properties are different for masking");
    return;
  }
  if (other.GetLayerCount() != 3 && Image->nChannels == 3)
  {
    other.ConvertToRGB();
  }
  if (other.GetLayerCount() != 1 && Image->nChannels == 1)
  {
    other.ConvertToGrayscale();
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  unsigned char* MaskImageData = (unsigned char*)other.Image->imageData;

  for (int i = Image->widthStep*Image->height-1; i >= 0; --i)
  {
    if (MaskImageData[i] == 0)
      ImageData[i] = 0;
  }
}


void MEImage::ConvertToColorSpace(ME::ColorSpaceType mode)
{
  if (Image->nChannels == 1)
    return;

  if (mode == ME::RGBtoYUV)
  {
    ComputeColorSpace(ME::RGBtoYUV);
    return;
  } else
  if (mode == ME::RGBtoYIQ)
  {
    ComputeColorSpace(ME::RGBtoYIQ);
    return;
  } else
  if (mode == ME::RGBtorgI)
  {
    unsigned char* ImageData = (unsigned char*)Image->imageData;
    int WidthStep = Image->widthStep;
    int RowStart = 0;

    for (int y = Image->height-1; y >= 0; --y)
    {
      for (int x = (Image->width-1)*3; x >= 0; x -= 3)
      {
        int r = 0;
        int g = 0;
        int I = 0;

        I = (int)ImageData[RowStart+x]+(int)ImageData[RowStart+x+1]+(int)ImageData[RowStart+x+2];
        r = (int)((float)ImageData[RowStart+x] / I*255);
        g = (int)((float)ImageData[RowStart+x+1] / I*255);
        ImageData[RowStart+x] = (unsigned char)r;
        ImageData[RowStart+x+1] = (unsigned char)g;
        ImageData[RowStart+x+2] = (unsigned char)(I / 3);
      }
      RowStart += WidthStep;
    }
    return;
  }
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);
  int Conversion = CV_RGB2XYZ;

  if (mode == ME::RGBtoXYZCIED65)
    Conversion = CV_RGB2XYZ;
  if (mode == ME::XYZCIED65toRGB)
    Conversion = CV_XYZ2RGB;
  if (mode == ME::RGBtoHSV)
    Conversion = CV_RGB2HSV;
  if (mode == ME::HSVtoRGB)
    Conversion = CV_HSV2RGB;
  if (mode == ME::RGBtoHLS)
    Conversion = CV_RGB2HLS;
  if (mode == ME::HLStoRGB)
    Conversion = CV_HLS2RGB;
  if (mode == ME::RGBtoCIELab)
    Conversion = CV_RGB2Lab;
  if (mode == ME::CIELabtoRGB)
    Conversion = CV_Lab2RGB;
  if (mode == ME::RGBtoCIELuv)
    Conversion = CV_RGB2Luv;
  if (mode == ME::CIELuvtoRGB)
    Conversion = CV_Luv2RGB;

  cvCvtColor(Image, TempImg, Conversion);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::ConvertToGrayscale()
{
  if (Image->nChannels == 1)
    return;

  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, 1);

  cvCvtColor(Image, TempImg, CV_RGB2GRAY);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::ConvertToRGB()
{
  if (Image->nChannels != 1)
    return;

  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, 3);

  cvCvtColor(Image, TempImg, CV_GRAY2RGB);
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::ConvertBGRToRGB()
{
  if (Image->nChannels != 3)
    return;

  cvCvtColor(Image, Image, CV_RGB2BGR);
}


void MEImage::LBP(ME::LBPType mode)
{
  if (Image->nChannels > 1)
  {
    ConvertToGrayscale();
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, 1);
  unsigned char* TempImgData = (unsigned char*)TempImg->imageData;
  int WidthStep = Image->widthStep;
  int WidthStep_2 = Image->widthStep*2;

  cvSetZero(TempImg);
  if (mode == ME::NormalLBP)
  {
    for (int i = Image->widthStep*(Image->height-2)-1; i >= Image->widthStep+1; --i)
    {
      TempImgData[i] =
        (ImageData[i] <= ImageData[i-Image->widthStep-1])+
        ((ImageData[i] <= ImageData[i-Image->widthStep])*2)+
        ((ImageData[i] <= ImageData[i-Image->widthStep+1])*4)+
        ((ImageData[i] <= ImageData[i-1])*8)+
        ((ImageData[i] <= ImageData[i+1])*16)+
        ((ImageData[i] <= ImageData[i+Image->widthStep-1])*32)+
        ((ImageData[i] <= ImageData[i+Image->widthStep])*64)+
        ((ImageData[i] <= ImageData[i+Image->widthStep+1])*128);
    }
  }
  if (mode == ME::SpecialLBP)
  {
    for (int i = Image->widthStep*(Image->height - 3) - 2; i >= Image->widthStep*2 + 2; --i)
    {
      int CenterPixel = (ImageData[i + 1] + ImageData[i - 1] +
                         ImageData[i - WidthStep] + ImageData[i + WidthStep])/4;
      TempImgData[i] = ((CenterPixel <= (ImageData[i - (WidthStep_2) - 2] +
                                         ImageData[i - (WidthStep_2) - 1] +
                                         ImageData[i - WidthStep - 2] +
                                         ImageData[i - WidthStep - 1])/4)) +
                       ((CenterPixel <= (ImageData[i - WidthStep] +
                                         ImageData[i - (WidthStep_2)])/2)*2) +
                       ((CenterPixel <= ((ImageData[i - (WidthStep_2) + 2] +
                                          ImageData[i - (WidthStep_2) + 1] +
                                          ImageData[i - WidthStep + 2] +
                                          ImageData[i - WidthStep + 1])/4))*4) +
                       ((CenterPixel <= (ImageData[i - 1] +
                                         ImageData[i - 2])/2)*8) +
                       ((CenterPixel <= (ImageData[i + 1] +
                                         ImageData[i + 2])/2)*16) +
                       ((CenterPixel <= ((ImageData[i + (WidthStep_2) - 2] +
                                          ImageData[i + (WidthStep_2) - 1] +
                                          ImageData[i + WidthStep - 2] +
                                          ImageData[i + WidthStep - 1])/4))*32) +
                       ((CenterPixel <= (ImageData[i + WidthStep] +
                                         ImageData[i - WidthStep_2])/2)*64) +
                       ((CenterPixel <= ((ImageData[i + (WidthStep_2) + 2] +
                                          ImageData[i + (WidthStep_2) + 1] +
                                          ImageData[i + WidthStep + 2] +
                                          ImageData[i + WidthStep + 1])/4))*128);
    }
  }
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


void MEImage::Binarize(int threshold)
{
  unsigned char* ImageData = (unsigned char*)Image->imageData;

  for (int i = Image->height*Image->widthStep-1; i >= 0; --i)
  {
    if (ImageData[i] >= threshold)
    {
      ImageData[i] = 255;
    } else {
      ImageData[i] = 0;
    }
  }
}


void MEImage::Subtract(const MEImage& other, ME::SubtractionType mode)
{
  if (other.GetWidth() != Image->width || other.GetHeight() != Image->height ||
      other.GetLayerCount() != Image->nChannels)
  {
    MC_WARNING("Image properties are different for subtraction.");
    return;
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  const unsigned char* DstData = (unsigned char*)other.Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;

  if (mode == ME::NormalSubtraction)
  {
    for (int y = Image->height-1; y >= 0; --y)
    {
      for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
      {
        if (ImageData[RowStart+x]-DstData[RowStart+x] < 0)
          ImageData[RowStart+x] = 0;
        else
          ImageData[RowStart+x] = ImageData[RowStart+x]-DstData[RowStart+x];
      }
      RowStart += WidthStep;
    }
  }
  if (mode == ME::AbsolutSubtraction)
  {
    for (int y = Image->height-1; y >= 0; --y)
    {
      for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
      {
        if (ImageData[RowStart+x]-DstData[RowStart+x] < 0)
          ImageData[RowStart+x] = -ImageData[RowStart+x]+DstData[RowStart+x];
        else
          ImageData[RowStart+x] = ImageData[RowStart+x]-DstData[RowStart+x];
      }
      RowStart += WidthStep;
    }
  }
}


void MEImage::Multiple(MEImage& other)
{
  if (other.GetWidth() != Image->width || other.GetHeight() != Image->height ||
      other.GetLayerCount() != Image->nChannels)
  {
    MC_WARNING("Image properties are different for multiplication.");
    return;
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  unsigned char* DstData = (unsigned char*)other.Image->imageData;

  for (int i = Image->height*Image->widthStep-1; i >= 0; --i)
  {
    if (ImageData[i] >= 128 && DstData[i] >= 128)
    {
      float Result = (float)ImageData[i] / 128*DstData[i] / 128;

      if (Result >= 1)
      {
        ImageData[i] = 255;
      } else {
        ImageData[i] = 0;
      }
    } else {
      ImageData[i] = 0;
    }
  }
}


void MEImage::Addition(MEImage& other, ME::AdditionType mode)
{
  if (other.GetWidth() != Image->width || other.GetHeight() != Image->height ||
      other.GetLayerCount() != Image->nChannels)
  {
    MC_WARNING("Image properties are different for addition.");
    return;
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  unsigned char* SrcData = (unsigned char*)other.Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;

  if (mode == ME::AverageAddition)
  {
    for (int i = Image->height*Image->widthStep-1; i >= 0; --i)
    {
      ImageData[i] = (ImageData[i]+SrcData[i]) / 2;
    }
  } else
  if (mode == ME::UnionAddition)
  {
    for (int i = Image->height*Image->widthStep-1; i >= 0; --i)
    {
      if (SrcData[i] > ImageData[i])
        ImageData[i] = SrcData[i];
    }
  } else
  if (mode == ME::MaskAddition && other.GetLayerCount() == 1)
  {
    for (int y = Image->height-1; y >= 0; --y)
    {
      for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
      {
        if (SrcData[RowStart+x] > 0)
          ImageData[RowStart+x] = SrcData[RowStart+x];
      }
      RowStart += WidthStep;
    }
  } else
  if (mode == ME::MaskAddition && other.GetLayerCount() == 3)
  {
    for (int y = Image->height-1; y >= 0; --y)
    {
      for (int x = Image->width*Image->nChannels-4; x >= 0; x -= 3)
      {
        if (SrcData[RowStart+x] > 0 || SrcData[RowStart+x+1] > 0 || SrcData[RowStart+x+2] > 0)
        {
          ImageData[RowStart+x] = SrcData[RowStart+x];
          ImageData[RowStart+x+1] = SrcData[RowStart+x+1];
          ImageData[RowStart+x+2] = SrcData[RowStart+x+2];
        }
      }
      RowStart += WidthStep;
    }
  }
}


void MEImage::EliminateSinglePixels()
{
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  unsigned char* DstData = (unsigned char*)TempImg->imageData;
  int sum = 0;
  int xy = 0;
  int ywidth = Image->widthStep;

  for (int y = Image->height-1; y >= 0; --y)
    for (int x = Image->width-1; x >= 0; --x)
    {
      xy = y*ywidth+x*Image->nChannels;

      for (int l = Image->nChannels-1; l >= 0; --l)
      {
        if ((ImageData[xy+l] > 0) && (x > 0) && (y > 0) && (x < Image->width-1) && (y < Image->height-1))
        {
          sum = (ImageData[xy-ywidth-Image->nChannels+l] > 0)+
                (ImageData[xy-ywidth+l] > 0)+
                (ImageData[xy-ywidth+Image->nChannels+l] > 0)+
                (ImageData[xy-Image->nChannels+l] > 0)+
                (ImageData[xy+Image->nChannels+l] > 0)+
                (ImageData[xy+ywidth-Image->nChannels+l] > 0)+
                (ImageData[xy+ywidth+l] > 0)+
                (ImageData[xy+ywidth+Image->nChannels+l] > 0);

          if (sum > 3)
          {
            DstData[xy+l] = 255;
          } else {
            DstData[xy+l] = 0;
          }
        } else {
          DstData[xy+l] = 0;
        }
      }
    }
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


float MEImage::DifferenceAreas(MEImage& reference, int difference) const
{
  if (reference.GetWidth() != GetWidth() || reference.GetHeight() != GetHeight() ||
      reference.GetLayerCount() != GetLayerCount())
  {
    MC_WARNING("Image dimensions or channels are different for area statistics.");
    return -1.0;
  }
  int Difference = MCBound(0, difference, 100);
  int Pixels = 0;
  unsigned char* OrigImgData = (unsigned char*)Image->imageData;
  unsigned char* RefImgData = (unsigned char*)reference.Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;

  for (int y = Image->height-1; y >= 0; --y)
  {
    for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
    {
      if (abs(OrigImgData[RowStart+x]-RefImgData[RowStart+x]) > Difference)
        Pixels++;
    }
    RowStart += WidthStep;
  }
  return (float)Pixels / ((float)Image->height*Image->widthStep*100);
}


int MEImage::AverageDifference(MEImage& reference) const
{
  if (reference.GetWidth() != GetWidth() || reference.GetHeight() != GetHeight() ||
      reference.GetLayerCount() != GetLayerCount())
  {
    MC_WARNING("Image dimensions or channels are different.");
    return -1;
  }
  if (Image->height == 0 || Image->widthStep == 0)
    return 0;

  int Difference = 0;
  unsigned char* OrigImgData = (unsigned char*)Image->imageData;
  unsigned char* RefImgData = (unsigned char*)reference.Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;

  for (int y = Image->height-1; y >= 0; --y)
  {
    for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
    {
      Difference += MCAbs(OrigImgData[RowStart+x]-RefImgData[RowStart+x]);
    }
    RowStart += WidthStep;
  }
  Difference = Difference / (Image->height*Image->widthStep);
  return Difference;
}


void MEImage::Minimum(MEImage& other)
{
  if (other.GetWidth() != Image->width || other.GetHeight() != Image->height ||
      other.GetLayerCount() != Image->nChannels)
  {
    MC_WARNING("Image properties are different for minimum.");
    return;
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  unsigned char* SecData = (unsigned char*)other.Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;

  for (int y = Image->height-1; y >= 0; --y)
  {
    for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
    {
      ImageData[RowStart+x] = (ImageData[RowStart+x] > SecData[RowStart+x] ?
                               SecData[RowStart+x] : ImageData[RowStart+x]);
    }
    RowStart += WidthStep;
  }
}


float MEImage::AverageBrightnessLevel() const
{
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;
  int BrightnessLevel = 0;

  for (int y = Image->height-1; y >= 0; --y)
  {
    for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
    {
      BrightnessLevel += (int)ImageData[RowStart+x];
    }
    RowStart += WidthStep;
  }
  return (float)BrightnessLevel / ((float)GetWidth()*GetHeight()*GetLayerCount());
}


void MEImage::Rotate(int x, int y, float degree)
{
  const int X = MCBound(0, x, GetWidth()-1);
  const int Y = MCBound(0, y, GetHeight()-1);

  cv::Mat Matrix = cv::getRotationMatrix2D(cv::Point(X, Y), degree, 1.0);
  IplImage* TempImg = cvCreateImage(cvSize(GetWidth(), GetHeight()), 8, Image->nChannels);

  cv::warpAffine(cv::Mat(Image, false), cv::Mat(TempImg, false), Matrix, cv::Size(GetWidth(), GetHeight()));
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}


bool MEImage::Equal(const MEImage& other) const
{
  return Equal(other, 1);
}


bool MEImage::Equal(const MEImage& other, int max_diff) const
{
  if (&other == this)
    return true;

  if (other.GetWidth() != Image->width || other.GetHeight() != Image->height ||
      other.GetLayerCount() != Image->nChannels)
  {
    return false;
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  unsigned char* RefData = (unsigned char*)other.Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;

  for (int y = Image->height-1; y >= 0; --y)
  {
    for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
    {
      if (MCAbs(ImageData[RowStart+x]-RefData[RowStart+x]) >= max_diff)
        return false;
    }
    RowStart += WidthStep;
  }
  return true;
}


unsigned char MEImage::GrayscalePixel(int x, int y) const
{
  const int X = MCBound(0, x, GetWidth()-1);
  const int Y = MCBound(0, y, GetHeight()-1);

  int Sum = 0;
  unsigned char* ImageData = (unsigned char*)Image->imageData;

  for (int l = 0; l < Image->nChannels; l++)
  {
    Sum = Sum+(int)ImageData[Y*Image->width*Image->nChannels+X*Image->nChannels+l];
  }
  return (unsigned char)((float)Sum / Image->nChannels);
}


unsigned int MEImage::GetWhitePixelCount()
{
  return cvSumPixels(Image);
}


void MEImage::FillHoles()
{
  if (GetLayerCount() != 1)
  {
    MC_WARNING("Holes can be filled only in binary images.");
    return;
  }
  // Taken from http://stackoverflow.com/a/16015873
  CvScalar White = CV_RGB(255, 255, 255);
  IplImage* Dst = cvCreateImage(cvGetSize(Image), 8, 1);
  CvMemStorage* Storage = cvCreateMemStorage(0);
  CvSeq* Contour = 0;

  cvFindContours(Image, Storage, &Contour, sizeof(CvContour),
                 CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
  cvZero(Dst);

  for (; Contour != 0; Contour = Contour->h_next)
  {
    cvDrawContours(Dst, Contour, White, White, 0, CV_FILLED);
  }
  cvInRangeS(Dst, White, White, Image);
  cvFree(&Dst);
}


void MEImage::Invert()
{
  cvNot(Image, Image);
}


void MEImage::GammaCorrection(float gamma_level)
{
  unsigned char Table[256];

  for (unsigned int i = 0; i < 256; i++)
  {
    Table[i] = (unsigned char)MCBound(0, (int)(pow((float)i / 255, gamma_level)*255), 255);
  }
  unsigned char* ImageData = (unsigned char*)Image->imageData;
  int WidthStep = Image->widthStep;
  int RowStart = 0;

  for (int y = Image->height-1; y >= 0; --y)
  {
    for (int x = Image->width*Image->nChannels-1; x >= 0; --x)
    {
      ImageData[RowStart+x] = Table[ImageData[RowStart+x]];
    }
    RowStart += WidthStep;
  }
}


bool MEImage::_Copy(const MEImage& other)
{
  if (&other == this)
    return true;

  if (Image)
  {
    RELEASE_IPLIMAGE(Image);
  }
  Image = cvCloneImage(other.GetIplImage());
  return true;
}


void MEImage::_Init(int width, int height, int layer_count)
{
  if (Image)
    RELEASE_IPLIMAGE(Image);

  if (width < 1 || height < 1 || (layer_count != 1 && layer_count != 3))
  {
    Image = cvCreateImage(cvSize(16, 16), 8, 1);
    return;
  }
  Image = cvCreateImage(cvSize(width, height), 8, layer_count);
}


void MEImage::ComputeColorSpace(ME::ColorSpaceType mode)
{
  if (Image->nChannels != 3)
  {
    MC_WARNING("Image must have three color channels (%d != 3)", Image->nChannels);
    return;
  }
  if (mode != ME::RGBtoYUV && mode != ME::RGBtoYIQ)
  {
    MC_WARNING("Color space conversion is not supported (%d)", (int)mode);
    return;
  }
  float TransformMatrix[3][3];
  IplImage* TempImg = cvCreateImage(cvSize(Image->width, Image->height), 8, Image->nChannels);

  for (int i = 0; i < 3; i++)
    for (int i1 = 0; i1 < 3; i1++)
    {
      if (mode == ME::RGBtoYUV)
        TransformMatrix[i][i1] = RGBtoYUVMatrix[i][i1];
      if (mode == ME::RGBtoYIQ)
        TransformMatrix[i][i1] = RGBtoYIQMatrix[i][i1];
    }
  float xmin = 0.0;
  float xmax = 0.0;
  float ymin = 0.0;
  float ymax = 0.0;
  float zmin = 0.0;
  float zmax = 0.0;

  if (mode == ME::RGBtoYUV)
  {
    xmin = 0.0;
    xmax = 255.0;
    ymin = -111.18;
    ymax = 111.18;
    zmin = -156.825;
    zmax = 156.825;
  }
  if (mode == ME::RGBtoYIQ)
  {
    xmin = 0.0;
    xmax = 255.0;
    ymin = -151.98;
    ymax = 151.98;
    zmin = -133.365;
    zmax = 133.365;
  }
  unsigned char* SrcData = (unsigned char*)Image->imageData;
  unsigned char* DstData = (unsigned char*)TempImg->imageData;

  for (int i = Image->widthStep*Image->height-1; i >= 0; i-=3)
  {
    float x = (float)SrcData[i]*TransformMatrix[0][0]+
              (float)SrcData[i+1]*TransformMatrix[0][1]+
              (float)SrcData[i+2]*TransformMatrix[0][2];
    float y = (float)SrcData[i]*TransformMatrix[1][0]+
              (float)SrcData[i+1]*TransformMatrix[1][1]+
              (float)SrcData[i+2]*TransformMatrix[1][2];
    float z = (float)SrcData[i]*TransformMatrix[2][0]+
              (float)SrcData[i+1]*TransformMatrix[2][1]+
              (float)SrcData[i+2]*TransformMatrix[2][2];

    x = xmax-xmin != 0.0 ? 255.0 : (x-xmin) / (xmax-xmin)*255.0;
    y = ymax-ymin != 0.0 ? 255.0 : (y-xmin) / (ymax-ymin)*255.0;
    z = zmax-zmin != 0.0 ? 255.0 : (z-xmin) / (zmax-zmin)*255.0;

    DstData[i] = (unsigned char)MCBound(0, (int)x, 255);
    DstData[i+1] = (unsigned char)MCBound(0, (int)y, 255);
    DstData[i+2] = (unsigned char)MCBound(0, (int)z, 255);
  }
  RELEASE_IPLIMAGE(Image);
  Image = TempImg;
}