Add some geometric functions.
[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 "machine.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 __PARAMS((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 (integer *) 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) ((integer) 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(double *vect, integer n) ;
82
83 double Maxi(double *vect,integer n) ;
84
85 extern double exp10 __PARAMS((double));
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 rotation of point from to point dest given in int with angle in radian  */
105 void iRotate2D( int from[2], int center[2], double angle, int dest[2] ) ;
106
107 /* perform the rotation of point from to point dest given in int. */
108 /* the angle is directly given with its sine and cosine for speed */
109 void iRotate2Dim( int    from[2]   ,
110                   int    center[2] ,
111                   double cosAngle  ,
112                   double sinAngle  ,
113                   int    dest[2]    ) ;
114
115 /* perform an homethety point from to point dest. The 2 factors stand for the ration */
116 /* along the 2 coordinates */
117 void homothety2D( double from[2], double center[2], double factors[2], double dest[2] ) ;
118
119 /* perform an homethety point from to point dest given in pixels. */
120 /* The 2 factors stand for the ration along the 2 coordinates */
121 void iHomothety2D( int from[2], int center[2], double factors[2], int dest[2] ) ;
122
123
124 /* perform the translation of point from to point dest with vector trans */
125 void translate2D( double from[2], double trans[2], double dest[2] ) ;
126
127 /* perform the translation of point from to point dest with vector trans given in pixels.*/
128 void iTranslate2D( int from[2], int trans[2], int dest[2] ) ;
129
130 /**
131  * Normalize a 2d vector.
132  */
133 void normalize2d( double vect[2] ) ;
134
135 /**
136  * Normalize a 2d vector in pixels coordinates.
137  */
138 void iNormalize2d( int vect[2] ) ;
139
140 /**
141  * Perform the substraction of vect1 and vect2 and store it in res
142  */
143 void vectSubstract2D(const double vect1[2], const double vect2[], double res[2]);
144
145 /**
146  * return the scalar product of two 2d vectors.
147  */
148 #define DOT_PROD_2D(v1,v2) ( ((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) )
149
150 /**
151  * Square norm of a vector
152  */
153 #define SQUARE_NORM_2D(v) ( DOT_PROD_2D((v),(v)) )
154
155 /**
156  * Norm of a 2D vector
157  */
158 #define NORM_2D(v) ( sqrt( SQUARE_NORM_2D(v) ) )
159
160 /************************************************************************/
161 /* 3D algorithms                                                        */
162 /************************************************************************/
163
164 /**
165  * Scalar product of 2 vectors in 3D
166  */
167 #define DOT_PROD_3D(v1,v2) ( ((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) + ((v1)[2]) * ((v2)[2]) )
168
169 /**
170  * Cross product of two vector
171  * @param res v1^v2
172  */
173 void crossProduct( const double v1[3], const double v2[3], double res[3] ) ;
174
175 /**
176  * Square norm of a 3D vector
177  */
178 #define SQUARE_NORM_3D(v) ( DOT_PROD_3D((v),(v)) )
179
180 /**
181  * Norm of a 3D vector
182  */
183 #define NORM_3D(v) ( sqrt( SQUARE_NORM_3D(v) ) )
184
185 /**
186  * substraction of two vector
187  * @param res result of v1 - v2
188  */
189 void vectSubstract3D( double v1[3], double v2[3], double res[3]);
190
191 /**
192  * Multiply a vector by a scalar
193  * @param res scalar.v
194  */
195 void scalarMult3D( double v[3], double scalar, double res[3]);
196
197 /**
198  * Normalize a 3D vector
199  */
200 void normalize3D( double vect[3] ) ;
201
202 /**
203  * Set a 4x4 matrix to identity.
204  */
205 void setToIdentity(double mat4D[4][4]);
206
207 /**
208  * Compute the product mat4D*vect3D and store the result in res.
209  */
210 void mat4DMult(const double mat4D[4][4], const double vect3D[3], double res[3]);
211
212 /*----------------------------------------------------------------------------*/
213 /* check if two values can be considered equal given an accurracy */
214 int safeEqual( double val1, double val2, double accuracy ) ;
215
216 /* with a macro it is faster */
217 /* the x == y test is put to avoid division by 0 */
218 #define SAFE_EQUAL(x,y,acc) ( (x) == (y) ) || ( Abs( (x) - (y) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
219
220 /* test if a value if lesser than an other or just sligthy greater */
221 #define SAFE_LT(x,y,acc) ( (x) == (y) || ( (x) - (y) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
222 #define SAFE_GT(x,y,acc) ( (x) == (y) || ( (y) - (x) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
223 /*----------------------------------------------------------------------------*/
224
225 /*----------------------------------------------------------------------------*/
226 /* truncate an integer to a 16 bits integer. Overflow value are truncated to the min */
227 /* and max of 16 bits integer. */
228 #define INT_2_16B(i) ( (i) > INT16MAX ? (INT16MAX) : ( (i) < INT16MIN ? INT16MIN : ((SCIINT16) i)) )
229 /*----------------------------------------------------------------------------*/
230
231 /*----------------------------------------------------------------------------*/
232 /* truncate an integer to a char. Overflow value are truncated to the min */
233 /* and max of char integer. */
234 #define INT_2_UCHAR(i) ( (i) > UCHAR_MAX ? (UCHAR_MAX) : ( (i) < 0  ? 0 : ((char) i)) )
235 /*----------------------------------------------------------------------------*/
236
237 /*----------------------------------------------------------------------------*/
238 /* truncate a float or double to an int. Overflow value are truncated to the min */
239 /* and max of 32 bits integer. */
240 #define FLOAT_2_INT(f) ( (f) > INT_MAX ? (INT_MAX) : ( (f) < INT_MIN ? (INT_MIN) : ( inint( f ) ) ) )
241 /*----------------------------------------------------------------------------*/
242
243 /*----------------------------------------------------------------------------*/
244 /* return the number of digits of a positive integer (ie for 10236 it is 5 )  */
245 /* the added 0.5 is to avoid trouble with 10^i which could become 9.999999999 */
246 #define GET_NB_DIGITS(i) ( (i) == 0 ? 1 : ((int) floor( log10( (i) + 0.5 ) ) ) + 1 )
247 /*----------------------------------------------------------------------------*/
248
249
250
251
252
253 #endif /* SCI_MATH.HG */
254