AOI_Types.cpp

#include "./AOI_Types.h"
#include <ACPL/Types.h>
#include "../GTypes.h"
#include <memory.h>
 
AOI_Rectangle::AOI_Rectangle()
{
        left = top = AOI_PosInf;
        right = bottom = AOI_NegInf;
}
 
AOI_Rectangle::AOI_Rectangle( float x1, float y1, float x2, float y2 )
{
        left = x1;
        top = y1;
        right = x2;
        bottom = y2;
}
 
AOI_Rectangle::AOI_Rectangle( const AOI_Rectangle& inBounds )
{
        left = inBounds.left;
        top = inBounds.top;
        right = inBounds.right;
        bottom = inBounds.bottom;
}
 
void    AOI_Rectangle::Union( const AOI_Rectangle& inBounds )
{
        if( inBounds.left < left )
                left = inBounds.left;
        if( inBounds.top < top )
                top = inBounds.top;
        if( inBounds.right > right )
                right = inBounds.right;
        if( inBounds.bottom > bottom )
                bottom = inBounds.bottom;
}
 
bool    AOI_Rectangle::Intersect( const AOI_Rectangle& inBounds )
{
        if( inBounds.left > left )
                left = inBounds.left;
        if( inBounds.top > top )
                top = inBounds.top;
        if( inBounds.right < right )
                right = inBounds.right;
        if( inBounds.bottom < bottom )
                bottom = inBounds.bottom;
        return left <= right && top <= bottom;
}
 
bool    AOI_Rectangle::CoordInBounds( const AOI_Point& inCoord ) const
{
        return inCoord.x >= left && inCoord.x <= right && inCoord.y >= top && inCoord.y <= bottom;
}
 
bool    AOI_Rectangle::Overlaps( const AOI_Rectangle& inBounds ) const
{
        return inBounds.left < right && inBounds.top < bottom && inBounds.right > left && inBounds.bottom > top;
}
 
void    AOI_Rectangle::TLtoBR()
{
        float h;
        if( left > right )
        {
                h = left;
                left = right;
                right = h;
        }
        if( top > bottom )
        {
                h = top;
                top = bottom;
                bottom = h;
        }
}
 
AOI_Mapping::AOI_Mapping()
{
        Reset();
}
 
AOI_Mapping::AOI_Mapping( const AOI_Mapping& inMap )
{
        ::memcpy( &map, &inMap.map, 9 * sizeof(float) );
}
 
AOI_Mapping::AOI_Mapping( const float* array )
{
        ::memcpy( &map, array, 9 * sizeof(float) );
}
 
AOI_Mapping::AOI_Mapping( const double* array )
{
        map[0][0] = float( array[0] );
        map[0][1] = float( array[1] );
        map[0][2] = 0;
        map[1][0] = float( array[2] );
        map[1][1] = float( array[3] );
        map[1][2] = 0;
        map[2][0] = float( array[4] );
        map[2][1] = float( array[5] );
        map[2][2] = 1;
}
 
void    AOI_Mapping::Reset()
{
        for( int32_t i = 0; i != 3; ++i )
                for( int32_t j = 0; j != 3; ++j )
                        map[i][j] = 0;
        map[0][0] = map[1][1] = map[2][2] = 1;
}
 
void    AOI_Mapping::Invert()
{
        double  a=1,b=0,c=0,d=0,e=1,f=0,g=0,h=0,i=1,
                        j=map[0][0],k=map[1][0],l=map[2][0],
                        m=map[0][1],n=map[1][1],o=map[2][1],
                        p=map[0][2],q=map[1][2],r=map[2][2];
 
        if( j == 0 ) // m != 0
        {
                 b=1; j = m; k += n; l+=o;
        }
        if( n == 0 )
        {
                d = 1; e += b; m += j; n = k; o +=l;
        }
        if( j != 1.0 )
        {
                a/=j; b/=j; c/=j; k/=j; l/=j; j=1;
        }
        if( m )
        {
                d-=m*a; e-=m*b; f-=m*c; n-=m*k; o-=m*l; m=0;
        }
        if( p )
        {
                g-=p*a; h-=p*b; i-=p*c; q-=p*k; r-=p*l; p=0;
        }
        if( n != 1.0 )
        {
                d/=n; e/=n; f/=n; o/=n; n=1;
        }
        if( k )
        {
                a-=k*d; b-=k*e; c-=k*f; l-=k*o; k=0;
        }
        if( q )
        {
                g-=q*d; h-=q*e; i-=q*f; r-=q*o; q=0;
        }
        if( r != 1.0 )
        {
                g/=r; h/=r; i/=r; r=1;
        }
        if( o )
        {
                d-=o*g; e-=o*h; f-=o*i; o=0;
        }
        if( l )
        {
                a-=l*g; b-=l*h; c-=l*i; l=0;
        }
 
        map[0][0] = float( a );
        map[1][0] = float( b );
        map[2][0] = float( c );
        map[0][1] = float( d );
        map[1][1] = float( e );
        map[2][1] = float( f );
        Check();
}
 
void    AOI_Mapping::Move( float dx, float dy )
{
        map[2][0] += dx;
        map[2][1] += dy;
}
 
void    AOI_Mapping::Rotate( float degreeAngle, float x, float y )
{
#if ACPL_MAC
        float   co = cos( degreeAngle * M_PI / 180 ),
                        si = sin( degreeAngle * M_PI / 180 ),
                        rot[] = { co, -si, 0 , si, co, 0, x, y, 1 };
#else
        double  angle = ( degreeAngle / 180.0 ) * M_PI;
        float   co = float( cos( angle ) ),
                        si = float( sin( angle ) );
        if( co > -0.0001 && co < 0.0001 )
                co = 0;
        else if( co > 0.9999 )
                co = 1;
        else if( co < -0.9999 )
                co = -1;
        if( si > -0.0001 && si < 0.0001 )
                si = 0;
        else if( si > 0.9999 )
                si = 1;
        else if( si < -0.9999 )
                si = -1;
        float   rot[] = { co, -si, 0 , si, co, 0, x, y, 1 };
#endif
        AOI_Mapping r( rot );
        map[2][0] -= x;
        map[2][1] -= y;
        Map( r );
}
 
void    AOI_Mapping::Scale( float x, float y, float sx, float sy )
{
        float   scal[] = { sx, 0.0f, 0.0f, 0.0f, sy, 0.0f, x, y, 1.0f };
        AOI_Mapping s( scal );
        map[2][0] -= x;
        map[2][1] -= y;
        Map( s );
}
 
void    AOI_Mapping::Skew( float x, float y, float sx, float sy )
{
        float   skew[] = { 1.0f, sy, 0.0f,sx, 1.0f, 0.0f, x, y, 1.0f };
        AOI_Mapping s( skew );
        map[2][0] -= x;
        map[2][1] -= y;
        Map( s );
}
 
void    AOI_Mapping::Map( const AOI_Mapping& in )
{
        float nieuwe[3][3];
 
        nieuwe[0][0] = map[0][0] * in.map[0][0] + map[0][1] * in.map[1][0];
        nieuwe[0][1] = map[0][0] * in.map[0][1] + map[0][1] * in.map[1][1];
        nieuwe[0][2] = map[0][0] * in.map[0][2] + map[0][1] * in.map[1][2];
 
        nieuwe[1][0] = map[1][0] * in.map[0][0] + map[1][1] * in.map[1][0];
        nieuwe[1][1] = map[1][0] * in.map[0][1] + map[1][1] * in.map[1][1];
        nieuwe[1][2] = map[1][0] * in.map[0][2] + map[1][1] * in.map[1][2];
 
        nieuwe[2][0] = map[2][0] * in.map[0][0] + map[2][1] * in.map[1][0] + map[2][2] * in.map[2][0];
        nieuwe[2][1] = map[2][0] * in.map[0][1] + map[2][1] * in.map[1][1] + map[2][2] * in.map[2][1];
        nieuwe[2][2] = 1;
 
        ::memcpy( &map,&nieuwe,  9 * sizeof(int32_t) );
        Check();
}
 
float   AOI_Mapping::Determinant() const
{
        return fabsf(map[0][0] * map[1][1] - map[0][1] * map[1][0]);
}
 
bool    AOI_Mapping::IsUnity() const
{
        return  map[0][0] == 1 && map[0][1] == 0 &&
                        map[1][0] == 0 && map[1][1] == 1 &&
                        map[2][0] == 0 && map[2][1] == 0;
}
 
bool    AOI_Mapping::IsMove() const
{
        return  map[0][0] == 1 && map[0][1] == 0 &&
                        map[1][0] == 0 && map[1][1] == 1;
}
 
bool    AOI_Mapping::IsScale() const
{
        return  map[0][1] == 0 && map[1][0] == 0 &&
                        map[2][0] == 0 && map[2][1] == 0;
}
 
void    AOI_Mapping::Check()
{
        for( short i = 0; i<3; i++ )
                for( short j = 0; j < 3; j++ )
                        if( map[i][j] != 0.0 && fabsf( map[i][j] ) < 0.0000001f )
                                map[i][j] = 0.0;
}
 
AOI_Point::AOI_Point()
{
        x = y = 0;
}
 
AOI_Point::AOI_Point( float inX, float inY )
{
        x = inX;
        y = inY;
}
 
AOI_Point::AOI_Point( const AOI_Point& inCoord )
{
        x = inCoord.x;
        y = inCoord.y;
}
 
int32_t AOIAPI  AOI_ColorSpaceComponents( AOI_ColorSpaceEnum space )
{
        return aur::PDF::ColorSpaceComponents( aur::PDF::ColorSpace( space ) );
}