usImageRF2D.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 __usImageRF2D_h_
#define __usImageRF2D_h_
 
#include <cstring>
 
#include <visp3/ustk_core/usImagePreScanSettings.h>
 
template <class Type> class usImageRF2D : public usImagePreScanSettings
{
  friend class usRawFileParser;
  friend class usNetworkGrabberRF2D;
  friend class usNetworkGrabberRF3D;
  friend class usVirtualServer;
 
public:
  usImageRF2D();
  usImageRF2D(unsigned int height, unsigned int width);
  usImageRF2D(unsigned int height, unsigned int width, const usImagePreScanSettings &preScanSettings);
  usImageRF2D(const usImageRF2D &other);
  virtual ~usImageRF2D();
 
  const Type *getBitmap() const;
 
  unsigned int getHeight() const;
  unsigned int getNumberOfPixel() const;
  unsigned int getRFSampleNumber() const;
 
  const Type *getSignal(unsigned int scanlineIndex) const;
 
  unsigned int getWidth() const;
 
  void init(unsigned int height, unsigned int width);
 
  usImageRF2D<Type> &operator=(const usImageRF2D<Type> &other);
  bool operator==(const usImageRF2D<Type> &other);
 
  Type operator()(unsigned int i, unsigned int j) const;
  void operator()(unsigned int i, unsigned int j, const Type &value);
 
  void setScanLineNumber(unsigned int scanLineNumber);
 
  void resize(const unsigned int height, const unsigned int width);
  void resize(const unsigned int height, const unsigned int width, const Type &val);
 
private:
  Type *bitmap;
  unsigned int npixels;
  unsigned int width;
  unsigned int height;
  Type **col;
};
 
template <class Type>
usImageRF2D<Type>::usImageRF2D() : usImagePreScanSettings(), bitmap(NULL), npixels(0), width(0), height(0), col(NULL)
{
}
 
template <class Type>
usImageRF2D<Type>::usImageRF2D(unsigned int height, unsigned int width)
  : usImagePreScanSettings(), bitmap(NULL), npixels(0), width(0), height(0), col(NULL)
{
  init(height, width);
}
 
template <class Type>
usImageRF2D<Type>::usImageRF2D(unsigned int height, unsigned int width, const usImagePreScanSettings &preScanSettings)
  : usImagePreScanSettings(preScanSettings), bitmap(NULL), npixels(0), width(0), height(0), col(NULL)
{
  if (width != preScanSettings.getScanLineNumber())
    throw(vpException(vpException::badValue, "RF image width differ from transducer scan line number"));
 
  init(height, width);
  setImagePreScanSettings(preScanSettings);
}
 
template <class Type>
usImageRF2D<Type>::usImageRF2D(const usImageRF2D &other)
  : usImagePreScanSettings(other), bitmap(NULL), npixels(0), width(0), height(0), col(NULL)
{
  // allocation and resize
  resize(other.getHeight(), other.getWidth());
 
  // filling pixels values
  memcpy(bitmap, other.getBitmap(), (size_t)(height * width * sizeof(Type)));
}
 
template <class Type> usImageRF2D<Type>::~usImageRF2D()
{
  if (bitmap != NULL) {
    delete[] bitmap;
    bitmap = NULL;
  }
 
  if (col != NULL) {
    delete[] col;
    col = NULL;
  }
}
 
template <class Type> usImageRF2D<Type> &usImageRF2D<Type>::operator=(const usImageRF2D<Type> &other)
{
  resize(other.getHeight(), other.getWidth());
  memcpy(bitmap, other.getBitmap(), height * width * sizeof(Type));
 
  // from usImagePreScanSettings
  usImagePreScanSettings::operator=(other);
 
  return *this;
}
 
template <class Type> bool usImageRF2D<Type>::operator==(const usImageRF2D<Type> &other)
{
 
  if (this->width != other.getWidth())
    return false;
  if (this->height != other.getHeight())
    return false;
 
  for (unsigned int i = 0; i < npixels; i++) {
    if (bitmap[i] != other.bitmap[i]) {
      return false;
    }
  }
  return usImagePreScanSettings::operator==(other);
}
 
template <class Type> Type usImageRF2D<Type>::operator()(unsigned int i, unsigned int j) const
{
  if (i >= height || j >= width)
    throw vpException(vpException::dimensionError, "usImageRF2D, try to acess index out of image bounds");
 
  return col[j][i];
}
 
template <class Type> void usImageRF2D<Type>::operator()(unsigned int i, unsigned int j, const Type &value)
{
  if (i >= height || j >= width)
    throw vpException(vpException::dimensionError, "usImageRF2D, try to write at index out of image bounds");
 
  col[j][i] = value;
}
 
template <class Type> std::ostream &operator<<(std::ostream &out, const usImageRF2D<Type> &other)
{
  return out << static_cast<const usImagePreScanSettings &>(other) << "image height : " << other.getHeight()
             << std::endl
             << "image width : " << other.getWidth() << std::endl
             << "number of A-samples in a scan line : " << other.getRFSampleNumber() << std::endl
             << "number of scan lines : " << other.getScanLineNumber() << std::endl;
}
 
template <class Type> unsigned int usImageRF2D<Type>::getRFSampleNumber() const { return getHeight(); }
 
template <class Type> void usImageRF2D<Type>::setScanLineNumber(unsigned int scanLineNumber)
{
  if (scanLineNumber != getWidth())
    resize(this->getHeight(), scanLineNumber);
 
  usTransducerSettings::setScanLineNumber(scanLineNumber);
}
 
template <class Type> void usImageRF2D<Type>::resize(const unsigned int height, const unsigned int width)
{
  this->init(height, width);
  this->setScanLineNumber(width);
}
 
template <class Type>
void usImageRF2D<Type>::resize(const unsigned int height, const unsigned int width, const Type &val)
{
  this->init(height, width);
  this->setScanLineNumber(width);
 
  // fill bitmap
  for (unsigned int n = 0; n < this->npixels; n++) {
    bitmap[n] = val;
  }
}
 
template <class Type> void usImageRF2D<Type>::init(unsigned int height, unsigned int width)
{
  if (width != this->width) {
    if (col != NULL) {
      delete[] col;
      col = NULL;
    }
  }
 
  if ((height != this->height) || (width != this->width)) {
    if (bitmap != NULL) {
      delete[] bitmap;
      bitmap = NULL;
    }
  }
  this->width = width;
  this->height = height;
 
  npixels = width * height;
  if (bitmap == NULL)
    bitmap = new Type[npixels];
 
  if (bitmap == NULL) {
    throw(vpException(vpException::memoryAllocationError, "cannot allocate bitmap "));
  }
 
  if (col == NULL)
    col = new Type *[width];
  if (col == NULL) {
    throw(vpException(vpException::memoryAllocationError, "cannot allocate col "));
  }
 
  unsigned int j;
  for (j = 0; j < width; j++)
    col[j] = bitmap + j * height;
}
 
template <class Type> unsigned int usImageRF2D<Type>::getHeight() const { return height; }
 
template <class Type> unsigned int usImageRF2D<Type>::getNumberOfPixel() const { return npixels; }
 
template <class Type> unsigned int usImageRF2D<Type>::getWidth() const { return width; }
 
template <class Type> const Type *usImageRF2D<Type>::getBitmap() const { return bitmap; }
 
template <class Type> const Type *usImageRF2D<Type>::getSignal(unsigned int scanlineIndex) const
{
  return col[scanlineIndex];
}
#endif // __usImageRF2D_h_