test_sdk/math/gtl_math_octv.h

#ifndef OCTV_H
#define OCTV_H

#include <QObject>

#include "core/gtl_analog_data.h"
#include "core/gtl.h"
#include "gtl_math_spec.h"

#include "math_global.h"

namespace gtl
{
    namespace math
    {
        class MATH_EXPORT octv : public QObject, public std::vector<std::pair<qreal, qreal>>
        {
            Q_OBJECT

            Q_PROPERTY(qreal minimum READ minimum WRITE set_minimum NOTIFY minimum_changed);
            Q_PROPERTY(qreal maximum READ maximum WRITE set_maximum NOTIFY maximum_changed);
            Q_PROPERTY(ratios ratio READ ratio WRITE set_ratio NOTIFY ratio_changed);
            Q_PROPERTY(looks look READ look WRITE set_look NOTIFY look_changed);
            Q_PROPERTY(fractions fraction READ fraction WRITE set_fraction NOTIFY fraction_changed);
            Q_PROPERTY(units unit READ unit WRITE set_unit NOTIFY unit_changed);
//            Q_PROPERTY(windows window READ window WRITE set_window NOTIFY window_changed);
//            Q_PROPERTY(int average READ average WRITE set_average NOTIFY average_changed);
//            Q_PROPERTY(int overlap READ overlap WRITE set_overlap NOTIFY overlap_changed);

        public:
            enum ratios
            {
                two,
                ten
            };
            Q_ENUM(ratios)

            enum looks
            {
                amplitude,
                rms
            };
            Q_ENUM(looks)

            enum fractions
            {
                one,
                one_third,
                one_sixth,
                one_twelwe
            };
            Q_ENUM(fractions)


        public:
            octv(gtl::analog_data *ad);

            gtl::analog_data *ad() const;

            qreal left(int idx);
            qreal right(int idx);

            qreal minimum() const;
            void set_minimum(qreal value);

            qreal maximum() const;
            void set_maximum(qreal value);

            ratios ratio() const;
            void set_ratio(ratios value);

            looks look() const;
            void set_look(looks value);

            fractions fraction() const;
            void set_fraction(fractions value);

            units unit() const;
            void set_unit(units value);

//            int average() const;
//            void set_average(int value);

//            qreal overlap() const;
//            void set_overlap(int value);

        private:
            void init();
            std::pair<int, int> calculate_band_indexes(qreal frequency);
            qreal calculate_octave(std::vector<qreal>::iterator begin, std::vector<qreal>::iterator end);
            qreal g_pow(qreal value, bool direction);

            gtl::analog_data* _ad;

            qreal _min; // Минимальная частота
            qreal _max; // Максимальная частота
            ratios _r; // Изменение в 2 или в 10 раз
            looks _l; // Представление - амплитуда или СКЗ
            fractions _frac; // Делитель полосы октавы
            units _unit;

            gtl::math::spec *_spec = NULL; // Спектр
            std::vector<qreal> *_frequencies = NULL; // Частоты октав (нижняя, верхняя, нижняя,...)
            int _r_rbw; // Делитель разрешения
            qreal _gfl; // Коэффициент для вычисления нижней частоты октавы
            qreal _gfh; // Коэффициент для вычисления верхней частоты октавы
            int _frac_num; // Делитель полосы октавы - число

        protected:
            virtual void calculate();
            virtual void before_updating();
            virtual void after_updating();

        private slots:
            virtual void spec_changed();
            virtual void set_rate(qreal value);

        signals:
            void minimum_changed();
            void maximum_changed();
            void ratio_changed();
            void look_changed();
            void fraction_changed();
            void unit_changed();

//            void window_changed();
//            void average_changed();
//            void overlap_changed();

            void initialized();
            void changed();
            void acquired(qreal);

        };
    }
}

#endif // OCTV_H