GmExtents.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//----- Included files ---------------------------------------------------------

// 1. Precompiled header

// 2. My header
#include <xmsgrid/geometry/GmExtents.h>

// 3. Standard Library Headers

// 4. External Library Headers

// 5. Shared Headers
#include <boost/serialization/export.hpp>
#include <boost/serialization/vector.hpp>
#include <xmscore/math/math.h>
#include <xmscore/misc/XmConst.h>

// 6. Non-shared Headers

using namespace xms;

//----- Namespace declaration --------------------------------------------------

namespace xms
{
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents2d::GmExtents2d()
{
  Clear();
} // GmExtents2d::GmExtents2d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents2d::GmExtents2d(const GmExtents3d& a_extents)
{
  m_min = static_cast<Pt2d>(a_extents.GetMin());
  m_max = static_cast<Pt2d>(a_extents.GetMax());
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents2d::GmExtents2d(const Pt2d& a_min, const Pt2d& a_max)
: m_min(a_min)
, m_max(a_max)
{
} // GmExtents2d::GmExtents2d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents2d::GmExtents2d(const Pt3d& a_min, const Pt3d& a_max)
: m_min(a_min)
, m_max(a_max)
{
} // GmExtents2d::GmExtents2d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents2d::~GmExtents2d()
{
} // GmExtents2d::~GmExtents2d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents2d::operator+=(const GmExtents2d& a_rhs)
{
  m_min.x = std::min(m_min.y, a_rhs.m_min.x);
  m_max.x = std::max(m_max.x, a_rhs.m_max.x);
  m_min.y = std::min(m_min.y, a_rhs.m_min.y);
  m_max.y = std::max(m_max.y, a_rhs.m_max.y);
} // GmExtents2d::operator +=
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents2d::AddToExtents(const Pt3d& pt)
{
  Pt3d thePt(pt);

  m_min.x = std::min(m_min.x, thePt.x);
  m_max.x = std::max(m_max.x, thePt.x);
  m_min.y = std::min(m_min.y, thePt.y);
  m_max.y = std::max(m_max.y, thePt.y);
} // GmExtents2d::AddToExtents.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool GmExtents2d::IsValid()
{
  return (m_min.x <= m_max.x);
} // GmExtents2d::IsValid
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents2d::SetTolerance(double a_Tol)
{
  m_tolerance = a_Tol;
} // GmExtents2d::SetTolerance
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents2d::GetTolerance()
{
  return m_tolerance;
} // GmExtents2d::GetTolerance
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool GmExtents2d::Overlap(const GmExtents2d& a_b) const
{
  // We add (or subtract) the tolerance to our mins and maxs to get
  // modified boundaries
  Pt2d modMin = m_min - m_tolerance;
  Pt2d modMax = m_max + m_tolerance;

  if (a_b.m_min.x > modMax.x)
  {
    return false;
  }
  if (a_b.m_max.x < modMin.x)
  {
    return false;
  }
  if (a_b.m_min.y > modMax.y)
  {
    return false;
  }
  if (a_b.m_max.y < modMin.y)
  {
    return false;
  }
  return true;
} // GmExtents2d::Overlap
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents2d::Clear()
{
  m_min = XM_DBL_HIGHEST;
  m_max = XM_DBL_LOWEST;
} // GmExtents2d::Clear
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents2d::GetExtents(double* a_MinX, double* a_MaxX, double* a_MinY, double* a_MaxY)
{
  if (a_MinX)
  {
    *a_MinX = m_min.x;
  }
  if (a_MaxX)
  {
    *a_MaxX = m_max.x;
  }
  if (a_MinY)
  {
    *a_MinY = m_min.y;
  }
  if (a_MaxY)
  {
    *a_MaxY = m_max.y;
  }
} // GmExtents2d::GetExtents
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents2d::GetExtents(Pt3d& a_dMin, Pt3d& a_dMax)
{
  a_dMin = m_min;
  a_dMax = m_max;
} // GmExtents2d::GetExtents
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents2d::GetMinX() const
{
  return m_min.x;
} // GmExtents2d::GetMinX
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents2d::GetMaxX() const
{
  return m_max.x;
} // GmExtents2d::GetMaxX
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents2d::GetMinY() const
{
  return m_min.y;
} // GmExtents2d::GetMinY
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents2d::GetMaxY() const
{
  return m_max.y;
} // GmExtents2d::GetMaxY
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Pt2d GmExtents2d::GetMin() const
{
  return m_min;
} // GmExtents2d::GetMin
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Pt2d GmExtents2d::GetMax() const
{
  return m_max;
} // GmExtents2d::GetMax
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents2d::Set(const Pt2d& a_min, const Pt2d& a_max)
{
  m_min = a_min;
  m_max = a_max;
} // GmExtents2d::Set

double GmExtents2d::m_tolerance(0.0); 

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents3d::GmExtents3d()
{
  Clear();
} // GmExtents3d::GmExtents3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents3d::GmExtents3d(const Pt3d& a_min, const Pt3d& a_max)
: m_min(a_min)
, m_max(a_max)
{
} // GmExtents3d::GmExtents3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents3d::GmExtents3d(const Pt2d& a_min, const Pt2d& a_max)
: m_min(a_min)
, m_max(a_max)
{
} // GmExtents3d::GmExtents3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GmExtents3d::GmExtents3d(const GmExtents2d& a_extents)
{
  m_min = static_cast<Pt3d>(a_extents.GetMin());
  m_max = static_cast<Pt3d>(a_extents.GetMax());
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3d::operator+=(const GmExtents3d& a_rhs)
{
  m_min.x = std::min(m_min.x, a_rhs.m_min.x);
  m_max.x = std::max(m_max.x, a_rhs.m_max.x);
  m_min.y = std::min(m_min.y, a_rhs.m_min.y);
  m_max.y = std::max(m_max.y, a_rhs.m_max.y);
  m_min.z = std::min(m_min.z, a_rhs.m_min.z);
  m_max.z = std::max(m_max.z, a_rhs.m_max.z);
} // GmExtents3d::operator +=
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3d::AddToExtents(const Pt3d& pt)
{
  m_min.x = std::min(m_min.x, pt.x);
  m_max.x = std::max(m_max.x, pt.x);
  m_min.y = std::min(m_min.y, pt.y);
  m_max.y = std::max(m_max.y, pt.y);
  m_min.z = std::min(m_min.z, pt.z);
  m_max.z = std::max(m_max.z, pt.z);
} // GmExtents3d::AddToExtents
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool GmExtents3d::IsValid() const
{
  return (m_min.x <= m_max.x);
} // GmExtents3d::IsValid
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3d::SetTolerance(double a_Tol)
{
  m_tolerance = a_Tol;
} // GmExtents3d::SetTolerance
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents3d::GetTolerance()
{
  return m_tolerance;
} // GmExtents3d::GetTolerance
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool GmExtents3d::Overlap(GmExtents3d& a_b) const
{
  // We add (or subtract) the tolerance to our mins and maxs to get
  // modified boundaries
  Pt3d modMin = m_min - m_tolerance;
  Pt3d modMax = m_max + m_tolerance;

  if (a_b.m_min.x > modMax.x)
  {
    return false;
  }
  if (a_b.m_max.x < modMin.x)
  {
    return false;
  }
  if (a_b.m_min.y > modMax.y)
  {
    return false;
  }
  if (a_b.m_max.y < modMin.y)
  {
    return false;
  }
  if (a_b.m_min.z > modMax.z)
  {
    return false;
  }
  if (a_b.m_max.z < modMin.z)
  {
    return false;
  }
  return true;
} // GmExtents3d::Overlap
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3d::Clear()
{
  m_min = XM_DBL_HIGHEST;
  m_max = XM_DBL_LOWEST;
} // GmExtents3d::Clear
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool GmExtents3d::IsPointWithin(const Pt3d& pt) const
{
  return (m_min.x <= pt.x && m_max.x >= pt.x && m_min.y <= pt.y && m_max.y >= pt.y &&
          m_min.z <= pt.z && m_max.z >= pt.z);
} // GmExtents3d::IsPointWithin
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3d::GetExtents(double* a_MinX,
                             double* a_MaxX,
                             double* a_MinY,
                             double* a_MaxY,
                             double* a_MinZ,
                             double* a_MaxZ) const
{
  if (a_MinX)
  {
    *a_MinX = m_min.x;
  }
  if (a_MaxX)
  {
    *a_MaxX = m_max.x;
  }
  if (a_MinY)
  {
    *a_MinY = m_min.y;
  }
  if (a_MaxY)
  {
    *a_MaxY = m_max.y;
  }
  if (a_MinZ)
  {
    *a_MinZ = m_min.z;
  }
  if (a_MaxZ)
  {
    *a_MaxZ = m_max.z;
  }
} // GmExtents3d::GetExtents
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3d::GetExtents(Pt3d& a_dMin, Pt3d& a_dMax) const
{
  a_dMin = m_min;
  a_dMax = m_max;
} // GmExtents3d::GetExtents
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents3d::GetMinX() const
{
  return m_min.x;
} // GmExtents3d::GetMinX
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents3d::GetMaxX() const
{
  return m_max.x;
} // GmExtents3d::GetMaxX
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents3d::GetMinY() const
{
  return m_min.y;
} // GmExtents3d::GetMinY
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents3d::GetMaxY() const
{
  return m_max.y;
} // GmExtents3d::GetMaxY
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents3d::GetMinZ() const
{
  return m_min.z;
} // GmExtents3d::GetMinZ
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double GmExtents3d::GetMaxZ() const
{
  return m_max.z;
} // GmExtents3d::GetMaxZ
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Pt3d GmExtents3d::GetMin() const
{
  return m_min;
} // GmExtents3d::GetMin
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Pt3d GmExtents3d::GetMax() const
{
  return m_max;
} // GmExtents3d::GetMax
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3d::Set(const Pt3d& a_min, const Pt3d& a_max)
{
  m_min = a_min;
  m_max = a_max;
} // GmExtents3d::Set

double GmExtents3d::m_tolerance(1.0e-6); 

} // namespace xms

#ifdef CXX_TEST

#include <xmsgrid/geometry/GmExtents.t.h>

//----- Namespace declaration --------------------------------------------------

// namespace xms {
using namespace xms;

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3dUnitTests::testSinglePt()
{
  GmExtents3d e;

  Pt3d pt(50.0, 60.0, 80.0);

  e.AddToExtents(pt);

  TS_ASSERT(e.IsValid());
  const double kDelta = 0.000001;
  TS_ASSERT_DELTA(50.0, e.GetMinX(), kDelta);
  TS_ASSERT_DELTA(50.0, e.GetMaxX(), kDelta);
  TS_ASSERT_DELTA(60.0, e.GetMinY(), kDelta);
  TS_ASSERT_DELTA(60.0, e.GetMaxY(), kDelta);
  TS_ASSERT_DELTA(80.0, e.GetMinZ(), kDelta);
  TS_ASSERT_DELTA(80.0, e.GetMaxZ(), kDelta);
} // GmExtents3dUnitTests::testSinglePt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3dUnitTests::testMultiplePts()
{
  GmExtents3d e;

  Pt3d pt(50.0, 60.0, 80.0);

  e.AddToExtents(pt);

  pt.Set(100.0, 120.0, 160.0);
  e.AddToExtents(pt);
  pt.Set(200.0, -100.0, -200.0);
  e.AddToExtents(pt);

  TS_ASSERT(e.IsValid());
  const double kDelta = 0.000001;
  TS_ASSERT_DELTA(50.0, e.GetMinX(), kDelta);
  TS_ASSERT_DELTA(200.0, e.GetMaxX(), kDelta);
  TS_ASSERT_DELTA(-100.0, e.GetMinY(), kDelta);
  TS_ASSERT_DELTA(120.0, e.GetMaxY(), kDelta);
  TS_ASSERT_DELTA(-200.0, e.GetMinZ(), kDelta);
  TS_ASSERT_DELTA(160.0, e.GetMaxZ(), kDelta);
} // GmExtents3dUnitTests::testMultiplePts
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3dUnitTests::testNoPts()
{
  GmExtents3d e;

  TS_ASSERT(!e.IsValid());

} // GmExtents3dUnitTests::testNoPts
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void GmExtents3dUnitTests::testOverlapping()
{
  {
    GmExtents3d e, f;
    // x -100 to -50, y 50 to 100, z -25 to 25
    Pt3d pt(-100.0, 50.0, -25.0);
    e.AddToExtents(pt);
    pt.Set(-50.0, 100.0, -25.0);
    e.AddToExtents(pt);
    pt.Set(-50.0, 100.0, 25.0);
    e.AddToExtents(pt);

    // x -150 to -40, y 25 to 75, z -15 to 55
    pt.Set(-150.0, 30.0, 55.0);
    f.AddToExtents(pt);
    pt.Set(-50.0, 25.0, -5.0);
    f.AddToExtents(pt);
    pt.Set(-40.0, 75.0, -15.0);
    f.AddToExtents(pt);

    TS_ASSERT(e.IsValid());
    TS_ASSERT(f.IsValid());
    TS_ASSERT_EQUALS(e.Overlap(f), true);

    // x -550 to -101, y 101 to 251, z -125 to -26
    f.Clear();
    pt.Set(-101.0, 101.0, -125.0);
    f.AddToExtents(pt);
    pt.Set(-550.0, 182.0, -98.0);
    f.AddToExtents(pt);
    pt.Set(-150.0, 251.0, -26.0);
    f.AddToExtents(pt);

    TS_ASSERT_EQUALS(e.Overlap(f), false);

    // x -150 to -100+, y 50 to 100, z -25 to 25
    f.SetTolerance(0.01);
    f.Clear();
    pt.Set(-100.0 - 2 * f.GetTolerance(), 50.0, -25.0);
    f.AddToExtents(pt);
    pt.Set(-150.0, 100.0, -25.0);
    f.AddToExtents(pt);
    pt.Set(-150.0, 100.0, 25.0);
    f.AddToExtents(pt);

    TS_ASSERT_EQUALS(e.Overlap(f), false);
  }
  //--------------------------------------------------
  {
    GmExtents2d e, f;

    Pt3d pt(-100.0, 50.0, 0);
    e.AddToExtents(pt);
    pt.Set(-50.0, 100.0, 0);
    e.AddToExtents(pt);

    pt.Set(-150.0, 25.0, 0);
    f.AddToExtents(pt);
    pt.Set(-101.0, 75.0, 0);
    f.AddToExtents(pt);

    // x -100 to -50,  y 50 to 100
    // x -150 to -101, y 25 to 75
    //      X                    Y
    //          |-------|     |--------|
    // |-------|          |--------|
    TS_ASSERT(e.IsValid());
    TS_ASSERT(f.IsValid());
    TS_ASSERT_EQUALS(e.Overlap(f), false);

    f.Clear();
    pt.Set(-550.0, 251.0, 0);
    f.AddToExtents(pt);
    pt.Set(-101.0, 101.0, 0);
    f.AddToExtents(pt);

    // x -100 to -50,  y 50 to 100
    // x -550 to -101, y 101 to 251
    //      X                    Y
    //     |-------|    |--------|
    // |-------|                  |--------|
    TS_ASSERT_EQUALS(e.Overlap(f), false);

    // x -100 to -50,  y 50 to 100
    // x -150 to -100+, y -50 to 75
    //      X                    Y
    //          |-------|       |--------|
    // |-------|           |--------|
    f.Clear();
    pt.Set(-100.0 - 2 * f.GetTolerance(), -50.0, 0);
    f.AddToExtents(pt);
    pt.Set(-150.0, 75.0, 0);
    f.AddToExtents(pt);

    TS_ASSERT_EQUALS(e.Overlap(f), true);

    // x -100 to -50,  y  50 to 100
    // x -75 to -60,   y -50 to 75
    //      X                Y
    // |-----------|     |--------|
    //   |-------|     |------------|
    f.Clear();
    pt.Set(-75.0 - f.GetTolerance(), 25.0, 0);
    f.AddToExtents(pt);
    pt.Set(-60.0, 125.0, 0);
    f.AddToExtents(pt);

    TS_ASSERT_EQUALS(e.Overlap(f), true);
  }
} // GmExtents3dUnitTests::testOverlapping

  //} // namespace xms

#endif