7740b0d16348097e333bfa6289ee1dd0ff536e16
[blender.git] / intern / dualcon / intern / Projections.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Tao Ju
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 #ifndef PROJECTIONS_H
24 #define PROJECTIONS_H
25
26 #include <stdio.h>
27 #include <stdlib.h>
28
29 #define CONTAINS_INDEX
30 #define GRID_DIMENSION 20
31
32 #if defined(_WIN32) && !defined(__MINGW32__)
33 #define isnan(n) _isnan(n)
34 #define LONG __int64
35 #else
36 #include <stdint.h>
37 #define LONG int64_t
38 #endif
39 #define UCHAR unsigned char
40
41 /**
42  * Structures and classes for computing projections of triangles
43  * onto separating axes during scan conversion
44  *
45  * @author Tao Ju
46  */
47
48
49 extern const int vertmap[8][3];
50 extern const int centmap[3][3][3][2];
51 extern const int edgemap[12][2];
52 extern const int facemap[6][4];
53
54 /**
55  * Structure for the projections inheritable from parent
56  */
57 struct InheritableProjections {
58         /// Projections of triangle
59         LONG trigProj[13][2];
60
61         /// Projections of triangle vertices on primary axes
62         LONG trigVertProj[13][3];
63
64         /// Projections of triangle edges
65         LONG trigEdgeProj[13][3][2];
66
67         /// Normal of the triangle
68         double norm[3];
69         double normA, normB;
70
71         /// End points along each axis
72         //int cubeEnds[13][2] ;
73
74         /// Error range on each axis
75         /// LONG errorProj[13];
76
77 #ifdef CONTAINS_INDEX
78         /// Index of polygon
79         int index;
80 #endif
81 };
82
83
84 /**
85  * Class for projections of cube / triangle vertices on the separating axes
86  */
87 class Projections
88 {
89 public:
90 /// Inheritable portion
91 InheritableProjections *inherit;
92
93 /// Projections of the cube vertices
94 LONG cubeProj[13][6];
95
96 public:
97
98 Projections( )
99 {
100 }
101
102 /**
103  * Construction
104  * from a cube (axes aligned) and triangle
105  */
106 Projections(LONG cube[2][3], LONG trig[3][3], LONG error, int triind)
107 {
108         int i, j;
109         inherit = new InheritableProjections;
110 #ifdef CONTAINS_INDEX
111         inherit->index = triind;
112 #endif
113         /// Create axes
114         LONG axes[13][3];
115
116         // Cube faces
117         axes[0][0] = 1;
118         axes[0][1] = 0;
119         axes[0][2] = 0;
120
121         axes[1][0] = 0;
122         axes[1][1] = 1;
123         axes[1][2] = 0;
124
125         axes[2][0] = 0;
126         axes[2][1] = 0;
127         axes[2][2] = 1;
128
129         // Triangle face
130         LONG trigedge[3][3];
131         for (i = 0; i < 3; i++)
132         {
133                 for (j = 0; j < 3; j++)
134                 {
135                         trigedge[i][j] = trig[(i + 1) % 3][j] - trig[i][j];
136                 }
137         }
138         crossProduct(trigedge[0], trigedge[1], axes[3]);
139
140         /// Normalize face normal and store
141         double dedge1[] = { (double) trig[1][0] - (double) trig[0][0],
142                                 (double) trig[1][1] - (double) trig[0][1],
143                                 (double) trig[1][2] - (double) trig[0][2] };
144         double dedge2[] = { (double) trig[2][0] - (double) trig[1][0],
145                                 (double) trig[2][1] - (double) trig[1][1],
146                                 (double) trig[2][2] - (double) trig[1][2] };
147         crossProduct(dedge1, dedge2, inherit->norm);
148         normalize(inherit->norm);
149 //              inherit->normA = norm[ 0 ] ;
150 //              inherit->normB = norm[ 2 ] > 0 ? norm[ 1 ] : 2 + norm[ 1 ] ;
151
152         // Face edges and triangle edges
153         int ct = 4;
154         for (i = 0; i < 3; i++)
155                 for (j = 0; j < 3; j++)
156                 {
157                         crossProduct(axes[j], trigedge[i], axes[ct]);
158                         ct++;
159                 }
160
161         /// Generate projections
162         LONG cubeedge[3][3];
163         for (i = 0; i < 3; i++)
164         {
165                 for (j = 0; j < 3; j++)
166                 {
167                         cubeedge[i][j] = 0;
168                 }
169                 cubeedge[i][i] = cube[1][i] - cube[0][i];
170         }
171
172         for (j = 0; j < 13; j++)
173         {
174                 // Origin
175                 cubeProj[j][0] = dotProduct(axes[j], cube[0]);
176
177                 // 3 direction vectors
178                 for (i = 1; i < 4; i++)
179                 {
180                         cubeProj[j][i] = dotProduct(axes[j], cubeedge[i - 1]);
181                 }
182
183                 // Offsets of 2 ends of cube projection
184                 LONG max = 0;
185                 LONG min = 0;
186                 for (i = 1; i < 8; i++)
187                 {
188                         LONG proj = vertmap[i][0] * cubeProj[j][1] + vertmap[i][1] * cubeProj[j][2] + vertmap[i][2] * cubeProj[j][3];
189                         if (proj > max)
190                         {
191                                 max = proj;
192                         }
193                         if (proj < min)
194                         {
195                                 min = proj;
196                         }
197                 }
198                 cubeProj[j][4] = min;
199                 cubeProj[j][5] = max;
200
201         }
202
203         for (j = 0; j < 13; j++)
204         {
205                 LONG vts[3] = { dotProduct(axes[j], trig[0]),
206                                     dotProduct(axes[j], trig[1]),
207                                     dotProduct(axes[j], trig[2])  };
208
209                 // Vertex
210                 inherit->trigVertProj[j][0] = vts[0];
211                 inherit->trigVertProj[j][1] = vts[1];
212                 inherit->trigVertProj[j][2] = vts[2];
213
214                 // Edge
215                 for (i = 0; i < 3; i++)
216                 {
217                         if (vts[i] < vts[(i + 1) % 3])
218                         {
219                                 inherit->trigEdgeProj[j][i][0] = vts[i];
220                                 inherit->trigEdgeProj[j][i][1] = vts[(i + 1) % 3];
221                         }
222                         else {
223                                 inherit->trigEdgeProj[j][i][1] = vts[i];
224                                 inherit->trigEdgeProj[j][i][0] = vts[(i + 1) % 3];
225                         }
226                 }
227
228                 // Triangle
229                 inherit->trigProj[j][0] = vts[0];
230                 inherit->trigProj[j][1] = vts[0];
231                 for (i = 1; i < 3; i++)
232                 {
233                         if (vts[i] < inherit->trigProj[j][0])
234                         {
235                                 inherit->trigProj[j][0] = vts[i];
236                         }
237                         if (vts[i] > inherit->trigProj[j][1])
238                         {
239                                 inherit->trigProj[j][1] = vts[i];
240                         }
241                 }
242         }
243
244 }
245
246 /**
247  * Construction
248  * from a parent Projections object and the index of the children
249  */
250 Projections (Projections *parent)
251 {
252         // Copy inheritable projections
253         this->inherit = parent->inherit;
254
255         // Shrink cube projections
256         for (int i = 0; i < 13; i++)
257         {
258                 cubeProj[i][0] = parent->cubeProj[i][0];
259                 for (int j = 1; j < 6; j++)
260                 {
261                         cubeProj[i][j] = parent->cubeProj[i][j] >> 1;
262                 }
263         }
264 };
265
266 Projections (Projections *parent, int box[3], int depth)
267 {
268         int mask =  (1 << depth) - 1;
269         int nbox[3] = { box[0] & mask, box[1] & mask, box[2] & mask };
270
271         // Copy inheritable projections
272         this->inherit = parent->inherit;
273
274         // Shrink cube projections
275         for (int i = 0; i < 13; i++)
276         {
277                 for (int j = 1; j < 6; j++)
278                 {
279                         cubeProj[i][j] = parent->cubeProj[i][j] >> depth;
280                 }
281
282                 cubeProj[i][0] = parent->cubeProj[i][0] + nbox[0] * cubeProj[i][1] + nbox[1] * cubeProj[i][2] + nbox[2] * cubeProj[i][3];
283         }
284 };
285
286 /**
287  * Testing intersection based on vertex/edge masks
288  */
289 int getIntersectionMasks(UCHAR cedgemask, UCHAR& edgemask)
290 {
291         int i, j;
292         edgemask = cedgemask;
293
294         // Pre-processing
295         /*
296            if ( cvertmask & 1 )
297            {
298             edgemask |= 5 ;
299            }
300            if ( cvertmask & 2 )
301            {
302             edgemask |= 3 ;
303            }
304            if ( cvertmask & 4 )
305            {
306             edgemask |= 6 ;
307            }
308
309          */
310
311         // Test axes for edge intersection
312         UCHAR bit = 1;
313         for (j = 0; j < 3; j++)
314         {
315                 if (edgemask & bit)
316                 {
317                         for (i = 0; i < 13; i++)
318                         {
319                                 LONG proj0 = cubeProj[i][0] + cubeProj[i][4];
320                                 LONG proj1 = cubeProj[i][0] + cubeProj[i][5];
321
322                                 if (proj0 > inherit->trigEdgeProj[i][j][1] ||
323                                     proj1 < inherit->trigEdgeProj[i][j][0])
324                                 {
325                                         edgemask &= (~bit);
326                                         break;
327                                 }
328                         }
329                 }
330                 bit <<= 1;
331         }
332
333         /*
334            if ( edgemask != 0 )
335            {
336             printf("%d %d\n", cedgemask, edgemask) ;
337            }
338          */
339
340         // Test axes for triangle intersection
341         if (edgemask)
342         {
343                 return 1;
344         }
345
346         for (i = 3; i < 13; i++)
347         {
348                 LONG proj0 = cubeProj[i][0] + cubeProj[i][4];
349                 LONG proj1 = cubeProj[i][0] + cubeProj[i][5];
350
351                 if (proj0 > inherit->trigProj[i][1] ||
352                     proj1 < inherit->trigProj[i][0])
353                 {
354                         return 0;
355                 }
356         }
357
358         return 1;
359 }
360
361 /**
362  * Retrieving children masks using PRIMARY AXES
363  */
364 UCHAR getChildrenMasks(UCHAR cvertmask, UCHAR vertmask[8])
365 {
366         int i, j, k;
367         int bmask[3][2] = {{0, 0}, {0, 0}, {0, 0}};
368         int vmask[3][3][2] = {{{0, 0}, {0, 0}, {0, 0}}, {{0, 0}, {0, 0}, {0, 0}}, {{0, 0}, {0, 0}, {0, 0}}};
369         UCHAR boxmask = 0;
370         LONG len = cubeProj[0][1] >> 1;
371
372         for (i = 0; i < 3; i++)
373         {
374                 LONG mid = cubeProj[i][0] + len;
375
376                 // Check bounding box
377                 if (mid >= inherit->trigProj[i][0])
378                 {
379                         bmask[i][0] = 1;
380                 }
381                 if (mid <= inherit->trigProj[i][1])
382                 {
383                         bmask[i][1] = 1;
384                 }
385
386                 // Check vertex mask
387                 if (cvertmask)
388                 {
389                         for (j = 0; j < 3; j++)
390                         {
391                                 if (cvertmask & (1 << j) )
392                                 {
393                                         // Only check if it's contained this node
394                                         if (mid >= inherit->trigVertProj[i][j])
395                                         {
396                                                 vmask[i][j][0] = 1;
397                                         }
398                                         if (mid <= inherit->trigVertProj[i][j])
399                                         {
400                                                 vmask[i][j][1] = 1;
401                                         }
402                                 }
403                         }
404                 }
405
406                 /*
407                    // Check edge mask
408                    if ( cedgemask )
409                    {
410                     for ( j = 0 ; j < 3 ; j ++ )
411                     {
412                         if ( cedgemask & ( 1 << j ) )
413                         {
414                             // Only check if it's contained this node
415                             if ( mid >= inherit->trigEdgeProj[i][j][0] )
416                             {
417                                 emask[i][j][0] = 1 ;
418                             }
419                             if ( mid <= inherit->trigEdgeProj[i][j][1] )
420                             {
421                                 emask[i][j][1] = 1 ;
422                             }
423                         }
424                     }
425                    }
426                  */
427
428         }
429
430         // Fill in masks
431         int ct = 0;
432         for (i = 0; i < 2; i++)
433                 for (j = 0; j < 2; j++)
434                         for (k = 0; k < 2; k++)
435                         {
436                                 boxmask |= ( (bmask[0][i] & bmask[1][j] & bmask[2][k]) << ct);
437                                 vertmask[ct] = ((vmask[0][0][i] & vmask[1][0][j] & vmask[2][0][k]) |
438                                                 ((vmask[0][1][i] & vmask[1][1][j] & vmask[2][1][k]) << 1) |
439                                                 ((vmask[0][2][i] & vmask[1][2][j] & vmask[2][2][k]) << 2) );
440                                 /*
441                                    edgemask[ct] = (( emask[0][0][i] & emask[1][0][j] & emask[2][0][k] ) |
442                                                (( emask[0][1][i] & emask[1][1][j] & emask[2][1][k] ) << 1 ) |
443                                                (( emask[0][2][i] & emask[1][2][j] & emask[2][2][k] ) << 2 ) ) ;
444                                    edgemask[ct] = cedgemask ;
445                                  */
446                                 ct++;
447                         }
448
449         // Return bounding box masks
450         return boxmask;
451 }
452
453 UCHAR getBoxMask( )
454 {
455         int i, j, k;
456         int bmask[3][2] = {{0, 0}, {0, 0}, {0, 0}};
457         UCHAR boxmask = 0;
458         LONG len = cubeProj[0][1] >> 1;
459
460         for (i = 0; i < 3; i++)
461         {
462                 LONG mid = cubeProj[i][0] + len;
463
464                 // Check bounding box
465                 if (mid >= inherit->trigProj[i][0])
466                 {
467                         bmask[i][0] = 1;
468                 }
469                 if (mid <= inherit->trigProj[i][1])
470                 {
471                         bmask[i][1] = 1;
472                 }
473
474         }
475
476         // Fill in masks
477         int ct = 0;
478         for (i = 0; i < 2; i++)
479                 for (j = 0; j < 2; j++)
480                         for (k = 0; k < 2; k++)
481                         {
482                                 boxmask |= ( (bmask[0][i] & bmask[1][j] & bmask[2][k]) << ct);
483                                 ct++;
484                         }
485
486         // Return bounding box masks
487         return boxmask;
488 }
489
490
491 /**
492  * Get projections for sub-cubes (simple axes)
493  */
494 void getSubProjectionsSimple(Projections *p[8])
495 {
496         // Process the axes cooresponding to the triangle's normal
497         int ind = 3;
498         LONG len = cubeProj[0][1] >> 1;
499         LONG trigproj[3] = { cubeProj[ind][1] >> 1, cubeProj[ind][2] >> 1, cubeProj[ind][3] >> 1 };
500
501         int ct = 0;
502         for (int i = 0; i < 2; i++)
503                 for (int j = 0; j < 2; j++)
504                         for (int k = 0; k < 2; k++)
505                         {
506                                 p[ct] = new Projections( );
507                                 p[ct]->inherit = inherit;
508
509                                 p[ct]->cubeProj[0][0] = cubeProj[0][0] + i * len;
510                                 p[ct]->cubeProj[1][0] = cubeProj[1][0] + j * len;
511                                 p[ct]->cubeProj[2][0] = cubeProj[2][0] + k * len;
512                                 p[ct]->cubeProj[0][1] = len;
513
514                                 for (int m = 1; m < 4; m++)
515                                 {
516                                         p[ct]->cubeProj[ind][m] = trigproj[m - 1];
517                                 }
518                                 p[ct]->cubeProj[ind][0] = cubeProj[ind][0] + i * trigproj[0] + j * trigproj[1] + k * trigproj[2];
519
520                                 ct++;
521                         }
522 }
523
524 /**
525  * Shifting a cube to a new origin
526  */
527 void shift(int off[3])
528 {
529         for (int i = 0; i < 13; i++)
530         {
531                 cubeProj[i][0] += off[0] * cubeProj[i][1] + off[1] * cubeProj[i][2] + off[2] * cubeProj[i][3];
532         }
533 }
534
535 void shiftNoPrimary(int off[3])
536 {
537         for (int i = 3; i < 13; i++)
538         {
539                 cubeProj[i][0] += off[0] * cubeProj[i][1] + off[1] * cubeProj[i][2] + off[2] * cubeProj[i][3];
540         }
541 }
542
543 /**
544  * Method to test intersection of the triangle and the cube
545  */
546 int isIntersecting( )
547 {
548         for (int i = 0; i < 13; i++)
549         {
550                 /*
551                    LONG proj0 = cubeProj[i][0] +
552                     vertmap[inherit->cubeEnds[i][0]][0] * cubeProj[i][1] +
553                     vertmap[inherit->cubeEnds[i][0]][1] * cubeProj[i][2] +
554                     vertmap[inherit->cubeEnds[i][0]][2] * cubeProj[i][3] ;
555                    LONG proj1 = cubeProj[i][0] +
556                     vertmap[inherit->cubeEnds[i][1]][0] * cubeProj[i][1] +
557                     vertmap[inherit->cubeEnds[i][1]][1] * cubeProj[i][2] +
558                     vertmap[inherit->cubeEnds[i][1]][2] * cubeProj[i][3] ;
559                  */
560
561                 LONG proj0 = cubeProj[i][0] + cubeProj[i][4];
562                 LONG proj1 = cubeProj[i][0] + cubeProj[i][5];
563
564                 if (proj0 > inherit->trigProj[i][1] ||
565                     proj1 < inherit->trigProj[i][0])
566                 {
567                         return 0;
568                 }
569         }
570
571         return 1;
572 };
573
574 int isIntersectingNoPrimary( )
575 {
576         for (int i = 3; i < 13; i++)
577         {
578                 /*
579                    LONG proj0 = cubeProj[i][0] +
580                     vertmap[inherit->cubeEnds[i][0]][0] * cubeProj[i][1] +
581                     vertmap[inherit->cubeEnds[i][0]][1] * cubeProj[i][2] +
582                     vertmap[inherit->cubeEnds[i][0]][2] * cubeProj[i][3] ;
583                    LONG proj1 = cubeProj[i][0] +
584                     vertmap[inherit->cubeEnds[i][1]][0] * cubeProj[i][1] +
585                     vertmap[inherit->cubeEnds[i][1]][1] * cubeProj[i][2] +
586                     vertmap[inherit->cubeEnds[i][1]][2] * cubeProj[i][3] ;
587                  */
588
589                 LONG proj0 = cubeProj[i][0] + cubeProj[i][4];
590                 LONG proj1 = cubeProj[i][0] + cubeProj[i][5];
591
592                 if (proj0 > inherit->trigProj[i][1] ||
593                     proj1 < inherit->trigProj[i][0])
594                 {
595                         return 0;
596                 }
597         }
598
599         return 1;
600 };
601
602 /**
603  * Method to test intersection of the triangle and one edge
604  */
605 int isIntersecting(int edgeInd)
606 {
607         for (int i = 0; i < 13; i++)
608         {
609
610                 LONG proj0 = cubeProj[i][0] +
611                              vertmap[edgemap[edgeInd][0]][0] * cubeProj[i][1] +
612                              vertmap[edgemap[edgeInd][0]][1] * cubeProj[i][2] +
613                              vertmap[edgemap[edgeInd][0]][2] * cubeProj[i][3];
614                 LONG proj1 = cubeProj[i][0] +
615                              vertmap[edgemap[edgeInd][1]][0] * cubeProj[i][1] +
616                              vertmap[edgemap[edgeInd][1]][1] * cubeProj[i][2] +
617                              vertmap[edgemap[edgeInd][1]][2] * cubeProj[i][3];
618
619
620                 if (proj0 < proj1)
621                 {
622                         if (proj0 > inherit->trigProj[i][1] ||
623                             proj1 < inherit->trigProj[i][0])
624                         {
625                                 return 0;
626                         }
627                 }
628                 else {
629                         if (proj1 > inherit->trigProj[i][1] ||
630                             proj0 < inherit->trigProj[i][0])
631                         {
632                                 return 0;
633                         }
634                 }
635         }
636
637         // printf( "Intersecting: %d %d\n", edgemap[edgeInd][0], edgemap[edgeInd][1] )  ;
638         return 1;
639 };
640
641 /**
642  * Method to test intersection of one triangle edge and one cube face
643  */
644 int isIntersecting(int edgeInd, int faceInd)
645 {
646         for (int i = 0; i < 13; i++)
647         {
648                 LONG trigproj0 = inherit->trigVertProj[i][edgeInd];
649                 LONG trigproj1 = inherit->trigVertProj[i][(edgeInd + 1) % 3];
650
651                 if (trigproj0 < trigproj1)
652                 {
653                         int t1 = 1, t2 = 1;
654                         for (int j = 0; j < 4; j++)
655                         {
656                                 LONG proj = cubeProj[i][0] +
657                                             vertmap[facemap[faceInd][j]][0] * cubeProj[i][1] +
658                                             vertmap[facemap[faceInd][j]][1] * cubeProj[i][2] +
659                                             vertmap[facemap[faceInd][j]][2] * cubeProj[i][3];
660                                 if (proj >= trigproj0)
661                                 {
662                                         t1 = 0;
663                                 }
664                                 if (proj <= trigproj1)
665                                 {
666                                         t2 = 0;
667                                 }
668                         }
669                         if (t1 || t2)
670                         {
671                                 return 0;
672                         }
673                 }
674                 else {
675                         int t1 = 1, t2 = 1;
676                         for (int j = 0; j < 4; j++)
677                         {
678                                 LONG proj = cubeProj[i][0] +
679                                             vertmap[facemap[faceInd][j]][0] * cubeProj[i][1] +
680                                             vertmap[facemap[faceInd][j]][1] * cubeProj[i][2] +
681                                             vertmap[facemap[faceInd][j]][2] * cubeProj[i][3];
682                                 if (proj >= trigproj1)
683                                 {
684                                         t1 = 0;
685                                 }
686                                 if (proj <= trigproj0)
687                                 {
688                                         t2 = 0;
689                                 }
690                         }
691                         if (t1 || t2)
692                         {
693                                 return 0;
694                         }
695                 }
696         }
697
698         return 1;
699 };
700
701
702 int isIntersectingPrimary(int edgeInd)
703 {
704         for (int i = 0; i < 13; i++)
705         {
706
707                 LONG proj0 = cubeProj[i][0];
708                 LONG proj1 = cubeProj[i][0] + cubeProj[i][edgeInd + 1];
709
710                 if (proj0 < proj1)
711                 {
712                         if (proj0 > inherit->trigProj[i][1] ||
713                             proj1 < inherit->trigProj[i][0])
714                         {
715                                 return 0;
716                         }
717                 }
718                 else {
719                         if (proj1 > inherit->trigProj[i][1] ||
720                             proj0 < inherit->trigProj[i][0])
721                         {
722                                 return 0;
723                         }
724                 }
725
726         }
727
728         // printf( "Intersecting: %d %d\n", edgemap[edgeInd][0], edgemap[edgeInd][1] )  ;
729         return 1;
730 };
731
732 double getIntersection(int edgeInd)
733 {
734         int i = 3;
735
736         LONG proj0 = cubeProj[i][0] +
737                      vertmap[edgemap[edgeInd][0]][0] * cubeProj[i][1] +
738                      vertmap[edgemap[edgeInd][0]][1] * cubeProj[i][2] +
739                      vertmap[edgemap[edgeInd][0]][2] * cubeProj[i][3];
740         LONG proj1 = cubeProj[i][0] +
741                      vertmap[edgemap[edgeInd][1]][0] * cubeProj[i][1] +
742                      vertmap[edgemap[edgeInd][1]][1] * cubeProj[i][2] +
743                      vertmap[edgemap[edgeInd][1]][2] * cubeProj[i][3];
744         LONG proj2 = inherit->trigProj[i][1];
745
746         /*
747            if ( proj0 < proj1 )
748            {
749             if ( proj2 < proj0 || proj2 > proj1 )
750             {
751                 return -1 ;
752             }
753            }
754            else
755            {
756             if ( proj2 < proj1 || proj2 > proj0 )
757             {
758                 return -1 ;
759             }
760            }
761          */
762
763         double alpha = (double)(proj2 - proj0) / (double)(proj1 - proj0);
764         /*
765            if ( alpha < 0 )
766            {
767             alpha = 0.5 ;
768            }
769            else if ( alpha > 1 )
770            {
771             alpha = 0.5 ;
772            }
773          */
774
775         return alpha;
776 };
777
778 float getIntersectionPrimary(int edgeInd)
779 {
780         int i = 3;
781
782
783         LONG proj0 = cubeProj[i][0];
784         LONG proj1 = cubeProj[i][0] + cubeProj[i][edgeInd + 1];
785         LONG proj2 = inherit->trigProj[i][1];
786         LONG d = proj1 - proj0;
787         double alpha;
788
789         if (d == 0)
790                 alpha = 0.5;
791         else {
792                 alpha = (double)((proj2 - proj0)) / (double)d;
793
794                 if (alpha < 0 || alpha > 1)
795                         alpha = 0.5;
796         }
797
798         return (float)alpha;
799 };
800
801 /**
802  * Method to perform cross-product
803  */
804 void crossProduct(LONG a[3], LONG b[3], LONG res[3])
805 {
806         res[0] = a[1] * b[2] - a[2] * b[1];
807         res[1] = a[2] * b[0] - a[0] * b[2];
808         res[2] = a[0] * b[1] - a[1] * b[0];
809 }
810 void crossProduct(double a[3], double b[3], double res[3])
811 {
812         res[0] = a[1] * b[2] - a[2] * b[1];
813         res[1] = a[2] * b[0] - a[0] * b[2];
814         res[2] = a[0] * b[1] - a[1] * b[0];
815 }
816
817 /**
818  * Method to perform dot product
819  */
820 LONG dotProduct(LONG a[3], LONG b[3])
821 {
822         return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
823 }
824
825 void normalize(double a[3])
826 {
827         double mag = a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
828         if (mag > 0)
829         {
830                 mag = sqrt(mag);
831                 a[0] /= mag;
832                 a[1] /= mag;
833                 a[2] /= mag;
834         }
835 }
836
837 };
838
839 #endif