transform_trs.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <geometry/transform_trs.h>
#include <trigo.h>
 
#include <algorithm>
#include <cmath>
 
 
// Composing and decomposing a rotation can leave a scale one unit in the last place off
static bool sameScale( double aA, double aB )
{
    return std::abs( aA - aB ) <= 1e-9 * std::max( std::abs( aA ), std::abs( aB ) );
}
 
 
VECTOR2D TRANSFORM_TRS::Apply( const VECTOR2D& aPoint ) const
{
    VECTOR2D scaled( aPoint.x * m_scaleX, aPoint.y * m_scaleY );
    RotatePoint( scaled, m_rotate );
    return scaled + VECTOR2D( m_translate );
}
 
 
VECTOR2I TRANSFORM_TRS::Apply( const VECTOR2I& aPoint ) const
{
    VECTOR2D r = Apply( VECTOR2D( aPoint ) );
    return VECTOR2I( KiROUND( r.x ), KiROUND( r.y ) );
}
 
 
VECTOR2D TRANSFORM_TRS::InverseApply( const VECTOR2D& aPoint ) const
{
    VECTOR2D shifted = aPoint - VECTOR2D( m_translate );
    RotatePoint( shifted, -m_rotate );
    return VECTOR2D( shifted.x / m_scaleX, shifted.y / m_scaleY );
}
 
 
VECTOR2I TRANSFORM_TRS::InverseApply( const VECTOR2I& aPoint ) const
{
    VECTOR2D r = InverseApply( VECTOR2D( aPoint ) );
    return VECTOR2I( KiROUND( r.x ), KiROUND( r.y ) );
}
 
 
TRANSFORM_TRS TRANSFORM_TRS::RescaleAround( const VECTOR2I& aFixedPoint,
                                            double aSx, double aSy ) const
{
    TRANSFORM_TRS result = *this;
 
    // aSx/aSy are scale multipliers in the footprint's own frame, so the local
    // scale factors scale directly.
    result.m_scaleX = m_scaleX * aSx;
    result.m_scaleY = m_scaleY * aSy;
 
    // The offset from the fixed point is in board axes. Rotate it into the
    // footprint frame, scale it there, then rotate back (R D R^-1) so the position
    // move matches the local scaling when the footprint is rotated.
    VECTOR2D offset( m_translate.x - aFixedPoint.x, m_translate.y - aFixedPoint.y );
    RotatePoint( offset, -m_rotate );
    offset.x *= aSx;
    offset.y *= aSy;
    RotatePoint( offset, m_rotate );
 
    result.m_translate = VECTOR2I( KiROUND( aFixedPoint.x + offset.x ), KiROUND( aFixedPoint.y + offset.y ) );
    return result;
}
 
 
bool TRANSFORM_TRS::IsIdentity() const
{
    return m_translate == VECTOR2I( 0, 0 ) && m_rotate.IsZero() && HasUnitScale();
}
 
 
bool TRANSFORM_TRS::IsUniformScale() const
{
    return sameScale( m_scaleX, m_scaleY );
}
 
 
bool TRANSFORM_TRS::HasUnitScale() const
{
    return sameScale( m_scaleX, 1.0 ) && sameScale( m_scaleY, 1.0 );
}
 
 
double TRANSFORM_TRS::ApplyLinearScale( double aLength ) const
{
    double scale = IsUniformScale() ? m_scaleX : ( m_scaleX + m_scaleY ) / 2;
 
    return aLength * scale;
}
 
 
double TRANSFORM_TRS::InverseApplyLinearScale( double aLength ) const
{
    double scale = IsUniformScale() ? m_scaleX : ( m_scaleX + m_scaleY ) / 2;
 
    return aLength / scale;
}
 
 
bool TRANSFORM_TRS::operator==( const TRANSFORM_TRS& aOther ) const
{
    return m_translate == aOther.m_translate
           && m_rotate == aOther.m_rotate
           && m_scaleX == aOther.m_scaleX
           && m_scaleY == aOther.m_scaleY;
}