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_POINT_H
#define LIBREPCB_POINT_H

/*******************************************************************************
 *  Includes
 ******************************************************************************/
#include "../fileio/serializableobject.h"
#include "length.h"

#include <QtCore>

/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {

class Angle;

/*******************************************************************************
 *  Class Point
 ******************************************************************************/

class Point final : public SerializableObject {
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) {}

  Point(const SExpression& node, const Version& fileFormat);

  ~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>(
        qSqrt(mX.toNm() * mX.toNm() + mY.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 override;

  // 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 uint qHash(const Point& key, uint seed = 0) noexcept {
  return ::qHash(qMakePair(key.getX(), key.getY()), seed);
}

/*******************************************************************************
 *  End of File
 ******************************************************************************/

}  // namespace librepcb

Q_DECLARE_METATYPE(librepcb::Point)

#endif  // LIBREPCB_POINT_H