Merge remote-tracking branch 'origin/5.4'
[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
21 #include <stdlib.h>
22 #include "dynlib_graphics.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         round(a)        (int)(((a)<0.0)?(a)-.5:(a)+.5)
51 #define EPSILON 1.0e-13
52
53 #define linint(x) ((int)  floor(x + 0.5 ))
54 #define inint(x) ((int) floor(x + 0.5 ))
55
56 #if (defined(sun) || defined(SYSV))
57 #include <ieeefp.h>
58 #endif
59
60 #if defined(_MSC_VER)
61 #define M_PI 3.14159265358979323846
62 #else
63 #if defined(HAVE_VALUES_H)
64 #include <values.h>
65 #else
66 #if defined(HAVE_LIMITS_H)
67 #include <limits.h>
68 #endif
69 #endif
70 #endif
71
72 #ifndef M_PI
73 #define M_PI 3.14159265358979323846
74 #endif
75
76 GRAPHICS_IMPEXP double Mini(const double vect[], int n);
77
78 GRAPHICS_IMPEXP double Maxi(const double vect[], int n);
79
80 GRAPHICS_IMPEXP void MiniMaxi(const double vect[], int n, double * const min, double * const max);
81
82 /* prototypes */
83
84 /*----------------------------------------------------------------------------*/
85 /************************************************************************/
86 /* 2D algorithms                                                        */
87 /************************************************************************/
88 /* perform the rotation of point from to point dest with angle in radian  */
89 GRAPHICS_IMPEXP void rotate2D(double from[2], double center[2], double angle, double dest[2]);
90
91 /* perform the rotation of point from to point to. */
92 /* the angle is directly given with its sine and cosine for speed */
93 GRAPHICS_IMPEXP void rotate2Dim(double from[2]   ,
94                                 double center[2] ,
95                                 double cosAngle  ,
96                                 double sinAngle  ,
97                                 double dest[2]);
98
99 /* perform the translation of point from to point dest with vector trans */
100 GRAPHICS_IMPEXP void translate2D(double from[2], double trans[2], double dest[2]);
101
102 /* perform the translation of point from to point dest with vector trans given in pixels.*/
103 GRAPHICS_IMPEXP void iTranslate2D(int from[2], int trans[2], int dest[2]);
104
105 /**
106  * Normalize a 2d vector.
107  */
108 GRAPHICS_IMPEXP void normalize2d(double vect[2]);
109
110 /**
111  * Normalize a 2d vector in pixels coordinates.
112  */
113 GRAPHICS_IMPEXP void iNormalize2d(int vect[2]);
114
115 /**
116  * Perform the substraction of vect1 and vect2 and store it in res
117  */
118 GRAPHICS_IMPEXP void vectSubstract2D(const double vect1[2], const double vect2[], double res[2]);
119
120 /**
121  * substraction of two vector
122  * @param res result of v1 + v2
123  */
124 GRAPHICS_IMPEXP void vectAdd2D(const double v1[2], const double v2[2], double res[2]);
125
126 /**
127  * Multiply a vector by a scalar
128  * @param res scalar.v
129  */
130 GRAPHICS_IMPEXP void scalarMult2D(const double v[2], const double scalar, double res[2]);
131
132 /**
133  * return the scalar product of two 2d vectors.
134  */
135 #define DOT_PROD_2D(v1,v2) (((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]))
136
137 /**
138  * Square norm of a vector
139  */
140 #define SQUARE_NORM_2D(v) (DOT_PROD_2D((v),(v)))
141
142 /**
143  * Norm of a 2D vector
144  */
145 #define NORM_2D(v) (sqrt(SQUARE_NORM_2D(v)))
146
147 /**
148  * Compute wether the point lies within the triangle defined by A, B and C
149  */
150 GRAPHICS_IMPEXP BOOL isPointInTriangle(const double point[2], const double a[2],
151                                        const double b[2], const double c[2]);
152
153 /**
154  * Compute wether p1 and p2 are on the same side of line (A,B).
155  */
156 GRAPHICS_IMPEXP BOOL areOnSameSideOfLine(const double p1[2], const double p2[2],
157         const double a[2], const double b[2]);
158
159 /************************************************************************/
160 /* 3D algorithms                                                        */
161 /************************************************************************/
162
163 /**
164  * Scalar product of 2 vectors in 3D
165  */
166 #define DOT_PROD_3D(v1,v2) (((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) + ((v1)[2]) * ((v2)[2]))
167
168 /**
169  * Cross product of two vector
170  * @param res v1^v2
171  */
172 GRAPHICS_IMPEXP void crossProduct(const double v1[3], const double v2[3], double res[3]);
173
174 /**
175  * Square norm of a 3D vector
176  */
177 #define SQUARE_NORM_3D(v) (DOT_PROD_3D((v),(v)))
178
179 /**
180  * Norm of a 3D vector
181  */
182 #define NORM_3D(v) (sqrt(SQUARE_NORM_3D(v)))
183
184 /**
185  * substraction of two vector
186  * @param res result of v1 - v2
187  */
188 GRAPHICS_IMPEXP void vectSubstract3D(const double v1[3], const double v2[3], double res[3]);
189
190 /**
191  * substraction of two vector
192  * @param res result of v1 + v2
193  */
194 GRAPHICS_IMPEXP void vectAdd3D(const double v1[3], const double v2[3], double res[3]);
195
196 /**
197  * Multiply a vector by a scalar
198  * @param res scalar.v
199  */
200 GRAPHICS_IMPEXP void scalarMult3D(const double v[3], double scalar, double res[3]);
201
202 /**
203  * Normalize a 3D vector
204  */
205 GRAPHICS_IMPEXP void normalize3D(double vect[3]);
206
207 /**
208  * Set a 4x4 matrix to identity.
209  */
210 GRAPHICS_IMPEXP void setToIdentity(double mat4D[4][4]);
211
212 /**
213  * Compute the product mat4D*vect3D and store the result in res.
214  */
215 GRAPHICS_IMPEXP void mat4DMult(const double mat4D[4][4], const double vect3D[3], double res[3]);
216
217 /*----------------------------------------------------------------------------*/
218
219 /* check if two values can be considered equal given an accurracy */
220 /* the x == y test is put to avoid division by 0 */
221 #define SAFE_EQUAL2(x,y,acc) (Abs((x) - (y)) / Max(Abs((x) + (y)), EPSILON) < (acc))
222
223 #define SAFE_EQUAL(x,y,acc) ((x) == (y)) || (Abs((x) - (y)) < (acc) * Max(Abs((x)), Abs((y))))
224 /* test if a value if lesser than an other or just sligthy greater */
225 #define SAFE_LT(x,y,acc) ((x) == (y) || ((x) - (y)) < (acc) * Max(Abs((x)), Abs((y))))
226 #define SAFE_GT(x,y,acc) ((x) == (y) || ((y) - (x)) < (acc) * Max(Abs((x)), Abs((y))))
227 /*----------------------------------------------------------------------------*/
228
229 /*----------------------------------------------------------------------------*/
230 /* truncate an int to a 16 bits integer. Overflow value are truncated to the min */
231 /* and max of 16 bits integer. */
232 #define INT_2_16B(i) ((i) > INT16MAX ? (INT16MAX) : ((i) < INT16MIN ? INT16MIN : ((SCIINT16) i)))
233 /*----------------------------------------------------------------------------*/
234
235 /*----------------------------------------------------------------------------*/
236 /* truncate an int to a char. Overflow value are truncated to the min */
237 /* and max of char integer. */
238 #define INT_2_UCHAR(i) ((i) > UCHAR_MAX ? (UCHAR_MAX) : ((i) < 0  ? 0 : ((char) i)))
239 /*----------------------------------------------------------------------------*/
240
241 /*----------------------------------------------------------------------------*/
242 /* truncate a float or double to an int. Overflow value are truncated to the min */
243 /* and max of 32 bits integer. */
244 #define FLOAT_2_INT(f) ((f) > INT_MAX ? (INT_MAX) : ((f) < INT_MIN ? (INT_MIN) : (inint(f))))
245 /*----------------------------------------------------------------------------*/
246
247 /*----------------------------------------------------------------------------*/
248 /* return the number of digits of a positive int (ie for 10236 it is 5)  */
249 /* the added 0.5 is to avoid trouble with 10^i which could become 9.999999999 */
250 #define GET_NB_DIGITS_POS(i) ((i) == 0 ? 1 : ((int) floor(log10((i) + 0.5))) + 1)
251 /*----------------------------------------------------------------------------*/
252
253 /*----------------------------------------------------------------------------*/
254 /* return the number of digits of an int (ie for 10236 it is 5 or -102 it is 4)  */
255 /* For negative values, the length is increased by 1 because of the '-' sign" */
256 #define GET_NB_DIGITS(i) ((i) > 0 ? GET_NB_DIGITS_POS(i) : GET_NB_DIGITS_POS(-i) + 1)
257 /*----------------------------------------------------------------------------*/
258
259
260
261
262 #endif /* SCI_MATH.HG */
263