Add zoom functions.
[scilab.git] / scilab / modules / graphics / src / c / math_graphics.c
1 /*------------------------------------------------------------------------
2  *    Graphic library
3  *    Copyright (C) 1998-2001 Enpc/Jean-Philippe Chancelier
4  *    jpc@cermics.enpc.fr 
5  --------------------------------------------------------------------------*/
6
7 #include "math_graphics.h"
8
9 /* 
10  * we use spConfig.h for machine constants 
11  * XXX : spConfig should be merged and unified 
12  *       with other machine constant scilab code 
13  */
14
15 #define spINSIDE_SPARSE
16 #include "../../sparse/includes/spConfig.h"
17
18 double Mini(double *vect, integer n)
19 {
20   int i;
21   double vmin;
22   vmin = LARGEST_REAL;
23   for (i = 0 ; i < n ; i++)
24     /*    if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] < vmin)  */
25     if ( finite(vect[i])== 1 && vect[i] < vmin) 
26       vmin=vect[i];
27   return(vmin);
28 }
29
30 double Maxi(double *vect,integer n)
31 {
32   int i;
33   double maxi;
34   maxi= - LARGEST_REAL;
35   for (i =0 ; i < n ; i++)
36     /* if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] > maxi) */
37     if ( finite(vect[i])== 1 && vect[i] > maxi) 
38       maxi=vect[i];
39   return(maxi);
40 }
41
42 /*----------------------------------------------------------------------------*/
43
44 /* perform the rotation of point from to point dest  */
45 void rotate2D( double from[2], double center[2], double angle, double dest[2] )
46 {
47   rotate2Dim( from, center, cos( angle ), sin( angle ), dest ) ;
48 }
49
50 /*----------------------------------------------------------------------------*/
51 /* perform the rotation of point from to point to. */
52 /* the angle is directly given with its sine and cosine for speed */
53 void rotate2Dim( double from[2]   ,
54                  double center[2] ,
55                  double cosAngle  ,
56                  double sinAngle  ,
57                  double dest[2]    )
58 {
59   double diff[2] ;
60
61   /* put the center to (0,0) */
62   diff[0] = from[0] - center[0] ;
63   diff[1] = from[1] - center[1] ;
64
65   /* turn and translate back */
66   dest[0] = diff[0] * cosAngle - diff[1] * sinAngle + center[0] ;
67   dest[1] = diff[0] * sinAngle + diff[1] * cosAngle + center[1] ;
68 }
69 /*----------------------------------------------------------------------------*/
70 /* perform the rotation of point from to point dest given in int with angle in radian  */
71 void iRotate2D( int from[2], int center[2], double angle, int dest[2] )
72 {
73   iRotate2Dim( from, center, cos( angle ), sin( angle ), dest ) ;
74 }
75
76 /*----------------------------------------------------------------------------*/
77 /* perform the rotation of point from to point to. */
78 /* the angle is directly given with its sine and cosine for speed */
79 void iRotate2Dim( int    from[2]   ,
80                   int    center[2] ,
81                   double cosAngle  ,
82                   double sinAngle  ,
83                   int    dest[2]    )
84 {
85   int diff[2] ;
86
87   /* put the center to (0,0) */
88   diff[0] = from[0] - center[0] ;
89   diff[1] = from[1] - center[1] ;
90
91   /* turn and translate back */
92   dest[0] = round( diff[0] * cosAngle - diff[1] * sinAngle + center[0] ) ;
93   dest[1] = round( diff[0] * sinAngle + diff[1] * cosAngle + center[1] ) ;
94 }
95 /*----------------------------------------------------------------------------*/
96 /* perform an homethety point from to point dest. The 2 factors stand for the ration */
97 /* along the 2 coordinates */
98 void homothety2D( double from[2], double center[2], double factors[2], double dest[2] )
99 {
100   dest[0] = center[0] + factors[0] * ( from[0] - center[0] ) ;
101   dest[1] = center[1] + factors[1] * ( from[1] - center[1] ) ;
102 }
103 /*----------------------------------------------------------------------------*/
104 /* perform an homethety point from to point dest given in pixels. */
105 /* The 2 factors stand for the ration along the 2 coordinates */
106 void iHomothety2D( int from[2], int center[2], double factors[2], int dest[2] )
107 {
108   dest[0] = round( center[0] + factors[0] * ( from[0] - center[0] ) ) ;
109   dest[1] = round( center[1] + factors[1] * ( from[1] - center[1] ) ) ;
110 }
111 /*----------------------------------------------------------------------------*/
112 /* perform the translation of point from to point to with vector trans */
113 void translate2D( double from[2], double trans[2], double dest[2] )
114 {
115   dest[0] = from[0] + trans[0] ;
116   dest[1] = from[1] + trans[1] ;
117 }
118 /*----------------------------------------------------------------------------*/
119 void iTranslate2D( int from[2], int trans[2], int dest[2] )
120 {
121   dest[0] = from[0] + trans[0] ;
122   dest[1] = from[1] + trans[1] ;
123 }
124 /*----------------------------------------------------------------------------*/
125 void vectSubstract2D(const double vect1[2], const double vect2[], double res[2])
126 {
127   res[0] = vect1[0] - vect2[0];
128   res[1] = vect1[1] - vect2[1];
129 }
130 /*----------------------------------------------------------------------------*/
131 void normalize2d( double vect[2] )
132 {
133   double norm = NORM_2D(vect) ;
134   vect[0] /= norm ;
135   vect[1] /= norm ;
136 }
137 /*----------------------------------------------------------------------------*/
138 void iNormalize2d( int vect[2] )
139 {
140   double norm = NORM_2D(vect) ;
141   vect[0] = round( vect[0] / norm ) ;
142   vect[1] = round( vect[1] / norm ) ;
143 }
144 /*----------------------------------------------------------------------------*/
145 void crossProduct( const double v1[3], const double v2[3], double res[3] )
146 {
147   res[0] = v1[1] * v2[2] - v1[2] * v2[1] ;
148   res[1] = v1[2] * v2[0] - v1[0] * v2[2] ;
149   res[2] = v1[0] * v2[1] - v1[1] * v2[0] ;
150 }
151 /*----------------------------------------------------------------------------*/
152 void normalize3D( double vect[3] )
153 {
154   double norm = NORM_3D(vect) ;
155   vect[0] /= norm ;
156   vect[1] /= norm ;
157   vect[2] /= norm ;
158 }
159 /*----------------------------------------------------------------------------*/
160 void setToIdentity(double mat4D[4][4])
161 {
162   int i;
163   int j;
164   for (i = 0; i < 4; i++)
165   {
166     for (j = 0; j < 4; j++)
167     {
168       mat4D[i][j] = 0.0;
169     }
170     mat4D[i][i] = 1.0;
171   }
172 }
173 /*----------------------------------------------------------------------------*/
174 void mat4DMult(const double mat4D[4][4], const double vect3D[3], double res[3])
175 {
176   int i;
177   double res4D[4];
178   // w coordinate of the vector is supposed to be 1;
179   for (i = 0; i < 4; i++) {
180     res4D[i]  =  vect3D[0] * mat4D[i][0] + vect3D[1] * mat4D[i][1]
181                + vect3D[2] * mat4D[i][2] + mat4D[i][3];
182   }
183   res[0] = res4D[0] / res4D[3];
184   res[1] = res4D[1] / res4D[3];
185   res[2] = res4D[2] / res4D[3];
186 }
187 /*----------------------------------------------------------------------------*/
188 /* check if two values can be considered equal given an accurracy */
189 int safeEqual( double val1, double val2, double accuracy )
190 {
191   /* the val1 == val2 is put to avoid division by 0 */
192   return ( val1 == val2 ) || ( Abs( val1 - val2 ) < accuracy * Max( Abs(val1), Abs(val2 ) ) ) ;
193 }
194 /*----------------------------------------------------------------------------*/