DiscontinuousSegmentation.hxx

Go to the documentation of this file.

#ifndef DiscontinuousSegmentation_hxx
#define DiscontinuousSegmentation_hxx

#include "Segmentation.hxx"

namespace CLAM
{
        class DiscontinuousSegmentation : public Segmentation
        {
        public:
                class InsertedOutOfBounds : public std::exception
                {
                        public:
                        const char * what() const throw () { return "Segmentation point inserted out of limits";}
                };
                class OffsetMissing : public std::exception
                {
                        public:
                        const char * what() const throw () { return "Odd number of segmentation points, every segment beggining must be followed by its ending";}
                };
                class MissplacedOnset : public std::exception
                {
                        std::string _message;
                        public:
                        MissplacedOnset(unsigned missplacedOnset,
                                        double previousOffsetPosition,
                                        double intendedOnsetPosition)
                        {
                                std::ostringstream os;
                                os << "Segment " << missplacedOnset
                                        << " starts at " << intendedOnsetPosition
                                        << " overlapping previous segment which ends at " << previousOffsetPosition;
                                _message = os.str();
                        }
                        virtual ~MissplacedOnset() throw () {}
                        const char * what() const throw () { return _message.c_str(); }
                };
                class MissplacedOffset : public std::exception
                {
                        std::string _message;
                        public:
                        MissplacedOffset(unsigned missplacedOffset,
                                        double onsetPosition,
                                        double offsetPosition)
                        {
                                std::ostringstream os;
                                os << "Segment " << missplacedOffset
                                        << " starts at " << onsetPosition
                                        << " but ends before that, at " << offsetPosition;
                                _message = os.str();
                        }
                        virtual ~MissplacedOffset() throw () {}
                        const char * what() const throw () { return _message.c_str(); }
                };
                typedef std::vector<double> TimePositions;
        public:
                DiscontinuousSegmentation(double maxPosition=0)
                        : Segmentation(maxPosition)
                {
                }
                DiscontinuousSegmentation(double maxPosition, const TData * begin, const TData * end)
                        : Segmentation(maxPosition)
                {
                        takeArray(begin, end);
                }
                void takeArray(const TData * begin, const TData * end)
                {
                        double previousOffset=0.0;
                        unsigned i=0;
                        for (const TData* it=begin; it!=end; i++)
                        {
                                double onset = *it++;
                                std::cout << onset << " " << std::flush;
                                if (onset<previousOffset) throw MissplacedOnset(i,previousOffset,onset);
                                if (it==end) throw OffsetMissing();
                                double offset = *it++;
                                std::cout << offset << " " << std::flush;
                                if (offset<onset) throw MissplacedOffset(i, onset, offset);
                                if (offset>_maxPosition) throw InsertedOutOfBounds();  //_maxPosition 
                                _onsets.push_back(onset);
                                _offsets.push_back(offset);
                                _labels.push_back(""); // TODO: a constructor with not empty labels
                                _selection.push_back(false);
                                previousOffset=offset;
                        }
                }
                unsigned insert(double timePosition)
                {
                        if (timePosition<0.0) throw InsertedOutOfBounds();
                        if (timePosition>_maxPosition) throw InsertedOutOfBounds();
                        TimePositions::iterator nextOffset = 
                                std::lower_bound(_offsets.begin(), _offsets.end(), timePosition);
                        if (nextOffset == _offsets.end()) // Beyond any existing segment
                        {
                                _onsets.push_back(timePosition);
                                _offsets.push_back(_maxPosition);
                                _labels.push_back("");
                                _selection.push_back(false);
                                return _onsets.size()-1;
                        }
                        // 'nextOffsetPosition' must be computed before the insertion to not invalidate iterators.
                        unsigned nextOffsetPosition = nextOffset - _offsets.begin();
                        if (_onsets[nextOffsetPosition]<=timePosition) // Just in the middle of a segment
                        {
                                _offsets.insert(nextOffset, timePosition);
                                _onsets.insert(_onsets.begin()+nextOffsetPosition+1, timePosition);
                                _labels.insert(_labels.begin()+nextOffsetPosition+1, "");
                                _selection.insert(_selection.begin()+nextOffsetPosition+1, false);
                                if (nextOffsetPosition<_current) _current++;
                                return nextOffsetPosition+1;
                        }
                        else // In a gap before a segment
                        {
                                _offsets.insert(nextOffset, _onsets[nextOffsetPosition]);
                                _onsets.insert(_onsets.begin()+nextOffsetPosition, timePosition);
                                _labels.insert(_labels.begin()+nextOffsetPosition, "");
                                _selection.insert(_selection.begin()+nextOffsetPosition, false);
                                if (_current>=nextOffsetPosition) _current++;
                                return nextOffsetPosition;
                        }
                        
                }
                unsigned insert(double timePosition, std::string label)
                {
                        unsigned segment = insert(timePosition);
                        setLabel(segment, label);
                        return segment;
                }
                void remove(unsigned segment)
                {
                        _offsets.erase(_offsets.begin()+segment);
                        _onsets.erase(_onsets.begin()+segment);
                        _labels.erase(_labels.begin()+segment);
                        _selection.erase(_selection.begin()+segment);
                        if (_current!=0 && segment<=_current) _current--;
                }
                unsigned pickOffset(double timePosition, double tolerance) const
                {
                        return pickPosition(_offsets, timePosition, tolerance);
                }
                unsigned pickOnset(double timePosition, double tolerance) const
                {
                        return pickPosition(_onsets, timePosition, tolerance);
                }
                unsigned pickSegmentBody(double timePosition) const
                {
                        if (timePosition<0) return _offsets.size();
                        TimePositions::const_iterator lowerBound =
                                std::lower_bound(_offsets.begin(), _offsets.end(), timePosition);
                        unsigned index = lowerBound-_offsets.begin();
                        if (index==_offsets.size()) return index;
                        if (_onsets[index]>timePosition) return _offsets.size();
                        return index;
                }
                void dragOnset(unsigned segment, double newTimePosition)
                {
                        // The onset is attached to the previous offset
                        if (segment>=_onsets.size()) return; // Invalid segment

                        // Limit to the left to the previous onset or 0
                        double leftBound = segment ? _offsets[segment-1] : 0;
                        if (newTimePosition<leftBound)
                                newTimePosition=leftBound;
                        // Limit to the right to the own offset
                        double rigthBound = _offsets[segment];
                        if (newTimePosition>rigthBound)
                                newTimePosition=rigthBound;

                        // The offset and the next onset change together
                        _onsets[segment]=newTimePosition;
                }
                void dragOffset(unsigned segment, double newTimePosition)
                {
                        if (segment>=_offsets.size()) return; // Invalid segment

                        // Limit to the right to the next offset or max
                        double rigthBound = segment+1==_offsets.size()? _maxPosition : _onsets[segment+1];
                        if (newTimePosition>rigthBound)
                                newTimePosition=rigthBound;
                        // Limit to the left to the own onset
                        double leftBound = _onsets[segment];
                        if (newTimePosition<leftBound)
                                newTimePosition=leftBound;

                        // The offset and the next onset change together
                        _offsets[segment]=newTimePosition;
                }
                void fillArray(DataArray& segmentation) const
                {
                        unsigned nSegments = _onsets.size();
                        segmentation.Resize(nSegments*2);
                        segmentation.SetSize(nSegments*2);
                        for (unsigned i=0; i<nSegments; i++)
                                {
                                        segmentation[i*2] = _onsets[i];
                                        segmentation[i*2+1] = _offsets[i];
                                }
                }

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


        private:
                unsigned pickPosition(const TimePositions & positions, double timePosition, double tolerance) const
                {
                        TimePositions::const_iterator lowerBound = 
                                std::lower_bound(positions.begin(), positions.end(), timePosition-tolerance);
                        TimePositions::const_iterator upperBound = 
                                std::upper_bound(lowerBound, positions.end(), timePosition+tolerance);

                        if (lowerBound==upperBound) return positions.size(); // None found
        
                        // Pick the closest in range
                        unsigned lowerSegment = lowerBound - positions.begin();
                        unsigned upperSegment = upperBound - positions.begin();
                        double lastDifference = std::fabs(timePosition-positions[lowerSegment]);
                        for (unsigned i=lowerSegment; i<upperSegment; i++)
                        {
                                double newDifference = std::fabs(timePosition-positions[i]);
                                if (newDifference>lastDifference) break;
                                lastDifference = newDifference;
                                lowerSegment = i;
                        }
                        return lowerSegment;
                }
        };

}



#endif//DiscontinuousSegmentation_hxx