From d0534789125d5ef8c44743b1fd9eaff21b9e7e0d Mon Sep 17 00:00:00 2001
From: Mikko Rasa <tdb@tdb.fi>
Date: Mon, 14 Mar 2022 08:52:06 +0200
Subject: [PATCH] Rename AffineTransformation to AffineTransform

This seems like a more appropriate term for the operation.
---
 ...finetransformation.h => affinetransform.h} | 82 +++++++++----------
 source/geometry/dummy.cpp                     |  2 +-
 source/geometry/loader.h                      | 14 ++--
 source/geometry/transformedshape.h            | 12 +--
 4 files changed, 55 insertions(+), 55 deletions(-)
 rename source/geometry/{affinetransformation.h => affinetransform.h} (58%)

diff --git a/source/geometry/affinetransformation.h b/source/geometry/affinetransform.h
similarity index 58%
rename from source/geometry/affinetransformation.h
rename to source/geometry/affinetransform.h
index e311b88..1cd4011 100644
--- a/source/geometry/affinetransformation.h
+++ b/source/geometry/affinetransform.h
@@ -1,5 +1,5 @@
-#ifndef MSP_GEOMETRY_AFFINETRANSFORMATION_H_
-#define MSP_GEOMETRY_AFFINETRANSFORMATION_H_
+#ifndef MSP_GEOMETRY_AFFINETRANSFORM_H_
+#define MSP_GEOMETRY_AFFINETRANSFORM_H_
 
 #include <msp/linal/matrix.h>
 #include "angle.h"
@@ -10,37 +10,37 @@ namespace Msp {
 namespace Geometry {
 
 template<typename T, unsigned D>
-class AffineTransformation;
+class AffineTransform;
 
 
 /**
-Helper class to provide specialized operations for AffineTransformation.
+Helper class to provide specialized operations for AffineTransform.
 */
 template<typename T, unsigned D>
-class AffineTransformationOps
+class AffineTransformOps
 {
 protected:
-	AffineTransformationOps() { }
+	AffineTransformOps() { }
 };
 
 template<typename T>
-class AffineTransformationOps<T, 2>
+class AffineTransformOps<T, 2>
 {
 protected:
-	AffineTransformationOps() { }
+	AffineTransformOps() { }
 
 public:
-	static AffineTransformation<T, 2> rotation(const Angle<T> &);
+	static AffineTransform<T, 2> rotation(const Angle<T> &);
 };
 
 template<typename T>
-class AffineTransformationOps<T, 3>
+class AffineTransformOps<T, 3>
 {
 protected:
-	AffineTransformationOps() { }
+	AffineTransformOps() { }
 
 public:
-	static AffineTransformation<T, 3> rotation(const Angle<T> &, const LinAl::Vector<T, 3> &);
+	static AffineTransform<T, 3> rotation(const Angle<T> &, const LinAl::Vector<T, 3> &);
 };
 
 
@@ -50,22 +50,22 @@ straightness of lines and ratios of distances.  Angles and distances themselves
 may change.  Internally this is represented by a square matrix of size D+1.
 */
 template<typename T, unsigned D>
-class AffineTransformation: public AffineTransformationOps<T, D>
+class AffineTransform: public AffineTransformOps<T, D>
 {
-	friend class AffineTransformationOps<T, D>;
+	friend class AffineTransformOps<T, D>;
 
 private:
 	LinAl::Matrix<T, D+1, D+1> matrix;
 
 public:
-	AffineTransformation();
+	AffineTransform();
 
-	static AffineTransformation<T, D> translation(const LinAl::Vector<T, D> &);
-	static AffineTransformation<T, D> scaling(const LinAl::Vector<T, D> &);
-	static AffineTransformation<T, D> shear(const LinAl::Vector<T, D> &, const LinAl::Vector<T, D> &);
+	static AffineTransform<T, D> translation(const LinAl::Vector<T, D> &);
+	static AffineTransform<T, D> scaling(const LinAl::Vector<T, D> &);
+	static AffineTransform<T, D> shear(const LinAl::Vector<T, D> &, const LinAl::Vector<T, D> &);
 
-	AffineTransformation &operator*=(const AffineTransformation &);
-	AffineTransformation &invert();
+	AffineTransform &operator*=(const AffineTransform &);
+	AffineTransform &invert();
 
 	const LinAl::Matrix<T, D+1, D+1> &get_matrix() const { return matrix; }
 	operator const LinAl::Matrix<T, D+1, D+1> &() const { return matrix; }
@@ -77,34 +77,34 @@ public:
 };
 
 template<typename T, unsigned D>
-inline AffineTransformation<T, D>::AffineTransformation()
+inline AffineTransform<T, D>::AffineTransform()
 {
 	this->matrix = LinAl::Matrix<T, D+1, D+1>::identity();
 }
 
 
 template<typename T, unsigned D>
-AffineTransformation<T, D> AffineTransformation<T, D>::translation(const LinAl::Vector<T, D> &v)
+AffineTransform<T, D> AffineTransform<T, D>::translation(const LinAl::Vector<T, D> &v)
 {
-	AffineTransformation<T, D> r;
+	AffineTransform<T, D> r;
 	for(unsigned i=0; i<D; ++i)
 		r.matrix(i, D) = v[i];
 	return r;
 }
 
 template<typename T, unsigned D>
-AffineTransformation<T, D> AffineTransformation<T, D>::scaling(const LinAl::Vector<T, D> &factors)
+AffineTransform<T, D> AffineTransform<T, D>::scaling(const LinAl::Vector<T, D> &factors)
 {
-	AffineTransformation<T, D> r;
+	AffineTransform<T, D> r;
 	for(unsigned i=0; i<D; ++i)
 		r.matrix(i, i) = factors[i];
 	return r;
 }
 
 template<typename T, unsigned D>
-AffineTransformation<T, D> AffineTransformation<T, D>::shear(const LinAl::Vector<T, D> &normal, const LinAl::Vector<T, D> &shift)
+AffineTransform<T, D> AffineTransform<T, D>::shear(const LinAl::Vector<T, D> &normal, const LinAl::Vector<T, D> &shift)
 {
-	AffineTransformation<T, D> r;
+	AffineTransform<T, D> r;
 	for(unsigned i=0; i<D; ++i)
 		for(unsigned j=0; j<D; ++j)
 			r.matrix(i, j) += normal[j]*shift[i];
@@ -112,9 +112,9 @@ AffineTransformation<T, D> AffineTransformation<T, D>::shear(const LinAl::Vector
 }
 
 template<typename T>
-AffineTransformation<T, 2> AffineTransformationOps<T, 2>::rotation(const Angle<T> &angle)
+AffineTransform<T, 2> AffineTransformOps<T, 2>::rotation(const Angle<T> &angle)
 {
-	AffineTransformation<T, 2> r;
+	AffineTransform<T, 2> r;
 	T c = cos(angle);
 	T s = sin(angle);
 	r.matrix(0, 0) = c;
@@ -125,9 +125,9 @@ AffineTransformation<T, 2> AffineTransformationOps<T, 2>::rotation(const Angle<T
 }
 
 template<typename T>
-AffineTransformation<T, 3> AffineTransformationOps<T, 3>::rotation(const Angle<T> &angle, const LinAl::Vector<T, 3> &axis)
+AffineTransform<T, 3> AffineTransformOps<T, 3>::rotation(const Angle<T> &angle, const LinAl::Vector<T, 3> &axis)
 {
-	AffineTransformation<T, 3> r;
+	AffineTransform<T, 3> r;
 	LinAl::Vector<T, 3> axn = normalize(axis);
 	T c = cos(angle);
 	T s = sin(angle);
@@ -145,54 +145,54 @@ AffineTransformation<T, 3> AffineTransformationOps<T, 3>::rotation(const Angle<T
 }
 
 template<typename T, unsigned D>
-inline AffineTransformation<T, D> &AffineTransformation<T, D>::operator*=(const AffineTransformation<T, D> &other)
+inline AffineTransform<T, D> &AffineTransform<T, D>::operator*=(const AffineTransform<T, D> &other)
 {
 	matrix *= other.get_matrix();
 	return *this;
 }
 
 template<typename T, unsigned D>
-inline AffineTransformation<T, D> operator*(const AffineTransformation<T, D> &at1, const AffineTransformation<T, D> &at2)
+inline AffineTransform<T, D> operator*(const AffineTransform<T, D> &at1, const AffineTransform<T, D> &at2)
 {
-	AffineTransformation<T, D> r = at1;
+	AffineTransform<T, D> r = at1;
 	return r *= at2;
 }
 
 template<typename T, unsigned D>
-inline AffineTransformation<T, D> &AffineTransformation<T, D>::invert()
+inline AffineTransform<T, D> &AffineTransform<T, D>::invert()
 {
 	matrix.invert();
 	return *this;
 }
 
 template<typename T, unsigned D>
-inline AffineTransformation<T, D> invert(const AffineTransformation<T, D> &at)
+inline AffineTransform<T, D> invert(const AffineTransform<T, D> &at)
 {
-	AffineTransformation<T, D> r = at;
+	AffineTransform<T, D> r = at;
 	return r.invert();
 }
 
 template<typename T, unsigned D>
-inline LinAl::Vector<T, D> AffineTransformation<T, D>::transform(const LinAl::Vector<T, D> &v) const
+inline LinAl::Vector<T, D> AffineTransform<T, D>::transform(const LinAl::Vector<T, D> &v) const
 {
 	return (matrix*compose(v, T(1))).template slice<D>(0);
 }
 
 template<typename T, unsigned D>
-inline LinAl::Vector<T, D> AffineTransformation<T, D>::transform_linear(const LinAl::Vector<T, D> &v) const
+inline LinAl::Vector<T, D> AffineTransform<T, D>::transform_linear(const LinAl::Vector<T, D> &v) const
 {
 	return (matrix*compose(v, T(0))).template slice<D>(0);
 }
 
 template<typename T, unsigned D>
-inline Ray<T, D> AffineTransformation<T, D>::transform(const Ray<T, D> &ray) const
+inline Ray<T, D> AffineTransform<T, D>::transform(const Ray<T, D> &ray) const
 {
 	LinAl::Vector<T, D> dir = transform_linear(ray.get_direction());
 	return Ray<T, D>(transform(ray.get_start()), dir, ray.get_limit()*dir.norm());
 }
 
 template<typename T, unsigned D>
-inline BoundingBox<T, D> AffineTransformation<T, D>::transform(const BoundingBox<T, D> &bbox) const
+inline BoundingBox<T, D> AffineTransform<T, D>::transform(const BoundingBox<T, D> &bbox) const
 {
 	LinAl::Vector<T, D> min_pt;
 	LinAl::Vector<T, D> max_pt;
diff --git a/source/geometry/dummy.cpp b/source/geometry/dummy.cpp
index 26aad38..be685b0 100644
--- a/source/geometry/dummy.cpp
+++ b/source/geometry/dummy.cpp
@@ -1,4 +1,4 @@
-#include "affinetransformation.h"
+#include "affinetransform.h"
 #include "angle.h"
 #include "boundingbox.h"
 #include "boundingsphere.h"
diff --git a/source/geometry/loader.h b/source/geometry/loader.h
index 2aff83f..0a9c4b5 100644
--- a/source/geometry/loader.h
+++ b/source/geometry/loader.h
@@ -140,7 +140,7 @@ template<typename T, unsigned D>
 class TransformationLoader: public Loader<T, D>
 {
 protected:
-	AffineTransformation<T, D> transformation;
+	AffineTransform<T, D> transformation;
 
 public:
 	TransformationLoader();
@@ -349,7 +349,7 @@ inline void TransformationLoader<T, D>::translate(const std::vector<T> &offset)
 	if(offset.size()!=D)
 		throw std::invalid_argument("TransformationLoader::translate");
 
-	transformation *= AffineTransformation<T, D>::translation(LinAl::Vector<T, D>(&offset[0]));
+	transformation *= AffineTransform<T, D>::translation(LinAl::Vector<T, D>(&offset[0]));
 }
 
 template<typename T, unsigned D>
@@ -363,10 +363,10 @@ inline void TransformationLoader<T, D>::scale(const std::vector<T> &s)
 		LinAl::Vector<T, D> us;
 		for(unsigned i=0; i<D; ++i)
 			us[i] = s.front();
-		transformation *= AffineTransformation<T, D>::scaling(us);
+		transformation *= AffineTransform<T, D>::scaling(us);
 	}
 	else
-		transformation *= AffineTransformation<T, D>::scaling(LinAl::Vector<T, D>(&s[0]));
+		transformation *= AffineTransform<T, D>::scaling(LinAl::Vector<T, D>(&s[0]));
 }
 
 template<typename T, unsigned D>
@@ -375,7 +375,7 @@ inline void TransformationLoader<T, D>::shear(const std::vector<T> &s)
 	if(s.size()!=2*D)
 		throw std::invalid_argument("TransformationLoader::shear");
 
-	transformation *= AffineTransformation<T, D>::shear(LinAl::Vector<T, D>(&s[0]), LinAl::Vector<T, D>(&s[D]));
+	transformation *= AffineTransform<T, D>::shear(LinAl::Vector<T, D>(&s[0]), LinAl::Vector<T, D>(&s[D]));
 }
 
 
@@ -388,7 +388,7 @@ inline ShapeLoader<TransformedShape<T, 2> >::ShapeLoader()
 template<typename T>
 inline void ShapeLoader<TransformedShape<T, 2> >::rotate(T a)
 {
-	TransformationLoader<T, 2>::transformation *= AffineTransformation<T, 2>::rotation(Angle<T>::from_degrees(a));
+	TransformationLoader<T, 2>::transformation *= AffineTransform<T, 2>::rotation(Angle<T>::from_degrees(a));
 }
 
 
@@ -401,7 +401,7 @@ inline ShapeLoader<TransformedShape<T, 3> >::ShapeLoader()
 template<typename T>
 inline void ShapeLoader<TransformedShape<T, 3> >::rotate(T a, T x, T y, T z)
 {
-	TransformationLoader<T, 3>::transformation *= AffineTransformation<T, 3>::rotation(Angle<T>::from_degrees(a), LinAl::Vector<T, 3>(x, y, z));
+	TransformationLoader<T, 3>::transformation *= AffineTransform<T, 3>::rotation(Angle<T>::from_degrees(a), LinAl::Vector<T, 3>(x, y, z));
 }
 
 
diff --git a/source/geometry/transformedshape.h b/source/geometry/transformedshape.h
index 9387123..168fbd9 100644
--- a/source/geometry/transformedshape.h
+++ b/source/geometry/transformedshape.h
@@ -1,7 +1,7 @@
 #ifndef MSP_GEOMETRY_TRANSFORMEDSHAPE_H_
 #define MSP_GEOMETRY_TRANSFORMEDSHAPE_H_
 
-#include "affinetransformation.h"
+#include "affinetransform.h"
 #include "shape.h"
 
 namespace Msp {
@@ -15,11 +15,11 @@ class TransformedShape: public Shape<T, D>
 {
 private:
 	Shape<T, D> *shape;
-	AffineTransformation<T, D> transformation;
-	AffineTransformation<T, D> inverse_trans;
+	AffineTransform<T, D> transformation;
+	AffineTransform<T, D> inverse_trans;
 
 public:
-	TransformedShape(const Shape<T, D> &, const AffineTransformation<T, D> &);
+	TransformedShape(const Shape<T, D> &, const AffineTransform<T, D> &);
 	TransformedShape(const TransformedShape &);
 	TransformedShape &operator=(const TransformedShape &);
 	~TransformedShape();
@@ -27,7 +27,7 @@ public:
 	virtual TransformedShape *clone() const;
 
 	const Shape<T, D> &get_shape() const { return *shape; }
-	const AffineTransformation<T, D> &get_transformation() const { return transformation; }
+	const AffineTransform<T, D> &get_transformation() const { return transformation; }
 
 	virtual BoundingBox<T, D> get_axis_aligned_bounding_box(unsigned = 0) const;
 	virtual bool contains(const LinAl::Vector<T, D> &) const;
@@ -37,7 +37,7 @@ public:
 };
 
 template<typename T, unsigned D>
-inline TransformedShape<T, D>::TransformedShape(const Shape<T, D> &s, const AffineTransformation<T, D> &t):
+inline TransformedShape<T, D>::TransformedShape(const Shape<T, D> &s, const AffineTransform<T, D> &t):
 	shape(s.clone()),
 	transformation(t),
 	inverse_trans(invert(t))
-- 
2.43.0