pattern/parallelepiped.hpp

Go to the documentation of this file.

#ifndef MSMAZES_CORE_PATTERN_PARALLELEPIPED_HPP
#define MSMAZES_CORE_PATTERN_PARALLELEPIPED_HPP

#define MSMAZES_CORE_PATTERN_ARITY 9

// BOOST_ASSERT
#include <boost/assert.hpp>
// std::floor
#include <cmath>
// BOOST_STATIC_CONSTANT
#include <boost/config.hpp>
// BOOST_PP_LESS
#include <boost/preprocessor/comparison/less.hpp>
// boost::mpl::true_ and boost::mpl::false_
#include <boost/mpl/bool.hpp>
// boost::is_same
#include <boost/type_traits/is_same.hpp>
// sgdk::Pi
#include <swiss_gd_knife/zref/pi.hpp>
// sgdk::Tangent
#include <swiss_gd_knife/zref/tangent.hpp>
// sgdk::ZeroChecker
#include <swiss_gd_knife/math/zero_checker.hpp>
// sgdk::Compass, sgdk::ZeroDirection and, sgdk::PositiveRotation
#include <swiss_gd_knife/math/geom/compass.hpp>
// Boost.Parameter keyword objects used by the Core Pattern class templates
#include <msmazes/core/pattern/keywords.hpp>

#if BOOST_PP_LESS(BOOST_PARAMETER_MAX_ARITY, MSMAZES_CORE_PATTERN_ARITY)
#error Set BOOST_PARAMETER_MAX_ARITY to 9 or higher.
#endif

// msmazes::TesselationFormerGenerator and msmazes::PhysicalPattern
#include <msmazes/core/pattern/physical.hpp>
// MSMAZES_CORE_PATTERN_TESSELATION_FORMER_TYPE
#include <msmazes/core/pattern/tesselation_former_type.hpp>

namespace msmazes {
  namespace _detail {

    struct OrthogonalParallelepipedTag
    {
    };

    template <
        typename PatternType
    >
    struct OrthogonalParallelepipedTesselationFormer
    {
        typedef PatternType
                Pattern;
        typedef OrthogonalParallelepipedTag
                tag;
        typedef OrthogonalParallelepipedTesselationFormer
                type;

     private:
        typedef typename Pattern::Cell
                Cell;
        typedef typename Pattern::Coordinate
                Coordinate;

     public:
        BOOST_STATIC_CONSTANT(bool, MAKES_3D_TESSELATION = true);

        template <
            typename ArgumentPack
        >
        static typename Pattern::CellIndex
            countCells(
                const ArgumentPack& p
            )
        {
            const Cell& min = p[init_cell_minimum_arg];
            const Cell& max = p[init_cell_maximum_arg];
            const Cell& inc = p[init_cell_increment_arg];

            Coordinate                  x, y, z;
            typename Pattern::CellIndex cell_count = 0;

            for (
                z = min[2];
                z <= max[2];
                z += inc[2]
            )
            {
                for (
                    y = min[1];
                    y <= max[1];
                    y += inc[1]
                )
                {
                    for (
                        x = min[0];
                        x <= max[0];
                        x += inc[0]
                    )
                    {
                        ++cell_count;
                    }
                }
            }

            return cell_count;
        }

        template <
            typename OutputIterator
          , typename ArgumentPack
        >
        static void
            makeCells(
                OutputIterator cell_iterator
              , const ArgumentPack& p
            )
        {
            const Cell& min = p[init_cell_minimum_arg];
            const Cell& max = p[init_cell_maximum_arg];
            const Cell& inc = p[init_cell_increment_arg];

            Cell cell(3);

            for (
                cell[2] = min[2];
                cell[2] <= max[2];
                cell[2] += inc[2]
            )
            {
                for (
                    cell[1] = min[1];
                    cell[1] <= max[1];
                    cell[1] += inc[1]
                )
                {
                    for (
                        cell[0] = min[0];
                        cell[0] <= max[0];
                        cell[0] += inc[0]
                    )
                    {
                        *cell_iterator = cell;
                        ++cell_iterator;
                    }
                }
            }
        }

        template <
            typename ArgumentPack
        >
        static bool
            isLegalEdge(
                const typename Pattern::Cell& source
              , const typename Pattern::Cell& target
              , const ArgumentPack& p
            )
        {
            const Cell&      inc = p[init_cell_increment_arg];
            const Coordinate dx  = target[0] - source[0];
            const Coordinate dy  = target[1] - source[1];
            const Coordinate dz  = target[2] - source[2];

            sgdk::ZeroChecker<Coordinate>
                zero_checker(p[init_zero_tolerance_arg | 0.00001]);

            return
                zero_checker.isZero(dx - inc[0])
             && zero_checker.isZero(dy)
             && zero_checker.isZero(dz)
             || zero_checker.isZero(dy - inc[1])
             && zero_checker.isZero(dx)
             && zero_checker.isZero(dz)
             || zero_checker.isZero(dz - inc[2])
             && zero_checker.isZero(dx)
             && zero_checker.isZero(dy);
        }
    };
  }  // namespace _detail

struct OrthogonalTesselationSelector
{
};

template <>
struct TesselationFormerGenerator<OrthogonalTesselationSelector>
{
    template <typename Pattern>
    struct apply
    {
        typedef typename _detail::OrthogonalParallelepipedTesselationFormer<
                    Pattern
                >::type
                type;
    };
};

  namespace _detail {

    template <typename Coordinate>
    class Upsilon2DIncrement
    {
     private:
        Coordinate _distance;
        Coordinate _z;

     public:
        Upsilon2DIncrement(const Coordinate distance, const Coordinate z_inc)
          : _distance(distance), _z(z_inc)
        {
        }

        Coordinate getOctagonSquareCellCenterDistance() const
        {
            return _distance;
        }

        Coordinate getZIncrement() const
        {
            return _z;
        }
    };

    template <typename Coordinate>
    class UpsilonOctagonSquareCellCenterDistance
    {
     private:
        Coordinate _distance;

     public:
        explicit UpsilonOctagonSquareCellCenterDistance(
            const Coordinate distance
        ) : _distance(distance)
        {
        }

        Upsilon2DIncrement<Coordinate>
            setZIncrement(
                const Coordinate z_increment
            ) const
        {
            return Upsilon2DIncrement<Coordinate>(_distance, z_increment);
        }
    };

    template <typename Coordinate>
    class UpsilonZIncrement
    {
     private:
        Coordinate _z;

     public:
        explicit UpsilonZIncrement(const Coordinate z_increment)
          : _z(z_increment)
        {
        }

        Upsilon2DIncrement<Coordinate>
            setOctagonSquareCellCenterDistance(
                const Coordinate distance
            ) const
        {
            return Upsilon2DIncrement<Coordinate>(distance, _z);
        }
    };
  }  // namespace _detail

template <typename Coordinate>
_detail::UpsilonOctagonSquareCellCenterDistance<Coordinate>
    setOctagonSquareCellCenterDistance(
        const Coordinate distance
    )
{
    return _detail::UpsilonOctagonSquareCellCenterDistance<Coordinate>(
        distance
    );
}

template <typename Coordinate>
_detail::UpsilonZIncrement<Coordinate>
    setZIncrement(
        const Coordinate z_increment
    )
{
    return _detail::UpsilonZIncrement<Coordinate>(
        z_increment
    );
}

  namespace _detail {

    struct Upsilon2DParallelepipedTag
    {
    };

    template <
        typename PatternType
      , typename BooleanConstantHasOctagonMinCorner
    >
    struct Upsilon2DParallelepipedTesselationFormer
    {
        typedef PatternType
                Pattern;
        typedef Upsilon2DParallelepipedTag
                tag;
        typedef Upsilon2DParallelepipedTesselationFormer
                type;

     private:
        typedef typename Pattern::Cell
                Cell;
        typedef typename Pattern::Coordinate
                Coordinate;
        typedef Upsilon2DIncrement<Coordinate>
                Increment;

     public:
        BOOST_STATIC_CONSTANT(bool, MAKES_3D_TESSELATION = false);

        template <
            typename ArgumentPack
        >
        static typename Pattern::CellIndex
            countCells(
                const ArgumentPack& p
            )
        {
            const Cell&
                min = p[init_cell_minimum_arg];
            const Cell&
                max = p[init_cell_maximum_arg];
            const Increment&
                inc = p[init_cell_increment_arg];
            const Coordinate
                w_inc = inc.getOctagonSquareCellCenterDistance();
            const Coordinate
                z_inc = inc.getZIncrement();

            Coordinate                  x, y, z;
            typename Pattern::CellIndex cell_count = 0;

            for (
                z = min[2];
                z <= max[2];
                z += z_inc
            )
            {
                for (
                    y = min[1];
                    y <= max[1];
                    y += w_inc
                )
                {
                    for (
                        x = min[0];
                        x <= max[0];
                        x += w_inc
                    )
                    {
                        ++cell_count;
                    }
                }
            }

            return cell_count;
        }

        template <
            typename OutputIterator
          , typename ArgumentPack
        >
        static void
            makeCells(
                OutputIterator cell_iterator
              , const ArgumentPack& p
            )
        {
            const Cell&
                min = p[init_cell_minimum_arg];
            const Cell&
                max = p[init_cell_maximum_arg];
            const Increment&
                inc = p[init_cell_increment_arg];
            const Coordinate
                w_inc = inc.getOctagonSquareCellCenterDistance();
            const Coordinate
                z_inc = inc.getZIncrement();

            Cell cell(3);

            for (
                cell[2] = min[2];
                cell[2] <= max[2];
                cell[2] += z_inc
            )
            {
                for (
                    cell[1] = min[1];
                    cell[1] <= max[1];
                    cell[1] += w_inc
                )
                {
                    for (
                        cell[0] = min[0];
                        cell[0] <= max[0];
                        cell[0] += w_inc
                    )
                    {
                        *cell_iterator = cell;
                        ++cell_iterator;
                    }
                }
            }
        }

        template <
            typename ArgumentPack
        >
        static bool
            isLegalEdge(
                const typename Pattern::Cell& source
              , const typename Pattern::Cell& target
              , const ArgumentPack& p
            )
        {
            const Cell&
                min = p[init_cell_minimum_arg];
            const Increment&
                inc = p[init_cell_increment_arg];
            const Coordinate
                w_inc = inc.getOctagonSquareCellCenterDistance();
            const Coordinate
                z_inc = inc.getZIncrement();
            const Coordinate
                dx = target[0] - source[0];
            const Coordinate
                dy = target[1] - source[1];
            const Coordinate
                dz = target[2] - source[2];

            sgdk::ZeroChecker<Coordinate>
                zero_checker(p[init_zero_tolerance_arg | 0.00001]);

            if (zero_checker.isZero(dx - w_inc))
            {
                if (zero_checker.isZero(dy))
                {
                    return zero_checker.isZero(dz);
                }
                else if (
                    zero_checker.isZero(dz)
                 && (
                        zero_checker.isZero(dy + w_inc)
                     || zero_checker.isZero(dy - w_inc)
                    )
                )
                {
                    return
                        BooleanConstantHasOctagonMinCorner::value
                     == (
                            (
                                static_cast<int>(
                                    std::floor(
                                        (
                                            (source[0] - min[0])
                                          - (source[1] - min[1])
                                        )
                                      / w_inc
                                      + source[1]
                                      + 0.5
                                    )
                                )
                              & 1
                            )
                         != 0
                        );
                }
                else
                {
                    return false;
                }
            }
            else if (zero_checker.isZero(dx))
            {
                if (zero_checker.isZero(dy))
                {
                    return zero_checker.isZero(dz - z_inc);
                }
                else if (zero_checker.isZero(dy - w_inc))
                {
                    return zero_checker.isZero(dz);
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
    };
  }  // namespace _detail

struct UpsilonOctagonMinCornerTesselationSelector
{
};

template <>
struct TesselationFormerGenerator<UpsilonOctagonMinCornerTesselationSelector>
{
    template <typename Pattern>
    struct apply
    {
        typedef typename _detail::Upsilon2DParallelepipedTesselationFormer<
                    Pattern
                  , boost::mpl::true_
                >::type
                type;
    };
};

struct UpsilonSquareMinCornerTesselationSelector
{
};

template <>
struct TesselationFormerGenerator<UpsilonSquareMinCornerTesselationSelector>
{
    template <typename Pattern>
    struct apply
    {
        typedef typename _detail::Upsilon2DParallelepipedTesselationFormer<
                    Pattern
                  , boost::mpl::false_
                >::type
                type;
    };
};

  namespace _detail {

    struct CubicGridParallelepipedTag
    {
    };

    template <
        typename PatternType
      , typename BooleanConstantHas26SidedSolidMinCorner
    >
    struct Upsilon3DParallelepipedTesselationFormer
    {
        typedef PatternType
                Pattern;
        typedef CubicGridParallelepipedTag
                tag;
        typedef Upsilon3DParallelepipedTesselationFormer
                type;

     private:
        typedef typename Pattern::Cell
                Cell;
        typedef typename Pattern::Coordinate
                Coordinate;

     public:
        BOOST_STATIC_CONSTANT(bool, MAKES_3D_TESSELATION = true);

        template <
            typename ArgumentPack
        >
        static typename Pattern::CellIndex
            countCells(
                const ArgumentPack& p
            )
        {
            const Cell&      min = p[init_cell_minimum_arg];
            const Cell&      max = p[init_cell_maximum_arg];
            const Coordinate inc = p[init_cell_increment_arg];

            Coordinate                  x, y, z;
            typename Pattern::CellIndex cell_count = 0;

            for (
                z = min[2];
                z <= max[2];
                z += inc
            )
            {
                for (
                    y = min[1];
                    y <= max[1];
                    y += inc
                )
                {
                    for (
                        x = min[0];
                        x <= max[0];
                        x += inc
                    )
                    {
                        ++cell_count;
                    }
                }
            }

            return cell_count;
        }

        template <
            typename OutputIterator
          , typename ArgumentPack
        >
        static void
            makeCells(
                OutputIterator cell_iterator
              , const ArgumentPack& p
            )
        {
            const Cell&      min = p[init_cell_minimum_arg];
            const Cell&      max = p[init_cell_maximum_arg];
            const Coordinate inc = p[init_cell_increment_arg];

            Cell cell(3);

            for (
                cell[2] = min[2];
                cell[2] <= max[2];
                cell[2] += inc
            )
            {
                for (
                    cell[1] = min[1];
                    cell[1] <= max[1];
                    cell[1] += inc
                )
                {
                    for (
                        cell[0] = min[0];
                        cell[0] <= max[0];
                        cell[0] += inc
                    )
                    {
                        *cell_iterator = cell;
                        ++cell_iterator;
                    }
                }
            }
        }

        template <
            typename ArgumentPack
        >
        static bool
            isLegalEdge(
                const typename Pattern::Cell& source
              , const typename Pattern::Cell& target
              , const ArgumentPack& p
            )
        {
            const Cell&      min = p[init_cell_minimum_arg];
            const Coordinate inc = p[init_cell_increment_arg];
            const Coordinate dx  = target[0] - source[0];
            const Coordinate dy  = target[1] - source[1];
            const Coordinate dz  = target[2] - source[2];

            sgdk::ZeroChecker<Coordinate>
                zero_checker(p[init_zero_tolerance_arg | 0.00001]);

            if (zero_checker.isZero(dx - inc))
            {
                if (zero_checker.isZero(dy))
                {
                    if (zero_checker.isZero(dz))
                    {
                        return true;
                    }
                    else if (
                        BooleanConstantHas26SidedSolidMinCorner::value
                     == (
                            (
                                static_cast<int>(
                                    std::floor(
                                        (
                                            (source[0] - min[0])
                                          + (source[1] - min[1])
                                          + (source[2] - min[2])
                                        )
                                      / inc
                                      + 0.5
                                    )
                                )
                              & 1
                            )
                         == 0
                        )
                    )
                    {
                        return
                            zero_checker.isZero(dz + inc)
                         || zero_checker.isZero(dz - inc);
                    }
                    else
                    {
                        return false;
                    }
                }
                else if (
                    zero_checker.isZero(dz)
                 && (
                        zero_checker.isZero(dy + inc)
                     || zero_checker.isZero(dy - inc)
                    )
                )
                {
                    return
                        BooleanConstantHas26SidedSolidMinCorner::value
                     == (
                            (
                                static_cast<int>(
                                    std::floor(
                                        (
                                            (source[0] - min[0])
                                          - (source[1] - min[1])
                                          + (source[2] - min[2])
                                        )
                                      / inc
                                      + source[1]
                                      + 0.5
                                    )
                                )
                              & 1
                            )
                         != 0
                        );
                }
                else
                {
                    return false;
                }
            }
            else if (zero_checker.isZero(dx))
            {
                if (zero_checker.isZero(dy))
                {
                    return zero_checker.isZero(dz - inc);
                }
                else if (zero_checker.isZero(dy - inc))
                {
                    if (zero_checker.isZero(dz))
                    {
                        return true;
                    }
                    else if (
                        BooleanConstantHas26SidedSolidMinCorner::value
                     == (
                            (
                                static_cast<int>(
                                    std::floor(
                                        (
                                            (source[0] - min[0])
                                          + (source[1] - min[1])
                                          + (source[2] - min[2])
                                        )
                                      / inc
                                      + 0.5
                                    )
                                )
                              & 1
                            )
                         == 0
                        )
                    )
                    {
                        return
                            zero_checker.isZero(dz + inc)
                         || zero_checker.isZero(dz - inc);
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
    };
  }  // namespace _detail

struct Upsilon26SidedSolidMinCornerTesselationSelector
{
};

template <>
struct TesselationFormerGenerator<
    Upsilon26SidedSolidMinCornerTesselationSelector
>
{
    template <typename Pattern>
    struct apply
    {
        typedef typename _detail::Upsilon3DParallelepipedTesselationFormer<
                    Pattern
                  , boost::mpl::true_
                >::type
                type;
    };
};

struct UpsilonCubeMinCornerTesselationSelector
{
};

template <>
struct TesselationFormerGenerator<UpsilonCubeMinCornerTesselationSelector>
{
    template <typename Pattern>
    struct apply
    {
        typedef typename _detail::Upsilon3DParallelepipedTesselationFormer<
                    Pattern
                  , boost::mpl::false_
                >::type
                type;
    };
};

  namespace _detail {

    template <
        typename PatternType
    >
    struct ZetaTesselationFormer
    {
        typedef PatternType
                Pattern;
        typedef CubicGridParallelepipedTag
                tag;
        typedef ZetaTesselationFormer
                type;

     private:
        typedef typename Pattern::Cell
                Cell;
        typedef typename Pattern::Coordinate
                Coordinate;

     public:
        BOOST_STATIC_CONSTANT(bool, MAKES_3D_TESSELATION = true);

        template <
            typename ArgumentPack
        >
        static typename Pattern::CellIndex
            countCells(
                const ArgumentPack& p
            )
        {
            const Cell&      min = p[init_cell_minimum_arg];
            const Cell&      max = p[init_cell_maximum_arg];
            const Coordinate inc = p[init_cell_increment_arg];

            Coordinate                  x, y, z;
            typename Pattern::CellIndex cell_count = 0;

            for (
                z = min[2];
                z <= max[2];
                z += inc
            )
            {
                for (
                    y = min[1];
                    y <= max[1];
                    y += inc
                )
                {
                    for (
                        x = min[0];
                        x <= max[0];
                        x += inc
                    )
                    {
                        ++cell_count;
                    }
                }
            }

            return cell_count;
        }

        template <
            typename OutputIterator
          , typename ArgumentPack
        >
        static void
            makeCells(
                OutputIterator cell_iterator
              , const ArgumentPack& p
            )
        {
            const Cell&      min = p[init_cell_minimum_arg];
            const Cell&      max = p[init_cell_maximum_arg];
            const Coordinate inc = p[init_cell_increment_arg];

            Cell cell(3);

            for (
                cell[2] = min[2];
                cell[2] <= max[2];
                cell[2] += inc
            )
            {
                for (
                    cell[1] = min[1];
                    cell[1] <= max[1];
                    cell[1] += inc
                )
                {
                    for (
                        cell[0] = min[0];
                        cell[0] <= max[0];
                        cell[0] += inc
                    )
                    {
                        *cell_iterator = cell;
                        ++cell_iterator;
                    }
                }
            }
        }

        template <
            typename ArgumentPack
        >
        static bool
            isLegalEdge(
                const typename Pattern::Cell& source
              , const typename Pattern::Cell& target
              , const ArgumentPack& p
            )
        {
        

            const Coordinate inc = p[init_cell_increment_arg];
            const Coordinate dx  = target[0] - source[0];
            const Coordinate dy  = target[1] - source[1];
            const Coordinate dz  = target[2] - source[2];

            sgdk::ZeroChecker<Coordinate>
                zero_checker(p[init_zero_tolerance_arg | 0.00001]);

            return
                zero_checker.isZero(dz - inc)
             && (
                    (
                        zero_checker.isZero(dx)
                     || zero_checker.isZero(dx - inc)
                    )
                 && (
                        zero_checker.isZero(dy)
                     || zero_checker.isZero(dy - inc)
                    )
                 || zero_checker.isZero(dx - inc)
                 && zero_checker.isZero(dy + inc)
                 || zero_checker.isZero(dx + inc)
                 && zero_checker.isZero(dy - inc)
                )
             || zero_checker.isZero(dz + inc)
             && (
                    zero_checker.isZero(dy - inc)
                 && (
                        zero_checker.isZero(dx - inc)
                     || zero_checker.isZero(dx)
                    )
                 || zero_checker.isZero(dx - inc)
                 && zero_checker.isZero(dy)
                )
             || zero_checker.isZero(dz)
             && (
                    zero_checker.isZero(dy - inc)
                 && (
                        zero_checker.isZero(dx - inc)
                     || zero_checker.isZero(dx)
                    )
                 || zero_checker.isZero(dx - inc)
                 && (
                        zero_checker.isZero(dy)
                     || zero_checker.isZero(dy + inc)
                    )
                );
        }
    };
  }  // namespace _detail

struct ZetaTesselationSelector
{
};

template <>
struct TesselationFormerGenerator<ZetaTesselationSelector>
{
    template <typename Pattern>
    struct apply
    {
        typedef typename _detail::ZetaTesselationFormer<
                    Pattern
                >::type
                type;
    };
};

  namespace _parallelepiped {

    struct parameters
      : boost::parameter::parameters<
            boost::parameter::required<
                keyword_tag::init_tesselation_selector_arg
            >
          , boost::parameter::required<
                keyword_tag::init_cell_minimum_arg
            >
          , boost::parameter::required<
                keyword_tag::init_cell_maximum_arg
            >
          , boost::parameter::required<
                keyword_tag::init_cell_increment_arg
            >
          , boost::parameter::required<
                keyword_tag::init_entrance_cell_arg
            >
          , boost::parameter::required<
                keyword_tag::init_exit_cell_arg
            >
          , boost::parameter::optional<
                keyword_tag::init_zero_direction_arg
            >
          , boost::parameter::optional<
                keyword_tag::init_positive_rotation_arg
            >
          , boost::parameter::optional<
                keyword_tag::init_zero_tolerance_arg
            >
        >
    {
    };
  }  // namespace _parallelepiped


template <
#ifndef MSMAZES_DOX
    typename DirectionType = unsigned int
  , typename DirectionChangeType = int
  , typename CellContainerSelector = boost::vecS
  , typename PiConstant = sgdk::Pi
  , typename TangentFunction = sgdk::Tangent
#endif  /* MSMAZES_DOX */
>
class Parallelepiped
#ifndef MSMAZES_DOX
  : public PhysicalPattern<
               typename TangentFunction::result_type
             , DirectionType
             , DirectionChangeType
             , CellContainerSelector
           >
#endif  /* MSMAZES_DOX */
{
#ifndef MSMAZES_DOX
 private:
    typedef PhysicalPattern<
                typename TangentFunction::result_type
              , DirectionType
              , DirectionChangeType
              , CellContainerSelector
            >
            ParentPattern;
#endif  /* MSMAZES_DOX */

 public:
#ifdef MSMAZES_DOX
    typedef implementation_defined Cell;
#else
    typedef typename ParentPattern::Cell
            Cell;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined Coordinate;
#else
    typedef typename ParentPattern::Coordinate
            Coordinate;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined CellEqualityPolicy;
#else
    typedef typename ParentPattern::CellEqualityPolicy
            CellEqualityPolicy;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined Graph;
#else
    typedef typename ParentPattern::Graph
            Graph;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined CellIndex;
#else
    typedef typename ParentPattern::CellIndex
            CellIndex;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined EdgeDirectedCategory;
#else
    typedef typename ParentPattern::EdgeDirectedCategory
            EdgeDirectedCategory;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined Direction;
#else
    typedef typename ParentPattern::Direction
            Direction;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined DirectionChange;
#else
    typedef typename ParentPattern::DirectionChange
            DirectionChange;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined OutDegree;
#else
    typedef typename ParentPattern::OutDegree
            OutDegree;
#endif  /* MSMAZES_DOX */

#ifdef MSMAZES_DOX
    typedef implementation_defined HasIndexableEndpointCells;
#else
    typedef typename ParentPattern::HasIndexableEndpointCells
            HasIndexableEndpointCells;
#endif  /* MSMAZES_DOX */

 private:
    typedef Parallelepiped
            type;
    typedef sgdk::Compass<Direction,DirectionChange,PiConstant,TangentFunction>
            Compass;

    bool                          _is_3d;
    bool                          _is_not_3d_tesselation;
    bool                          _is_zeta;
    OutDegree                     _max_3d_out_degree;
    Compass                       _xy_compass;
    Compass                       _xz_compass;
    Compass                       _yz_compass;
    sgdk::ZeroDirection           _zero_direction;
    sgdk::PositiveRotation        _positive_rotation;
    sgdk::ZeroChecker<Coordinate> _zero_checker;

    Parallelepiped(const type& copy)
    {
    }

 public:

    Parallelepiped()
      : ParentPattern()
      , _is_3d(false)
      , _is_not_3d_tesselation(false)
      , _is_zeta(false)
      , _max_3d_out_degree()
      , _xy_compass()
      , _xz_compass()
      , _yz_compass()
      , _zero_direction(sgdk::ZeroDirection::POSITIVE_Y_AXIS)
      , _positive_rotation(sgdk::PositiveRotation::CLOCKWISE)
      , _zero_checker(0.00001)
    {
    }


    virtual ~Parallelepiped()
    {
    }

    static Cell
        createCell(
            const Coordinate x
          , const Coordinate y
          , const Coordinate z
        )
    {
        return ParentPattern::createCell(x, y, z);
    }

    static Cell
        createCellIncrement(
            const Coordinate x
          , const Coordinate y
          , const Coordinate z
        )
    {
        return ParentPattern::createCell(x, y, z);
    }

 private:
    template <
        typename ArgumentPack
    >
    void
        _initializeFromTesselationFormer(
            const _detail::OrthogonalParallelepipedTag& tag
          , const ArgumentPack& p
        )
    {
        const Cell& min = p[init_cell_minimum_arg];
        const Cell& max = p[init_cell_maximum_arg];
        const Cell& inc = p[init_cell_increment_arg];

        BOOST_ASSERT(
            (
                (min[2] < max[2])
             || _zero_checker.isZero(max[2] - min[2])
            )
         && "The z coordinates of your bounds are out of order."
        );
        BOOST_ASSERT(
            (0.0 < inc[0])
         && !_zero_checker.isZero(inc[0])
         && "How long is this pattern along the x axis?"
        );
        BOOST_ASSERT(
            (0.0 < inc[1])
         && !_zero_checker.isZero(inc[1])
         && "How long is this pattern along the y axis?"
        );
        BOOST_ASSERT(
            (0.0 < inc[2])
         && !_zero_checker.isZero(inc[2])
         && "How long is this pattern along the z axis?"
        );

        const Coordinate endpoint_x_maximum = max[0] - inc[0];
        const Coordinate endpoint_x_minimum = min[0] + inc[0];
        const Coordinate endpoint_y_maximum = max[1] - inc[1];
        const Coordinate endpoint_y_minimum = min[1] + inc[1];

        BOOST_ASSERT(
            (
                (endpoint_x_minimum < endpoint_x_maximum)
             || _zero_checker.isZero(
                    endpoint_x_maximum - endpoint_x_minimum
                )
            )
         && "The x coordinates of your bounds are out of order."
        );
        BOOST_ASSERT(
            (
                (endpoint_y_minimum < endpoint_y_maximum)
             || _zero_checker.isZero(
                    endpoint_y_maximum - endpoint_y_minimum
                )
            )
         && "The y coordinates of your bounds are out of order."
        );

        _xy_compass.setDirectionCount(4);
        _xz_compass.setDirectionCount(4);
        _yz_compass.setDirectionCount(4);
        _max_3d_out_degree = 6;

        _is_3d
          = (min[2] + inc[2] < max[2])
         || _zero_checker.isZero(max[2] - min[2] - inc[2]);
    }

    template <
        typename ArgumentPack
    >
    void
        _initializeFromTesselationFormer(
            const _detail::Upsilon2DParallelepipedTag& tag
          , const ArgumentPack& p
        )
    {
        const Cell&
            min = p[init_cell_minimum_arg];
        const Cell&
            max = p[init_cell_maximum_arg];
        const _detail::Upsilon2DIncrement<Coordinate>&
            inc = p[init_cell_increment_arg];
        const Coordinate
            w_inc = inc.getOctagonSquareCellCenterDistance();
        const Coordinate
            z_inc = inc.getZIncrement();

        BOOST_ASSERT(
            (
                (min[2] < max[2])
             || _zero_checker.isZero(max[2] - min[2])
            )
         && "The z coordinates of your bounds are out of order."
        );
        BOOST_ASSERT(
            (0.0 < w_inc)
         && !_zero_checker.isZero(w_inc)
         && "How long is this pattern along the x and y axes?"
        );
        BOOST_ASSERT(
            (0.0 < z_inc)
         && !_zero_checker.isZero(z_inc)
         && "How long is this pattern along the z axis?"
        );

        const Coordinate endpoint_x_maximum = max[0] - w_inc;
        const Coordinate endpoint_x_minimum = min[0] + w_inc;
        const Coordinate endpoint_y_maximum = max[1] - w_inc;
        const Coordinate endpoint_y_minimum = min[1] + w_inc;

        BOOST_ASSERT(
            (
                (endpoint_x_minimum < endpoint_x_maximum)
             || _zero_checker.isZero(
                    endpoint_x_maximum - endpoint_x_minimum
                )
            )
         && "The x coordinates of your bounds are out of order."
        );
        BOOST_ASSERT(
            (
                (endpoint_y_minimum < endpoint_y_maximum)
             || _zero_checker.isZero(
                    endpoint_y_maximum - endpoint_y_minimum
                )
            )
         && "The y coordinates of your bounds are out of order."
        );

        _xy_compass.setDirectionCount(8);
        _xz_compass.setDirectionCount(8);
        _yz_compass.setDirectionCount(8);

        _max_3d_out_degree = 10;
        _is_3d
          = (min[2] + z_inc < max[2])
         || _zero_checker.isZero(max[2] - min[2] - z_inc);
    }

    template <
        typename ArgumentPack
    >
    void
        _initializeFromTesselationFormer(
            const _detail::CubicGridParallelepipedTag& tag
          , const ArgumentPack& p
        )
    {
        const Cell&      min = p[init_cell_minimum_arg];
        const Cell&      max = p[init_cell_maximum_arg];
        const Coordinate inc = p[init_cell_increment_arg];

        BOOST_ASSERT(
            (
                (min[2] < max[2])
             || _zero_checker.isZero(max[2] - min[2])
            )
         && "The z coordinates of your bounds are out of order."
        );
        BOOST_ASSERT(
            (0.0 < inc)
         && !_zero_checker.isZero(inc)
         && "How long is this pattern along the x, y, and z axes?"
        );

        const Coordinate endpoint_x_maximum = max[0] - inc;
        const Coordinate endpoint_x_minimum = min[0] + inc;
        const Coordinate endpoint_y_maximum = max[1] - inc;
        const Coordinate endpoint_y_minimum = min[1] + inc;

        BOOST_ASSERT(
            (
                (endpoint_x_minimum < endpoint_x_maximum)
             || _zero_checker.isZero(
                    endpoint_x_maximum - endpoint_x_minimum
                )
            )
         && "The x coordinates of your bounds are out of order."
        );
        BOOST_ASSERT(
            (
                (endpoint_y_minimum < endpoint_y_maximum)
             || _zero_checker.isZero(
                    endpoint_y_maximum - endpoint_y_minimum
                )
            )
         && "The y coordinates of your bounds are out of order."
        );

        _xy_compass.setDirectionCount(8);
        _xz_compass.setDirectionCount(8);
        _yz_compass.setDirectionCount(8);
        _max_3d_out_degree = _is_zeta ? 26 : 18;
        _is_3d
          = (min[2] + inc < max[2])
         || _zero_checker.isZero(max[2] - min[2] - inc);
    }

 public:
#ifdef MSMAZES_DOX

    template <typename TesselationSelector, typename Increment>
    void initialize(
        const TesselationSelector& init_tesselation_selector_arg
      , const Cell& init_cell_minimum_arg
      , const Cell& init_cell_maximum_arg
      , Increment init_cell_increment_arg
      , const Cell& init_entrance_cell_arg
      , const Cell& init_exit_cell_arg
      , const sgdk::ZeroDirection& init_zero_direction_arg
      , const sgdk::PositiveRotation& init_positive_rotation_arg
      , const Coordinate init_zero_tolerance_arg
    );

    template <typename Params>
    void initialize_with_named_params(Params& p)
#else
    BOOST_PARAMETER_MEMFUN(
        void
      , initialize
      , 6
      , MSMAZES_CORE_PATTERN_ARITY
      , _parallelepiped::parameters
    )
#endif  /* MSMAZES_DOX */
    {
        typedef MSMAZES_CORE_PATTERN_TESSELATION_FORMER_TYPE(Params, type)
                TesselationFormer;
        typedef typename TesselationFormer::tag
                Tag;

        _is_not_3d_tesselation
          = !TesselationFormer::MAKES_3D_TESSELATION;
        _is_zeta
          = boost::is_same<
                TesselationFormer
              , _detail::ZetaTesselationFormer<type>
            >::value;
        _zero_direction
          = p[init_zero_direction_arg | sgdk::ZeroDirection::POSITIVE_Y_AXIS];
        _positive_rotation
          = p[init_positive_rotation_arg | sgdk::PositiveRotation::CLOCKWISE];
        _zero_checker.setZeroTolerance(p[init_zero_tolerance_arg | 0.00001]);

        _xy_compass.setZeroDirection(_zero_direction);
        _initializeFromTesselationFormer(Tag(), p);
        ParentPattern::initializeWithTesselationFormer(TesselationFormer(), p);

        if (_zero_direction.isParallelToYAxis())
        {
            _xz_compass.setZeroDirection(sgdk::ZeroDirection::POSITIVE_Y_AXIS);
            _xz_compass.setPositiveRotation(_positive_rotation);

            if (_zero_direction.isPositive())
            {
                _yz_compass.setZeroDirection(
                    sgdk::ZeroDirection::POSITIVE_X_AXIS
                );
                _yz_compass.setPositiveRotation(
                    _positive_rotation.isClockwise()
                  ? sgdk::PositiveRotation::COUNTERCLOCKWISE
                  : sgdk::PositiveRotation::CLOCKWISE
                );
            }
            else
            {
                _yz_compass.setZeroDirection(
                    sgdk::ZeroDirection::NEGATIVE_X_AXIS
                );
                _yz_compass.setPositiveRotation(_positive_rotation);
            }
        }
        else// if (_zero_direction.isParallelToXAxis())
        {
            _yz_compass.setZeroDirection(sgdk::ZeroDirection::POSITIVE_Y_AXIS);
            _yz_compass.setPositiveRotation(_positive_rotation);

            if (_zero_direction.isPositive())
            {
                _xz_compass.setZeroDirection(
                    sgdk::ZeroDirection::POSITIVE_X_AXIS
                );
                _xz_compass.setPositiveRotation(
                    _positive_rotation.isClockwise()
                  ? sgdk::PositiveRotation::COUNTERCLOCKWISE
                  : sgdk::PositiveRotation::CLOCKWISE
                );
            }
            else
            {
                _xz_compass.setZeroDirection(
                    sgdk::ZeroDirection::NEGATIVE_X_AXIS
                );
                _xz_compass.setPositiveRotation(_positive_rotation);
            }
        }
    }

    inline const Graph& getGraph() const
    {
        return ParentPattern::getGraph();
    }

    inline CellIndex getCellCount() const
    {
        return ParentPattern::getCellCount();
    }

    inline const Cell& getCell(const CellIndex index) const
    {
        return ParentPattern::getCell(index);
    }

    inline const Cell& getEntranceCell() const
    {
        return ParentPattern::getEntranceCell();
    }

    inline const Cell& getSourceCell() const
    {
        return ParentPattern::getSourceCell();
    }

    inline const Cell& getTargetCell() const
    {
        return ParentPattern::getTargetCell();
    }

    inline const Cell& getExitCell() const
    {
        return ParentPattern::getExitCell();
    }

#ifndef MSMAZES_DOX
 protected:
    Direction
        getEdgeDirectionDerived(
            const Cell& source
          , const Cell& target
        ) const
    {
        const Coordinate dx = target[0] - source[0];
        const Coordinate dy = target[1] - source[1];
        const Coordinate dz = target[2] - source[2];

        if (_zero_checker.isZero(dz))
        {
            if (_zero_direction.isParallelToYAxis())
            {
                return _xy_compass.getDirection(dx, dy);
            }
            else// if (_zero_direction.isParallelToXAxis())
            {
                return _xy_compass.getDirection(dy, dx);
            }
        }
        else if (_is_zeta)
        {
            if (_zero_checker.isZero(dx) && _zero_checker.isZero(dy))
            {
                return (dz < 0.0) ? 25 : 16;
            }
            else if (_zero_direction.isParallelToYAxis())
            {
                return
                    _xy_compass.getDirection(dx, dy) + ((dz < 0.0) ? 17 : 8);
            }
            else// if (_zero_direction.isParallelToXAxis())
            {
                return
                    _xy_compass.getDirection(dy, dx) + ((dz < 0.0) ? 17 : 8);
            }
        }
        else// if (!_zero_checker.isZero(dz) && !_is_zeta)
        {
            const Direction
                direction_count = _xy_compass.getDirectionCount();

            if (_zero_direction.isParallelToYAxis())
            {
                if (_is_not_3d_tesselation)
                {
                    return
                        direction_count
                      + (
                            ((direction_count & 1) == 0)
                         && (
                                (
                                    _yz_compass.getDirection(dy, dz) 
                                  > (direction_count >> 1)
                                )
                             == _positive_rotation.isClockwise()
                            )
                          ? 0
                          : 1
                        );
                }
                else if (_zero_checker.isZero(dx))
                {
                    const Direction
                        direction = _yz_compass.getDirection(dy, dz);

                    return
                        direction
                      + direction_count
                      - (
                            ((direction_count & 1) == 0)
                         && (direction > (direction_count >> 1))
                          ? 2
                          : 1
                        );
                }
                else if ((direction_count & 3) == 0)
                {
                    const Direction
                        direction = _xz_compass.getDirection(dx, dz);

                    return
                        direction
                      + (direction_count << 1)
                      - (
                            (direction > (direction_count >> 1))
                          ? ((direction > ((direction_count * 3) >> 2)) ? 6 : 5)
                          : ((direction > (direction_count >> 2)) ? 4 : 3)
                        );
                }
                else
                {
                    return
                        _xz_compass.getDirection(dx, dz)
                      + (direction_count << 1)
                      - ((direction_count & 1) ? 1 : 2);
                }
            }
            else// if (_zero_direction.isParallelToXAxis())
            {
                if (_is_not_3d_tesselation)
                {
                    return
                        direction_count
                      + (
                            ((direction_count & 1) == 0)
                         && (
                                _xz_compass.getDirection(dx, dz)
                              > (direction_count >> 1)
                            )
                          ? 0
                          : 1
                        );
                }
                else if (_zero_checker.isZero(dy))
                {
                    const Direction
                        direction = _xz_compass.getDirection(dx, dz);

                    return
                        direction
                      + direction_count
                      - (
                            ((direction_count & 1) == 0)
                         && (direction > (direction_count >> 1))
                          ? 2
                          : 1
                        );
                }
                else if ((direction_count & 3) == 0)
                {
                    const Direction
                        direction = _yz_compass.getDirection(dy, dz);

                    return
                        direction
                      + (direction_count << 1)
                      - (
                            (direction > (direction_count >> 1))
                          ? ((direction > ((direction_count * 3) >> 2)) ? 6 : 5)
                          : ((direction > (direction_count >> 2)) ? 4 : 3)
                        );
                }
                else
                {
                    return
                        _yz_compass.getDirection(dy, dz)
                      + (direction_count << 1)
                      - ((direction_count & 1) ? 1 : 2);
                }
            }
        }
    }

    DirectionChange
        getYawTurnDerived(
            const Cell& source
          , const Cell& parent
          , const Cell& target
        ) const
    {
        const Coordinate dx1 = parent[0] - source[0];
        const Coordinate dy1 = parent[1] - source[1];

        if (_zero_checker.isZero(dx1) && _zero_checker.isZero(dy1))
        {
            return 0;
        }

        const Coordinate dx2 = target[0] - parent[0];
        const Coordinate dy2 = target[1] - parent[1];

        if (_zero_checker.isZero(dx2) && _zero_checker.isZero(dy2))
        {
            return 0;
        }

        return _xy_compass.getDirectionChange(dx1, dy1, dx2, dy2);
    }

    OutDegree getMaxOutDegreeDerived() const
    {
        if (_is_3d)
        {
            return _max_3d_out_degree;
        }
        else
        {
            return _xy_compass.getDirectionCount();
        }
    }

 public:
#endif  /* MSMAZES_DOX */

    Direction
        getEdgeDirection(
            const CellIndex source_index
          , const CellIndex target_index
        ) const
    {
        return ParentPattern::getEdgeDirection(source_index, target_index);
    }

    DirectionChange
        getYawTurn(
            const CellIndex source_index
          , const CellIndex parent_index
          , const CellIndex target_index
        ) const
    {
        return
            ParentPattern::getYawTurn(source_index, parent_index, target_index);
    }

    OutDegree getMaxOutDegree() const
    {
        return ParentPattern::getMaxOutDegree();
    }
};
}  // namespace msmazes

#undef MSMAZES_CORE_PATTERN_ARITY

#endif  /* MSMAZES_CORE_PATTERN_PARALLELEPIPED_HPP */

---

Multi-State Mazes in C++ is hosted by . Use the Table of Contents for navigation.