add some includes
[scilab.git] / scilab / modules / scicos_blocks / src / c / cmscope.c
1 /*  Scicos
2 *
3 *  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 *
19 * See the file ./license.txt
20 */
21 /**
22    \file cmscope.c
23    \author Benoit Bayol
24    \version 1.0
25    \date September 2006 - January 2007
26    \brief CMSCOPE is a typical scope which links its input to the simulation time
27    \see CMSCOPE.sci in macros/scicos_blocks/Sinks/
28 */
29 #include "CurrentObjectsManagement.h"
30 #include "scoMemoryScope.h"
31 #include "scoWindowScope.h"
32 #include "scoMisc.h"
33 #include "scoGetProperty.h"
34 #include "scoSetProperty.h"
35 #include "scicos_block4.h"
36
37 /** \fn cmscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
38     \brief Function to draw or redraw the window
39 */
40 void cmscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
41 {
42   int i; //As usual
43   int * ipar; //Integer Parameters
44   int * colors; //Colors
45   int win; //Windows ID : To give a name to the window
46   int buffer_size; //Buffer Size
47   int win_pos[2]; //Position of the Window
48   int win_dim[2]; //Dimension of the Window
49   int inherited_events;
50   int nipar;
51   int dimension = 2;
52   double * rpar; //Reals parameters
53   double dt; //Time++
54   double * period; //Refresh Period of the scope is a vector here
55   double * ymin,* ymax; //Ymin and Ymax are vectors here
56   double * xmin, *xmax;
57   int nbr_period;
58   int * number_of_curves_by_subwin;
59   int number_of_subwin;
60   int nbr_total_curves;
61
62
63   rpar = GetRparPtrs(block);
64   ipar = GetIparPtrs(block);
65   nipar = GetNipar(block);
66   win = ipar[0];
67   number_of_subwin = ipar[1];
68   buffer_size = ipar[2];
69   win_pos[0] = ipar[3];
70   win_pos[1] = ipar[4];
71   win_dim[0] = ipar[5];
72   win_dim[1] = ipar[6];
73   nbr_total_curves = 0;
74   //Don't forget malloc for 'type *'
75   number_of_curves_by_subwin = (int*)scicos_malloc(number_of_subwin*sizeof(int));
76   for (i = 7; i < 7+number_of_subwin ; i++)
77     {
78       number_of_curves_by_subwin[i-7] = ipar[i];
79       nbr_total_curves = nbr_total_curves + ipar[i];
80     }
81   colors = (int*)scicos_malloc(nbr_total_curves*sizeof(int));
82   for(i = 0; i < nbr_total_curves ; i++)
83     {
84       colors[i] = ipar[i+7+number_of_subwin];
85     }
86   inherited_events = ipar[7+number_of_subwin+number_of_subwin];
87
88   dt = rpar[0];
89
90   nbr_period = 0;
91   period = (double*)scicos_malloc(number_of_subwin*sizeof(double));
92   for (i = 0 ; i < number_of_subwin ; i++)
93     {
94       period[i] = rpar[i+1];
95       nbr_period++; 
96     }
97   ymin = (double*)scicos_malloc(number_of_subwin*sizeof(double));
98   ymax = (double*)scicos_malloc(number_of_subwin*sizeof(double));
99   for (i = 0 ; i < number_of_subwin ; i++)
100     {
101       ymin[i] = rpar[2*i+nbr_period+1];
102       ymax[i] = rpar[2*i+nbr_period+2];
103     }
104
105   /*Allocating memory*/
106   if(firstdraw == 1)
107     {
108
109       scoInitScopeMemory(block->work,pScopeMemory, number_of_subwin, number_of_curves_by_subwin);
110       for(i = 0 ; i < number_of_subwin ; i++)
111         {
112           scoSetLongDrawSize(*pScopeMemory, i, 5000);
113           scoSetShortDrawSize(*pScopeMemory,i,buffer_size);
114           scoSetPeriod(*pScopeMemory,i,period[i]);
115         }    
116     }
117
118   /* Xmin and Xmax are calculated here because we need a variable which is only existing in the pScopeMemory. pScopeMemory is allocated just few lines before. Indeed in this TimeAmplitudeScope Xmin and Xmax have to change often. To be sure to redraw in the correct scale we have to calculate xmin and xmax thanks to the period_counter. If the window haven't to be redraw (recreate)  it wouldn't be necessary*/
119   xmin = (double*)scicos_malloc(number_of_subwin*sizeof(double));
120   xmax = (double*)scicos_malloc(number_of_subwin*sizeof(double));
121   for (i = 0 ; i < number_of_subwin ; i++)
122     {
123       xmin[i] = period[i]*(scoGetPeriodCounter(*pScopeMemory,i));
124       xmax[i] = period[i]*(scoGetPeriodCounter(*pScopeMemory,i)+1);
125     }
126
127   /*Creating the Scope*/
128   scoInitOfWindow(*pScopeMemory, dimension, win, win_pos, win_dim, xmin, xmax, ymin, ymax, NULL, NULL);
129   if(scoGetScopeActivation(*pScopeMemory) == 1)
130     {
131       scoAddTitlesScope(*pScopeMemory,"t","y",NULL);
132
133   /*Add a couple of polyline : one for the shortdraw and one for the longdraw*/
134   /*    scoAddPolylineLineStyle(*pScopeMemory,colors); */
135       scoAddCoupleOfPolylines(*pScopeMemory,colors);
136     }
137   scicos_free(number_of_curves_by_subwin);
138   scicos_free(colors);
139   scicos_free(period);
140   scicos_free(ymin);
141   scicos_free(ymax);
142   scicos_free(xmin);
143   scicos_free(xmax);
144 }
145
146 /** \fn void cmscope(scicos_block * block, int flag)
147     \brief the computational function
148     \param block A pointer to a scicos_block
149     \param flag An integer which indicates the state of the block (init, update, ending)
150 */
151 void cmscope(scicos_block * block, int flag)
152 {
153   /* Declarations */
154   ScopeMemory * pScopeMemory;
155   int NbrPtsShort;
156   double * u1;
157   double t; //get_scicos_time()
158   scoGraphicalObject pShortDraw;
159   int i,j;
160
161
162   /* Initializations and Allocations*/
163   //Allocations are done here because there are dependent of some values presents below
164  
165   /* State Machine Control */
166   switch(flag)
167     {
168     case Initialization:
169       {
170         cmscope_draw(block,&pScopeMemory,1);
171         break; //Break of the switch condition don t forget it
172       } //End of Initialization
173   
174     case StateUpdate:
175       {
176         /*Retreiving Scope in the block->work*/
177         scoRetrieveScopeMemory(block->work,&pScopeMemory);
178         if(scoGetScopeActivation(pScopeMemory) == 1)
179           {
180             /* Charging Elements */
181             t = get_scicos_time();
182             /* If window has been destroyed we recreate it */
183             if(scoGetPointerScopeWindow(pScopeMemory) == NULL)
184               {
185                 cmscope_draw(block,&pScopeMemory,0);
186               }
187
188             scoRefreshDataBoundsX(pScopeMemory,t);
189
190             //Here we are calculating the points in the polylines
191             for (i = 0 ; i < scoGetNumberOfSubwin(pScopeMemory) ; i++)
192               {
193                 u1 = GetRealInPortPtrs(block,i+1);
194                 pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,0);
195                 NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1;
196                 for (j = 0; j < scoGetNumberOfCurvesBySubwin(pScopeMemory,i) ; j++)
197                   {
198                     pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,j);
199                     pPOLYLINE_FEATURE(pShortDraw)->pvx[NbrPtsShort] = t;
200                     pPOLYLINE_FEATURE(pShortDraw)->pvy[NbrPtsShort] = u1[j];
201                     pPOLYLINE_FEATURE(pShortDraw)->n1++;
202                   }
203               }
204
205             scoDrawScopeAmplitudeTimeStyle(pScopeMemory, t);
206
207             
208             //Break of the switch don t forget it !
209           }//End of stateupdate
210         break; 
211         //This case is activated when the simulation is done or when we close scicos
212       }
213     case Ending:
214       {
215         scoRetrieveScopeMemory(block->work, &pScopeMemory);
216         if(scoGetScopeActivation(pScopeMemory) == 1)
217           {
218             sciSetUsedWindow(scoGetWindowID(pScopeMemory));
219             pShortDraw = sciGetCurrentFigure();
220             pFIGURE_FEATURE(pShortDraw)->user_data = NULL;
221             pFIGURE_FEATURE(pShortDraw)->size_of_user_data = 0;
222             scoDelCoupleOfPolylines(pScopeMemory);
223
224           }
225         scoFreeScopeMemory(block->work, &pScopeMemory);
226
227         break;
228       }
229     }
230 }