$search

vlrImage.cpp

Go to the documentation of this file.

/*********************************************************************
 *
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2011, Robert Bosch LLC.
 *  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 the Robert Bosch 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.
 *
 *********************************************************************/

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <map>
#include <typeinfo>

#include "vlr/vlrException.h"
#include "vlr/vlrImage.h"

namespace vlr {

template<class T>
Image<T>::Image(uint32_t width, uint32_t height, uint32_t channels, uint32_t padded_width, bool manage_buffer, colorSpace_t colorSpace) :
  ImageBase(width, height, channels, padded_width, manage_buffer, colorSpace) {
  create();
}

template<class T>
Image<T>::Image(uint32_t width, uint32_t height, uint32_t channels, colorSpace_t colorSpace) :
  ImageBase(width, height, channels, width, true, colorSpace) {
  create();
}

template<class T>
Image<T>::Image(uint32_t width, uint32_t height, uint32_t channels) :
  ImageBase(width, height, channels, width, true, CS_GRAY) {
  create();
}

template<class T>
Image<T>::Image(uint32_t width, uint32_t height) :
  ImageBase(width, height, 1, width, true, CS_GRAY) {
  create();
}

template<class T>
void Image<T>::create() {
  element_size_ = sizeof(T);
  if (manage_buffer_ && num_elements_ > 0) {
    data_ = new T[num_elements_];
  }
  type_name_ = typeid(*this).name();
}

template<class T>
Image<T>::Image(const Image& img, bool ignoreManageBuffer, bool copyData, bool copyTags) :
  ImageBase(img.width_, img.height_, img.channels_, img.padded_width_, img.manage_buffer_, img.color_space_) {

  if (ignoreManageBuffer) {
    manage_buffer_ = true;
  } // create a buffer for the data regardless of source
  create();
  if (manage_buffer_ && num_elements_ > 0) {
    if (copyData) {
      memcpy(data_, img.data_, num_elements_ * element_size_);
    }
  }
  if (copyTags) {
    tags_ = img.tags_;
  }
}

template<class T>
Image<T>& Image<T>::operator=(const Image<T>& img) {
  if (this == &img) {
    return *this;
  }

  // TODO: assigment operator always creates deep copy
  if (!sameDims(img) || !manage_buffer_)
  //            {throw("assignment failed: images have different dimensions");}
  {
    T* tmp = 0;

    if (num_elements_ > 0) {
      tmp = new T[num_elements_];
    }
    if (data_ && manage_buffer_) {
      delete[] data_;
    }

    data_ = tmp;
    width_ = img.width();
    height_ = img.height();
    channels_ = img.channels();
    padded_width_ = img.paddedWidth();
    manage_buffer_ = true;
  }

  if (num_elements_ > 0) {
    memcpy(data_, img.data_, num_elements_ * element_size_);
  }

  tags_ = img.tags_;
  color_space_ = img.colorSpace();

  return *this;
}

template<class T>
Image<T>::~Image() {
  if (data_ && manage_buffer_) {
    delete[] data_;
  }
}

template<class T>
void Image<T>::bounds(T& lowerBound, T& upperBound) {
  T* data_ptr = data_;

  uint32_t align_gap = padded_width_ - width_;

  lowerBound = upperBound = *data_ptr;

  for (uint32_t c = 0; c < channels_; c++) {
    for (uint32_t y = 0; y < height_; y++) {
      for (uint32_t x = 0; x < width_; x++) {
        if (*data_ptr < lowerBound) {
          lowerBound = *data_ptr;
        }
        else if (*data_ptr > upperBound) {
          upperBound = *data_ptr;
        }
        data_ptr++;
      }
      data_ptr += align_gap;
    }
  }
}

template<class T>
void Image<T>::normalize(T newMin, T newMax) {
  T imgMinVal, imgMaxVal, dFactor;

  if (!data_) {
    throw VLRException("Zero data pointer.");
  }

  T* data_ptr = data_;

  uint32_t align_gap = padded_width_ - width_;

  bounds(imgMinVal, imgMaxVal);

  if (imgMaxVal == imgMinVal) {
    return;
  }

  dFactor = (newMax - newMin) / (imgMaxVal - imgMinVal);

  for (uint32_t c = 0; c < channels_; c++) {
    for (uint32_t y = 0; y < height_; y++) {
      for (uint32_t x = 0; x < width_; x++) {
        *data_ptr = (*data_ptr - imgMinVal) * dFactor + newMin;
        data_ptr++;
      }

      data_ptr += align_gap;
    }
  }
}

template<class T>
Image<T> Image<T>::operator +(const Image<T>& img) const {
  if (!sameDims(img)) {
    throw VLRException("Different image dimensions.");
  }

  Image<T> res = Image<T> (*this); // TODO: Implement tag class filtering...
  const T* data1 = data_;
  const T* data2 = const_cast<Image<T>*> (&img)->data();
  T* resdata = res.data();
  for (uint32_t i = 0; i < num_elements_; i++) {
    *resdata++ = *data1++ + *data2++;
  }

  return res;
}

template<class T>
bool Image<T>::reformat(uint32_t new_width, uint32_t new_height, uint32_t new_channels, uint32_t new_padded_width, colorSpace_t new_color_space)

{
  if (new_color_space != CS_GRAY && new_channels < 3) {
    return false;
  }

  color_space_ = new_color_space;

  if (new_width == width_ && new_height == height_ && new_channels == channels_ && new_padded_width == padded_width_) {
    return true;
  }

  if (data_ && manage_buffer_) {
    delete[] data_;
    data_ = NULL;
  }

  width_ = new_width;
  height_ = new_height;
  channels_ = new_channels;
  padded_width_ = new_padded_width;
  manage_buffer_ = true;

  num_elements_ = padded_width_ * height_ * channels_;

  if (num_elements_ > 0) {
    data_ = new T[num_elements_];
  }
  tags_.clear();
  return true;
}

template<class T>
Image<T> Image<T>::operator ()(uint32_t x, uint32_t y, uint32_t roi_width, uint32_t roi_height) const {

  if (roi_width == 0 || roi_height == 0 || x + roi_width > width_ || y + roi_height > height_) {
    throw VLRException("Illegal roi dimensions.");
  }

  Image<T> res(roi_width, roi_height, channels_, padded_width_, false, color_space_);
  res.data_ = &data_[y * padded_width_ + x];

  return res;
}

// instantiations for supported data types
template class Image<uint8_t> ;
template class Image<int8_t> ;
template class Image<char> ; // should be int8_t ?!?
template class Image<uint16_t> ;
template class Image<int16_t> ;
template class Image<uint32_t> ;
template class Image<int32_t> ;
template class Image<float> ;
template class Image<double> ;
} // namespace vlr

---

vlr
Author(s): Soeren Kammel
autogenerated on Sun Mar 3 11:53:51 2013