ppath_ac.h

Go to the documentation of this file.

/*
 * $Id: ppath_ac.h 17555 2014-09-18 07:36:52Z predoehl $
 */

#ifndef PPATH_AC_H_UOFARIZONAVISION
#define PPATH_AC_H_UOFARIZONAVISION 1

#include <qd_cpp/pixpath.h>

namespace kjb
{
namespace qd
{

class PixPathAc : public PixPath {

    mutable std::vector< float > arclen_cache;

    mutable bool arclen_valid;

    void refresh_the_cache_if_stale() const
    {
        if ( ! arclen_valid )
        {
            ETX( PixPath::arclength( &arclen_cache ) );
            arclen_valid = true;
        }
    }

protected:
    PixPathAc()
    :   PixPath(),
        arclen_valid( false )
    {}

    PixPathAc( size_t potential_size )
    :   PixPath( potential_size ),
        arclen_valid( false )
    {}

    PixPathAc( const std::string& fn )
    :   PixPath( fn ),
        arclen_valid( false )
    {}

public:
    PixPathAc( const PixPath& path )
    :   PixPath( path ),
        arclen_valid( false )
    {}

    static PixPathAc reserve( size_t potential_size = 0 )
    {
        return PixPathAc( potential_size );
    }


    PixPathAc& assign( unsigned index, const PixPoint& newp )
    {
        arclen_valid = false;
        PixPath::assign( index, newp );
        return *this;
    }

    void swap( PixPathAc& vpp )
    {
        PixPath::swap( vpp );
        arclen_cache.swap( vpp.arclen_cache );
        std::swap( arclen_valid, vpp.arclen_valid );
    }

    void push_back( const PixPoint& pp )
    {
        arclen_valid = false;
        PixPath::push_back( pp );
    }

    void clear()
    {
        arclen_valid = false;
        PixPath::clear();
    }

    PixPathAc& append( const_iterator begin, const_iterator end )
    {
        arclen_valid = false;
        PixPath::append( begin, end );
        return *this;
    }

    PixPathAc& append( const PixPath& suffix )  // PixPath input is adequate
    {
        arclen_valid = false;
        PixPath::append( suffix );
        return *this;
    }

    int append_no_overlap( const PixPath& suffix )
    {
        arclen_valid = false;
        return PixPath::append_no_overlap( suffix );
    }

    PixPathAc& ow_reverse()
    {
        arclen_valid = false;
        PixPath::ow_reverse();
        return *this;
    }

    int arclength( std::vector< float >* alvec ) const
    {
        KJB( NRE( alvec ) );

        refresh_the_cache_if_stale();
        alvec -> resize( size() );
        std::copy( arclen_cache.begin(), arclen_cache.end(), alvec->begin() );
        return kjb_c::NO_ERROR;
    }

    float arclength( size_t index ) const
    {
        refresh_the_cache_if_stale();
        return arclen_cache.at( index );
    }

    float arclength() const;

    size_t whereis_arclength_ratio( float ) const;

    size_t halfway() const
    {
        return whereis_arclength_ratio( 0.5 );
    }
};

}
}

#endif