Free functions handling variant type

Functions
template<typename T >
HOMOG2D_INUMTYPE	h2d::area (const T &elem)
	Returns area of element or variant (free function) More...
template<typename U , typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
void	h2d::draw (img::Image< U > &img, const T &cont, const img::DrawParams &dp=img::DrawParams())
	Free function, draws a set of primitives. More...
template<typename T >
Dtype	h2d::dtype (const T &elem)
	Returns the underlying data type of object or variant. More...
template<typename T >
FRect_< HOMOG2D_INUMTYPE >	h2d::getBB (const T &t)
	Return Bounding Box of primitive or container holding primitives (free function) More...
template<typename T >
HOMOG2D_INUMTYPE	h2d::length (const T &elem)
	Returns length of element or variant (free function) More...
template<typename T >
HOMOG2D_INUMTYPE	h2d::size (const T &elem)
	Returns size of element or variant (free function) More...
template<typename T , typename FPT >
CommonType_< FPT >	h2d::transform (const Homogr_< FPT > &h, const T &elem)
	Apply homography to primitive. More...
template<typename T >
Type	h2d::type (const T &elem)
	Free function. Returns the type of object or variant. More...

Detailed Description

defgroup

These function can be used on a "regular" geometric object or on a CommonType object, holding a std::variant and allowing run-time polymorphism,

See md_docs_homog2d_manual.html::section_rtp

Function Documentation

area()

template<typename T >

HOMOG2D_INUMTYPE h2d::area

(

const T &

elem

)

Returns area of element or variant (free function)

{
#ifdef HOMOG2D_ENABLE_VRTP
    if constexpr( trait::IsVariant<T>::value )
        return std::visit( fct::AreaFunct{}, elem );
    else
#endif
        return elem.area();
}

Here is the caller graph for this function:

draw()

template<typename U , typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>

void h2d::draw	(	img::Image< U > &	img,
		const T &	cont,
		const img::DrawParams &	dp = img::DrawParams()
	)

Free function, draws a set of primitives.

• Type T can be std::array<type> or std::vector<type>, with type being anything drawable.
• The types inside the container can be either plain h2d types (FRect, Segment, ...) of variant types, using the CommonType class (requires HOMOG2D_ENABLE_VRTP symbol).

{
#ifdef HOMOG2D_ENABLE_VRTP
    if constexpr( trait::IsVariant<typename T::value_type>::value )
    {
        fct::DrawFunct vde( img, dp ); // functor
        for( auto& e: cont )
            std::visit( vde, e );
    }
    else
#endif
    {
        size_t c=0;
        for( const auto& elem: cont )
        {
            elem.draw( img, dp );
            priv::impl_drawIndexes( img, c++, dp, elem );
        }
    }
}

Here is the call graph for this function:

dtype()

template<typename T >

Dtype h2d::dtype

(

const T &

elem

)

Returns the underlying data type of object or variant.

Can be printed with getString()

{
#ifdef HOMOG2D_ENABLE_VRTP
    if constexpr( trait::IsVariant<T>::value )
        return std::visit( fct::DTypeFunct{}, elem );
    else
#endif
        return elem.dtype();
}

Here is the caller graph for this function:

getBB()

template<typename T >

FRect_<HOMOG2D_INUMTYPE> h2d::getBB

(

const T &

t

)

Return Bounding Box of primitive or container holding primitives (free function)

tests: [BB-cont]

{
    HOMOG2D_START;

    if constexpr( !trait::IsContainer<T>::value ) // if not a container,
        return t.getBB();                         // then call the member function
    else
    {
        if( t.empty() )
            HOMOG2D_THROW_ERROR_1( "unable, can't compute BB of empty container" );

        if constexpr( trait::IsPoint<typename T::value_type>::value )
        {
            if( t.size() < 2 )
                HOMOG2D_THROW_ERROR_1( "unable, need at least two points" );
            return FRect_<typename T::value_type::FType>( priv::getBB_Points( t ) );
        }
        else
        {
            if constexpr( trait::HasBB<typename T::value_type>::value )
            {
                using FPT = typename T::value_type::FType;
                std::vector<FRect_<FPT>> v_bb( t.size() );

                auto it = v_bb.begin();
                for( const auto& elem: t ) // compute bounding box of each element
                    *it++ = elem.getBB();

                return priv::getBB_FRect( v_bb ); // compute BB of all the BB
            }
            else
            {
                if constexpr( trait::IsSegment<typename T::value_type>::value )
                {
                    if( t.empty()  )
                        HOMOG2D_THROW_ERROR_1( "unable, need at least one segment" );
                    return priv::getBB_Segments( t );
                }
                else
                {
#ifdef HOMOG2D_ENABLE_VRTP
                    if constexpr( !trait::IsVariant<typename T::value_type>::value )
                    {
                        HOMOG2D_THROW_ERROR_1( "Unable, cannot compute BoundingBox of a container holding Line2d objects" );
                    }
                    else
                        return priv::getBB_CommonType( t );
#else
                    HOMOG2D_THROW_ERROR_1( "Unable, cannot compute BoundingBox of a container holding Line2d objects" );
#endif
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

length()

template<typename T >

HOMOG2D_INUMTYPE h2d::length

(

const T &

elem

)

Returns length of element or variant (free function)

{
#ifdef HOMOG2D_ENABLE_VRTP
    if constexpr( trait::IsVariant<T>::value )
        return std::visit( fct::LengthFunct{}, elem );
    else
#endif
        return elem.length();
}

Here is the caller graph for this function:

size()

template<typename T >

HOMOG2D_INUMTYPE h2d::size

(

const T &

elem

)

Returns size of element or variant (free function)

{
#ifdef HOMOG2D_ENABLE_VRTP
    if constexpr( trait::IsVariant<T>::value )
        return std::visit( fct::SizeFunct{}, elem );
    else
#endif
        return elem.size();
}

Here is the caller graph for this function:

transform()

template<typename T , typename FPT >

CommonType_<FPT> h2d::transform	(	const Homogr_< FPT > &	h,
		const T &	elem
	)

Apply homography to primitive.

Warning

The floating-point type of the returned object (variant) will be the one of the homography h, NOT the one of the input element.

{
    if constexpr( trait::IsVariant<T>::value )
        return std::visit( fct::TransformFunct<FPT>(h), elem );
    else
        return h * elem;
}

Here is the caller graph for this function:

type()

template<typename T >

Type h2d::type

(

const T &

elem

)

Free function. Returns the type of object or variant.

Can be printed with getString()

See also

CommonType_

{
#ifdef HOMOG2D_ENABLE_VRTP
    if constexpr( trait::IsVariant<T>::value )
        return std::visit( fct::TypeFunct{}, elem );
    else
#endif
        return elem.type();
}

Here is the caller graph for this function: