Point: use free function dot() instead of operator*()

Also rename crossProduct() to cross() which is consistent with dot() and
the name used in e.g. Python numpy and the eigen c++ library.

Author: axxel

core/src/PerspectiveTransform.cpp

@@ -71,9 +71,9 @@ PerspectiveTransform PerspectiveTransform::UnitSquareTo(const QuadrilateralF& q)
 	} else {
 		auto d1 = q[1] - q[2];
 		auto d2 = q[3] - q[2];
-		auto denominator = crossProduct(d1, d2);
-		auto a13 = crossProduct(d3, d2) / denominator;
-		auto a23 = crossProduct(d1, d3) / denominator;
+		auto denominator = cross(d1, d2);
+		auto a13 = cross(d3, d2) / denominator;
+		auto a23 = cross(d1, d3) / denominator;
 		return {x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0,
 				y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0,
 				a13, a23, 1.0f};

core/src/Point.h

@@ -70,27 +70,26 @@ PointT<T> operator/(const PointT<T>& a, U d)
 	return {a.x / d, a.y / d};
 }
 
-template <typename T, typename U>
-double operator*(const PointT<T>& a, const PointT<U>& b)
+template <typename T>
+double length(PointT<T> d)
 {
-	return double(a.x) * b.x + a.y * b.y;
+	return std::sqrt(dot(d, d));
 }
 
 template <typename T>
 double distance(PointT<T> a, PointT<T> b)
 {
-	auto d = a - b;
-	return std::sqrt(d * d);
+	return length(a - b);
 }
 
-template <typename T>
-double length(PointT<T> d)
+template <typename T, typename U>
+double dot(const PointT<T>& a, const PointT<U>& b)
 {
-	return std::sqrt(d * d);
+	return double(a.x) * b.x + a.y * b.y;
 }
 
 template <typename T>
-double crossProduct(PointT<T> a, PointT<T> b)
+double cross(PointT<T> a, PointT<T> b)
 {
 	return a.x * b.y - b.x * a.y;
 }

core/src/Quadrilateral.h

@@ -78,7 +78,7 @@ bool IsConvex(const Quadrilateral<PointT>& poly)
 	{
 		auto d1 = poly[(i + 2) % N] - poly[(i + 1) % N];
 		auto d2 = poly[i] - poly[(i + 1) % N];
-		auto cp = crossProduct(d1, d2);
+		auto cp = cross(d1, d2);
 
 		if (i == 0)
 			sign = cp > 0;

core/src/datamatrix/DMDetector.cpp

@@ -448,12 +448,12 @@ class RegressionLine
 			a = +sumXY / std::sqrt(sumXX * sumXX + sumXY * sumXY);
 			b = -sumXX / std::sqrt(sumXX * sumXX + sumXY * sumXY);
 		}
-		if (_directionInward * normal() < 0) {
+		if (dot(_directionInward, normal()) < 0) {
 			a = -a;
 			b = -b;
 		}
-		c = normal() * mean; // (a*mean.x + b*mean.y);
-		return _directionInward * normal() > 0.5; // angle between original and new direction is at most 60 degree
+		c = dot(normal(), mean); // (a*mean.x + b*mean.y);
+		return dot(_directionInward, normal()) > 0.5; // angle between original and new direction is at most 60 degree
 	}
 
 	template <typename Container, typename Filter>
@@ -474,7 +474,7 @@ class RegressionLine
 	int length() const { return _points.size() >= 2 ? int(distance(_points.front(), _points.back())) : 0; }
 	bool isValid() const { return !std::isnan(a); }
 	PointF normal() const { return isValid() ? PointF(a, b) : _directionInward; }
-	double signedDistance(PointI p) const { return normal() * p - c; }
+	double signedDistance(PointI p) const { return dot(normal(), p) - c; }
 	PointF project(PointI p) const { return p - signedDistance(p) * normal(); }
 
 	void reverse() { std::reverse(_points.begin(), _points.end()); }
@@ -483,7 +483,7 @@ class RegressionLine
 		assert(_directionInward != PointF());
 		_points.push_back(p);
 		if (_points.size() == 1)
-			c = normal() * p;
+			c = dot(normal(), p);
 	}
 
 	void pop_back() { _points.pop_back(); }
@@ -605,7 +605,7 @@ class EdgeTracer : public BitMatrixCursor<PointI>
 		auto old_d = d;
 		setDirection(p - origin);
 		// if the new direction is pointing "backward", i.e. angle(new, old) > 90 deg -> break
-		if (d * old_d < 0)
+		if (dot(d, old_d) < 0)
 			return false;
 		// make sure d stays in the same quadrant to prevent an infinite loop
 		if (std::abs(d.x) == std::abs(d.y))
@@ -651,7 +651,7 @@ class EdgeTracer : public BitMatrixCursor<PointI>
 				// In case the 'go outward' step in traceStep lead us astray, we might end up with a line
 				// that is almost perpendicular to d. Then the back-projection below can result in an
 				// endless loop. Break if the angle between d and line is greater than 45 deg.
-				if (std::abs(normalized(d) * line.normal()) > 0.7) // thresh is approx. sin(45 deg)
+				if (std::abs(dot(normalized(d), line.normal())) > 0.7) // thresh is approx. sin(45 deg)
 					return false;
 
 				auto np = line.project(p);
@@ -663,7 +663,7 @@ class EdgeTracer : public BitMatrixCursor<PointI>
 				p = round(np);
 			}
 			else {
-				auto stepLengthInMainDir = line.points().empty() ? 0.0 : mainDirection(d) * (p - line.points().back());
+				auto stepLengthInMainDir = line.points().empty() ? 0.0 : dot(mainDirection(d), (p - line.points().back()));
 				line.add(p);
 
 				if (stepLengthInMainDir > 1) {

core/src/qrcode/QRFinderPatternFinder.cpp

@@ -422,7 +422,7 @@ static FinderPatternInfo SelectBestPatterns(std::vector<FinderPattern> possibleC
 	std::array<FinderPattern, 3> bestPatterns;
 	std::array<double, 3> squares;
 
-	auto squaredDistance = [](PointF a, PointF b) { return (a - b) * (a - b); };
+	auto squaredDistance = [](PointF a, PointF b) { return dot((a - b), (a - b)); };
 
 	for (int i = 0; i < nbPossibleCenters - 2; i++) {
 		auto& fpi = possibleCenters[i];
@@ -484,7 +484,7 @@ static FinderPatternInfo SelectBestPatterns(std::vector<FinderPattern> possibleC
 	// This asks whether BC x BA has a positive z component, which is the arrangement
 	// we want for A, B, C. If it's negative, then we've got it flipped around and
 	// should swap A and C.
-	if (crossProduct(c - b, a - b) < 0) {
+	if (cross(c - b, a - b) < 0) {
 		std::swap(a, c);
 	}