poly_SVO.h

//-----------------------------------------------------------------------------
// Created on: 10 December 2019
//-----------------------------------------------------------------------------
// Copyright (c) 2019-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_ScalarMembership.h>
 
// Core includes
#include <mobius/core_XYZ.h>
 
// Standard includes
#include <map>
 
namespace mobius {
 
class poly_SVO
{
public:
 
  struct Summary
  {
    int                   membership; 
    std::map<double, int> grains;     
 
    Summary() : membership(0) {} 
 
    mobiusPoly_EXPORT void
      AddCell(const double size);
 
    mobiusPoly_EXPORT void
      Dump(std::ostream& oss) const;
 
    mobiusPoly_EXPORT void
      DumpJSON(std::ostream& oss) const;
  };
 
public:
 
  mobiusPoly_EXPORT static bool
    IsValidCornerId(const size_t id);
 
  mobiusPoly_EXPORT static size_t
    GetCornerID(const size_t nx,
                const size_t ny,
                const size_t nz);
 
  mobiusPoly_EXPORT static void
    GetCornerLocation(const size_t id,
                      size_t&      nx,
                      size_t&      ny,
                      size_t&      nz);
 
public:
 
  mobiusPoly_EXPORT
    poly_SVO();
 
  mobiusPoly_EXPORT
    poly_SVO(const t_xyz& cornerMin,
             const t_xyz& cornerMax);
 
  mobiusPoly_EXPORT
    ~poly_SVO();
 
public:
 
  mobiusPoly_EXPORT void
    Release();
 
  mobiusPoly_EXPORT bool
    HasScalars();
 
  mobiusPoly_EXPORT void
    SetScalar(const size_t id,
              const double s);
 
  mobiusPoly_EXPORT double
    GetScalar(const size_t id) const;
 
  mobiusPoly_EXPORT bool
    IsLeaf() const;
 
  mobiusPoly_EXPORT void
    GetLeaves(std::vector<const poly_SVO*>& leaves,
              const int                     sm = ScalarMembership_OnInOut) const;
 
  mobiusPoly_EXPORT bool
    IsNegative() const;
 
  mobiusPoly_EXPORT bool
    IsPositive() const;
 
  mobiusPoly_EXPORT bool
    IsZeroCrossing() 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;
 
  mobiusPoly_EXPORT void
    CollectSummary(const int sm,
                   Summary&  summary) 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,
              std::vector<long long>&       depths,
              const long long               depth) const;
 
  mobiusPoly_EXPORT void
    getLeaves(const poly_SVO*               pNode,
              const int                     sm,
              std::vector<const poly_SVO*>& leaves) const;
 
protected:
 
  poly_SVO** m_pChildren;  
  double     m_scalars[8]; 
 
  /*
    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.
  */
 
  /* 48 bytes for corners */
  t_xyz m_cornerMin;  
  t_xyz m_cornerMax;  
 
};
 
}
 
#endif