Fix bug 2540
[scilab.git] / scilab / modules / graphics / includes / math_graphics.h
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 1998 - 2000 - ENPC - Jean-Philipe Chancelier
4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
5  * 
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at    
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14 /*------------------------------------------------------------------------
15  *    Graphic library
16  --------------------------------------------------------------------------*/
17
18 #ifndef __SCIMATH_H__
19 #define __SCIMATH_H__
20 #include <limits.h>
21 #include <math.h>
22 #include <stdlib.h>
23 #include "BOOL.h"
24 #include "core_math.h"
25
26 #ifdef _MSC_VER 
27                 #include <float.h>
28                 #define finite(x) _finite(x) 
29 #else  /* _MSC_VER */ 
30         /** This should only be provided when finite prototype is missing **/
31         /** XXX : to be tested **/
32         #ifndef __cplusplus
33         int finite (double);
34         #endif
35 #endif /* _MSC_VER */
36
37 #ifdef _MSC_VER 
38         #include <float.h>
39         #define ISNAN(x) _isnan(x)
40 #else 
41         #define ISNAN(x) isnan(x)
42 #endif 
43
44
45 #define PI0 (int *) 0
46 #define PD0 (double *) 0
47 #define SMDOUBLE 1.e-200 /* Smalest number to avoid dividing by zero */
48
49 /* angle conversion */
50 #define PI_OVER_180  0.01745329251994329576913914624236578987393
51 #define _180_OVER_PI 57.29577951308232087665461840231273527024
52 #define DEG2RAD(x) ((x) * PI_OVER_180  )
53 #define RAD2DEG(x) ((x) * _180_OVER_PI )
54
55 #define         round(a)        (int)(((a)<0.0)?(a)-.5:(a)+.5)
56 #define EPSILON 1.0e-13
57
58 #define linint(x) ((int)  floor(x + 0.5 )) 
59 #define inint(x) ((int) floor(x + 0.5 ))  
60
61 #if (defined(sun) && defined(SYSV)) 
62 #include <ieeefp.h>
63 #endif
64
65 #if defined(_MSC_VER)
66   #define M_PI 3.14159265358979323846
67 #else
68   #if defined(HAVE_VALUES_H)
69     #include <values.h>
70   #else
71     #if defined(HAVE_LIMITS_H)
72      #include <limits.h>
73     #endif
74   #endif
75 #endif
76
77 #ifndef M_PI
78 #define M_PI 3.14159265358979323846 
79 #endif
80
81 double Mini(const double vect[], int n) ;
82
83 double Maxi(const double vect[], int n) ;
84
85
86
87 /* prototypes */
88
89 /*----------------------------------------------------------------------------*/
90 /************************************************************************/
91 /* 2D algorithms                                                        */
92 /************************************************************************/
93 /* perform the rotation of point from to point dest with angle in radian  */
94 void rotate2D( double from[2], double center[2], double angle, double dest[2] ) ;
95
96 /* perform the rotation of point from to point to. */
97 /* the angle is directly given with its sine and cosine for speed */
98 void rotate2Dim( double from[2]   ,
99                  double center[2] ,
100                  double cosAngle  ,
101                  double sinAngle  ,
102                  double dest[2]    ) ;
103
104 /* perform the translation of point from to point dest with vector trans */
105 void translate2D( double from[2], double trans[2], double dest[2] ) ;
106
107 /* perform the translation of point from to point dest with vector trans given in pixels.*/
108 void iTranslate2D( int from[2], int trans[2], int dest[2] ) ;
109
110 /**
111  * Normalize a 2d vector.
112  */
113 void normalize2d( double vect[2] ) ;
114
115 /**
116  * Normalize a 2d vector in pixels coordinates.
117  */
118 void iNormalize2d( int vect[2] ) ;
119
120 /**
121  * Perform the substraction of vect1 and vect2 and store it in res
122  */
123 void vectSubstract2D(const double vect1[2], const double vect2[], double res[2]);
124
125 /**
126  * substraction of two vector
127  * @param res result of v1 + v2
128  */
129 void vectAdd2D(const double v1[2], const double v2[2], double res[2]);
130
131 /**
132  * Multiply a vector by a scalar
133  * @param res scalar.v
134  */
135 void scalarMult2D(const double v[2], const double scalar, double res[2]);
136
137 /**
138  * return the scalar product of two 2d vectors.
139  */
140 #define DOT_PROD_2D(v1,v2) ( ((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) )
141
142 /**
143  * Square norm of a vector
144  */
145 #define SQUARE_NORM_2D(v) ( DOT_PROD_2D((v),(v)) )
146
147 /**
148  * Norm of a 2D vector
149  */
150 #define NORM_2D(v) ( sqrt( SQUARE_NORM_2D(v) ) )
151
152 /**
153  * Compute wether the point lies within the triangle defined by A, B and C
154  */
155 BOOL isPointInTriangle(const double point[2], const double a[2],
156                        const double b[2], const double c[2]);
157
158 /**
159  * Compute wether p1 and p2 are on the same side of line (A,B).
160  */
161 BOOL areOnSameSideOfLine(const double p1[2], const double p2[2],
162                          const double a[2], const double b[2]);
163
164 /************************************************************************/
165 /* 3D algorithms                                                        */
166 /************************************************************************/
167
168 /**
169  * Scalar product of 2 vectors in 3D
170  */
171 #define DOT_PROD_3D(v1,v2) ( ((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) + ((v1)[2]) * ((v2)[2]) )
172
173 /**
174  * Cross product of two vector
175  * @param res v1^v2
176  */
177 void crossProduct( const double v1[3], const double v2[3], double res[3] ) ;
178
179 /**
180  * Square norm of a 3D vector
181  */
182 #define SQUARE_NORM_3D(v) ( DOT_PROD_3D((v),(v)) )
183
184 /**
185  * Norm of a 3D vector
186  */
187 #define NORM_3D(v) ( sqrt( SQUARE_NORM_3D(v) ) )
188
189 /**
190  * substraction of two vector
191  * @param res result of v1 - v2
192  */
193 void vectSubstract3D(const double v1[3], const double v2[3], double res[3]);
194
195 /**
196  * substraction of two vector
197  * @param res result of v1 + v2
198  */
199 void vectAdd3D(const double v1[3], const double v2[3], double res[3]);
200
201 /**
202  * Multiply a vector by a scalar
203  * @param res scalar.v
204  */
205 void scalarMult3D(const double v[3], double scalar, double res[3]);
206
207 /**
208  * Normalize a 3D vector
209  */
210 void normalize3D( double vect[3] ) ;
211
212 /**
213  * Set a 4x4 matrix to identity.
214  */
215 void setToIdentity(double mat4D[4][4]);
216
217 /**
218  * Compute the product mat4D*vect3D and store the result in res.
219  */
220 void mat4DMult(const double mat4D[4][4], const double vect3D[3], double res[3]);
221
222 /*----------------------------------------------------------------------------*/
223
224 /* check if two values can be considered equal given an accurracy */
225 /* the x == y test is put to avoid division by 0 */
226 #define SAFE_EQUAL(x,y,acc) ( (x) == (y) ) || ( Abs( (x) - (y) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
227
228 /* test if a value if lesser than an other or just sligthy greater */
229 #define SAFE_LT(x,y,acc) ( (x) == (y) || ( (x) - (y) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
230 #define SAFE_GT(x,y,acc) ( (x) == (y) || ( (y) - (x) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
231 /*----------------------------------------------------------------------------*/
232
233 /*----------------------------------------------------------------------------*/
234 /* truncate an int to a 16 bits integer. Overflow value are truncated to the min */
235 /* and max of 16 bits integer. */
236 #define INT_2_16B(i) ( (i) > INT16MAX ? (INT16MAX) : ( (i) < INT16MIN ? INT16MIN : ((SCIINT16) i)) )
237 /*----------------------------------------------------------------------------*/
238
239 /*----------------------------------------------------------------------------*/
240 /* truncate an int to a char. Overflow value are truncated to the min */
241 /* and max of char integer. */
242 #define INT_2_UCHAR(i) ( (i) > UCHAR_MAX ? (UCHAR_MAX) : ( (i) < 0  ? 0 : ((char) i)) )
243 /*----------------------------------------------------------------------------*/
244
245 /*----------------------------------------------------------------------------*/
246 /* truncate a float or double to an int. Overflow value are truncated to the min */
247 /* and max of 32 bits integer. */
248 #define FLOAT_2_INT(f) ( (f) > INT_MAX ? (INT_MAX) : ( (f) < INT_MIN ? (INT_MIN) : ( inint( f ) ) ) )
249 /*----------------------------------------------------------------------------*/
250
251 /*----------------------------------------------------------------------------*/
252 /* return the number of digits of a positive int (ie for 10236 it is 5 )  */
253 /* the added 0.5 is to avoid trouble with 10^i which could become 9.999999999 */
254 #define GET_NB_DIGITS_POS(i) ( (i) == 0 ? 1 : ((int) floor( log10( (i) + 0.5 ) ) ) + 1 )
255 /*----------------------------------------------------------------------------*/
256
257 /*----------------------------------------------------------------------------*/
258 /* return the number of digits of an int (ie for 10236 it is 5 or -102 it is 4 )  */
259 /* For negative values, the length is increased by 1 because of the '-' sign" */
260 #define GET_NB_DIGITS(i) ( (i) > 0 ? GET_NB_DIGITS_POS(i) : GET_NB_DIGITS_POS(-i) + 1 )
261 /*----------------------------------------------------------------------------*/
262
263
264
265
266 #endif /* SCI_MATH.HG */
267