CustomDesignChart.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/NDEVRChart.h>
#include <NDEVR/QTDesignObject.h>
#include <NDEVR/QCustomCombobox.h>
#include <NDEVR/QCustomLabel.h>
#include <NDEVR/DesignParameter.h>
#include <NDEVR/DesignParameterAccumulator.h>
#include <NDEVR/SnapLocation.h>
#include <NDEVR/DesignObjectLookup.h>
#include <NDEVR/FeatureOptions.h>
#include <NDEVR/Translator.h>
#include <QHBoxLayout>
namespace NDEVR
{
    class CustomDesignChart : public NDEVRChart
    {
    public:
        CustomDesignChart(DesignObjectLookup* lookup, QWidget* parent = nullptr)
            : NDEVRChart(parent)
            , m_manager(lookup)
        {
            m_locked_axes = false;
        }
        void updateChart()
        {
            if (m_parameters[X].column_name.size() == 0)
                return;
            if (m_parameters[Y].column_name.size() == 0)
                return;
            Buffer<Model> models = m_manager->getModelsByID(m_object_ids);
 
            BitFlag flag(0);
            flag(DesignParameterAccumulator::e_get_floats, true);
            m_coordinate_unit = ConstPointer<Unit>();
            m_unit[X] = m_parameters[X].defaultUnit();
            m_unit[Y] = m_parameters[Y].defaultUnit();
            DesignParameterAccumulator h_accumulator(m_parameters[X], flag);
            h_accumulator.use_unit = false;
            h_accumulator.parseAll(models);
            DesignParameterAccumulator v_accumulator(m_parameters[Y], flag);
            v_accumulator.use_unit = false;
            v_accumulator.parseAll(models);
            setTitle(_td("custom_plot_title", "[X] Vs [Y]").replace("[X]", m_parameters[X].displayName()).replace("[Y]", m_parameters[Y].displayName()));
 
            if (v_accumulator.float_values.size() != h_accumulator.float_values.size() || h_accumulator.float_values.size() == 0)
            {
                clearAll();
            }
            else
            {
                Buffer<Vector<2, fltp04>> initial_data;
                for (uint04 i = 0; i < h_accumulator.float_values.size(); i++)
                {
                    if (isNaN(h_accumulator.float_values[i]))
                        continue;
                    if (isNaN(v_accumulator.float_values[i]))
                        continue;
                    if (m_bounds[MIN][X] > h_accumulator.float_values[i])
                        continue;
                    if (m_bounds[MAX][X] < h_accumulator.float_values[i])
                        continue;
                    if (m_bounds[MIN][Y] > v_accumulator.float_values[i])
                        continue;
                    if (m_bounds[MAX][Y] < v_accumulator.float_values[i])
                        continue;
                    initial_data.add(Vector<2, fltp04>(h_accumulator.float_values[i], v_accumulator.float_values[i]));
                    
                }
 
                PlotData plot_data;
                //plot_data.point_data;
                plot_data.pen = QPen(QTTools::convert(RGBColor(200, 200, 200)));
                uint04 jump = (initial_data.size() / 10000) + 1;
                for (uint04 i = 0; i < initial_data.size(); i += jump)
                {
                    Vertex<3, fltp08> vert(initial_data[i][X],  0.0, initial_data[i][Y]);
                    plot_data.point_data.add(vert);
                }
                setData(plot_data);
                updateAxisScale();
 
            }
        }
        void setHorizontalParameter(const DesignParameter& param)
        {
            m_parameters[X] = param;
            setSideAxes(m_parameters[X].displayName().translation(), m_parameters[Y].displayName().translation());
        }
        void setVerticalParameter(const DesignParameter& param)
        {
            m_parameters[Y] = param;
            setSideAxes(m_parameters[X].displayName().translation(), m_parameters[Y].displayName().translation());
        }
        void setUUID(const UUID& id)
        {
            m_object_ids = { id };
        }
        Bounds<2, fltp08> bounds() const { return m_bounds; }
        void setBounds(const Bounds<2, fltp08>& bounds) { m_bounds = bounds; }
    protected:
        DesignParameter m_parameters[2];
        Buffer<UUID> m_object_ids;
        DesignObjectLookup* m_manager = nullptr;
        Bounds<2, fltp08> m_bounds = Constant<Bounds<2, fltp08>>::NaN;
 
    };
 
    class CustomDesignChartDialog : public QWidget
    {
    public:
        CustomDesignChartDialog(const DynamicPointer<QTDesignObject>& object, QWidget* parent = nullptr)
            : QWidget(parent)
            , m_chart(new CustomDesignChart(object->manager()))
            , m_h_combo(new QCustomComboBox())
            , m_v_combo(new QCustomComboBox())
            , m_h_min_edit(new QCustomLineEdit())
            , m_h_max_edit(new QCustomLineEdit())
            , m_v_min_edit(new QCustomLineEdit())
            , m_v_max_edit(new QCustomLineEdit())
        {
            m_chart->setUUID(object->uuid());
            setWindowTitle(_tqs("Plot Data"));
            QVBoxLayout* layout = new QVBoxLayout();
            layout->addWidget(m_chart);
 
 
            setupCombo(_t("Horizontal Axis"), m_h_combo);
            setupCombo(_t("Vertical Axis"), m_v_combo);
 
            connect(m_h_combo, &QCustomComboBox::edited, this, [this]
            {
                DesignParameter param(m_h_combo->getAs<String>());
                m_chart->setHorizontalParameter(param);
                m_h_min_edit->setConstantUnit(param.defaultUnit());
                m_h_min_edit->clear();
                m_h_max_edit->setConstantUnit(param.defaultUnit());
                m_h_max_edit->clear();
                m_chart->updateChart();
            });
            connect(m_v_combo, &QCustomComboBox::edited, this, [this]
            {
                DesignParameter param(m_v_combo->getAs<String>());
                m_chart->setVerticalParameter(param);
                m_v_min_edit->setConstantUnit(param.defaultUnit());
                m_v_min_edit->clear();
                m_v_max_edit->setConstantUnit(param.defaultUnit());
                m_v_max_edit->clear();
                m_chart->updateChart();
            });
 
            setupLineEdit(_t("X Min"), m_h_min_edit, MIN, X);
            setupLineEdit(_t("X Max"), m_h_max_edit, MAX, X);
            setupLineEdit(_t("Y Min"), m_v_min_edit, MIN, Y);
            setupLineEdit(_t("Y Max"), m_v_max_edit, MAX, Y);
            QHBoxLayout* h_layout = new QHBoxLayout();
 
            h_layout->addWidget(new QCustomLabel(_t("Vertical")));
            h_layout->addWidget(m_v_combo);
            h_layout->addWidget(m_v_min_edit);
            h_layout->addWidget(m_v_max_edit);
 
            h_layout->addWidget(new QCustomLabel(_t("Horizontal")));
            h_layout->addWidget(m_h_combo);
            h_layout->addWidget(m_h_min_edit);
            h_layout->addWidget(m_h_max_edit);
            layout->addLayout(h_layout);
            setLayout(layout);
            
 
        }
        void setupLineEdit(const TranslatedString& label, QCustomLineEdit* edit, uint01 min_max, uint01 axis)
        {
            edit->setup<fltp08>(label);
            edit->customValidator().setAllowEmpty(true);
            connect(edit, &QCustomLineEdit::editingFinishedSignal, this, [this, min_max, axis, edit]
            {
                Bounds<2, fltp08> axis_scale = m_chart->bounds();
                axis_scale[min_max][axis] = edit->getUnitValue();
                m_chart->setBounds(axis_scale);
                m_chart->updateChart();
            });
            edit->setPlaceholderText(label.translation().getAs<QString>());
            edit->setAllowPlaceholderAsValue(false);
        }
        void clearBounds()
        {
            m_chart->setBounds(Constant<Bounds<2, fltp08>>::NaN);
            
            m_h_min_edit->clear();
            m_v_min_edit->clear();
            m_h_max_edit->clear();
            m_v_max_edit->clear();
        }
        void setupCombo(const TranslatedString& title, QCustomComboBox* combo)
        {
            Buffer<DesignParameter> params;
            if (FeatureOptions::IsFeatureEnabled(FeatureOptions::supports_scanner))
            {
                params.add(DesignParameter("intensity"));
                params.add(DesignParameter("distance"));
                params.add(DesignParameter("scan_time"));
                params.add(DesignParameter("pitch"));
                params.add(DesignParameter("roll"));
            }
#if true
            params.add(DesignParameter("real"));
            params.add(DesignParameter("imaginary"));
#endif
            params.add(DesignParameter(VertexProperty::Position, X));
            params.add(DesignParameter(VertexProperty::Position, Y));
            params.add(DesignParameter(VertexProperty::Position, Z));
            params.add(DesignParameter(VertexProperty::Normal, X));
            params.add(DesignParameter(VertexProperty::Normal, Y));
            params.add(DesignParameter(VertexProperty::Normal, Z));
            if (!m_object.isNull() && m_object->is<Model>())
            {
                //Model model = m_target->getAs<Model>();
                DesignParameterFinder finder;
                finder.parseAll(m_object->getAs<Model>());
                for (uint04 i = params.size() - 1; !isNaN(i); i--)
                {
                    if (!finder.parameters.contains(params[i]))
                        params.removeIndex(i);
                }
            }
            Buffer<TranslatedString> display_items(params.size());
            Buffer<String> items(params.size());
            for (uint04 i = 0; i < params.size(); i++)
            {
                display_items.add(params[i].displayName());
                items.add(params[i].stringID());
            }
            combo->setup(title, items, display_items);
        }
    protected:
        DynamicPointer<QTDesignObject> m_object;
        CustomDesignChart* m_chart;
        QCustomComboBox* m_h_combo;
        QCustomComboBox* m_v_combo;
        QCustomLineEdit* m_h_min_edit;
        QCustomLineEdit* m_h_max_edit;
        QCustomLineEdit* m_v_min_edit;
        QCustomLineEdit* m_v_max_edit;
    };
    
}