FreeCAD

1
# -*- coding: utf-8 -*-
2
# ***************************************************************************
3
# *   Copyright (c) 2021 sliptonic <shopinthewoods@gmail.com>               *
4
# *                                                                         *
5
# *   This program is free software; you can redistribute it and/or modify  *
6
# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
7
# *   as published by the Free Software Foundation; either version 2 of     *
8
# *   the License, or (at your option) any later version.                   *
9
# *   for detail see the LICENCE text file.                                 *
10
# *                                                                         *
11
# *   This program is distributed in the hope that it will be useful,       *
12
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
13
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
14
# *   GNU Library General Public License for more details.                  *
15
# *                                                                         *
16
# *   You should have received a copy of the GNU Library General Public     *
17
# *   License along with this program; if not, write to the Free Software   *
18
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
19
# *   USA                                                                   *
20
# *                                                                         *
21
# ***************************************************************************
22

23
import FreeCAD
24
import Path
25
import Path.Base.Generator.rotation as generator
26
import Tests.PathTestUtils as PathTestUtils
27
import numpy as np
28

29
Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule())
30
Path.Log.trackModule(Path.Log.thisModule())
31

32

33
class TestPathRotationGenerator(PathTestUtils.PathTestBase):
34
    def test00(self):
35
        """Test relAngle function"""
36
        v = FreeCAD.Vector(0.5, 0.5, 0.5)
37
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.x), 45))
38
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.y), 45))
39
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.z), 45))
40

41
        v = FreeCAD.Vector(-0.5, 0.5, 0.5)
42
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.x), 135))
43
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.y), -45))
44
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.z), 45))
45

46
        v = FreeCAD.Vector(-0.5, -0.5, -0.5)
47
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.x), -135))
48
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.y), -135))
49
        self.assertTrue(np.isclose(generator.relAngle(v, generator.refAxis.z), -135))
50

51
    def test10(self):
52
        """Test Basic Rotation Generator Return"""
53
        v1 = FreeCAD.Vector(0.0, 0.0, 1.0)
54
        args = {
55
            "normalVector": v1,
56
            "aMin": -360,
57
            "aMax": 360,
58
            "cMin": -360,
59
            "cMax": 360,
60
            "compound": True,
61
        }
62

63
        result = generator.generate(**args)
64

65
        self.assertTrue(type(result) is list)
66
        self.assertTrue(len(result) == 1)
67
        self.assertTrue(type(result[0]) is Path.Command)
68

69
        command = result[0]
70
        self.assertTrue(np.isclose(command.Parameters["A"], 0))
71
        self.assertTrue(np.isclose(command.Parameters["C"], 0))
72

73
        args["compound"] = False
74
        result = generator.generate(**args)
75
        self.assertTrue(len(result) == 2)
76

77
        Path.Log.debug(result)
78

79
    def test20(self):
80
        """Test non-zero rotation"""
81
        v1 = FreeCAD.Vector(0.5, 0.5, 0.5)
82
        args = {
83
            "normalVector": v1,
84
            "aMin": -360,
85
            "aMax": 360,
86
            "cMin": -360,
87
            "cMax": 360,
88
            "compound": True,
89
        }
90

91
        result = generator.generate(**args)
92

93
        command = result[0]
94
        Path.Log.debug(command.Parameters)
95
        self.assertTrue(np.isclose(command.Parameters["A"], 54.736))
96
        self.assertTrue(np.isclose(command.Parameters["C"], 45))
97

98
        Path.Log.track(result)
99

100
    def test30(self):
101
        """Test A limits"""
102
        v1 = FreeCAD.Vector(0.5, 0.5, 0.5)
103

104
        args = {"normalVector": v1, "cMin": -360, "cMax": 360, "compound": True}
105

106
        # Constrain a axis rotation negative
107
        args["aMin"] = -90
108
        args["aMax"] = 0
109

110
        result = generator.generate(**args)
111
        Path.Log.debug(result)
112

113
        command = result[0]
114
        self.assertTrue(np.isclose(command.Parameters["A"], -54.736))
115
        self.assertTrue(np.isclose(command.Parameters["C"], -135))
116

117
        # Constrain a axis rotation positive
118
        args["aMin"] = 0
119
        args["aMax"] = 90
120

121
        result = generator.generate(**args)
122
        Path.Log.debug(result)
123

124
        command = result[0]
125
        self.assertTrue(np.isclose(command.Parameters["A"], 54.736))
126
        self.assertTrue(np.isclose(command.Parameters["C"], 45))
127

128
    def test40(self):
129
        """Test C limits"""
130
        v1 = FreeCAD.Vector(0.5, 0.5, 0.5)
131

132
        args = {"normalVector": v1, "aMin": -360, "aMax": 360, "compound": True}
133

134
        # Constrain a axis rotation negative
135
        args["cMin"] = -180
136
        args["cMax"] = 0
137

138
        result = generator.generate(**args)
139
        Path.Log.debug(result)
140

141
        command = result[0]
142
        self.assertTrue(np.isclose(command.Parameters["A"], -54.736))
143
        self.assertTrue(np.isclose(command.Parameters["C"], -135))
144

145
        # Constrain a axis rotation positive
146
        args["cMin"] = 0
147
        args["cMax"] = 180
148

149
        result = generator.generate(**args)
150
        Path.Log.debug(result)
151

152
        command = result[0]
153
        self.assertTrue(np.isclose(command.Parameters["A"], 54.736))
154
        self.assertTrue(np.isclose(command.Parameters["C"], 45))
155

156
    def test50(self):
157
        """Test handling of no valid solution"""
158
        v1 = FreeCAD.Vector(0.5, 0.5, 0.5)
159
        args = {
160
            "normalVector": v1,
161
            "aMin": 0,
162
            "aMax": 10,
163
            "cMin": 0,
164
            "cMax": 10,
165
            "compound": True,
166
        }
167

168
        self.assertRaises(ValueError, generator.generate, **args)
169