point.h

Go to the documentation of this file.

/*
 * LibrePCB - Professional EDA for everyone!
 * Copyright (C) 2013 LibrePCB Developers, see AUTHORS.md for contributors.
 * https://librepcb.org/
 *
 * 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/>.
 */
 
#ifndef LIBREPCB_CORE_POINT_H
#define LIBREPCB_CORE_POINT_H
 
/*******************************************************************************
 *  Includes
 ******************************************************************************/
#include "length.h"
 
#include <QtCore>
 
/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {
 
class Angle;
class SExpression;
 
/*******************************************************************************
 *  Class Point
 ******************************************************************************/
 
class Point final {
public:
  // Constructors / Destructor
 
  Point() noexcept : Point(Length(0), Length(0)) {}
 
  Point(const Point& point) noexcept : mX(point.mX), mY(point.mY) {}
 
  explicit Point(const Length& x, const Length& y) noexcept : mX(x), mY(y) {}
 
  explicit Point(const SExpression& node);
 
  ~Point() noexcept {}
 
  // Setters
 
  void setX(const Length& x) noexcept { mX = x; }
 
  void setY(const Length& y) noexcept { mY = y; }
 
  void setXmm(const QString& mm) { mX.setLengthMm(mm); }
 
  void setYmm(const QString& mm) { mY.setLengthMm(mm); }
 
  void setPointNm(LengthBase_t nmX, LengthBase_t nmY) noexcept {
    mX.setLengthNm(nmX);
    mY.setLengthNm(nmY);
  }
 
  void setPointMm(const QPointF& millimeters) {
    mX.setLengthMm(millimeters.x());
    mY.setLengthMm(millimeters.y());
  }
 
  void setPointInch(const QPointF& inches) {
    mX.setLengthInch(inches.x());
    mY.setLengthInch(inches.y());
  }
 
  void setPointMil(const QPointF& mils) {
    mX.setLengthMil(mils.x());
    mX.setLengthMil(mils.y());
  }
 
  void setPointPx(const QPointF& pixels) {
    mX.setLengthPx(pixels.x());
    mY.setLengthPx(-pixels.y());
  }  // invert Y!
 
  // Getters
 
  const Length& getX() const noexcept { return mX; }
 
  const Length& getY() const noexcept { return mY; }
 
  UnsignedLength getLength() const noexcept {
    LengthBase_t length =
        static_cast<LengthBase_t>(std::hypot(mX.toNm(), mY.toNm()));
    Q_ASSERT(length >= 0);
    return UnsignedLength(length);
  }
 
  bool isOrigin() const noexcept { return ((mX == 0) && (mY == 0)); }
 
  // Conversions
 
  QPointF toMmQPointF() const noexcept { return QPointF(mX.toMm(), mY.toMm()); }
 
  QPointF toInchQPointF() const noexcept {
    return QPointF(mX.toInch(), mY.toInch());
  }
 
  QPointF toMilQPointF() const noexcept {
    return QPointF(mX.toMil(), mY.toMil());
  }
 
  QPointF toPxQPointF() const noexcept {
    return QPointF(mX.toPx(), -mY.toPx());
  }  // invert Y!
 
  // General Methods
 
  Point abs() const noexcept;
 
  Point& makeAbs() noexcept;
 
  Point mappedToGrid(const PositiveLength& gridInterval) const noexcept;
 
  Point& mapToGrid(const PositiveLength& gridInterval) noexcept;
 
  bool isOnGrid(const PositiveLength& gridInterval) const noexcept;
 
  Point rotated(const Angle& angle,
                const Point& center = Point(0, 0)) const noexcept;
 
  Point& rotate(const Angle& angle, const Point& center = Point(0, 0)) noexcept;
 
  Point mirrored(Qt::Orientation orientation,
                 const Point& center = Point(0, 0)) const noexcept;
 
  Point& mirror(Qt::Orientation orientation,
                const Point& center = Point(0, 0)) noexcept;
 
  void serialize(SExpression& root) const;
 
  // Static Functions
 
  static Point fromMm(qreal millimetersX, qreal millimetersY);
  static Point fromMm(const QPointF& millimeters);
 
  static Point fromInch(qreal inchesX, qreal inchesY);
  static Point fromInch(const QPointF& inches);
 
  static Point fromMil(qreal milsX, qreal milsY);
  static Point fromMil(const QPointF& mils);
 
  static Point fromPx(qreal pixelsX, qreal pixelsY);
  static Point fromPx(const QPointF& pixels);
 
  // Operators
  Point& operator=(const Point& rhs) {
    mX = rhs.mX;
    mY = rhs.mY;
    return *this;
  }
  Point& operator+=(const Point& rhs) {
    mX += rhs.mX;
    mY += rhs.mY;
    return *this;
  }
  Point& operator-=(const Point& rhs) {
    mX -= rhs.mX;
    mY -= rhs.mY;
    return *this;
  }
  Point& operator*=(const Point& rhs) {
    mX *= rhs.mX;
    mY *= rhs.mY;
    return *this;
  }
  Point& operator*=(LengthBase_t rhs) {
    mX *= rhs;
    mY *= rhs;
    return *this;
  }
  Point& operator/=(const Point& rhs) {
    mX /= rhs.mX;
    mY /= rhs.mY;
    return *this;
  }
  Point& operator/=(LengthBase_t rhs) {
    mX /= rhs;
    mY /= rhs;
    return *this;
  }
  Point operator+(const Point& rhs) const {
    return Point(mX + rhs.mX, mY + rhs.mY);
  }
  Point operator-() const { return Point(-mX, -mY); }
  Point operator-(const Point& rhs) const {
    return Point(mX - rhs.mX, mY - rhs.mY);
  }
  Point operator*(const Length& rhs) const { return Point(mX * rhs, mY * rhs); }
  Point operator*(LengthBase_t rhs) const { return Point(mX * rhs, mY * rhs); }
  Point operator/(const Length& rhs) const { return Point(mX / rhs, mY / rhs); }
  Point operator/(LengthBase_t rhs) const { return Point(mX / rhs, mY / rhs); }
  Point operator%(const Length& rhs) const { return Point(mX % rhs, mY % rhs); }
  bool operator==(const Point& rhs) const {
    return (mX == rhs.mX) && (mY == rhs.mY);
  }
  bool operator!=(const Point& rhs) const {
    return (mX != rhs.mX) || (mY != rhs.mY);
  }
 
 
  bool operator<(const Point& rhs) const noexcept {
    return (mX < rhs.mX) || ((mX == rhs.mX) && (mY < rhs.mY));
  }
  bool operator<=(const Point& rhs) const noexcept {
    return (mX < rhs.mX) || ((mX == rhs.mX) && (mY <= rhs.mY));
  }
  bool operator>(const Point& rhs) const noexcept {
    return (mX > rhs.mX) || ((mX == rhs.mX) && (mY > rhs.mY));
  }
  bool operator>=(const Point& rhs) const noexcept {
    return (mX > rhs.mX) || ((mX == rhs.mX) && (mY >= rhs.mY));
  }
 
private:
  Length mX;  
  Length mY;  
};
 
/*******************************************************************************
 *  Non-Member Functions
 ******************************************************************************/
 
QDataStream& operator<<(QDataStream& stream, const Point& point);
QDebug operator<<(QDebug stream, const Point& point);
 
inline std::size_t qHash(const Point& key, std::size_t seed = 0) noexcept {
  return ::qHash(qMakePair(key.getX(), key.getY()), seed);
}
 
/*******************************************************************************
 *  End of File
 ******************************************************************************/
 
}  // namespace librepcb
 
Q_DECLARE_METATYPE(librepcb::Point)
 
#endif