py api was raising SystemError exception incorrectly, this is intended for internal...
[blender.git] / source / blender / python / generic / mathutils.c
1 /* 
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
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 General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * This is a new part of Blender.
24  *
25  * Contributor(s): Joseph Gilbert, Campbell Barton
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 /* Note: Changes to Mathutils since 2.4x
31  * use radians rather then degrees
32  * - Mathutils.Vector/Euler/Quaternion(), now only take single sequence arguments.
33  * - Mathutils.MidpointVecs --> vector.lerp(other, fac)
34  * - Mathutils.AngleBetweenVecs --> vector.angle(other)
35  * - Mathutils.ProjectVecs --> vector.project(other)
36  * - Mathutils.DifferenceQuats --> quat.difference(other)
37  * - Mathutils.Slerp --> quat.slerp(other, fac)
38  * - Mathutils.Rand: removed, use pythons random module
39  * - Mathutils.RotationMatrix(angle, size, axis_flag, axis) --> Mathutils.RotationMatrix(angle, size, axis); merge axis & axis_flag args
40  * - Mathutils.OrthoProjectionMatrix(plane, size, axis) --> Mathutils.OrthoProjectionMatrix(axis, size); merge axis & plane args
41  * - Mathutils.ShearMatrix(plane, factor, size) --> Mathutils.ShearMatrix(plane, size, factor); swap size & factor args, match other constructors.
42  * - Matrix.scalePart --> Matrix.scale_part
43  * - Matrix.translationPart --> Matrix.translation_part
44  * - Matrix.rotationPart --> Matrix.rotation_part
45  * - mathutils.Matrix.Shear(plane, fac, size), now takes a pair of floats for 3x3 or 4x4 shear factor.
46  * - toMatrix --> to_matrix
47  * - toEuler --> to_euler
48  * - toQuat --> to_quat
49  * - Vector.toTrackQuat --> Vector.to_track_quat
50  * - Vector.rotate(axis, angle) --> rotate(other), where other can be Euler/Quaternion/Matrix.
51  * - Quaternion * Quaternion --> cross product (not dot product)
52  * - Euler.rotate(angle, axis) --> Euler.rotate_axis(axis, angle)
53  * - Euler.unique() *removed*, not a standard function only toggled different rotations.
54  * - Matrix.rotation_part() -> to_3x3()
55  * - Matrix.scale_part() -> to_scale()
56  * - Matrix.translation_part() -> to_translation()
57  * - Matrix.resize4x4() -> resize_4x4()
58  * - Euler.to_quat() -> to_quaternion()
59  * - Matrix.to_quat() -> to_quaternion()
60  * resizing nolonger returns the resized value.
61  * - Vector.resize2D -> resize_2d
62  * - Vector.resize3D -> resize_3d
63  * - Vector.resize4D -> resize_4d
64  * added new functions.
65  * - Vector.to_2d()
66  * - Vector.to_3d()
67  * - Vector.to_4d()
68  * moved into class functions.
69  * - Mathutils.RotationMatrix -> mathutils.Matrix.Rotation
70  * - Mathutils.ScaleMatrix -> mathutils.Matrix.Scale
71  * - Mathutils.ShearMatrix -> mathutils.Matrix.Shear
72  * - Mathutils.TranslationMatrix -> mathutils.Matrix.Translation
73  * - Mathutils.OrthoProjectionMatrix -> mathutils.Matrix.OrthoProjection
74  *
75  * Moved to Geometry module: Intersect, TriangleArea, TriangleNormal, QuadNormal, LineIntersect
76  * - geometry.Intersect -> intersect_ray_tri
77  * - geometry.ClosestPointOnLine -> intersect_point_line
78  * - geometry.PointInTriangle2D -> intersect_point_tri_2d
79  * - geometry.PointInQuad2D -> intersect_point_quad_2d
80  * - geometry.LineIntersect -> intersect_line_line
81  * - geometry.LineIntersect2D -> intersect_line_line_2d
82  * - geometry.BezierInterp -> interpolate_bezier
83  * - geometry.TriangleArea -> area_tri
84  * - geometry.QuadNormal, TriangleNormal -> normal
85  * - geometry.PolyFill -> tesselate_polygon
86  * - geometry.BoxPack2D -> box_pack_2d
87  * - geometry.BarycentricTransform -> barycentric_transform
88  */
89
90 #include <Python.h>
91
92 #include "mathutils.h"
93
94 #include "BLI_math.h"
95 #include "BLI_utildefines.h"
96
97
98
99 //-------------------------DOC STRINGS ---------------------------
100 static char M_Mathutils_doc[] =
101 "This module provides access to matrices, eulers, quaternions and vectors."
102 ;
103 static int mathutils_array_parse_fast(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
104 {
105         PyObject *value_fast= NULL;
106         PyObject *item;
107
108         int i, size;
109
110         /* non list/tuple cases */
111         if(!(value_fast=PySequence_Fast(value, error_prefix))) {
112                 /* PySequence_Fast sets the error */
113                 return -1;
114         }
115
116         size= PySequence_Fast_GET_SIZE(value_fast);
117
118         if(size > array_max || size < array_min) {
119                 if (array_max == array_min)     PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
120                 else                                            PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
121                 Py_DECREF(value_fast);
122                 return -1;
123         }
124
125         i= size;
126         do {
127                 i--;
128                 if(((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0) && PyErr_Occurred()) {
129                         PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d expected a number, found '%.200s' type, ", error_prefix, i, Py_TYPE(item)->tp_name);
130                         Py_DECREF(value_fast);
131                         return -1;
132                 }
133         } while(i);
134
135         Py_XDECREF(value_fast);
136         return size;
137 }
138
139 /* helper functionm returns length of the 'value', -1 on error */
140 int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
141 {
142 #if 1 /* approx 6x speedup for mathutils types */
143         int size;
144
145         if(     (VectorObject_Check(value) && (size= ((VectorObject *)value)->size)) ||
146                 (EulerObject_Check(value) && (size= 3)) ||
147                 (QuaternionObject_Check(value) && (size= 4)) ||
148                 (ColorObject_Check(value) && (size= 3))
149         ) {
150                 if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
151                         return -1;
152                 }
153
154                 if(size > array_max || size < array_min) {
155                         if (array_max == array_min)     PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
156                         else                                            PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
157                         return -1;
158                 }
159
160                 memcpy(array, ((BaseMathObject *)value)->data, size * sizeof(float));
161                 return size;
162         }
163         else
164 #endif
165         {
166                 return mathutils_array_parse_fast(array, array_min, array_max, value, error_prefix);
167         }
168 }
169
170 int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error_prefix)
171 {
172         if(EulerObject_Check(value)) {
173                 if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
174                         return -1;
175                 }
176                 else {
177                         eulO_to_mat3(rmat, ((EulerObject *)value)->eul, ((EulerObject *)value)->order);
178                         return 0;
179                 }
180         }
181         else if (QuaternionObject_Check(value)) {
182                 if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
183                         return -1;
184                 }
185                 else {
186                         float tquat[4];
187                         normalize_qt_qt(tquat, ((QuaternionObject *)value)->quat);
188                         quat_to_mat3(rmat, tquat);
189                         return 0;
190                 }
191         }
192         else if (MatrixObject_Check(value)) {
193                 if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
194                         return -1;
195                 }
196                 else if(((MatrixObject *)value)->col_size < 3 || ((MatrixObject *)value)->row_size < 3) {
197                         PyErr_Format(PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
198                         return -1;
199                 }
200                 else {
201                         matrix_as_3x3(rmat, (MatrixObject *)value);
202                         normalize_m3(rmat);
203                         return 0;
204                 }
205         }
206         else {
207                 PyErr_Format(PyExc_TypeError, "%.200s: expected a Euler, Quaternion or Matrix type, found %.200s", error_prefix, Py_TYPE(value)->tp_name);
208                 return -1;
209         }
210 }
211
212
213 //----------------------------------MATRIX FUNCTIONS--------------------
214
215
216 /* Utility functions */
217
218 // LomontRRDCompare4, Ever Faster Float Comparisons by Randy Dillon
219 #define SIGNMASK(i) (-(int)(((unsigned int)(i))>>31))
220
221 int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
222 {       // solid, fast routine across all platforms
223         // with constant time behavior
224         int ai = *(int *)(&af);
225         int bi = *(int *)(&bf);
226         int test = SIGNMASK(ai^bi);
227         int diff, v1, v2;
228
229         assert((0 == test) || (0xFFFFFFFF == test));
230         diff = (ai ^ (test & 0x7fffffff)) - bi;
231         v1 = maxDiff + diff;
232         v2 = maxDiff - diff;
233         return (v1|v2) >= 0;
234 }
235
236 /*---------------------- EXPP_VectorsAreEqual -------------------------
237   Builds on EXPP_FloatsAreEqual to test vectors */
238 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
239 {
240         int x;
241         for (x=0; x< size; x++){
242                 if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
243                         return 0;
244         }
245         return 1;
246 }
247
248
249 /* Mathutils Callbacks */
250
251 /* for mathutils internal use only, eventually should re-alloc but to start with we only have a few users */
252 static Mathutils_Callback *mathutils_callbacks[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
253
254 int Mathutils_RegisterCallback(Mathutils_Callback *cb)
255 {
256         int i;
257         
258         /* find the first free slot */
259         for(i= 0; mathutils_callbacks[i]; i++) {
260                 if(mathutils_callbacks[i]==cb) /* already registered? */
261                         return i;
262         }
263         
264         mathutils_callbacks[i] = cb;
265         return i;
266 }
267
268 /* use macros to check for NULL */
269 int _BaseMathObject_ReadCallback(BaseMathObject *self)
270 {
271         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
272         if(cb->get(self, self->cb_subtype))
273                 return 1;
274
275         if(!PyErr_Occurred())
276                 PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
277         return 0;
278 }
279
280 int _BaseMathObject_WriteCallback(BaseMathObject *self)
281 {
282         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
283         if(cb->set(self, self->cb_subtype))
284                 return 1;
285
286         if(!PyErr_Occurred())
287                 PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
288         return 0;
289 }
290
291 int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
292 {
293         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
294         if(cb->get_index(self, self->cb_subtype, index))
295                 return 1;
296
297         if(!PyErr_Occurred())
298                 PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
299         return 0;
300 }
301
302 int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
303 {
304         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
305         if(cb->set_index(self, self->cb_subtype, index))
306                 return 1;
307
308         if(!PyErr_Occurred())
309                 PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
310         return 0;
311 }
312
313 /* BaseMathObject generic functions for all mathutils types */
314 char BaseMathObject_Owner_doc[] = "The item this is wrapping or None  (readonly).";
315 PyObject *BaseMathObject_getOwner(BaseMathObject *self, void *UNUSED(closure))
316 {
317         PyObject *ret= self->cb_user ? self->cb_user : Py_None;
318         Py_INCREF(ret);
319         return ret;
320 }
321
322 char BaseMathObject_Wrapped_doc[] = "True when this object wraps external data (readonly).\n\n:type: boolean";
323 PyObject *BaseMathObject_getWrapped(BaseMathObject *self, void *UNUSED(closure))
324 {
325         return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1:0);
326 }
327
328 void BaseMathObject_dealloc(BaseMathObject * self)
329 {
330         /* only free non wrapped */
331         if(self->wrapped != Py_WRAP)
332                 PyMem_Free(self->data);
333
334         Py_XDECREF(self->cb_user);
335         Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
336 }
337
338 /*----------------------------MODULE INIT-------------------------*/
339 static struct PyMethodDef M_Mathutils_methods[] = {
340         {NULL, NULL, 0, NULL}
341 };
342
343 static struct PyModuleDef M_Mathutils_module_def = {
344         PyModuleDef_HEAD_INIT,
345         "mathutils",  /* m_name */
346         M_Mathutils_doc,  /* m_doc */
347         0,  /* m_size */
348         M_Mathutils_methods,  /* m_methods */
349         NULL,  /* m_reload */
350         NULL,  /* m_traverse */
351         NULL,  /* m_clear */
352         NULL,  /* m_free */
353 };
354
355 PyMODINIT_FUNC BPyInit_mathutils(void)
356 {
357         PyObject *submodule;
358         PyObject *item;
359
360         if( PyType_Ready( &vector_Type ) < 0 )
361                 return NULL;
362         if( PyType_Ready( &matrix_Type ) < 0 )
363                 return NULL;    
364         if( PyType_Ready( &euler_Type ) < 0 )
365                 return NULL;
366         if( PyType_Ready( &quaternion_Type ) < 0 )
367                 return NULL;
368         if( PyType_Ready( &color_Type ) < 0 )
369                 return NULL;
370
371         submodule = PyModule_Create(&M_Mathutils_module_def);
372         
373         /* each type has its own new() function */
374         PyModule_AddObject( submodule, "Vector",                (PyObject *)&vector_Type );
375         PyModule_AddObject( submodule, "Matrix",                (PyObject *)&matrix_Type );
376         PyModule_AddObject( submodule, "Euler",                 (PyObject *)&euler_Type );
377         PyModule_AddObject( submodule, "Quaternion",    (PyObject *)&quaternion_Type );
378         PyModule_AddObject( submodule, "Color",                 (PyObject *)&color_Type );
379         
380         /* submodule */
381         PyModule_AddObject( submodule, "geometry",              (item=BPyInit_mathutils_geometry()));
382         /* XXX, python doesnt do imports with this usefully yet
383          * 'from mathutils.geometry import PolyFill'
384          * ...fails without this. */
385         PyDict_SetItemString(PyThreadState_GET()->interp->modules, "mathutils.geometry", item);
386         Py_INCREF(item);
387
388         mathutils_matrix_vector_cb_index= Mathutils_RegisterCallback(&mathutils_matrix_vector_cb);
389
390         return submodule;
391 }