MRSceneStateCheck.h

Go to the documentation of this file.

#pragma once
 
#include "MRISceneStateCheck.h"
#include "MRMesh/MRObject.h"
#include "exports.h"
 
namespace MR
{
 

struct NoVisualRepresentationCheck {};

struct NoModelCheck {};
 
template<typename ObjectT>
std::string getNObjectsLine( unsigned n )
{
    switch ( n )
    {
    case 1:
        return std::string( "one " ) + ObjectT::StaticClassName();
    case 2:
        return std::string( "two " ) + ObjectT::StaticClassNameInPlural();
    case 3:
        return std::string( "three " ) + ObjectT::StaticClassNameInPlural();
    case 4:
        return std::string( "four " ) + ObjectT::StaticClassNameInPlural();
    default:
        return std::to_string( n ) + " " + ObjectT::StaticClassNameInPlural();
    }
}

template<typename ObjectT, bool visualRepresentationCheck, bool modelCheck>
std::string sceneSelectedExactly( const std::vector<std::shared_ptr<const Object>>& objs, unsigned n )
{
    if ( objs.size() != n )
        return "Select exactly " + getNObjectsLine<ObjectT>( n );
    for ( const auto& obj : objs )
    {
        auto tObj = dynamic_cast<const ObjectT*>( obj.get() );
        if ( !tObj )
            return std::string( "Selected object(s) must be " ) + ObjectT::StaticClassName();
 
        if constexpr ( modelCheck )
            if ( !tObj->hasModel() )
                return "Selected object(s) must have valid model";
 
        if constexpr ( visualRepresentationCheck )
            if ( !tObj->hasVisualRepresentation() )
                return "Selected object(s) must have valid visual representation";
    }
    return "";
}

template<typename ObjectT, bool visualRepresentationCheck, bool modelCheck>
std::string sceneSelectedAtLeast( const std::vector<std::shared_ptr<const Object>>& objs, unsigned n )
{
    if ( objs.size() < n )
        return "Select at least " + getNObjectsLine<ObjectT>( n );
    unsigned i = 0;
    for ( const auto& obj : objs )
    {
        auto tObj = dynamic_cast<const ObjectT*>( obj.get() );
        if ( !tObj )
            continue;
 
        if constexpr ( modelCheck )
            if ( !tObj->hasModel() )
                continue;
 
        if constexpr ( visualRepresentationCheck )
            if ( !tObj->hasVisualRepresentation() )
                continue;
        ++i;
    }
    return ( i >= n ) ?
        "" :
        ( "Select at least " + getNObjectsLine<ObjectT>( n ) + " with valid model" );
}

template<typename ObjectT, bool visualRepresentationCheck, bool modelCheck>
std::string sceneSelectedAtMost( const std::vector<std::shared_ptr<const Object>>& objs, unsigned n )
{
    unsigned i = 0;
    for ( const auto& obj : objs )
    {
        auto tObj = dynamic_cast<const ObjectT*>( obj.get() );
        if ( !tObj )
            continue;
 
        if constexpr ( modelCheck )
            if ( !tObj->hasModel() )
                continue;
 
        if constexpr ( visualRepresentationCheck )
            if ( !tObj->hasVisualRepresentation() )
                continue;
        ++i;
    }
    return ( i <= n ) ?
        "" :
        ( "Select at most " + getNObjectsLine<ObjectT>( n ) );
}

extern template MRVIEWER_API std::string getNObjectsLine<ObjectMesh>( unsigned );
extern template MRVIEWER_API std::string getNObjectsLine<ObjectPoints>( unsigned );
extern template MRVIEWER_API std::string getNObjectsLine<ObjectLines>( unsigned );
extern template MRVIEWER_API std::string sceneSelectedExactly<ObjectMesh, true, true>( const std::vector<std::shared_ptr<const Object>>&, unsigned );
extern template MRVIEWER_API std::string sceneSelectedExactly<ObjectPoints, true, true>( const std::vector<std::shared_ptr<const Object>>&, unsigned );
extern template MRVIEWER_API std::string sceneSelectedExactly<ObjectLines, true, true>( const std::vector<std::shared_ptr<const Object>>&, unsigned );
 

template<unsigned N, typename ObjectT, typename = void>
class SceneStateExactCheck : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateExactCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedExactly<ObjectT, true, true>(objs, N);
    }
};
 
template<unsigned N, typename ObjectT>
class SceneStateExactCheck<N, ObjectT, NoVisualRepresentationCheck> : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateExactCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedExactly<ObjectT, false, true>(objs, N);
    }
};
 
template<unsigned N, typename ObjectT>
class SceneStateExactCheck<N, ObjectT, NoModelCheck> : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateExactCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedExactly<ObjectT, false, false>( objs, N );
    }
};

template<unsigned N, typename ObjectT, typename = void>
class SceneStateAtLeastCheck : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateAtLeastCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedAtLeast<ObjectT, true, true>( objs, N );
    }
};
 
template<unsigned N, typename ObjectT>
class SceneStateAtLeastCheck<N, ObjectT, NoVisualRepresentationCheck> : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateAtLeastCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedAtLeast<ObjectT, false, true>( objs, N );
    }
};
 
template<unsigned N, typename ObjectT>
class SceneStateAtLeastCheck<N, ObjectT, NoModelCheck> : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateAtLeastCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedAtLeast<ObjectT, false, false>( objs, N );
    }
};

template<unsigned N, typename ObjectT, typename = void>
class SceneStateAtMostCheck : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateAtMostCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedAtMost<ObjectT, true, true>( objs, N );
    }
};
 
template<unsigned N, typename ObjectT>
class SceneStateAtMostCheck<N, ObjectT, NoVisualRepresentationCheck> : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateAtMostCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedAtMost<ObjectT, false, true>( objs, N );
    }
};
 
template<unsigned N, typename ObjectT>
class SceneStateAtMostCheck<N, ObjectT, NoModelCheck> : virtual public ISceneStateCheck
{
public:
    virtual ~SceneStateAtMostCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        return sceneSelectedAtMost<ObjectT, false, false>( objs, N );
    }
};

template<typename ...Checks>
class SceneStateOrCheck : public Checks...
{
public:
    virtual ~SceneStateOrCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>&objs ) const override
    {
        std::vector<std::string> checkRes;
        checkRes.reserve( sizeof...( Checks ) );
        ( checkRes.push_back( Checks::isAvailable( objs ) ), ... );
        std::string combinedRes;
        for ( int i = 0; i  < checkRes.size(); ++i )
        {
            if ( checkRes[i].empty() )
                return "";
 
            if ( i != 0 )
                checkRes[i].front() = ( char )tolower( checkRes[i].front() );
 
            combinedRes += checkRes[i];
            if ( i + 1 < checkRes.size() )
                combinedRes += " or ";
        }
        return combinedRes;
    }
};

template<typename ...Checks>
class SceneStateAndCheck : public Checks...
{
public:
    virtual ~SceneStateAndCheck() = default;
    virtual std::string isAvailable( const std::vector<std::shared_ptr<const Object>>& objs ) const override
    {
        std::vector<std::string> checkRes;
        checkRes.reserve( sizeof...( Checks ) );
        ( checkRes.push_back( Checks::isAvailable( objs ) ), ... );
        std::string combinedRes;
        for ( int i = 0; i < checkRes.size(); ++i )
        {
            if ( checkRes[i].empty() )
                continue;
 
            if ( !combinedRes.empty() )
            {
                combinedRes += " and ";
                checkRes[i].front() = ( char )tolower( checkRes[i].front() );
            }
            combinedRes += checkRes[i];
        }
        return combinedRes;
    }
};
 
 
}