poly_Quadtree.h

//-----------------------------------------------------------------------------
// Created on: 25 June 2021
//-----------------------------------------------------------------------------
// Copyright (c) 2021-present, Sergey Slyadnev
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright
//      notice, this list of conditions and the following disclaimer.
//    * Redistributions in binary form must reproduce the above copyright
//      notice, this list of conditions and the following disclaimer in the
//      documentation and/or other materials provided with the distribution.
//    * Neither the name of Sergey Slyadnev nor the
//      names of all contributors may be used to endorse or promote products
//      derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//-----------------------------------------------------------------------------
 
#ifndef poly_SVO_HeaderFile
#define poly_SVO_HeaderFile
 
// Poly includes
#include <mobius/poly.h>
 
// Core includes
#include <mobius/core_UV.h>
 
namespace mobius {
 
class poly_QuadtreeNode
{
public:
 
  mobiusPoly_EXPORT static bool
    IsValidCornerId(const size_t id);
 
  mobiusPoly_EXPORT static size_t
    GetCornerID(const size_t nx,
                const size_t ny);
 
  mobiusPoly_EXPORT static void
    GetCornerLocation(const size_t id,
                      size_t&      nx,
                      size_t&      ny);
 
public:
 
  mobiusPoly_EXPORT
    poly_QuadtreeNode();
 
  mobiusPoly_EXPORT
    poly_QuadtreeNode(const t_uv& cornerMin,
                      const t_uv& cornerMax);
 
  mobiusPoly_EXPORT
    ~poly_QuadtreeNode();
 
public:
 
  //mobiusPoly_EXPORT void
  //  Release();
 
  //mobiusPoly_EXPORT bool
  //  IsLeaf() const;
 
  //mobiusPoly_EXPORT bool
  //  Split();
 
  //mobiusPoly_EXPORT void
  //  SetChild(const size_t id, poly_SVO* pChild);
 
  //mobiusPoly_EXPORT poly_SVO*
  //  GetChild(const size_t id) const;
 
  //mobiusPoly_EXPORT poly_SVO*
  //  FindChild(const std::vector<size_t>& path) const;
 
  //mobiusPoly_EXPORT unsigned
  //  GetDepth0() const;
 
  //mobiusPoly_EXPORT double
  //  Eval(const t_xyz& P,
  //       const bool   bndOnly = false) const;
 
  //mobiusPoly_EXPORT unsigned long long
  //  GetMemoryInBytes(int& numNodes) const;
 
public:
 
  //const t_xyz& GetCornerMin() const
  //{
  //  return m_cornerMin;
  //}
 
  //void SetCornerMin(const t_xyz& P)
  //{
  //  m_cornerMin = P;
  //}
 
  //const t_xyz& GetCornerMax() const
  //{
  //  return m_cornerMax;
  //}
 
  //void SetCornerMax(const t_xyz& P)
  //{
  //  m_cornerMax = P;
  //}
 
  //const t_xyz& GetP0() const
  //{
  //  return m_cornerMin;
  //}
 
  //t_xyz GetP1() const
  //{
  //  return t_xyz( m_cornerMax.X(), m_cornerMin.Y(), m_cornerMin.Z() );
  //}
 
  //t_xyz GetP2() const
  //{
  //  return t_xyz( m_cornerMin.X(), m_cornerMax.Y(), m_cornerMin.Z() );
  //}
 
  //t_xyz GetP3() const
  //{
  //  return t_xyz( m_cornerMax.X(), m_cornerMax.Y(), m_cornerMin.Z() );
  //}
 
  //t_xyz GetP4() const
  //{
  //  return t_xyz( m_cornerMin.X(), m_cornerMin.Y(), m_cornerMax.Z() );
  //}
 
  //t_xyz GetP5() const
  //{
  //  return t_xyz( m_cornerMax.X(), m_cornerMin.Y(), m_cornerMax.Z() );
  //}
 
  //t_xyz GetP6() const
  //{
  //  return t_xyz( m_cornerMin.X(), m_cornerMax.Y(), m_cornerMax.Z() );
  //}
 
  //const t_xyz& GetP7() const
  //{
  //  return m_cornerMax;
  //}
 
  //double GetCellSize() const
  //{
  //  return (m_cornerMax - m_cornerMin).Modulus();
  //}
 
protected:
 
  /*mobiusPoly_EXPORT void
    getLeaves(const poly_SVO*               pNode,
              const int                     sm,
              std::vector<const poly_SVO*>& leaves) const;*/
 
protected:
 
  //poly_SVO** m_pChildren;  //!< Child octree nodes (8 bytes).
  //double     m_scalars[8]; //!< Stored scalar values (64 bytes).
 
  //  NOTICE: we store the corner points of each cell for convenience. It is
  //          not really necessary to have them here as the corners can be deduced
  //          from the root node if we know its dimensions. At the same time,
  //          we have found that the convenience of having the explicit corner
  //          points as a part of cell definition outweights the memory overheads.
  //*/
 
  //t_xyz m_cornerMin;  //!< Min corner of the SVO box.
  //t_xyz m_cornerMax;  //!< Max corner of the SVO box.
 
};
 
}
 
#endif