elliptical-arc.h

Go to the documentation of this file.

/*
 * Authors:
 *    MenTaLguY <mental@rydia.net>
 *    Marco Cecchetti <mrcekets at gmail.com>
 *    Krzysztof Kosiński <tweenk.pl@gmail.com>
 * 
 * Copyright 2007-2009 Authors
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 */
 
#ifndef LIB2GEOM_SEEN_ELLIPTICAL_ARC_H
#define LIB2GEOM_SEEN_ELLIPTICAL_ARC_H
 
#include <algorithm>
#include <2geom/affine.h>
#include <2geom/angle.h>
#include <2geom/bezier-curve.h>
#include <2geom/curve.h>
#include <2geom/ellipse.h>
#include <2geom/sbasis-curve.h>  // for non-native methods
#include <2geom/utils.h>
 
namespace Geom 
{
 
class EllipticalArc : public Curve
{
public:
    EllipticalArc()
        : _initial_point(0,0)
        , _final_point(0,0)
        , _large_arc(false)
    {}
    EllipticalArc( Point const &ip, Point const &r,
                   Coord rot_angle, bool large_arc, bool sweep,
                   Point const &fp
                 )
        : _initial_point(ip)
        , _final_point(fp)
        , _ellipse(0, 0, r[X], r[Y], rot_angle)
        , _angles(0, 0, sweep)
        , _large_arc(large_arc)
    {
        _updateCenterAndAngles();
    }
 
    EllipticalArc( Point const &ip, Coord rx, Coord ry,
                   Coord rot_angle, bool large_arc, bool sweep,
                   Point const &fp
                 )
        : _initial_point(ip)
        , _final_point(fp)
        , _ellipse(0, 0, rx, ry, rot_angle)
        , _angles(0, 0, sweep)
        , _large_arc(large_arc)
    {
        _updateCenterAndAngles();
    }
 
 
    Coord center(Dim2 d) const { return _ellipse.center(d); }
 
    Point center() const { return _ellipse.center(); }
 
    Coord ray(Dim2 d) const { return _ellipse.ray(d); }
 
    Point rays() const { return _ellipse.rays(); }
 
    Angle rotationAngle() const {
        return _ellipse.rotationAngle();
    }
 
    bool largeArc() const { return _large_arc; }
 
    bool sweep() const { return _angles.sweep(); }
 
    Angle initialAngle() const { return _angles.initialAngle(); }
    Angle finalAngle() const { return _angles.finalAngle(); }
 
 
    void set( Point const &ip, double rx, double ry,
              double rot_angle, bool large_arc, bool sweep,
              Point const &fp
            )
    {
        _initial_point = ip;
        _final_point = fp;
        _ellipse.setRays(rx, ry);
        _ellipse.setRotationAngle(rot_angle);
        _angles.setSweep(sweep);
        _large_arc = large_arc;
        _updateCenterAndAngles();
    }
 
    void set( Point const &ip, Point const &r,
              Angle rot_angle, bool large_arc, bool sweep,
              Point const &fp
            )
    {
        _initial_point = ip;
        _final_point = fp;
        _ellipse.setRays(r);
        _ellipse.setRotationAngle(rot_angle);
        _angles.setSweep(sweep);
        _large_arc = large_arc;
        _updateCenterAndAngles();
    }
 
    void setEndpoints(Point const &ip, Point const &fp) {
        _initial_point = ip;
        _final_point = fp;
        _updateCenterAndAngles();
    }
 
 
    bool containsAngle(Angle angle) const { return _angles.contains(angle); }
 
    Point pointAtAngle(Coord t) const;
 
    Coord valueAtAngle(Coord t, Dim2 d) const;
 
    Coord timeAtAngle(Angle a) const { return _angles.timeAtAngle(a); }
 
    Angle angleAt(Coord t) const { return _angles.angleAt(t); }
 
    Coord sweepAngle() const { return _angles.sweepAngle(); }
 
    Coord angularExtent() const { return _angles.extent(); }
 
    AngleInterval angularInterval() const { return _angles; }
 
    Point pointAt(Coord t) const override;
 
    Coord valueAt(Coord t, Dim2 d) const override;
 
    Affine unitCircleTransform() const {
        Affine result = _ellipse.unitCircleTransform();
        return result;
    }
 
    Affine inverseUnitCircleTransform() const {
        Affine result = _ellipse.inverseUnitCircleTransform();
        return result;
    }
 
 
    bool isChord() const {
        return ray(X) == 0 || ray(Y) == 0;
    }
 
    LineSegment chord() const { return LineSegment(_initial_point, _final_point); }
 
    // implementation of overloads goes here
    Point initialPoint() const override { return _initial_point; }
    Point finalPoint() const override { return _final_point; }
    Curve* duplicate() const override { return new EllipticalArc(*this); }
    void setInitial(Point const &p) override {
        _initial_point = p;
        _updateCenterAndAngles();
    }
    void setFinal(Point const &p) override {
        _final_point = p;
        _updateCenterAndAngles();
    }
    bool isDegenerate() const override {
        return _initial_point == _final_point;
    }
    bool isLineSegment() const override { return isChord(); }
    Rect boundsFast() const override {
        return boundsExact();
    }
    Rect boundsExact() const override;
    void expandToTransformed(Rect &bbox, Affine const &transform) const override;
    // TODO: native implementation of the following methods
    OptRect boundsLocal(OptInterval const &i, unsigned int deg) const override {
        return SBasisCurve(toSBasis()).boundsLocal(i, deg);
    }
    std::vector<double> roots(double v, Dim2 d) const override;
#ifdef HAVE_GSL
    std::vector<double> allNearestTimes( Point const& p, double from = 0, double to = 1 ) const override;
    double nearestTime( Point const& p, double from = 0, double to = 1 ) const override {
        if ( are_near(ray(X), ray(Y)) && are_near(center(), p) ) {
            return from;
        }
        return allNearestTimes(p, from, to).front();
    }
#endif
    std::vector<CurveIntersection> intersect(Curve const &other, Coord eps=EPSILON) const override;
    int degreesOfFreedom() const override { return 7; }
    Curve *derivative() const override;
 
    using Curve::operator*=;
    void operator*=(Translate const &tr) override;
    void operator*=(Scale const &s) override;
    void operator*=(Rotate const &r) override;
    void operator*=(Zoom const &z) override;
    void operator*=(Affine const &m) override;
 
    std::vector<Point> pointAndDerivatives(Coord t, unsigned int n) const override;
    D2<SBasis> toSBasis() const override;
    Curve *portion(double f, double t) const override;
    Curve *reverse() const override;
    bool isNear(Curve const &other, Coord precision) const override;
    void feed(PathSink &sink, bool moveto_initial) const override;
    int winding(Point const &p) const override;
 
protected:
    bool _equalTo(Curve const &c) const override;
 
private:
    void _updateCenterAndAngles();
    std::vector<ShapeIntersection> _filterIntersections(std::vector<ShapeIntersection> &&xs, bool is_first) const;
    bool _validateIntersection(ShapeIntersection &xing, bool is_first) const;
    std::vector<ShapeIntersection> _intersectSameEllipse(EllipticalArc const *other) const;
 
    Point _initial_point, _final_point;
    Ellipse _ellipse;
    AngleInterval _angles;
    bool _large_arc;
}; // end class EllipticalArc
 
 
// implemented in elliptical-arc-from-sbasis.cpp
bool arc_from_sbasis(EllipticalArc &ea, D2<SBasis> const &in,
                     double tolerance = EPSILON, unsigned num_samples = 20);
 
std::ostream &operator<<(std::ostream &out, EllipticalArc const &ea);
 
} // end namespace Geom
 
#endif // LIB2GEOM_SEEN_ELLIPTICAL_ARC_H
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :