shape.h

#pragma once

#ifndef SHAPE_H
#define SHAPE_H




#include "vector.h"

#include <vector>
#include <array>
#include <cmath>




/*==============================================================================
    Shape class
==============================================================================*/


template< typename t_Identifier >
struct Shape {

    t_Identifier const Inside( t_Identifier const& identifierDefault, Vector< double, 3 > const& position ) const;
    bool const Split( Vector< double, 3 > const& position, double const side ) const;


    void PushBall( t_Identifier const& identifier, Vector< double, 3 > const& center, double const radius, double const power );


private:

    struct Ball {

        t_Identifier identifier;

        Vector< double, 3 > center;
        double radius;
        double radiusPower;
        double power;
    };

    enum Comparison {

        COMPARISON_INSIDE,
        COMPARISON_OUTSIDE,
        COMPARISON_BOTH
    };


    static inline bool const IsInside( Ball const& ball, Vector< double, 3 > const& position );
    static inline Comparison const IsInside( Ball const& ball, Vector< double, 3 > const& position, double const side );


    std::vector< Ball > m_balls;
};




/*==============================================================================
    Shape methods
==============================================================================*/


template< typename t_Identifier >
t_Identifier const Shape< t_Identifier >::Inside( t_Identifier const& identifierDefault, Vector< double, 3 > const& position ) const {

    t_Identifier result = identifierDefault;

    typename std::vector< Ball >::const_iterator ii    = m_balls.begin();
    typename std::vector< Ball >::const_iterator iiEnd = m_balls.end();
    for ( ; ii != iiEnd; ++ii )
        if ( IsInside( *ii, position ) )
            result = ii->identifier;

    return result;
}


template< typename t_Identifier >
bool const Shape< t_Identifier >::Split( Vector< double, 3 > const& position, double const side ) const {

    bool split = false;
    {   typename std::vector< Ball >::const_iterator ii    = m_balls.begin();
        typename std::vector< Ball >::const_iterator iiEnd = m_balls.end();
        for ( ; ( ! split ) && ( ii != iiEnd ); ++ii )
            if ( IsInside( *ii, position, side ) == COMPARISON_BOTH )
                split = true;
    }
    return split;
}


template< typename t_Identifier >
void Shape< t_Identifier >::PushBall( t_Identifier const& identifier, Vector< double, 3 > const& center, double const radius, double const power ) {

    Ball ball;
    ball.identifier = identifier;
    ball.center = center;
    ball.radius = radius;
    ball.radiusPower = std::pow( radius, power );
    ball.power = power;

    m_balls.push_back( ball );
}


template< typename t_Identifier >
bool const Shape< t_Identifier >::IsInside( Ball const& ball, Vector< double, 3 > const& position ) {

    bool result = false;

    Vector< double, 3 > delta = std::abs( position - ball.center );
    if ( ( delta[ 0 ] < ball.radius ) && ( delta[ 1 ] < ball.radius ) && ( delta[ 2 ] < ball.radius ) ) {

        double const distance = std::pow( delta[ 0 ], ball.power ) + std::pow( delta[ 1 ], ball.power ) + std::pow( delta[ 2 ], ball.power );
        result = ( distance < ball.radiusPower );
    }

    return result;
}


template< typename t_Identifier >
typename Shape< t_Identifier >::Comparison const Shape< t_Identifier >::IsInside( Ball const& ball, Vector< double, 3 > const& position, double const side ) {

    Vector< double, 3 > minimumDelta = std::abs( position + side - ball.center );
    Vector< double, 3 > maximumDelta = std::abs( position - ball.center );

    if ( maximumDelta[ 0 ] < minimumDelta[ 0 ] )
        std::swap( maximumDelta[ 0 ], minimumDelta[ 0 ] );
    if ( ( ball.center[ 0 ] >= position[ 0 ] ) && ( ball.center[ 0 ] <= position[ 0 ] + side ) )
        minimumDelta[ 0 ] = 0;

    if ( maximumDelta[ 1 ] < minimumDelta[ 1 ] )
        std::swap( maximumDelta[ 1 ], minimumDelta[ 1 ] );
    if ( ( ball.center[ 1 ] >= position[ 1 ] ) && ( ball.center[ 1 ] <= position[ 1 ] + side ) )
        minimumDelta[ 1 ] = 0;

    if ( maximumDelta[ 2 ] < minimumDelta[ 2 ] )
        std::swap( maximumDelta[ 2 ], minimumDelta[ 2 ] );
    if ( ( ball.center[ 2 ] >= position[ 2 ] ) && ( ball.center[ 2 ] <= position[ 2 ] + side ) )
        minimumDelta[ 2 ] = 0;

    bool maximumInside = false;
    if ( ( maximumDelta[ 0 ] < ball.radius ) && ( maximumDelta[ 1 ] < ball.radius ) && ( maximumDelta[ 2 ] < ball.radius ) ) {

        double const distance = std::pow( maximumDelta[ 0 ], ball.power ) + std::pow( maximumDelta[ 1 ], ball.power ) + std::pow( maximumDelta[ 2 ], ball.power );
        maximumInside = ( distance < ball.radiusPower );
    }

    bool minimumInside = maximumInside;
    if ( ( ! minimumInside ) && ( minimumDelta[ 0 ] < ball.radius ) && ( minimumDelta[ 1 ] < ball.radius ) && ( minimumDelta[ 2 ] < ball.radius ) ) {

        double const distance = std::pow( minimumDelta[ 0 ], ball.power ) + std::pow( minimumDelta[ 1 ], ball.power ) + std::pow( minimumDelta[ 2 ], ball.power );
        minimumInside = ( distance < ball.radiusPower );
    }

    Comparison result = COMPARISON_BOTH;
    if ( maximumInside )
        result = COMPARISON_INSIDE;
    else if ( ! minimumInside )
        result = COMPARISON_OUTSIDE;
    return result;
}




#endif    // SHAPE_H