Area3D.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Area3D.h"
 
#include <algorithm>
 
#include <QObject>
#include <QString>
 
#include "Displacement.h"
#include "Distance.h"
#include "IException.h"
#include "IString.h"
 
namespace Isis {
  Area3D::Area3D() {
    nullTheData();
  }
  Area3D::Area3D() {…}
 

  Area3D::Area3D(const Displacement &startX, const Displacement &startY,
                 const Displacement &startZ,
                 const Distance &width, const Distance &height,
                 const Distance &depth) {
    nullTheData();
    setArea(startX, startY, startZ,
            startX + width, startY + height, startZ + depth);
  }
  Area3D::Area3D(const Displacement &startX, const Displacement &startY, {…}
 

  Area3D::Area3D(const Displacement &startX, const Displacement &startY,
                 const Displacement &startZ,
                 const Displacement &endX, const Displacement &endY,
                 const Displacement &endZ) {
    nullTheData();
    setArea(startX, startY, startZ, endX, endY, endZ);
  }
  Area3D::Area3D(const Displacement &startX, const Displacement &startY, {…}
 

  Area3D::Area3D(const Area3D &areaToCopy) {
    nullTheData();
 
    if(areaToCopy.m_startX) {
      m_startX = new Displacement(*areaToCopy.m_startX);
    }
 
    if(areaToCopy.m_startY) {
      m_startY = new Displacement(*areaToCopy.m_startY);
    }
 
    if(areaToCopy.m_startZ) {
      m_startZ = new Displacement(*areaToCopy.m_startZ);
    }
 
    if(areaToCopy.m_endX) {
      m_endX = new Displacement(*areaToCopy.m_endX);
    }
 
    if(areaToCopy.m_endY) {
      m_endY = new Displacement(*areaToCopy.m_endY);
    }
 
    if(areaToCopy.m_endZ) {
      m_endZ = new Displacement(*areaToCopy.m_endZ);
    }
  }
  Area3D::Area3D(const Area3D &areaToCopy) {…}
 

  Area3D::~Area3D() {
    deleteTheData();
  }
  Area3D::~Area3D() {…}
 

  Displacement Area3D::getStartX() const {
    Displacement startX;
 
    if(m_startX)
      startX = *m_startX;
 
    return startX;
  }
  Displacement Area3D::getStartX() const  {…}
 

  Displacement Area3D::getStartY() const {
    Displacement startY;
 
    if(m_startY)
      startY = *m_startY;
 
    return startY;
  }
  Displacement Area3D::getStartY() const  {…}
 

  Displacement Area3D::getStartZ() const {
    Displacement startZ;
 
    if(m_startZ)
      startZ = *m_startZ;
 
    return startZ;
  }
  Displacement Area3D::getStartZ() const  {…}
 

  Distance Area3D::getWidth() const {
    return Distance(
        (getEndX() - getStartX()).meters(),
        Distance::Meters);
  }
  Distance Area3D::getWidth() const  {…}
 

  Distance Area3D::getHeight() const {
    return Distance(
        (getEndY() - getStartY()).meters(),
        Distance::Meters);
  }
  Distance Area3D::getHeight() const  {…}
 

  Distance Area3D::getDepth() const {
    return Distance(
        (getEndZ() - getStartZ()).meters(),
        Distance::Meters);
  }
  Distance Area3D::getDepth() const  {…}
 

  Displacement Area3D::getEndX() const {
    Displacement endX;
 
    if(m_endX)
      endX = *m_endX;
 
    return endX;
  }
  Displacement Area3D::getEndX() const  {…}
 

  Displacement Area3D::getEndY() const {
    Displacement endY;
 
    if(m_endY)
      endY = *m_endY;
 
    return endY;
  }
  Displacement Area3D::getEndY() const  {…}
 

  Displacement Area3D::getEndZ() const {
    Displacement endZ;
 
    if(m_endZ)
      endZ = *m_endZ;
 
    return endZ;
  }
  Displacement Area3D::getEndZ() const  {…}
 

  void Area3D::setStartX(const Displacement &startX) {
    setArea(startX, getStartY(), getStartZ(),
            getEndX(), getEndY(), getEndZ());
  }
  void Area3D::setStartX(const Displacement &startX) {…}
 

  void Area3D::setStartY(const Displacement &startY) {
    setArea(getStartX(), startY, getStartZ(),
            getEndX(), getEndY(), getEndZ());
  }
  void Area3D::setStartY(const Displacement &startY) {…}
 

  void Area3D::setStartZ(const Displacement &startZ) {
    setArea(getStartX(), getStartY(), startZ,
            getEndX(), getEndY(), getEndZ());
  }
  void Area3D::setStartZ(const Displacement &startZ) {…}
 

  void Area3D::moveStartX(const Displacement &startX) {
    setArea(startX, getStartY(), getStartZ(),
            getEndX() + (startX - getStartX()), getEndY(), getEndZ());
  }
  void Area3D::moveStartX(const Displacement &startX) {…}
 

  void Area3D::moveStartY(const Displacement &startY) {
    setArea(getStartX(), startY, getStartZ(),
            getEndX(), getEndY() + (startY - getStartY()), getEndZ());
  }
  void Area3D::moveStartY(const Displacement &startY) {…}
 

  void Area3D::moveStartZ(const Displacement &startZ) {
    setArea(getStartX(), getStartY(), startZ,
            getEndX(), getEndY(), getEndZ() + (startZ - getStartZ()));
  }
  void Area3D::moveStartZ(const Displacement &startZ) {…}
 

  void Area3D::setWidth(const Distance &width) {
    setArea(getStartX(), getStartY(), getStartZ(),
            getStartX() + width, getEndY(), getEndZ());
  }
  void Area3D::setWidth(const Distance &width) {…}
 

  void Area3D::setHeight(const Distance &height) {
    setArea(getStartX(), getStartY(), getStartZ(),
            getEndX(), getStartY() + height, getEndZ());
  }
  void Area3D::setHeight(const Distance &height) {…}
 

  void Area3D::setDepth(const Distance &depth) {
    setArea(getStartX(), getStartY(), getStartZ(),
            getEndX(), getEndY(), getStartZ() + depth);
  }
  void Area3D::setDepth(const Distance &depth) {…}
 

  void Area3D::setEndX(const Displacement &endX) {
    setArea(getStartX(), getStartY(), getStartZ(),
            endX, getEndY(), getEndZ());
  }
  void Area3D::setEndX(const Displacement &endX) {…}
 

  void Area3D::setEndY(const Displacement &endY) {
    setArea(getStartX(), getStartY(), getStartZ(),
            getEndX(), endY, getEndZ());
  }
  void Area3D::setEndY(const Displacement &endY) {…}
 

  void Area3D::setEndZ(const Displacement &endZ) {
    setArea(getStartX(), getStartY(), getStartZ(),
            getEndX(), getEndY(), endZ);
  }
  void Area3D::setEndZ(const Displacement &endZ) {…}
 

  void Area3D::moveEndX(const Displacement &endX) {
    setArea(getStartX() + (endX - getEndX()), getStartY(), getStartZ(),
            endX, getEndY(), getEndZ());
  }
  void Area3D::moveEndX(const Displacement &endX) {…}
 

  void Area3D::moveEndY(const Displacement &endY) {
    setArea(getStartX(), getStartY() + (endY - getEndY()), getStartZ(),
            getEndX(), endY, getEndZ());
  }
  void Area3D::moveEndY(const Displacement &endY) {…}
 

  void Area3D::moveEndZ(const Displacement &endZ) {
    setArea(getStartX(), getStartY(), getStartZ() + (endZ - getEndZ()),
            getEndX(), getEndY(), endZ);
  }
  void Area3D::moveEndZ(const Displacement &endZ) {…}
 

  void Area3D::setXDimension(const Displacement &startX,
                             const Distance &width) {
    setArea(startX, getStartY(), getStartZ(),
            startX + width, getEndY(), getEndZ());
  }
  void Area3D::setXDimension(const Displacement &startX, {…}
 

  void Area3D::setYDimension(const Displacement &startY,
                             const Distance &height) {
    setArea(getStartX(), startY, getStartZ(),
            getEndX(), startY + height, getEndZ());
  }
  void Area3D::setYDimension(const Displacement &startY, {…}
 

  void Area3D::setZDimension(const Displacement &startZ,
                             const Distance &depth) {
    setArea(getStartX(), getStartY(), startZ,
            getEndX(), getEndY(), startZ + depth);
  }
  void Area3D::setZDimension(const Displacement &startZ, {…}
 

  Area3D Area3D::intersect(const Area3D &otherArea) const {
    Area3D result;
 
    // Check validity because of comparison operators.
    if (isValid() && otherArea.isValid()) {
      Displacement startX(std::max(getStartX(), otherArea.getStartX()));
      Displacement startY(std::max(getStartY(), otherArea.getStartY()));
      Displacement startZ(std::max(getStartZ(), otherArea.getStartZ()));
      Displacement endX(std::min(getEndX(), otherArea.getEndX()));
      Displacement endY(std::min(getEndY(), otherArea.getEndY()));
      Displacement endZ(std::min(getEndZ(), otherArea.getEndZ()));
 
 
      if (startX <= endX && startY <= endY && startZ <= endZ)
        result = Area3D(startX, startY, startZ, endX, endY, endZ);
    }
 
    return result;
  }
  Area3D Area3D::intersect(const Area3D &otherArea) const  {…}
 

  bool Area3D::isValid() const {
    bool valid = true;
 
    if(!m_startX)
      valid = false;
    else if(!m_startY)
      valid = false;
    else if(!m_startZ)
      valid = false;
    else if(!m_endX)
      valid = false;
    else if(!m_endY)
      valid = false;
    else if(!m_endZ)
      valid = false;
 
    return valid;
  }
  bool Area3D::isValid() const  {…}
 

  bool Area3D::operator ==(const Area3D &otherArea) const {
    return getStartX() == otherArea.getStartX() &&
            getStartY() == otherArea.getStartY() &&
            getStartZ() == otherArea.getStartZ() &&
            getEndX() == otherArea.getEndX() &&
            getEndY() == otherArea.getEndY() &&
            getEndZ() == otherArea.getEndZ();
  }
  bool Area3D::operator ==(const Area3D &otherArea) const  {…}
 

  bool Area3D::operator !=(const Area3D &otherArea) const {
    return !(*this == otherArea);
  }
  bool Area3D::operator !=(const Area3D &otherArea) const  {…}
 

  Area3D &Area3D::operator =(const Area3D &areaToCopy) {
    deleteTheData();
 
    if(areaToCopy.m_startX) {
      m_startX = new Displacement(*areaToCopy.m_startX);
    }
 
    if(areaToCopy.m_startY) {
      m_startY = new Displacement(*areaToCopy.m_startY);
    }
 
    if(areaToCopy.m_startZ) {
      m_startZ = new Displacement(*areaToCopy.m_startZ);
    }
 
    if(areaToCopy.m_endX) {
      m_endX = new Displacement(*areaToCopy.m_endX);
    }
 
    if(areaToCopy.m_endY) {
      m_endY = new Displacement(*areaToCopy.m_endY);
    }
 
    if(areaToCopy.m_endZ) {
      m_endZ = new Displacement(*areaToCopy.m_endZ);
    }
 
    return *this;
  }
  Area3D &Area3D::operator =(const Area3D &areaToCopy) {…}
 

  void Area3D::setArea(const Displacement &startX,
      const Displacement &startY, const Displacement &startZ,
      const Displacement &endX, const Displacement &endY,
      const Displacement &endZ) {
    bool startXValid = startX.isValid();
    bool endXValid = endX.isValid();
    bool startYValid = startY.isValid();
    bool endYValid = endY.isValid();
    bool startZValid = startZ.isValid();
    bool endZValid = endZ.isValid();
 
    deleteTheData();
 
    // Optimized for success.
    if(startXValid && startYValid && startZValid && endXValid && endYValid &&
       endZValid && startX <= endX && startY <= endY && startZ <= endZ) {
      m_startX = new Displacement(startX);
      m_startY = new Displacement(startY);
      m_startZ = new Displacement(startZ);
      m_endX = new Displacement(endX);
      m_endY = new Displacement(endY);
      m_endZ = new Displacement(endZ);
    }
    else {
      if(startXValid && endXValid && startX > endX) {
        QString msg = QObject::tr("Cannot have a 3D area with inverted X coordinates of "
                                  "[%1 meters] to [%2 meters]")
                        .arg(startX.meters()).arg(endX.meters());
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
 
      if(startYValid && endYValid && startY > endY) {
        QString msg = QObject::tr("Cannot have a 3D area with inverted Y coordinates of "
                                  "[%1 meters] to [%2 meters]")
                        .arg(startY.meters()).arg(endY.meters());
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
 
      if(startZValid && endZValid && startZ > endZ) {
        QString msg = QObject::tr("Cannot have a 3D area with inverted Z coordinates of "
                                  "[%1 meters] to [%2 meters]")
                        .arg(startZ.meters()).arg(endZ.meters());
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
 
      if(startXValid)
        m_startX = new Displacement(startX);
 
      if(startYValid)
        m_startY = new Displacement(startY);
 
      if(startZValid)
        m_startZ = new Displacement(startZ);
 
      if(endXValid)
        m_endX = new Displacement(endX);
 
      if(endYValid)
        m_endY = new Displacement(endY);
 
      if(endZValid)
        m_endZ = new Displacement(endZ);
    }
  }
  void Area3D::setArea(const Displacement &startX, {…}
 

  void Area3D::deleteTheData() {
    if(m_startX) {
      delete m_startX;
      m_startX = NULL;
    }
 
    if(m_startY) {
      delete m_startY;
      m_startY = NULL;
    }
 
    if(m_startZ) {
      delete m_startZ;
      m_startZ = NULL;
    }
 
    if(m_endX) {
      delete m_endX;
      m_endX = NULL;
    }
 
    if(m_endY) {
      delete m_endY;
      m_endY = NULL;
    }
 
    if(m_endZ) {
      delete m_endZ;
      m_endZ = NULL;
    }
  }
  void Area3D::deleteTheData() {…}
 

  void Area3D::nullTheData() {
    m_startX = NULL;
    m_startY = NULL;
    m_startZ = NULL;
    m_endX = NULL;
    m_endY = NULL;
    m_endZ = NULL;
  }
  void Area3D::nullTheData() {…}
}