From ce7b347fa4e4251e2d65f1355cb3ed1ecebe7da8 Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Thu, 5 Aug 2021 16:17:47 -0300 Subject: [PATCH 01/11] Resolve conflicts with ign-math6. Signed-off-by: LolaSegura --- src/RollingMean.i | 49 ++++++++++++++++++++++++++++++++++++ src/RollingMean_TEST.py | 55 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+) create mode 100644 src/RollingMean.i create mode 100644 src/RollingMean_TEST.py diff --git a/src/RollingMean.i b/src/RollingMean.i new file mode 100644 index 000000000..f3f419676 --- /dev/null +++ b/src/RollingMean.i @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2021 Open Source Robotics Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +%module rollingMean +%{ +#include +%} + +namespace ignition +{ + namespace math + { + class RollingMean + { + + public: explicit RollingMean(size_t _windowSize = 10); + public: ~RollingMean(); + public: double Mean() const; + public: size_t Count() const; + public: void Push(double _value); + public: void Clear(); + public: void SetWindowSize(size_t _windowSize); + public: size_t WindowSize() const; + + #ifdef _WIN32 + #pragma warning(push) + #pragma warning(disable: 4251) + #endif + private: std::unique_ptr dataPtr; + #ifdef _WIN32 + #pragma warning(pop) + #endif + }; + } +} \ No newline at end of file diff --git a/src/RollingMean_TEST.py b/src/RollingMean_TEST.py new file mode 100644 index 000000000..284c0755d --- /dev/null +++ b/src/RollingMean_TEST.py @@ -0,0 +1,55 @@ +# Copyright (C) 2021 Open Source Robotics Foundation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest +import math +from ignition.math import RollingMean + + +class TestRollingMean(unittest.TestCase): + + def test_rolling_mean(self): + mean = RollingMean() + self.assertEqual(0, mean.Count()) + self.assertEqual(10, mean.WindowSize()) + + mean.SetWindowSize(4) + self.assertEqual(4, mean.WindowSize()) + mean.SetWindowSize(0) + self.assertEqual(4, mean.WindowSize()) + + mean.Push(1.0) + self.assertAlmostEqual(1.0, mean.Mean()) + mean.Push(2.0) + self.assertAlmostEqual(1.5, mean.Mean()) + mean.Push(3.0) + self.assertAlmostEqual(2.0, mean.Mean()) + mean.Push(10.0) + self.assertAlmostEqual(4.0, mean.Mean()) + mean.Push(20.0) + self.assertAlmostEqual(8.75, mean.Mean()) + + mean.Clear() + self.assertTrue(math.isnan(mean.Mean())) + + mean.Push(100.0) + mean.Push(200.0) + mean.Push(300.0) + self.assertEqual(3, mean.Count()) + mean.SetWindowSize(2) + self.assertEqual(0, mean.Count()) + + +if __name__ == '__main__': + unittest.main() From 9d91a2515744d9ef74c89144bb399cd71ee44e50 Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Thu, 5 Aug 2021 16:20:19 -0300 Subject: [PATCH 02/11] Adds scripting interface to Color and a python test. Signed-off-by: LolaSegura --- src/Color.i | 94 ++++++++++++++ src/Color_TEST.py | 322 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 416 insertions(+) create mode 100644 src/Color.i create mode 100644 src/Color_TEST.py diff --git a/src/Color.i b/src/Color.i new file mode 100644 index 000000000..946b6938f --- /dev/null +++ b/src/Color.i @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2021 Open Source Robotics Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +%module Color +%{ +#include +#include +#include +#include +%} + +namespace ignition +{ + namespace math + { + class Color + { + public: static const Color White; + public: static const Color Black; + public: static const Color Red; + public: static const Color Green; + public: static const Color Blue; + public: static const Color Yellow; + public: static const Color Magenta; + public: static const Color Cyan; + public: typedef unsigned int RGBA; + public: typedef unsigned int BGRA; + public: typedef unsigned int ARGB; + public: typedef unsigned int ABGR; + + public: Color(); + public: Color(const float _r, const float _g, const float _b, + const float _a = 1.0); + public: Color(const Color &_clr); + public: virtual ~Color(); + public: void Reset(); + public: void Set(const float _r = 1, const float _g = 1, + const float _b = 1, const float _a = 1); + public: Vector3 HSV() const; + public: void SetFromHSV(const float _h, const float _s, const float _v); + public: Vector3 YUV() const; + public: void SetFromYUV(const float _y, const float _u, const float _v); + public: RGBA AsRGBA() const; + public: BGRA AsBGRA() const; + public: ARGB AsARGB() const; + public: ABGR AsABGR() const; + public: void SetFromRGBA(const RGBA _v); + public: void SetFromBGRA(const BGRA _v); + public: void SetFromARGB(const ARGB _v); + public: void SetFromABGR(const ABGR _v); + public: Color operator+(const Color &_pt) const; + public: Color operator+(const float &_v) const; + public: const Color &operator+=(const Color &_pt); + public: Color operator-(const Color &_pt) const; + public: Color operator-(const float &_v) const; + public: const Color &operator-=(const Color &_pt); + public: const Color operator/(const Color &_pt) const; + public: const Color operator/(const float &_v) const; + public: const Color &operator/=(const Color &_pt); + public: const Color operator*(const Color &_pt) const; + public: const Color operator*(const float &_v) const; + public: const Color &operator*=(const Color &_pt); + public: bool operator==(const Color &_pt) const; + public: bool operator!=(const Color &_pt) const; + private: void Clamp(); + public: float R() const; + public: float G() const; + public: float B() const; + public: float A() const; + public: void R(const float _r); + public: void G(const float _g); + public: void B(const float _b); + public: void A(const float _a); + private: float r = 0; + private: float g = 0; + private: float b = 0; + private: float a = 1; + }; + } +} diff --git a/src/Color_TEST.py b/src/Color_TEST.py new file mode 100644 index 000000000..15a241a26 --- /dev/null +++ b/src/Color_TEST.py @@ -0,0 +1,322 @@ +# Copyright (C) 2021 Open Source Robotics Foundation + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest +from ignition.math import Color +from ignition.math import Vector3f + + +class TestColor(unittest.TestCase): + + def test_const_color(self): + self.assertAlmostEqual(1.0, Color.White.R()) + self.assertAlmostEqual(1.0, Color.White.G()) + self.assertAlmostEqual(1.0, Color.White.B()) + self.assertAlmostEqual(1.0, Color.White.A()) + + self.assertAlmostEqual(0.0, Color.Black.R()) + self.assertAlmostEqual(0.0, Color.Black.G()) + self.assertAlmostEqual(0.0, Color.Black.B()) + self.assertAlmostEqual(1.0, Color.Black.A()) + + self.assertAlmostEqual(1.0, Color.Red.R()) + self.assertAlmostEqual(0.0, Color.Red.G()) + self.assertAlmostEqual(0.0, Color.Red.B()) + self.assertAlmostEqual(1.0, Color.Red.A()) + + self.assertAlmostEqual(0.0, Color.Green.R()) + self.assertAlmostEqual(1.0, Color.Green.G()) + self.assertAlmostEqual(0.0, Color.Green.B()) + self.assertAlmostEqual(1.0, Color.Green.A()) + + self.assertAlmostEqual(0.0, Color.Blue.R()) + self.assertAlmostEqual(0.0, Color.Blue.G()) + self.assertAlmostEqual(1.0, Color.Blue.B()) + self.assertAlmostEqual(1.0, Color.Blue.A()) + + self.assertAlmostEqual(1.0, Color.Yellow.R()) + self.assertAlmostEqual(1.0, Color.Yellow.G()) + self.assertAlmostEqual(0.0, Color.Yellow.B()) + self.assertAlmostEqual(1.0, Color.Yellow.A()) + + self.assertAlmostEqual(1.0, Color.Magenta.R()) + self.assertAlmostEqual(0.0, Color.Magenta.G()) + self.assertAlmostEqual(1.0, Color.Magenta.B()) + self.assertAlmostEqual(1.0, Color.Magenta.A()) + + self.assertAlmostEqual(0.0, Color.Cyan.R()) + self.assertAlmostEqual(1.0, Color.Cyan.G()) + self.assertAlmostEqual(1.0, Color.Cyan.B()) + self.assertAlmostEqual(1.0, Color.Cyan.A()) + + def test_color(self): + clr0 = Color() + self.assertAlmostEqual(0.0, clr0.R()) + self.assertAlmostEqual(0.0, clr0.G()) + self.assertAlmostEqual(0.0, clr0.B()) + self.assertAlmostEqual(1.0, clr0.A()) + self.assertEqual(clr0.AsRGBA(), 255) + clr0.A(0.0) + self.assertEqual(clr0.AsRGBA(), 0) + + clr = Color(.1, .2, .3, 1.0) + self.assertAlmostEqual(0.1, clr.R()) + self.assertAlmostEqual(0.2, clr.G()) + self.assertAlmostEqual(0.3, clr.B()) + self.assertAlmostEqual(1.0, clr.A()) + + clr.Set(1, 0, 0, 0) + self.assertAlmostEqual(clr.AsRGBA(), 255 << 24) + self.assertAlmostEqual(clr.AsBGRA(), 255 << 8) + self.assertAlmostEqual(clr.AsARGB(), 255 << 16) + self.assertAlmostEqual(clr.AsABGR(), 255) + clr0.SetFromRGBA(255 << 24) + self.assertEqual(clr0, clr) + clr0.SetFromBGRA(255 << 8) + self.assertEqual(clr0, clr) + clr0.SetFromARGB(255 << 16) + self.assertEqual(clr0, clr) + clr0.SetFromABGR(255) + self.assertEqual(clr0, clr) + + clr.Set(0, 1, 0, 0) + self.assertAlmostEqual(clr.AsRGBA(), 255 << 16) + self.assertAlmostEqual(clr.AsBGRA(), 255 << 16) + self.assertAlmostEqual(clr.AsARGB(), 255 << 8) + self.assertAlmostEqual(clr.AsABGR(), 255 << 8) + clr0.SetFromRGBA(255 << 16) + self.assertEqual(clr0, clr) + clr0.SetFromBGRA(255 << 16) + self.assertEqual(clr0, clr) + clr0.SetFromARGB(255 << 8) + self.assertEqual(clr0, clr) + clr0.SetFromABGR(255 << 8) + self.assertEqual(clr0, clr) + + clr.Set(0, 0, 1, 0) + self.assertAlmostEqual(clr.AsRGBA(), 255 << 8) + self.assertAlmostEqual(clr.AsBGRA(), 255 << 24) + self.assertAlmostEqual(clr.AsARGB(), 255) + self.assertAlmostEqual(clr.AsABGR(), 255 << 16) + clr0.SetFromRGBA(255 << 8) + self.assertEqual(clr0, clr) + clr0.SetFromBGRA(255 << 24) + self.assertEqual(clr0, clr) + clr0.SetFromARGB(255) + self.assertEqual(clr0, clr) + clr0.SetFromABGR(255 << 16) + self.assertEqual(clr0, clr) + + clr.Set(0, 0, 0, 1) + self.assertAlmostEqual(clr.AsRGBA(), 255) + self.assertAlmostEqual(clr.AsBGRA(), 255) + self.assertAlmostEqual(clr.AsARGB(), 255 << 24) + self.assertAlmostEqual(clr.AsABGR(), 255 << 24) + clr0.SetFromRGBA(255) + self.assertEqual(clr0, clr) + clr0.SetFromBGRA(255) + self.assertEqual(clr0, clr) + clr0.SetFromARGB(255 << 24) + self.assertEqual(clr0, clr) + clr0.SetFromABGR(255 << 24) + self.assertEqual(clr0, clr) + + clr.Reset() + self.assertAlmostEqual(0.0, clr.R()) + self.assertAlmostEqual(0.0, clr.G()) + self.assertAlmostEqual(0.0, clr.B()) + self.assertAlmostEqual(1.0, clr.A()) + + clr.SetFromHSV(0, 0.5, 1.0) + self.assertAlmostEqual(1.0, clr.R()) + self.assertAlmostEqual(0.5, clr.G()) + self.assertAlmostEqual(0.5, clr.B()) + self.assertAlmostEqual(1.0, clr.A()) + + self.assertTrue(clr.HSV() == Vector3f(6, 0.5, 1)) + + clr.SetFromHSV(60, 0.0, 1.0) + self.assertAlmostEqual(1.0, clr.R()) + self.assertAlmostEqual(1.0, clr.G()) + self.assertAlmostEqual(1.0, clr.B()) + self.assertAlmostEqual(1.0, clr.A()) + + clr.SetFromHSV(120, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.R()) + self.assertAlmostEqual(1.0, clr.G()) + self.assertAlmostEqual(0.5, clr.B()) + self.assertAlmostEqual(1.0, clr.A()) + + clr.SetFromHSV(180, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.R()) + self.assertAlmostEqual(1.0, clr.G()) + self.assertAlmostEqual(1.0, clr.B()) + self.assertAlmostEqual(1.0, clr.A()) + + clr.SetFromHSV(240, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.R()) + self.assertAlmostEqual(0.5, clr.G()) + self.assertAlmostEqual(1.0, clr.B()) + self.assertAlmostEqual(1.0, clr.A()) + + clr.Set(0.1, 0.2, 0.3, 0.4) + clr = clr + 0.2 + self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) + + clr.Set(0.1, 0.2, 0.3, 0.4) + clr += Color(0.2, 0.2, 0.2, 0.2) + self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) + + clr.Set(0.1, 0.2, 0.3, 0.4) + clr = clr - 0.1 + self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) + + clr.Set(0.1, 0.2, 0.3, 0.4) + clr -= Color(0.1, 0.1, 0.1, 0.1) + self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) + + clr.Set(1.0, 1.0, 1.0, 1.0) + clr = clr / 1.6 + self.assertTrue(clr == Color(0.625, 0.625, 0.625, 0.625)) + + clr.Set(1.0, 1.0, 1.0, 1.0) + clr /= Color(1.0, 1.0, 1.0, 1.0) + self.assertTrue(clr == Color(1.0, 1.0, 1.0, 1.0)) + + clr.Set(.1, .2, .3, .4) + clr = clr * .1 + self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) + + clr.Set(.1, .2, .3, .4) + clr *= Color(0.1, 0.1, 0.1, 0.1) + self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) + + clr.SetFromYUV(0.5, 0.2, 0.8) + self.assertAlmostEqual(0.00553, clr.R(), delta=1e-3) + self.assertAlmostEqual(0.0, clr.G()) + self.assertAlmostEqual(0.9064, clr.B(), delta=1e-3) + self.assertAlmostEqual(0.04, clr.A()) + + self.assertTrue(clr.YUV() == Vector3f(0.104985, 0.95227, 0.429305)) + + clr = Color(1.0, 0.0, 0.5, 1.0) + Color(0.1, 0.3, 0.4, 1.0) + self.assertAlmostEqual(0.00431373, clr.R(), delta=1e-4) + self.assertAlmostEqual(0.3, clr.G(), delta=1e-4) + self.assertAlmostEqual(0.9, clr.B(), delta=1e-4) + self.assertAlmostEqual(1.0, clr.A(), delta=1e-4) + + clr = Color(1.0, 0.0, 0.5, 1.0) - Color(0.1, 0.3, 0.4, 1.0) + self.assertAlmostEqual(0.9, clr.R(), delta=1e-4) + self.assertAlmostEqual(0.0, clr.G(), delta=1e-4) + self.assertAlmostEqual(0.1, clr.B(), delta=1e-4) + self.assertAlmostEqual(0.0, clr.A(), delta=1e-4) + + clr = Color(0.5, 0.2, 0.4, 0.6) / 2.0 + self.assertAlmostEqual(0.25, clr.R(), delta=1e-4) + self.assertAlmostEqual(0.1, clr.G(), delta=1e-4) + self.assertAlmostEqual(0.2, clr.B(), delta=1e-4) + self.assertAlmostEqual(0.3, clr.A(), delta=1e-4) + + def test_mul(self): + clr = Color(0.0, 0.01, 0.2, 1.0) + clr2 = Color(1.0, 0.2, 0.2, 0.0) + clr3 = clr * clr2 + + self.assertAlmostEqual(clr3.R(), 0.0) + self.assertAlmostEqual(clr3.G(), 0.002) + self.assertAlmostEqual(clr3.B(), 0.04) + self.assertAlmostEqual(clr3.A(), 0.0) + + def test_division(self): + clr = Color(0.0, 0.01, 0.2, 1.0) + clr2 = clr / 0.2 + self.assertAlmostEqual(clr2.R(), 0.0) + self.assertAlmostEqual(clr2.G(), 0.05) + self.assertAlmostEqual(clr2.B(), 1.0) + self.assertAlmostEqual(clr2.A(), 1.0) + + clr2 = clr / 2.0 + self.assertAlmostEqual(clr2.R(), 0.0) + self.assertAlmostEqual(clr2.G(), 0.005) + self.assertAlmostEqual(clr2.B(), 0.1) + self.assertAlmostEqual(clr2.A(), 0.5) + + clr2.Set(0.0, 0.2, 0.4, 0.5) + clr3 = clr / clr2 + self.assertAlmostEqual(clr3.R(), 0.0) + self.assertAlmostEqual(clr3.G(), 0.05) + self.assertAlmostEqual(clr3.B(), 0.5) + self.assertAlmostEqual(clr3.A(), 1.0) + + clr.Set(0.0, 0.0, 0.0, 0.0) + clr2.Set(0.0, 0.0, 0.0, 0.0) + clr3 = clr / clr2 + self.assertAlmostEqual(clr3.R(), 0.0) + self.assertAlmostEqual(clr3.G(), 0.0) + self.assertAlmostEqual(clr3.B(), 0.0) + self.assertAlmostEqual(clr3.A(), 0.0) + + def test_const_set(self): + clr = Color(0.1, 0.2, 0.3, 0.4) + self.assertAlmostEqual(clr.R(), 0.1) + self.assertAlmostEqual(clr.G(), 0.2) + self.assertAlmostEqual(clr.B(), 0.3) + self.assertAlmostEqual(clr.A(), 0.4) + + clr2 = Color() + clr2.R(0.4) + clr2.G(0.3) + clr2.B(0.2) + clr2.A(0.1) + self.assertAlmostEqual(clr2.R(), 0.4) + self.assertAlmostEqual(clr2.G(), 0.3) + self.assertAlmostEqual(clr2.B(), 0.2) + self.assertAlmostEqual(clr2.A(), 0.1) + + self.assertTrue(clr2 != clr) + + def test_HSV(self): + clr = Color() + hsv = clr.HSV() + self.assertAlmostEqual(hsv.X(), -1.0) + self.assertAlmostEqual(hsv.Y(), 0.0) + self.assertAlmostEqual(hsv.Z(), 0.0) + + clr.Set(0.1, 0.2, 0.3, 1.0) + hsv = clr.HSV() + self.assertAlmostEqual(hsv.X(), 3.5, delta=1e-3) + self.assertAlmostEqual(hsv.Y(), 0.666667, delta=1e-3) + self.assertAlmostEqual(hsv.Z(), 0.3, delta=1e-3) + + clr.Set(0.3, 0.2, 0.1, 1.0) + hsv = clr.HSV() + self.assertAlmostEqual(hsv.X(), 0.5, delta=1e-3) + self.assertAlmostEqual(hsv.Y(), 0.666667, delta=1e-3) + self.assertAlmostEqual(hsv.Z(), 0.3, delta=1e-3) + + clr.SetFromHSV(60, 10, 5) + self.assertAlmostEqual(clr.R(), 0.0196078, delta=1e-3) + self.assertAlmostEqual(clr.G(), 0.0196078, delta=1e-3) + self.assertAlmostEqual(clr.B(), 0.0, delta=1e-3) + self.assertAlmostEqual(clr.A(), 1.0, delta=1e-3) + + clr.SetFromHSV(360.0, 0.5, 0.6) + self.assertAlmostEqual(clr.R(), 0.6, delta=1e-3) + self.assertAlmostEqual(clr.G(), 0.3, delta=1e-3) + self.assertAlmostEqual(clr.B(), 0.3, delta=1e-3) + self.assertAlmostEqual(clr.A(), 1.0, delta=1e-3) + + +if __name__ == '__main__': + unittest.main() From abaf238b43491ab74d6b872e958e7e13a8c60e16 Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Fri, 6 Aug 2021 14:57:35 -0300 Subject: [PATCH 03/11] Adds scripting interface to Spline and a python test. Signed-off-by: LolaSegura --- src/Spline.i | 80 ++++++++++++++++++++++ src/Spline_TEST.py | 166 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 246 insertions(+) create mode 100644 src/Spline.i create mode 100644 src/Spline_TEST.py diff --git a/src/Spline.i b/src/Spline.i new file mode 100644 index 000000000..ccb6c396e --- /dev/null +++ b/src/Spline.i @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2016 Open Source Robotics Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +%module spline +%{ +#include +#include +#include +#include +%} + +namespace ignition +{ + namespace math + { + class ControlPoint; + class SplinePrivate; + + class Spline + { + public: Spline(); + public: ~Spline(); + public: void Tension(double _t); + public: double Tension() const; + public: double ArcLength() const; + public: double ArcLength(const double _t) const; + public: double ArcLength(const unsigned int _index, + const double _t) const; + public: void AddPoint(const Vector3 &_p); + public: void AddPoint(const Vector3 &_p, const Vector3 &_t); + private: void AddPoint(const ControlPoint &_cp, const bool _fixed); + public: Vector3 Point(const unsigned int _index) const; + public: Vector3 Tangent(const unsigned int _index) const; + public: Vector3 MthDerivative(const unsigned int _index, + const unsigned int _mth) const; + public: size_t PointCount() const; + public: void Clear(); + public: bool UpdatePoint(const unsigned int _index, + const Vector3 &_p); + public: bool UpdatePoint(const unsigned int _index, + const Vector3 &_p, + const Vector3 &_t); + private: bool UpdatePoint(const unsigned int _index, + const ControlPoint &_cp, + const bool _fixed); + public: Vector3 Interpolate(const double _t) const; + public: Vector3 Interpolate(const unsigned int _fromIndex, + const double _t) const; + public: Vector3 InterpolateTangent(const double _t) const; + public: Vector3 InterpolateTangent(const unsigned int _fromIndex, + const double _t) const; + public: Vector3 InterpolateMthDerivative(const unsigned int _mth, + const double _1) const; + public: Vector3 InterpolateMthDerivative(const unsigned int _fromIndex, + const unsigned int _mth, + const double _s) const; + public: void AutoCalculate(bool _autoCalc); + public: void RecalcTangents(); + private: void Rebuild(); + private: bool MapToSegment(const double _t, + unsigned int &_index, + double &_fraction) const; + private: SplinePrivate *dataPtr; + }; + } +} \ No newline at end of file diff --git a/src/Spline_TEST.py b/src/Spline_TEST.py new file mode 100644 index 000000000..efdd2c1d6 --- /dev/null +++ b/src/Spline_TEST.py @@ -0,0 +1,166 @@ +# Copyright (C) 2021 Open Source Robotics Foundation + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest +import math +from ignition.math import Vector3d +from ignition.math import Spline + + +class TestSpline(unittest.TestCase): + + def test_spline(self): + s = Spline() + + s.AddPoint(Vector3d(0, 0, 0)) + self.assertEqual(1, s.PointCount()) + + s.Clear() + self.assertEqual(0, s.PointCount()) + + s.AddPoint(Vector3d(0, 0, 0)) + self.assertTrue(s.Point(0) == Vector3d(0, 0, 0)) + s.AddPoint(Vector3d(1, 1, 1)) + self.assertTrue(s.Point(1) == Vector3d(1, 1, 1)) + + # UpdatePoint + self.assertFalse(s.UpdatePoint(2, Vector3d(2, 2, 2))) + + self.assertTrue(s.UpdatePoint(1, Vector3d(2, 2, 2))) + s.AutoCalculate(False) + self.assertTrue(s.UpdatePoint(0, Vector3d(-1, -1, -1))) + s.AutoCalculate(True) + + # Interpolate + self.assertAlmostEqual(s.Interpolate(0.0), Vector3d(-1, -1, -1)) + self.assertAlmostEqual(s.Interpolate(0.5), Vector3d(0.5, 0.5, 0.5)) + self.assertAlmostEqual(s.Interpolate(1.0), Vector3d(2, 2, 2)) + + # Interpolate + s.AddPoint(Vector3d(4, 4, 4)) + self.assertAlmostEqual(s.Interpolate(1, 0.2), + Vector3d(2.496, 2.496, 2.496)) + + def test_fixed_tangent(self): + s = Spline() + + # AddPoint + s.AutoCalculate(False) + s.AddPoint(Vector3d(0, 0, 0)) + s.AddPoint(Vector3d(0, 0.5, 0), Vector3d(0, 1, 0)) + s.AddPoint(Vector3d(0.5, 1, 0), Vector3d(1, 0, 0)) + s.AddPoint(Vector3d(1, 1, 0), Vector3d(1, 0, 0)) + + # UpdatePoint + s.UpdatePoint(0, Vector3d(0, 0, 0), Vector3d(0, 1, 0)) + + s.AutoCalculate(True) + + s.RecalcTangents() + + # Interpolate + self.assertAlmostEqual(s.Interpolate(0, 0.5), Vector3d(0, 0.25, 0)) + self.assertAlmostEqual(s.InterpolateTangent(0, 0.5), + Vector3d(0, 0.25, 0)) + self.assertAlmostEqual(s.Interpolate(1, 0.5), + Vector3d(0.125, 0.875, 0)) + self.assertAlmostEqual(s.Interpolate(2, 0.5), Vector3d(0.75, 1, 0)) + self.assertAlmostEqual(s.InterpolateTangent(2, 0.5), + Vector3d(0.25, 0, 0)) + + def test_arc_length(self): + s = Spline() + self.assertFalse(math.isfinite(s.ArcLength())) + s.AddPoint(Vector3d(1, 1, 1), Vector3d(1, 1, 1)) + self.assertFalse(math.isfinite(s.ArcLength(0))) + s.AddPoint(Vector3d(3, 3, 3), Vector3d(1, 1, 1)) + s.AddPoint(Vector3d(4, 4, 4), Vector3d(1, 1, 1)) + self.assertAlmostEqual(s.ArcLength(0, 1.0), + 3.46410161513775, delta=1e-14) + self.assertAlmostEqual(s.ArcLength(), 5.19615242270663, delta=1e-14) + self.assertAlmostEqual(s.ArcLength(), s.ArcLength(1.0)) + self.assertFalse(math.isfinite(s.ArcLength(-1.0))) + self.assertFalse(math.isfinite(s.ArcLength(4, 0.0))) + + def test_tension(self): + s = Spline() + + s.Tension(0.1) + self.assertAlmostEqual(s.Tension(), 0.1) + + def test_interpolate(self): + s = Spline() + self.assertFalse(s.Interpolate(0, 0.1).IsFinite()) + + s.AddPoint(Vector3d(0, 0, 0)) + self.assertAlmostEqual(s.Interpolate(0, 0.1), Vector3d(0, 0, 0)) + self.assertFalse(s.InterpolateTangent(0.1).IsFinite()) + + s.AddPoint(Vector3d(1, 2, 3)) + self.assertAlmostEqual(s.Interpolate(0, 0.0), s.Point(0)) + self.assertFalse(s.Interpolate(0, -0.1).IsFinite()) + self.assertAlmostEqual(s.InterpolateTangent(0, 0.0), s.Tangent(0)) + + # Fast and slow call variations + self.assertAlmostEqual(s.Interpolate(0, 0.5), Vector3d(0.5, 1.0, 1.5)) + self.assertAlmostEqual(s.Interpolate(0, 1.0), s.Point(1)) + self.assertAlmostEqual(s.InterpolateTangent(0, 0.5), + Vector3d(1.25, 2.5, 3.75)) + self.assertAlmostEqual(s.InterpolateTangent(0, 1.0), s.Tangent(1)) + self.assertAlmostEqual(s.InterpolateMthDerivative(2, 0.5), + Vector3d(0, 0, 0)) + self.assertAlmostEqual(s.InterpolateMthDerivative(2, 1.0), + Vector3d(-3, -6, -9)) + self.assertAlmostEqual(s.InterpolateMthDerivative(3, 0.5), + Vector3d(-6, -12, -18)) + self.assertAlmostEqual(s.InterpolateMthDerivative(3, 1.0), + Vector3d(-6, -12, -18)) + self.assertAlmostEqual(s.InterpolateMthDerivative(4, 0.5), + Vector3d(0, 0, 0)) + self.assertAlmostEqual(s.InterpolateMthDerivative(4, 1.0), + Vector3d(0, 0, 0)) + + def test_point(self): + s = Spline() + self.assertFalse(s.Point(0).IsFinite()) + + def test_tangent(self): + s = Spline() + self.assertFalse(s.Tangent(0).IsFinite()) + + s.AddPoint(Vector3d(0, 0, 0)) + self.assertFalse(s.Tangent(0).IsFinite()) + + s.AddPoint(Vector3d(1, 0, 0)) + self.assertAlmostEqual(s.Tangent(0), Vector3d(0.5, 0, 0)) + + s.AddPoint(Vector3d(1, 1, 0), Vector3d(-1, 1, 0)) + self.assertAlmostEqual(s.Tangent(1), Vector3d(0.5, 0.5, 0)) + self.assertAlmostEqual(s.Tangent(2), Vector3d(-1, 1, 0)) + + def test_recalc_tangents(self): + s = Spline() + + s.AddPoint(Vector3d(0, 0, 0)) + s.AddPoint(Vector3d(.4, .4, .4)) + s.AddPoint(Vector3d(0, 0, 0)) + + s.RecalcTangents() + + self.assertAlmostEqual(s.Interpolate(0, 0.5), Vector3d(0.2, 0.2, 0.2)) + self.assertAlmostEqual(s.Interpolate(1, 0.5), Vector3d(0.2, 0.2, 0.2)) + + +if __name__ == '__main__': + unittest.main() From d96a2a22aab4d69246e6f671ea5faed31fb07a6d Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Thu, 12 Aug 2021 12:23:13 -0300 Subject: [PATCH 04/11] Adds python support for operator[] and operator<< to the Color class. Signed-off-by: LolaSegura --- src/Color.i | 17 +++++++++++++++++ src/Color_TEST.py | 12 ++++++++++++ 2 files changed, 29 insertions(+) diff --git a/src/Color.i b/src/Color.i index 946b6938f..f044e2430 100644 --- a/src/Color.i +++ b/src/Color.i @@ -23,6 +23,8 @@ #include %} +%include "std_string.i" + namespace ignition { namespace math @@ -90,5 +92,20 @@ namespace ignition private: float b = 0; private: float a = 1; }; + + %extend Color{ + float __getitem__(const unsigned int i) + { + return (*$self)[i]; + } + } + + %extend Color { + std::string __str__() const { + std::ostringstream out; + out << *$self; + return out.str(); + } + } } } diff --git a/src/Color_TEST.py b/src/Color_TEST.py index 15a241a26..79b6c7d9d 100644 --- a/src/Color_TEST.py +++ b/src/Color_TEST.py @@ -13,6 +13,7 @@ # limitations under the License. import unittest +import math from ignition.math import Color from ignition.math import Vector3f @@ -170,6 +171,13 @@ def test_color(self): self.assertAlmostEqual(1.0, clr.B()) self.assertAlmostEqual(1.0, clr.A()) + clr.SetFromHSV(300, 0.5, 1.0) + self.assertAlmostEqual(1.0, clr[0]) + self.assertAlmostEqual(0.5, clr[1]) + self.assertAlmostEqual(1.0, clr[2]) + self.assertAlmostEqual(1.0, clr[3]) + self.assertTrue(math.isnan(clr[4])) + clr.Set(0.1, 0.2, 0.3, 0.4) clr = clr + 0.2 self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) @@ -286,6 +294,10 @@ def test_const_set(self): self.assertTrue(clr2 != clr) + def test_stream_out(self): + c = Color(0.1, 0.2, 0.3, 0.5) + self.assertAlmostEqual(str(c), "0.1 0.2 0.3 0.5") + def test_HSV(self): clr = Color() hsv = clr.HSV() From 7dfb6ec6ee1bbc9790a54a613fef2ff70099c649 Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Wed, 18 Aug 2021 15:14:12 -0300 Subject: [PATCH 05/11] Adds %rename tag to interface files in order to match pep-8 naiming style. Signed-off-by: LolaSegura --- src/Color.i | 2 + src/Color_TEST.py | 406 ++++++++++++++++++++-------------------- src/RollingMean.i | 2 +- src/RollingMean_TEST.py | 56 +++--- src/Spline.i | 6 +- src/Spline_TEST.py | 164 ++++++++-------- 6 files changed, 317 insertions(+), 319 deletions(-) diff --git a/src/Color.i b/src/Color.i index f044e2430..4af1792d0 100644 --- a/src/Color.i +++ b/src/Color.i @@ -31,6 +31,8 @@ namespace ignition { class Color { + %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; + %rename("%(uppercase)s", %$isstatic, %$isvariable) ""; public: static const Color White; public: static const Color Black; public: static const Color Red; diff --git a/src/Color_TEST.py b/src/Color_TEST.py index 79b6c7d9d..c8018614d 100644 --- a/src/Color_TEST.py +++ b/src/Color_TEST.py @@ -21,276 +21,276 @@ class TestColor(unittest.TestCase): def test_const_color(self): - self.assertAlmostEqual(1.0, Color.White.R()) - self.assertAlmostEqual(1.0, Color.White.G()) - self.assertAlmostEqual(1.0, Color.White.B()) - self.assertAlmostEqual(1.0, Color.White.A()) - - self.assertAlmostEqual(0.0, Color.Black.R()) - self.assertAlmostEqual(0.0, Color.Black.G()) - self.assertAlmostEqual(0.0, Color.Black.B()) - self.assertAlmostEqual(1.0, Color.Black.A()) - - self.assertAlmostEqual(1.0, Color.Red.R()) - self.assertAlmostEqual(0.0, Color.Red.G()) - self.assertAlmostEqual(0.0, Color.Red.B()) - self.assertAlmostEqual(1.0, Color.Red.A()) - - self.assertAlmostEqual(0.0, Color.Green.R()) - self.assertAlmostEqual(1.0, Color.Green.G()) - self.assertAlmostEqual(0.0, Color.Green.B()) - self.assertAlmostEqual(1.0, Color.Green.A()) - - self.assertAlmostEqual(0.0, Color.Blue.R()) - self.assertAlmostEqual(0.0, Color.Blue.G()) - self.assertAlmostEqual(1.0, Color.Blue.B()) - self.assertAlmostEqual(1.0, Color.Blue.A()) - - self.assertAlmostEqual(1.0, Color.Yellow.R()) - self.assertAlmostEqual(1.0, Color.Yellow.G()) - self.assertAlmostEqual(0.0, Color.Yellow.B()) - self.assertAlmostEqual(1.0, Color.Yellow.A()) - - self.assertAlmostEqual(1.0, Color.Magenta.R()) - self.assertAlmostEqual(0.0, Color.Magenta.G()) - self.assertAlmostEqual(1.0, Color.Magenta.B()) - self.assertAlmostEqual(1.0, Color.Magenta.A()) - - self.assertAlmostEqual(0.0, Color.Cyan.R()) - self.assertAlmostEqual(1.0, Color.Cyan.G()) - self.assertAlmostEqual(1.0, Color.Cyan.B()) - self.assertAlmostEqual(1.0, Color.Cyan.A()) + self.assertAlmostEqual(1.0, Color.WHITE.r()) + self.assertAlmostEqual(1.0, Color.WHITE.g()) + self.assertAlmostEqual(1.0, Color.WHITE.b()) + self.assertAlmostEqual(1.0, Color.WHITE.a()) + + self.assertAlmostEqual(0.0, Color.BLACK.r()) + self.assertAlmostEqual(0.0, Color.BLACK.g()) + self.assertAlmostEqual(0.0, Color.BLACK.b()) + self.assertAlmostEqual(1.0, Color.BLACK.a()) + + self.assertAlmostEqual(1.0, Color.RED.r()) + self.assertAlmostEqual(0.0, Color.RED.g()) + self.assertAlmostEqual(0.0, Color.RED.b()) + self.assertAlmostEqual(1.0, Color.RED.a()) + + self.assertAlmostEqual(0.0, Color.GREEN.r()) + self.assertAlmostEqual(1.0, Color.GREEN.g()) + self.assertAlmostEqual(0.0, Color.GREEN.b()) + self.assertAlmostEqual(1.0, Color.GREEN.a()) + + self.assertAlmostEqual(0.0, Color.BLUE.r()) + self.assertAlmostEqual(0.0, Color.BLUE.g()) + self.assertAlmostEqual(1.0, Color.BLUE.b()) + self.assertAlmostEqual(1.0, Color.BLUE.a()) + + self.assertAlmostEqual(1.0, Color.YELLOW.r()) + self.assertAlmostEqual(1.0, Color.YELLOW.g()) + self.assertAlmostEqual(0.0, Color.YELLOW.b()) + self.assertAlmostEqual(1.0, Color.YELLOW.a()) + + self.assertAlmostEqual(1.0, Color.MAGENTA.r()) + self.assertAlmostEqual(0.0, Color.MAGENTA.g()) + self.assertAlmostEqual(1.0, Color.MAGENTA.b()) + self.assertAlmostEqual(1.0, Color.MAGENTA.a()) + + self.assertAlmostEqual(0.0, Color.CYAN.r()) + self.assertAlmostEqual(1.0, Color.CYAN.g()) + self.assertAlmostEqual(1.0, Color.CYAN.b()) + self.assertAlmostEqual(1.0, Color.CYAN.a()) def test_color(self): clr0 = Color() - self.assertAlmostEqual(0.0, clr0.R()) - self.assertAlmostEqual(0.0, clr0.G()) - self.assertAlmostEqual(0.0, clr0.B()) - self.assertAlmostEqual(1.0, clr0.A()) - self.assertEqual(clr0.AsRGBA(), 255) - clr0.A(0.0) - self.assertEqual(clr0.AsRGBA(), 0) + self.assertAlmostEqual(0.0, clr0.r()) + self.assertAlmostEqual(0.0, clr0.g()) + self.assertAlmostEqual(0.0, clr0.b()) + self.assertAlmostEqual(1.0, clr0.a()) + self.assertEqual(clr0.as_rgba(), 255) + clr0.a(0.0) + self.assertEqual(clr0.as_rgba(), 0) clr = Color(.1, .2, .3, 1.0) - self.assertAlmostEqual(0.1, clr.R()) - self.assertAlmostEqual(0.2, clr.G()) - self.assertAlmostEqual(0.3, clr.B()) - self.assertAlmostEqual(1.0, clr.A()) - - clr.Set(1, 0, 0, 0) - self.assertAlmostEqual(clr.AsRGBA(), 255 << 24) - self.assertAlmostEqual(clr.AsBGRA(), 255 << 8) - self.assertAlmostEqual(clr.AsARGB(), 255 << 16) - self.assertAlmostEqual(clr.AsABGR(), 255) - clr0.SetFromRGBA(255 << 24) + self.assertAlmostEqual(0.1, clr.r()) + self.assertAlmostEqual(0.2, clr.g()) + self.assertAlmostEqual(0.3, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set(1, 0, 0, 0) + self.assertAlmostEqual(clr.as_rgba(), 255 << 24) + self.assertAlmostEqual(clr.as_bgra(), 255 << 8) + self.assertAlmostEqual(clr.as_argb(), 255 << 16) + self.assertAlmostEqual(clr.as_abgr(), 255) + clr0.set_from_rgba(255 << 24) self.assertEqual(clr0, clr) - clr0.SetFromBGRA(255 << 8) + clr0.set_from_bgra(255 << 8) self.assertEqual(clr0, clr) - clr0.SetFromARGB(255 << 16) + clr0.set_from_argb(255 << 16) self.assertEqual(clr0, clr) - clr0.SetFromABGR(255) + clr0.set_from_abgr(255) self.assertEqual(clr0, clr) - clr.Set(0, 1, 0, 0) - self.assertAlmostEqual(clr.AsRGBA(), 255 << 16) - self.assertAlmostEqual(clr.AsBGRA(), 255 << 16) - self.assertAlmostEqual(clr.AsARGB(), 255 << 8) - self.assertAlmostEqual(clr.AsABGR(), 255 << 8) - clr0.SetFromRGBA(255 << 16) + clr.set(0, 1, 0, 0) + self.assertAlmostEqual(clr.as_rgba(), 255 << 16) + self.assertAlmostEqual(clr.as_bgra(), 255 << 16) + self.assertAlmostEqual(clr.as_argb(), 255 << 8) + self.assertAlmostEqual(clr.as_abgr(), 255 << 8) + clr0.set_from_rgba(255 << 16) self.assertEqual(clr0, clr) - clr0.SetFromBGRA(255 << 16) + clr0.set_from_bgra(255 << 16) self.assertEqual(clr0, clr) - clr0.SetFromARGB(255 << 8) + clr0.set_from_argb(255 << 8) self.assertEqual(clr0, clr) - clr0.SetFromABGR(255 << 8) + clr0.set_from_abgr(255 << 8) self.assertEqual(clr0, clr) - clr.Set(0, 0, 1, 0) - self.assertAlmostEqual(clr.AsRGBA(), 255 << 8) - self.assertAlmostEqual(clr.AsBGRA(), 255 << 24) - self.assertAlmostEqual(clr.AsARGB(), 255) - self.assertAlmostEqual(clr.AsABGR(), 255 << 16) - clr0.SetFromRGBA(255 << 8) + clr.set(0, 0, 1, 0) + self.assertAlmostEqual(clr.as_rgba(), 255 << 8) + self.assertAlmostEqual(clr.as_bgra(), 255 << 24) + self.assertAlmostEqual(clr.as_argb(), 255) + self.assertAlmostEqual(clr.as_abgr(), 255 << 16) + clr0.set_from_rgba(255 << 8) self.assertEqual(clr0, clr) - clr0.SetFromBGRA(255 << 24) + clr0.set_from_bgra(255 << 24) self.assertEqual(clr0, clr) - clr0.SetFromARGB(255) + clr0.set_from_argb(255) self.assertEqual(clr0, clr) - clr0.SetFromABGR(255 << 16) + clr0.set_from_abgr(255 << 16) self.assertEqual(clr0, clr) - clr.Set(0, 0, 0, 1) - self.assertAlmostEqual(clr.AsRGBA(), 255) - self.assertAlmostEqual(clr.AsBGRA(), 255) - self.assertAlmostEqual(clr.AsARGB(), 255 << 24) - self.assertAlmostEqual(clr.AsABGR(), 255 << 24) - clr0.SetFromRGBA(255) + clr.set(0, 0, 0, 1) + self.assertAlmostEqual(clr.as_rgba(), 255) + self.assertAlmostEqual(clr.as_bgra(), 255) + self.assertAlmostEqual(clr.as_argb(), 255 << 24) + self.assertAlmostEqual(clr.as_abgr(), 255 << 24) + clr0.set_from_rgba(255) self.assertEqual(clr0, clr) - clr0.SetFromBGRA(255) + clr0.set_from_bgra(255) self.assertEqual(clr0, clr) - clr0.SetFromARGB(255 << 24) + clr0.set_from_argb(255 << 24) self.assertEqual(clr0, clr) - clr0.SetFromABGR(255 << 24) + clr0.set_from_abgr(255 << 24) self.assertEqual(clr0, clr) - clr.Reset() - self.assertAlmostEqual(0.0, clr.R()) - self.assertAlmostEqual(0.0, clr.G()) - self.assertAlmostEqual(0.0, clr.B()) - self.assertAlmostEqual(1.0, clr.A()) - - clr.SetFromHSV(0, 0.5, 1.0) - self.assertAlmostEqual(1.0, clr.R()) - self.assertAlmostEqual(0.5, clr.G()) - self.assertAlmostEqual(0.5, clr.B()) - self.assertAlmostEqual(1.0, clr.A()) - - self.assertTrue(clr.HSV() == Vector3f(6, 0.5, 1)) - - clr.SetFromHSV(60, 0.0, 1.0) - self.assertAlmostEqual(1.0, clr.R()) - self.assertAlmostEqual(1.0, clr.G()) - self.assertAlmostEqual(1.0, clr.B()) - self.assertAlmostEqual(1.0, clr.A()) - - clr.SetFromHSV(120, 0.5, 1.0) - self.assertAlmostEqual(0.5, clr.R()) - self.assertAlmostEqual(1.0, clr.G()) - self.assertAlmostEqual(0.5, clr.B()) - self.assertAlmostEqual(1.0, clr.A()) - - clr.SetFromHSV(180, 0.5, 1.0) - self.assertAlmostEqual(0.5, clr.R()) - self.assertAlmostEqual(1.0, clr.G()) - self.assertAlmostEqual(1.0, clr.B()) - self.assertAlmostEqual(1.0, clr.A()) - - clr.SetFromHSV(240, 0.5, 1.0) - self.assertAlmostEqual(0.5, clr.R()) - self.assertAlmostEqual(0.5, clr.G()) - self.assertAlmostEqual(1.0, clr.B()) - self.assertAlmostEqual(1.0, clr.A()) - - clr.SetFromHSV(300, 0.5, 1.0) + clr.reset() + self.assertAlmostEqual(0.0, clr.r()) + self.assertAlmostEqual(0.0, clr.g()) + self.assertAlmostEqual(0.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(0, 0.5, 1.0) + self.assertAlmostEqual(1.0, clr.r()) + self.assertAlmostEqual(0.5, clr.g()) + self.assertAlmostEqual(0.5, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + self.assertTrue(clr.hsv() == Vector3f(6, 0.5, 1)) + + clr.set_from_hsv(60, 0.0, 1.0) + self.assertAlmostEqual(1.0, clr.r()) + self.assertAlmostEqual(1.0, clr.g()) + self.assertAlmostEqual(1.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(120, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.r()) + self.assertAlmostEqual(1.0, clr.g()) + self.assertAlmostEqual(0.5, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(180, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.r()) + self.assertAlmostEqual(1.0, clr.g()) + self.assertAlmostEqual(1.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(240, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.r()) + self.assertAlmostEqual(0.5, clr.g()) + self.assertAlmostEqual(1.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(300, 0.5, 1.0) self.assertAlmostEqual(1.0, clr[0]) self.assertAlmostEqual(0.5, clr[1]) self.assertAlmostEqual(1.0, clr[2]) self.assertAlmostEqual(1.0, clr[3]) self.assertTrue(math.isnan(clr[4])) - clr.Set(0.1, 0.2, 0.3, 0.4) + clr.set(0.1, 0.2, 0.3, 0.4) clr = clr + 0.2 self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) - clr.Set(0.1, 0.2, 0.3, 0.4) + clr.set(0.1, 0.2, 0.3, 0.4) clr += Color(0.2, 0.2, 0.2, 0.2) self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) - clr.Set(0.1, 0.2, 0.3, 0.4) + clr.set(0.1, 0.2, 0.3, 0.4) clr = clr - 0.1 self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) - clr.Set(0.1, 0.2, 0.3, 0.4) + clr.set(0.1, 0.2, 0.3, 0.4) clr -= Color(0.1, 0.1, 0.1, 0.1) self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) - clr.Set(1.0, 1.0, 1.0, 1.0) + clr.set(1.0, 1.0, 1.0, 1.0) clr = clr / 1.6 self.assertTrue(clr == Color(0.625, 0.625, 0.625, 0.625)) - clr.Set(1.0, 1.0, 1.0, 1.0) + clr.set(1.0, 1.0, 1.0, 1.0) clr /= Color(1.0, 1.0, 1.0, 1.0) self.assertTrue(clr == Color(1.0, 1.0, 1.0, 1.0)) - clr.Set(.1, .2, .3, .4) + clr.set(.1, .2, .3, .4) clr = clr * .1 self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) - clr.Set(.1, .2, .3, .4) + clr.set(.1, .2, .3, .4) clr *= Color(0.1, 0.1, 0.1, 0.1) self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) - clr.SetFromYUV(0.5, 0.2, 0.8) - self.assertAlmostEqual(0.00553, clr.R(), delta=1e-3) - self.assertAlmostEqual(0.0, clr.G()) - self.assertAlmostEqual(0.9064, clr.B(), delta=1e-3) - self.assertAlmostEqual(0.04, clr.A()) + clr.set_from_yuv(0.5, 0.2, 0.8) + self.assertAlmostEqual(0.00553, clr.r(), delta=1e-3) + self.assertAlmostEqual(0.0, clr.g()) + self.assertAlmostEqual(0.9064, clr.b(), delta=1e-3) + self.assertAlmostEqual(0.04, clr.a()) - self.assertTrue(clr.YUV() == Vector3f(0.104985, 0.95227, 0.429305)) + self.assertTrue(clr.yuv() == Vector3f(0.104985, 0.95227, 0.429305)) clr = Color(1.0, 0.0, 0.5, 1.0) + Color(0.1, 0.3, 0.4, 1.0) - self.assertAlmostEqual(0.00431373, clr.R(), delta=1e-4) - self.assertAlmostEqual(0.3, clr.G(), delta=1e-4) - self.assertAlmostEqual(0.9, clr.B(), delta=1e-4) - self.assertAlmostEqual(1.0, clr.A(), delta=1e-4) + self.assertAlmostEqual(0.00431373, clr.r(), delta=1e-4) + self.assertAlmostEqual(0.3, clr.g(), delta=1e-4) + self.assertAlmostEqual(0.9, clr.b(), delta=1e-4) + self.assertAlmostEqual(1.0, clr.a(), delta=1e-4) clr = Color(1.0, 0.0, 0.5, 1.0) - Color(0.1, 0.3, 0.4, 1.0) - self.assertAlmostEqual(0.9, clr.R(), delta=1e-4) - self.assertAlmostEqual(0.0, clr.G(), delta=1e-4) - self.assertAlmostEqual(0.1, clr.B(), delta=1e-4) - self.assertAlmostEqual(0.0, clr.A(), delta=1e-4) + self.assertAlmostEqual(0.9, clr.r(), delta=1e-4) + self.assertAlmostEqual(0.0, clr.g(), delta=1e-4) + self.assertAlmostEqual(0.1, clr.b(), delta=1e-4) + self.assertAlmostEqual(0.0, clr.a(), delta=1e-4) clr = Color(0.5, 0.2, 0.4, 0.6) / 2.0 - self.assertAlmostEqual(0.25, clr.R(), delta=1e-4) - self.assertAlmostEqual(0.1, clr.G(), delta=1e-4) - self.assertAlmostEqual(0.2, clr.B(), delta=1e-4) - self.assertAlmostEqual(0.3, clr.A(), delta=1e-4) + self.assertAlmostEqual(0.25, clr.r(), delta=1e-4) + self.assertAlmostEqual(0.1, clr.g(), delta=1e-4) + self.assertAlmostEqual(0.2, clr.b(), delta=1e-4) + self.assertAlmostEqual(0.3, clr.a(), delta=1e-4) def test_mul(self): clr = Color(0.0, 0.01, 0.2, 1.0) clr2 = Color(1.0, 0.2, 0.2, 0.0) clr3 = clr * clr2 - self.assertAlmostEqual(clr3.R(), 0.0) - self.assertAlmostEqual(clr3.G(), 0.002) - self.assertAlmostEqual(clr3.B(), 0.04) - self.assertAlmostEqual(clr3.A(), 0.0) + self.assertAlmostEqual(clr3.r(), 0.0) + self.assertAlmostEqual(clr3.g(), 0.002) + self.assertAlmostEqual(clr3.b(), 0.04) + self.assertAlmostEqual(clr3.a(), 0.0) def test_division(self): clr = Color(0.0, 0.01, 0.2, 1.0) clr2 = clr / 0.2 - self.assertAlmostEqual(clr2.R(), 0.0) - self.assertAlmostEqual(clr2.G(), 0.05) - self.assertAlmostEqual(clr2.B(), 1.0) - self.assertAlmostEqual(clr2.A(), 1.0) + self.assertAlmostEqual(clr2.r(), 0.0) + self.assertAlmostEqual(clr2.g(), 0.05) + self.assertAlmostEqual(clr2.b(), 1.0) + self.assertAlmostEqual(clr2.a(), 1.0) clr2 = clr / 2.0 - self.assertAlmostEqual(clr2.R(), 0.0) - self.assertAlmostEqual(clr2.G(), 0.005) - self.assertAlmostEqual(clr2.B(), 0.1) - self.assertAlmostEqual(clr2.A(), 0.5) + self.assertAlmostEqual(clr2.r(), 0.0) + self.assertAlmostEqual(clr2.g(), 0.005) + self.assertAlmostEqual(clr2.b(), 0.1) + self.assertAlmostEqual(clr2.a(), 0.5) - clr2.Set(0.0, 0.2, 0.4, 0.5) + clr2.set(0.0, 0.2, 0.4, 0.5) clr3 = clr / clr2 - self.assertAlmostEqual(clr3.R(), 0.0) - self.assertAlmostEqual(clr3.G(), 0.05) - self.assertAlmostEqual(clr3.B(), 0.5) - self.assertAlmostEqual(clr3.A(), 1.0) + self.assertAlmostEqual(clr3.r(), 0.0) + self.assertAlmostEqual(clr3.g(), 0.05) + self.assertAlmostEqual(clr3.b(), 0.5) + self.assertAlmostEqual(clr3.a(), 1.0) - clr.Set(0.0, 0.0, 0.0, 0.0) - clr2.Set(0.0, 0.0, 0.0, 0.0) + clr.set(0.0, 0.0, 0.0, 0.0) + clr2.set(0.0, 0.0, 0.0, 0.0) clr3 = clr / clr2 - self.assertAlmostEqual(clr3.R(), 0.0) - self.assertAlmostEqual(clr3.G(), 0.0) - self.assertAlmostEqual(clr3.B(), 0.0) - self.assertAlmostEqual(clr3.A(), 0.0) + self.assertAlmostEqual(clr3.r(), 0.0) + self.assertAlmostEqual(clr3.g(), 0.0) + self.assertAlmostEqual(clr3.b(), 0.0) + self.assertAlmostEqual(clr3.a(), 0.0) def test_const_set(self): clr = Color(0.1, 0.2, 0.3, 0.4) - self.assertAlmostEqual(clr.R(), 0.1) - self.assertAlmostEqual(clr.G(), 0.2) - self.assertAlmostEqual(clr.B(), 0.3) - self.assertAlmostEqual(clr.A(), 0.4) + self.assertAlmostEqual(clr.r(), 0.1) + self.assertAlmostEqual(clr.g(), 0.2) + self.assertAlmostEqual(clr.b(), 0.3) + self.assertAlmostEqual(clr.a(), 0.4) clr2 = Color() - clr2.R(0.4) - clr2.G(0.3) - clr2.B(0.2) - clr2.A(0.1) - self.assertAlmostEqual(clr2.R(), 0.4) - self.assertAlmostEqual(clr2.G(), 0.3) - self.assertAlmostEqual(clr2.B(), 0.2) - self.assertAlmostEqual(clr2.A(), 0.1) + clr2.r(0.4) + clr2.g(0.3) + clr2.b(0.2) + clr2.a(0.1) + self.assertAlmostEqual(clr2.r(), 0.4) + self.assertAlmostEqual(clr2.g(), 0.3) + self.assertAlmostEqual(clr2.b(), 0.2) + self.assertAlmostEqual(clr2.a(), 0.1) self.assertTrue(clr2 != clr) @@ -300,34 +300,34 @@ def test_stream_out(self): def test_HSV(self): clr = Color() - hsv = clr.HSV() + hsv = clr.hsv() self.assertAlmostEqual(hsv.X(), -1.0) self.assertAlmostEqual(hsv.Y(), 0.0) self.assertAlmostEqual(hsv.Z(), 0.0) - clr.Set(0.1, 0.2, 0.3, 1.0) - hsv = clr.HSV() + clr.set(0.1, 0.2, 0.3, 1.0) + hsv = clr.hsv() self.assertAlmostEqual(hsv.X(), 3.5, delta=1e-3) self.assertAlmostEqual(hsv.Y(), 0.666667, delta=1e-3) self.assertAlmostEqual(hsv.Z(), 0.3, delta=1e-3) - clr.Set(0.3, 0.2, 0.1, 1.0) - hsv = clr.HSV() + clr.set(0.3, 0.2, 0.1, 1.0) + hsv = clr.hsv() self.assertAlmostEqual(hsv.X(), 0.5, delta=1e-3) self.assertAlmostEqual(hsv.Y(), 0.666667, delta=1e-3) self.assertAlmostEqual(hsv.Z(), 0.3, delta=1e-3) - clr.SetFromHSV(60, 10, 5) - self.assertAlmostEqual(clr.R(), 0.0196078, delta=1e-3) - self.assertAlmostEqual(clr.G(), 0.0196078, delta=1e-3) - self.assertAlmostEqual(clr.B(), 0.0, delta=1e-3) - self.assertAlmostEqual(clr.A(), 1.0, delta=1e-3) - - clr.SetFromHSV(360.0, 0.5, 0.6) - self.assertAlmostEqual(clr.R(), 0.6, delta=1e-3) - self.assertAlmostEqual(clr.G(), 0.3, delta=1e-3) - self.assertAlmostEqual(clr.B(), 0.3, delta=1e-3) - self.assertAlmostEqual(clr.A(), 1.0, delta=1e-3) + clr.set_from_hsv(60, 10, 5) + self.assertAlmostEqual(clr.r(), 0.0196078, delta=1e-3) + self.assertAlmostEqual(clr.g(), 0.0196078, delta=1e-3) + self.assertAlmostEqual(clr.b(), 0.0, delta=1e-3) + self.assertAlmostEqual(clr.a(), 1.0, delta=1e-3) + + clr.set_from_hsv(360.0, 0.5, 0.6) + self.assertAlmostEqual(clr.r(), 0.6, delta=1e-3) + self.assertAlmostEqual(clr.g(), 0.3, delta=1e-3) + self.assertAlmostEqual(clr.b(), 0.3, delta=1e-3) + self.assertAlmostEqual(clr.a(), 1.0, delta=1e-3) if __name__ == '__main__': diff --git a/src/RollingMean.i b/src/RollingMean.i index f3f419676..d024b8b6f 100644 --- a/src/RollingMean.i +++ b/src/RollingMean.i @@ -26,7 +26,7 @@ namespace ignition { class RollingMean { - + %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; public: explicit RollingMean(size_t _windowSize = 10); public: ~RollingMean(); public: double Mean() const; diff --git a/src/RollingMean_TEST.py b/src/RollingMean_TEST.py index 284c0755d..76a7795c3 100644 --- a/src/RollingMean_TEST.py +++ b/src/RollingMean_TEST.py @@ -21,34 +21,34 @@ class TestRollingMean(unittest.TestCase): def test_rolling_mean(self): mean = RollingMean() - self.assertEqual(0, mean.Count()) - self.assertEqual(10, mean.WindowSize()) - - mean.SetWindowSize(4) - self.assertEqual(4, mean.WindowSize()) - mean.SetWindowSize(0) - self.assertEqual(4, mean.WindowSize()) - - mean.Push(1.0) - self.assertAlmostEqual(1.0, mean.Mean()) - mean.Push(2.0) - self.assertAlmostEqual(1.5, mean.Mean()) - mean.Push(3.0) - self.assertAlmostEqual(2.0, mean.Mean()) - mean.Push(10.0) - self.assertAlmostEqual(4.0, mean.Mean()) - mean.Push(20.0) - self.assertAlmostEqual(8.75, mean.Mean()) - - mean.Clear() - self.assertTrue(math.isnan(mean.Mean())) - - mean.Push(100.0) - mean.Push(200.0) - mean.Push(300.0) - self.assertEqual(3, mean.Count()) - mean.SetWindowSize(2) - self.assertEqual(0, mean.Count()) + self.assertEqual(0, mean.count()) + self.assertEqual(10, mean.window_size()) + + mean.set_window_size(4) + self.assertEqual(4, mean.window_size()) + mean.set_window_size(0) + self.assertEqual(4, mean.window_size()) + + mean.push(1.0) + self.assertAlmostEqual(1.0, mean.mean()) + mean.push(2.0) + self.assertAlmostEqual(1.5, mean.mean()) + mean.push(3.0) + self.assertAlmostEqual(2.0, mean.mean()) + mean.push(10.0) + self.assertAlmostEqual(4.0, mean.mean()) + mean.push(20.0) + self.assertAlmostEqual(8.75, mean.mean()) + + mean.clear() + self.assertTrue(math.isnan(mean.mean())) + + mean.push(100.0) + mean.push(200.0) + mean.push(300.0) + self.assertEqual(3, mean.count()) + mean.set_window_size(2) + self.assertEqual(0, mean.count()) if __name__ == '__main__': diff --git a/src/Spline.i b/src/Spline.i index ccb6c396e..1b6bfb0cf 100644 --- a/src/Spline.i +++ b/src/Spline.i @@ -32,6 +32,7 @@ namespace ignition class Spline { + %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; public: Spline(); public: ~Spline(); public: void Tension(double _t); @@ -70,11 +71,6 @@ namespace ignition const double _s) const; public: void AutoCalculate(bool _autoCalc); public: void RecalcTangents(); - private: void Rebuild(); - private: bool MapToSegment(const double _t, - unsigned int &_index, - double &_fraction) const; - private: SplinePrivate *dataPtr; }; } } \ No newline at end of file diff --git a/src/Spline_TEST.py b/src/Spline_TEST.py index efdd2c1d6..9f60db8fb 100644 --- a/src/Spline_TEST.py +++ b/src/Spline_TEST.py @@ -23,143 +23,143 @@ class TestSpline(unittest.TestCase): def test_spline(self): s = Spline() - s.AddPoint(Vector3d(0, 0, 0)) - self.assertEqual(1, s.PointCount()) + s.add_point(Vector3d(0, 0, 0)) + self.assertEqual(1, s.point_count()) - s.Clear() - self.assertEqual(0, s.PointCount()) + s.clear() + self.assertEqual(0, s.point_count()) - s.AddPoint(Vector3d(0, 0, 0)) - self.assertTrue(s.Point(0) == Vector3d(0, 0, 0)) - s.AddPoint(Vector3d(1, 1, 1)) - self.assertTrue(s.Point(1) == Vector3d(1, 1, 1)) + s.add_point(Vector3d(0, 0, 0)) + self.assertTrue(s.point(0) == Vector3d(0, 0, 0)) + s.add_point(Vector3d(1, 1, 1)) + self.assertTrue(s.point(1) == Vector3d(1, 1, 1)) - # UpdatePoint - self.assertFalse(s.UpdatePoint(2, Vector3d(2, 2, 2))) + # update_point + self.assertFalse(s.update_point(2, Vector3d(2, 2, 2))) - self.assertTrue(s.UpdatePoint(1, Vector3d(2, 2, 2))) - s.AutoCalculate(False) - self.assertTrue(s.UpdatePoint(0, Vector3d(-1, -1, -1))) - s.AutoCalculate(True) + self.assertTrue(s.update_point(1, Vector3d(2, 2, 2))) + s.auto_calculate(False) + self.assertTrue(s.update_point(0, Vector3d(-1, -1, -1))) + s.auto_calculate(True) - # Interpolate - self.assertAlmostEqual(s.Interpolate(0.0), Vector3d(-1, -1, -1)) - self.assertAlmostEqual(s.Interpolate(0.5), Vector3d(0.5, 0.5, 0.5)) - self.assertAlmostEqual(s.Interpolate(1.0), Vector3d(2, 2, 2)) + # interpolate + self.assertAlmostEqual(s.interpolate(0.0), Vector3d(-1, -1, -1)) + self.assertAlmostEqual(s.interpolate(0.5), Vector3d(0.5, 0.5, 0.5)) + self.assertAlmostEqual(s.interpolate(1.0), Vector3d(2, 2, 2)) - # Interpolate - s.AddPoint(Vector3d(4, 4, 4)) - self.assertAlmostEqual(s.Interpolate(1, 0.2), + # interpolate + s.add_point(Vector3d(4, 4, 4)) + self.assertAlmostEqual(s.interpolate(1, 0.2), Vector3d(2.496, 2.496, 2.496)) def test_fixed_tangent(self): s = Spline() - # AddPoint - s.AutoCalculate(False) - s.AddPoint(Vector3d(0, 0, 0)) - s.AddPoint(Vector3d(0, 0.5, 0), Vector3d(0, 1, 0)) - s.AddPoint(Vector3d(0.5, 1, 0), Vector3d(1, 0, 0)) - s.AddPoint(Vector3d(1, 1, 0), Vector3d(1, 0, 0)) + # add_point + s.auto_calculate(False) + s.add_point(Vector3d(0, 0, 0)) + s.add_point(Vector3d(0, 0.5, 0), Vector3d(0, 1, 0)) + s.add_point(Vector3d(0.5, 1, 0), Vector3d(1, 0, 0)) + s.add_point(Vector3d(1, 1, 0), Vector3d(1, 0, 0)) - # UpdatePoint - s.UpdatePoint(0, Vector3d(0, 0, 0), Vector3d(0, 1, 0)) + # update_point + s.update_point(0, Vector3d(0, 0, 0), Vector3d(0, 1, 0)) - s.AutoCalculate(True) + s.auto_calculate(True) - s.RecalcTangents() + s.recalc_tangents() - # Interpolate - self.assertAlmostEqual(s.Interpolate(0, 0.5), Vector3d(0, 0.25, 0)) - self.assertAlmostEqual(s.InterpolateTangent(0, 0.5), + # interpolate + self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0, 0.25, 0)) + self.assertAlmostEqual(s.interpolate_tangent(0, 0.5), Vector3d(0, 0.25, 0)) - self.assertAlmostEqual(s.Interpolate(1, 0.5), + self.assertAlmostEqual(s.interpolate(1, 0.5), Vector3d(0.125, 0.875, 0)) - self.assertAlmostEqual(s.Interpolate(2, 0.5), Vector3d(0.75, 1, 0)) - self.assertAlmostEqual(s.InterpolateTangent(2, 0.5), + self.assertAlmostEqual(s.interpolate(2, 0.5), Vector3d(0.75, 1, 0)) + self.assertAlmostEqual(s.interpolate_tangent(2, 0.5), Vector3d(0.25, 0, 0)) def test_arc_length(self): s = Spline() - self.assertFalse(math.isfinite(s.ArcLength())) - s.AddPoint(Vector3d(1, 1, 1), Vector3d(1, 1, 1)) - self.assertFalse(math.isfinite(s.ArcLength(0))) - s.AddPoint(Vector3d(3, 3, 3), Vector3d(1, 1, 1)) - s.AddPoint(Vector3d(4, 4, 4), Vector3d(1, 1, 1)) - self.assertAlmostEqual(s.ArcLength(0, 1.0), + self.assertFalse(math.isfinite(s.arc_length())) + s.add_point(Vector3d(1, 1, 1), Vector3d(1, 1, 1)) + self.assertFalse(math.isfinite(s.arc_length(0))) + s.add_point(Vector3d(3, 3, 3), Vector3d(1, 1, 1)) + s.add_point(Vector3d(4, 4, 4), Vector3d(1, 1, 1)) + self.assertAlmostEqual(s.arc_length(0, 1.0), 3.46410161513775, delta=1e-14) - self.assertAlmostEqual(s.ArcLength(), 5.19615242270663, delta=1e-14) - self.assertAlmostEqual(s.ArcLength(), s.ArcLength(1.0)) - self.assertFalse(math.isfinite(s.ArcLength(-1.0))) - self.assertFalse(math.isfinite(s.ArcLength(4, 0.0))) + self.assertAlmostEqual(s.arc_length(), 5.19615242270663, delta=1e-14) + self.assertAlmostEqual(s.arc_length(), s.arc_length(1.0)) + self.assertFalse(math.isfinite(s.arc_length(-1.0))) + self.assertFalse(math.isfinite(s.arc_length(4, 0.0))) def test_tension(self): s = Spline() - s.Tension(0.1) - self.assertAlmostEqual(s.Tension(), 0.1) + s.tension(0.1) + self.assertAlmostEqual(s.tension(), 0.1) def test_interpolate(self): s = Spline() - self.assertFalse(s.Interpolate(0, 0.1).IsFinite()) + self.assertFalse(s.interpolate(0, 0.1).IsFinite()) - s.AddPoint(Vector3d(0, 0, 0)) - self.assertAlmostEqual(s.Interpolate(0, 0.1), Vector3d(0, 0, 0)) - self.assertFalse(s.InterpolateTangent(0.1).IsFinite()) + s.add_point(Vector3d(0, 0, 0)) + self.assertAlmostEqual(s.interpolate(0, 0.1), Vector3d(0, 0, 0)) + self.assertFalse(s.interpolate_tangent(0.1).IsFinite()) - s.AddPoint(Vector3d(1, 2, 3)) - self.assertAlmostEqual(s.Interpolate(0, 0.0), s.Point(0)) - self.assertFalse(s.Interpolate(0, -0.1).IsFinite()) - self.assertAlmostEqual(s.InterpolateTangent(0, 0.0), s.Tangent(0)) + s.add_point(Vector3d(1, 2, 3)) + self.assertAlmostEqual(s.interpolate(0, 0.0), s.point(0)) + self.assertFalse(s.interpolate(0, -0.1).IsFinite()) + self.assertAlmostEqual(s.interpolate_tangent(0, 0.0), s.tangent(0)) # Fast and slow call variations - self.assertAlmostEqual(s.Interpolate(0, 0.5), Vector3d(0.5, 1.0, 1.5)) - self.assertAlmostEqual(s.Interpolate(0, 1.0), s.Point(1)) - self.assertAlmostEqual(s.InterpolateTangent(0, 0.5), + self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0.5, 1.0, 1.5)) + self.assertAlmostEqual(s.interpolate(0, 1.0), s.point(1)) + self.assertAlmostEqual(s.interpolate_tangent(0, 0.5), Vector3d(1.25, 2.5, 3.75)) - self.assertAlmostEqual(s.InterpolateTangent(0, 1.0), s.Tangent(1)) - self.assertAlmostEqual(s.InterpolateMthDerivative(2, 0.5), + self.assertAlmostEqual(s.interpolate_tangent(0, 1.0), s.tangent(1)) + self.assertAlmostEqual(s.interpolate_mth_derivative(2, 0.5), Vector3d(0, 0, 0)) - self.assertAlmostEqual(s.InterpolateMthDerivative(2, 1.0), + self.assertAlmostEqual(s.interpolate_mth_derivative(2, 1.0), Vector3d(-3, -6, -9)) - self.assertAlmostEqual(s.InterpolateMthDerivative(3, 0.5), + self.assertAlmostEqual(s.interpolate_mth_derivative(3, 0.5), Vector3d(-6, -12, -18)) - self.assertAlmostEqual(s.InterpolateMthDerivative(3, 1.0), + self.assertAlmostEqual(s.interpolate_mth_derivative(3, 1.0), Vector3d(-6, -12, -18)) - self.assertAlmostEqual(s.InterpolateMthDerivative(4, 0.5), + self.assertAlmostEqual(s.interpolate_mth_derivative(4, 0.5), Vector3d(0, 0, 0)) - self.assertAlmostEqual(s.InterpolateMthDerivative(4, 1.0), + self.assertAlmostEqual(s.interpolate_mth_derivative(4, 1.0), Vector3d(0, 0, 0)) def test_point(self): s = Spline() - self.assertFalse(s.Point(0).IsFinite()) + self.assertFalse(s.point(0).IsFinite()) def test_tangent(self): s = Spline() - self.assertFalse(s.Tangent(0).IsFinite()) + self.assertFalse(s.tangent(0).IsFinite()) - s.AddPoint(Vector3d(0, 0, 0)) - self.assertFalse(s.Tangent(0).IsFinite()) + s.add_point(Vector3d(0, 0, 0)) + self.assertFalse(s.tangent(0).IsFinite()) - s.AddPoint(Vector3d(1, 0, 0)) - self.assertAlmostEqual(s.Tangent(0), Vector3d(0.5, 0, 0)) + s.add_point(Vector3d(1, 0, 0)) + self.assertAlmostEqual(s.tangent(0), Vector3d(0.5, 0, 0)) - s.AddPoint(Vector3d(1, 1, 0), Vector3d(-1, 1, 0)) - self.assertAlmostEqual(s.Tangent(1), Vector3d(0.5, 0.5, 0)) - self.assertAlmostEqual(s.Tangent(2), Vector3d(-1, 1, 0)) + s.add_point(Vector3d(1, 1, 0), Vector3d(-1, 1, 0)) + self.assertAlmostEqual(s.tangent(1), Vector3d(0.5, 0.5, 0)) + self.assertAlmostEqual(s.tangent(2), Vector3d(-1, 1, 0)) def test_recalc_tangents(self): s = Spline() - s.AddPoint(Vector3d(0, 0, 0)) - s.AddPoint(Vector3d(.4, .4, .4)) - s.AddPoint(Vector3d(0, 0, 0)) + s.add_point(Vector3d(0, 0, 0)) + s.add_point(Vector3d(.4, .4, .4)) + s.add_point(Vector3d(0, 0, 0)) - s.RecalcTangents() + s.recalc_tangents() - self.assertAlmostEqual(s.Interpolate(0, 0.5), Vector3d(0.2, 0.2, 0.2)) - self.assertAlmostEqual(s.Interpolate(1, 0.5), Vector3d(0.2, 0.2, 0.2)) + self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0.2, 0.2, 0.2)) + self.assertAlmostEqual(s.interpolate(1, 0.5), Vector3d(0.2, 0.2, 0.2)) if __name__ == '__main__': From c0407ad5857b323f79dc5ec3be4c9e1d2654563a Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Fri, 20 Aug 2021 11:28:30 -0300 Subject: [PATCH 06/11] Updates the test to follow the naiming style and moves the .i and python test to the python folder. Signed-off-by: LolaSegura --- src/Color.i | 113 ------------- src/Color_TEST.py | 334 -------------------------------------- src/RollingMean.i | 49 ------ src/RollingMean_TEST.py | 55 ------- src/Spline.i | 76 --------- src/Spline_TEST.py | 166 ------------------- src/python/CMakeLists.txt | 3 + src/python/python.i | 3 + 8 files changed, 6 insertions(+), 793 deletions(-) delete mode 100644 src/Color.i delete mode 100644 src/Color_TEST.py delete mode 100644 src/RollingMean.i delete mode 100644 src/RollingMean_TEST.py delete mode 100644 src/Spline.i delete mode 100644 src/Spline_TEST.py diff --git a/src/Color.i b/src/Color.i deleted file mode 100644 index 4af1792d0..000000000 --- a/src/Color.i +++ /dev/null @@ -1,113 +0,0 @@ -/* - * Copyright (C) 2021 Open Source Robotics Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * -*/ - -%module Color -%{ -#include -#include -#include -#include -%} - -%include "std_string.i" - -namespace ignition -{ - namespace math - { - class Color - { - %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; - %rename("%(uppercase)s", %$isstatic, %$isvariable) ""; - public: static const Color White; - public: static const Color Black; - public: static const Color Red; - public: static const Color Green; - public: static const Color Blue; - public: static const Color Yellow; - public: static const Color Magenta; - public: static const Color Cyan; - public: typedef unsigned int RGBA; - public: typedef unsigned int BGRA; - public: typedef unsigned int ARGB; - public: typedef unsigned int ABGR; - - public: Color(); - public: Color(const float _r, const float _g, const float _b, - const float _a = 1.0); - public: Color(const Color &_clr); - public: virtual ~Color(); - public: void Reset(); - public: void Set(const float _r = 1, const float _g = 1, - const float _b = 1, const float _a = 1); - public: Vector3 HSV() const; - public: void SetFromHSV(const float _h, const float _s, const float _v); - public: Vector3 YUV() const; - public: void SetFromYUV(const float _y, const float _u, const float _v); - public: RGBA AsRGBA() const; - public: BGRA AsBGRA() const; - public: ARGB AsARGB() const; - public: ABGR AsABGR() const; - public: void SetFromRGBA(const RGBA _v); - public: void SetFromBGRA(const BGRA _v); - public: void SetFromARGB(const ARGB _v); - public: void SetFromABGR(const ABGR _v); - public: Color operator+(const Color &_pt) const; - public: Color operator+(const float &_v) const; - public: const Color &operator+=(const Color &_pt); - public: Color operator-(const Color &_pt) const; - public: Color operator-(const float &_v) const; - public: const Color &operator-=(const Color &_pt); - public: const Color operator/(const Color &_pt) const; - public: const Color operator/(const float &_v) const; - public: const Color &operator/=(const Color &_pt); - public: const Color operator*(const Color &_pt) const; - public: const Color operator*(const float &_v) const; - public: const Color &operator*=(const Color &_pt); - public: bool operator==(const Color &_pt) const; - public: bool operator!=(const Color &_pt) const; - private: void Clamp(); - public: float R() const; - public: float G() const; - public: float B() const; - public: float A() const; - public: void R(const float _r); - public: void G(const float _g); - public: void B(const float _b); - public: void A(const float _a); - private: float r = 0; - private: float g = 0; - private: float b = 0; - private: float a = 1; - }; - - %extend Color{ - float __getitem__(const unsigned int i) - { - return (*$self)[i]; - } - } - - %extend Color { - std::string __str__() const { - std::ostringstream out; - out << *$self; - return out.str(); - } - } - } -} diff --git a/src/Color_TEST.py b/src/Color_TEST.py deleted file mode 100644 index c8018614d..000000000 --- a/src/Color_TEST.py +++ /dev/null @@ -1,334 +0,0 @@ -# Copyright (C) 2021 Open Source Robotics Foundation - -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at - -# http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import unittest -import math -from ignition.math import Color -from ignition.math import Vector3f - - -class TestColor(unittest.TestCase): - - def test_const_color(self): - self.assertAlmostEqual(1.0, Color.WHITE.r()) - self.assertAlmostEqual(1.0, Color.WHITE.g()) - self.assertAlmostEqual(1.0, Color.WHITE.b()) - self.assertAlmostEqual(1.0, Color.WHITE.a()) - - self.assertAlmostEqual(0.0, Color.BLACK.r()) - self.assertAlmostEqual(0.0, Color.BLACK.g()) - self.assertAlmostEqual(0.0, Color.BLACK.b()) - self.assertAlmostEqual(1.0, Color.BLACK.a()) - - self.assertAlmostEqual(1.0, Color.RED.r()) - self.assertAlmostEqual(0.0, Color.RED.g()) - self.assertAlmostEqual(0.0, Color.RED.b()) - self.assertAlmostEqual(1.0, Color.RED.a()) - - self.assertAlmostEqual(0.0, Color.GREEN.r()) - self.assertAlmostEqual(1.0, Color.GREEN.g()) - self.assertAlmostEqual(0.0, Color.GREEN.b()) - self.assertAlmostEqual(1.0, Color.GREEN.a()) - - self.assertAlmostEqual(0.0, Color.BLUE.r()) - self.assertAlmostEqual(0.0, Color.BLUE.g()) - self.assertAlmostEqual(1.0, Color.BLUE.b()) - self.assertAlmostEqual(1.0, Color.BLUE.a()) - - self.assertAlmostEqual(1.0, Color.YELLOW.r()) - self.assertAlmostEqual(1.0, Color.YELLOW.g()) - self.assertAlmostEqual(0.0, Color.YELLOW.b()) - self.assertAlmostEqual(1.0, Color.YELLOW.a()) - - self.assertAlmostEqual(1.0, Color.MAGENTA.r()) - self.assertAlmostEqual(0.0, Color.MAGENTA.g()) - self.assertAlmostEqual(1.0, Color.MAGENTA.b()) - self.assertAlmostEqual(1.0, Color.MAGENTA.a()) - - self.assertAlmostEqual(0.0, Color.CYAN.r()) - self.assertAlmostEqual(1.0, Color.CYAN.g()) - self.assertAlmostEqual(1.0, Color.CYAN.b()) - self.assertAlmostEqual(1.0, Color.CYAN.a()) - - def test_color(self): - clr0 = Color() - self.assertAlmostEqual(0.0, clr0.r()) - self.assertAlmostEqual(0.0, clr0.g()) - self.assertAlmostEqual(0.0, clr0.b()) - self.assertAlmostEqual(1.0, clr0.a()) - self.assertEqual(clr0.as_rgba(), 255) - clr0.a(0.0) - self.assertEqual(clr0.as_rgba(), 0) - - clr = Color(.1, .2, .3, 1.0) - self.assertAlmostEqual(0.1, clr.r()) - self.assertAlmostEqual(0.2, clr.g()) - self.assertAlmostEqual(0.3, clr.b()) - self.assertAlmostEqual(1.0, clr.a()) - - clr.set(1, 0, 0, 0) - self.assertAlmostEqual(clr.as_rgba(), 255 << 24) - self.assertAlmostEqual(clr.as_bgra(), 255 << 8) - self.assertAlmostEqual(clr.as_argb(), 255 << 16) - self.assertAlmostEqual(clr.as_abgr(), 255) - clr0.set_from_rgba(255 << 24) - self.assertEqual(clr0, clr) - clr0.set_from_bgra(255 << 8) - self.assertEqual(clr0, clr) - clr0.set_from_argb(255 << 16) - self.assertEqual(clr0, clr) - clr0.set_from_abgr(255) - self.assertEqual(clr0, clr) - - clr.set(0, 1, 0, 0) - self.assertAlmostEqual(clr.as_rgba(), 255 << 16) - self.assertAlmostEqual(clr.as_bgra(), 255 << 16) - self.assertAlmostEqual(clr.as_argb(), 255 << 8) - self.assertAlmostEqual(clr.as_abgr(), 255 << 8) - clr0.set_from_rgba(255 << 16) - self.assertEqual(clr0, clr) - clr0.set_from_bgra(255 << 16) - self.assertEqual(clr0, clr) - clr0.set_from_argb(255 << 8) - self.assertEqual(clr0, clr) - clr0.set_from_abgr(255 << 8) - self.assertEqual(clr0, clr) - - clr.set(0, 0, 1, 0) - self.assertAlmostEqual(clr.as_rgba(), 255 << 8) - self.assertAlmostEqual(clr.as_bgra(), 255 << 24) - self.assertAlmostEqual(clr.as_argb(), 255) - self.assertAlmostEqual(clr.as_abgr(), 255 << 16) - clr0.set_from_rgba(255 << 8) - self.assertEqual(clr0, clr) - clr0.set_from_bgra(255 << 24) - self.assertEqual(clr0, clr) - clr0.set_from_argb(255) - self.assertEqual(clr0, clr) - clr0.set_from_abgr(255 << 16) - self.assertEqual(clr0, clr) - - clr.set(0, 0, 0, 1) - self.assertAlmostEqual(clr.as_rgba(), 255) - self.assertAlmostEqual(clr.as_bgra(), 255) - self.assertAlmostEqual(clr.as_argb(), 255 << 24) - self.assertAlmostEqual(clr.as_abgr(), 255 << 24) - clr0.set_from_rgba(255) - self.assertEqual(clr0, clr) - clr0.set_from_bgra(255) - self.assertEqual(clr0, clr) - clr0.set_from_argb(255 << 24) - self.assertEqual(clr0, clr) - clr0.set_from_abgr(255 << 24) - self.assertEqual(clr0, clr) - - clr.reset() - self.assertAlmostEqual(0.0, clr.r()) - self.assertAlmostEqual(0.0, clr.g()) - self.assertAlmostEqual(0.0, clr.b()) - self.assertAlmostEqual(1.0, clr.a()) - - clr.set_from_hsv(0, 0.5, 1.0) - self.assertAlmostEqual(1.0, clr.r()) - self.assertAlmostEqual(0.5, clr.g()) - self.assertAlmostEqual(0.5, clr.b()) - self.assertAlmostEqual(1.0, clr.a()) - - self.assertTrue(clr.hsv() == Vector3f(6, 0.5, 1)) - - clr.set_from_hsv(60, 0.0, 1.0) - self.assertAlmostEqual(1.0, clr.r()) - self.assertAlmostEqual(1.0, clr.g()) - self.assertAlmostEqual(1.0, clr.b()) - self.assertAlmostEqual(1.0, clr.a()) - - clr.set_from_hsv(120, 0.5, 1.0) - self.assertAlmostEqual(0.5, clr.r()) - self.assertAlmostEqual(1.0, clr.g()) - self.assertAlmostEqual(0.5, clr.b()) - self.assertAlmostEqual(1.0, clr.a()) - - clr.set_from_hsv(180, 0.5, 1.0) - self.assertAlmostEqual(0.5, clr.r()) - self.assertAlmostEqual(1.0, clr.g()) - self.assertAlmostEqual(1.0, clr.b()) - self.assertAlmostEqual(1.0, clr.a()) - - clr.set_from_hsv(240, 0.5, 1.0) - self.assertAlmostEqual(0.5, clr.r()) - self.assertAlmostEqual(0.5, clr.g()) - self.assertAlmostEqual(1.0, clr.b()) - self.assertAlmostEqual(1.0, clr.a()) - - clr.set_from_hsv(300, 0.5, 1.0) - self.assertAlmostEqual(1.0, clr[0]) - self.assertAlmostEqual(0.5, clr[1]) - self.assertAlmostEqual(1.0, clr[2]) - self.assertAlmostEqual(1.0, clr[3]) - self.assertTrue(math.isnan(clr[4])) - - clr.set(0.1, 0.2, 0.3, 0.4) - clr = clr + 0.2 - self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) - - clr.set(0.1, 0.2, 0.3, 0.4) - clr += Color(0.2, 0.2, 0.2, 0.2) - self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) - - clr.set(0.1, 0.2, 0.3, 0.4) - clr = clr - 0.1 - self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) - - clr.set(0.1, 0.2, 0.3, 0.4) - clr -= Color(0.1, 0.1, 0.1, 0.1) - self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) - - clr.set(1.0, 1.0, 1.0, 1.0) - clr = clr / 1.6 - self.assertTrue(clr == Color(0.625, 0.625, 0.625, 0.625)) - - clr.set(1.0, 1.0, 1.0, 1.0) - clr /= Color(1.0, 1.0, 1.0, 1.0) - self.assertTrue(clr == Color(1.0, 1.0, 1.0, 1.0)) - - clr.set(.1, .2, .3, .4) - clr = clr * .1 - self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) - - clr.set(.1, .2, .3, .4) - clr *= Color(0.1, 0.1, 0.1, 0.1) - self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) - - clr.set_from_yuv(0.5, 0.2, 0.8) - self.assertAlmostEqual(0.00553, clr.r(), delta=1e-3) - self.assertAlmostEqual(0.0, clr.g()) - self.assertAlmostEqual(0.9064, clr.b(), delta=1e-3) - self.assertAlmostEqual(0.04, clr.a()) - - self.assertTrue(clr.yuv() == Vector3f(0.104985, 0.95227, 0.429305)) - - clr = Color(1.0, 0.0, 0.5, 1.0) + Color(0.1, 0.3, 0.4, 1.0) - self.assertAlmostEqual(0.00431373, clr.r(), delta=1e-4) - self.assertAlmostEqual(0.3, clr.g(), delta=1e-4) - self.assertAlmostEqual(0.9, clr.b(), delta=1e-4) - self.assertAlmostEqual(1.0, clr.a(), delta=1e-4) - - clr = Color(1.0, 0.0, 0.5, 1.0) - Color(0.1, 0.3, 0.4, 1.0) - self.assertAlmostEqual(0.9, clr.r(), delta=1e-4) - self.assertAlmostEqual(0.0, clr.g(), delta=1e-4) - self.assertAlmostEqual(0.1, clr.b(), delta=1e-4) - self.assertAlmostEqual(0.0, clr.a(), delta=1e-4) - - clr = Color(0.5, 0.2, 0.4, 0.6) / 2.0 - self.assertAlmostEqual(0.25, clr.r(), delta=1e-4) - self.assertAlmostEqual(0.1, clr.g(), delta=1e-4) - self.assertAlmostEqual(0.2, clr.b(), delta=1e-4) - self.assertAlmostEqual(0.3, clr.a(), delta=1e-4) - - def test_mul(self): - clr = Color(0.0, 0.01, 0.2, 1.0) - clr2 = Color(1.0, 0.2, 0.2, 0.0) - clr3 = clr * clr2 - - self.assertAlmostEqual(clr3.r(), 0.0) - self.assertAlmostEqual(clr3.g(), 0.002) - self.assertAlmostEqual(clr3.b(), 0.04) - self.assertAlmostEqual(clr3.a(), 0.0) - - def test_division(self): - clr = Color(0.0, 0.01, 0.2, 1.0) - clr2 = clr / 0.2 - self.assertAlmostEqual(clr2.r(), 0.0) - self.assertAlmostEqual(clr2.g(), 0.05) - self.assertAlmostEqual(clr2.b(), 1.0) - self.assertAlmostEqual(clr2.a(), 1.0) - - clr2 = clr / 2.0 - self.assertAlmostEqual(clr2.r(), 0.0) - self.assertAlmostEqual(clr2.g(), 0.005) - self.assertAlmostEqual(clr2.b(), 0.1) - self.assertAlmostEqual(clr2.a(), 0.5) - - clr2.set(0.0, 0.2, 0.4, 0.5) - clr3 = clr / clr2 - self.assertAlmostEqual(clr3.r(), 0.0) - self.assertAlmostEqual(clr3.g(), 0.05) - self.assertAlmostEqual(clr3.b(), 0.5) - self.assertAlmostEqual(clr3.a(), 1.0) - - clr.set(0.0, 0.0, 0.0, 0.0) - clr2.set(0.0, 0.0, 0.0, 0.0) - clr3 = clr / clr2 - self.assertAlmostEqual(clr3.r(), 0.0) - self.assertAlmostEqual(clr3.g(), 0.0) - self.assertAlmostEqual(clr3.b(), 0.0) - self.assertAlmostEqual(clr3.a(), 0.0) - - def test_const_set(self): - clr = Color(0.1, 0.2, 0.3, 0.4) - self.assertAlmostEqual(clr.r(), 0.1) - self.assertAlmostEqual(clr.g(), 0.2) - self.assertAlmostEqual(clr.b(), 0.3) - self.assertAlmostEqual(clr.a(), 0.4) - - clr2 = Color() - clr2.r(0.4) - clr2.g(0.3) - clr2.b(0.2) - clr2.a(0.1) - self.assertAlmostEqual(clr2.r(), 0.4) - self.assertAlmostEqual(clr2.g(), 0.3) - self.assertAlmostEqual(clr2.b(), 0.2) - self.assertAlmostEqual(clr2.a(), 0.1) - - self.assertTrue(clr2 != clr) - - def test_stream_out(self): - c = Color(0.1, 0.2, 0.3, 0.5) - self.assertAlmostEqual(str(c), "0.1 0.2 0.3 0.5") - - def test_HSV(self): - clr = Color() - hsv = clr.hsv() - self.assertAlmostEqual(hsv.X(), -1.0) - self.assertAlmostEqual(hsv.Y(), 0.0) - self.assertAlmostEqual(hsv.Z(), 0.0) - - clr.set(0.1, 0.2, 0.3, 1.0) - hsv = clr.hsv() - self.assertAlmostEqual(hsv.X(), 3.5, delta=1e-3) - self.assertAlmostEqual(hsv.Y(), 0.666667, delta=1e-3) - self.assertAlmostEqual(hsv.Z(), 0.3, delta=1e-3) - - clr.set(0.3, 0.2, 0.1, 1.0) - hsv = clr.hsv() - self.assertAlmostEqual(hsv.X(), 0.5, delta=1e-3) - self.assertAlmostEqual(hsv.Y(), 0.666667, delta=1e-3) - self.assertAlmostEqual(hsv.Z(), 0.3, delta=1e-3) - - clr.set_from_hsv(60, 10, 5) - self.assertAlmostEqual(clr.r(), 0.0196078, delta=1e-3) - self.assertAlmostEqual(clr.g(), 0.0196078, delta=1e-3) - self.assertAlmostEqual(clr.b(), 0.0, delta=1e-3) - self.assertAlmostEqual(clr.a(), 1.0, delta=1e-3) - - clr.set_from_hsv(360.0, 0.5, 0.6) - self.assertAlmostEqual(clr.r(), 0.6, delta=1e-3) - self.assertAlmostEqual(clr.g(), 0.3, delta=1e-3) - self.assertAlmostEqual(clr.b(), 0.3, delta=1e-3) - self.assertAlmostEqual(clr.a(), 1.0, delta=1e-3) - - -if __name__ == '__main__': - unittest.main() diff --git a/src/RollingMean.i b/src/RollingMean.i deleted file mode 100644 index d024b8b6f..000000000 --- a/src/RollingMean.i +++ /dev/null @@ -1,49 +0,0 @@ -/* - * Copyright (C) 2021 Open Source Robotics Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * -*/ - -%module rollingMean -%{ -#include -%} - -namespace ignition -{ - namespace math - { - class RollingMean - { - %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; - public: explicit RollingMean(size_t _windowSize = 10); - public: ~RollingMean(); - public: double Mean() const; - public: size_t Count() const; - public: void Push(double _value); - public: void Clear(); - public: void SetWindowSize(size_t _windowSize); - public: size_t WindowSize() const; - - #ifdef _WIN32 - #pragma warning(push) - #pragma warning(disable: 4251) - #endif - private: std::unique_ptr dataPtr; - #ifdef _WIN32 - #pragma warning(pop) - #endif - }; - } -} \ No newline at end of file diff --git a/src/RollingMean_TEST.py b/src/RollingMean_TEST.py deleted file mode 100644 index 76a7795c3..000000000 --- a/src/RollingMean_TEST.py +++ /dev/null @@ -1,55 +0,0 @@ -# Copyright (C) 2021 Open Source Robotics Foundation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import unittest -import math -from ignition.math import RollingMean - - -class TestRollingMean(unittest.TestCase): - - def test_rolling_mean(self): - mean = RollingMean() - self.assertEqual(0, mean.count()) - self.assertEqual(10, mean.window_size()) - - mean.set_window_size(4) - self.assertEqual(4, mean.window_size()) - mean.set_window_size(0) - self.assertEqual(4, mean.window_size()) - - mean.push(1.0) - self.assertAlmostEqual(1.0, mean.mean()) - mean.push(2.0) - self.assertAlmostEqual(1.5, mean.mean()) - mean.push(3.0) - self.assertAlmostEqual(2.0, mean.mean()) - mean.push(10.0) - self.assertAlmostEqual(4.0, mean.mean()) - mean.push(20.0) - self.assertAlmostEqual(8.75, mean.mean()) - - mean.clear() - self.assertTrue(math.isnan(mean.mean())) - - mean.push(100.0) - mean.push(200.0) - mean.push(300.0) - self.assertEqual(3, mean.count()) - mean.set_window_size(2) - self.assertEqual(0, mean.count()) - - -if __name__ == '__main__': - unittest.main() diff --git a/src/Spline.i b/src/Spline.i deleted file mode 100644 index 1b6bfb0cf..000000000 --- a/src/Spline.i +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (C) 2016 Open Source Robotics Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * -*/ - -%module spline -%{ -#include -#include -#include -#include -%} - -namespace ignition -{ - namespace math - { - class ControlPoint; - class SplinePrivate; - - class Spline - { - %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; - public: Spline(); - public: ~Spline(); - public: void Tension(double _t); - public: double Tension() const; - public: double ArcLength() const; - public: double ArcLength(const double _t) const; - public: double ArcLength(const unsigned int _index, - const double _t) const; - public: void AddPoint(const Vector3 &_p); - public: void AddPoint(const Vector3 &_p, const Vector3 &_t); - private: void AddPoint(const ControlPoint &_cp, const bool _fixed); - public: Vector3 Point(const unsigned int _index) const; - public: Vector3 Tangent(const unsigned int _index) const; - public: Vector3 MthDerivative(const unsigned int _index, - const unsigned int _mth) const; - public: size_t PointCount() const; - public: void Clear(); - public: bool UpdatePoint(const unsigned int _index, - const Vector3 &_p); - public: bool UpdatePoint(const unsigned int _index, - const Vector3 &_p, - const Vector3 &_t); - private: bool UpdatePoint(const unsigned int _index, - const ControlPoint &_cp, - const bool _fixed); - public: Vector3 Interpolate(const double _t) const; - public: Vector3 Interpolate(const unsigned int _fromIndex, - const double _t) const; - public: Vector3 InterpolateTangent(const double _t) const; - public: Vector3 InterpolateTangent(const unsigned int _fromIndex, - const double _t) const; - public: Vector3 InterpolateMthDerivative(const unsigned int _mth, - const double _1) const; - public: Vector3 InterpolateMthDerivative(const unsigned int _fromIndex, - const unsigned int _mth, - const double _s) const; - public: void AutoCalculate(bool _autoCalc); - public: void RecalcTangents(); - }; - } -} \ No newline at end of file diff --git a/src/Spline_TEST.py b/src/Spline_TEST.py deleted file mode 100644 index 9f60db8fb..000000000 --- a/src/Spline_TEST.py +++ /dev/null @@ -1,166 +0,0 @@ -# Copyright (C) 2021 Open Source Robotics Foundation - -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at - -# http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import unittest -import math -from ignition.math import Vector3d -from ignition.math import Spline - - -class TestSpline(unittest.TestCase): - - def test_spline(self): - s = Spline() - - s.add_point(Vector3d(0, 0, 0)) - self.assertEqual(1, s.point_count()) - - s.clear() - self.assertEqual(0, s.point_count()) - - s.add_point(Vector3d(0, 0, 0)) - self.assertTrue(s.point(0) == Vector3d(0, 0, 0)) - s.add_point(Vector3d(1, 1, 1)) - self.assertTrue(s.point(1) == Vector3d(1, 1, 1)) - - # update_point - self.assertFalse(s.update_point(2, Vector3d(2, 2, 2))) - - self.assertTrue(s.update_point(1, Vector3d(2, 2, 2))) - s.auto_calculate(False) - self.assertTrue(s.update_point(0, Vector3d(-1, -1, -1))) - s.auto_calculate(True) - - # interpolate - self.assertAlmostEqual(s.interpolate(0.0), Vector3d(-1, -1, -1)) - self.assertAlmostEqual(s.interpolate(0.5), Vector3d(0.5, 0.5, 0.5)) - self.assertAlmostEqual(s.interpolate(1.0), Vector3d(2, 2, 2)) - - # interpolate - s.add_point(Vector3d(4, 4, 4)) - self.assertAlmostEqual(s.interpolate(1, 0.2), - Vector3d(2.496, 2.496, 2.496)) - - def test_fixed_tangent(self): - s = Spline() - - # add_point - s.auto_calculate(False) - s.add_point(Vector3d(0, 0, 0)) - s.add_point(Vector3d(0, 0.5, 0), Vector3d(0, 1, 0)) - s.add_point(Vector3d(0.5, 1, 0), Vector3d(1, 0, 0)) - s.add_point(Vector3d(1, 1, 0), Vector3d(1, 0, 0)) - - # update_point - s.update_point(0, Vector3d(0, 0, 0), Vector3d(0, 1, 0)) - - s.auto_calculate(True) - - s.recalc_tangents() - - # interpolate - self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0, 0.25, 0)) - self.assertAlmostEqual(s.interpolate_tangent(0, 0.5), - Vector3d(0, 0.25, 0)) - self.assertAlmostEqual(s.interpolate(1, 0.5), - Vector3d(0.125, 0.875, 0)) - self.assertAlmostEqual(s.interpolate(2, 0.5), Vector3d(0.75, 1, 0)) - self.assertAlmostEqual(s.interpolate_tangent(2, 0.5), - Vector3d(0.25, 0, 0)) - - def test_arc_length(self): - s = Spline() - self.assertFalse(math.isfinite(s.arc_length())) - s.add_point(Vector3d(1, 1, 1), Vector3d(1, 1, 1)) - self.assertFalse(math.isfinite(s.arc_length(0))) - s.add_point(Vector3d(3, 3, 3), Vector3d(1, 1, 1)) - s.add_point(Vector3d(4, 4, 4), Vector3d(1, 1, 1)) - self.assertAlmostEqual(s.arc_length(0, 1.0), - 3.46410161513775, delta=1e-14) - self.assertAlmostEqual(s.arc_length(), 5.19615242270663, delta=1e-14) - self.assertAlmostEqual(s.arc_length(), s.arc_length(1.0)) - self.assertFalse(math.isfinite(s.arc_length(-1.0))) - self.assertFalse(math.isfinite(s.arc_length(4, 0.0))) - - def test_tension(self): - s = Spline() - - s.tension(0.1) - self.assertAlmostEqual(s.tension(), 0.1) - - def test_interpolate(self): - s = Spline() - self.assertFalse(s.interpolate(0, 0.1).IsFinite()) - - s.add_point(Vector3d(0, 0, 0)) - self.assertAlmostEqual(s.interpolate(0, 0.1), Vector3d(0, 0, 0)) - self.assertFalse(s.interpolate_tangent(0.1).IsFinite()) - - s.add_point(Vector3d(1, 2, 3)) - self.assertAlmostEqual(s.interpolate(0, 0.0), s.point(0)) - self.assertFalse(s.interpolate(0, -0.1).IsFinite()) - self.assertAlmostEqual(s.interpolate_tangent(0, 0.0), s.tangent(0)) - - # Fast and slow call variations - self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0.5, 1.0, 1.5)) - self.assertAlmostEqual(s.interpolate(0, 1.0), s.point(1)) - self.assertAlmostEqual(s.interpolate_tangent(0, 0.5), - Vector3d(1.25, 2.5, 3.75)) - self.assertAlmostEqual(s.interpolate_tangent(0, 1.0), s.tangent(1)) - self.assertAlmostEqual(s.interpolate_mth_derivative(2, 0.5), - Vector3d(0, 0, 0)) - self.assertAlmostEqual(s.interpolate_mth_derivative(2, 1.0), - Vector3d(-3, -6, -9)) - self.assertAlmostEqual(s.interpolate_mth_derivative(3, 0.5), - Vector3d(-6, -12, -18)) - self.assertAlmostEqual(s.interpolate_mth_derivative(3, 1.0), - Vector3d(-6, -12, -18)) - self.assertAlmostEqual(s.interpolate_mth_derivative(4, 0.5), - Vector3d(0, 0, 0)) - self.assertAlmostEqual(s.interpolate_mth_derivative(4, 1.0), - Vector3d(0, 0, 0)) - - def test_point(self): - s = Spline() - self.assertFalse(s.point(0).IsFinite()) - - def test_tangent(self): - s = Spline() - self.assertFalse(s.tangent(0).IsFinite()) - - s.add_point(Vector3d(0, 0, 0)) - self.assertFalse(s.tangent(0).IsFinite()) - - s.add_point(Vector3d(1, 0, 0)) - self.assertAlmostEqual(s.tangent(0), Vector3d(0.5, 0, 0)) - - s.add_point(Vector3d(1, 1, 0), Vector3d(-1, 1, 0)) - self.assertAlmostEqual(s.tangent(1), Vector3d(0.5, 0.5, 0)) - self.assertAlmostEqual(s.tangent(2), Vector3d(-1, 1, 0)) - - def test_recalc_tangents(self): - s = Spline() - - s.add_point(Vector3d(0, 0, 0)) - s.add_point(Vector3d(.4, .4, .4)) - s.add_point(Vector3d(0, 0, 0)) - - s.recalc_tangents() - - self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0.2, 0.2, 0.2)) - self.assertAlmostEqual(s.interpolate(1, 0.5), Vector3d(0.2, 0.2, 0.2)) - - -if __name__ == '__main__': - unittest.main() diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt index 2d502ff5f..47b9d25b9 100644 --- a/src/python/CMakeLists.txt +++ b/src/python/CMakeLists.txt @@ -69,9 +69,12 @@ if (PYTHONLIBS_FOUND) # Add the Python tests set(python_tests Angle_TEST + Color_TEST GaussMarkovProcess_TEST python_TEST Rand_TEST + RollingMean_TEST + Spline_TEST Vector2_TEST Vector3_TEST Vector4_TEST diff --git a/src/python/python.i b/src/python/python.i index 614c220bd..ee125c71a 100644 --- a/src/python/python.i +++ b/src/python/python.i @@ -5,3 +5,6 @@ %include Vector2.i %include Vector3.i %include Vector4.i +%include Color.i +%include RollingMean.i +%include Spline.i From 73ca31016201e5fc48b0cecfb79ef6e70d8c8c29 Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Fri, 20 Aug 2021 12:10:41 -0300 Subject: [PATCH 07/11] Adds swig files to the python/CMakeList. Signed-off-by: LolaSegura --- src/python/CMakeLists.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt index 47b9d25b9..439a258d0 100644 --- a/src/python/CMakeLists.txt +++ b/src/python/CMakeLists.txt @@ -16,8 +16,11 @@ if (SWIG_FOUND) set(swig_files Angle + Color GaussMarkovProcess Rand + RollingMean + Spline Vector2 Vector3 Vector4) From 97af5496b2fb5c107b818f822ca1b65c813a7277 Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Fri, 20 Aug 2021 12:30:50 -0300 Subject: [PATCH 08/11] Tracks moved files. Signed-off-by: LolaSegura --- src/python/Color.i | 113 +++++++++++ src/python/Color_TEST.py | 334 +++++++++++++++++++++++++++++++++ src/python/RollingMean.i | 49 +++++ src/python/RollingMean_TEST.py | 55 ++++++ src/python/Spline.i | 76 ++++++++ src/python/Spline_TEST.py | 166 ++++++++++++++++ 6 files changed, 793 insertions(+) create mode 100644 src/python/Color.i create mode 100644 src/python/Color_TEST.py create mode 100644 src/python/RollingMean.i create mode 100644 src/python/RollingMean_TEST.py create mode 100644 src/python/Spline.i create mode 100644 src/python/Spline_TEST.py diff --git a/src/python/Color.i b/src/python/Color.i new file mode 100644 index 000000000..4af1792d0 --- /dev/null +++ b/src/python/Color.i @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2021 Open Source Robotics Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +%module Color +%{ +#include +#include +#include +#include +%} + +%include "std_string.i" + +namespace ignition +{ + namespace math + { + class Color + { + %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; + %rename("%(uppercase)s", %$isstatic, %$isvariable) ""; + public: static const Color White; + public: static const Color Black; + public: static const Color Red; + public: static const Color Green; + public: static const Color Blue; + public: static const Color Yellow; + public: static const Color Magenta; + public: static const Color Cyan; + public: typedef unsigned int RGBA; + public: typedef unsigned int BGRA; + public: typedef unsigned int ARGB; + public: typedef unsigned int ABGR; + + public: Color(); + public: Color(const float _r, const float _g, const float _b, + const float _a = 1.0); + public: Color(const Color &_clr); + public: virtual ~Color(); + public: void Reset(); + public: void Set(const float _r = 1, const float _g = 1, + const float _b = 1, const float _a = 1); + public: Vector3 HSV() const; + public: void SetFromHSV(const float _h, const float _s, const float _v); + public: Vector3 YUV() const; + public: void SetFromYUV(const float _y, const float _u, const float _v); + public: RGBA AsRGBA() const; + public: BGRA AsBGRA() const; + public: ARGB AsARGB() const; + public: ABGR AsABGR() const; + public: void SetFromRGBA(const RGBA _v); + public: void SetFromBGRA(const BGRA _v); + public: void SetFromARGB(const ARGB _v); + public: void SetFromABGR(const ABGR _v); + public: Color operator+(const Color &_pt) const; + public: Color operator+(const float &_v) const; + public: const Color &operator+=(const Color &_pt); + public: Color operator-(const Color &_pt) const; + public: Color operator-(const float &_v) const; + public: const Color &operator-=(const Color &_pt); + public: const Color operator/(const Color &_pt) const; + public: const Color operator/(const float &_v) const; + public: const Color &operator/=(const Color &_pt); + public: const Color operator*(const Color &_pt) const; + public: const Color operator*(const float &_v) const; + public: const Color &operator*=(const Color &_pt); + public: bool operator==(const Color &_pt) const; + public: bool operator!=(const Color &_pt) const; + private: void Clamp(); + public: float R() const; + public: float G() const; + public: float B() const; + public: float A() const; + public: void R(const float _r); + public: void G(const float _g); + public: void B(const float _b); + public: void A(const float _a); + private: float r = 0; + private: float g = 0; + private: float b = 0; + private: float a = 1; + }; + + %extend Color{ + float __getitem__(const unsigned int i) + { + return (*$self)[i]; + } + } + + %extend Color { + std::string __str__() const { + std::ostringstream out; + out << *$self; + return out.str(); + } + } + } +} diff --git a/src/python/Color_TEST.py b/src/python/Color_TEST.py new file mode 100644 index 000000000..91c5f9bf4 --- /dev/null +++ b/src/python/Color_TEST.py @@ -0,0 +1,334 @@ +# Copyright (C) 2021 Open Source Robotics Foundation + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest +import math +from ignition.math import Color +from ignition.math import Vector3f + + +class TestColor(unittest.TestCase): + + def test_const_color(self): + self.assertAlmostEqual(1.0, Color.WHITE.r()) + self.assertAlmostEqual(1.0, Color.WHITE.g()) + self.assertAlmostEqual(1.0, Color.WHITE.b()) + self.assertAlmostEqual(1.0, Color.WHITE.a()) + + self.assertAlmostEqual(0.0, Color.BLACK.r()) + self.assertAlmostEqual(0.0, Color.BLACK.g()) + self.assertAlmostEqual(0.0, Color.BLACK.b()) + self.assertAlmostEqual(1.0, Color.BLACK.a()) + + self.assertAlmostEqual(1.0, Color.RED.r()) + self.assertAlmostEqual(0.0, Color.RED.g()) + self.assertAlmostEqual(0.0, Color.RED.b()) + self.assertAlmostEqual(1.0, Color.RED.a()) + + self.assertAlmostEqual(0.0, Color.GREEN.r()) + self.assertAlmostEqual(1.0, Color.GREEN.g()) + self.assertAlmostEqual(0.0, Color.GREEN.b()) + self.assertAlmostEqual(1.0, Color.GREEN.a()) + + self.assertAlmostEqual(0.0, Color.BLUE.r()) + self.assertAlmostEqual(0.0, Color.BLUE.g()) + self.assertAlmostEqual(1.0, Color.BLUE.b()) + self.assertAlmostEqual(1.0, Color.BLUE.a()) + + self.assertAlmostEqual(1.0, Color.YELLOW.r()) + self.assertAlmostEqual(1.0, Color.YELLOW.g()) + self.assertAlmostEqual(0.0, Color.YELLOW.b()) + self.assertAlmostEqual(1.0, Color.YELLOW.a()) + + self.assertAlmostEqual(1.0, Color.MAGENTA.r()) + self.assertAlmostEqual(0.0, Color.MAGENTA.g()) + self.assertAlmostEqual(1.0, Color.MAGENTA.b()) + self.assertAlmostEqual(1.0, Color.MAGENTA.a()) + + self.assertAlmostEqual(0.0, Color.CYAN.r()) + self.assertAlmostEqual(1.0, Color.CYAN.g()) + self.assertAlmostEqual(1.0, Color.CYAN.b()) + self.assertAlmostEqual(1.0, Color.CYAN.a()) + + def test_color(self): + clr0 = Color() + self.assertAlmostEqual(0.0, clr0.r()) + self.assertAlmostEqual(0.0, clr0.g()) + self.assertAlmostEqual(0.0, clr0.b()) + self.assertAlmostEqual(1.0, clr0.a()) + self.assertEqual(clr0.as_rgba(), 255) + clr0.a(0.0) + self.assertEqual(clr0.as_rgba(), 0) + + clr = Color(.1, .2, .3, 1.0) + self.assertAlmostEqual(0.1, clr.r()) + self.assertAlmostEqual(0.2, clr.g()) + self.assertAlmostEqual(0.3, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set(1, 0, 0, 0) + self.assertAlmostEqual(clr.as_rgba(), 255 << 24) + self.assertAlmostEqual(clr.as_bgra(), 255 << 8) + self.assertAlmostEqual(clr.as_argb(), 255 << 16) + self.assertAlmostEqual(clr.as_abgr(), 255) + clr0.set_from_rgba(255 << 24) + self.assertEqual(clr0, clr) + clr0.set_from_bgra(255 << 8) + self.assertEqual(clr0, clr) + clr0.set_from_argb(255 << 16) + self.assertEqual(clr0, clr) + clr0.set_from_abgr(255) + self.assertEqual(clr0, clr) + + clr.set(0, 1, 0, 0) + self.assertAlmostEqual(clr.as_rgba(), 255 << 16) + self.assertAlmostEqual(clr.as_bgra(), 255 << 16) + self.assertAlmostEqual(clr.as_argb(), 255 << 8) + self.assertAlmostEqual(clr.as_abgr(), 255 << 8) + clr0.set_from_rgba(255 << 16) + self.assertEqual(clr0, clr) + clr0.set_from_bgra(255 << 16) + self.assertEqual(clr0, clr) + clr0.set_from_argb(255 << 8) + self.assertEqual(clr0, clr) + clr0.set_from_abgr(255 << 8) + self.assertEqual(clr0, clr) + + clr.set(0, 0, 1, 0) + self.assertAlmostEqual(clr.as_rgba(), 255 << 8) + self.assertAlmostEqual(clr.as_bgra(), 255 << 24) + self.assertAlmostEqual(clr.as_argb(), 255) + self.assertAlmostEqual(clr.as_abgr(), 255 << 16) + clr0.set_from_rgba(255 << 8) + self.assertEqual(clr0, clr) + clr0.set_from_bgra(255 << 24) + self.assertEqual(clr0, clr) + clr0.set_from_argb(255) + self.assertEqual(clr0, clr) + clr0.set_from_abgr(255 << 16) + self.assertEqual(clr0, clr) + + clr.set(0, 0, 0, 1) + self.assertAlmostEqual(clr.as_rgba(), 255) + self.assertAlmostEqual(clr.as_bgra(), 255) + self.assertAlmostEqual(clr.as_argb(), 255 << 24) + self.assertAlmostEqual(clr.as_abgr(), 255 << 24) + clr0.set_from_rgba(255) + self.assertEqual(clr0, clr) + clr0.set_from_bgra(255) + self.assertEqual(clr0, clr) + clr0.set_from_argb(255 << 24) + self.assertEqual(clr0, clr) + clr0.set_from_abgr(255 << 24) + self.assertEqual(clr0, clr) + + clr.reset() + self.assertAlmostEqual(0.0, clr.r()) + self.assertAlmostEqual(0.0, clr.g()) + self.assertAlmostEqual(0.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(0, 0.5, 1.0) + self.assertAlmostEqual(1.0, clr.r()) + self.assertAlmostEqual(0.5, clr.g()) + self.assertAlmostEqual(0.5, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + self.assertTrue(clr.hsv() == Vector3f(6, 0.5, 1)) + + clr.set_from_hsv(60, 0.0, 1.0) + self.assertAlmostEqual(1.0, clr.r()) + self.assertAlmostEqual(1.0, clr.g()) + self.assertAlmostEqual(1.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(120, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.r()) + self.assertAlmostEqual(1.0, clr.g()) + self.assertAlmostEqual(0.5, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(180, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.r()) + self.assertAlmostEqual(1.0, clr.g()) + self.assertAlmostEqual(1.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(240, 0.5, 1.0) + self.assertAlmostEqual(0.5, clr.r()) + self.assertAlmostEqual(0.5, clr.g()) + self.assertAlmostEqual(1.0, clr.b()) + self.assertAlmostEqual(1.0, clr.a()) + + clr.set_from_hsv(300, 0.5, 1.0) + self.assertAlmostEqual(1.0, clr[0]) + self.assertAlmostEqual(0.5, clr[1]) + self.assertAlmostEqual(1.0, clr[2]) + self.assertAlmostEqual(1.0, clr[3]) + self.assertTrue(math.isnan(clr[4])) + + clr.set(0.1, 0.2, 0.3, 0.4) + clr = clr + 0.2 + self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) + + clr.set(0.1, 0.2, 0.3, 0.4) + clr += Color(0.2, 0.2, 0.2, 0.2) + self.assertTrue(clr == Color(0.3, 0.4, 0.5, 0.6)) + + clr.set(0.1, 0.2, 0.3, 0.4) + clr = clr - 0.1 + self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) + + clr.set(0.1, 0.2, 0.3, 0.4) + clr -= Color(0.1, 0.1, 0.1, 0.1) + self.assertTrue(clr == Color(0.0, 0.1, 0.2, 0.3)) + + clr.set(1.0, 1.0, 1.0, 1.0) + clr = clr / 1.6 + self.assertTrue(clr == Color(0.625, 0.625, 0.625, 0.625)) + + clr.set(1.0, 1.0, 1.0, 1.0) + clr /= Color(1.0, 1.0, 1.0, 1.0) + self.assertTrue(clr == Color(1.0, 1.0, 1.0, 1.0)) + + clr.set(.1, .2, .3, .4) + clr = clr * .1 + self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) + + clr.set(.1, .2, .3, .4) + clr *= Color(0.1, 0.1, 0.1, 0.1) + self.assertTrue(clr == Color(0.01, 0.02, 0.03, 0.04)) + + clr.set_from_yuv(0.5, 0.2, 0.8) + self.assertAlmostEqual(0.00553, clr.r(), delta=1e-3) + self.assertAlmostEqual(0.0, clr.g()) + self.assertAlmostEqual(0.9064, clr.b(), delta=1e-3) + self.assertAlmostEqual(0.04, clr.a()) + + self.assertTrue(clr.yuv() == Vector3f(0.104985, 0.95227, 0.429305)) + + clr = Color(1.0, 0.0, 0.5, 1.0) + Color(0.1, 0.3, 0.4, 1.0) + self.assertAlmostEqual(0.00431373, clr.r(), delta=1e-4) + self.assertAlmostEqual(0.3, clr.g(), delta=1e-4) + self.assertAlmostEqual(0.9, clr.b(), delta=1e-4) + self.assertAlmostEqual(1.0, clr.a(), delta=1e-4) + + clr = Color(1.0, 0.0, 0.5, 1.0) - Color(0.1, 0.3, 0.4, 1.0) + self.assertAlmostEqual(0.9, clr.r(), delta=1e-4) + self.assertAlmostEqual(0.0, clr.g(), delta=1e-4) + self.assertAlmostEqual(0.1, clr.b(), delta=1e-4) + self.assertAlmostEqual(0.0, clr.a(), delta=1e-4) + + clr = Color(0.5, 0.2, 0.4, 0.6) / 2.0 + self.assertAlmostEqual(0.25, clr.r(), delta=1e-4) + self.assertAlmostEqual(0.1, clr.g(), delta=1e-4) + self.assertAlmostEqual(0.2, clr.b(), delta=1e-4) + self.assertAlmostEqual(0.3, clr.a(), delta=1e-4) + + def test_mul(self): + clr = Color(0.0, 0.01, 0.2, 1.0) + clr2 = Color(1.0, 0.2, 0.2, 0.0) + clr3 = clr * clr2 + + self.assertAlmostEqual(clr3.r(), 0.0) + self.assertAlmostEqual(clr3.g(), 0.002) + self.assertAlmostEqual(clr3.b(), 0.04) + self.assertAlmostEqual(clr3.a(), 0.0) + + def test_division(self): + clr = Color(0.0, 0.01, 0.2, 1.0) + clr2 = clr / 0.2 + self.assertAlmostEqual(clr2.r(), 0.0) + self.assertAlmostEqual(clr2.g(), 0.05) + self.assertAlmostEqual(clr2.b(), 1.0) + self.assertAlmostEqual(clr2.a(), 1.0) + + clr2 = clr / 2.0 + self.assertAlmostEqual(clr2.r(), 0.0) + self.assertAlmostEqual(clr2.g(), 0.005) + self.assertAlmostEqual(clr2.b(), 0.1) + self.assertAlmostEqual(clr2.a(), 0.5) + + clr2.set(0.0, 0.2, 0.4, 0.5) + clr3 = clr / clr2 + self.assertAlmostEqual(clr3.r(), 0.0) + self.assertAlmostEqual(clr3.g(), 0.05) + self.assertAlmostEqual(clr3.b(), 0.5) + self.assertAlmostEqual(clr3.a(), 1.0) + + clr.set(0.0, 0.0, 0.0, 0.0) + clr2.set(0.0, 0.0, 0.0, 0.0) + clr3 = clr / clr2 + self.assertAlmostEqual(clr3.r(), 0.0) + self.assertAlmostEqual(clr3.g(), 0.0) + self.assertAlmostEqual(clr3.b(), 0.0) + self.assertAlmostEqual(clr3.a(), 0.0) + + def test_const_set(self): + clr = Color(0.1, 0.2, 0.3, 0.4) + self.assertAlmostEqual(clr.r(), 0.1) + self.assertAlmostEqual(clr.g(), 0.2) + self.assertAlmostEqual(clr.b(), 0.3) + self.assertAlmostEqual(clr.a(), 0.4) + + clr2 = Color() + clr2.r(0.4) + clr2.g(0.3) + clr2.b(0.2) + clr2.a(0.1) + self.assertAlmostEqual(clr2.r(), 0.4) + self.assertAlmostEqual(clr2.g(), 0.3) + self.assertAlmostEqual(clr2.b(), 0.2) + self.assertAlmostEqual(clr2.a(), 0.1) + + self.assertTrue(clr2 != clr) + + def test_stream_out(self): + c = Color(0.1, 0.2, 0.3, 0.5) + self.assertAlmostEqual(str(c), "0.1 0.2 0.3 0.5") + + def test_HSV(self): + clr = Color() + hsv = clr.hsv() + self.assertAlmostEqual(hsv.x(), -1.0) + self.assertAlmostEqual(hsv.y(), 0.0) + self.assertAlmostEqual(hsv.z(), 0.0) + + clr.set(0.1, 0.2, 0.3, 1.0) + hsv = clr.hsv() + self.assertAlmostEqual(hsv.x(), 3.5, delta=1e-3) + self.assertAlmostEqual(hsv.y(), 0.666667, delta=1e-3) + self.assertAlmostEqual(hsv.z(), 0.3, delta=1e-3) + + clr.set(0.3, 0.2, 0.1, 1.0) + hsv = clr.hsv() + self.assertAlmostEqual(hsv.x(), 0.5, delta=1e-3) + self.assertAlmostEqual(hsv.y(), 0.666667, delta=1e-3) + self.assertAlmostEqual(hsv.z(), 0.3, delta=1e-3) + + clr.set_from_hsv(60, 10, 5) + self.assertAlmostEqual(clr.r(), 0.0196078, delta=1e-3) + self.assertAlmostEqual(clr.g(), 0.0196078, delta=1e-3) + self.assertAlmostEqual(clr.b(), 0.0, delta=1e-3) + self.assertAlmostEqual(clr.a(), 1.0, delta=1e-3) + + clr.set_from_hsv(360.0, 0.5, 0.6) + self.assertAlmostEqual(clr.r(), 0.6, delta=1e-3) + self.assertAlmostEqual(clr.g(), 0.3, delta=1e-3) + self.assertAlmostEqual(clr.b(), 0.3, delta=1e-3) + self.assertAlmostEqual(clr.a(), 1.0, delta=1e-3) + + +if __name__ == '__main__': + unittest.main() diff --git a/src/python/RollingMean.i b/src/python/RollingMean.i new file mode 100644 index 000000000..d024b8b6f --- /dev/null +++ b/src/python/RollingMean.i @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2021 Open Source Robotics Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +%module rollingMean +%{ +#include +%} + +namespace ignition +{ + namespace math + { + class RollingMean + { + %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; + public: explicit RollingMean(size_t _windowSize = 10); + public: ~RollingMean(); + public: double Mean() const; + public: size_t Count() const; + public: void Push(double _value); + public: void Clear(); + public: void SetWindowSize(size_t _windowSize); + public: size_t WindowSize() const; + + #ifdef _WIN32 + #pragma warning(push) + #pragma warning(disable: 4251) + #endif + private: std::unique_ptr dataPtr; + #ifdef _WIN32 + #pragma warning(pop) + #endif + }; + } +} \ No newline at end of file diff --git a/src/python/RollingMean_TEST.py b/src/python/RollingMean_TEST.py new file mode 100644 index 000000000..76a7795c3 --- /dev/null +++ b/src/python/RollingMean_TEST.py @@ -0,0 +1,55 @@ +# Copyright (C) 2021 Open Source Robotics Foundation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest +import math +from ignition.math import RollingMean + + +class TestRollingMean(unittest.TestCase): + + def test_rolling_mean(self): + mean = RollingMean() + self.assertEqual(0, mean.count()) + self.assertEqual(10, mean.window_size()) + + mean.set_window_size(4) + self.assertEqual(4, mean.window_size()) + mean.set_window_size(0) + self.assertEqual(4, mean.window_size()) + + mean.push(1.0) + self.assertAlmostEqual(1.0, mean.mean()) + mean.push(2.0) + self.assertAlmostEqual(1.5, mean.mean()) + mean.push(3.0) + self.assertAlmostEqual(2.0, mean.mean()) + mean.push(10.0) + self.assertAlmostEqual(4.0, mean.mean()) + mean.push(20.0) + self.assertAlmostEqual(8.75, mean.mean()) + + mean.clear() + self.assertTrue(math.isnan(mean.mean())) + + mean.push(100.0) + mean.push(200.0) + mean.push(300.0) + self.assertEqual(3, mean.count()) + mean.set_window_size(2) + self.assertEqual(0, mean.count()) + + +if __name__ == '__main__': + unittest.main() diff --git a/src/python/Spline.i b/src/python/Spline.i new file mode 100644 index 000000000..1b6bfb0cf --- /dev/null +++ b/src/python/Spline.i @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2016 Open Source Robotics Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +%module spline +%{ +#include +#include +#include +#include +%} + +namespace ignition +{ + namespace math + { + class ControlPoint; + class SplinePrivate; + + class Spline + { + %rename("%(undercase)s", %$isfunction, %$ismember, %$not %$isconstructor) ""; + public: Spline(); + public: ~Spline(); + public: void Tension(double _t); + public: double Tension() const; + public: double ArcLength() const; + public: double ArcLength(const double _t) const; + public: double ArcLength(const unsigned int _index, + const double _t) const; + public: void AddPoint(const Vector3 &_p); + public: void AddPoint(const Vector3 &_p, const Vector3 &_t); + private: void AddPoint(const ControlPoint &_cp, const bool _fixed); + public: Vector3 Point(const unsigned int _index) const; + public: Vector3 Tangent(const unsigned int _index) const; + public: Vector3 MthDerivative(const unsigned int _index, + const unsigned int _mth) const; + public: size_t PointCount() const; + public: void Clear(); + public: bool UpdatePoint(const unsigned int _index, + const Vector3 &_p); + public: bool UpdatePoint(const unsigned int _index, + const Vector3 &_p, + const Vector3 &_t); + private: bool UpdatePoint(const unsigned int _index, + const ControlPoint &_cp, + const bool _fixed); + public: Vector3 Interpolate(const double _t) const; + public: Vector3 Interpolate(const unsigned int _fromIndex, + const double _t) const; + public: Vector3 InterpolateTangent(const double _t) const; + public: Vector3 InterpolateTangent(const unsigned int _fromIndex, + const double _t) const; + public: Vector3 InterpolateMthDerivative(const unsigned int _mth, + const double _1) const; + public: Vector3 InterpolateMthDerivative(const unsigned int _fromIndex, + const unsigned int _mth, + const double _s) const; + public: void AutoCalculate(bool _autoCalc); + public: void RecalcTangents(); + }; + } +} \ No newline at end of file diff --git a/src/python/Spline_TEST.py b/src/python/Spline_TEST.py new file mode 100644 index 000000000..293fa5fbf --- /dev/null +++ b/src/python/Spline_TEST.py @@ -0,0 +1,166 @@ +# Copyright (C) 2021 Open Source Robotics Foundation + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest +import math +from ignition.math import Vector3d +from ignition.math import Spline + + +class TestSpline(unittest.TestCase): + + def test_spline(self): + s = Spline() + + s.add_point(Vector3d(0, 0, 0)) + self.assertEqual(1, s.point_count()) + + s.clear() + self.assertEqual(0, s.point_count()) + + s.add_point(Vector3d(0, 0, 0)) + self.assertTrue(s.point(0) == Vector3d(0, 0, 0)) + s.add_point(Vector3d(1, 1, 1)) + self.assertTrue(s.point(1) == Vector3d(1, 1, 1)) + + # update_point + self.assertFalse(s.update_point(2, Vector3d(2, 2, 2))) + + self.assertTrue(s.update_point(1, Vector3d(2, 2, 2))) + s.auto_calculate(False) + self.assertTrue(s.update_point(0, Vector3d(-1, -1, -1))) + s.auto_calculate(True) + + # interpolate + self.assertAlmostEqual(s.interpolate(0.0), Vector3d(-1, -1, -1)) + self.assertAlmostEqual(s.interpolate(0.5), Vector3d(0.5, 0.5, 0.5)) + self.assertAlmostEqual(s.interpolate(1.0), Vector3d(2, 2, 2)) + + # interpolate + s.add_point(Vector3d(4, 4, 4)) + self.assertAlmostEqual(s.interpolate(1, 0.2), + Vector3d(2.496, 2.496, 2.496)) + + def test_fixed_tangent(self): + s = Spline() + + # add_point + s.auto_calculate(False) + s.add_point(Vector3d(0, 0, 0)) + s.add_point(Vector3d(0, 0.5, 0), Vector3d(0, 1, 0)) + s.add_point(Vector3d(0.5, 1, 0), Vector3d(1, 0, 0)) + s.add_point(Vector3d(1, 1, 0), Vector3d(1, 0, 0)) + + # update_point + s.update_point(0, Vector3d(0, 0, 0), Vector3d(0, 1, 0)) + + s.auto_calculate(True) + + s.recalc_tangents() + + # interpolate + self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0, 0.25, 0)) + self.assertAlmostEqual(s.interpolate_tangent(0, 0.5), + Vector3d(0, 0.25, 0)) + self.assertAlmostEqual(s.interpolate(1, 0.5), + Vector3d(0.125, 0.875, 0)) + self.assertAlmostEqual(s.interpolate(2, 0.5), Vector3d(0.75, 1, 0)) + self.assertAlmostEqual(s.interpolate_tangent(2, 0.5), + Vector3d(0.25, 0, 0)) + + def test_arc_length(self): + s = Spline() + self.assertFalse(math.isfinite(s.arc_length())) + s.add_point(Vector3d(1, 1, 1), Vector3d(1, 1, 1)) + self.assertFalse(math.isfinite(s.arc_length(0))) + s.add_point(Vector3d(3, 3, 3), Vector3d(1, 1, 1)) + s.add_point(Vector3d(4, 4, 4), Vector3d(1, 1, 1)) + self.assertAlmostEqual(s.arc_length(0, 1.0), + 3.46410161513775, delta=1e-14) + self.assertAlmostEqual(s.arc_length(), 5.19615242270663, delta=1e-14) + self.assertAlmostEqual(s.arc_length(), s.arc_length(1.0)) + self.assertFalse(math.isfinite(s.arc_length(-1.0))) + self.assertFalse(math.isfinite(s.arc_length(4, 0.0))) + + def test_tension(self): + s = Spline() + + s.tension(0.1) + self.assertAlmostEqual(s.tension(), 0.1) + + def test_interpolate(self): + s = Spline() + self.assertFalse(s.interpolate(0, 0.1).is_finite()) + + s.add_point(Vector3d(0, 0, 0)) + self.assertAlmostEqual(s.interpolate(0, 0.1), Vector3d(0, 0, 0)) + self.assertFalse(s.interpolate_tangent(0.1).is_finite()) + + s.add_point(Vector3d(1, 2, 3)) + self.assertAlmostEqual(s.interpolate(0, 0.0), s.point(0)) + self.assertFalse(s.interpolate(0, -0.1).is_finite()) + self.assertAlmostEqual(s.interpolate_tangent(0, 0.0), s.tangent(0)) + + # Fast and slow call variations + self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0.5, 1.0, 1.5)) + self.assertAlmostEqual(s.interpolate(0, 1.0), s.point(1)) + self.assertAlmostEqual(s.interpolate_tangent(0, 0.5), + Vector3d(1.25, 2.5, 3.75)) + self.assertAlmostEqual(s.interpolate_tangent(0, 1.0), s.tangent(1)) + self.assertAlmostEqual(s.interpolate_mth_derivative(2, 0.5), + Vector3d(0, 0, 0)) + self.assertAlmostEqual(s.interpolate_mth_derivative(2, 1.0), + Vector3d(-3, -6, -9)) + self.assertAlmostEqual(s.interpolate_mth_derivative(3, 0.5), + Vector3d(-6, -12, -18)) + self.assertAlmostEqual(s.interpolate_mth_derivative(3, 1.0), + Vector3d(-6, -12, -18)) + self.assertAlmostEqual(s.interpolate_mth_derivative(4, 0.5), + Vector3d(0, 0, 0)) + self.assertAlmostEqual(s.interpolate_mth_derivative(4, 1.0), + Vector3d(0, 0, 0)) + + def test_point(self): + s = Spline() + self.assertFalse(s.point(0).is_finite()) + + def test_tangent(self): + s = Spline() + self.assertFalse(s.tangent(0).is_finite()) + + s.add_point(Vector3d(0, 0, 0)) + self.assertFalse(s.tangent(0).is_finite()) + + s.add_point(Vector3d(1, 0, 0)) + self.assertAlmostEqual(s.tangent(0), Vector3d(0.5, 0, 0)) + + s.add_point(Vector3d(1, 1, 0), Vector3d(-1, 1, 0)) + self.assertAlmostEqual(s.tangent(1), Vector3d(0.5, 0.5, 0)) + self.assertAlmostEqual(s.tangent(2), Vector3d(-1, 1, 0)) + + def test_recalc_tangents(self): + s = Spline() + + s.add_point(Vector3d(0, 0, 0)) + s.add_point(Vector3d(.4, .4, .4)) + s.add_point(Vector3d(0, 0, 0)) + + s.recalc_tangents() + + self.assertAlmostEqual(s.interpolate(0, 0.5), Vector3d(0.2, 0.2, 0.2)) + self.assertAlmostEqual(s.interpolate(1, 0.5), Vector3d(0.2, 0.2, 0.2)) + + +if __name__ == '__main__': + unittest.main() From 01a0c472eb8609d9e1e6691f578f89a4b06574bb Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Mon, 23 Aug 2021 10:05:04 -0300 Subject: [PATCH 09/11] Address comments. Signed-off-by: LolaSegura --- src/python/Color.i | 8 ++------ src/python/Color_TEST.py | 2 +- src/python/RollingMean.i | 11 +---------- src/python/RollingMean_TEST.py | 2 +- src/python/Spline.i | 7 +++---- src/python/Spline_TEST.py | 2 +- 6 files changed, 9 insertions(+), 23 deletions(-) diff --git a/src/python/Color.i b/src/python/Color.i index 4af1792d0..d916614e2 100644 --- a/src/python/Color.i +++ b/src/python/Color.i @@ -18,9 +18,9 @@ %module Color %{ #include -#include -#include #include +#include +#include %} %include "std_string.i" @@ -89,10 +89,6 @@ namespace ignition public: void G(const float _g); public: void B(const float _b); public: void A(const float _a); - private: float r = 0; - private: float g = 0; - private: float b = 0; - private: float a = 1; }; %extend Color{ diff --git a/src/python/Color_TEST.py b/src/python/Color_TEST.py index 91c5f9bf4..6a433b846 100644 --- a/src/python/Color_TEST.py +++ b/src/python/Color_TEST.py @@ -12,8 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest import math +import unittest from ignition.math import Color from ignition.math import Vector3f diff --git a/src/python/RollingMean.i b/src/python/RollingMean.i index d024b8b6f..be96792d4 100644 --- a/src/python/RollingMean.i +++ b/src/python/RollingMean.i @@ -35,15 +35,6 @@ namespace ignition public: void Clear(); public: void SetWindowSize(size_t _windowSize); public: size_t WindowSize() const; - - #ifdef _WIN32 - #pragma warning(push) - #pragma warning(disable: 4251) - #endif - private: std::unique_ptr dataPtr; - #ifdef _WIN32 - #pragma warning(pop) - #endif }; } -} \ No newline at end of file +} diff --git a/src/python/RollingMean_TEST.py b/src/python/RollingMean_TEST.py index 76a7795c3..90c7044f2 100644 --- a/src/python/RollingMean_TEST.py +++ b/src/python/RollingMean_TEST.py @@ -12,8 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest import math +import unittest from ignition.math import RollingMean diff --git a/src/python/Spline.i b/src/python/Spline.i index 1b6bfb0cf..cf086a577 100644 --- a/src/python/Spline.i +++ b/src/python/Spline.i @@ -17,10 +17,10 @@ %module spline %{ -#include +#include #include +#include #include -#include %} namespace ignition @@ -28,7 +28,6 @@ namespace ignition namespace math { class ControlPoint; - class SplinePrivate; class Spline { @@ -73,4 +72,4 @@ namespace ignition public: void RecalcTangents(); }; } -} \ No newline at end of file +} diff --git a/src/python/Spline_TEST.py b/src/python/Spline_TEST.py index 293fa5fbf..ea55efffe 100644 --- a/src/python/Spline_TEST.py +++ b/src/python/Spline_TEST.py @@ -12,8 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest import math +import unittest from ignition.math import Vector3d from ignition.math import Spline From ea69351d0139267391a561917f5b4feb9b3bd5db Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Mon, 23 Aug 2021 11:16:10 -0300 Subject: [PATCH 10/11] Alphasort Spline. Signed-off-by: LolaSegura --- src/python/Spline_TEST.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/python/Spline_TEST.py b/src/python/Spline_TEST.py index ea55efffe..a043ed5ac 100644 --- a/src/python/Spline_TEST.py +++ b/src/python/Spline_TEST.py @@ -14,8 +14,8 @@ import math import unittest -from ignition.math import Vector3d from ignition.math import Spline +from ignition.math import Vector3d class TestSpline(unittest.TestCase): From 1cd3bdf6fdfc5522167e8602056f10d4920eb1dd Mon Sep 17 00:00:00 2001 From: LolaSegura Date: Tue, 31 Aug 2021 10:28:35 -0300 Subject: [PATCH 11/11] Deletes extra swig_files inside CMakeList file. Signed-off-by: LolaSegura --- src/python/CMakeLists.txt | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt index 439a258d0..5544becb2 100644 --- a/src/python/CMakeLists.txt +++ b/src/python/CMakeLists.txt @@ -13,17 +13,6 @@ if (SWIG_FOUND) include_directories(${PROJECT_SOURCE_DIR}/include) include_directories(${PYTHON_INCLUDE_PATH}) - - set(swig_files - Angle - Color - GaussMarkovProcess - Rand - RollingMean - Spline - Vector2 - Vector3 - Vector4) endif() #################################