cgv
Loading...
Searching...
No Matches
fvec.h
1#pragma once
2
3// Make sure this is the first thing the compiler sees, while preventing warnings if
4// it happened to already be defined by something else including this header
5#ifndef _USE_MATH_DEFINES
6 #define _USE_MATH_DEFINES 1
7#endif
8#include <algorithm>
9#include <array>
10#include <cmath>
11#include <cstdint>
12#include <cstring>
13#include <iostream>
14#include <limits>
15#include <sstream>
16
17#include <cgv/type/standard_types.h>
18
19#include "constants.h"
20#include "functions.h"
21
22namespace cgv {
23namespace math {
24
25template <typename T> class vec;
26
28template <typename T, cgv::type::uint32_type N>
29class fvec {
30protected:
31 // the components of the vector
32 T v[N];
33
34public:
35 //@name type definitions
37
38 typedef T value_type;
40 typedef T& reference;
42 typedef const T& const_reference;
44 typedef std::size_t size_type;
46 typedef std::ptrdiff_t difference_type;
48 typedef T* pointer;
50 typedef const T* const_pointer;
52 typedef T* iterator;
54 typedef const T* const_iterator;
56 typedef std::reverse_iterator<iterator> reverse_iterator;
58 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
60 enum { dims = N };
62
63 //@name construction and assignment
65
66 fvec() {}
68 fvec(const T& x) { for(unsigned i = 0; i < N; ++i) v[i] = x; }
70 template <uint32_t _N = N, typename std::enable_if<_N >= 2, int>::type = 0>
71 fvec(const T& x, const T& y) { set(x, y); }
73 template <uint32_t _N = N, typename std::enable_if<_N >= 3, int>::type = 0>
74 fvec(const T& x, const T& y, const T& z) { set(x, y, z); }
76 template <uint32_t _N = N, typename std::enable_if<_N >= 4, int>::type = 0>
77 fvec(const T& x, const T& y, const T& z, const T& w) { set(x, y, z, w); }
79 fvec(cgv::type::uint32_type n, const T* a) {
80 cgv::type::uint32_type i, min_n = n < N ? n : N;
81 memmove(v, a, min_n * sizeof(T));
82 for(i = min_n; i < N; ++i) v[i] = T(0);
83 }
85 template <typename S>
86 fvec(cgv::type::uint32_type n, const S* a) {
87 cgv::type::uint32_type i, min_n = n < N ? n : N;
88 for(i = 0; i < min_n; ++i) v[i] = static_cast<T>(a[i]);
89 for(; i < N; ++i) v[i] = T(0);
90 }
92 template <typename S>
93 fvec(const fvec<S, N>& other) { for(unsigned i = 0; i < N; ++i) v[i] = static_cast<T>(other[i]); }
95 template <typename S1, typename S2>
96 fvec(const fvec<S1, N - 1>& other, S2 s) { for(unsigned i = 0; i < N - 1; ++i) v[i] = static_cast<T>(other[i]); v[N - 1] = static_cast<T>(s); }
98 template <typename S>
99 fvec(const fvec<S, N + 1>& other) { for(unsigned i = 0; i < N; ++i) v[i] = static_cast<T>(other[i]); }
101 fvec(const std::array<T, N>& a) : fvec(N, a.data()) {}
103 void assign(const std::array<T, N>& a) { for(unsigned i = 0; i < N; ++i) v[i] = a[i]; }
105 template <uint32_t _N = N, typename std::enable_if<_N >= 2, int>::type = 0>
106 void set(const T& x, const T& y) { v[0] = x; v[1] = y; }
108 template <uint32_t _N = N, typename std::enable_if<_N >= 3, int>::type = 0>
109 void set(const T& x, const T& y, const T& z) { v[0] = x; v[1] = y; v[2] = z; }
111 template <uint32_t _N = N, typename std::enable_if<_N >= 4, int>::type = 0>
112 void set(const T& x, const T& y, const T& z, const T& w) { v[0] = x; v[1] = y; v[2] = z; v[3] = w; }
114 void fill(const T& x) { for(unsigned i = 0; i < N; ++i) v[i] = x; }
116 void zeros() { fill(T(0)); }
118 void zerosh() { for(unsigned i = 0; i < N - 1; ++i) v[i] = T(0); v[N - 1] = T(1); }
120 void ones() { fill(T(1)); }
122 fvec<T, N + 1> lift() const { fvec<T, N + 1> h; (fvec<T, N>&)h = *this; h[N] = T(1); return h; }
124 fvec<T, N - 1> clip() const { return down()/this->operator[](N-1); }
126 const fvec<T, N - 1>& down() const { return *reinterpret_cast<const fvec<T, N-1>*>(this); }
128 fvec<T, N - 1>& down() { return *reinterpret_cast<fvec<T, N-1>*>(this); }
130 static fvec<T, N> zeroh() { fvec<T, N> r; r.zerosh(); return r; }
132 vec<T> to_vec() const;
134 static fvec<T, N> from_vec(const vec<T>&);
136
137 //@name access to components
139
140 static cgv::type::uint32_type size() { return N; }
142 T& x() { return v[0]; }
144 const T& x() const { return v[0]; }
146 T& y() { return v[1]; }
148 const T& y() const { return v[1]; }
150 T& z() { return v[2]; }
152 const T& z() const { return v[2]; }
154 T& w() { return v[3]; }
156 const T& w() const { return v[3]; }
158 T& operator[](int i) { return v[i]; }
160 const T& operator[](int i) const { return v[i]; }
162 T& operator()(int i) { return v[i]; }
164 const T& operator()(int i) const { return v[i]; }
166 T* data() { return v; }
168 const T* data() const { return v; }
170
171 //@name iterators
173
174 iterator begin() { return v; }
176 iterator end() { return v + N; }
178 const_iterator begin() const { return v; }
180 const_iterator end() const { return v + N; }
182 reverse_iterator rbegin() { return reverse_iterator(end()); }
184 reverse_iterator rend() { return reverse_iterator(begin()); }
186 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
188 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
190
191 //@name operators
193
194 fvec<T, N>& operator += (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] += s; return *this; }
196 fvec<T, N>& operator -= (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] -= s; return *this; }
198 fvec<T, N>& operator *= (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] *= s; return *this; }
200 fvec<T, N>& operator /= (const T& s) { for(unsigned i = 0; i < N; ++i) v[i] /= s; return *this; }
202 template <typename S>
203 fvec<T, N>& operator += (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] += static_cast<T>(v[i]); return *this; }
205 template <typename S>
206 fvec<T, N>& operator -= (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] -= static_cast<T>(v[i]); return *this; }
208 template <typename S>
209 fvec<T, N>& operator *= (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] *= static_cast<T>(v[i]); return *this; }
211 template <typename S>
212 fvec<T, N>& operator /= (const fvec<S, N>& v) { for(unsigned i = 0; i < N; ++i) this->v[i] /= static_cast<T>(v[i]); return *this; }
214 template <typename S>
215 fvec<T, N> operator + (const fvec<S, N>& v) const { fvec<T, N> r = *this; r += v; return r; }
217 template <typename S>
218 fvec<T, N> operator - (const fvec<S, N>& v) const { fvec<T, N> r = *this; r -= v; return r; }
220 template <typename S>
221 fvec<T, N> operator * (const fvec<S, N>& v) const { fvec<T, N> r = *this; r *= v; return r; }
223 template <typename S>
224 fvec<T, N> operator / (const fvec<S, N>& v) const { fvec<T, N> r = *this; r /= v; return r; }
226 fvec<T, N> operator + (const T& s) const { fvec<T, N> r = *this; r += s; return r; }
228 fvec<T, N> operator - (const T& s) const { fvec<T, N> r = *this; r -= s; return r; }
230 fvec<T, N> operator * (const T& s) const { fvec<T, N> r = *this; r *= s; return r; }
232 fvec<T, N> operator / (const T& s) const { fvec<T, N> r = *this; r /= s; return r; }
233
235 fvec<T, N> operator - () const { fvec<T, N> r; for(unsigned i = 0; i < N; ++i) r[i] = -v[i]; return r; }
236
238 template <typename S>
239 bool operator == (const fvec<S, N>& v) const {
240 for(unsigned i = 0; i < N; ++i)
241 if(operator[](i) != static_cast<T>(v[i])) return false;
242 return true;
243 }
245 template <typename S>
246 bool operator != (const fvec<S, N>& v) const {
247 for(unsigned i = 0; i < N; ++i)
248 if(operator[](i) != static_cast<T>(v[i])) return true;
249 return false;
250 }
252 template <typename S>
253 bool operator < (const fvec<S, N>& v) const {
254 for (unsigned i = N; i > 0; ) {
255 if (operator[](i) == static_cast<T>(v[i]))
256 continue;
257 return operator[](i) < static_cast<T>(v[i]);
258 }
259 return false;
260 }
262
263 //@name functions
265
266 T sqr_length() const {
267 T l = 0;
268 for(unsigned i = 0; i < N; ++i)
269 l += v[i] * v[i];
270 return l;
271 }
273 T length() const {
274 return std::sqrt(sqr_length());
275 }
277 void sign() {
278 for(unsigned i = 0; i < N; ++i)
279 v[i] = cgv::math::sign(v[i]);
280 }
282 void step(const fvec<T, N>& r) {
283 for(unsigned i = 0; i < N; ++i)
284 v[i] = cgv::math::step(v[i], r[i]);
285 }
287 void abs() {
288 if(std::numeric_limits<T>::is_signed) {
289 for(unsigned i = 0; i < N; ++i)
290 v[i] = std::abs(v[i]);
291 }
292 }
294 void ceil() {
295 for(unsigned i = 0; i < N; ++i)
296 v[i] = std::ceil(v[i]);
297 }
299 void floor() {
300 for(unsigned i = 0; i < N; ++i)
301 v[i] = std::floor(v[i]);
302 }
304 void round() {
305 for(unsigned i = 0; i < N; ++i)
306 v[i] = std::round(v[i]);
307 }
309 T normalize() {
310 T l = length();
311 T inv_l = T(1) / l;
312 for(unsigned i = 0; i < N; ++i)
313 v[i] *= inv_l;
314 return l;
315 }
317 T safe_normalize() {
318 T l = length();
319 if(std::abs(l) < std::numeric_limits<T>::epsilon())
320 return T(0);
321 T inv_l = T(1) / l;
322 for(unsigned i = 0; i < N; ++i)
323 v[i] *= inv_l;
324 return l;
325 }
327};
328
330#define CGV_MATH_FVEC_DECLARED
331
333template<typename T, cgv::type::uint32_type N>
334fvec<T, N> normalize(const fvec<T, N>& v) { fvec<T, N> w(v); w.normalize(); return w; }
335
337template<typename T, cgv::type::uint32_type N>
338fvec<T, N> safe_normalize(const fvec<T, N>& v) { fvec<T, N> w(v); w.safe_normalize(); return w; }
339
341template<typename T, cgv::type::uint32_type N>
342std::ostream& operator<<(std::ostream& out, const fvec<T, N>& v) {
343 for(unsigned i = 0; i < N - 1; ++i)
344 out << v[i] << " ";
345 out << v[N - 1];
346 return out;
347
348}
349
351template<typename T, cgv::type::uint32_type N>
352std::istream& operator>>(std::istream& in, fvec<T, N>& v) {
353 for(unsigned i = 0; i < N; ++i) {
354 in >> v[i];
355 if(in.fail() && i == 1) {
356 for(unsigned i = 1; i < N; ++i)
357 v[i] = v[0];
358 break;
359 }
360 }
361 return in;
362}
363
365template<typename T, cgv::type::uint32_type N>
366std::string to_string(const fvec<T, N>& v) {
367 std::ostringstream ss;
368 ss << v;
369 return ss.str();
370}
371
373template<typename T, cgv::type::uint32_type N>
374bool from_string(const std::string& s, fvec<T, N>& v) {
375 std::istringstream iss(s);
376 iss >> v;
377 return !iss.fail();
378}
379
381template <typename T, cgv::type::uint32_type N>
382fvec<T, N> operator * (const T& s, const fvec<T, N>& v) { fvec<T, N> r = v; r *= s; return r; }
383
385template <typename T, cgv::type::uint32_type N>
386fvec<T, N> operator / (const T& s, const fvec<T, N>& v) {
387 fvec<T, N> r;
388 for(unsigned i = 0; i < N; ++i)
389 r[i] = s / v[i];
390 return r;
391}
392
394template <typename T, typename S, cgv::type::uint32_type N>
395inline T dot(const fvec<T, N>& v, const fvec<S, N>& w) {
396 T r = 0;
397 for(unsigned i = 0; i < N; ++i)
398 r += static_cast<T>(v[i] * w[i]);
399 return r;
400}
401
404template <typename T, typename S, cgv::type::uint32_type N>
405inline S dot_pos(const fvec<T, N>& v, const fvec<S, N + 1>& w) {
406 T r = 0;
407 for(unsigned i = 0; i < N; ++i)
408 r += v[i] * w[i];
409 return r + w[N];
410}
413template <typename T, typename S, cgv::type::uint32_type N>
414inline S dot_pos(const fvec<T, N + 1>& v, const fvec<S, N>& w) {
415 T r = 0;
416 for(unsigned i = 0; i < N; ++i)
417 r += v[i] * w[i];
418 return r + v[N];
419}
420
423template <typename T, typename S, cgv::type::uint32_type N>
424inline S dot_dir(const fvec<T, N>& v, const fvec<S, N + 1>& w) {
425 T r = 0;
426 for(unsigned i = 0; i < N; ++i)
427 r += v[i] * w[i];
428 return r;
429}
432template <typename T, typename S, cgv::type::uint32_type N>
433inline S dot_dir(const fvec<T, N + 1>& v, const fvec<S, N>& w) {
434 T r = 0;
435 for(unsigned i = 0; i < N; ++i)
436 r += v[i] * w[i];
437 return r;
438}
439
441template <typename T, cgv::type::uint32_type N>
442inline fvec<T, N> cross(const fvec<T, N>& v, const fvec<T, N>& w) {
443 fvec<T, N> r(3);
444 r[0] = v[1] * w[2] - v[2] * w[1];
445 r[1] = v[2] * w[0] - v[0] * w[2];
446 r[2] = v[0] * w[1] - v[1] * w[0];
447 return r;
448}
449
451template <typename T, cgv::type::uint32_type N>
452inline T sqr_length(const fvec<T, N>& v) { return dot(v, v); }
453
455template <typename T, cgv::type::uint32_type N>
456inline T length(const fvec<T, N>& v) { return std::sqrt(dot(v, v)); }
457
459template <typename T, cgv::type::uint32_type N>
460inline T l1_norm(const fvec<T, N>& v) {
461 T sum = T(0);
462 for(unsigned i = 0; i < N; ++i)
463 sum += std::numeric_limits<T>::is_signed ? std::abs(v[i]) : v[i];
464 return sum;
465}
466
468template <typename T, cgv::type::uint32_type N>
469inline fvec<T, N> sign(fvec<T, N> v) { v.sign(); return v; }
470
472template <typename T, cgv::type::uint32_type N>
473inline fvec<T, N> step(const fvec<T, N>& edge, const fvec<T, N>& x) { fvec<T, N> r(edge); r.step(x); return r; }
474
476template <typename T, cgv::type::uint32_type N>
477inline fvec<T, N> abs(fvec<T, N> v) { v.abs(); return v; }
478
480template <typename T, cgv::type::uint32_type N>
481inline fvec<T, N> round(fvec<T, N> v) { v.round(); return v; }
482
484template <typename T, cgv::type::uint32_type N>
485inline fvec<T, N> floor(fvec<T, N> v) { v.floor(); return v; }
486
488template <typename T, cgv::type::uint32_type N>
489inline fvec<T, N> ceil(fvec<T, N> v) { v.ceil(); return v; }
490
492template <typename T, cgv::type::uint32_type N>
493inline fvec<T, N + 1> hom(fvec<T, N> v) {
494 return fvec<T, N + 1>(v, T(1));
495}
496
498template <typename T, cgv::type::uint32_type N>
499T min_value(const fvec<T, N>& v) {
500 return *(std::min_element(v.begin(), v.end()));
501}
502
504template <typename T, cgv::type::uint32_type N>
505unsigned min_index(const fvec<T, N>& v) {
506 return static_cast<unsigned>(std::distance(v.begin(), std::min_element(v.begin(), v.end())));
507}
508
510template <typename T, cgv::type::uint32_type N>
511T max_value(const fvec<T, N>& v) {
512 return *(std::max_element(v.begin(), v.end()));
513}
514
516template <typename T, cgv::type::uint32_type N>
517unsigned max_index(const fvec<T, N>& v) {
518 return static_cast<unsigned>(std::distance(v.begin(), std::max_element(v.begin(), v.end())));
519}
520
522template <typename T, cgv::type::uint32_type N>
523const fvec<T, N> lerp(const fvec<T, N>& v0, const fvec<T, N>& v1, T t) {
524 return (T(1) - t) * v0 + t * v1;
525}
526
528template <typename T, cgv::type::uint32_type N>
529const fvec<T, N> lerp(const fvec<T, N>& v0, const fvec<T, N>& v1, const fvec<T, N>& t) {
530 return (fvec<T, N>(1) - t) * v0 + t * v1;
531}
532
534template <typename T, cgv::type::uint32_type N>
535const fvec<T, N> slerp(const fvec<T, N>& v0, const fvec<T, N>& v1, T t) {
536 T dotv0v1 = dot(v0, v1);
537 // clamp between [-1,1]
538 if(dotv0v1 < -1)
539 dotv0v1 = -1;
540
541 if(dotv0v1 > 1)
542 dotv0v1 = 1;
543
544 T theta = std::acos(dotv0v1) * t;
545 auto v2 = normalize(v1 - (dotv0v1)*v0);
546 return T(std::cos(theta)) * v0 + T(std::sin(theta)) * v2;
547}
548
550template <typename T, cgv::type::uint32_type N>
551const fvec<T, N> min(const fvec<T, N>& v, T s) {
552 fvec<T, N> c;
553 for(unsigned i = 0; i < N; ++i)
554 c(i) = std::min(v[i], s);
555 return c;
556}
557
559template <typename T, cgv::type::uint32_type N>
560const fvec<T, N> min(const fvec<T, N>& v0, const fvec<T, N>& v1) {
561 fvec<T, N> c;
562 for(unsigned i = 0; i < N; ++i)
563 c[i] = std::min(v0[i], v1[i]);
564 return c;
565}
566
568template <typename T, cgv::type::uint32_type N>
569const fvec<T, N> max(const fvec<T, N>& v, T s) {
570 fvec<T, N> c;
571 for(unsigned i = 0; i < N; ++i)
572 c[i] = std::max(v[i], s);
573 return c;
574}
575
577template <typename T, cgv::type::uint32_type N>
578const fvec<T, N> max(const fvec<T, N>& v0, const fvec<T, N>& v1) {
579 fvec<T, N> c;
580 for(unsigned i = 0; i < N; ++i)
581 c[i] = std::max(v0[i], v1[i]);
582 return c;
583}
584
586template <typename T, cgv::type::uint32_type N>
587const fvec<T, N> clamp(const fvec<T, N>& v, T l, T r) {
588 fvec<T, N> c;
589 for(unsigned i = 0; i < N; ++i)
590 c[i] = cgv::math::clamp(v[i], l, r);
591 return c;
592}
593
595template <typename T, cgv::type::uint32_type N>
596const fvec<T, N> clamp(const fvec<T, N>& v, const fvec<T, N>& vl, const fvec<T, N>& vr) {
597 fvec<T, N> c;
598 for(unsigned i = 0; i < N; ++i)
599 c[i] = cgv::math::clamp(v[i], vl[i], vr[i]);
600 return c;
601}
602
604template <typename T, cgv::type::uint32_type N>
605const fvec<T, N> saturate(const fvec<T, N>& v) {
606 return clamp(v, T(0), T(1));
607}
608
610template <typename T, cgv::type::uint32_type N>
611const fvec<T, N> pow(const fvec<T, N>& v, T e) {
612 fvec<T, N> c;
613 for(unsigned i = 0; i < N; ++i)
614 c[i] = std::pow(v[i], e);
615 return c;
616}
617
619template <typename T, cgv::type::uint32_type N>
620const fvec<T, N> pow(const fvec<T, N>& v, const fvec<T, N>& e) {
621 fvec<T, N> c;
622 for(unsigned i = 0; i < N; ++i)
623 c[i] = std::pow(v[i], e[i]);
624 return c;
625}
626
628template <typename T, cgv::type::uint32_type N>
629fvec<T, N> ortho(const fvec<T, N>& v) = delete;
630
632template <typename T>
633fvec<T, 2> ortho(const fvec<T, 2>& v) {
634 return fvec<T, 2>(-v.y(), v.x());
635}
636
638template <typename T>
639fvec<T, 3> ortho(const fvec<T, 3>& v) {
640 return std::abs(v.x()) > std::abs(v.z()) ? fvec<T, 3>(-v.y(), v.x(), T(0)) : fvec<T, 3>(T(0), -v.z(), v.y());
641}
642
644template <typename T, cgv::type::uint32_type N>
645T to_angle(fvec<T, N> v) = delete;
646
648template <typename T>
649T to_angle(fvec<T, 2> v) {
650 v.normalize();
651 float a = std::atan2(v.y(), v.x());
652 if(a < T(0))
653 a += T(2) * static_cast<T>(cgv::math::constants::pi);
654 return a;
655}
656
658template <typename T, cgv::type::uint32_type N>
659T to_direction(fvec<T, N> v) = delete;
660
662template <typename T>
663fvec<T, 2> to_direction(T a) {
664 return fvec<T, 2>(std::cos(a), std::sin(a));
665}
666
668template <typename T, cgv::type::uint32_type N>
669fvec<T, N> project_to_vector(const fvec<T, N>& v, const fvec<T, N>& w) {
670 return w * dot(v, w) / dot(w, w);
671}
672
674template <typename T, cgv::type::uint32_type N>
675fvec<T, N> project_to_plane(const fvec<T, N>& v, const fvec<T, N>& n) {
676 return v - n * dot(v, n) / dot(n, n);
677}
678
679} // namespace math
680
683
685typedef cgv::math::fvec<bool, 2> bvec2;
687typedef cgv::math::fvec<bool, 3> bvec3;
689typedef cgv::math::fvec<bool, 4> bvec4;
690
692typedef cgv::math::fvec<float, 2> vec2;
694typedef cgv::math::fvec<float, 3> vec3;
696typedef cgv::math::fvec<float, 4> vec4;
697
699typedef cgv::math::fvec<double, 2> dvec2;
701typedef cgv::math::fvec<double, 3> dvec3;
703typedef cgv::math::fvec<double, 4> dvec4;
704
706typedef cgv::math::fvec<int16_t, 2> svec2;
708typedef cgv::math::fvec<int16_t, 3> svec3;
710typedef cgv::math::fvec<int16_t, 4> svec4;
712typedef cgv::math::fvec<uint16_t, 2> usvec2;
714typedef cgv::math::fvec<uint16_t, 3> usvec3;
716typedef cgv::math::fvec<uint16_t, 4> usvec4;
717
719typedef cgv::math::fvec<int32_t, 2> ivec2;
721typedef cgv::math::fvec<int32_t, 3> ivec3;
723typedef cgv::math::fvec<int32_t, 4> ivec4;
725typedef cgv::math::fvec<uint32_t, 2> uvec2;
727typedef cgv::math::fvec<uint32_t, 3> uvec3;
729typedef cgv::math::fvec<uint32_t, 4> uvec4;
730
732typedef cgv::math::fvec<int64_t, 2> lvec2;
734typedef cgv::math::fvec<int64_t, 3> lvec3;
736typedef cgv::math::fvec<int64_t, 4> lvec4;
738typedef cgv::math::fvec<uint64_t, 2> ulvec2;
740typedef cgv::math::fvec<uint64_t, 3> ulvec3;
742typedef cgv::math::fvec<uint64_t, 4> ulvec4;
743
745
746} // namespace cgv
747
748#include "vec.h"
749
750namespace cgv {
751namespace math {
752
754template <typename T, cgv::type::uint32_type N>
755vec<T> fvec<T,N>::to_vec() const {
756 vec<T> r;
757 r.set_extern_data(N,const_cast<T*>(v));
758 return r;
759}
760
762template <typename T, cgv::type::uint32_type N>
763fvec<T, N> fvec<T, N>::from_vec(const vec<T>& v)
764{
765 return fvec<T, N>(N < v.dim() ? N : v.dim(), &v[0]);
766}
767
768} // namespace math
769} // namespace cgv
770
771
772/*
773#include <cgv/utils/convert_string.h>
774#include <cgv/type/info/type_name.h>
775
776namespace cgv {
777namespace type {
778namespace info {
779
780template <typename T, cgv::type::uint32_type N>
781struct type_name<cgv::math::fvec<T,N> >
782{
783 static const char* get_name() {
784 static std::string name;
785 if (name.empty()) {
786 name = "fvec<";
787 name += type_name<T>::get_name();
788 name += ',';
789 name += cgv::utils::to_string(N);
790 name += '>';
791 }
792 return name.c_str();
793 }
794};
795
796}
797}
798}
799*/
cgv::base::single_method_action
complete implementation of method actions that only call one method when entering a node
Definition action.h:113
cgv::math::fvec
A vector with zero based index.
Definition fvec.h:29
cgv::math::fvec::rend
reverse_iterator rend()
return a reverse iterator past the last component of the reversed *this that corresponds to the compo...
Definition fvec.h:184
cgv::math::fvec::fvec
fvec(const fvec< S, N+1 > &other)
construct from vector of one dimension higher by dropping the highest dimension
Definition fvec.h:99
cgv::math::fvec::z
T & z()
return third component
Definition fvec.h:150
cgv::math::fvec::y
T & y()
return second component
Definition fvec.h:146
cgv::math::fvec::safe_normalize
T safe_normalize()
normalize the vector using the L2-Norm and return the length; if length is zero the vector remains un...
Definition fvec.h:317
cgv::math::fvec::normalize
T normalize()
normalize the vector using the L2-Norm and return the length
Definition fvec.h:309
cgv::math::fvec::zeroh
static fvec< T, N > zeroh()
constuct a homogeneous zero-vector (yields same result as calling fvec<T, N-1>(0)....
Definition fvec.h:130
cgv::math::fvec::operator()
T & operator()(int i)
return a reference to the component at specified index i
Definition fvec.h:162
cgv::math::fvec::round
void round()
round componentwise
Definition fvec.h:304
cgv::math::fvec::z
const T & z() const
return third component
Definition fvec.h:152
cgv::math::fvec::operator==
bool operator==(const fvec< S, N > &v) const
test for equality
Definition fvec.h:239
cgv::math::fvec::operator*=
fvec< T, N > & operator*=(const T &s)
in place multiplication with s
Definition fvec.h:198
cgv::math::fvec::operator*
fvec< T, N > operator*(const fvec< S, N > &v) const
componentwise vector multiplication
Definition fvec.h:221
cgv::math::fvec::down
fvec< T, N - 1 > & down()
provide reference to vector where last dimension is dropped
Definition fvec.h:128
cgv::math::fvec::operator-=
fvec< T, N > & operator-=(const T &s)
in place subtraction by scalar s
Definition fvec.h:196
cgv::math::fvec::operator[]
T & operator[](int i)
return a reference to the component at specified index i
Definition fvec.h:158
cgv::math::fvec::operator/=
fvec< T, N > & operator/=(const T &s)
in place division by scalar s
Definition fvec.h:200
cgv::math::fvec::sign
void sign()
componentwise sign values
Definition fvec.h:277
cgv::math::fvec::begin
iterator begin()
return an iterator to the first component of *this
Definition fvec.h:174
cgv::math::fvec::data
T * data()
return a pointer to the underlying array serving as component storage
Definition fvec.h:166
cgv::math::fvec::operator<
bool operator<(const fvec< S, N > &v) const
define smaller operator based on component comparison with significance increasing from 0 to N-1,...
Definition fvec.h:253
cgv::math::fvec::sqr_length
T sqr_length() const
square length of vector
Definition fvec.h:266
cgv::math::fvec::down
const fvec< T, N - 1 > & down() const
provide const reference to vector where last dimension is dropped
Definition fvec.h:126
cgv::math::fvec::length
T length() const
length of the vector L2-Norm
Definition fvec.h:273
cgv::math::fvec::floor
void floor()
floor componentwise
Definition fvec.h:299
cgv::math::fvec::from_vec
static fvec< T, N > from_vec(const vec< T > &)
conversion from vector
Definition fvec.h:763
cgv::math::fvec::operator+
fvec< T, N > operator+(const fvec< S, N > &v) const
vector addition
Definition fvec.h:215
cgv::math::fvec::fvec
fvec(const std::array< T, N > &a)
construct from std::array of same size
Definition fvec.h:101
cgv::math::fvec::operator+=
fvec< T, N > & operator+=(const T &s)
in place addition of a scalar s
Definition fvec.h:194
cgv::math::fvec::rbegin
const_reverse_iterator rbegin() const
return a reverse iterator to the first component of the reversed *this that corresponds to the last c...
Definition fvec.h:186
cgv::math::fvec::operator/
fvec< T, N > operator/(const fvec< S, N > &v) const
componentwise vector division
Definition fvec.h:224
cgv::math::fvec::operator!=
bool operator!=(const fvec< S, N > &v) const
test for unequal
Definition fvec.h:246
cgv::math::fvec::end
const_iterator end() const
return an iterator past the last component of *this
Definition fvec.h:180
cgv::math::fvec::to_vec
vec< T > to_vec() const
conversion to vector type
Definition fvec.h:755
cgv::math::fvec::clip
fvec< T, N - 1 > clip() const
convert back from homogeneous representation by performing a w-clip
Definition fvec.h:124
cgv::math::fvec::fvec
fvec(const T &x)
create a vector where all N components are initialized to the constant value x
Definition fvec.h:68
cgv::math::fvec::rend
const_reverse_iterator rend() const
return a reverse iterator past the last component of the reversed *this that corresponds to the compo...
Definition fvec.h:188
cgv::math::fvec::rbegin
reverse_iterator rbegin()
return a reverse iterator to the first component of the reversed *this that corresponds to the last c...
Definition fvec.h:182
cgv::math::fvec::y
const T & y() const
return second component
Definition fvec.h:148
cgv::math::fvec::end
iterator end()
return an iterator past the last component of *this
Definition fvec.h:176
cgv::math::fvec::fvec
fvec()
create an uninitialized vector
Definition fvec.h:66
cgv::math::fvec::operator()
const T & operator()(int i) const
return a reference to the component at specified index i
Definition fvec.h:164
cgv::math::fvec::w
const T & w() const
return fourth component
Definition fvec.h:156
cgv::math::fvec::x
T & x()
return first component
Definition fvec.h:142
cgv::math::fvec::operator-
fvec< T, N > operator-() const
negate the vector
Definition fvec.h:235
cgv::math::fvec::abs
void abs()
componentwise absolute values
Definition fvec.h:287
cgv::math::fvec::x
const T & x() const
return first component
Definition fvec.h:144
cgv::math::fvec::ceil
void ceil()
ceil componentwise
Definition fvec.h:294
cgv::math::fvec::begin
const_iterator begin() const
return an iterator to the first component of *this
Definition fvec.h:178
cgv::math::fvec::w
T & w()
return fourth component
Definition fvec.h:154
cgv::math::fvec::step
void step(const fvec< T, N > &r)
componentwise step function using stored values as edge
Definition fvec.h:282
cgv::math::fvec::data
const T * data() const
return a pointer to the underlying array serving as component storage
Definition fvec.h:168
cgv::math::fvec::operator[]
const T & operator[](int i) const
return a reference to the component at specified index i
Definition fvec.h:160
cgv::math::fvec::assign
void assign(const std::array< T, N > &a)
set to the contents of the given std::array with same size
Definition fvec.h:103
cgv::math::fvec::size
static cgv::type::uint32_type size()
return number of components
Definition fvec.h:140
cgv::math::vec
A column vector class.
Definition vec.h:28
cgv::math::vec::set_extern_data
void set_extern_data(unsigned dim, T *data)
set data pointer to an external data array
Definition vec.h:168
cgv::math::vec::dim
unsigned dim() const
number of elements
Definition vec.h:61
cgv::utils::to_string
std::string to_string(const std::string &v, unsigned int w, unsigned int p, bool)
specialization of conversion from string to strings
Definition convert_string.cxx:7
cgv::utils::from_string
bool from_string(std::string &v, const std::string &s)
specialization to extract string value from string
Definition convert_string.cxx:13
cgv::utils::min_value
T min_value(ForwardIt first, ForwardIt last, T fallback)
Find the minimum value in the range [first, last) or return fallback if the range is empty.
Definition algorithm.h:57
cgv::utils::max_value
T max_value(ForwardIt first, ForwardIt last, T fallback)
Find the maximum value in the range [first, last) or return fallback if the range is empty.
Definition algorithm.h:89
cgv
this header is dependency free
Definition print.h:11
cgv::lvec2
cgv::math::fvec< int64_t, 2 > lvec2
declare type of 2d 64 bit integer vectors
Definition fvec.h:732
cgv::usvec4
cgv::math::fvec< uint16_t, 4 > usvec4
declare type of 4d 16 bit unsigned integer vectors
Definition fvec.h:716
cgv::vec4
cgv::math::fvec< float, 4 > vec4
declare type of 4d single precision floating point vectors (used for homogeneous coordinates)
Definition fvec.h:696
cgv::ulvec4
cgv::math::fvec< uint64_t, 4 > ulvec4
declare type of 4d 64 bit unsigned integer vectors
Definition fvec.h:742
cgv::dvec4
cgv::math::fvec< double, 4 > dvec4
declare type of 4d double precision floating point vectors (used for homogeneous coordinates)
Definition fvec.h:703
cgv::dvec3
cgv::math::fvec< double, 3 > dvec3
declare type of 3d double precision floating point vectors
Definition fvec.h:701
cgv::uvec3
cgv::math::fvec< uint32_t, 3 > uvec3
declare type of 3d 32 bit unsigned integer vectors
Definition fvec.h:727
cgv::ivec3
cgv::math::fvec< int32_t, 3 > ivec3
declare type of 3d 32 bit integer vectors
Definition fvec.h:721
cgv::ivec4
cgv::math::fvec< int32_t, 4 > ivec4
declare type of 4d 32 bit integer vectors
Definition fvec.h:723
cgv::uvec4
cgv::math::fvec< uint32_t, 4 > uvec4
declare type of 4d 32 bit unsigned integer vectors
Definition fvec.h:729
cgv::ivec2
cgv::math::fvec< int32_t, 2 > ivec2
declare type of 2d 32 bit integer vectors
Definition fvec.h:719
cgv::svec3
cgv::math::fvec< int16_t, 3 > svec3
declare type of 3d 16 bit integer vectors
Definition fvec.h:708
cgv::usvec3
cgv::math::fvec< uint16_t, 3 > usvec3
declare type of 3d 16 bit unsigned integer vectors
Definition fvec.h:714
cgv::vec2
cgv::math::fvec< float, 2 > vec2
declare type of 2d single precision floating point vectors
Definition fvec.h:692
cgv::lvec3
cgv::math::fvec< int64_t, 3 > lvec3
declare type of 3d 64 bit integer vectors
Definition fvec.h:734
cgv::bvec4
cgv::math::fvec< bool, 4 > bvec4
declare type of 4d boolean vectors
Definition fvec.h:689
cgv::vec3
cgv::math::fvec< float, 3 > vec3
declare type of 3d single precision floating point vectors
Definition fvec.h:694
cgv::dvec2
cgv::math::fvec< double, 2 > dvec2
declare type of 2d double precision floating point vectors
Definition fvec.h:699
cgv::usvec2
cgv::math::fvec< uint16_t, 2 > usvec2
declare type of 2d 16 bit unsigned integer vectors
Definition fvec.h:712
cgv::uvec2
cgv::math::fvec< uint32_t, 2 > uvec2
declare type of 2d 32 bit unsigned integer vectors
Definition fvec.h:725
cgv::svec2
cgv::math::fvec< int16_t, 2 > svec2
declare type of 2d 16 bit integer vectors
Definition fvec.h:706
cgv::ulvec3
cgv::math::fvec< uint64_t, 3 > ulvec3
declare type of 3d 64 bit unsigned integer vectors
Definition fvec.h:740
cgv::lvec4
cgv::math::fvec< int64_t, 4 > lvec4
declare type of 4d 64 bit integer vectors
Definition fvec.h:736
cgv::bvec3
cgv::math::fvec< bool, 3 > bvec3
declare type of 3d boolean vectors
Definition fvec.h:687
cgv::svec4
cgv::math::fvec< int16_t, 4 > svec4
declare type of 4d 16 bit integer vectors
Definition fvec.h:710
cgv::bvec2
cgv::math::fvec< bool, 2 > bvec2
declare type of 2d boolean vectors
Definition fvec.h:685
cgv::ulvec2
cgv::math::fvec< uint64_t, 2 > ulvec2
declare type of 2d 64 bit unsigned integer vectors
Definition fvec.h:738
vr
the vr namespace for virtual reality support
Definition gl_vr_display.cxx:5
vr::operator<<
std::ostream & operator<<(std::ostream &os, const vr_device_info &di)
stream out operator for device infos
Definition vr_info.cxx:10