normal.cc 2 KB
Newer Older
1
2
3
4
5
6
7
8
9
/*
 * File:   normal.cc
 * Author: Jordan
 *
 * Created on August 9, 2012, 7:01 PM
 */

#include <cmath>
#include <iomanip>
10
#include <sstream>
11
12

#include "radixmath/normal.hh"
13
namespace radix {
14
15
16
17

/**
 * Default constructor
 */
18
19
20
21
Normal::Normal()
    : x(0.0)
    , y(0.0)
    , z(0.0) {}
22
23
24
25
26

/**
 * Constructor
 * @param a
 */
27
28
29
30
Normal::Normal(Real a)
    : x(a)
    , y(a)
    , z(a) {}
31
32
33
34
35
36
37

/**
 * Constructor
 * @param _x
 * @param _y
 * @param _z
 */
38
39
40
41
Normal::Normal(Real _x, Real _y, Real _z)
    : x(_x)
    , y(_y)
    , z(_z) {}
42
43
44
45
46

/**
 * Copy constructor
 * @param n
 */
47
48
49
50
Normal::Normal(const Normal &n)
    : x(n.x)
    , y(n.y)
    , z(n.z) {}
51
52
53
54
55

/**
 * Copy Vector3D constructor
 * @param v
 */
56
57
58
59
Normal::Normal(const Vector3D &v)
    : x(v.x)
    , y(v.y)
    , z(v.z) {}
60
61
62
63

/**
 * Destructor
 */
64
Normal::~Normal() {}
65

66
67
Normal &Normal::operator=(const Normal &rhs) {
  if (this == &rhs) return (*this);
68

69
70
71
  x = rhs.x;
  y = rhs.y;
  z = rhs.z;
72

73
  return (*this);
74
75
}

76
77
78
79
80
Normal &Normal::operator=(const Point3D &rhs) {
  x = rhs.x;
  y = rhs.y;
  z = rhs.z;
  return (*this);
81
82
}

83
84
85
86
87
Normal &Normal::operator=(const Vector3D &rhs) {
  x = rhs.x;
  y = rhs.y;
  z = rhs.z;
  return (*this);
88
89
}

90
91
92
93
94
void Normal::normalize(void) {
  Real length = std::sqrt(x * x + y * y + z * z);
  x /= length;
  y /= length;
  z /= length;
95
96
97
98
99
100
}

/**
 * @function operator*
 * @brief multiplication by a matrix on the left
 *
101
102
 * a normal is transformed by multiplying it on the left by the transpose of the
 * upper left 3 x 3 partition of the inverse transformation matrix
103
 */
104
105
106
107
108
109
Normal operator*(const Matrix &mat, const Normal &n) {
  return (Normal(
      mat.matrix[0][0] * n.x + mat.matrix[1][0] * n.y + mat.matrix[2][0] * n.z,
      mat.matrix[0][1] * n.x + mat.matrix[1][1] * n.y + mat.matrix[2][1] * n.z,
      mat.matrix[0][2] * n.x + mat.matrix[1][2] * n.y +
          mat.matrix[2][2] * n.z));
110
111
}

112
113
114
115
116
std::string Normal::toString() const {
  std::stringstream stream;
  stream << std::setprecision(15);
  stream << x << "," << y << "," << z;
  return stream.str();
117
}
118
}  // namespace radix