renderer_detail_normal_mrf.h

#pragma once

#ifndef RENDERER_DETAIL_NORMAL_MRF_H
#define RENDERER_DETAIL_NORMAL_MRF_H




#include "vector.h"

#include <boost/shared_array.hpp>

#include <array>
#include <memory>




namespace Renderer {


namespace detail {




/*==============================================================================
    NormalMRF class
==============================================================================*/


struct NormalMRF {

    inline NormalMRF(
        boost::shared_array< float > const& depths,
        Vector< unsigned int, 2 > const dimension,    // width, height
        double const spread,
        double const voxelSize,
        double const observationPrecision,
        double const gradientPrecision,
        double const minimumEdgeDelta,
        double const maximumEdgeDelta,
        unsigned int const coarseness = 0
    );


    inline Vector< unsigned int, 2 > const& Dimension() const;


    inline void Refine();    // decrements coarseness

    inline void SmoothGlobal();    // smooth horizontally and vertically across the screen
    inline void SmoothLocal();     // smooth in a "checkboard" pattern

    inline unsigned int Coarseness() const;


    void CalculateNormals(
        Vector< float, 3 >* const normals,        // destination buffer
        Vector< double, 2 > const fieldOfView,    // horizontal, vertical size of image plane, with 1 = 90 degrees
        Vector< double, 3 > const xx,             // first column of camera matrix (assumed normalized)
        Vector< double, 3 > const yy,             // second column of camera matrix (assumed normalized)
        Vector< double, 3 > const zz              // third column of camera matrix (assumed normalized)
    );


private:

    typedef std::pair< double, Vector< double, 2 > > State;


    void SmoothHorizontal( bool const odd, bool const decreasing );
    void SmoothVertical(   bool const odd, bool const decreasing );
    void SmoothCardinalCheckerboard( bool const odd );
    void SmoothDiagonalCheckerboard( bool const odd );

    void InitializeStates();


    Vector< unsigned int, 2 > m_dimension;

    double m_spread;
    double m_voxelSize;
    double m_observationPrecision;
    double m_gradientPrecision;
    double m_minimumEdgeDelta;
    double m_maximumEdgeDelta;
    unsigned int m_coarseness;

    boost::shared_array< float > m_depths;
    std::unique_ptr< State[] > m_states;
};




/*==============================================================================
    NormalMRF methods
==============================================================================*/


NormalMRF::NormalMRF(
    boost::shared_array< float > const& depths,
    Vector< unsigned int, 2 > const dimension,
    double const spread,
    double const voxelSize,
    double const observationPrecision,
    double const gradientPrecision,
    double const minimumEdgeDelta,
    double const maximumEdgeDelta,
    unsigned int const coarseness
) :
    m_dimension( dimension ),
    m_spread(    spread    ),
    m_voxelSize( voxelSize ),
    m_observationPrecision( observationPrecision * Square( spread ) ),    // scale the observation precision by the spread, so that the parameters are independent of the screen resolution
    m_gradientPrecision(    gradientPrecision                       ),
    m_minimumEdgeDelta( minimumEdgeDelta ),
    m_maximumEdgeDelta( maximumEdgeDelta ),
    m_coarseness( coarseness ),
    m_depths( depths ),
    m_states( new State[ m_dimension.Product() ] )
{
    assert( ( m_dimension[ 0 ] > 0 ) && ( m_dimension[ 1 ] > 0 ) );

    assert( m_spread    > 0 );
    assert( m_voxelSize > 0 );
    assert( m_observationPrecision > 0 );
    assert( m_gradientPrecision    > 0 );
    assert( ( m_minimumEdgeDelta >= 0 ) && ( m_maximumEdgeDelta > m_minimumEdgeDelta ) );

    // make sure that the coarsest level is at least a 2x2 grid
    for ( ; ( m_coarseness > 0 ) && ( ( 1u << m_coarseness ) >= dimension.Minimum() ); --m_coarseness );

    InitializeStates();
}


Vector< unsigned int, 2 > const& NormalMRF::Dimension() const {

    return m_dimension;
}


void NormalMRF::Refine() {

    assert( m_coarseness > 0 );
    --m_coarseness;

    SmoothDiagonalCheckerboard( true );
    SmoothCardinalCheckerboard( true );
}


void NormalMRF::SmoothGlobal() {

    SmoothHorizontal( false, false );
    SmoothHorizontal( true,  true  );
    SmoothVertical(   false, false );
    SmoothVertical(   true,  true  );
    SmoothHorizontal( false, true  );
    SmoothHorizontal( true,  false );
    SmoothVertical(   false, true  );
    SmoothVertical(   true,  false );
}


void NormalMRF::SmoothLocal() {

    SmoothCardinalCheckerboard( false );
    SmoothCardinalCheckerboard( true  );
}


unsigned int NormalMRF::Coarseness() const {

    return m_coarseness;
}




}    // namespace detail


}    // namespace Renderer




#endif    // RENDERER_DETAIL_NORMAL_MRF_H