Point.h

Go to the documentation of this file.

#pragma once
 
 
#include "math/MathUtils.h"
#include "objects/utility/OperatorTemplate.h"
 
NAMESPACE_SPH_BEGIN
 
struct PlotPoint : public OperatorTemplate<PlotPoint> {
    Float x, y;
 
    PlotPoint() = default;
 
    PlotPoint(const Float x, const Float y)
        : x(x)
        , y(y) {}
 
    PlotPoint& operator+=(const PlotPoint& other) {
        x += other.x;
        y += other.y;
        return *this;
    }
 
    PlotPoint& operator*=(const Float value) {
        x *= value;
        y *= value;
        return *this;
    }
 
    bool operator==(const PlotPoint& other) const {
        return x == other.x && y == other.y;
    }
};
 
struct ErrorPlotPoint : public PlotPoint {
    Float dx, dy;
};
 
class AffineMatrix2 : public OperatorTemplate<AffineMatrix2> {
private:
    Float data[6];
 
public:
    AffineMatrix2(const Float scale = 1._f, const PlotPoint translation = PlotPoint(0._f, 0._f))
        : data{ scale, 0._f, translation.x, 0._f, scale, translation.y } {}
 
    AffineMatrix2(const Float xx,
        const Float yx,
        const Float xy,
        const Float yy,
        const Float tx = 0._f,
        const Float ty = 0._f)
        : data{ xx, yx, tx, xy, yy, ty } {}
 
    Float& operator()(const Size i, const Size j) {
        SPH_ASSERT(i < 2 && j < 3);
        return data[3 * i + j];
    }
 
    Float operator()(const Size i, const Size j) const {
        SPH_ASSERT(i < 2 && j < 3);
        return data[3 * i + j];
    }
 
    Float get(const Size i, const Size j) const {
        return operator()(i, j);
    }
 
    PlotPoint transformPoint(const PlotPoint& p) const {
        return PlotPoint(
            get(0, 0) * p.x + get(0, 1) * p.y + get(0, 2), get(1, 0) * p.x + get(1, 1) * p.y + get(1, 2));
    }
 
    PlotPoint transformVector(const PlotPoint& p) const {
        return PlotPoint(get(0, 0) * p.x + get(0, 1) * p.y, get(1, 0) * p.x + get(1, 1) * p.y);
    }
 
    AffineMatrix2 inverse() const {
        const Float a = get(0, 0);
        const Float b = get(0, 1);
        const Float c = get(1, 0);
        const Float d = get(1, 1);
        const Float tx = get(0, 2);
        const Float ty = get(1, 2);
 
        const Float det = a * d - b * c;
        const Float detInv = 1._f / det;
        SPH_ASSERT(det != 0._f);
 
        return AffineMatrix2(d * detInv,
            -b * detInv,
            -c * detInv,
            a * detInv,
            -(d * tx - b * ty) * detInv,
            (c * tx - a * ty) * detInv);
    }
 
    AffineMatrix2 transpose() const {
        return AffineMatrix2(data[0], data[3], data[1], data[4], -data[2], -data[5]);
    }
 
    static AffineMatrix2 rotate(const Float phi) {
        const Float c = cos(phi);
        const Float s = sin(phi);
        return AffineMatrix2(c, s, -s, c);
    }
 
    bool operator==(const AffineMatrix2& other) const {
        for (Size i = 0; i < 6; ++i) {
            if (data[i] != other.data[i]) {
                return false;
            }
        }
        return true;
    }
};
 
 
NAMESPACE_SPH_END