normal.cc 2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
/*
 * File:   normal.cc
 * Author: Jordan
 *
 * Created on August 9, 2012, 7:01 PM
 */

#include <cmath>
#include <sstream>
#include <iomanip>

#include "radixmath/normal.hh"
namespace radix
{

/**
 * Default constructor
 */
Normal::Normal()
    : x(0.0), y(0.0), z(0.0)
{
}

/**
 * Constructor
 * @param a
 */
Normal::Normal(Real a)
    : x(a), y(a), z(a)
{
}

/**
 * Constructor
 * @param _x
 * @param _y
 * @param _z
 */
Normal::Normal(Real _x, Real _y, Real _z)
    : x(_x), y(_y), z(_z)
{
}

/**
 * Copy constructor
 * @param n
 */
Normal::Normal(const Normal& n)
    : x(n.x), y(n.y), z(n.z)
{
}

/**
 * Copy Vector3D constructor
 * @param v
 */
Normal::Normal(const Vector3D& v)
    : x(v.x), y(v.y), z(v.z)
{
}

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

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

    x = rhs.x;
    y = rhs.y;
    z = rhs.z;

    return (*this);
}

Normal& Normal::operator=(const Point3D& rhs)
{
    x = rhs.x;
    y = rhs.y;
    z = rhs.z;
    return (*this);
}

Normal& Normal::operator=(const Vector3D& rhs)
{
    x = rhs.x;
    y = rhs.y;
    z = rhs.z;
    return (*this);
}

void Normal::normalize(void)
{
    Real length = std::sqrt(x * x + y * y + z * z);
    x /= length;
    y /= length;
    z /= length;
}

/**
 * @function operator*
 * @brief multiplication by a matrix on the left
 *
 * 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
 */
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));
}

std::string Normal::toString()const
{
    std::stringstream stream;
    stream<<std::setprecision(15);
    stream<<x<<","<<y<<","<<z;
    return stream.str();
}
}//namespace radix