DesignParameterAccumulator.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
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 String& parameter);
        void _parseAll() final override;
        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 accumulate(fltp08 value, const uint01& dim = X, bool to_unit = true);
        ParseResult process(Model& model) final override;
        ParseResult process(Model& model, Geometry& geo) final override;
        ParseResult process(Model& model, Material& mat) final override;
        void _parseAll() final override;
        void accumulate(const DesignObject& object, fltp08 known_avg = Constant<fltp08>::NaN);
        void setToDefaults(const DesignObject& object);
        DesignObject::DesignObjectType type() { return m_design_type; }
        void clear();
        virtual ParseResult postProcess(Model& m) final override;
        void addToTotal(fltp08 value);
        void setCollectVerticesByPrimitive(PrimitiveProperty vertex_collection_primitive);
    protected:
        
        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 String& data);
    public:
        Matrix<fltp08> transform = Matrix<fltp08>(1.0);
        DesignParameter parameter;
        ConstPointer<Unit> override_unit;
        fltp08 average = Constant<fltp08>::NaN;
        BitFlag accumulate_mode;
        fltp08 max = Constant<fltp08>::Min;
        fltp08 min = Constant<fltp08>::Max;
        fltp08 total_value = 0.0;
        fltp08 upper_variance = 0.0;//variance for greater than average values
        fltp08 lower_variance = 0.0;//variance for less than average values
        fltp08 upper_std_dev = 0.0;//standard deviation for greater than average values
        fltp08 lower_std_dev = 0.0;//standard deviation for less than average values
        uint04 total_upper = 0;//Total less than average values
        uint04 total_lower = 0;//Total greater than average values
        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<String> string_values;
        Buffer<uint04> indices;
        Buffer<fltp08> float_values;
        String string_cache;
    protected:
        fltp08 total_value_c = 0.0;//Used to keep precision when accumulating
        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>::NaN;
    };
 
    class NDEVR_DESIGN_API DesignParameterSetter final : public ModelIterator
    {
    public:
        enum SetMode
        {
             e_set_from_strings
        };
    public:
        explicit DesignParameterSetter(const DesignParameter& design_parameter, SetMode mode);
        ParseResult process(Model& model) final override;
        ParseResult process(Model& model, Geometry& geo) final override;
        ParseResult process(Model& model, Material& mat) final override;
        void _parseAll() final override;
        void setToDefaults(const DesignObject& object);
        void clear();
    protected:
        const String& 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);
        DesignParameter parameter;
        SetMode set_mode;
        uint04 total_count = 0;
        uint04 set_offset = 0;
        uint04 max_num_of_values = Constant<uint04>::Max;
        String default_value;
        bool is_normal_prop = false;
        bool recursive = true;
        bool recursive_matrix = false;
        bool use_defaults = false;
        Buffer<String> string_values;
        Buffer<uint04> indices;
        Buffer<fltp08> float_values;
    protected:
        fltp08 total_value_c = 0.0;//Used to keep precision when accumulating
        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>::NaN;
    };
 
    
}