usImagePostScan3D.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 __usImagePostScan3D_h_
#define __usImagePostScan3D_h_
 
#include <visp3/core/vpConfig.h>
#include <visp3/ustk_core/usImage3D.h>
 
#include <visp3/ustk_core/usMotorSettings.h>
 
template <class Type>
class usImagePostScan3D : public usImage3D<Type>, public usTransducerSettings, public usMotorSettings
{
public:
  usImagePostScan3D();
  usImagePostScan3D(const usImage3D<Type> &image, const usTransducerSettings &transducerSettings,
                    const usMotorSettings &motorSettings, double spacingX, double spacingY, double spacingZ,
                    double scanLineDepth);
  usImagePostScan3D(const usImagePostScan3D &other);
  virtual ~usImagePostScan3D();
 
  double getElementSpacingX() const;
  double getElementSpacingY() const;
  double getElementSpacingZ() const;
  double getScanLineDepth() const;
 
  usImagePostScan3D<Type> &operator=(const usImagePostScan3D<Type> &other);
 
  bool operator==(const usImagePostScan3D<Type> &other);
 
  void setData(const usImage3D<Type> &image3D);
 
  void setElementSpacingX(double elementSpacingX);
  void setElementSpacingY(double elementSpacingY);
  void setElementSpacingZ(double elementSpacingZ);
  void setScanLineDepth(double scanLineDepth);
 
private:
  double m_elementSpacingX; 
  double m_elementSpacingY; 
  double m_elementSpacingZ; 
  double m_scanLineDepth; 
};
 
template <class Type>
usImagePostScan3D<Type>::usImagePostScan3D()
  : usImage3D<Type>(), usTransducerSettings(), usMotorSettings(), m_elementSpacingX(1.0), m_elementSpacingY(1.0),
    m_elementSpacingZ(1.0), m_scanLineDepth(0.0)
{
}
 
template <class Type>
usImagePostScan3D<Type>::usImagePostScan3D(const usImagePostScan3D &other)
  : usImage3D<Type>(other), usTransducerSettings(other), usMotorSettings(other),
    m_elementSpacingX(other.getElementSpacingX()), m_elementSpacingY(other.getElementSpacingY()),
    m_elementSpacingZ(other.getElementSpacingZ()), m_scanLineDepth(other.getScanLineDepth())
{
}
 
template <class Type>
usImagePostScan3D<Type>::usImagePostScan3D(const usImage3D<Type> &image, const usTransducerSettings &transducerSettings,
                                           const usMotorSettings &motorSettings, double spacingX, double spacingY,
                                           double spacingZ, double scanLineDepth)
  : usImage3D<Type>(image), usTransducerSettings(transducerSettings), usMotorSettings(motorSettings),
    m_elementSpacingX(spacingX), m_elementSpacingY(spacingY), m_elementSpacingZ(spacingZ),
    m_scanLineDepth(scanLineDepth)
{
}
 
template <class Type> usImagePostScan3D<Type>::~usImagePostScan3D() {}
 
template <class Type> usImagePostScan3D<Type> &usImagePostScan3D<Type>::operator=(const usImagePostScan3D<Type> &other)
{
  // from usImage3D
  usImage3D<Type>::operator=(other);
 
  // from settings
  usTransducerSettings::operator=(other);
  usMotorSettings::operator=(other);
 
  // from this class
  m_elementSpacingX = other.getElementSpacingX();
  m_elementSpacingY = other.getElementSpacingY();
  m_elementSpacingZ = other.getElementSpacingZ();
  m_scanLineDepth = other.getScanLineDepth();
 
  return *this;
}
 
template <class Type> bool usImagePostScan3D<Type>::operator==(usImagePostScan3D<Type> const &other)
{
  return usImage3D<Type>::operator==(other) && usTransducerSettings::operator==(other) &&
         usMotorSettings::operator==(other) && m_elementSpacingX == other.getElementSpacingX() &&
         m_elementSpacingY == other.getElementSpacingY() && m_elementSpacingZ == other.getElementSpacingZ() &&
         m_scanLineDepth == other.getScanLineDepth();
}
 
template <class Type> std::ostream &operator<<(std::ostream &out, const usImagePostScan3D<Type> &other)
{
  return out << static_cast<const usImage3D<Type> &>(other) << static_cast<const usTransducerSettings &>(other)
             << static_cast<const usMotorSettings &>(other) << "spacingX = " << other.getElementSpacingX() << std::endl
             << "spacingY = " << other.getElementSpacingY() << std::endl
             << "spacingZ = " << other.getElementSpacingZ() << std::endl
             << "scan line depth = " << other.getScanLineDepth() << std::endl;
}
 
template <class Type> void usImagePostScan3D<Type>::setData(const usImage3D<Type> &image3D)
{
  usImage3D<Type>::operator=(image3D);
}
 
template <class Type> double usImagePostScan3D<Type>::getElementSpacingX() const { return m_elementSpacingX; }
 
template <class Type> double usImagePostScan3D<Type>::getElementSpacingY() const { return m_elementSpacingY; }
 
template <class Type> double usImagePostScan3D<Type>::getElementSpacingZ() const { return m_elementSpacingZ; }
 
template <class Type> double usImagePostScan3D<Type>::getScanLineDepth() const { return m_scanLineDepth; }
 
template <class Type> void usImagePostScan3D<Type>::setElementSpacingX(double elementSpacingX)
{
  m_elementSpacingX = elementSpacingX;
}
 
template <class Type> void usImagePostScan3D<Type>::setElementSpacingY(double elementSpacingY)
{
  m_elementSpacingY = elementSpacingY;
}
 
template <class Type> void usImagePostScan3D<Type>::setElementSpacingZ(double elementSpacingZ)
{
  m_elementSpacingZ = elementSpacingZ;
}
 
template <class Type> void usImagePostScan3D<Type>::setScanLineDepth(double scanLineDepth)
{
  m_scanLineDepth = scanLineDepth;
}
 
#endif // __usImagePostScan3D_h_