$search

rtcImage.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2008
 * Robert Bosch LLC
 * Research and Technology Center North America
 * Palo Alto, California
 *
 * All rights reserved.
 *
 *------------------------------------------------------------------------------
 * project ....: PUMA: Probablistic Unsupervised Model Acquisition
 * file .......: Image.cpp
 * authors ....: Benjamin Pitzer
 * organization: Robert Bosch LLC
 * creation ...: 10/13/2006
 * modified ...: $Date: 2009-03-11 10:01:02 -0700 (Wed, 11 Mar 2009) $
 * changed by .: $Author: wg75pal $
 * revision ...: $Revision: 825 $
 */

//== INCLUDES ==================================================================
//#include <opencv/cv.h>
//#include <opencv/highgui.h> //for cvLoadImage()
#include "rtc/rtcImage.h"

//== NAMESPACES ================================================================
namespace rtc {

//== IMPLEMENTATION ============================================================
template <>
bool Image<Vec3uc>::readFromFile(const char* filename)
{
  cv::Mat img = cv::imread(filename);
  if(img.empty()) return false;
  int w = img.cols;
  int h = img.rows;
  setSize(h,w);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      x[r*w+c][0] = img.at<Vec3b> (r, c)[2]; // R
      x[r*w+c][1] = img.at<Vec3b> (r, c)[1]; // G
      x[r*w+c][2] = img.at<Vec3b> (r, c)[0]; // B
    }
  }
  return true;
}

template <>
bool Image<Vec4uc>::readFromFile(const char* filename)
{
  cv::Mat img = cv::imread(filename);
  if(img.empty()) return false;
  int w = img.cols;
  int h = img.rows;
  setSize(h,w);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      x[r*w+c][0] = img.at<Vec3b> (r, c)[2]; // R
      x[r*w+c][1] = img.at<Vec3b> (r, c)[1]; // G
      x[r*w+c][2] = img.at<Vec3b> (r, c)[0]; // B
      x[r*w+c][3] = (uchar)(255);
    }
  }
  return true;
}

template <>
bool Image<float>::readFromFile(const char* filename)
{
  cv::Mat img = cv::imread(filename);
  if(img.empty()) return false;
  int w = img.cols;
  int h = img.rows;
  setSize(h,w);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      uchar R = img.at<Vec3b> (r, c)[2]; // R
      uchar G = img.at<Vec3b> (r, c)[1]; // G
      uchar B = img.at<Vec3b> (r, c)[0]; // B
      x[r*w+c] = (R*0.299+G*0.587+B*0.114)/256.0;
    }
  }
  return true;
}

template <>
bool Image<unsigned char>::readFromFile(const char* filename)
{
  cv::Mat img = cv::imread(filename);
  if(img.empty()) return false;
  int w = img.cols;
  int h = img.rows;
  setSize(h,w);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      uchar R = img.at<Vec3b> (r, c)[2]; // R
      uchar G = img.at<Vec3b> (r, c)[1]; // G
      uchar B = img.at<Vec3b> (r, c)[0]; // B
      x[r*w+c] = R*0.299+G*0.587+B*0.114;
    }
  }
  return true;
}

template <>
bool Image<Vec3uc>::writeToFile(const char* filename) const
{
  int w = columns();
  int h = rows();
  cv::Mat image (h, w, CV_8UC3);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      image.at<unsigned char> (r, 3*c+2) = x[r*w+c][0]; // R
      image.at<unsigned char> (r, 3*c+1) = x[r*w+c][1]; // G
      image.at<unsigned char> (r, 3*c) = x[r*w+c][2]; // B
    }
  }
  cv::imwrite(filename, image);
  return true;
}

template <>
bool Image<Vec4uc>::writeToFile(const char* filename) const
{
  int w = columns();
  int h = rows();
  //CvSize size = {w,h};
  //cv::Mat img (size,IPL_DEPTH_8U,4);
  cv::Mat img (h, w, CV_8UC4);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      img.at<Vec3b> (r, c)[2] = x[r*w+c][0]; // R
      img.at<Vec3b> (r, c)[1] = x[r*w+c][1]; // G
      img.at<Vec3b> (r, c)[0] = x[r*w+c][2]; // B
      img.at<Vec3b> (r, c)[4] = x[r*w+c][3]; // B
    }
  }
  cv::imwrite(filename, img);
  return true;
}

template <>
bool Image<float>::writeToFile(const char* filename) const
{
  int w = columns();
  int h = rows();
  CvSize size = {w,h};
  cv::Mat img (size,IPL_DEPTH_8U,1);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      img.at<float> (r, c) = rtc_clamp<int>(at(r,c)*256,0,255);
    }
  }
  return true;
}

template <>
bool Image<unsigned char>::writeToFile(const char* filename) const
{
  int w = columns();
  int h = rows();
  CvSize size = {w,h};
  cv::Mat img (size,IPL_DEPTH_8U,1);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      img.at<unsigned char> (r, c) = at(r,c);
    }
  }
  return true;
}
template <>
Image<Vec3uc>::Pixel Image<Vec3uc>::interpolate(const float row, const float col) const
{
  const int truncR = rtc_clamp(static_cast<int>(row),0,rows()-1);
  const int truncR1 = rtc_clamp(truncR+1,0,rows()-1);
  const float fractR = row - static_cast<float>(truncR);
  const int truncC = rtc_clamp(static_cast<int>(col),0,columns()-1);
  const int truncC1 = rtc_clamp(truncC+1,0,columns()-1);
  const float fractC = col - static_cast<float>(truncC);

  // do the interpolation
  const Vec3f syx = at(truncR,truncC);
  const Vec3f syx1 = at(truncR,truncC1);
  const Vec3f sy1x = at(truncR1,truncC);
  const Vec3f sy1x1 = at(truncR1,truncC1);
  // normal interpolation within range
  const Vec3f tmp1 = syx  + (syx1-syx)*fractC;
  const Vec3f tmp2 = sy1x + (sy1x1-sy1x)*fractC;
  return (tmp1 + (tmp2-tmp1)*fractR);
}

template <>
Image<Vec4uc>::Pixel Image<Vec4uc>::interpolate(const float row, const float col) const
{
  const int truncR = rtc_clamp(static_cast<int>(row),0,rows()-1);
  const int truncR1 = rtc_clamp(truncR+1,0,rows()-1);
  const float fractR = row - static_cast<float>(truncR);
  const int truncC = rtc_clamp(static_cast<int>(col),0,columns()-1);
  const int truncC1 = rtc_clamp(truncC+1,0,columns()-1);
  const float fractC = col - static_cast<float>(truncC);

  // do the interpolation
  const Vec4f syx = at(truncR,truncC);
  const Vec4f syx1 = at(truncR,truncC1);
  const Vec4f sy1x = at(truncR1,truncC);
  const Vec4f sy1x1 = at(truncR1,truncC1);
  // normal interpolation within range
  const Vec4f tmp1 = syx  + (syx1-syx)*fractC;
  const Vec4f tmp2 = sy1x + (sy1x1-sy1x)*fractC;
  return (tmp1 + (tmp2-tmp1)*fractR);
}

template <>
Image<float>::Pixel Image<float>::interpolate(const float row, const float col) const
{
  const int truncR = rtc_clamp(static_cast<int>(row),0,rows()-1);
  const int truncR1 = rtc_clamp(truncR+1,0,rows()-1);
  const float fractR = row - static_cast<float>(truncR);
  const int truncC = rtc_clamp(static_cast<int>(col),0,columns()-1);
  const int truncC1 = rtc_clamp(truncC+1,0,columns()-1);
  const float fractC = col - static_cast<float>(truncC);

  // do the interpolation
  const float syx = at(truncR,truncC);
  const float syx1 = at(truncR,truncC1);
  const float sy1x = at(truncR1,truncC);
  const float sy1x1 = at(truncR1,truncC1);
  // normal interpolation within range
  const float tmp1 = syx  + (syx1-syx)*fractC;
  const float tmp2 = sy1x + (sy1x1-sy1x)*fractC;
  return (tmp1 + (tmp2-tmp1)*fractR);
}

template <>
Image<unsigned char>::Pixel Image<unsigned char>::interpolate(const float row, const float col) const
{
  const int truncR = rtc_clamp(static_cast<int>(row),0,rows()-1);
  const int truncR1 = rtc_clamp(truncR+1,0,rows()-1);
  const float fractR = row - static_cast<float>(truncR);
  const int truncC = rtc_clamp(static_cast<int>(col),0,columns()-1);
  const int truncC1 = rtc_clamp(truncC+1,0,columns()-1);
  const float fractC = col - static_cast<float>(truncC);

  // do the interpolation
  const float syx = at(truncR,truncC);
  const float syx1 = at(truncR,truncC1);
  const float sy1x = at(truncR1,truncC);
  const float sy1x1 = at(truncR1,truncC1);
  // normal interpolation within range
  const float tmp1 = syx  + (syx1-syx)*fractC;
  const float tmp2 = sy1x + (sy1x1-sy1x)*fractC;
  return (unsigned char)(tmp1 + (tmp2-tmp1)*fractR);
}

template <>
bool Image<Vec3uc>::fromOpenCV(const cv::Mat& image)
{
  int w = image.cols;
  int h = image.rows;
  setSize(h,w);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      x[r*w+c][0] = image.at<Vec3b> (r, c)[2]; // R
      x[r*w+c][1] = image.at<Vec3b> (r, c)[1]; // G
      x[r*w+c][2] = image.at<Vec3b> (r, c)[0]; // B
    }
  }
  return true;
}

template <>
bool Image<Vec4uc>::fromOpenCV(const cv::Mat& image)
{
  int w = image.cols;
  int h = image.rows;
  setSize(h,w);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      x[r*w+c][0] = image.at<Vec3b> (r, c)[2]; // R
      x[r*w+c][1] = image.at<Vec3b> (r, c)[1]; // G
      x[r*w+c][2] = image.at<Vec3b> (r, c)[0]; // B
      x[r*w+c][3] = (uchar)(255);
    }
  }
  return true;
}

  //specialization class
template <>
bool Image<Vec3uc>::toOpenCV(cv::Mat& image) const
{
  int w = columns();
  int h = rows();
  image.create(h, w, CV_8UC3);
  for(int r=0;r<h;++r) 
  {
    for(int c=0;c<w;++c) 
    {
      image.at<unsigned char> (r, 3*c+2) = x[r*w+c][0]; // R
      image.at<unsigned char> (r, 3*c+1) = x[r*w+c][1]; // G
      image.at<unsigned char> (r, 3*c) = x[r*w+c][2]; // B
    }
  }
  return true;
}
//==============================================================================
} // namespace rtc
//==============================================================================

---

rtc
Author(s): Benjamin Pitzer
autogenerated on Sun Mar 3 11:08:04 2013