make Vec3 math methods public

Author: hschendel

float.go

@@ -18,7 +18,7 @@ const HalfPi = math.Pi * 0.5
 // QuarterPi is math.Pi * 0.25
 const QuarterPi = math.Pi * 0.25
 
-// almostEqual returns true, if a and b are equal allowing for numerical error tol.
+// AlmostEqual returns true, if a and b are equal allowing for numerical error tol.
 func almostEqual32(a, b, tol float32) bool {
 	return math.Abs(float64(a-b)) <= float64(tol)
 }

solid.go

@@ -91,7 +91,7 @@ func (s *Solid) Measure() SolidMeasure {
 		}
 	}
 
-	measure.Len = measure.Max.diff(measure.Min)
+	measure.Len = measure.Max.Diff(measure.Min)
 
 	return measure
 }
@@ -226,10 +226,11 @@ func (s *Solid) scaleDim(factor float64, dim int) {
 	}
 }
 
-// Rotate the solid by angle radians around a rotation axis defined
+// Rotate the solid by Angle radians around a rotation axis defined
 // by a point pos on the axis and a direction vector dir. This
 // example would rotate the solid by 90 degree around the z-axis:
-//    stl.Rotate(stl.Vec3{0,0,0}, stl.Vec3{0,0,1}, stl.HalfPi)
+//
+//	stl.Rotate(stl.Vec3{0,0,0}, stl.Vec3{0,0,1}, stl.HalfPi)
 func (s *Solid) Rotate(pos, dir Vec3, angle float64) {
 	var rotationMatrix Mat4
 	RotationMatrix(pos, dir, angle, &rotationMatrix)

solid_test.go

@@ -131,7 +131,7 @@ func TestRotate(t *testing.T) {
 	s := makeTestSolid()
 	s.Rotate(Vec3{0, 0, 0}, Vec3{0, 0, 1}, 0)
 	if !sOrig.sameOrderAlmostEqual(s) {
-		t.Error("Not equal after rotation around z-axis with 0 angle")
+		t.Error("Not equal after rotation around z-axis with 0 Angle")
 		t.Log("Expected:\n", sOrig)
 		t.Log("Found:\n", s)
 	}

test_test.go

@@ -89,9 +89,9 @@ func (s *Solid) sameOrderAlmostEqual(o *Solid) bool {
 }
 
 func (t *Triangle) sameOrderAlmostEqual(o *Triangle, tol float32) bool {
-	return t.Normal.almostEqual(o.Normal, tol) &&
-		t.Vertices[0].almostEqual(o.Vertices[0], tol) &&
-		t.Vertices[1].almostEqual(o.Vertices[1], tol) &&
-		t.Vertices[2].almostEqual(o.Vertices[2], tol) &&
+	return t.Normal.AlmostEqual(o.Normal, tol) &&
+		t.Vertices[0].AlmostEqual(o.Vertices[0], tol) &&
+		t.Vertices[1].AlmostEqual(o.Vertices[1], tol) &&
+		t.Vertices[2].AlmostEqual(o.Vertices[2], tol) &&
 		t.Attributes == o.Attributes
 }

transform.go

@@ -6,11 +6,11 @@ import (
 	"math"
 )
 
-// RotationMatrix calculates a 4x4 rotation matrix for a rotation of angle in radians
+// RotationMatrix calculates a 4x4 rotation matrix for a rotation of Angle in radians
 // around a rotation axis defined by a point on it (pos) and its direction (dir).
 // The result is written into *rotationMatrix.
 func RotationMatrix(pos Vec3, dir Vec3, angle float64, rotationMatrix *Mat4) {
-	dirN := dir.unitVec()
+	dirN := dir.UnitVec3()
 
 	s := math.Sin(angle)
 	c := math.Cos(angle)

triangle.go

@@ -26,9 +26,9 @@ type Triangle struct {
 func (t *Triangle) calculateNormal() Vec3 {
 	// The normal is calculated by normalizing the result of
 	// (V0-V2) x (V1-V2)
-	return t.Vertices[0].diff(t.Vertices[2]).
-		cross(t.Vertices[1].diff(t.Vertices[2])).
-		unitVec()
+	return t.Vertices[0].Diff(t.Vertices[2]).
+		Cross(t.Vertices[1].Diff(t.Vertices[2])).
+		UnitVec3()
 }
 
 // Recalculate the redundant normal vector using the right hand rule
@@ -52,16 +52,16 @@ func (t *Triangle) transformNR(transformationMatrix *Mat4) {
 }
 
 // Returns true if at least two vertices are exactly equal, meaning
-// this is a line, or even a dot.
+// this is a line, or even a Dot.
 func (t *Triangle) hasEqualVertices() bool {
 	return t.Vertices[0] == t.Vertices[1] ||
 		t.Vertices[0] == t.Vertices[2] ||
 		t.Vertices[1] == t.Vertices[2]
 }
 
 // Checks if normal matches vertices using right hand rule, with
-// numerical tolerance for angle between them given by tol in radians.
+// numerical tolerance for Angle between them given by tol in radians.
 func (t *Triangle) checkNormal(tol float64) bool {
 	calculatedNormal := t.calculateNormal()
-	return t.Normal.angle(calculatedNormal) < tol
+	return t.Normal.Angle(calculatedNormal) < tol
 }

vec3.go

@@ -17,8 +17,8 @@ func (vec Vec3) len() float64 {
 	return math.Sqrt(float64(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]))
 }
 
-// unitVec returns vec multiplied by 1/vec.Len(), so its new length is 1. If the vector is empty, it is returned as such.
-func (vec Vec3) unitVec() Vec3 {
+// UnitVec3 returns vec multiplied by 1/vec.Len(), so its new length is 1. If the vector is empty, it is returned as such.
+func (vec Vec3) UnitVec3() Vec3 {
 	l := vec.len()
 	if l == 0 {
 		return vec
@@ -27,58 +27,58 @@ func (vec Vec3) unitVec() Vec3 {
 	return Vec3{float32(float64(vec[0]) / l), float32(float64(vec[1]) / l), float32(float64(vec[2]) / l)}
 }
 
-// multScalar multiplies vec by scalar.
-func (vec Vec3) multScalar(scalar float64) Vec3 {
+// MultScalar multiplies vec by scalar.
+func (vec Vec3) MultScalar(scalar float64) Vec3 {
 	return Vec3{float32(float64(vec[0]) * scalar), float32(float64(vec[1]) * scalar), float32(float64(vec[2]) * scalar)}
 }
 
-// almostEqual returns true if vec and o are equal allowing for numerical error tol.
-func (vec Vec3) almostEqual(o Vec3, tol float32) bool {
+// AlmostEqual returns true if vec and o are equal allowing for numerical error tol.
+func (vec Vec3) AlmostEqual(o Vec3, tol float32) bool {
 	return almostEqual32(vec[0], o[0], tol) && almostEqual32(vec[1], o[1], tol) && almostEqual32(vec[2], o[2], tol)
 }
 
-// add returns the sum of vectors vec and o.
-func (vec Vec3) add(o Vec3) Vec3 {
+// Add returns the sum of vectors vec and o.
+func (vec Vec3) Add(o Vec3) Vec3 {
 	return Vec3{
 		vec[0] + o[0],
 		vec[1] + o[1],
 		vec[2] + o[2],
 	}
 }
 
-// diff returns the difference vec - o.
-func (vec Vec3) diff(o Vec3) Vec3 {
+// Diff returns the difference vec - o.
+func (vec Vec3) Diff(o Vec3) Vec3 {
 	return Vec3{
 		vec[0] - o[0],
 		vec[1] - o[1],
 		vec[2] - o[2],
 	}
 }
 
-// cross returns the vector cross product vec x o.
-func (vec Vec3) cross(o Vec3) Vec3 {
+// Cross returns the vector Cross product vec x o.
+func (vec Vec3) Cross(o Vec3) Vec3 {
 	return Vec3{
 		vec[1]*o[2] - vec[2]*o[1],
 		vec[2]*o[0] - vec[0]*o[2],
 		vec[0]*o[1] - vec[1]*o[0],
 	}
 }
 
-// dot returns the dot product between vec and o.
-func (vec Vec3) dot(o Vec3) float64 {
+// Dot returns the Dot product between vec and o.
+func (vec Vec3) Dot(o Vec3) float64 {
 	return float64(vec[0])*float64(o[0]) +
 		float64(vec[1])*float64(o[1]) +
 		float64(vec[2])*float64(o[2])
 }
 
-// angle between vec and o in radians, without sign, between 0 and Pi.
+// Angle between vec and o in radians, without sign, between 0 and Pi.
 // If vec or o is the origin, this returns 0.
-func (vec Vec3) angle(o Vec3) float64 {
+func (vec Vec3) Angle(o Vec3) float64 {
 	lenProd := vec.len() * o.len()
 	if lenProd == 0 {
 		return 0
 	}
-	cosAngle := vec.dot(o) / lenProd
+	cosAngle := vec.Dot(o) / lenProd
 	// Numerical correction
 	if cosAngle < -1 {
 		cosAngle = -1

vec3_test.go

@@ -10,21 +10,21 @@ func TestVec3Angle(t *testing.T) {
 	v := Vec3{1, 0, 0}
 	tol := 0.00005
 	testV := []Vec3{
-		Vec3{0, 1, 0},
-		Vec3{0, -1, 0},
-		Vec3{-1, 0, 0},
-		Vec3{-1, 1, 0},
-		Vec3{-1, -1, 0}}
+		{0, 1, 0},
+		{0, -1, 0},
+		{-1, 0, 0},
+		{-1, 1, 0},
+		{-1, -1, 0}}
 	expected := []float64{
 		HalfPi,
 		HalfPi,
 		Pi,
 		HalfPi + QuarterPi,
 		HalfPi + QuarterPi}
 	for i, tv := range testV {
-		r := v.angle(tv)
+		r := v.Angle(tv)
 		if !almostEqual64(expected[i], r, tol) {
-			t.Errorf("angle(%v, %v) = %g Pi, expected %g Pi", v, tv, r/Pi, expected[i]/Pi)
+			t.Errorf("Angle(%v, %v) = %g Pi, expected %g Pi", v, tv, r/Pi, expected[i]/Pi)
 		}
 	}
 }