DesignParameterAccumulator.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: DesignParameterAccumulator
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignParameter.h>
#include <NDEVR/DesignObject.h>
#include <NDEVR/ModelIterator.h>
 
namespace NDEVR
{
    class Geometry;
    class Model;
    class TableColumn;
    class DesignObject;

    class NDEVR_DESIGN_API DesignParameterFinder final : public ModelIterator
    {
    public:
        ParseResult process(Model& model) final override;

        ParseResult process(Model& model, Geometry& geo) final override;

        ParseResult process(Model& model, Material& mat) final override;

        void addParameter(const StringView& parameter);
    private:
        void _parseAllModels() final override;
    public:
        Buffer<DesignParameter> parameters;           
        Dictionary<String, uint04> parameter_count;   
    };

    class NDEVR_DESIGN_API DesignParameterAccumulator final : public ModelIterator
    {
    public:
        enum AccumulateMode
        {
              e_get_max_min   
            , e_get_average   
            , e_get_variance  
            , e_get_std_dev   
            , e_get_strings   
            , e_get_total     
            , e_get_indices   
            , e_get_floats    
        };
    public:
        explicit DesignParameterAccumulator(const DesignParameter& design_parameter, BitFlag mode = BitFlag(0));

        void setToDefaults(const DesignObject& object);

        void accumulate(fltp08 value, const uint01& dim = X, bool to_unit = true);

        void accumulate(const DesignObject& object, fltp08 known_avg = Constant<fltp08>::Invalid);

        void addToTotal(fltp08 value);

        DesignObject::DesignObjectType type() { return m_design_type; }

        void clear();

        void setCollectVerticesByPrimitive(PrimitiveProperty vertex_collection_primitive);
    private:
        ParseResult process(Model& model) final override;

        ParseResult process(Model& model, Geometry& geo) final override;

        ParseResult process(Model& model, Material& mat) final override;

        ParseResult postProcess(Model& m) final override;
    private:
        void _parseAllModels() final override;

        bool _setupValues(const DesignObject& object);

        void _accumulate(const DesignObject& object);

        Matrix<fltp08> _matrix(const DesignObject& object);

        void _accumulateVertices(const Geometry& geo, const TableColumn& column);

        void _accumulate(const DesignObject& object, uint04 row, const TableColumn& column);
        //void _accumulate(const StringView& data);
    public:
        Matrix<fltp08> transform = Matrix<fltp08>(1.0);           
        DesignParameter parameter;                                 
        ConstPointer<Unit> override_unit;                          
        fltp08 average = Constant<fltp08>::Invalid;                
        BitFlag accumulate_mode;                                   
        fltp08 max = Constant<fltp08>::Min;                        
        fltp08 min = Constant<fltp08>::Max;                        
        fltp08 total_value = 0.0;                                  
        fltp08 upper_variance = 0.0;                               
        fltp08 lower_variance = 0.0;                               
        fltp08 upper_std_dev = 0.0;                                
        fltp08 lower_std_dev = 0.0;                                
        uint04 total_upper = 0;                                    
        uint04 total_lower = 0;                                    
        uint04 total_count = 0;                                    
        uint04 min_num_of_decimals = 0;                            
        uint04 max_num_of_decimals = Constant<uint04>::Max;        
        uint04 min_digits = 0;                                     
        uint04 max_num_of_values = Constant<uint04>::Max;          
        String default_value;                                      
        bool is_normal_prop = false;                               
        bool add_commas = false;                                   
        bool recursive_matrix = false;                             
        bool use_defaults = false;                                 
        bool include_unit_symbols = true;                          
        Buffer<StringAllocatingView> string_values;                
        Buffer<uint04> indices;                                    
        Buffer<fltp08> float_values;                               
        StringAllocatingView string_cache;                         
    protected:
        fltp08 total_value_c = 0.0;                                
        bool is_matrix_prop = false;                               
        bool is_design_index = false;                              
        bool is_vertex_index = false;                              
        bool is_special_field = false;                              
        PrimitiveProperty m_vertex_collection_primitive = PrimitiveProperty::Vertices; 
        DesignObject::DesignObjectType m_design_type = DesignObject::DesignObjectType::e_model; 
        uint04 property_index = Constant<uint04>::Invalid;         
    };

    class NDEVR_DESIGN_API DesignParameterSetter final : public ModelIterator
    {
    public:
        enum SetMode
        {
             e_set_from_strings 
        };
    public:
        ParseResult process(Model& model) final override;

        ParseResult process(Material& mat);

        ParseResult process(Geometry& geo);

        ParseResult process(DesignObject& object);

        explicit DesignParameterSetter(const DesignParameter& design_parameter, SetMode mode);

        void setToDefaults(const DesignObject& object);
    private:
        ParseResult process(Model& model, Geometry& geo) final override;

        ParseResult process(Model& model, Material& mat) final override;

        void clear();
    private:
        StringView currentValue() const;

        bool _setupValues(const DesignObject& object);

        void _set(DesignObject& object);

        Matrix<fltp08> _matrix(const DesignObject& object) const;

        void _setVertices(Geometry& geo, TableColumn& column);

        void _set(DesignObject& object, uint04 row, TableColumn& column);
    public:
        Matrix<fltp08> transform = Matrix<fltp08>(1.0);           
        Buffer<String> string_values;                              
        String default_value;                                      
        Buffer<uint04> indices;                                    
        Buffer<fltp08> float_values;                               
        DesignParameter parameter;                                 
        SetMode set_mode;                                          
        uint04 total_count = 0;                                    
        uint04 set_offset = 0;                                     
        uint04 max_num_of_values = Constant<uint04>::Max;          
        bool is_normal_prop = false;                               
        bool recursive = true;                                     
        bool recursive_matrix = false;                             
        bool use_defaults = false;                                 
        bool swap_result = false;                                  
    protected:
        fltp08 total_value_c = 0.0;                                
        bool is_matrix_prop = false;                               
        bool is_design_index = false;                              
        bool is_vertex_index = false;                              
        bool is_special_field = false;                              
        DesignObject::DesignObjectType m_design_type = DesignObject::DesignObjectType::e_model; 
        uint04 property_index = Constant<uint04>::Invalid;         
    };
 
 
}