patch [#25027] formatting mathutils.geometry module docs for sphinx
[blender.git] / source / blender / python / generic / mathutils_geometry.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 #include "mathutils_geometry.h"
31
32 /* Used for PolyFill */
33 #include "BKE_displist.h"
34 #include "MEM_guardedalloc.h"
35 #include "BLI_blenlib.h"
36  
37 #include "BKE_utildefines.h"
38 #include "BKE_curve.h"
39 #include "BLI_boxpack2d.h"
40 #include "BLI_math.h"
41
42 #define SWAP_FLOAT(a,b,tmp) tmp=a; a=b; b=tmp
43 #define eps 0.000001
44
45
46 /*-------------------------DOC STRINGS ---------------------------*/
47 static char M_Geometry_doc[] = "The Blender geometry module\n\n";
48 static char M_Geometry_Intersect_doc[] =
49 ".. function:: Intersect(v1, v2, v3, ray, orig, clip=True)\n"
50 "\n"
51 "   Returns the intersection between a ray and a triangle, if possible, returns None otherwise.\n"
52 "\n"
53 "   :rtype: boolean\n"
54 "   :arg v1: Point1\n"
55 "   :type v1: :class:`mathutils.Vector`\n"
56 "   :arg v2: Point2\n"
57 "   :type v2: :class:`mathutils.Vector`\n"
58 "   :arg v3: Point3\n"
59 "   :type v3: :class:`mathutils.Vector`\n"
60 "   :arg ray: Direction of the projection\n"
61 "   :type ray: :class:`mathutils.Vector`\n"
62 "   :arg orig: Origin\n"
63 "   :type orig: :class:`mathutils.Vector`\n"
64 "   :arg clip: Clip by the ray length\n"
65 "   :type clip: boolean\n";
66
67 static char M_Geometry_TriangleArea_doc[] =
68 ".. function:: TriangleArea(v1, v2, v3)\n"
69 "\n"
70 "   Returns the area size of the 2D or 3D triangle defined.\n"
71 "\n"
72 "   :rtype: float\n"
73 "   :arg v1: Point1\n"
74 "   :type v1: :class:`mathutils.Vector`\n"
75 "   :arg v2: Point2\n"
76 "   :type v2: :class:`mathutils.Vector`\n"
77 "   :arg v3: Point3\n"
78 "   :type v3: :class:`mathutils.Vector`\n";
79
80 static char M_Geometry_TriangleNormal_doc[] = 
81 ".. function:: TriangleNormal(v1, v2, v3)\n"
82 "\n"
83 "   Returns the normal of the 3D triangle defined.\n"
84 "\n"
85 "   :rtype: :class:`mathutils.Vector`\n"
86 "   :arg v1: Point1\n"
87 "   :type v1: :class:`mathutils.Vector`\n"
88 "   :arg v2: Point2\n"
89 "   :type v2: :class:`mathutils.Vector`\n"
90 "   :arg v3: Point3\n"
91 "   :type v3: :class:`mathutils.Vector`\n";
92
93 static char M_Geometry_QuadNormal_doc[] = 
94 ".. function:: QuadNormal(v1, v2, v3, v4)\n"
95 "\n"
96 "   Returns the normal of the 3D quad defined.\n"
97 "\n"
98 "   :rtype: :class:`mathutils.Vector`\n"
99 "   :arg v1: Point1\n"
100 "   :type v1: :class:`mathutils.Vector`\n"
101 "   :arg v2: Point2\n"
102 "   :type v2: :class:`mathutils.Vector`\n"
103 "   :arg v3: Point3\n"
104 "   :type v3: :class:`mathutils.Vector`\n"
105 "   :arg v4: Point4\n"
106 "   :type v4: :class:`mathutils.Vector`\n";
107
108 static char M_Geometry_LineIntersect_doc[] = 
109 ".. function:: LineIntersect(v1, v2, v3, v4)\n"
110 "\n"
111 "   Returns a tuple with the points on each line respectively closest to the other.\n"
112 "\n"
113 "   :rtype: tuple with elements being of type :class:`mathutils.Vector`\n"
114 "   :arg v1: First point of the first line\n"
115 "   :type v1: :class:`mathutils.Vector`\n"
116 "   :arg v2: Second point of the first line\n"
117 "   :type v2: :class:`mathutils.Vector`\n"
118 "   :arg v3: First point of the second line\n"
119 "   :type v3: :class:`mathutils.Vector`\n"
120 "   :arg v4: Second point of the second line\n"
121 "   :type v4: :class:`mathutils.Vector`\n";
122
123 static char M_Geometry_PolyFill_doc[] = 
124 ".. function:: PolyFill(veclist_list)\n"
125 "\n"
126 "   Takes a list of polylines (each point a vector) and returns the point indicies for a polyline filled with triangles.\n"
127 "\n"
128 "   :rtype: list\n"
129 "   :arg veclist_list: list of polylines\n";
130
131 static char M_Geometry_LineIntersect2D_doc[] = 
132 ".. function:: LineIntersect2D(lineA_p1, lineA_p2, lineB_p1, lineB_p2)\n"
133 "\n"
134 "   Takes 2 lines (as 4 vectors) and returns a vector for their point of intersection or None.\n"
135 "\n"
136 "   :rtype: :class:`mathutils.Vector`\n"
137 "   :arg lineA_p1: First point of the first line\n"
138 "   :type lineA_p1: :class:`mathutils.Vector`\n"
139 "   :arg lineA_p2: Second point of the first line\n"
140 "   :type lineA_p2: :class:`mathutils.Vector`\n"
141 "   :arg lineB_p1: First point of the second line\n"
142 "   :type lineB_p1: :class:`mathutils.Vector`\n"
143 "   :arg lineB_p2: Second point of the second line\n"
144 "   :type lineB_p2: :class:`mathutils.Vector`\n";
145
146 static char M_Geometry_ClosestPointOnLine_doc[] =
147 ".. function:: ClosestPointOnLine(pt, line_p1, line_p2)\n"
148 "\n"
149 "   Takes a point and a line and returns a tuple with the closest point on the line and its distance from the first point of the line as a percentage of the length of the line.\n"
150 "\n"
151 "   :rtype: (:class:`mathutils.Vector`, float)\n"
152 "   :arg pt: Point\n"
153 "   :type pt: :class:`mathutils.Vector`\n"
154 "   :arg line_p1: First point of the line\n"
155 "   :type line_p1: :class:`mathutils.Vector`\n"
156 "   :arg line_p1: Second point of the line\n"
157 "   :type line_p1: :class:`mathutils.Vector`\n";
158
159 static char M_Geometry_PointInTriangle2D_doc[] = 
160 ".. function:: PointInTriangle2D(pt, tri_p1, tri_p2, tri_p3)\n"
161 "\n"
162 "   Takes 4 vectors (using only the x and y coordinates): one is the point and the next 3 define the triangle. Returns 1 if the point is within the triangle, otherwise 0.\n"
163 "\n"
164 "   :rtype: int\n"
165 "   :arg pt: Point\n"
166 "   :type v1: :class:`mathutils.Vector`\n"
167 "   :arg tri_p1: First point of the triangle\n"
168 "   :type tri_p1: :class:`mathutils.Vector`\n"
169 "   :arg tri_p2: Second point of the triangle\n"
170 "   :type tri_p2: :class:`mathutils.Vector`\n"
171 "   :arg tri_p3: Third point of the triangle\n"
172 "   :type tri_p3: :class:`mathutils.Vector`\n";
173
174 static char M_Geometry_PointInQuad2D_doc[] =
175 ".. function:: PointInQuad2D(pt, quad_p1, quad_p2, quad_p3, quad_p4)\n"
176 "\n"
177 "   Takes 5 vectors (using only the x and y coordinates): one is the point and the next 4 define the quad, only the x and y are used from the vectors. Returns 1 if the point is within the quad, otherwise 0.\n"
178 "\n"
179 "   :rtype: int\n"
180 "   :arg pt: Point\n"
181 "   :type v1: :class:`mathutils.Vector`\n"
182 "   :arg quad_p1: First point of the quad\n"
183 "   :type quad_p1: :class:`mathutils.Vector`\n"
184 "   :arg quad_p2: Second point of the quad\n"
185 "   :type quad_p2: :class:`mathutils.Vector`\n"
186 "   :arg quad_p3: Third point of the quad\n"
187 "   :type quad_p3: :class:`mathutils.Vector`\n"
188 "   :arg quad_p4: Forth point of the quad\n"
189 "   :type quad_p4: :class:`mathutils.Vector`\n";
190
191 static char M_Geometry_BoxPack2D_doc[] = "";
192 static char M_Geometry_BezierInterp_doc[] = "";
193 static char M_Geometry_BarycentricTransform_doc[] = "";
194
195 //---------------------------------INTERSECTION FUNCTIONS--------------------
196 //----------------------------------geometry.Intersect() -------------------
197 static PyObject *M_Geometry_Intersect(PyObject *UNUSED(self), PyObject* args)
198 {
199         VectorObject *ray, *ray_off, *vec1, *vec2, *vec3;
200         float dir[3], orig[3], v1[3], v2[3], v3[3], e1[3], e2[3], pvec[3], tvec[3], qvec[3];
201         float det, inv_det, u, v, t;
202         int clip = 1;
203
204         if(!PyArg_ParseTuple(args, "O!O!O!O!O!|i", &vector_Type, &vec1, &vector_Type, &vec2, &vector_Type, &vec3, &vector_Type, &ray, &vector_Type, &ray_off , &clip)) {
205                 PyErr_SetString(PyExc_TypeError, "expected 5 vector types" );
206                 return NULL;
207         }
208         if(vec1->size != 3 || vec2->size != 3 || vec3->size != 3 || ray->size != 3 || ray_off->size != 3) {
209                 PyErr_SetString(PyExc_TypeError, "only 3D vectors for all parameters");
210                 return NULL;
211         }
212
213         if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2) || !BaseMath_ReadCallback(vec3) || !BaseMath_ReadCallback(ray) || !BaseMath_ReadCallback(ray_off))
214                 return NULL;
215
216         VECCOPY(v1, vec1->vec);
217         VECCOPY(v2, vec2->vec);
218         VECCOPY(v3, vec3->vec);
219
220         VECCOPY(dir, ray->vec);
221         normalize_v3(dir);
222
223         VECCOPY(orig, ray_off->vec);
224
225         /* find vectors for two edges sharing v1 */
226         sub_v3_v3v3(e1, v2, v1);
227         sub_v3_v3v3(e2, v3, v1);
228
229         /* begin calculating determinant - also used to calculated U parameter */
230         cross_v3_v3v3(pvec, dir, e2);
231
232         /* if determinant is near zero, ray lies in plane of triangle */
233         det = dot_v3v3(e1, pvec);
234
235         if (det > -0.000001 && det < 0.000001) {
236                 Py_RETURN_NONE;
237         }
238
239         inv_det = 1.0f / det;
240
241         /* calculate distance from v1 to ray origin */
242         sub_v3_v3v3(tvec, orig, v1);
243
244         /* calculate U parameter and test bounds */
245         u = dot_v3v3(tvec, pvec) * inv_det;
246         if (clip && (u < 0.0f || u > 1.0f)) {
247                 Py_RETURN_NONE;
248         }
249
250         /* prepare to test the V parameter */
251         cross_v3_v3v3(qvec, tvec, e1);
252
253         /* calculate V parameter and test bounds */
254         v = dot_v3v3(dir, qvec) * inv_det;
255
256         if (clip && (v < 0.0f || u + v > 1.0f)) {
257                 Py_RETURN_NONE;
258         }
259
260         /* calculate t, ray intersects triangle */
261         t = dot_v3v3(e2, qvec) * inv_det;
262
263         mul_v3_fl(dir, t);
264         add_v3_v3v3(pvec, orig, dir);
265
266         return newVectorObject(pvec, 3, Py_NEW, NULL);
267 }
268 //----------------------------------geometry.LineIntersect() -------------------
269 /* Line-Line intersection using algorithm from mathworld.wolfram.com */
270 static PyObject *M_Geometry_LineIntersect(PyObject *UNUSED(self), PyObject* args)
271 {
272         PyObject * tuple;
273         VectorObject *vec1, *vec2, *vec3, *vec4;
274         float v1[3], v2[3], v3[3], v4[3], i1[3], i2[3];
275
276         if( !PyArg_ParseTuple( args, "O!O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2, &vector_Type, &vec3, &vector_Type, &vec4 ) ) {
277                 PyErr_SetString(PyExc_TypeError, "expected 4 vector types" );
278                 return NULL;
279         }
280         if( vec1->size != vec2->size || vec1->size != vec3->size || vec3->size != vec2->size) {
281                 PyErr_SetString(PyExc_TypeError,"vectors must be of the same size" );
282                 return NULL;
283         }
284
285         if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2) || !BaseMath_ReadCallback(vec3) || !BaseMath_ReadCallback(vec4))
286                 return NULL;
287
288         if( vec1->size == 3 || vec1->size == 2) {
289                 int result;
290
291                 if (vec1->size == 3) {
292                         VECCOPY(v1, vec1->vec);
293                         VECCOPY(v2, vec2->vec);
294                         VECCOPY(v3, vec3->vec);
295                         VECCOPY(v4, vec4->vec);
296                 }
297                 else {
298                         v1[0] = vec1->vec[0];
299                         v1[1] = vec1->vec[1];
300                         v1[2] = 0.0f;
301
302                         v2[0] = vec2->vec[0];
303                         v2[1] = vec2->vec[1];
304                         v2[2] = 0.0f;
305
306                         v3[0] = vec3->vec[0];
307                         v3[1] = vec3->vec[1];
308                         v3[2] = 0.0f;
309
310                         v4[0] = vec4->vec[0];
311                         v4[1] = vec4->vec[1];
312                         v4[2] = 0.0f;
313                 }
314
315                 result = isect_line_line_v3(v1, v2, v3, v4, i1, i2);
316
317                 if (result == 0) {
318                         /* colinear */
319                         Py_RETURN_NONE;
320                 }
321                 else {
322                         tuple = PyTuple_New( 2 );
323                         PyTuple_SetItem( tuple, 0, newVectorObject(i1, vec1->size, Py_NEW, NULL) );
324                         PyTuple_SetItem( tuple, 1, newVectorObject(i2, vec1->size, Py_NEW, NULL) );
325                         return tuple;
326                 }
327         }
328         else {
329                 PyErr_SetString(PyExc_TypeError, "2D/3D vectors only" );
330                 return NULL;
331         }
332 }
333
334
335
336 //---------------------------------NORMALS FUNCTIONS--------------------
337 //----------------------------------geometry.QuadNormal() -------------------
338 static PyObject *M_Geometry_QuadNormal(PyObject *UNUSED(self), PyObject* args)
339 {
340         VectorObject *vec1;
341         VectorObject *vec2;
342         VectorObject *vec3;
343         VectorObject *vec4;
344         float v1[3], v2[3], v3[3], v4[3], e1[3], e2[3], n1[3], n2[3];
345
346         if( !PyArg_ParseTuple( args, "O!O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2, &vector_Type, &vec3, &vector_Type, &vec4 ) ) {
347                 PyErr_SetString(PyExc_TypeError, "expected 4 vector types" );
348                 return NULL;
349         }
350         if( vec1->size != vec2->size || vec1->size != vec3->size || vec1->size != vec4->size) {
351                 PyErr_SetString(PyExc_TypeError,"vectors must be of the same size" );
352                 return NULL;
353         }
354         if( vec1->size != 3 ) {
355                 PyErr_SetString(PyExc_TypeError, "only 3D vectors" );
356                 return NULL;
357         }
358
359         if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2) || !BaseMath_ReadCallback(vec3) || !BaseMath_ReadCallback(vec4))
360                 return NULL;
361
362         VECCOPY(v1, vec1->vec);
363         VECCOPY(v2, vec2->vec);
364         VECCOPY(v3, vec3->vec);
365         VECCOPY(v4, vec4->vec);
366
367         /* find vectors for two edges sharing v2 */
368         sub_v3_v3v3(e1, v1, v2);
369         sub_v3_v3v3(e2, v3, v2);
370
371         cross_v3_v3v3(n1, e2, e1);
372         normalize_v3(n1);
373
374         /* find vectors for two edges sharing v4 */
375         sub_v3_v3v3(e1, v3, v4);
376         sub_v3_v3v3(e2, v1, v4);
377
378         cross_v3_v3v3(n2, e2, e1);
379         normalize_v3(n2);
380
381         /* adding and averaging the normals of both triangles */
382         add_v3_v3v3(n1, n2, n1);
383         normalize_v3(n1);
384
385         return newVectorObject(n1, 3, Py_NEW, NULL);
386 }
387
388 //----------------------------geometry.TriangleNormal() -------------------
389 static PyObject *M_Geometry_TriangleNormal(PyObject *UNUSED(self), PyObject* args)
390 {
391         VectorObject *vec1, *vec2, *vec3;
392         float v1[3], v2[3], v3[3], e1[3], e2[3], n[3];
393
394         if( !PyArg_ParseTuple( args, "O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2, &vector_Type, &vec3 ) ) {
395                 PyErr_SetString(PyExc_TypeError, "expected 3 vector types" );
396                 return NULL;
397         }
398         if( vec1->size != vec2->size || vec1->size != vec3->size ) {
399                 PyErr_SetString(PyExc_TypeError, "vectors must be of the same size" );
400                 return NULL;
401         }
402         if( vec1->size != 3 ) {
403                 PyErr_SetString(PyExc_TypeError, "only 3D vectors" );
404                 return NULL;
405         }
406
407         if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2) || !BaseMath_ReadCallback(vec3))
408                 return NULL;
409
410         VECCOPY(v1, vec1->vec);
411         VECCOPY(v2, vec2->vec);
412         VECCOPY(v3, vec3->vec);
413
414         /* find vectors for two edges sharing v2 */
415         sub_v3_v3v3(e1, v1, v2);
416         sub_v3_v3v3(e2, v3, v2);
417
418         cross_v3_v3v3(n, e2, e1);
419         normalize_v3(n);
420
421         return newVectorObject(n, 3, Py_NEW, NULL);
422 }
423
424 //--------------------------------- AREA FUNCTIONS--------------------
425 //----------------------------------geometry.TriangleArea() -------------------
426 static PyObject *M_Geometry_TriangleArea(PyObject *UNUSED(self), PyObject* args)
427 {
428         VectorObject *vec1, *vec2, *vec3;
429         float v1[3], v2[3], v3[3];
430
431         if( !PyArg_ParseTuple
432                 ( args, "O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2
433                 , &vector_Type, &vec3 ) ) {
434                 PyErr_SetString(PyExc_TypeError, "expected 3 vector types");
435                 return NULL;
436         }
437         if( vec1->size != vec2->size || vec1->size != vec3->size ) {
438                 PyErr_SetString(PyExc_TypeError, "vectors must be of the same size" );
439                 return NULL;
440         }
441
442         if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2) || !BaseMath_ReadCallback(vec3))
443                 return NULL;
444
445         if (vec1->size == 3) {
446                 VECCOPY(v1, vec1->vec);
447                 VECCOPY(v2, vec2->vec);
448                 VECCOPY(v3, vec3->vec);
449
450                 return PyFloat_FromDouble( area_tri_v3(v1, v2, v3) );
451         }
452         else if (vec1->size == 2) {
453                 v1[0] = vec1->vec[0];
454                 v1[1] = vec1->vec[1];
455
456                 v2[0] = vec2->vec[0];
457                 v2[1] = vec2->vec[1];
458
459                 v3[0] = vec3->vec[0];
460                 v3[1] = vec3->vec[1];
461
462                 return PyFloat_FromDouble( area_tri_v2(v1, v2, v3) );
463         }
464         else {
465                 PyErr_SetString(PyExc_TypeError, "only 2D,3D vectors are supported" );
466                 return NULL;
467         }
468 }
469
470 /*----------------------------------geometry.PolyFill() -------------------*/
471 /* PolyFill function, uses Blenders scanfill to fill multiple poly lines */
472 static PyObject *M_Geometry_PolyFill(PyObject *UNUSED(self), PyObject * polyLineSeq )
473 {
474         PyObject *tri_list; /*return this list of tri's */
475         PyObject *polyLine, *polyVec;
476         int i, len_polylines, len_polypoints, ls_error = 0;
477         
478         /* display listbase */
479         ListBase dispbase={NULL, NULL};
480         DispList *dl;
481         float *fp; /*pointer to the array of malloced dl->verts to set the points from the vectors */
482         int index, *dl_face, totpoints=0;
483         
484         
485         dispbase.first= dispbase.last= NULL;
486         
487         
488         if(!PySequence_Check(polyLineSeq)) {
489                 PyErr_SetString(PyExc_TypeError, "expected a sequence of poly lines" );
490                 return NULL;
491         }
492         
493         len_polylines = PySequence_Size( polyLineSeq );
494         
495         for( i = 0; i < len_polylines; ++i ) {
496                 polyLine= PySequence_GetItem( polyLineSeq, i );
497                 if (!PySequence_Check(polyLine)) {
498                         freedisplist(&dispbase);
499                         Py_XDECREF(polyLine); /* may be null so use Py_XDECREF*/
500                         PyErr_SetString(PyExc_TypeError, "One or more of the polylines is not a sequence of mathutils.Vector's" );
501                         return NULL;
502                 }
503                 
504                 len_polypoints= PySequence_Size( polyLine );
505                 if (len_polypoints>0) { /* dont bother adding edges as polylines */
506 #if 0
507                         if (EXPP_check_sequence_consistency( polyLine, &vector_Type ) != 1) {
508                                 freedisplist(&dispbase);
509                                 Py_DECREF(polyLine);
510                                 PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type" );
511                                 return NULL;
512                         }
513 #endif
514                         dl= MEM_callocN(sizeof(DispList), "poly disp");
515                         BLI_addtail(&dispbase, dl);
516                         dl->type= DL_INDEX3;
517                         dl->nr= len_polypoints;
518                         dl->type= DL_POLY;
519                         dl->parts= 1; /* no faces, 1 edge loop */
520                         dl->col= 0; /* no material */
521                         dl->verts= fp= MEM_callocN( sizeof(float)*3*len_polypoints, "dl verts");
522                         dl->index= MEM_callocN(sizeof(int)*3*len_polypoints, "dl index");
523                         
524                         for( index = 0; index<len_polypoints; ++index, fp+=3) {
525                                 polyVec= PySequence_GetItem( polyLine, index );
526                                 if(VectorObject_Check(polyVec)) {
527                                         
528                                         if(!BaseMath_ReadCallback((VectorObject *)polyVec))
529                                                 ls_error= 1;
530                                         
531                                         fp[0] = ((VectorObject *)polyVec)->vec[0];
532                                         fp[1] = ((VectorObject *)polyVec)->vec[1];
533                                         if( ((VectorObject *)polyVec)->size > 2 )
534                                                 fp[2] = ((VectorObject *)polyVec)->vec[2];
535                                         else
536                                                 fp[2]= 0.0f; /* if its a 2d vector then set the z to be zero */
537                                 }
538                                 else {
539                                         ls_error= 1;
540                                 }
541                                 
542                                 totpoints++;
543                                 Py_DECREF(polyVec);
544                         }
545                 }
546                 Py_DECREF(polyLine);
547         }
548         
549         if(ls_error) {
550                 freedisplist(&dispbase); /* possible some dl was allocated */
551                 PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type" );
552                 return NULL;
553         }
554         else if (totpoints) {
555                 /* now make the list to return */
556                 filldisplist(&dispbase, &dispbase, 0);
557                 
558                 /* The faces are stored in a new DisplayList
559                 thats added to the head of the listbase */
560                 dl= dispbase.first; 
561                 
562                 tri_list= PyList_New(dl->parts);
563                 if( !tri_list ) {
564                         freedisplist(&dispbase);
565                         PyErr_SetString(PyExc_RuntimeError, "geometry.PolyFill failed to make a new list" );
566                         return NULL;
567                 }
568                 
569                 index= 0;
570                 dl_face= dl->index;
571                 while(index < dl->parts) {
572                         PyList_SET_ITEM(tri_list, index, Py_BuildValue("iii", dl_face[0], dl_face[1], dl_face[2]) );
573                         dl_face+= 3;
574                         index++;
575                 }
576                 freedisplist(&dispbase);
577         } else {
578                 /* no points, do this so scripts dont barf */
579                 freedisplist(&dispbase); /* possible some dl was allocated */
580                 tri_list= PyList_New(0);
581         }
582         
583         return tri_list;
584 }
585
586
587 static PyObject *M_Geometry_LineIntersect2D(PyObject *UNUSED(self), PyObject* args)
588 {
589         VectorObject *line_a1, *line_a2, *line_b1, *line_b2;
590         float a1x, a1y, a2x, a2y,  b1x, b1y, b2x, b2y, xi, yi, a1,a2,b1,b2, newvec[2];
591         if( !PyArg_ParseTuple ( args, "O!O!O!O!",
592           &vector_Type, &line_a1,
593           &vector_Type, &line_a2,
594           &vector_Type, &line_b1,
595           &vector_Type, &line_b2)
596         ) {
597                 PyErr_SetString(PyExc_TypeError, "expected 4 vector types" );
598                 return NULL;
599         }
600         
601         if(!BaseMath_ReadCallback(line_a1) || !BaseMath_ReadCallback(line_a2) || !BaseMath_ReadCallback(line_b1) || !BaseMath_ReadCallback(line_b2))
602                 return NULL;
603         
604         a1x= line_a1->vec[0];
605         a1y= line_a1->vec[1];
606         a2x= line_a2->vec[0];
607         a2y= line_a2->vec[1];
608
609         b1x= line_b1->vec[0];
610         b1y= line_b1->vec[1];
611         b2x= line_b2->vec[0];
612         b2y= line_b2->vec[1];
613         
614         if((MIN2(a1x, a2x) > MAX2(b1x, b2x)) ||
615            (MAX2(a1x, a2x) < MIN2(b1x, b2x)) ||
616            (MIN2(a1y, a2y) > MAX2(b1y, b2y)) ||
617            (MAX2(a1y, a2y) < MIN2(b1y, b2y))  ) {
618                 Py_RETURN_NONE;
619         }
620         /* Make sure the hoz/vert line comes first. */
621         if (fabs(b1x - b2x) < eps || fabs(b1y - b2y) < eps) {
622                 SWAP_FLOAT(a1x, b1x, xi); /*abuse xi*/
623                 SWAP_FLOAT(a1y, b1y, xi);
624                 SWAP_FLOAT(a2x, b2x, xi);
625                 SWAP_FLOAT(a2y, b2y, xi);
626         }
627         
628         if (fabs(a1x-a2x) < eps) { /* verticle line */
629                 if (fabs(b1x-b2x) < eps){ /*verticle second line */
630                         Py_RETURN_NONE; /* 2 verticle lines dont intersect. */
631                 }
632                 else if (fabs(b1y-b2y) < eps) {
633                         /*X of vert, Y of hoz. no calculation needed */
634                         newvec[0]= a1x;
635                         newvec[1]= b1y;
636                         return newVectorObject(newvec, 2, Py_NEW, NULL);
637                 }
638                 
639                 yi = (float)(((b1y / fabs(b1x - b2x)) * fabs(b2x - a1x)) + ((b2y / fabs(b1x - b2x)) * fabs(b1x - a1x)));
640                 
641                 if (yi > MAX2(a1y, a2y)) {/* New point above seg1's vert line */
642                         Py_RETURN_NONE;
643                 } else if (yi < MIN2(a1y, a2y)) { /* New point below seg1's vert line */
644                         Py_RETURN_NONE;
645                 }
646                 newvec[0]= a1x;
647                 newvec[1]= yi;
648                 return newVectorObject(newvec, 2, Py_NEW, NULL);
649         } else if (fabs(a2y-a1y) < eps) {  /* hoz line1 */
650                 if (fabs(b2y-b1y) < eps) { /*hoz line2*/
651                         Py_RETURN_NONE; /*2 hoz lines dont intersect*/
652                 }
653                 
654                 /* Can skip vert line check for seg 2 since its covered above. */
655                 xi = (float)(((b1x / fabs(b1y - b2y)) * fabs(b2y - a1y)) + ((b2x / fabs(b1y - b2y)) * fabs(b1y - a1y)));
656                 if (xi > MAX2(a1x, a2x)) { /* New point right of hoz line1's */
657                         Py_RETURN_NONE;
658                 } else if (xi < MIN2(a1x, a2x)) { /*New point left of seg1's hoz line */
659                         Py_RETURN_NONE;
660                 }
661                 newvec[0]= xi;
662                 newvec[1]= a1y;
663                 return newVectorObject(newvec, 2, Py_NEW, NULL);
664         }
665         
666         b1 = (a2y-a1y)/(a2x-a1x);
667         b2 = (b2y-b1y)/(b2x-b1x);
668         a1 = a1y-b1*a1x;
669         a2 = b1y-b2*b1x;
670         
671         if (b1 - b2 == 0.0) {
672                 Py_RETURN_NONE;
673         }
674         
675         xi = - (a1-a2)/(b1-b2);
676         yi = a1+b1*xi;
677         if ((a1x-xi)*(xi-a2x) >= 0 && (b1x-xi)*(xi-b2x) >= 0 && (a1y-yi)*(yi-a2y) >= 0 && (b1y-yi)*(yi-b2y)>=0) {
678                 newvec[0]= xi;
679                 newvec[1]= yi;
680                 return newVectorObject(newvec, 2, Py_NEW, NULL);
681         }
682         Py_RETURN_NONE;
683 }
684
685 static PyObject *M_Geometry_ClosestPointOnLine(PyObject *UNUSED(self), PyObject* args)
686 {
687         VectorObject *pt, *line_1, *line_2;
688         float pt_in[3], pt_out[3], l1[3], l2[3];
689         float lambda;
690         PyObject *ret;
691         
692         if( !PyArg_ParseTuple ( args, "O!O!O!",
693         &vector_Type, &pt,
694         &vector_Type, &line_1,
695         &vector_Type, &line_2)
696           ) {
697                 PyErr_SetString(PyExc_TypeError, "expected 3 vector types" );
698                 return NULL;
699         }
700         
701         if(!BaseMath_ReadCallback(pt) || !BaseMath_ReadCallback(line_1) || !BaseMath_ReadCallback(line_2))
702                 return NULL;
703         
704         /* accept 2d verts */
705         if (pt->size==3) { VECCOPY(pt_in, pt->vec);}
706         else { pt_in[2]=0.0;    VECCOPY2D(pt_in, pt->vec) }
707         
708         if (line_1->size==3) { VECCOPY(l1, line_1->vec);}
709         else { l1[2]=0.0;       VECCOPY2D(l1, line_1->vec) }
710         
711         if (line_2->size==3) { VECCOPY(l2, line_2->vec);}
712         else { l2[2]=0.0;       VECCOPY2D(l2, line_2->vec) }
713         
714         /* do the calculation */
715         lambda = closest_to_line_v3( pt_out,pt_in, l1, l2);
716         
717         ret = PyTuple_New(2);
718         PyTuple_SET_ITEM( ret, 0, newVectorObject(pt_out, 3, Py_NEW, NULL) );
719         PyTuple_SET_ITEM( ret, 1, PyFloat_FromDouble(lambda) );
720         return ret;
721 }
722
723 static PyObject *M_Geometry_PointInTriangle2D(PyObject *UNUSED(self), PyObject* args)
724 {
725         VectorObject *pt_vec, *tri_p1, *tri_p2, *tri_p3;
726         
727         if( !PyArg_ParseTuple ( args, "O!O!O!O!",
728           &vector_Type, &pt_vec,
729           &vector_Type, &tri_p1,
730           &vector_Type, &tri_p2,
731           &vector_Type, &tri_p3)
732         ) {
733                 PyErr_SetString(PyExc_TypeError, "expected 4 vector types" );
734                 return NULL;
735         }
736         
737         if(!BaseMath_ReadCallback(pt_vec) || !BaseMath_ReadCallback(tri_p1) || !BaseMath_ReadCallback(tri_p2) || !BaseMath_ReadCallback(tri_p3))
738                 return NULL;
739         
740         return PyLong_FromLong(isect_point_tri_v2(pt_vec->vec, tri_p1->vec, tri_p2->vec, tri_p3->vec));
741 }
742
743 static PyObject *M_Geometry_PointInQuad2D(PyObject *UNUSED(self), PyObject* args)
744 {
745         VectorObject *pt_vec, *quad_p1, *quad_p2, *quad_p3, *quad_p4;
746         
747         if( !PyArg_ParseTuple ( args, "O!O!O!O!O!",
748           &vector_Type, &pt_vec,
749           &vector_Type, &quad_p1,
750           &vector_Type, &quad_p2,
751           &vector_Type, &quad_p3,
752           &vector_Type, &quad_p4)
753         ) {
754                 PyErr_SetString(PyExc_TypeError, "expected 5 vector types" );
755                 return NULL;
756         }
757         
758         if(!BaseMath_ReadCallback(pt_vec) || !BaseMath_ReadCallback(quad_p1) || !BaseMath_ReadCallback(quad_p2) || !BaseMath_ReadCallback(quad_p3) || !BaseMath_ReadCallback(quad_p4))
759                 return NULL;
760         
761         return PyLong_FromLong(isect_point_quad_v2(pt_vec->vec, quad_p1->vec, quad_p2->vec, quad_p3->vec, quad_p4->vec));
762 }
763
764 static int boxPack_FromPyObject(PyObject * value, boxPack **boxarray )
765 {
766         int len, i;
767         PyObject *list_item, *item_1, *item_2;
768         boxPack *box;
769         
770         
771         /* Error checking must already be done */
772         if( !PyList_Check( value ) ) {
773                 PyErr_SetString(PyExc_TypeError, "can only back a list of [x,y,x,w]" );
774                 return -1;
775         }
776         
777         len = PyList_Size( value );
778         
779         (*boxarray) = MEM_mallocN( len*sizeof(boxPack), "boxPack box");
780         
781         
782         for( i = 0; i < len; i++ ) {
783                 list_item = PyList_GET_ITEM( value, i );
784                 if( !PyList_Check( list_item ) || PyList_Size( list_item ) < 4 ) {
785                         MEM_freeN(*boxarray);
786                         PyErr_SetString(PyExc_TypeError, "can only back a list of [x,y,x,w]" );
787                         return -1;
788                 }
789                 
790                 box = (*boxarray)+i;
791                 
792                 item_1 = PyList_GET_ITEM(list_item, 2);
793                 item_2 = PyList_GET_ITEM(list_item, 3);
794                 
795                 if (!PyNumber_Check(item_1) || !PyNumber_Check(item_2)) {
796                         MEM_freeN(*boxarray);
797                         PyErr_SetString(PyExc_TypeError, "can only back a list of 2d boxes [x,y,x,w]" );
798                         return -1;
799                 }
800                 
801                 box->w =  (float)PyFloat_AsDouble( item_1 );
802                 box->h =  (float)PyFloat_AsDouble( item_2 );
803                 box->index = i;
804                 /* verts will be added later */
805         }
806         return 0;
807 }
808
809 static void boxPack_ToPyObject(PyObject * value, boxPack **boxarray)
810 {
811         int len, i;
812         PyObject *list_item;
813         boxPack *box;
814         
815         len = PyList_Size( value );
816         
817         for( i = 0; i < len; i++ ) {
818                 box = (*boxarray)+i;
819                 list_item = PyList_GET_ITEM( value, box->index );
820                 PyList_SET_ITEM( list_item, 0, PyFloat_FromDouble( box->x ));
821                 PyList_SET_ITEM( list_item, 1, PyFloat_FromDouble( box->y ));
822         }
823         MEM_freeN(*boxarray);
824 }
825
826
827 static PyObject *M_Geometry_BoxPack2D(PyObject *UNUSED(self), PyObject * boxlist )
828 {
829         boxPack *boxarray = NULL;
830         float tot_width, tot_height;
831         int len;
832         int error;
833         
834         if(!PyList_Check(boxlist)) {
835                 PyErr_SetString(PyExc_TypeError, "expected a sequence of boxes [[x,y,w,h], ... ]" );
836                 return NULL;
837         }
838         
839         len = PyList_Size( boxlist );
840         
841         if (!len)
842                 return Py_BuildValue( "ff", 0.0, 0.0);
843         
844         error = boxPack_FromPyObject(boxlist, &boxarray);
845         if (error!=0)   return NULL;
846         
847         /* Non Python function */
848         boxPack2D(boxarray, len, &tot_width, &tot_height);
849         
850         boxPack_ToPyObject(boxlist, &boxarray);
851         
852         return Py_BuildValue( "ff", tot_width, tot_height);
853 }
854
855 static PyObject *M_Geometry_BezierInterp(PyObject *UNUSED(self), PyObject* args)
856 {
857         VectorObject *vec_k1, *vec_h1, *vec_k2, *vec_h2;
858         int resolu;
859         int dims;
860         int i;
861         float *coord_array, *fp;
862         PyObject *list;
863         
864         float k1[4] = {0.0, 0.0, 0.0, 0.0};
865         float h1[4] = {0.0, 0.0, 0.0, 0.0};
866         float k2[4] = {0.0, 0.0, 0.0, 0.0};
867         float h2[4] = {0.0, 0.0, 0.0, 0.0};
868         
869         
870         if( !PyArg_ParseTuple ( args, "O!O!O!O!i",
871           &vector_Type, &vec_k1,
872           &vector_Type, &vec_h1,
873           &vector_Type, &vec_h2,
874           &vector_Type, &vec_k2, &resolu) || (resolu<=1)
875         ) {
876                 PyErr_SetString(PyExc_TypeError, "expected 4 vector types and an int greater then 1" );
877                 return NULL;
878         }
879         
880         if(!BaseMath_ReadCallback(vec_k1) || !BaseMath_ReadCallback(vec_h1) || !BaseMath_ReadCallback(vec_k2) || !BaseMath_ReadCallback(vec_h2))
881                 return NULL;
882         
883         dims= MAX4(vec_k1->size, vec_h1->size, vec_h2->size, vec_k2->size);
884         
885         for(i=0; i < vec_k1->size; i++) k1[i]= vec_k1->vec[i];
886         for(i=0; i < vec_h1->size; i++) h1[i]= vec_h1->vec[i];
887         for(i=0; i < vec_k2->size; i++) k2[i]= vec_k2->vec[i];
888         for(i=0; i < vec_h2->size; i++) h2[i]= vec_h2->vec[i];
889         
890         coord_array = MEM_callocN(dims * (resolu) * sizeof(float), "BezierInterp");
891         for(i=0; i<dims; i++) {
892                 forward_diff_bezier(k1[i], h1[i], h2[i], k2[i], coord_array+i, resolu-1, sizeof(float)*dims);
893         }
894         
895         list= PyList_New(resolu);
896         fp= coord_array;
897         for(i=0; i<resolu; i++, fp= fp+dims) {
898                 PyList_SET_ITEM(list, i, newVectorObject(fp, dims, Py_NEW, NULL));
899         }
900         MEM_freeN(coord_array);
901         return list;
902 }
903
904 static PyObject *M_Geometry_BarycentricTransform(PyObject *UNUSED(self), PyObject *args)
905 {
906         VectorObject *vec_pt;
907         VectorObject *vec_t1_tar, *vec_t2_tar, *vec_t3_tar;
908         VectorObject *vec_t1_src, *vec_t2_src, *vec_t3_src;
909         float vec[3];
910
911         if( !PyArg_ParseTuple ( args, "O!O!O!O!O!O!O!",
912           &vector_Type, &vec_pt,
913           &vector_Type, &vec_t1_src,
914           &vector_Type, &vec_t2_src,
915           &vector_Type, &vec_t3_src,
916           &vector_Type, &vec_t1_tar,
917           &vector_Type, &vec_t2_tar,
918           &vector_Type, &vec_t3_tar) || (       vec_pt->size != 3 ||
919                                                                                 vec_t1_src->size != 3 ||
920                                                                                 vec_t2_src->size != 3 ||
921                                                                                 vec_t3_src->size != 3 ||
922                                                                                 vec_t1_tar->size != 3 ||
923                                                                                 vec_t2_tar->size != 3 ||
924                                                                                 vec_t3_tar->size != 3)
925         ) {
926                 PyErr_SetString(PyExc_TypeError, "expected 7, 3D vector types" );
927                 return NULL;
928         }
929
930         barycentric_transform(vec, vec_pt->vec,
931                         vec_t1_tar->vec, vec_t2_tar->vec, vec_t3_tar->vec,
932                         vec_t1_src->vec, vec_t2_src->vec, vec_t3_src->vec);
933
934         return newVectorObject(vec, 3, Py_NEW, NULL);
935 }
936
937 struct PyMethodDef M_Geometry_methods[] = {
938         {"Intersect", ( PyCFunction ) M_Geometry_Intersect, METH_VARARGS, M_Geometry_Intersect_doc},
939         {"TriangleArea", ( PyCFunction ) M_Geometry_TriangleArea, METH_VARARGS, M_Geometry_TriangleArea_doc},
940         {"TriangleNormal", ( PyCFunction ) M_Geometry_TriangleNormal, METH_VARARGS, M_Geometry_TriangleNormal_doc},
941         {"QuadNormal", ( PyCFunction ) M_Geometry_QuadNormal, METH_VARARGS, M_Geometry_QuadNormal_doc},
942         {"LineIntersect", ( PyCFunction ) M_Geometry_LineIntersect, METH_VARARGS, M_Geometry_LineIntersect_doc},
943         {"PolyFill", ( PyCFunction ) M_Geometry_PolyFill, METH_O, M_Geometry_PolyFill_doc},
944         {"LineIntersect2D", ( PyCFunction ) M_Geometry_LineIntersect2D, METH_VARARGS, M_Geometry_LineIntersect2D_doc},
945         {"ClosestPointOnLine", ( PyCFunction ) M_Geometry_ClosestPointOnLine, METH_VARARGS, M_Geometry_ClosestPointOnLine_doc},
946         {"PointInTriangle2D", ( PyCFunction ) M_Geometry_PointInTriangle2D, METH_VARARGS, M_Geometry_PointInTriangle2D_doc},
947         {"PointInQuad2D", ( PyCFunction ) M_Geometry_PointInQuad2D, METH_VARARGS, M_Geometry_PointInQuad2D_doc},
948         {"BoxPack2D", ( PyCFunction ) M_Geometry_BoxPack2D, METH_O, M_Geometry_BoxPack2D_doc},
949         {"BezierInterp", ( PyCFunction ) M_Geometry_BezierInterp, METH_VARARGS, M_Geometry_BezierInterp_doc},
950         {"BarycentricTransform", ( PyCFunction ) M_Geometry_BarycentricTransform, METH_VARARGS, M_Geometry_BarycentricTransform_doc},
951         {NULL, NULL, 0, NULL}
952 };
953
954 static struct PyModuleDef M_Geometry_module_def = {
955         PyModuleDef_HEAD_INIT,
956         "mathutils.geometry",  /* m_name */
957         M_Geometry_doc,  /* m_doc */
958         0,  /* m_size */
959         M_Geometry_methods,  /* m_methods */
960         0,  /* m_reload */
961         0,  /* m_traverse */
962         0,  /* m_clear */
963         0,  /* m_free */
964 };
965
966 /*----------------------------MODULE INIT-------------------------*/
967 PyMODINIT_FUNC BPyInit_mathutils_geometry(void)
968 {
969         PyObject *submodule= PyModule_Create(&M_Geometry_module_def);
970         return submodule;
971 }