GeometryFilter.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/GeometryVertices.h>
#include <NDEVR/DesignCommand.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/UUID.h>
#include <NDEVR/GenericOption.h>
#include <NDEVR/Pointer.h>
 
namespace NDEVR
{
    class ManagedDesignCommand;
    class Model;
    class Geometry;

    struct NDEVR_DESIGN_API FilterDescription : public GenericOptionGroup
    {
        FilterDescription(const TranslatedString& filter_name, const String& filter_id);
    };

    struct NDEVR_DESIGN_API GeometryFilterParameters : public GenericOptionGroup, public GeometryVertices
    {
        GeometryFilterParameters();
        Matrix<fltp08> transform;   
        const void* lock = nullptr; 
        LogPtr log = nullptr;       
        Buffer<bool> filtered;      
        Dictionary<UUID, Bounds<1, uint04>> vertex_bounds;  
    };

    class NDEVR_DESIGN_API GeometryFilter : public SoftwareServiceManager, public SoftwareService
    {
    protected:
        explicit GeometryFilter(const TranslatedString& name, const StringView& id);
    public:
        static const Dictionary<String, GeometryFilter*>& AvailableFilters();

        static void AddAvailableFilter(GeometryFilter* filter);

        static void ExecuteFiltering(const JSONNode& active_filters, Model& model, LogPtr log, const void* lock);

        static void ExecuteFiltering(const JSONNode& active_filters, const Matrix<fltp08>& transform, Geometry& geo, LogPtr log, const void* lock);

        static Buffer<FilterDescription> GetAvailableDescriptions();

        static String ToCommandString(const Buffer<FilterDescription>& descriptions);

        static DynamicPointer<ManagedDesignCommand> AddFilterCommand(const FilterDescription& filter);

        static DynamicPointer<ManagedDesignCommand> SetFiltersCommand(const Buffer<FilterDescription>& filter);
    public:
        GeometryFilter(const GeometryFilter& filter) = delete;      
        GeometryFilter(const GeometryFilter&& filter) = delete;     
        virtual ~GeometryFilter() = default;                        

        virtual bool runFilter(GeometryFilterParameters& parameters) = 0;

        virtual bool canRunFilter(const GeometryFilterParameters&) { return true; }

        virtual Buffer<FilterDescription> defaultFilterArguments();

        [[nodiscard]] const TranslatedString& filterName() const { return m_name; }

        [[nodiscard]] const String& filterID() const { return m_id; }
    protected:
        TranslatedString m_name;    
        String m_id;                
    protected:
        static void PrepareForFiltering(const Matrix<fltp08>& transform, Geometry& geo, GeometryFilterParameters& params);

        static void ClearAllFiltering(Geometry& geo, LogPtr log, const void* lock);

        static void FinishFiltering(const Matrix<fltp08>& transform, Geometry& geo, const GeometryFilterParameters& params);
    protected:
        static Dictionary<String, GeometryFilter*> s_global_available_filters;  
    };
}