/home/maxime/Projets/Mixxx/1.10/mixxx/src/tonal/Segmentation.hxx

Go to the documentation of this file.

#ifndef Segmentation_hxx
#define Segmentation_hxx

#include <vector>
#include <algorithm>
#include <iterator>
#include <cmath>
#include <sstream>
#include "../defs.h"
//#include "Array.hxx"
//#include "XMLAdapter.hxx"

namespace CLAM
{
        typedef float TData;

        class Segmentation
        {
        public:
                class InsertedOutOfBounds : public std::exception
                {
                        public:
                        const char * what() const throw () { return "Segmentation point inserted out of limits";}
                };
                typedef std::vector<double> TimePositions;
        public:
                Segmentation()
                        : _current(0)
                        , _maxPosition(0)
                {
                }
                Segmentation(double maxPosition)
                        : _current(0)
                        , _maxPosition(maxPosition)
                {
                }
                virtual ~Segmentation();
                virtual unsigned insert(double timePosition)=0;
                virtual void remove(unsigned segment)=0;
                virtual unsigned pickOffset(double timePosition, double tolerance) const=0;
                virtual unsigned pickOnset(double timePosition, double tolerance) const=0;
                virtual unsigned pickSegmentBody(double timePosition) const=0;
                virtual void dragOnset(unsigned segment, double newTimePosition)=0;
                virtual void dragOffset(unsigned segment, double newTimePosition)=0;

                //virtual void fillArray(DataArray& segmentation) const =0;
                virtual void takeArray(const TData * begin, const TData * end) =0;

                const char * GetClassName() const { return "Segmentation"; }

                /*void StoreOn(Storage & storage) const
                {
                        XMLAdapter<double> adapter(_maxPosition, "max", false);
                        storage.Store(adapter);
                        CLAM::DataArray array;
                        fillArray(array);
                        array.StoreOn(storage);
                }*/

                /*void LoadFrom(Storage & storage) 
                {
                        double newmaxPosition;
                        XMLAdapter<double> adapter(newmaxPosition, "max", false);
                        if(storage.Load(adapter))
                        {
                                maxPosition(newmaxPosition);
                        }
                        else    {
                                //when the maxPos is not present, set it to a large number
                                maxPosition(100000);
                        }
                        DataArray array;
                        array.LoadFrom(storage);
                        const unsigned size = array.Size();
                        const TData* ptr=array.GetPtr(); 
                        takeArray(ptr, ptr+size);
                        
                }*/

                void select(unsigned segment)
                {
                        _selection[segment]=true;
                }
                void deselect(unsigned segment)
                {
                        _selection[segment]=false;
                }
                void clearSelection()
                {
                        for (unsigned i=0; i<_selection.size(); i++)
                                _selection[i]=false;
                }

                std::string boundsAsString() const
                {
                        std::ostringstream os;
                        for (unsigned i=0; i<_offsets.size(); i++)
                        {
                                if (_selection[i]) os << "+";
                                os << "(" << _onsets[i] << "," << _offsets[i] << ") ";
                        }
                        return os.str();
                }

                const TimePositions & onsets() const
                {
                        return _onsets;
                }
                const TimePositions & offsets() const
                {
                        return _offsets;
                }
                const std::vector<std::string> & labels() const
                {
                        return _labels;
                }
                void setLabel(unsigned segment, std::string label)
                {
                        if (segment>=_labels.size()) return; // Invalid segment
                        _labels[segment] = label;
                }
                const std::vector<bool> & selections() const
                {
                        return _selection;
                }
                unsigned current() const
                {
                        return _current;
                }
                void current(unsigned index)
                {
                        if (index>=_onsets.size()) return;
                        _current = index;
                }
                double maxPosition() const
                {
                        return _maxPosition;
                }
                virtual void maxPosition(double maxPosition)
                {
                        _maxPosition = maxPosition;
                }
                void xUnits(const std::string & units)
                {
                        _xUnits=units;
                }
                const std::string & xUnits() const
                {
                        return _xUnits;
                }
        protected:
                TimePositions _onsets;
                TimePositions _offsets;
                std::vector<std::string> _labels;
                std::vector<bool> _selection;
                unsigned _current;
                double _maxPosition;
                std::string _xUnits;
        };

}



#endif//Segmentation_hxx