CRNStroke.h

Go to the documentation of this file.

/* Copyright 2008-2016 INSA Lyon, CoReNum, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNStroke.h
 * \author Yann LEYDIER
 */

#ifndef CRNSTROKE_HEADER
#define CRNSTROKE_HEADER

#include <CRNObject.h>
#include <CRNData/CRNVector.h>
#include <CRNGeometry/CRNPoint2DInt.h>
#include <CRNGeometry/CRNRect.h>

namespace crn
{
    class Stroke;
    CRN_ALIAS_SMART_PTR(Stroke)
}
namespace crn
{
    /****************************************************************************/
    class Stroke: public Object
    {
        public:
            using datatype = std::vector<Point2DInt>;

            Stroke();
            virtual ~Stroke() override;

            Stroke(const Stroke &other);
            Stroke& operator=(const Stroke &other);
            Stroke(Stroke&&) = default;
            Stroke& operator=(Stroke&&) = default;

            void AddPoint(const Point2DInt &p);

            void MergeAtEnd(const Stroke &str);
            void MergeWithXInterpolation(const Stroke &str, unsigned int step = 1);

            size_t GetNbPoints() const noexcept { return points.size(); }
            Point2DInt& GetPoint(size_t index);
            const Point2DInt& GetPoint(size_t index) const;
            Point2DInt& operator[](size_t index) { return points[index]; }
            const Point2DInt& operator[](size_t index) const { return points[index]; }

            double GetFirstYAtX(double x) const;

            Rect GetBBox() const;

            Stroke MakeIntersection(const Rect &rect) const;
            Stroke MakeFirstIntersection(const Rect &rect) const;

            using iterator = datatype::iterator;
            iterator begin() { return points.begin(); } 
            iterator end() { return points.end(); } 
            using const_iterator = datatype::const_iterator;
            const_iterator begin() const { return points.begin(); } 
            const_iterator end() const { return points.end(); } 
            const_iterator cbegin() const { return points.cbegin(); } 
            const_iterator cend() const { return points.cend(); } 
            
            void Deserialize(xml::Element &el);
            xml::Element Serialize(xml::Element &parent) const;
            
        private:
            datatype points; 
            mutable SRect bbox; 
        CRN_DECLARE_CLASS_CONSTRUCTOR(Stroke)
        CRN_SERIALIZATION_CONSTRUCTOR(Stroke)
    };
    template<> struct IsSerializable<Stroke> : public std::true_type {};
    template<> struct IsClonable<Stroke> : public std::true_type {};

    inline size_t Size(const Stroke &s) noexcept { return s.GetNbPoints(); }
}
CRN_ADD_RANGED_FOR_TO_POINTERS(crn::Stroke)
CRN_ADD_RANGED_FOR_TO_CONST_POINTERS(crn::Stroke)

#endif