affine.h

Go to the documentation of this file.

/*
 * Authors:
 *   Lauris Kaplinski <lauris@kaplinski.com> (Original NRAffine definition and related macros)
 *   Nathan Hurst <njh@mail.csse.monash.edu.au> (Geom::Affine class version of the above)
 *   Michael G. Sloan <mgsloan@gmail.com> (reorganization and additions)
 *   Krzysztof Kosiński <tweenk.pl@gmail.com> (removal of boilerplate, docs)
 *
 * This code is in public domain.
 */
 
#ifndef LIB2GEOM_SEEN_AFFINE_H
#define LIB2GEOM_SEEN_AFFINE_H
 
#include <boost/operators.hpp>
#include <2geom/forward.h>
#include <2geom/point.h>
#include <2geom/utils.h>
 
namespace Geom {
 
class Affine
    : boost::equality_comparable< Affine // generates operator!= from operator==
    , boost::multipliable1< Affine
    , MultipliableNoncommutative< Affine, Translate
    , MultipliableNoncommutative< Affine, Scale
    , MultipliableNoncommutative< Affine, Rotate
    , MultipliableNoncommutative< Affine, HShear
    , MultipliableNoncommutative< Affine, VShear
    , MultipliableNoncommutative< Affine, Zoom
      > > > > > > > >
{
    Coord _c[6];
public:
    Affine() {
        _c[0] = _c[3] = 1;
        _c[1] = _c[2] = _c[4] = _c[5] = 0;
    }
 
    Affine(Coord c0, Coord c1, Coord c2, Coord c3, Coord c4, Coord c5) {
        _c[0] = c0; _c[1] = c1;
        _c[2] = c2; _c[3] = c3;
        _c[4] = c4; _c[5] = c5;
    }
 
    inline Coord operator[](unsigned i) const { return _c[i]; }
    inline Coord &operator[](unsigned i) { return _c[i]; }
 
    Affine &operator*=(Affine const &m);
    // implemented in transforms.cpp
    Affine &operator*=(Translate const &t);
    Affine &operator*=(Scale const &s);
    Affine &operator*=(Rotate const &r);
    Affine &operator*=(HShear const &h);
    Affine &operator*=(VShear const &v);
    Affine &operator*=(Zoom const &);
 
    bool operator==(Affine const &o) const {
        for(unsigned i = 0; i < 6; ++i) {
            if ( _c[i] != o._c[i] ) return false;
        }
        return true;
    }
 
    Point xAxis() const;
    Point yAxis() const;
    Point translation() const;
    Coord expansionX() const;
    Coord expansionY() const;
    Point expansion() const { return Point(expansionX(), expansionY()); }
    
    void setXAxis(Point const &vec);
    void setYAxis(Point const &vec);
 
    void setTranslation(Point const &loc);
 
    void setExpansionX(Coord val);
    void setExpansionY(Coord val);
    void setIdentity();
 
    bool isIdentity(Coord eps = EPSILON) const;
 
    bool isTranslation(Coord eps = EPSILON) const;
    bool isScale(Coord eps = EPSILON) const;
    bool isUniformScale(Coord eps = EPSILON) const;
    bool isRotation(Coord eps = EPSILON) const;
    bool isHShear(Coord eps = EPSILON) const;
    bool isVShear(Coord eps = EPSILON) const;
 
    bool isNonzeroTranslation(Coord eps = EPSILON) const;
    bool isNonzeroScale(Coord eps = EPSILON) const;
    bool isNonzeroUniformScale(Coord eps = EPSILON) const;
    bool isNonzeroRotation(Coord eps = EPSILON) const;
    bool isNonzeroNonpureRotation(Coord eps = EPSILON) const;
    Point rotationCenter() const;
    bool isNonzeroHShear(Coord eps = EPSILON) const;
    bool isNonzeroVShear(Coord eps = EPSILON) const;
 
    bool isZoom(Coord eps = EPSILON) const;
    bool preservesArea(Coord eps = EPSILON) const;
    bool preservesAngles(Coord eps = EPSILON) const;
    bool preservesDistances(Coord eps = EPSILON) const;
    bool flips() const;
 
    bool isSingular(Coord eps = EPSILON) const;
 
    Affine withoutTranslation() const {
        Affine ret(*this);
        ret.setTranslation(Point(0,0));
        return ret;
    }
    Affine inverse() const;
 
    Coord det() const;
    Coord descrim2() const;
    Coord descrim() const;
    inline static Affine identity();
};
 
inline std::ostream &operator<< (std::ostream &out_file, const Geom::Affine &m) {
    out_file << "A: " << m[0] << "  C: " << m[2] << "  E: " << m[4] << "\n";
    out_file << "B: " << m[1] << "  D: " << m[3] << "  F: " << m[5] << "\n";
    return out_file;
}
 
// Affine factories
Affine from_basis(const Point &x_basis, const Point &y_basis, const Point &offset=Point(0,0));
Affine elliptic_quadratic_form(Affine const &m);
 
class Eigen{
public:
    Point vectors[2];
    double values[2];
    Eigen(Affine const &m);
    Eigen(double M[2][2]);
};
 
inline Affine identity() {
    Affine ret(Affine::identity());
    return ret; // allow NRVO
}
 
inline Affine Affine::identity() {
    Affine ret(1.0, 0.0,
               0.0, 1.0,
               0.0, 0.0);
    return ret; // allow NRVO
}
 
bool are_near(Affine const &a1, Affine const &a2, Coord eps=EPSILON);
 
} // end namespace Geom
 
#endif // LIB2GEOM_SEEN_AFFINE_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 :