Image.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef IGNITION_COMMON_IMAGE_HH_
#define IGNITION_COMMON_IMAGE_HH_
 
#include <limits>
#include <memory>
#include <string>
#include <vector>
#include <ignition/math/Color.hh>
#include <ignition/common/graphics/Export.hh>
 
#include <ignition/utils/ImplPtr.hh>
 
namespace ignition
{
  namespace common
  {
    static std::string PixelFormatNames[] =
    {
      "UNKNOWN_PIXEL_FORMAT",
      "L_INT8",
      "L_INT16",
      "RGB_INT8",
      "RGBA_INT8",
      "BGRA_INT8",
      "RGB_INT16",
      "RGB_INT32",
      "BGR_INT8",
      "BGR_INT16",
      "BGR_INT32",
      "R_FLOAT16",
      "RGB_FLOAT16",
      "R_FLOAT32",
      "RGB_FLOAT32",
      "BAYER_RGGB8",
      "BAYER_BGGR8",
      "BAYER_GBRG8",
      "BAYER_GRBG8"
    };
 
    class IGNITION_COMMON_GRAPHICS_VISIBLE Image
    {
      public: enum PixelFormatType
              {
                UNKNOWN_PIXEL_FORMAT = 0,
                L_INT8,
                L_INT16,
                RGB_INT8,
                RGBA_INT8,
                BGRA_INT8,
                RGB_INT16,
                RGB_INT32,
                BGR_INT8,
                BGR_INT16,
                BGR_INT32,
                R_FLOAT16,
                RGB_FLOAT16,
                R_FLOAT32,
                RGB_FLOAT32,
                BAYER_RGGB8,
                BAYER_BGGR8,
                BAYER_GBRG8,
                BAYER_GRBG8,
                PIXEL_FORMAT_COUNT
              };
 
 
      public: static Image::PixelFormatType ConvertPixelFormat(
                  const std::string &_format);
 
      public: explicit Image(const std::string &_filename = "");
 
      public: virtual ~Image();
 
      public: int Load(const std::string &_filename);
 
      public: void SavePNG(const std::string &_filename);
 
      public: void SavePNGToBuffer(std::vector<unsigned char> &_buffer);
 
      public: void SetFromData(const unsigned char *_data,
                               unsigned int _width,
                               unsigned int _height,
                               Image::PixelFormatType _format);
 
      public: void Data(unsigned char **_data, unsigned int &_count);
 
      public: void RGBData(unsigned char **_data, unsigned int &_count);
 
      public: unsigned int Width() const;
 
      public: unsigned int Height() const;
 
      public: unsigned int BPP() const;
 
      // \brief Get the size of a row of pixel
      public: int Pitch() const;
 
      public: std::string Filename() const;
 
      public: PixelFormatType PixelFormat() const;
 
      public: math::Color Pixel(const unsigned int _x,
                  const unsigned int _y) const;
 
      public: math::Color AvgColor();
 
      public: math::Color MaxColor() const;
 
      public: void Rescale(const int _width, const int _height);
 
      public: bool Valid() const;
 
      public: template<typename T>
          static void ConvertToRGBImage(const void *_data,
          unsigned int _width, unsigned int _height, Image &_output,
          T _min = std::numeric_limits<T>::max(),
          T _max = std::numeric_limits<T>::lowest(), bool _flip = false)
      {
        unsigned int samples = _width * _height;
        unsigned int bufferSize = samples * sizeof(T);
 
        auto buffer = std::vector<T>(samples);
        memcpy(buffer.data(), _data, bufferSize);
 
        auto outputRgbBuffer = std::vector<uint8_t>(samples * 3);
 
        // use min and max values found in the data if not specified
        T min = std::numeric_limits<T>::max();
        T max = std::numeric_limits<T>::lowest();
        if (_min > max)
        {
          for (unsigned int i = 0; i < samples; ++i)
          {
            auto v = buffer[i];
            // ignore inf values when computing min/max
            // cast to float when calling isinf to avoid compile error on
            // windows
            if (v > max && !std::isinf(static_cast<float>(v)))
              max = v;
            if (v < min && !std::isinf(static_cast<float>(v)))
              min = v;
          }
        }
        min = math::equal(_min, std::numeric_limits<T>::max()) ? min : _min;
        max = math::equal(_max, std::numeric_limits<T>::lowest()) ? max : _max;
 
        // convert to rgb image
        // color is grayscale, i.e. r == b == g
        double range = static_cast<double>(max - min);
        if (ignition::math::equal(range, 0.0))
          range = 1.0;
        unsigned int idx = 0;
        for (unsigned int j = 0; j < _height; ++j)
        {
          for (unsigned int i = 0; i < _width; ++i)
          {
            auto v = buffer[idx++];
            double t = static_cast<double>(v - min) / range;
            if (_flip)
              t = 1.0 - t;
            uint8_t r = static_cast<uint8_t>(255*t);
            unsigned int outIdx = j * _width * 3 + i * 3;
            outputRgbBuffer[outIdx] = r;
            outputRgbBuffer[outIdx + 1] = r;
            outputRgbBuffer[outIdx + 2] = r;
          }
        }
        _output.SetFromData(outputRgbBuffer.data(), _width, _height, RGB_INT8);
      }
 
      IGN_UTILS_IMPL_PTR(dataPtr)
    };
  }
}
#endif