TrTriangulatorPoints.cpp

Go to the documentation of this file.

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

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

// 1. Precompiled header

// 2. My own header
#include <xmsgeom/triangulate/TrTriangulatorPoints.h>

// 3. Standard library headers

// 4. External library headers

// 5. Shared code headers
#include <xmscore/stl/vector.h>
#include <xmscore/misc/XmError.h>
#include <xmsgeom/geometry/geoms.h>
#include <xmscore/misc/Observer.h>
#include <xmsgeom/triangulate/triangles.h>

// 6. Non-shared code headers

//----- Forward declarations ---------------------------------------------------

//----- External globals -------------------------------------------------------

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

namespace xms
{
//----- Constants / Enumerations -----------------------------------------------

//----- Classes / Structs ------------------------------------------------------

//----- Internal functions -----------------------------------------------------

//----- Class / Function definitions -------------------------------------------

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
TrTriangulatorPoints::TrTriangulatorPoints(const VecPt3d& a_pts,
                                           VecInt& a_tris,
                                           VecInt2d* a_trisAdjToPts)
: m_pts(a_pts)
, m_idx(0)
, m_tris(a_tris)
, m_trisAdjToPts(a_trisAdjToPts)
, m_areaTol(-1)
, m_observer()
{
  UpdateAreaTolerance();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
TrTriangulatorPoints::~TrTriangulatorPoints()
{
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void TrTriangulatorPoints::SetObserver(BSHP<Observer> a_)
{
  m_observer = a_;
} // TrTriangulatorPoints::SetObserver
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int TrTriangulatorPoints::GetID() const
{
  return m_idx;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Pt3d TrTriangulatorPoints::GetLocation() const
{
  return m_pts[m_idx];
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int TrTriangulatorPoints::GetNPoints() const
{
  return (int)m_pts.size();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void TrTriangulatorPoints::IncrementPoint()
{
  ++m_idx;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void TrTriangulatorPoints::PrepareToReceiveTriangles()
{
  if (m_observer)
    m_observer->BeginOperationString("Triangulating Points");
  if (m_trisAdjToPts)
  {
    m_trisAdjToPts->resize(m_pts.size(), VecInt());
  }
} // TrTriangulatorPoints::PrepareToReceiveTriangles
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void TrTriangulatorPoints::FinalizeTriangulation()
{
  if (m_observer)
    m_observer->EndOperation();
  stShrinkCapacity(m_tris);
  if (m_trisAdjToPts)
  {
    stShrinkCapacity(*m_trisAdjToPts);
  }
} // TrTriangulatorPoints::FinalizeTriangulation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void TrTriangulatorPoints::ReceiveTriangle(int a_id1, int a_id2, int a_id3)
{
  // make sure the triangle has positive area
  double area = trArea(m_pts[a_id1 - 1], m_pts[a_id2 - 1], m_pts[a_id3 - 1]);
  if (area < m_areaTol)
  {
    return;
  }

  m_tris.push_back(a_id1 - 1);
  m_tris.push_back(a_id2 - 1);
  m_tris.push_back(a_id3 - 1);

  if (m_trisAdjToPts)
  {
    int triIdx = ((int)m_tris.size() / 3) - 1;
    (*m_trisAdjToPts)[a_id1 - 1].push_back(triIdx);
    (*m_trisAdjToPts)[a_id2 - 1].push_back(triIdx);
    (*m_trisAdjToPts)[a_id3 - 1].push_back(triIdx);
  }
  if (m_observer)
  {
    double prog = std::min(m_tris.size() / (double)(m_pts.size() * 2), 1.0);
    m_observer->ProgressStatus(prog);
  }
} // TrTriangulatorPoints::ReceiveTriangle
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void TrTriangulatorPoints::UpdateAreaTolerance()
{
  if (m_pts.empty())
    return;

  Pt3d ptMin(m_pts[0]), ptMax(m_pts[0]);
  for (const auto& p : m_pts)
    gmAddToExtents(p, ptMin, ptMax);
  m_areaTol = gmComputeXyTol(ptMin, ptMax);
  m_areaTol *= m_areaTol;
  m_areaTol *= 100;
} // TrTriangulatorPoints::UpdateAreaTolerance

} // namespace xms

#if CXX_TEST
// UNIT TESTS

#include <xmsgeom/triangulate/TrTriangulatorPoints.t.h>

#include <xmscore/testing/TestTools.h>
#include <xmsgeom/triangulate/detail/triangulate.h>

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

// namespace xms {
using namespace xms;

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void TrTriangulatorPointsUnitTests::test1()
{
  // 10-        3-----------4
  //   |       / \         / \
        //   |      /   \   2   /   \
        //   |     /     \     /     \
        //   |    /   0   \   /   1   \
        //   |   /         \ /         \
        //  0-  0-----------1-----------2
  //
  //      |-----|-----|-----|-----|
  //      0     5    10    15    20
  //
  // m_tris          =  3,0,1,  1,2,4,  1,4,3
  // m_trisAdjToPts  = [0][0,1,2][1][0,2][1,2]

  VecPt3d pts = {{0, 0, 0}, {10, 0, 0}, {20, 0, 0}, {5, 10, 0}, {15, 10, 0}};
  VecInt tris;
  VecInt2d trisAdjToPts;
  TrTriangulatorPoints client(pts, tris, &trisAdjToPts);
  trTriangulateIt(client);

  TS_ASSERT_EQUALS(tris.size(), 9);
  TS_ASSERT_EQUALS(tris[0], 3);
  TS_ASSERT_EQUALS(tris[1], 0);
  TS_ASSERT_EQUALS(tris[2], 1);
  TS_ASSERT_EQUALS(tris[3], 1);
  TS_ASSERT_EQUALS(tris[4], 2);
  TS_ASSERT_EQUALS(tris[5], 4);
  TS_ASSERT_EQUALS(tris[6], 1);
  TS_ASSERT_EQUALS(tris[7], 4);
  TS_ASSERT_EQUALS(tris[8], 3);

  TS_ASSERT_EQUALS(trisAdjToPts.size(), pts.size());
  TS_ASSERT_EQUALS((VecInt{0}), trisAdjToPts[0]);
  TS_ASSERT_EQUALS((VecInt{0, 1, 2}), trisAdjToPts[1]);
  TS_ASSERT_EQUALS((VecInt{1}), trisAdjToPts[2]);
  TS_ASSERT_EQUALS((VecInt{0, 2}), trisAdjToPts[3]);
  TS_ASSERT_EQUALS((VecInt{1, 2}), trisAdjToPts[4]);

} // TrTriangulatorPointsUnitTests::test1

  //} // namespace xms

#endif // CXX_TEST