BasicCompressedDenseThreeDimensionalModel.h

Go to the documentation of this file.

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*
    Sonic Visualiser
    An audio file viewer and annotation editor.
    Centre for Digital Music, Queen Mary, University of London.
    This file copyright 2006 Chris Cannam and QMUL.
    
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.  See the file
    COPYING included with this distribution for more information.
*/

#ifndef SV_BASIC_COMPRESSED_DENSE_THREE_DIMENSIONAL_MODEL_H
#define SV_BASIC_COMPRESSED_DENSE_THREE_DIMENSIONAL_MODEL_H

#include "DenseThreeDimensionalModel.h"

#include <QReadWriteLock>

#include <vector>

class BasicCompressedDenseThreeDimensionalModel : public DenseThreeDimensionalModel
{
    Q_OBJECT

public:

    // BasicCompressedDenseThreeDimensionalModel supports a basic
    // compression method that reduces the size of multirate data
    // (e.g. wavelet transform outputs) that are stored as plain 3d
    // grids by about 60% or thereabouts.  However, it can only be
    // used for models whose columns are set in order from 0 and never
    // subsequently changed.  For a model that is actually going to be
    // edited, you need an EditableDenseThreeDimensionalModel.

    BasicCompressedDenseThreeDimensionalModel(sv_samplerate_t sampleRate,
                                              int resolution,
                                              int height,
                                              bool notifyOnAdd = true);

    bool isOK() const override;
    bool isReady(int *completion = 0) const override;
    void setCompletion(int completion, bool update = true);
    int getCompletion() const override;

    sv_samplerate_t getSampleRate() const override;
    sv_frame_t getStartFrame() const override;
    sv_frame_t getTrueEndFrame() const override;

    virtual void setStartFrame(sv_frame_t);

    int getResolution() const override;

    virtual void setResolution(int sz);

    int getWidth() const override;

    int getHeight() const override;

    virtual void setHeight(int sz);

    float getMinimumLevel() const override;

    virtual void setMinimumLevel(float sz);

    float getMaximumLevel() const override;

    virtual void setMaximumLevel(float sz);

    Column getColumn(int x) const override;

    float getValueAt(int x, int n) const override;

    virtual void setColumn(int x, const Column &values);

    QString getBinName(int n) const override;

    virtual void setBinName(int n, QString);

    virtual void setBinNames(std::vector<QString> names);

    bool hasBinValues() const override;

    float getBinValue(int n) const override;

    virtual void setBinValues(std::vector<float> values);

    QString getBinValueUnit() const override;

    virtual void setBinValueUnit(QString unit);

    bool shouldUseLogValueScale() const override;

    QString getTypeName() const override { return tr("Editable Dense 3-D"); }

    QVector<QString>
    getStringExportHeaders(DataExportOptions options) const override;

    QVector<QVector<QString>>
    toStringExportRows(DataExportOptions options,
                       sv_frame_t startFrame,
                       sv_frame_t duration) const override;

    void toXml(QTextStream &out,
                       QString indent = "",
                       QString extraAttributes = "") const override;

protected:
    typedef std::vector<Column> ValueMatrix;
    ValueMatrix m_data;

    // m_trunc is used for simple compression.  If at least the top N
    // elements of column x (for N = some proportion of the column
    // height) are equal to those of an earlier column x', then
    // m_trunc[x] will contain x-x' and column x will be truncated so
    // as to remove the duplicate elements.  If the equal elements are
    // at the bottom, then m_trunc[x] will contain x'-x (a negative
    // value).  If m_trunc[x] is 0 then the whole of column x is
    // stored.
    std::vector<signed char> m_trunc;
    void truncateAndStore(int index, const Column & values);
    Column expandAndRetrieve(int index) const;
    Column rightHeight(const Column &c) const;

    std::vector<QString> m_binNames;
    std::vector<float> m_binValues;
    QString m_binValueUnit;

    sv_frame_t m_startFrame;
    sv_samplerate_t m_sampleRate;
    int m_resolution;
    int m_yBinCount;
    float m_minimum;
    float m_maximum;
    bool m_haveExtents;
    bool m_notifyOnAdd;
    sv_frame_t m_sinceLastNotifyMin;
    sv_frame_t m_sinceLastNotifyMax;
    int m_completion;

    mutable QReadWriteLock m_lock;
};

#endif