image_processing.h

Go to the documentation of this file.

/*
 * Software License Agreement (Modified BSD License)
 *
 *  Copyright (c) 2012, PAL Robotics, S.L.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of PAL Robotics, S.L. nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef __PAL_IMAGE_PROCESSING_H__
#define __PAL_IMAGE_PROCESSING_H__

//#include <opencv/cv.h>
#include <opencv2/core/core.hpp>

#include <vector>

namespace pal_vision_util
{
  void getConnectedComponents(const cv::Mat& binaryImage,
                              std::vector< std::vector<cv::Point2i> >& components,
                              std::vector< cv::Rect >& boundingBoxes);


  class ImageRoi
  {
    public:
    ImageRoi();

    ImageRoi(const ImageRoi& roi);

    ImageRoi(int left, int top, int w, int h);

    ImageRoi(CvRect rect);

    ~ImageRoi();

    void set(CvRect rect);

    void clear();

    bool empty() const;

    CvRect toCvRect() const;

    void keepInside(int imgWidth, int imgHeight);

    const ImageRoi& resize(double factorHorizontal, double factorVertical);

    int x, y, width, height;
  };

  class Image
  {
  public:

    Image();

    Image(IplImage *img);

    ~Image();

    void freeImage();

    void loadImage(const std::string& fileName);

    void set(IplImage *img);

    IplImage *release();

    void resizeImage(int width, int height, int channels, int depth);

    int getWidth() const { return _img->width; };
    int getHeight() const { return _img->height; };
    int getChannel() const { return _img->nChannels; };
    int getDepth() const { return _img->depth; };

    unsigned char getPixelB(int col, int row, int ch) const;

    float getPixelF(int col, int row, int ch) const;

    short getPixelS(int col, int row, int ch) const;

    void setPixelB(int col, int row, int ch, unsigned char value);

    void setPixelS(int col, int row, int ch, short value);

    void setPixelF(int col, int row, int ch, float value);

    IplImage* getIplImg() { return _img; };

    IplImage* operator->(void) const { return _img; }

    operator IplImage*()  const { return _img; }   //overloads cast to IplImage* operator

  private:

    IplImage *_img;
  };

  void getLab(const Image& img, Image& L, Image& a, Image& b);

  void setLab(const Image& L, const Image& a, const Image& b, Image& img);

  void dctNormalization(const Image& img, Image& normalizedImg, int coefficientsToCancel, const ImageRoi& roi = ImageRoi(0,0,0,0));

  void dctNormalization(const cv::Mat& img, cv::Mat& normalizedImg, int coefficientsToCancel, const ImageRoi& roi = ImageRoi(0,0,0,0));

} // namespace pal_vision_util

#endif // __PAL_IMAGE_PROCESSING_H__