defines.h

/*
 This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
 
#pragma once
 
#include <type_traits> // std::true_type
 
#include "../Common/defines.h"
 
#define PONCA_EXPLICIT_CAST_OPERATORS(CLASSNAME,CONVERTER)                                                         \
                   \
PONCA_MULTIARCH inline                                                                                             \
CLASSNAME<DataPoint, _NFilter, T>& CONVERTER()                                                                    \
{ return * static_cast<CLASSNAME<DataPoint, _NFilter, T>*>(this); }                                               \
                   \
PONCA_MULTIARCH inline                                                                                             \
const CLASSNAME<DataPoint, _NFilter, T>& CONVERTER() const                                                        \
{ return * static_cast<const CLASSNAME<DataPoint, _NFilter, T>*>(this); }
 
// CAST OPERATORS
 
#define PONCA_EXPLICIT_CAST_OPERATORS_DER(CLASSNAME,CONVERTER)                                                     \
                   \
PONCA_MULTIARCH inline                                                                                             \
CLASSNAME<DataPoint, _NFilter, DiffType, T>& CONVERTER()                                                          \
{ return * static_cast<CLASSNAME<DataPoint, _NFilter, DiffType, T>*>(this); }                                     \
                   \
PONCA_MULTIARCH inline                                                                                             \
const CLASSNAME<DataPoint, _NFilter, DiffType, T>& CONVERTER() const                                              \
{ return * static_cast<const CLASSNAME<DataPoint, _NFilter, DiffType, T>*>(this); }
 
 
// FIT DEFAULT TYPES
 
#define PONCA_FITTING_DECLARE_DEFAULT_TYPES                                                                         \
protected:                                                                                                          \
using Base = T;                                                            \
public:                                                                                                             \
using Scalar         = typename DataPoint::Scalar;                                \
using VectorType     = typename Base::VectorType;                                 \
using NeighborFilter = typename Base::NeighborFilter; 
#define PONCA_FITTING_DECLARE_MATRIX_TYPE                                                                           \
public:                                                                                                             \
using MatrixType  = typename DataPoint::MatrixType;                               \
 
#define PONCA_FITTING_DECLARE_DEFAULT_DER_TYPES                                                                     \
public:                                                                                                             \
using ScalarArray = typename Base::ScalarArray;                     \
using VectorArray = typename Base::VectorArray;     
// FIT API DOCUMENTATION
#define PONCA_FITTING_APIDOC_SETWFUNC \
 
#define PONCA_FITTING_APIDOC_INIT \
 
#define PONCA_FITTING_APIDOC_ADDNEIGHBOR \
 
#define PONCA_FITTING_APIDOC_ADDNEIGHBOR_DER \
 
#define PONCA_FITTING_APIDOC_FINALIZE \
 
// FIT API DECLARATION
 
#define PONCA_FITTING_IS_SIGNED(IS_SIGNED)                                                                         \
                 \
PONCA_MULTIARCH inline                                                                                             \
constexpr bool isSigned() { return IS_SIGNED; }
 
#define PONCA_FITTING_DECLARE_INIT                                                                                 \
PONCA_FITTING_APIDOC_INIT                                                                                          \
PONCA_MULTIARCH inline void init ();
 
#define PONCA_FITTING_DECLARE_ADDNEIGHBOR                                                                          \
PONCA_FITTING_APIDOC_ADDNEIGHBOR                                                                                   \
PONCA_MULTIARCH inline bool addLocalNeighbor(Scalar w, const VectorType &localQ, const DataPoint &attributes);
 
#define PONCA_FITTING_DECLARE_ADDNEIGHBOR_DER                                                                      \
PONCA_FITTING_APIDOC_ADDNEIGHBOR_DER                                                                               \
PONCA_MULTIARCH inline bool                                                                                        \
addLocalNeighbor(Scalar w, const VectorType &localQ, const DataPoint &attributes, ScalarArray &dw);
 
#define PONCA_FITTING_DECLARE_FINALIZE                                                                             \
PONCA_FITTING_APIDOC_FINALIZE                                                                                      \
PONCA_MULTIARCH inline FIT_RESULT finalize();
 
#define PONCA_FITTING_DECLARE_INIT_ADD_FINALIZE                                                                    \
PONCA_FITTING_DECLARE_INIT                                                                                         \
PONCA_FITTING_DECLARE_ADDNEIGHBOR                                                                                  \
PONCA_FITTING_DECLARE_FINALIZE
 
#define PONCA_FITTING_DECLARE_INIT_ADDDER_FINALIZE                                                                 \
PONCA_FITTING_DECLARE_INIT                                                                                         \
PONCA_FITTING_DECLARE_ADDNEIGHBOR_DER                                                                              \
PONCA_FITTING_DECLARE_FINALIZE
 
namespace Ponca
{
    template <typename T, typename = void>
    struct hasFirstFundamentalForm : std::false_type {};
 
    template <typename T>
    struct hasFirstFundamentalForm<T, std::void_t<decltype(std::declval<T>().firstFundamentalForm())>> : std::true_type {};
 
} // namespace Ponca