kicad/common/trigo.cpp

/**
 * @file trigo.cpp
 * @brief Trigonometric functions.
 */

#include <fctsys.h>
#include <macros.h>
#include <trigo.h>
#include <common.h>

static bool DistanceTest( int seuil, int dx, int dy, int spot_cX, int spot_cY );

bool TestSegmentHit( wxPoint aRefPoint, wxPoint aStart, wxPoint aEnd, int aDist )
{
    return DistanceTest( aDist, aEnd.x - aStart.x, aEnd.y - aStart.y,
                         aRefPoint.x - aStart.x, aRefPoint.y - aStart.y );
}


bool DistanceTest( int seuil, int dx, int dy, int spot_cX, int spot_cY )
{
    /*  We can have 4 cases::
     *      horizontal segment
     *      vertical segment
     *      45 degrees segment
     *      other slopes
     */
    int cXrot, cYrot, segX, segY;
    int pointX, pointY;

    segX   = dx;
    segY   = dy;
    pointX = spot_cX;
    pointY = spot_cY;

    /* Recalculating coord for the segment is in 1st quadrant (coord >= 0) */
    if( segX < 0 )   /* set > 0 by symmetry about the Y axis */
    {
        segX   = -segX;
        pointX = -pointX;
    }

    if( segY < 0 )   /* set > 0 by symmetry about the X axis */
    {
        segY   = -segY;
        pointY = -pointY;
    }


    if( segY == 0 ) /* horizontal */
    {
        if( abs( pointY ) <= seuil )
        {
            if( ( pointX >= 0 ) && ( pointX <= segX ) )
                return 1;

            if( ( pointX < 0 ) && ( pointX >= -seuil ) )
            {
                if( ( ( pointX * pointX ) + ( pointY * pointY ) ) <= ( seuil * seuil ) )
                    return true;
            }
            if( ( pointX > segX ) && ( pointX <= ( segX + seuil ) ) )
            {
                if( ( ( ( pointX - segX ) * ( pointX - segX ) )
                     + ( pointY * pointY ) ) <= ( seuil * seuil ) )
                    return true;
            }
        }
    }
    else if( segX == 0 ) /* vertical */
    {
        if( abs( pointX ) <= seuil )
        {
            if( ( pointY >= 0 ) && ( pointY <= segY ) )
                return true;

            if( ( pointY < 0 ) && ( pointY >= -seuil ) )
            {
                if( ( ( pointY * pointY ) + ( pointX * pointX ) ) <= ( seuil * seuil ) )
                    return true;
            }

            if( ( pointY > segY ) && ( pointY <= ( segY + seuil ) ) )
            {
                if( ( ( ( pointY - segY ) * ( pointY - segY ) )
                     + ( pointX * pointX ) ) <= ( seuil * seuil ) )
                    return true;
            }
        }
    }
    else if( segX == segY )    /* 45 degrees */
    {
        /* Rotate axes of 45 degrees. mouse was then
         * Coord: x1 = x * y * cos45 + sin45
         * y1 = y * cos45 - sin45 x *
         * And the segment of track is horizontal.
         * Coord recalculation of the mouse (sin45 = cos45 = .707 = 7 / 10
         * Note: sin or cos45 = .707, and when recalculating coord
         * dx45 and dy45, lect coeff .707 is neglected, dx and dy are
         * actually 0707 times
         * Too big. (security hole too small)
         * Spot_cX, Y * must be by .707 * .707 = 0.5
         */

        cXrot = (pointX + pointY) >> 1;
        cYrot = (pointY - pointX) >> 1;

        /* Recalculating coord of segment extremity, which will be vertical
         * following the orientation of axes on the screen: dx45 = pointx
         * (or pointy) and 1.414 is actually greater, and dy45 = 0
         */

        // * Threshold should be .707 to reflect the change in coeff dx, dy
        seuil *= 7;
        seuil /= 10;

        if( abs( cYrot ) <= seuil ) /* ok on vertical axis */
        {
            if( ( cXrot >= 0 ) && ( cXrot <= segX ) )
                return true;

            /* Check extremes using the radius of a circle. */
            if( ( cXrot < 0 ) && ( cXrot >= -seuil ) )
            {
                if( ( ( cXrot * cXrot ) + ( cYrot * cYrot ) ) <= ( seuil * seuil ) )
                    return true;
            }
            if( ( cXrot > segX ) && ( cXrot <= ( segX + seuil ) ) )
            {
                if( ( ( ( cXrot - segX ) * ( cXrot - segX ) )
                     + ( cYrot * cYrot ) ) <= ( seuil * seuil ) )
                    return true;
            }
        }
    }
    else    /* any orientation */
    {
        /* There is a change of axis (rotation), so that the segment
         * track is horizontal in the new reference
         */
        int angle;

        angle = KiROUND( ( atan2( (double) segY, (double) segX ) * 1800.0 / M_PI ) );
        cXrot = pointX;
        cYrot = pointY;

        RotatePoint( &cXrot, &cYrot, angle );   /* Rotate the point to be tested */
        RotatePoint( &segX, &segY, angle );     /* Rotate the segment */

        /* The track is horizontal, following the amendments to coordinate
         * axis and, therefore segX = length of segment
         */
        if( abs( cYrot ) <= seuil ) /* vertical axis */
        {
            if( ( cXrot >= 0 ) && ( cXrot <= segX ) )
                return true;

            if( ( cXrot < 0 ) && ( cXrot >= -seuil ) )
            {
                if( ( ( cXrot * cXrot ) + ( cYrot * cYrot ) ) <= ( seuil * seuil ) )
                    return true;
            }

            if( ( cXrot > segX ) && ( cXrot <= ( segX + seuil ) ) )
            {
                if( ( ( ( cXrot - segX ) * ( cXrot - segX ) )
                    + ( cYrot * cYrot ) ) <= ( seuil * seuil ) )
                    return true;
            }
        }
    }

    return false;
}


int ArcTangente( int dy, int dx )
{
    double fangle;

    if( dy == 0 )
    {
        if( dx >= 0 )
            return 0;
        else
            return -1800;
    }

    if( dx == 0 )
    {
        if( dy >= 0 )
            return 900;
        else
            return -900;
    }

    if( dx == dy )
    {
        if( dx >= 0 )
            return 450;
        else
            return -1800 + 450;
    }

    if( dx == -dy )
    {
        if( dx >= 0 )
            return -450;
        else
            return 1800 - 450;
    }

    fangle = atan2( (double) dy, (double) dx ) / M_PI * 1800;
    return KiROUND( fangle );
}


void RotatePoint( int* pX, int* pY, double angle )
{
    int tmp;

    while( angle < 0 )
        angle += 3600;

    while( angle >= 3600 )
        angle -= 3600;

    // Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
    if( angle == 0 )
        return;

    if( angle == 900 )          /* sin = 1, cos = 0 */
    {
        tmp = *pX;
        *pX = *pY;
        *pY = -tmp;
    }
    else if( angle == 1800 )    /* sin = 0, cos = -1 */
    {
        *pX = -*pX;
        *pY = -*pY;
    }
    else if( angle == 2700 )    /* sin = -1, cos = 0 */
    {
        tmp = *pX;
        *pX = -*pY;
        *pY = tmp;
    }
    else
    {
        double fangle = DEG2RAD( angle / 10.0 );
        double sinus = sin( fangle );
        double cosinus = cos( fangle );
        double fpx = (*pY * sinus ) + (*pX * cosinus );
        double fpy = (*pY * cosinus ) - (*pX * sinus );
        *pX = KiROUND( fpx );
        *pY = KiROUND( fpy );
    }
}


void RotatePoint( int* pX, int* pY, int cx, int cy, double angle )
{
    int ox, oy;

    ox = *pX - cx;
    oy = *pY - cy;

    RotatePoint( &ox, &oy, angle );

    *pX = ox + cx;
    *pY = oy + cy;
}


void RotatePoint( wxPoint* point, const wxPoint& centre, double angle )
{
    int ox, oy;

    ox = point->x - centre.x;
    oy = point->y - centre.y;

    RotatePoint( &ox, &oy, angle );
    point->x = ox + centre.x;
    point->y = oy + centre.y;
}


void RotatePoint( double* pX, double* pY, double cx, double cy, double angle )
{
    double ox, oy;

    ox = *pX - cx;
    oy = *pY - cy;

    RotatePoint( &ox, &oy, angle );

    *pX = ox + cx;
    *pY = oy + cy;
}


void RotatePoint( double* pX, double* pY, double angle )
{
    double tmp;

    while( angle < 0 )
        angle += 3600;

    while( angle >= 3600 )
        angle -= 3600;

    // Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
    if( angle == 0 )
        return;

    if( angle == 900 )          /* sin = 1, cos = 0 */
    {
        tmp = *pX;
        *pX = *pY;
        *pY = -tmp;
    }
    else if( angle == 1800 )    /* sin = 0, cos = -1 */
    {
        *pX = -*pX;
        *pY = -*pY;
    }
    else if( angle == 2700 )    /* sin = -1, cos = 0 */
    {
        tmp = *pX;
        *pX = -*pY;
        *pY = tmp;
    }
    else
    {
        double fangle = DEG2RAD( angle / 10.0 );
        double sinus = sin( fangle );
        double cosinus = cos( fangle );

        double fpx = (*pY * sinus ) + (*pX * cosinus );
        double fpy = (*pY * cosinus ) - (*pX * sinus );
        *pX = fpx;
        *pY = fpy;
    }
}


double EuclideanNorm( wxPoint vector )
{
    return hypot( (double) vector.x, (double) vector.y );
}

double DistanceLinePoint( wxPoint linePointA, wxPoint linePointB, wxPoint referencePoint )
{
    return fabs( (double) ( (linePointB.x - linePointA.x) * (linePointA.y - referencePoint.y) -
                 (linePointA.x - referencePoint.x ) * (linePointB.y - linePointA.y) )
                  / EuclideanNorm( linePointB - linePointA ) );
}


bool HitTestPoints( wxPoint pointA, wxPoint pointB, double threshold )
{
    wxPoint vectorAB = pointB - pointA;
    double  distance = EuclideanNorm( vectorAB );

    return distance < threshold;
}


double CrossProduct( wxPoint vectorA, wxPoint vectorB )
{
    return (double)vectorA.x * vectorB.y - (double)vectorA.y * vectorB.x;
}


double GetLineLength( const wxPoint& aPointA, const wxPoint& aPointB )
{
    return hypot( (double) aPointA.x - (double) aPointB.x,
                  (double) aPointA.y - (double) aPointB.y );
}