juce_AffineTransform.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
//==============================================================================
class JUCE_API  AffineTransform  final
{
public:
    //==============================================================================
    AffineTransform() = default;

    AffineTransform (const AffineTransform&) = default;

    AffineTransform (float mat00, float mat01, float mat02,
                     float mat10, float mat11, float mat12) noexcept;

    AffineTransform& operator= (const AffineTransform&) = default;

    bool operator== (const AffineTransform& other) const noexcept;

    bool operator!= (const AffineTransform& other) const noexcept;
 
    //==============================================================================
    template <typename ValueType>
    void transformPoint (ValueType& x, ValueType& y) const noexcept
    {
        auto oldX = x;
        x = static_cast<ValueType> (mat00 * oldX + mat01 * y + mat02);
        y = static_cast<ValueType> (mat10 * oldX + mat11 * y + mat12);
    }

    template <typename ValueType>
    void transformPoints (ValueType& x1, ValueType& y1,
                          ValueType& x2, ValueType& y2) const noexcept
    {
        auto oldX1 = x1, oldX2 = x2;
        x1 = static_cast<ValueType> (mat00 * oldX1 + mat01 * y1 + mat02);
        y1 = static_cast<ValueType> (mat10 * oldX1 + mat11 * y1 + mat12);
        x2 = static_cast<ValueType> (mat00 * oldX2 + mat01 * y2 + mat02);
        y2 = static_cast<ValueType> (mat10 * oldX2 + mat11 * y2 + mat12);
    }

    template <typename ValueType>
    void transformPoints (ValueType& x1, ValueType& y1,
                          ValueType& x2, ValueType& y2,
                          ValueType& x3, ValueType& y3) const noexcept
    {
        auto oldX1 = x1, oldX2 = x2, oldX3 = x3;
        x1 = static_cast<ValueType> (mat00 * oldX1 + mat01 * y1 + mat02);
        y1 = static_cast<ValueType> (mat10 * oldX1 + mat11 * y1 + mat12);
        x2 = static_cast<ValueType> (mat00 * oldX2 + mat01 * y2 + mat02);
        y2 = static_cast<ValueType> (mat10 * oldX2 + mat11 * y2 + mat12);
        x3 = static_cast<ValueType> (mat00 * oldX3 + mat01 * y3 + mat02);
        y3 = static_cast<ValueType> (mat10 * oldX3 + mat11 * y3 + mat12);
    }
 
    //==============================================================================
    AffineTransform translated (float deltaX,
                                float deltaY) const noexcept;

    template <typename PointType>
    AffineTransform translated (PointType delta) const noexcept
    {
        return translated ((float) delta.x, (float) delta.y);
    }

    static AffineTransform translation (float deltaX,
                                        float deltaY) noexcept;

    template <typename PointType>
    static AffineTransform translation (PointType delta) noexcept
    {
        return translation ((float) delta.x, (float) delta.y);
    }

    AffineTransform withAbsoluteTranslation (float translationX,
                                             float translationY) const noexcept;

    AffineTransform rotated (float angleInRadians) const noexcept;

    AffineTransform rotated (float angleInRadians,
                             float pivotX,
                             float pivotY) const noexcept;

    static AffineTransform rotation (float angleInRadians) noexcept;

    static AffineTransform rotation (float angleInRadians,
                                     float pivotX,
                                     float pivotY) noexcept;

    AffineTransform scaled (float factorX,
                            float factorY) const noexcept;

    AffineTransform scaled (float factor) const noexcept;

    AffineTransform scaled (float factorX, float factorY,
                            float pivotX, float pivotY) const noexcept;

    static AffineTransform scale (float factorX,
                                  float factorY) noexcept;

    static AffineTransform scale (float factor) noexcept;

    static AffineTransform scale (float factorX, float factorY,
                                  float pivotX, float pivotY) noexcept;

    AffineTransform sheared (float shearX, float shearY) const noexcept;

    static AffineTransform shear (float shearX, float shearY) noexcept;

    static AffineTransform verticalFlip (float height) noexcept;

    AffineTransform inverted() const noexcept;

    static AffineTransform fromTargetPoints (float x00, float y00,
                                             float x10, float y10,
                                             float x01, float y01) noexcept;

    static AffineTransform fromTargetPoints (float sourceX1, float sourceY1, float targetX1, float targetY1,
                                             float sourceX2, float sourceY2, float targetX2, float targetY2,
                                             float sourceX3, float sourceY3, float targetX3, float targetY3) noexcept;

    template <typename PointType>
    static AffineTransform fromTargetPoints (PointType source1, PointType target1,
                                             PointType source2, PointType target2,
                                             PointType source3, PointType target3) noexcept
    {
        return fromTargetPoints (source1.x, source1.y, target1.x, target1.y,
                                 source2.x, source2.y, target2.x, target2.y,
                                 source3.x, source3.y, target3.x, target3.y);
    }
 
    //==============================================================================
    AffineTransform followedBy (const AffineTransform& other) const noexcept;

    bool isIdentity() const noexcept;

    bool isSingularity() const noexcept;

    bool isOnlyTranslation() const noexcept;

    float getTranslationX() const noexcept                  { return mat02; }

    float getTranslationY() const noexcept                  { return mat12; }

    float getDeterminant() const noexcept;
 
    //==============================================================================
   #ifndef DOXYGEN
    [[deprecated ("This method produces incorrect values for transforms containing rotations. "
                 "See the method docs for a code example on how to calculate the correct scale factor.")]]
    float getScaleFactor() const noexcept;
 
    [[deprecated ("If you need an identity transform, just use AffineTransform() or {}.")]]
    static const AffineTransform identity;
   #endif
 
    //==============================================================================
    /* The transform matrix is:
 
        (mat00 mat01 mat02)
        (mat10 mat11 mat12)
        (  0     0     1  )
    */
    float mat00 { 1.0f }, mat01 { 0.0f }, mat02 { 0.0f };
    float mat10 { 0.0f }, mat11 { 1.0f }, mat12 { 0.0f };
};
 
} // namespace juce