Introduce new directory 'post' for post processing. Move all post processing funtionality there.

David Graeff · David Gräff
1 parent 84371ad2
Showing 17 changed files with 670 additions and 416 deletions
openhantek/src/analyse/dataanalyzer.cpp
openhantek/src/analyse/dataanalyzerresult.cpp
openhantek/src/analyse/enums.cpp → openhantek/src/post/enums.cpp
openhantek/src/analyse/enums.h → openhantek/src/post/enums.h
openhantek/src/post/graphgenerator.cpp
openhantek/src/post/graphgenerator.h
openhantek/src/post/mathchannelgenerator.cpp
openhantek/src/post/mathchannelgenerator.h
openhantek/src/post/postprocessing.cpp
openhantek/src/post/postprocessing.h
openhantek/src/post/ppresult.cpp
openhantek/src/analyse/dataanalyzerresult.h → openhantek/src/post/ppresult.h
openhantek/src/post/processor.h
openhantek/src/hantekdso/softwaretrigger.cpp → openhantek/src/post/softwaretrigger.cpp
openhantek/src/hantekdso/softwaretrigger.h → openhantek/src/post/softwaretrigger.h
openhantek/src/post/spectrumgenerator.cpp
openhantek/src/analyse/dataanalyzer.h → openhantek/src/post/spectrumgenerator.h
-// SPDX-License-Identifier: GPL-2.0+
-
-#define _USE_MATH_DEFINES
-#include <cmath>
-
-#include <QColor>
-#include <QMutex>
-#include <QTimer>
-
-#include <fftw3.h>
-
-#include "dataanalyzer.h"
-
-#include "glscope.h"
-#include "settings.h"
-#include "utils/printutils.h"
-
-std::unique_ptr<DataAnalyzerResult> DataAnalyzer::convertData(const DSOsamples *data, const DsoSettingsScope *scope, unsigned physicalChannels) {
-    QReadLocker locker(&data->lock);
-
-    unsigned int channelCount = (unsigned int)scope->voltage.size();
-
-    std::unique_ptr<DataAnalyzerResult> result =
-        std::unique_ptr<DataAnalyzerResult>(new DataAnalyzerResult(channelCount));
-
-    for (ChannelID channel = 0; channel < channelCount; ++channel) {
-        DataChannel *const channelData = result->modifyData(channel);
-
-        bool gotDataForChannel = channel < physicalChannels && channel < (unsigned int)data->data.size() &&
-                                 !data->data.at(channel).empty();
-        bool isMathChannel = channel >= physicalChannels &&
-                             (scope->voltage[channel].used || scope->spectrum[channel].used) &&
-                             result->channelCount() >= 2 && !result->data(0)->voltage.sample.empty() &&
-                             !result->data(1)->voltage.sample.empty();
-
-        if (!gotDataForChannel && !isMathChannel) {
-            // Clear unused channels
-            channelData->voltage.sample.clear();
-            result->modifyData(physicalChannels)->voltage.interval = 0;
-            continue;
-        }
-
-        // Set sampling interval
-        const double interval = 1.0 / data->samplerate;
-        if (interval != channelData->voltage.interval) {
-            channelData->voltage.interval = interval;
-            if (data->append) // Clear roll buffer if the samplerate changed
-                channelData->voltage.sample.clear();
-        }
-
-        unsigned int size;
-        if (channel < physicalChannels) {
-            size = (unsigned) data->data.at(channel).size();
-            if (data->append) size += channelData->voltage.sample.size();
-            result->challengeMaxSamples(size);
-        } else
-            size = result->getMaxSamples();
-
-        // Physical channels
-        if (channel < physicalChannels) {
-            // Copy the buffer of the oscilloscope into the sample buffer
-            if (data->append)
-                channelData->voltage.sample.insert(channelData->voltage.sample.end(), data->data.at(channel).begin(),
-                                                   data->data.at(channel).end());
-            else
-                channelData->voltage.sample = data->data.at(channel);
-        } else { // Math channel
-            // Resize the sample vector
-            channelData->voltage.sample.resize(size);
-            // Set sampling interval
-            result->modifyData(physicalChannels)->voltage.interval = result->data(0)->voltage.interval;
-
-            // Resize the sample vector
-            result->modifyData(physicalChannels)
-                ->voltage.sample.resize(
-                    qMin(result->data(0)->voltage.sample.size(), result->data(1)->voltage.sample.size()));
-
-            // Calculate values and write them into the sample buffer
-            std::vector<double>::const_iterator ch1Iterator = result->data(0)->voltage.sample.begin();
-            std::vector<double>::const_iterator ch2Iterator = result->data(1)->voltage.sample.begin();
-            std::vector<double> &resultData = result->modifyData(physicalChannels)->voltage.sample;
-            for (std::vector<double>::iterator resultIterator = resultData.begin(); resultIterator != resultData.end();
-                 ++resultIterator) {
-                switch (scope->voltage[physicalChannels].math) {
-                case Dso::MathMode::ADD_CH1_CH2:
-                    *resultIterator = *ch1Iterator + *ch2Iterator;
-                    break;
-                case Dso::MathMode::SUB_CH2_FROM_CH1:
-                    *resultIterator = *ch1Iterator - *ch2Iterator;
-                    break;
-                case Dso::MathMode::SUB_CH1_FROM_CH2:
-                    *resultIterator = *ch2Iterator - *ch1Iterator;
-                    break;
-                }
-                ++ch1Iterator;
-                ++ch2Iterator;
-            }
-        }
-    }
-    return result;
-}
-
-/// \brief Analyzes the data from the dso.
-DataAnalyzer::~DataAnalyzer() {
-    if (window) fftw_free(window);
-}
-
-void DataAnalyzer::applySettings(DsoSettings *settings) { this->settings = settings; }
-
-void DataAnalyzer::setSourceData(const DSOsamples *data) { sourceData = data; }
-
-std::unique_ptr<DataAnalyzerResult> DataAnalyzer::getNextResult() { return std::move(lastResult); }
-
-void DataAnalyzer::samplesAvailable() {
-    if (sourceData == nullptr) return;
-    std::unique_ptr<DataAnalyzerResult> result = convertData(sourceData, &settings->scope,settings->deviceSpecification->channels);
-    spectrumAnalysis(result.get(), lastWindow, lastRecordLength, window, &settings->scope);
-    lastResult.swap(result);
-    emit analyzed();
-}
-
-void DataAnalyzer::spectrumAnalysis(DataAnalyzerResult *result, Dso::WindowFunction &lastWindow,
-                                    unsigned int lastRecordLength, double *&lastWindowBuffer,
-                                    const DsoSettingsScope *scope) {
-    // Calculate frequencies, peak-to-peak voltages and spectrums
-    for (ChannelID channel = 0; channel < result->channelCount(); ++channel) {
-        DataChannel *const channelData = result->modifyData(channel);
-
-        if (channelData->voltage.sample.empty()) {
-            // Clear unused channels
-            channelData->spectrum.interval = 0;
-            channelData->spectrum.sample.clear();
-            continue;
-        }
-
-        // Calculate new window
-        size_t sampleCount = channelData->voltage.sample.size();
-        if (!lastWindowBuffer || lastWindow != scope->spectrumWindow || lastRecordLength != sampleCount) {
-            if (lastWindowBuffer) fftw_free(lastWindowBuffer);
-            lastWindowBuffer = fftw_alloc_real(sampleCount);
-            lastRecordLength = (unsigned)sampleCount;
-
-            unsigned int windowEnd = lastRecordLength - 1;
-            lastWindow = scope->spectrumWindow;
-
-            switch (scope->spectrumWindow) {
-            case Dso::WindowFunction::HAMMING:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 0.54 - 0.46 * cos(2.0 * M_PI * windowPosition / windowEnd);
-                break;
-            case Dso::WindowFunction::HANN:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 0.5 * (1.0 - cos(2.0 * M_PI * windowPosition / windowEnd));
-                break;
-            case Dso::WindowFunction::COSINE:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = sin(M_PI * windowPosition / windowEnd);
-                break;
-            case Dso::WindowFunction::LANCZOS:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition) {
-                    double sincParameter = (2.0 * windowPosition / windowEnd - 1.0) * M_PI;
-                    if (sincParameter == 0)
-                        *(lastWindowBuffer + windowPosition) = 1;
-                    else
-                        *(lastWindowBuffer + windowPosition) = sin(sincParameter) / sincParameter;
-                }
-                break;
-            case Dso::WindowFunction::BARTLETT:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) =
-                        2.0 / windowEnd * (windowEnd / 2 - std::abs((double)(windowPosition - windowEnd / 2.0)));
-                break;
-            case Dso::WindowFunction::TRIANGULAR:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) =
-                        2.0 / lastRecordLength *
-                        (lastRecordLength / 2 - std::abs((double)(windowPosition - windowEnd / 2.0)));
-                break;
-            case Dso::WindowFunction::GAUSS: {
-                double sigma = 0.4;
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) =
-                        exp(-0.5 * pow(((windowPosition - windowEnd / 2) / (sigma * windowEnd / 2)), 2));
-            } break;
-            case Dso::WindowFunction::BARTLETTHANN:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 0.62 -
-                                                           0.48 * std::abs((double)(windowPosition / windowEnd - 0.5)) -
-                                                           0.38 * cos(2.0 * M_PI * windowPosition / windowEnd);
-                break;
-            case Dso::WindowFunction::BLACKMAN: {
-                double alpha = 0.16;
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = (1 - alpha) / 2 -
-                                                           0.5 * cos(2.0 * M_PI * windowPosition / windowEnd) +
-                                                           alpha / 2 * cos(4.0 * M_PI * windowPosition / windowEnd);
-            } break;
-            // case Dso::WindowFunction::WINDOW_KAISER:
-            // TODO WINDOW_KAISER
-            // double alpha = 3.0;
-            // for(unsigned int windowPosition = 0; windowPosition <
-            // lastRecordLength; ++windowPosition)
-            //*(window + windowPosition) = ;
-            // break;
-            case Dso::WindowFunction::NUTTALL:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 0.355768 -
-                                                           0.487396 * cos(2 * M_PI * windowPosition / windowEnd) +
-                                                           0.144232 * cos(4 * M_PI * windowPosition / windowEnd) -
-                                                           0.012604 * cos(6 * M_PI * windowPosition / windowEnd);
-                break;
-            case Dso::WindowFunction::BLACKMANHARRIS:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 0.35875 -
-                                                           0.48829 * cos(2 * M_PI * windowPosition / windowEnd) +
-                                                           0.14128 * cos(4 * M_PI * windowPosition / windowEnd) -
-                                                           0.01168 * cos(6 * M_PI * windowPosition / windowEnd);
-                break;
-            case Dso::WindowFunction::BLACKMANNUTTALL:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 0.3635819 -
-                                                           0.4891775 * cos(2 * M_PI * windowPosition / windowEnd) +
-                                                           0.1365995 * cos(4 * M_PI * windowPosition / windowEnd) -
-                                                           0.0106411 * cos(6 * M_PI * windowPosition / windowEnd);
-                break;
-            case Dso::WindowFunction::FLATTOP:
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 1.0 - 1.93 * cos(2 * M_PI * windowPosition / windowEnd) +
-                                                           1.29 * cos(4 * M_PI * windowPosition / windowEnd) -
-                                                           0.388 * cos(6 * M_PI * windowPosition / windowEnd) +
-                                                           0.032 * cos(8 * M_PI * windowPosition / windowEnd);
-                break;
-            default: // Dso::WINDOW_RECTANGULAR
-                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
-                    *(lastWindowBuffer + windowPosition) = 1.0;
-            }
-        }
-
-        // Set sampling interval
-        channelData->spectrum.interval = 1.0 / channelData->voltage.interval / sampleCount;
-
-        // Number of real/complex samples
-        unsigned int dftLength = sampleCount / 2;
-
-        // Reallocate memory for samples if the sample count has changed
-        channelData->spectrum.sample.resize(sampleCount);
-
-        // Create sample buffer and apply window
-        std::unique_ptr<double[]> windowedValues = std::unique_ptr<double[]>(new double[sampleCount]);
-
-        for (unsigned int position = 0; position < sampleCount; ++position)
-            windowedValues[position] = lastWindowBuffer[position] * channelData->voltage.sample[position];
-
-        {
-            // Do discrete real to half-complex transformation
-            /// \todo Check if record length is multiple of 2
-            /// \todo Reuse plan and use FFTW_MEASURE to get fastest algorithm
-            fftw_plan fftPlan = fftw_plan_r2r_1d(sampleCount, windowedValues.get(),
-                                                 &channelData->spectrum.sample.front(), FFTW_R2HC, FFTW_ESTIMATE);
-            fftw_execute(fftPlan);
-            fftw_destroy_plan(fftPlan);
-        }
-
-        // Do an autocorrelation to get the frequency of the signal
-        std::unique_ptr<double[]> conjugateComplex = std::move(windowedValues);
-
-        // Real values
-        unsigned int position;
-        double correctionFactor = 1.0 / dftLength / dftLength;
-        conjugateComplex[0] = (channelData->spectrum.sample[0] * channelData->spectrum.sample[0]) * correctionFactor;
-        for (position = 1; position < dftLength; ++position)
-            conjugateComplex[position] =
-                (channelData->spectrum.sample[position] * channelData->spectrum.sample[position] +
-                 channelData->spectrum.sample[sampleCount - position] *
-                     channelData->spectrum.sample[sampleCount - position]) *
-                correctionFactor;
-        // Complex values, all zero for autocorrelation
-        conjugateComplex[dftLength] =
-            (channelData->spectrum.sample[dftLength] * channelData->spectrum.sample[dftLength]) * correctionFactor;
-        for (++position; position < sampleCount; ++position) conjugateComplex[position] = 0;
-
-        // Do half-complex to real inverse transformation
-        std::unique_ptr<double[]> correlation = std::unique_ptr<double[]>(new double[sampleCount]);
-        fftw_plan fftPlan =
-            fftw_plan_r2r_1d(sampleCount, conjugateComplex.get(), correlation.get(), FFTW_HC2R, FFTW_ESTIMATE);
-        fftw_execute(fftPlan);
-        fftw_destroy_plan(fftPlan);
-
-        // Calculate peak-to-peak voltage
-        double minimalVoltage, maximalVoltage;
-        minimalVoltage = maximalVoltage = channelData->voltage.sample[0];
-
-        for (unsigned int position = 1; position < sampleCount; ++position) {
-            if (channelData->voltage.sample[position] < minimalVoltage)
-                minimalVoltage = channelData->voltage.sample[position];
-            else if (channelData->voltage.sample[position] > maximalVoltage)
-                maximalVoltage = channelData->voltage.sample[position];
-        }
-
-        channelData->amplitude = maximalVoltage - minimalVoltage;
-
-        // Get the frequency from the correlation results
-        double minimumCorrelation = correlation[0];
-        double peakCorrelation = 0;
-        unsigned int peakPosition = 0;
-
-        for (unsigned int position = 1; position < sampleCount / 2; ++position) {
-            if (correlation[position] > peakCorrelation && correlation[position] > minimumCorrelation * 2) {
-                peakCorrelation = correlation[position];
-                peakPosition = position;
-            } else if (correlation[position] < minimumCorrelation)
-                minimumCorrelation = correlation[position];
-        }
-        correlation.reset(nullptr);
-
-        // Calculate the frequency in Hz
-        if (peakPosition)
-            channelData->frequency = 1.0 / (channelData->voltage.interval * peakPosition);
-        else
-            channelData->frequency = 0;
-
-        // Finally calculate the real spectrum if we want it
-        if (scope->spectrum[channel].used) {
-            // Convert values into dB (Relative to the reference level)
-            double offset = 60 - scope->spectrumReference - 20 * log10(dftLength);
-            double offsetLimit = scope->spectrumLimit - scope->spectrumReference;
-            for (std::vector<double>::iterator spectrumIterator = channelData->spectrum.sample.begin();
-                 spectrumIterator != channelData->spectrum.sample.end(); ++spectrumIterator) {
-                double value = 20 * log10(fabs(*spectrumIterator)) + offset;
-
-                // Check if this value has to be limited
-                if (offsetLimit > value) value = offsetLimit;
-
-                *spectrumIterator = value;
-            }
-        }
-    }
-}
-// SPDX-License-Identifier: GPL-2.0+
-
-#include "dataanalyzerresult.h"
-#include <QDebug>
-#include <stdexcept>
-
-DataAnalyzerResult::DataAnalyzerResult(unsigned int channelCount) { analyzedData.resize(channelCount); }
-
-/// \brief Returns the analyzed data.
-/// \param channel Channel, whose data should be returned.
-/// \return Analyzed data as AnalyzedData struct.
-const DataChannel *DataAnalyzerResult::data(ChannelID channel) const {
-    if (channel >= this->analyzedData.size()) return 0;
-
-    return &this->analyzedData[(size_t)channel];
-}
-
-DataChannel *DataAnalyzerResult::modifyData(ChannelID channel) {
-    if (channel >= this->analyzedData.size())
-        throw new std::runtime_error("If you modfiy the DataAnalyzerResult, you "
-                                     "need to set the channels first!");
-
-    return &this->analyzedData[(size_t)channel];
-}
-
-/// \brief Returns the sample count of the analyzed data.
-/// \return The maximum sample count of the last analyzed data.
-unsigned int DataAnalyzerResult::sampleCount() const { return this->maxSamples; }
-
-unsigned int DataAnalyzerResult::channelCount() const { return analyzedData.size(); }
-
-void DataAnalyzerResult::challengeMaxSamples(unsigned int newMaxSamples) {
-    if (newMaxSamples > this->maxSamples) this->maxSamples = newMaxSamples;
-}
-
-unsigned int DataAnalyzerResult::getMaxSamples() const { return maxSamples; }
+// SPDX-License-Identifier: GPL-2.0+
+
+#include <QDebug>
+#include <QMutex>
+#include <exception>
+
+#include "post/graphgenerator.h"
+#include "post/ppresult.h"
+#include "post/softwaretrigger.h"
+#include "hantekdso/controlspecification.h"
+#include "scopesettings.h"
+#include "utils/printutils.h"
+#include "viewconstants.h"
+
+static const SampleValues &useSpecSamplesOf(ChannelID channel, const PPresult *result,
+                                            const DsoSettingsScope *scope) {
+    static SampleValues emptyDefault;
+    if (!scope->spectrum[channel].used || !result->data(channel)) return emptyDefault;
+    return result->data(channel)->spectrum;
+}
+
+static const SampleValues &useVoltSamplesOf(ChannelID channel, const PPresult *result,
+                                            const DsoSettingsScope *scope) {
+    static SampleValues emptyDefault;
+    if (!scope->voltage[channel].used || !result->data(channel)) return emptyDefault;
+    return result->data(channel)->voltage;
+}
+
+GraphGenerator::GraphGenerator(const DsoSettingsScope *scope, bool isSoftwareTriggerDevice)
+    : scope(scope), isSoftwareTriggerDevice(isSoftwareTriggerDevice) {}
+
+bool GraphGenerator::isReady() const { return ready; }
+
+void GraphGenerator::generateGraphsTYvoltage(PPresult *result) {
+    unsigned preTrigSamples = 0;
+    unsigned postTrigSamples = 0;
+    unsigned swTriggerStart = 0;
+
+    // check trigger point for software trigger
+    if (isSoftwareTriggerDevice && scope->trigger.source < result->channelCount())
+        std::tie(preTrigSamples, postTrigSamples, swTriggerStart) = SoftwareTrigger::compute(result, scope);
+    result->softwareTriggerTriggered = postTrigSamples > preTrigSamples;
+
+    result->vaChannelVoltage.resize(scope->voltage.size());
+    for (ChannelID channel = 0; channel < scope->voltage.size(); ++channel) {
+        ChannelGraph &target = result->vaChannelVoltage[channel];
+        const SampleValues &samples = useVoltSamplesOf(channel, result, scope);
+
+        // Check if this channel is used and available at the data analyzer
+        if (samples.sample.empty()) {
+            // Delete all vector arrays
+            target.clear();
+            continue;
+        }
+        // Check if the sample count has changed
+        size_t sampleCount = samples.sample.size();
+        if (sampleCount > 500000) {
+            qWarning() << "Sample count too high!";
+            throw new std::runtime_error("Sample count too high!");
+        }
+        sampleCount -= (swTriggerStart - preTrigSamples);
+        size_t neededSize = sampleCount * 2;
+
+        // Set size directly to avoid reallocations
+        target.resize(neededSize);
+
+        // What's the horizontal distance between sampling points?
+        float horizontalFactor = (float)(samples.interval / scope->horizontal.timebase);
+
+        // Fill vector array
+        std::vector<double>::const_iterator dataIterator = samples.sample.begin();
+        const float gain = (float)scope->gain(channel);
+        const float offset = (float)scope->voltage[channel].offset;
+        const float invert = scope->voltage[channel].inverted ? -1.0f : 1.0f;
+
+        std::advance(dataIterator, swTriggerStart - preTrigSamples);
+
+        for (unsigned int position = 0; position < sampleCount; ++position) {
+            target.push_back(QVector3D(position * horizontalFactor - DIVS_TIME / 2,
+                                       (float)*(dataIterator++) / gain * invert + offset, 0.0));
+        }
+    }
+}
+
+void GraphGenerator::generateGraphsTYspectrum(PPresult *result) {
+    ready = true;
+    result->vaChannelSpectrum.resize(scope->spectrum.size());
+    for (ChannelID channel = 0; channel < scope->voltage.size(); ++channel) {
+        ChannelGraph &target = result->vaChannelSpectrum[channel];
+        const SampleValues &samples = useSpecSamplesOf(channel, result, scope);
+
+        // Check if this channel is used and available at the data analyzer
+        if (samples.sample.empty()) {
+            // Delete all vector arrays
+            target.clear();
+            continue;
+        }
+        // Check if the sample count has changed
+        size_t sampleCount = samples.sample.size();
+        if (sampleCount > 500000) {
+            qWarning() << "Sample count too high!";
+            throw new std::runtime_error("Sample count too high!");
+        }
+        size_t neededSize = sampleCount * 2;
+
+        // Set size directly to avoid reallocations
+        target.resize(neededSize);
+
+        // What's the horizontal distance between sampling points?
+        float horizontalFactor = (float)(samples.interval / scope->horizontal.frequencybase);
+
+        // Fill vector array
+        std::vector<double>::const_iterator dataIterator = samples.sample.begin();
+        const float magnitude = (float)scope->spectrum[channel].magnitude;
+        const float offset = (float)scope->spectrum[channel].offset;
+
+        for (unsigned int position = 0; position < sampleCount; ++position) {
+            target.push_back(QVector3D(position * horizontalFactor - DIVS_TIME / 2,
+                                       (float)*(dataIterator++) / magnitude + offset, 0.0));
+        }
+    }
+}
+
+void GraphGenerator::process(PPresult *data) {
+    if (scope->horizontal.format == Dso::GraphFormat::TY) {
+        ready = true;
+        generateGraphsTYspectrum(data);
+        generateGraphsTYvoltage(data);
+    } else
+        generateGraphsXY(data, scope);
+}
+
+void GraphGenerator::generateGraphsXY(PPresult *result, const DsoSettingsScope *scope) {
+    result->vaChannelVoltage.resize(scope->voltage.size());
+
+    // Delete all spectrum graphs
+    for (ChannelGraph &data : result->vaChannelSpectrum) data.clear();
+
+    // Generate voltage graphs for pairs of channels
+    for (ChannelID channel = 0; channel < scope->voltage.size(); channel += 2) {
+        // We need pairs of channels.
+        if (channel + 1 == scope->voltage.size()) {
+            result->vaChannelVoltage[channel].clear();
+            continue;
+        }
+
+        const ChannelID xChannel = channel;
+        const ChannelID yChannel = channel + 1;
+
+        const SampleValues &xSamples = useVoltSamplesOf(xChannel, result, scope);
+        const SampleValues &ySamples = useVoltSamplesOf(yChannel, result, scope);
+
+        // The channels need to be active
+        if (!xSamples.sample.size() || !ySamples.sample.size()) {
+            result->vaChannelVoltage[channel].clear();
+            result->vaChannelVoltage[channel + 1].clear();
+            continue;
+        }
+
+        // Check if the sample count has changed
+        const size_t sampleCount = std::min(xSamples.sample.size(), ySamples.sample.size());
+        ChannelGraph &drawLines = result->vaChannelVoltage[channel];
+        drawLines.resize(sampleCount * 2);
+
+        // Fill vector array
+        std::vector<double>::const_iterator xIterator = xSamples.sample.begin();
+        std::vector<double>::const_iterator yIterator = ySamples.sample.begin();
+        const double xGain = scope->gain(xChannel);
+        const double yGain = scope->gain(yChannel);
+        const double xOffset = scope->voltage[xChannel].offset;
+        const double yOffset = scope->voltage[yChannel].offset;
+        const double xInvert = scope->voltage[xChannel].inverted ? -1.0 : 1.0;
+        const double yInvert = scope->voltage[yChannel].inverted ? -1.0 : 1.0;
+
+        for (unsigned int position = 0; position < sampleCount; ++position) {
+            drawLines.push_back(QVector3D((float)(*(xIterator++) / xGain * xInvert + xOffset),
+                                          (float)(*(yIterator++) / yGain * yInvert + yOffset), 0.0));
+        }
+    }
+}
+// SPDX-License-Identifier: GPL-2.0+
+
+#pragma once
+
+#include <deque>
+
+#include <QObject>
+#include <QVector3D>
+
+#include "hantekdso/enums.h"
+#include "hantekprotocol/types.h"
+#include "processor.h"
+
+struct DsoSettingsScope;
+class PPresult;
+namespace Dso {
+struct ControlSpecification;
+}
+
+/// \brief Generates ready to be used vertex arrays
+class GraphGenerator : public QObject, public Processor {
+    Q_OBJECT
+
+  public:
+    GraphGenerator(const DsoSettingsScope *scope, bool isSoftwareTriggerDevice);
+    void generateGraphsXY(PPresult *result, const DsoSettingsScope *scope);
+
+    bool isReady() const;
+
+  private:
+    void generateGraphsTYvoltage(PPresult *result);
+    void generateGraphsTYspectrum(PPresult *result);
+
+  private:
+    bool ready = false;
+    const DsoSettingsScope *scope;
+    const bool isSoftwareTriggerDevice;
+
+    // Processor interface
+    private:
+    virtual void process(PPresult *) override;
+};
+#include "mathchannelgenerator.h"
+#include "scopesettings.h"
+
+MathChannelGenerator::MathChannelGenerator(const DsoSettingsScope *scope, unsigned physicalChannels)
+    : physicalChannels(physicalChannels), scope(scope) {}
+
+MathChannelGenerator::~MathChannelGenerator() {}
+
+void MathChannelGenerator::process(PPresult *result) {
+    bool channelsHaveData = !result->data(0)->voltage.sample.empty() && !result->data(1)->voltage.sample.empty();
+    if (!channelsHaveData) return;
+
+    for (ChannelID channel = physicalChannels; channel < result->channelCount(); ++channel) {
+        DataChannel *const channelData = result->modifyData(channel);
+
+        // Math channel enabled?
+        if (!scope->voltage[channel].used && !scope->spectrum[channel].used) continue;
+
+        // Set sampling interval
+        channelData->voltage.interval = result->data(0)->voltage.interval;
+
+        // Resize the sample vector
+        std::vector<double> &resultData = channelData->voltage.sample;
+        resultData.resize(std::min(result->data(0)->voltage.sample.size(), result->data(1)->voltage.sample.size()));
+
+        // Calculate values and write them into the sample buffer
+        std::vector<double>::const_iterator ch1Iterator = result->data(0)->voltage.sample.begin();
+        std::vector<double>::const_iterator ch2Iterator = result->data(1)->voltage.sample.begin();
+        for (std::vector<double>::iterator it = resultData.begin(); it != resultData.end(); ++it) {
+            switch (scope->voltage[physicalChannels].math) {
+            case Dso::MathMode::ADD_CH1_CH2:
+                *it = *ch1Iterator + *ch2Iterator;
+                break;
+            case Dso::MathMode::SUB_CH2_FROM_CH1:
+                *it = *ch1Iterator - *ch2Iterator;
+                break;
+            case Dso::MathMode::SUB_CH1_FROM_CH2:
+                *it = *ch2Iterator - *ch1Iterator;
+                break;
+            }
+            ++ch1Iterator;
+            ++ch2Iterator;
+        }
+    }
+}
+// SPDX-License-Identifier: GPL-2.0+
+
+#pragma once
+
+#include "processor.h"
+
+struct DsoSettingsScope;
+class PPresult;
+
+class MathChannelGenerator : public Processor
+{
+public:
+    MathChannelGenerator(const DsoSettingsScope *scope, unsigned physicalChannels);
+    virtual ~MathChannelGenerator();
+    virtual void process(PPresult *) override;
+private:
+    const unsigned physicalChannels;
+    const DsoSettingsScope *scope;
+};
+#include "postprocessing.h"
+
+PostProcessing::PostProcessing(unsigned channelCount) : channelCount(channelCount) {
+    qRegisterMetaType<std::shared_ptr<PPresult>>();
+}
+
+void PostProcessing::registerProcessor(Processor *processor) { processors.push_back(processor); }
+
+void PostProcessing::convertData(const DSOsamples *source, PPresult *destination) {
+    QReadLocker locker(&source->lock);
+
+    for (ChannelID channel = 0; channel < source->data.size(); ++channel) {
+        const std::vector<double> &rawChannelData = source->data.at(channel);
+
+        if (rawChannelData.empty()) { continue; }
+
+        DataChannel *const channelData = destination->modifyData(channel);
+        channelData->voltage.interval = 1.0 / source->samplerate;
+        channelData->voltage.sample = rawChannelData;
+    }
+}
+
+void PostProcessing::input(const DSOsamples *data) {
+    currentData.reset(new PPresult(channelCount));
+    convertData(data, currentData.get());
+    for (Processor *p : processors) p->process(currentData.get());
+    std::shared_ptr<PPresult> res = std::move(currentData);
+    emit processingFinished(res);
+}
+// SPDX-License-Identifier: GPL-2.0+
+
+#pragma once
+
+#include "dsosamples.h"
+#include "processor.h"
+
+#include <memory>
+#include <vector>
+
+#include <QObject>
+
+struct DsoSettingsScope;
+
+/**
+ * Manages all post processing processors. Register another processor with `registerProcessor(p)`.
+ * All processors, in the order of insertion, will process the input data, given by `input(data)`.
+ * The final result will be made available via the `processingFinished` signal.
+ */
+class PostProcessing : public QObject {
+    Q_OBJECT
+  public:
+    PostProcessing(unsigned channelCount);
+    /**
+     * Adds a new processor that is called when a new input arrived. The order of the processors is
+     * imporant. The first added processor will be called first. This class does not take ownership
+     * of the processors.
+     * @param processor
+     */
+    void registerProcessor(Processor *processor);
+
+
+  private:
+    /// A new `PPresult` is created for each new input. We need to know the channel size.
+    const unsigned channelCount;
+    /// The list of processors. Processors are not memory managed by this class.
+    std::vector<Processor *> processors;
+    ///
+    std::unique_ptr<PPresult> currentData;
+    static void convertData(const DSOsamples *source, PPresult *destination);
+  public slots:
+    /**
+     * Start processing new data. The actual data may be processed in another thread if you have moved
+     * this class object into another thread.
+     * @param data
+     */
+    void input(const DSOsamples *data);
+signals:
+    void processingFinished(std::shared_ptr<PPresult> result);
+};
+
+Q_DECLARE_METATYPE(std::shared_ptr<PPresult>)
+// SPDX-License-Identifier: GPL-2.0+
+
+#include "ppresult.h"
+#include <QDebug>
+#include <stdexcept>
+
+PPresult::PPresult(unsigned int channelCount) { analyzedData.resize(channelCount); }
+
+const DataChannel *PPresult::data(ChannelID channel) const {
+    if (channel >= this->analyzedData.size()) return 0;
+
+    return &this->analyzedData[(size_t)channel];
+}
+
+DataChannel *PPresult::modifyData(ChannelID channel) { return &this->analyzedData[(size_t)channel]; }
+
+unsigned int PPresult::sampleCount() const { return (unsigned)analyzedData[0].voltage.sample.size(); }
+
+unsigned int PPresult::channelCount() const { return (unsigned)analyzedData.size(); }
+
+double DataChannel::computeAmplitude() const {
+    double minimalVoltage, maximalVoltage;
+    minimalVoltage = maximalVoltage = voltage.sample[0];
+
+    for (unsigned int position = 1; position < voltage.sample.size(); ++position) {
+        if (voltage.sample[position] < minimalVoltage)
+            minimalVoltage = voltage.sample[position];
+        else if (voltage.sample[position] > maximalVoltage)
+            maximalVoltage = voltage.sample[position];
+    }
+
+    return maximalVoltage - minimalVoltage;
+}
@@ -2,8 +2,11 @@
  
 #pragma once
  
+#include <QVector3D>
+#include <QReadWriteLock>
+
 #include <vector>
-#include "hantekprotocol/definitions.h"
+#include "hantekprotocol/types.h"
  
 /// \brief Struct for a array of sample values.
 struct SampleValues {
@@ -15,28 +18,34 @@ struct SampleValues {
 struct DataChannel {
     SampleValues voltage;   ///< The time-domain voltage levels (V)
     SampleValues spectrum;  ///< The frequency-domain power levels (dB)
-    double amplitude = 0.0; ///< The amplitude of the signal
+
     double frequency = 0.0; ///< The frequency of the signal
+    // Calculate peak-to-peak voltage
+    double computeAmplitude() const;
 };
  
-/// A result from the { @link DataAnalyzer } class.
-class DataAnalyzerResult {
+typedef std::vector<QVector3D> ChannelGraph;
+typedef std::vector<ChannelGraph> ChannelsGraphs;
+
+/// Post processing results
+class PPresult {
   public:
-    DataAnalyzerResult(unsigned int channelCount);
+    PPresult(unsigned int channelCount);
+
+    /// \brief Returns the analyzed data.
+    /// \param channel Channel, whose data should be returned.
     const DataChannel *data(ChannelID channel) const;
+    /// \brief Returns the analyzed data. The data structure can be modifed.
+    /// \param channel Channel, whose data should be returned.
     DataChannel *modifyData(ChannelID channel);
+    /// \return The maximum sample count of the last analyzed data. This assumes there is at least one channel.
     unsigned int sampleCount() const;
     unsigned int channelCount() const;
  
-    /**
-     * Applies a new maximum samples value, if the given value is higher than the
-     * already stored one
-     * @param newMaxSamples Maximum samples value
-     */
-    void challengeMaxSamples(unsigned int newMaxSamples);
-    unsigned int getMaxSamples() const;
+    bool softwareTriggerTriggered = false;
  
+    ChannelsGraphs vaChannelSpectrum;
+    ChannelsGraphs vaChannelVoltage;
   private:
     std::vector<DataChannel> analyzedData; ///< The analyzed data for each channel
-    unsigned int maxSamples = 0;           ///< The maximum record length of the analyzed data
 };
+#pragma once
+
+#include "ppresult.h"
+
+class Processor {
+public:
+    virtual void process(PPresult*) = 0;
+};
-#include "softwaretrigger.h"
-#include "analyse/dataanalyzerresult.h"
+#include "post/softwaretrigger.h"
+#include "post/ppresult.h"
 #include "scopesettings.h"
 #include "viewconstants.h"
 #include "utils/printutils.h"
  
-SoftwareTrigger::PrePostStartTriggerSamples SoftwareTrigger::compute(const DataAnalyzerResult *data,
+SoftwareTrigger::PrePostStartTriggerSamples SoftwareTrigger::compute(const PPresult *data,
                                                                               const DsoSettingsScope *scope)
 {
     unsigned int preTrigSamples = 0;
 #pragma once
 #include <tuple>
 struct DsoSettingsScope;
-class DataAnalyzerResult;
+class PPresult;
  
  
 /**
@@ -18,5 +18,5 @@ class SoftwareTrigger {
      * @param scope Scope settings
      * @return Returns a tuple of positions [preTrigger, postTrigger, startTrigger]
      */
-    static PrePostStartTriggerSamples compute(const DataAnalyzerResult *data, const DsoSettingsScope *scope);
+    static PrePostStartTriggerSamples compute(const PPresult *data, const DsoSettingsScope *scope);
 };
+// SPDX-License-Identifier: GPL-2.0+
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+
+#include <QColor>
+#include <QMutex>
+#include <QTimer>
+
+#include <fftw3.h>
+
+#include "spectrumgenerator.h"
+
+#include "glscope.h"
+#include "settings.h"
+#include "utils/printutils.h"
+
+/// \brief Analyzes the data from the dso.
+SpectrumGenerator::SpectrumGenerator(const DsoSettingsScope *scope) : scope(scope) {}
+
+SpectrumGenerator::~SpectrumGenerator() {
+    if (lastWindowBuffer) fftw_free(lastWindowBuffer);
+}
+
+void SpectrumGenerator::process(PPresult *result) {
+    // Calculate frequencies and spectrums
+    for (ChannelID channel = 0; channel < result->channelCount(); ++channel) {
+        DataChannel *const channelData = result->modifyData(channel);
+
+        if (channelData->voltage.sample.empty()) {
+            // Clear unused channels
+            channelData->spectrum.interval = 0;
+            channelData->spectrum.sample.clear();
+            continue;
+        }
+
+        // Calculate new window
+        size_t sampleCount = channelData->voltage.sample.size();
+        if (!lastWindowBuffer || lastWindow != scope->spectrumWindow || lastRecordLength != sampleCount) {
+            if (lastWindowBuffer) fftw_free(lastWindowBuffer);
+            lastWindowBuffer = fftw_alloc_real(sampleCount);
+            lastRecordLength = (unsigned)sampleCount;
+
+            unsigned int windowEnd = lastRecordLength - 1;
+            lastWindow = scope->spectrumWindow;
+
+            switch (scope->spectrumWindow) {
+            case Dso::WindowFunction::HAMMING:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 0.54 - 0.46 * cos(2.0 * M_PI * windowPosition / windowEnd);
+                break;
+            case Dso::WindowFunction::HANN:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 0.5 * (1.0 - cos(2.0 * M_PI * windowPosition / windowEnd));
+                break;
+            case Dso::WindowFunction::COSINE:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = sin(M_PI * windowPosition / windowEnd);
+                break;
+            case Dso::WindowFunction::LANCZOS:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition) {
+                    double sincParameter = (2.0 * windowPosition / windowEnd - 1.0) * M_PI;
+                    if (sincParameter == 0)
+                        *(lastWindowBuffer + windowPosition) = 1;
+                    else
+                        *(lastWindowBuffer + windowPosition) = sin(sincParameter) / sincParameter;
+                }
+                break;
+            case Dso::WindowFunction::BARTLETT:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) =
+                        2.0 / windowEnd * (windowEnd / 2 - std::abs((double)(windowPosition - windowEnd / 2.0)));
+                break;
+            case Dso::WindowFunction::TRIANGULAR:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) =
+                        2.0 / lastRecordLength *
+                        (lastRecordLength / 2 - std::abs((double)(windowPosition - windowEnd / 2.0)));
+                break;
+            case Dso::WindowFunction::GAUSS: {
+                double sigma = 0.4;
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) =
+                        exp(-0.5 * pow(((windowPosition - windowEnd / 2) / (sigma * windowEnd / 2)), 2));
+            } break;
+            case Dso::WindowFunction::BARTLETTHANN:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 0.62 -
+                                                           0.48 * std::abs((double)(windowPosition / windowEnd - 0.5)) -
+                                                           0.38 * cos(2.0 * M_PI * windowPosition / windowEnd);
+                break;
+            case Dso::WindowFunction::BLACKMAN: {
+                double alpha = 0.16;
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = (1 - alpha) / 2 -
+                                                           0.5 * cos(2.0 * M_PI * windowPosition / windowEnd) +
+                                                           alpha / 2 * cos(4.0 * M_PI * windowPosition / windowEnd);
+            } break;
+            // case Dso::WindowFunction::WINDOW_KAISER:
+            // TODO WINDOW_KAISER
+            // double alpha = 3.0;
+            // for(unsigned int windowPosition = 0; windowPosition <
+            // lastRecordLength; ++windowPosition)
+            //*(window + windowPosition) = ;
+            // break;
+            case Dso::WindowFunction::NUTTALL:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 0.355768 -
+                                                           0.487396 * cos(2 * M_PI * windowPosition / windowEnd) +
+                                                           0.144232 * cos(4 * M_PI * windowPosition / windowEnd) -
+                                                           0.012604 * cos(6 * M_PI * windowPosition / windowEnd);
+                break;
+            case Dso::WindowFunction::BLACKMANHARRIS:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 0.35875 -
+                                                           0.48829 * cos(2 * M_PI * windowPosition / windowEnd) +
+                                                           0.14128 * cos(4 * M_PI * windowPosition / windowEnd) -
+                                                           0.01168 * cos(6 * M_PI * windowPosition / windowEnd);
+                break;
+            case Dso::WindowFunction::BLACKMANNUTTALL:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 0.3635819 -
+                                                           0.4891775 * cos(2 * M_PI * windowPosition / windowEnd) +
+                                                           0.1365995 * cos(4 * M_PI * windowPosition / windowEnd) -
+                                                           0.0106411 * cos(6 * M_PI * windowPosition / windowEnd);
+                break;
+            case Dso::WindowFunction::FLATTOP:
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 1.0 - 1.93 * cos(2 * M_PI * windowPosition / windowEnd) +
+                                                           1.29 * cos(4 * M_PI * windowPosition / windowEnd) -
+                                                           0.388 * cos(6 * M_PI * windowPosition / windowEnd) +
+                                                           0.032 * cos(8 * M_PI * windowPosition / windowEnd);
+                break;
+            default: // Dso::WINDOW_RECTANGULAR
+                for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
+                    *(lastWindowBuffer + windowPosition) = 1.0;
+            }
+        }
+
+        // Set sampling interval
+        channelData->spectrum.interval = 1.0 / channelData->voltage.interval / sampleCount;
+
+        // Number of real/complex samples
+        unsigned int dftLength = sampleCount / 2;
+
+        // Reallocate memory for samples if the sample count has changed
+        channelData->spectrum.sample.resize(sampleCount);
+
+        // Create sample buffer and apply window
+        std::unique_ptr<double[]> windowedValues = std::unique_ptr<double[]>(new double[sampleCount]);
+
+        for (unsigned int position = 0; position < sampleCount; ++position)
+            windowedValues[position] = lastWindowBuffer[position] * channelData->voltage.sample[position];
+
+        {
+            // Do discrete real to half-complex transformation
+            /// \todo Check if record length is multiple of 2
+            /// \todo Reuse plan and use FFTW_MEASURE to get fastest algorithm
+            fftw_plan fftPlan = fftw_plan_r2r_1d(sampleCount, windowedValues.get(),
+                                                 &channelData->spectrum.sample.front(), FFTW_R2HC, FFTW_ESTIMATE);
+            fftw_execute(fftPlan);
+            fftw_destroy_plan(fftPlan);
+        }
+
+        // Do an autocorrelation to get the frequency of the signal
+        std::unique_ptr<double[]> conjugateComplex = std::move(windowedValues);
+
+        // Real values
+        unsigned int position;
+        double correctionFactor = 1.0 / dftLength / dftLength;
+        conjugateComplex[0] = (channelData->spectrum.sample[0] * channelData->spectrum.sample[0]) * correctionFactor;
+        for (position = 1; position < dftLength; ++position)
+            conjugateComplex[position] =
+                (channelData->spectrum.sample[position] * channelData->spectrum.sample[position] +
+                 channelData->spectrum.sample[sampleCount - position] *
+                     channelData->spectrum.sample[sampleCount - position]) *
+                correctionFactor;
+        // Complex values, all zero for autocorrelation
+        conjugateComplex[dftLength] =
+            (channelData->spectrum.sample[dftLength] * channelData->spectrum.sample[dftLength]) * correctionFactor;
+        for (++position; position < sampleCount; ++position) conjugateComplex[position] = 0;
+
+        // Do half-complex to real inverse transformation
+        std::unique_ptr<double[]> correlation = std::unique_ptr<double[]>(new double[sampleCount]);
+        fftw_plan fftPlan =
+            fftw_plan_r2r_1d(sampleCount, conjugateComplex.get(), correlation.get(), FFTW_HC2R, FFTW_ESTIMATE);
+        fftw_execute(fftPlan);
+        fftw_destroy_plan(fftPlan);
+
+        // Get the frequency from the correlation results
+        double minimumCorrelation = correlation[0];
+        double peakCorrelation = 0;
+        unsigned int peakPosition = 0;
+
+        for (unsigned int position = 1; position < sampleCount / 2; ++position) {
+            if (correlation[position] > peakCorrelation && correlation[position] > minimumCorrelation * 2) {
+                peakCorrelation = correlation[position];
+                peakPosition = position;
+            } else if (correlation[position] < minimumCorrelation)
+                minimumCorrelation = correlation[position];
+        }
+        correlation.reset(nullptr);
+
+        // Calculate the frequency in Hz
+        if (peakPosition)
+            channelData->frequency = 1.0 / (channelData->voltage.interval * peakPosition);
+        else
+            channelData->frequency = 0;
+
+        // Finally calculate the real spectrum if we want it
+        if (scope->spectrum[channel].used) {
+            // Convert values into dB (Relative to the reference level)
+            double offset = 60 - scope->spectrumReference - 20 * log10(dftLength);
+            double offsetLimit = scope->spectrumLimit - scope->spectrumReference;
+            for (std::vector<double>::iterator spectrumIterator = channelData->spectrum.sample.begin();
+                 spectrumIterator != channelData->spectrum.sample.end(); ++spectrumIterator) {
+                double value = 20 * log10(fabs(*spectrumIterator)) + offset;
+
+                // Check if this value has to be limited
+                if (offsetLimit > value) value = offsetLimit;
+
+                *spectrumIterator = value;
+            }
+        }
+    }
+}
@@ -8,43 +8,28 @@
 #include <QThread>
 #include <memory>
  
-#include "dataanalyzerresult.h"
+#include "ppresult.h"
 #include "dsosamples.h"
 #include "utils/printutils.h"
 #include "enums.h"
  
+#include "processor.h"
+
 class DsoSettings;
 struct DsoSettingsScope;
  
 /// \brief Analyzes the data from the dso.
 /// Calculates the spectrum and various data about the signal and saves the
 /// time-/frequencysteps between two values.
-class DataAnalyzer : public QObject {
-    Q_OBJECT
-
+class SpectrumGenerator : public Processor {
   public:
-    ~DataAnalyzer();
-    void applySettings(DsoSettings *settings);
-    void setSourceData(const DSOsamples *data);
-    std::unique_ptr<DataAnalyzerResult> getNextResult();
-    /**
-     * Call this if the source data changed.
-     */
-    void samplesAvailable();
-
-  private:
-    static std::unique_ptr<DataAnalyzerResult> convertData(const DSOsamples *data, const DsoSettingsScope *scope, unsigned physicalChannels);
-    static void spectrumAnalysis(DataAnalyzerResult *result, Dso::WindowFunction &lastWindow,
-                                 unsigned int lastRecordLength, double *&lastWindowBuffer,
-                                 const DsoSettingsScope *scope);
+    SpectrumGenerator(const DsoSettingsScope* scope);
+    virtual ~SpectrumGenerator();
+    virtual void process(PPresult *data) override;
  
   private:
-    DsoSettings *settings;
+    const DsoSettingsScope* scope;
     unsigned int lastRecordLength = 0;                        ///< The record length of the previously analyzed data
     Dso::WindowFunction lastWindow = (Dso::WindowFunction)-1; ///< The previously used dft window function
-    double *window = nullptr;
-    const DSOsamples *sourceData = nullptr;
-    std::unique_ptr<DataAnalyzerResult> lastResult;
-  signals:
-    void analyzed();
+    double *lastWindowBuffer = nullptr;
 };