affine_transf.hpp

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// Copyright (C) 2025-present by Pablo Antolin
//
// This file is part of the QUGaR library.
//
// SPDX-License-Identifier:    MIT
//
// --------------------------------------------------------------------------
 
#ifndef QUGAR_IMPL_AFFINE_TRANSF_HPP
#define QUGAR_IMPL_AFFINE_TRANSF_HPP
 
 
#include <qugar/numbers.hpp>
#include <qugar/point.hpp>
#include <qugar/types.hpp>
#include <qugar/vector.hpp>
 
#include <utility>
 
namespace qugar::impl {
 
std::pair<Point<3>, Point<3>> create_reference_system_around_axis(Point<3> axis_z);
 
 
template<int dim> class AffineTransf
{
public:
  static constexpr int n_coefs = dim * (dim + 1);
  template<typename T> using Tensor = Vector<T, dim *(dim + 1) / 2>;
 
  explicit AffineTransf();
 
  explicit AffineTransf(const Point<dim> &origin);
 
  AffineTransf(const Point<dim> &origin, real scale);
 
  template<int dim_aux = dim>
    requires(dim_aux == dim && dim == 2)
  AffineTransf(const Point<dim> &origin, const Point<dim> &axis_x);
 
  template<int dim_aux = dim>
    requires(dim_aux == dim && dim == 3)
  AffineTransf(const Point<dim> &origin, const Point<dim> &axis_x, const Point<dim> &axis_y);
 
  template<int dim_aux = dim>
    requires(dim_aux == dim && dim == 2)
  AffineTransf(const Point<dim> &origin, const Point<dim> &axis_x, real scale_x, real scale_y);
 
  template<int dim_aux = dim>
    requires(dim_aux == dim && dim == 3)
  AffineTransf(const Point<dim> &origin,
    const Point<dim> &axis_x,
    const Point<dim> &axis_y,
    real scale_x,
    real scale_y,
    real scale_z);
 
  explicit AffineTransf(const Vector<real, n_coefs> &coefs);
 
  AffineTransf<dim> operator*(const AffineTransf<dim> &rhs) const;
 
  AffineTransf<dim> inverse() const;
 
  template<typename T> [[nodiscard]] Vector<T, dim> transform_point(const Vector<T, dim> &point) const;
 
  template<typename T> [[nodiscard]] Vector<T, dim> transform_vector(const Vector<T, dim> &vector) const;
 
  template<typename T> [[nodiscard]] Tensor<T> transform_tensor(const Tensor<T> &tensor) const;
 
private:
  [[nodiscard]] static Vector<real, n_coefs> compute_coefs(const Point<dim> &origin, real scale);
 
  template<int dim_aux = dim>
    requires(dim_aux == dim && dim == 3)
  [[nodiscard]] static Vector<real, n_coefs> compute_coefs(const Point<dim> &origin,
    const Point<dim> &axis_x = Point<dim>(numbers::one, numbers::zero, numbers::zero),
    const Point<dim> &axis_y = Point<dim>(numbers::zero, numbers::one, numbers::zero),
    real scale_x = numbers::one,
    real scale_y = numbers::one,
    real scale_z = numbers::one);
 
  template<int dim_aux = dim>
    requires(dim_aux == dim && dim == 2)
  [[nodiscard]] static Vector<real, n_coefs> compute_coefs(const Point<dim> &origin,
    const Point<dim> &axis_x = Point<dim>(numbers::one, numbers::zero),
    real scale_x = numbers::one,
    real scale_y = numbers::one);
 
  Vector<real, n_coefs> coefs_;
};
 
 
}// namespace qugar::impl
 
 
#endif// QUGAR_IMPL_AFFINE_TRANSF_HPP