usImageRF3D.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:
 * Marc Pouliquen
 *
 *****************************************************************************/
 
#ifndef __usImageRF3D_h_
#define __usImageRF3D_h_
 
#include <cstring>
 
#include <visp3/ustk_core/usImageRF2D.h>
 
#include <visp3/ustk_core/usImagePreScanSettings.h>
#include <visp3/ustk_core/usMotorSettings.h>
 
template <class Type> class usImageRF3D : public usImagePreScanSettings, public usMotorSettings
{
  friend class usRawFileParser;
 
public:
  usImageRF3D();
  usImageRF3D(unsigned int height, unsigned int width, unsigned int numberOfFrames);
  usImageRF3D(unsigned int height, unsigned int width, unsigned int numberOfFrames,
              const usImagePreScanSettings &imageSettings, const usMotorSettings &motorSettings);
  usImageRF3D(const usImageRF3D<Type> &other);
  virtual ~usImageRF3D();
 
  void getFrame(usImageRF2D<Type> &image, unsigned int index) const;
 
  const Type *getConstData() const;
 
  unsigned int getWidth() const;
  unsigned int getHeight() const;
  unsigned int getNumberOfFrames() const;
 
  unsigned int getRFSampleNumber() const;
 
  unsigned int getSize() const;
 
  void insertFrame(const usImageRF2D<short> &frame, unsigned int index);
 
  usImageRF3D<Type> &operator=(const usImageRF3D<Type> &other);
  bool operator==(const usImageRF3D<Type> &other);
 
  Type operator()(unsigned int i, unsigned int indexJ, unsigned int k) const;
  void operator()(unsigned int i, unsigned int indexJ, unsigned int k, const Type &value);
 
  void setFrameNumber(unsigned int frameNumber);
  void setScanLineNumber(unsigned int scanLineNumber);
 
  void resize(unsigned int height, unsigned int width, unsigned int numberOfFrames);
 
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 <class Type>
usImageRF3D<Type>::usImageRF3D()
  : usImagePreScanSettings(), usMotorSettings(), m_width(0), m_height(0), m_numberOfFrames(0), m_size(0), bitmap(NULL),
    framPointer(NULL)
{
}
 
template <class Type>
usImageRF3D<Type>::usImageRF3D(unsigned int height, unsigned int width, unsigned int numberOfFrames)
  : usImagePreScanSettings(), usMotorSettings(), m_width(0), m_height(0), m_numberOfFrames(0), m_size(0), bitmap(NULL),
    framPointer(NULL)
{
  resize(height, width, numberOfFrames);
}
 
template <class Type>
usImageRF3D<Type>::usImageRF3D(unsigned int height, unsigned int width, unsigned int numberOfFrames,
                               const usImagePreScanSettings &preScanSettings, const usMotorSettings &motorSettings)
  : usImagePreScanSettings(preScanSettings), usMotorSettings(motorSettings), m_width(0), m_height(0),
    m_numberOfFrames(0), m_size(0), bitmap(NULL), framPointer(NULL)
{
  if (width != preScanSettings.getScanLineNumber())
    throw(vpException(vpException::badValue, "3D RF image U-size differ from transducer scanline number"));
  if (numberOfFrames != motorSettings.getFrameNumber())
    throw(vpException(vpException::badValue, "3D RF image W-size differ from motor frame number"));
 
  init(height, width, numberOfFrames);
}
 
template <class Type>
usImageRF3D<Type>::usImageRF3D(const usImageRF3D &other)
  : usImagePreScanSettings(other), usMotorSettings(other), m_width(0), m_height(0), m_numberOfFrames(0), m_size(0),
    bitmap(NULL)
{
  init(other.getHeight(), other.getWidth(), other.getNumberOfFrames());
  memcpy(bitmap, other.getConstData(), (size_t)(m_width * m_height * m_numberOfFrames * sizeof(Type)));
}
 
template <class Type> usImageRF3D<Type>::~usImageRF3D()
{
  if (bitmap) {
    delete[] bitmap;
    bitmap = NULL;
  }
  if (framPointer) {
    delete[] framPointer;
    framPointer = NULL;
  }
}
 
template <class Type> usImageRF3D<Type> &usImageRF3D<Type>::operator=(const usImageRF3D<Type> &other)
{
  // allocation and resize
  resize(other.getHeight(), other.getWidth(), other.getNumberOfFrames());
 
  // filling voxel values
  memcpy(bitmap, other.getConstData(), (size_t)(m_width * m_height * m_numberOfFrames * sizeof(Type)));
 
  // from usImageSettings
  usImagePreScanSettings::operator=(other);
 
  // from usMotorSettings
  usMotorSettings::operator=(other);
 
  return *this;
}
 
template <class Type> bool usImageRF3D<Type>::operator==(const usImageRF3D<Type> &other)
{
  // test image settings
  if (!usImagePreScanSettings::operator==(other))
    return false;
  if (!usMotorSettings::operator==(other))
    return false;
 
  // test dimentions
  if (this->m_width != other.getWidth())
    return false;
  if (this->m_height != other.getHeight())
    return false;
  if (this->m_numberOfFrames != other.getNumberOfFrames())
    return false;
 
  // test bitmap
  for (unsigned int i = 0; i < m_size; i++) {
    if (bitmap[i] != other.bitmap[i]) {
      return false;
    }
  }
 
  return true;
}
 
template <class Type> std::ostream &operator<<(std::ostream &out, const usImageRF3D<Type> &image)
{
  return out << "width : " << image.getWidth() << "\nheight : " << image.getHeight()
             << "\nnumberOfFrames : " << image.getNumberOfFrames() << std::endl
             << static_cast<const usImagePreScanSettings &>(image) << static_cast<const usMotorSettings &>(image);
}
 
template <class Type> unsigned int usImageRF3D<Type>::getRFSampleNumber() const { return getHeight(); }
 
template <class Type> void usImageRF3D<Type>::setScanLineNumber(unsigned int scanLineNumber)
{
  if (scanLineNumber != m_width)
    resize(getHeight(), scanLineNumber, getNumberOfFrames());
  usTransducerSettings::setScanLineNumber(scanLineNumber);
}
 
template <class Type> void usImageRF3D<Type>::setFrameNumber(unsigned int frameNumber)
{
  if (frameNumber != m_numberOfFrames)
    resize(getHeight(), getWidth(), frameNumber);
  usMotorSettings::setFrameNumber(frameNumber);
}
 
template <class Type>
void usImageRF3D<Type>::resize(unsigned int height, unsigned int width, unsigned int numberOfFrames)
{
  init(height, width, numberOfFrames);
  usMotorSettings::setFrameNumber(numberOfFrames);
  usTransducerSettings::setScanLineNumber(width);
}
 
template <class Type> void usImageRF3D<Type>::insertFrame(const usImageRF2D<short> &frame, unsigned int index)
{
  // Dimentions checks
  if (index > this->getNumberOfFrames())
    throw(vpException(vpException::badValue, "usImageRF3D::insertFrame : frame index out of volume"));
 
  if (frame.getHeight() != this->getHeight() || frame.getWidth() != this->getWidth())
    throw(vpException(vpException::badValue, "usImageRF3D::insertFrame : frame size don't match volume size"));
 
  // offset to access the frame in the volume
  int offset = index * this->getHeight() * this->getWidth();
  Type *frameBeginning = bitmap + offset;
 
  // copy
  for (unsigned int i = 0; i < this->getHeight(); i++) {
    for (unsigned int j = 0; j < this->getWidth(); j++) {
      frameBeginning[i + this->getHeight() * j] = frame(i, j);
    }
  }
}
 
template <class Type> void usImageRF3D<Type>::getFrame(usImageRF2D<Type> &image, unsigned int index) const
{
  // Dimentions checks
  if (index > this->getNumberOfFrames())
    throw(vpException(vpException::badValue, "usImageRF3D::getFrame : frame index out of volume"));
 
  image.resize(this->getHeight(), this->getWidth());
 
  image.setImagePreScanSettings(getImagePreScanSettings());
 
  // offset to access the frame beginning in the volume
  int offset = index * this->getHeight() * this->getWidth();
  const Type *frameBeginning = this->getConstData() + offset;
 
  // copy
  for (unsigned int i = 0; i < this->getHeight(); i++) {
    for (unsigned int j = 0; j < this->getWidth(); j++) {
      image(i, j, frameBeginning[i + this->getHeight() * j]);
    }
  }
}
 
template <class Type> void usImageRF3D<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) {
      delete[] bitmap;
      bitmap = NULL;
    }
    if (framPointer != NULL) {
      delete[] framPointer;
      framPointer = NULL;
    }
  }
 
  this->m_width = width;
  this->m_height = height;
  this->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;
 
  if (bitmap == NULL) {
    throw(vpException(vpException::memoryAllocationError, "cannot allocate bitmap "));
  }
}
 
template <class Type> unsigned int usImageRF3D<Type>::getWidth() const { return m_width; }
 
template <class Type> unsigned int usImageRF3D<Type>::getHeight() const { return m_height; }
 
template <class Type> unsigned int usImageRF3D<Type>::getNumberOfFrames() const { return m_numberOfFrames; }
 
template <class Type> unsigned int usImageRF3D<Type>::getSize() const { return m_size; }
 
template <class Type> const Type *usImageRF3D<Type>::getConstData() const { return bitmap; }
 
template <class Type> Type usImageRF3D<Type>::operator()(unsigned int i, unsigned int j, unsigned int k) const
{
  bool indexOK = j < m_width && i < m_height && k < m_numberOfFrames;
  if (!indexOK)
    throw(vpException(vpException::dimensionError, "usImageRF3D : accessing a voxel out of range !"));
 
  return framPointer[k][m_height * j + i];
}
 
template <class Type>
void usImageRF3D<Type>::operator()(unsigned int i, unsigned int j, unsigned int k, const Type &value)
{
  bool indexOK = j < m_width && i < m_height && k < m_numberOfFrames;
  if (!indexOK)
    throw(vpException(vpException::dimensionError, "usImageRF3D : trying to write in a voxel out of range !"));
  framPointer[k][m_height * j + i] = value;
}
 
#endif // __usImageRF3D_h_