Method calc_math

DSView/pv/data/mathstack.cpp:361–428

}

void MathStack::calc_math(uint64_t mathFactor)
{
    assert(mathFactor > 0);

    std::lock_guard<std::mutex> lock(_mutex);

    _math_state = Running;

    const auto data = _dsoSig1->data();

    if (data->empty() || _math.size() < _total_sample_num)
        return;

    if (!_dsoSig1->enabled() || !_dsoSig2->enabled())
        return;

    if (data->get_channel_num() < 2)
        return;

    auto k1 = _dsoSig1->get_factor();
    auto k2 = _dsoSig2->get_factor();

    const double scale1 = _dsoSig1->get_vDialValue() / 1000.0 * k1 * DS_CONF_DSO_VDIVS *
                          _dsoSig1->get_scale() / _dsoSig1->get_view_rect().height();

    const double delta1 = _dsoSig1->get_hw_offset() * scale1;

    const double scale2 = _dsoSig2->get_vDialValue() / 1000.0 * k2 * DS_CONF_DSO_VDIVS *
                          _dsoSig2->get_scale() / _dsoSig2->get_view_rect().height();

    const double delta2 = _dsoSig2->get_hw_offset() * scale2;

    _sample_num = data->get_sample_count();
    assert(_sample_num <= _total_sample_num);

    const int index1 = _dsoSig1->get_index();
    const int index2 = _dsoSig2->get_index();
    const uint8_t* value_buffer1 = data->get_samples(0, 0, index1);
    const uint8_t* value_buffer2 = data->get_samples(0, 0, index2);
    double value1, value2;

    for (uint64_t sample = 0; sample < _sample_num; sample++) {
        value1 = *(value_buffer1 + sample);
        value2 = *(value_buffer2 + sample);

        switch(_type) 
        {
            case MATH_ADD:
                _math[sample] = ((delta1 - scale1 * value1) + (delta2 - scale2 * value2)) / mathFactor;
                break;
            case MATH_SUB:
                _math[sample] = ((delta1 - scale1 * value1) - (delta2 - scale2 * value2)) / mathFactor;
                break;
            case MATH_MUL:
                _math[sample] = (delta1 - scale1 * value1) * (delta2 - scale2 * value2) / mathFactor;
                break;
            case MATH_DIV:
                _math[sample] = (delta1 - scale1 * value1) / (delta2 - scale2 * value2) / mathFactor;