usImage3D.h

/****************************************************************************
 *
 * This file is part of the ustk software.
 * Copyright (C) 2016 - 2017 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ustk with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at ustk@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Authors:
 * Pierre Chatelain
 * Marc Pouliquen
 *
 *****************************************************************************/
 
#ifndef __usImage3D_h_
#define __usImage3D_h_
 
#include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
 
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpException.h>
#include <visp3/core/vpImage.h>
 
template <class Type> class usImage3D
{
public:
  usImage3D();
 
  usImage3D(unsigned int height, unsigned int width, unsigned int frameNumber);
 
  usImage3D(unsigned int height, unsigned int width, unsigned int frameNumber, Type initialValue);
 
  usImage3D(const usImage3D<Type> &image, const bool copy = true);
 
  virtual ~usImage3D();
 
 
  Type *getConstData() const { return bitmap; }
 
  Type *getData() { return bitmap; }
 
  Type *getData(unsigned int i, unsigned int j, unsigned int k) { return framPointer[k] + m_width * i + j; }
 
  unsigned int getWidth() const { return m_width; }
 
  unsigned int getHeight() const { return m_height; }
 
  unsigned int getNumberOfFrames() const { return m_numberOfFrames; }
 
  unsigned int getSize() const { return m_size; }
 
  void initData(Type value);
 
  usImage3D<Type> &operator=(const usImage3D<Type> &other);
 
  bool operator==(const usImage3D<Type> &other);
 
  inline Type operator()(unsigned int i, unsigned int j, unsigned int k) const
  {
    return framPointer[k][m_width * i + j];
  }
 
  inline void operator()(unsigned int i, unsigned int j, unsigned int k, Type value)
  {
    framPointer[k][m_width * i + j] = value;
  }
 
  void resize(unsigned int height, unsigned int width, unsigned int numberOfFrames);
 
  void setData(Type *data, int numberOfVoxels);
 
 
protected:
private:
  void init(unsigned int height, unsigned int width, unsigned int numberOfFrames);
 
  unsigned int m_width;          
  unsigned int m_height;         
  unsigned int m_numberOfFrames; 
  unsigned int m_size;           
  Type *bitmap;       
  Type **framPointer; 
};
 
/****************************************************************************
* Template implementations.
****************************************************************************/
template <class Type>
inline void usImage3D<Type>::init(unsigned int height, unsigned int width, unsigned int numberOfFrames)
{
  if ((width != this->m_width) || (height != this->m_height) || (numberOfFrames != this->m_numberOfFrames)) {
    if (bitmap != NULL) {
      vpDEBUG_TRACE(10, "Destruction bitmap[]");
      delete[] bitmap;
      bitmap = NULL;
    }
    if (framPointer != NULL) {
      vpDEBUG_TRACE(10, "Destruction framPointer[]");
      delete[] framPointer;
      framPointer = NULL;
    }
  }
 
  m_width = width;
  m_height = height;
  m_numberOfFrames = numberOfFrames;
 
  m_size = m_width * m_height * m_numberOfFrames;
 
  if (bitmap == NULL)
    bitmap = new Type[m_size];
 
  if (framPointer == NULL)
    framPointer = new Type *[numberOfFrames];
 
  for (unsigned int k = 0; k < numberOfFrames; k++)
    framPointer[k] = bitmap + m_width * m_height * k;
 
  //  vpERROR_TRACE("Allocate bitmap %p",bitmap) ;
  if (bitmap == NULL) {
    vpERROR_TRACE("cannot allocate bitmap ");
    throw(vpException(vpException::memoryAllocationError, "cannot allocate bitmap "));
  }
}
 
template <class Type>
usImage3D<Type>::usImage3D() : m_width(0), m_height(0), m_numberOfFrames(0), m_size(0), bitmap(NULL), framPointer(NULL)
{
}
 
template <class Type>
usImage3D<Type>::usImage3D(unsigned int height, unsigned int width, unsigned int frameNumber)
  : m_width(0), m_height(0), m_numberOfFrames(0), m_size(0), bitmap(NULL), framPointer(NULL)
{
  this->init(height, width, frameNumber);
  this->initData(Type());
}
 
template <class Type>
usImage3D<Type>::usImage3D(unsigned int height, unsigned int width, unsigned int frameNumber, Type initialValue)
  : m_width(0), m_height(0), m_numberOfFrames(0), m_size(0), bitmap(NULL), framPointer(NULL)
{
  this->init(height, width, frameNumber);
  this->initData(initialValue);
}
 
template <class Type>
usImage3D<Type>::usImage3D(const usImage3D<Type> &volume, const bool copy)
  : m_width(0), m_height(0), m_numberOfFrames(0), m_size(0), bitmap(NULL), framPointer(NULL)
{
  this->init(volume.getHeight(), volume.getWidth(), volume.getNumberOfFrames());
 
  // deep copy
  if (copy)
    memcpy(bitmap, volume.bitmap, m_size * sizeof(Type));
}
 
template <class Type> usImage3D<Type>::~usImage3D()
{
  if (bitmap) {
    delete[] bitmap;
    bitmap = NULL;
  }
  if (framPointer) {
    delete[] framPointer;
    framPointer = NULL;
  }
}
 
template <class Type> usImage3D<Type> &usImage3D<Type>::operator=(const usImage3D<Type> &other)
{
  this->init(other.m_height, other.m_width, other.m_numberOfFrames);
 
  memcpy(bitmap, other.bitmap, m_size * sizeof(Type));
  return *this;
}
 
template <class Type> bool usImage3D<Type>::operator==(const usImage3D<Type> &other)
{
  bool settingsOk = this->getWidth() == other.getWidth() && this->getHeight() == other.getHeight() &&
                    this->getNumberOfFrames() == other.getNumberOfFrames();
 
  if (settingsOk) {
    for (unsigned int i = 0; i < m_size; i++) {
      if (bitmap[i] != other.getConstData()[i])
        return false;
    }
  } else
    return false;
  return true;
}
 
template <class Type> std::ostream &operator<<(std::ostream &out, const usImage3D<Type> &image)
{
  return out << "width : " << image.getWidth() << std::endl
             << "height : " << image.getHeight() << std::endl
             << "frames in volume : " << image.getNumberOfFrames() << std::endl;
}
 
template <class Type> void usImage3D<Type>::setData(Type *data, int numberOfVoxels)
{
  try {
    if (m_size != numberOfVoxels) {
      throw(vpException(vpException::fatalError, "usImage3D::setData() error, bitmap dimensions mismatch."));
    }
    memcpy(bitmap, data, m_size * sizeof(Type));
  } catch (std::exception e) {
    std::cout << "usImage3D::setData(), error when trying to copy the data :" << std::endl;
    std::cout << e.what() << std::endl;
  }
}
 
template <class Type> void usImage3D<Type>::initData(Type value)
{
  try {
    std::fill_n(bitmap, m_size, value);
  } catch (const std::exception &e) {
    std::cout << e.what() << std::endl;
  }
}
 
template <class Type> void usImage3D<Type>::resize(unsigned int height, unsigned int width, unsigned int numberOfFrames)
{
  this->init(height, width, numberOfFrames);
}
#endif // __usImage3D_h_