Point.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/Point.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_Point_h
#define __PCL_Point_h
 
 
#include <pcl/Defs.h>
 
#include <pcl/Math.h>
#include <pcl/Relational.h>
 
#ifdef __PCL_QT_INTERFACE
#  include <QtCore/QPoint>
#endif
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
/*
 * ### NB: Template class GenericPoint cannot have virtual member functions.
 *         This is because internal PCL and core routines rely on
 *         GenericPoint<int>, GenericPoint<float> and GenericPoint<double> to
 *         be directly castable to int*, float* and double*, respectively. See
 *         also the PCL_ASSERT_POINT_SIZE() macro.
 */
 
#define PCL_ASSERT_POINT_SIZE() \
   static_assert( sizeof( *this ) == 2*sizeof( T ), "Invalid sizeof( GenericPoint<> )" )
 
template <typename T>
class PCL_CLASS GenericPoint
{
public:
 
   using component = T;
 
   /*
    * Point coordinates
    */
   component x; 
   component y; 
 
   constexpr GenericPoint()
   {
      PCL_ASSERT_POINT_SIZE();
   }
 
   template <typename T1, typename T2>
   constexpr GenericPoint( T1 xPos, T2 yPos )
      : x( component( xPos ) )
      , y( component( yPos ) )
   {
      PCL_ASSERT_POINT_SIZE();
   }
 
   constexpr GenericPoint( component d )
      : GenericPoint( d, d )
   {
      PCL_ASSERT_POINT_SIZE();
   }
 
   template <typename T1>
   GenericPoint( std::initializer_list<T1> l )
   {
      PCL_ASSERT_POINT_SIZE();
      switch ( l.size() )
      {
      default:
      case 2: y = component( l.begin()[1] );
      case 1: x = component( l.begin()[0] );
      case 0: break;
      }
      switch ( l.size() )
      {
      case 0: x = component( 0 );
      case 1: y = component( 0 );
      default:
      case 2: break;
      }
   }
 
   template <typename T1>
   GenericPoint( const GenericPoint<T1>& p )
      : GenericPoint( p.x, p.y )
   {
      PCL_ASSERT_POINT_SIZE();
   }
 
#ifdef __PCL_QT_INTERFACE
   GenericPoint( const QPoint& p )
      : GenericPoint( p.x(), p.y() )
   {
      PCL_ASSERT_POINT_SIZE();
   }
#endif
 
   template <typename T1>
   double SquaredDistanceTo( const GenericPoint<T1>& p ) const noexcept
   {
      double dx = double( p.x ) - double( x );
      double dy = double( p.y ) - double( y );
      return dx*dx + dy*dy;
   }
 
   template <typename T1>
   double DistanceTo( const GenericPoint<T1>& p ) const noexcept
   {
      return pcl::Sqrt( SquaredDistanceTo( p ) );
   }
 
   double SquaredDistanceToOrigin() const noexcept
   {
      return double( x )*double( x ) + double( y )*double( y );
   }
 
   double DistanceToOrigin() const noexcept
   {
      return pcl::Sqrt( SquaredDistanceToOrigin() );
   }
 
   template <typename T1>
   double ManhattanDistanceTo( const GenericPoint<T1>& p ) const noexcept
   {
      return Abs( double( p.x ) - double( x ) ) + Abs( double( p.y ) - double( y ) );
   }
 
   double ManhattanDistanceToOrigin() const noexcept
   {
      return Abs( double( x ) ) + Abs( double( y ) );
   }
 
   template <typename T1>
   void MoveTo( const GenericPoint<T1>& p ) noexcept
   {
      MoveTo( p.x, p.y );
   }
 
   template <typename T1, typename T2>
   void MoveTo( T1 xPos, T2 yPos ) noexcept
   {
      x = component( xPos ); y = component( yPos );
   }
 
#ifdef __PCL_QT_INTERFACE
   void MoveTo( const QPoint& p ) noexcept
   {
      MoveTo( p.x(), p.y() );
   }
#endif
 
   template <typename T1>
   GenericPoint MovedTo( const GenericPoint<T1>& p ) const noexcept
   {
      return GenericPoint( component( p.x ), component( p.y ) );
   }
 
   template <typename T1, typename T2>
   GenericPoint MovedTo( T1 xPos, T2 yPos ) const noexcept
   {
      return GenericPoint( component( xPos ), component( yPos ) );
   }
 
   template <typename T1>
   void MoveBy( const GenericPoint<T1>& d ) noexcept
   {
      MoveBy( d.x, d.y );
   }
 
   template <typename T1, typename T2>
   void MoveBy( T1 dx, T2 dy ) noexcept
   {
      x += component( dx ); y += component( dy );
   }
 
   template <typename T1>
   void MoveBy( T1 dxy ) noexcept
   {
      x += component( dxy ); y += component( dxy );
   }
 
#ifdef __PCL_QT_INTERFACE
   void MoveBy( const QPoint& p )
   {
      MoveBy( p.x(), p.y() );
   }
#endif
 
   template <typename T1>
   GenericPoint MovedBy( const GenericPoint<T1>& d ) const noexcept
   {
      return GenericPoint( x + component( d.x ), y + component( d.y ) );
   }
 
   template <typename T1, typename T2>
   GenericPoint MovedBy( T1 dx, T2 dy ) const noexcept
   {
      return GenericPoint( x + component( dx ), y + component( dy ) );
   }
 
   template <typename T1, typename T2>
   void Rotate( T1 angle, T2 xc, T2 yc ) noexcept
   {
      pcl::Rotate( x, y, angle, xc, yc );
   }
 
   template <typename T1, typename T2>
   void Rotate( T1 angle, const GenericPoint<T2>& center ) noexcept
   {
      Rotate( angle, center.x, center.y );
   }
 
   template <typename T1, typename T2>
   void Rotate( T1 sa, T1 ca, T2 xc, T2 yc ) noexcept
   {
      pcl::Rotate( x, y, sa, ca, xc, yc );
   }
 
   template <typename T1, typename T2>
   void Rotate( T1 sa, T1 ca, const GenericPoint<T2>& center ) noexcept
   {
      Rotate( sa, ca, center.x, center.y );
   }
 
   template <typename T1, typename T2>
   GenericPoint Rotated( T1 angle, T2 xc, T2 yc ) const noexcept
   {
      GenericPoint p( *this );
      p.Rotate( angle, xc, yc );
      return p;
   }
 
   template <typename T1, typename T2>
   GenericPoint Rotated( T1 angle, const GenericPoint<T2>& center ) const noexcept
   {
      GenericPoint p( *this );
      p.Rotate( angle, center );
      return p;
   }
 
   template <typename T1, typename T2>
   GenericPoint Rotated( T1 sa, T1 ca, T2 xc, T2 yc ) const noexcept
   {
      GenericPoint p( *this );
      p.Rotate( sa, ca, xc, yc );
      return p;
   }
 
   template <typename T1, typename T2>
   GenericPoint Rotated( T1 sa, T1 ca, const GenericPoint<T2>& center ) const noexcept
   {
      GenericPoint p( *this );
      p.Rotate( sa, ca, center );
      return p;
   }
 
   void Round() noexcept
   {
      x = component( pcl::Round( double( x ) ) );
      y = component( pcl::Round( double( y ) ) );
   }
 
   void Round( int n ) noexcept
   {
      PCL_PRECONDITION( n >= 0 )
      x = component( pcl::Round( double( x ), n ) );
      y = component( pcl::Round( double( y ), n ) );
   }
 
   GenericPoint Rounded() const noexcept
   {
      return GenericPoint( component( pcl::Round( double( x ) ) ), component( pcl::Round( double( y ) ) ) );
   }
 
   GenericPoint Rounded( int n ) const noexcept
   {
      PCL_PRECONDITION( n >= 0 )
      return GenericPoint( component( pcl::Round( double( x ), n ) ), component( pcl::Round( double( y ), n ) ) );
   }
 
   GenericPoint<int> RoundedToInt() const noexcept
   {
      return GenericPoint<int>( pcl::RoundInt( double( x ) ), pcl::RoundInt( double( y ) ) );
   }
 
   void Truncate() noexcept
   {
      x = component( pcl::Trunc( double( x ) ) );
      y = component( pcl::Trunc( double( y ) ) );
   }
 
   GenericPoint Truncated() const noexcept
   {
      return GenericPoint( component( pcl::Trunc( double( x ) ) ), component( pcl::Trunc( double( y ) ) ) );
   }
 
   GenericPoint<int> TruncatedToInt() const noexcept
   {
      return GenericPoint<int>( pcl::TruncInt( double( x ) ), pcl::TruncInt( double( y ) ) );
   }
 
   template <typename T1>
   GenericPoint& operator =( const GenericPoint<T1>& p ) noexcept
   {
      x = component( p.x );
      y = component( p.y );
      return *this;
   }
 
   GenericPoint& operator =( component v ) noexcept
   {
      x = y = v;
      return *this;
   }
 
#ifdef __PCL_QT_INTERFACE
   GenericPoint& operator =( const QPoint& p ) noexcept
   {
      x = component( p.x() );
      y = component( p.y() );
      return *this;
   }
#endif
 
   template <typename T1>
   GenericPoint& operator +=( const GenericPoint<T1>& p ) noexcept
   {
      x += component( p.x );
      y += component( p.y );
      return *this;
   }
 
   GenericPoint& operator +=( component d ) noexcept
   {
      x += d;
      y += d;
      return *this;
   }
 
#ifdef __PCL_QT_INTERFACE
   GenericPoint& operator +=( const QPoint& p ) noexcept
   {
      x += component( p.x() );
      y += component( p.y() );
      return *this;
   }
#endif
 
   template <typename T1>
   GenericPoint& operator -=( const GenericPoint<T1>& p ) noexcept
   {
      x -= component( p.x );
      y -= component( p.y );
      return *this;
   }
 
   GenericPoint& operator -=( component d ) noexcept
   {
      x -= d;
      y -= d;
      return *this;
   }
 
#ifdef __PCL_QT_INTERFACE
   GenericPoint& operator -=( const QPoint& p ) noexcept
   {
      x -= component( p.x() );
      y -= component( p.y() );
      return *this;
   }
#endif
 
   template <typename T1>
   GenericPoint& operator *=( const GenericPoint<T1>& p ) noexcept
   {
      x *= component( p.x );
      y *= component( p.y );
      return *this;
   }
 
   GenericPoint& operator *=( component d ) noexcept
   {
      x *= d;
      y *= d;
      return *this;
   }
 
#ifdef __PCL_QT_INTERFACE
   GenericPoint& operator *=( const QPoint& p ) noexcept
   {
      x *= component( p.x() );
      y *= component( p.y() );
      return *this;
   }
#endif
 
   template <typename T1>
   GenericPoint& operator /=( const GenericPoint<T1>& p ) noexcept
   {
      PCL_PRECONDITION( component( p.x ) != component( 0 ) && component( p.y ) != component( 0 ) )
      x /= component( p.x );
      y /= component( p.y );
      return *this;
   }
 
   GenericPoint& operator /=( component d ) noexcept
   {
      PCL_PRECONDITION( d != component( 0 ) )
      x /= d;
      y /= d;
      return *this;
   }
 
#ifdef __PCL_QT_INTERFACE
   GenericPoint& operator /=( const QPoint& p ) noexcept
   {
      PCL_PRECONDITION( component( p.x() ) != component( 0 ) && component( p.y() ) != component( 0 ) )
      x /= component( p.x() );
      y /= component( p.y() );
      return *this;
   }
#endif
 
   GenericPoint operator +() const noexcept
   {
      return *this;
   }
 
   GenericPoint operator -() const noexcept
   {
      return GenericPoint( -x, -y );
   }
 
   void Reflect() noexcept
   {
      x = -x;
      y = -y;
   }
 
   void ReflectX() noexcept
   {
      y = -y;
   }
 
   void ReflectY() noexcept
   {
      x = -x;
   }
 
   GenericPoint Reflected() const noexcept
   {
      return GenericPoint( -x, -y );
   }
 
   GenericPoint ReflectedX() const noexcept
   {
      return GenericPoint( x, -y );
   }
 
   GenericPoint ReflectedY() const noexcept
   {
      return GenericPoint( -x, y );
   }
 
   /*
    * Returns a point whose coordinates are the coordinates of this point
    * converted to radians, assuming that this point has coordinates expressed
    * in degrees.
    */
   GenericPoint Rad() const noexcept
   {
      return GenericPoint( pcl::Rad( x ), pcl::Rad( y ) );
   }
 
   GenericPoint Deg() const noexcept
   {
      return GenericPoint( pcl::Deg( x ), pcl::Deg( y ) );
   }
 
   GenericPoint& ToRad() noexcept
   {
      x = pcl::Rad( x );
      y = pcl::Rad( y );
      return *this;
   }
 
   GenericPoint& ToDeg() noexcept
   {
      x = pcl::Deg( x );
      y = pcl::Deg( y );
      return *this;
   }
 
   component& operator []( int i ) noexcept
   {
      return (i == 0) ? x : y;
   }
 
   component operator []( int i ) const noexcept
   {
      return (i == 0) ? x : y;
   }
 
   template <typename T1, typename T2>
   double Dot( T1 px, T2 py ) const noexcept
   {
      return double( x )*double( px ) + double( y )*double( py );
   }
 
   template <typename T1>
   double Dot( const GenericPoint<T1>& p ) const noexcept
   {
      return Dot( p.x, p.y );
   }
 
#ifdef __PCL_QT_INTERFACE
   operator QPoint() const noexcept
   {
      return QPoint( int( x ), int( y ) );
   }
#endif
};
 
#undef PCL_ASSERT_POINT_SIZE
 
// ----------------------------------------------------------------------------
 
template <typename T1, typename T2> inline
bool operator ==( const GenericPoint<T1>& p1, const GenericPoint<T2>& p2 ) noexcept
{
   return p1.x == p2.x && p1.y == p2.y;
}
 
template <typename T> inline
bool operator ==( const GenericPoint<T>& p1, T d2 ) noexcept
{
   return p1.x == d2 && p1.y == d2;
}
 
template <typename T> inline
bool operator ==( T d1, const GenericPoint<T>& p2 ) noexcept
{
   return d1 == p2.x && d1 == p2.y;
}
 
template <typename T1, typename T2> inline
bool operator <( const GenericPoint<T1>& p1, const GenericPoint<T2>& p2 ) noexcept
{
   return p1.y < p2.y || p1.y == p2.y && p1.x < p2.x;
}
 
template <typename T> inline
bool operator <( const GenericPoint<T>& p1, T d2 ) noexcept
{
   return p1.y < d2 || p1.y == d2 && p1.x < d2;
}
 
template <typename T> inline
bool operator <( T d1, const GenericPoint<T>& p2 ) noexcept
{
   return d1 < p2.y || d1 == p2.y && d1 < p2.x;
}
 
template <typename T1, typename T2> inline
GenericPoint<T1> operator +( const GenericPoint<T1>& p1, const GenericPoint<T2>& p2 ) noexcept
{
   return GenericPoint<T1>( T1( p1.x + p2.x ), T1( p1.y + p2.y ) );
}
 
template <typename T> inline
GenericPoint<T> operator +( const GenericPoint<T>& p1, T d2 ) noexcept
{
   return GenericPoint<T>( p1.x+d2, p1.y+d2 );
}
 
template <typename T> inline
GenericPoint<T> operator +( T d1, const GenericPoint<T>& p2 ) noexcept
{
   return GenericPoint<T>( p2.x+d1, p2.y+d1 );
}
 
template <typename T1, typename T2> inline
GenericPoint<T1> operator -( const GenericPoint<T1>& p1, const GenericPoint<T2>& p2 ) noexcept
{
   return GenericPoint<T1>( T1( p1.x - p2.x ), T1( p1.y - p2.y ) );
}
 
template <typename T> inline
GenericPoint<T> operator -( const GenericPoint<T>& p1, T d2 ) noexcept
{
   return GenericPoint<T>( p1.x-d2, p1.y-d2 );
}
 
template <typename T> inline
GenericPoint<T> operator -( T d1, const GenericPoint<T>& p2 ) noexcept
{
   return GenericPoint<T>( d1-p2.x, d1-p2.y );
}
 
template <typename T1, typename T2> inline
GenericPoint<T1> operator *( const GenericPoint<T1>& p1, const GenericPoint<T2>& p2 ) noexcept
{
   return GenericPoint<T1>( T1( p1.x * p2.x ), T1( p1.y * p2.y ) );
}
 
template <typename T> inline
GenericPoint<T> operator *( const GenericPoint<T>& p1, T d2 ) noexcept
{
   return GenericPoint<T>( p1.x*d2, p1.y*d2 );
}
 
template <typename T> inline
GenericPoint<T> operator *( T d1, const GenericPoint<T>& p2 ) noexcept
{
   return GenericPoint<T>( p2.x*d1, p2.y*d1 );
}
 
template <typename T1, typename T2> inline
GenericPoint<T1> operator /( const GenericPoint<T1>& p1, const GenericPoint<T2>& p2 ) noexcept
{
   PCL_PRECONDITION( p2.x != T2( 0 ) && p2.y != T2( 0 ) )
   return GenericPoint<T1>( T1( p1.x / p2.x ), T1( p1.y / p2.y ) );
}
 
template <typename T> inline
GenericPoint<T> operator /( const GenericPoint<T>& p1, T d2 ) noexcept
{
   PCL_PRECONDITION( d2 != T( 0 ) )
   return GenericPoint<T>( p1.x/d2, p1.y/d2 );
}
 
template <typename T> inline
GenericPoint<T> operator /( T d1, const GenericPoint<T>& p2 ) noexcept
{
   PCL_PRECONDITION( p2.x != T( 0 ) && p2.y != T( 0 ) )
   return GenericPoint<T>( d1/p2.x, d1/p2.y );
}
 
// ### FIXME: We cannot use two template arguments here due to a conflict with
//            Distance( FI, FI ) defined in Iterator.h
//template <typename T1, typename T2> inline
template <typename T> inline
double Distance( const GenericPoint<T>& p1, const GenericPoint<T>& p2 ) noexcept
{
   double dx = double( p2.x ) - double( p1.x );
   double dy = double( p2.y ) - double( p1.y );
   return pcl::Sqrt( dx*dx + dy*dy );
}
 
template <typename T1, typename T2> inline
double ManhattanDistance( const GenericPoint<T1>& p1, const GenericPoint<T2>& p2 ) noexcept
{
   return Abs( double( p2.x ) - double( p1.x ) ) + Abs( double( p2.y ) - double( p1.y ) );
}
 
template <typename T, typename T1, typename T2> inline
void Rotate( GenericPoint<T>& p, T1 a, T2 xc, T2 yc ) noexcept
{
   pcl::Rotate( p.x, p.y, a, xc, yc );
}
 
template <typename T, typename T1, typename T2> inline
void Rotate( GenericPoint<T>& p, T1 a, const GenericPoint<T2>& c ) noexcept
{
   pcl::Rotate( p, a, c.x, c.y );
}
 
template <typename T, typename T1, typename T2> inline
void Rotate( GenericPoint<T>& p, T1 sa, T1 ca, T2 xc, T2 yc ) noexcept
{
   pcl::Rotate( p.x, p.y, sa, ca, xc, yc );
}
 
template <typename T, typename T1, typename T2> inline
void Rotate( GenericPoint<T>& p, T1 sa, T1 ca, const GenericPoint<T2>& c ) noexcept
{
   pcl::Rotate( p, sa, ca, c.x, c.y );
}
 
template <typename T> inline
void Swap( GenericPoint<T>& p1, GenericPoint<T>& p2 ) noexcept
{
   pcl::Swap( p1.x, p2.x );
   pcl::Swap( p1.y, p2.y );
}
 
// ----------------------------------------------------------------------------
 
#ifndef __PCL_NO_POINT_INSTANTIATE
 
using I32Point = GenericPoint<int32>;
 
using Point = I32Point;
 
using F32Point = GenericPoint<float>;
 
using FPoint = F32Point;
 
using F64Point = GenericPoint<double>;
 
using DPoint = F64Point;
 
#endif   // !__PCL_NO_POINT_INSTANTIATE
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif  // __PCL_Point_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Point.h - Released 2024-06-18T15:48:54Z