Scilab [trunk]: scilab/modules/graphics/src/c/DrawObjects.c File Reference

#define round ( a ) (int)(((a)<0.0)?(a)-.5:(a)+.5)

Definition at line 69 of file DrawObjects.c.

int AdaptGraduationsOnXBottomLeft	(	int	iof,
		int	x,
		int	y,
		int	size,
		integer *	Ticsdir,
		int *	fontid,
		sciPointObj *	psubwin,
		double	xminval,
		double	xmaxval,
		double	fx,
		double	fy,
		double	fz
	)

Definition at line 1790 of file DrawObjects.c.

References sciSubWindow::axes, C2F, CheckDisplay(), ChoixFormatE(), ChooseFormatForOneGrad(), ComputeGoodTrans3d(), dr(), foo(), sciSubWindow::FRect, i, inint, int, InvAxis(), IsDownAxes(), sciSubWindow::logflags, AXES::nbsubtics, AXES::nxgrads, pas, pSUBWIN_FEATURE, AXES::reverse, TRUE, and AXES::xgrads.

01791 {
01792   int i;
01793   int nbtics, nbsubtics;
01794   int lastxindex;
01795   int old_rect[4];
01796   int nb_grads_max = 0;
01797   int vx[2], vy[2];
01798   int xm, ym;
01799   double grads_tmp[20];
01800   char c_format[5];
01801   integer barlengthx = 0,barlengthy = 0;
01802   integer rect[4],posi[2]; 
01803   integer textcolor = -1;
01804   int logrect[4],XX,YY;
01805   int pas;
01806   double fact_h = 1.5, fact_w = 1.5;
01807   int compteur = 0;
01808 
01809   int possible_pas, possible_compteur;
01810   
01811   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
01812   
01813   for(i=0;i<4;i++) old_rect[i] = 0; /* Init. old_rect to force first grad. to be displayed */
01814   
01815   lastxindex = ppsubwin->axes.nxgrads - 1;
01816   
01817   if(lastxindex == 0)
01818     ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.xgrads[0]));
01819   else
01820     ChoixFormatE(c_format,
01821                  ppsubwin->axes.xgrads[0],
01822                  ppsubwin->axes.xgrads[lastxindex],
01823                  ((ppsubwin->axes.xgrads[lastxindex])-(ppsubwin->axes.xgrads[0]))/(lastxindex));
01824   
01825   nbtics = ppsubwin->axes.nxgrads;
01826   nbsubtics = ppsubwin->axes.nbsubtics[0];
01827   
01828   
01829   for(i=0;i<nbtics;i++) grads_tmp[i] = ppsubwin->axes.xgrads[i];
01830 
01831   for(i=0;i<nbtics;i++)
01832     {
01833       char foo[256]; 
01834       double xtmp = ppsubwin->axes.xgrads[i];
01835                   
01836       sprintf(foo,c_format,xtmp);
01837 
01838       /***************************************************************/
01839       /************************* COMMON PART *************************/
01840       /***************************************************************/
01841       if(ppsubwin->axes.reverse[0] == TRUE)
01842         xtmp = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp);
01843                   
01844       ComputeGoodTrans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz);
01845                   
01846       vx[0]=xm;vy[0]=ym; 
01847                   
01848       barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
01849       barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
01850 
01851       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
01852       C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01853       
01854 
01855       if (IsDownAxes(psubwin)){
01856         vx[1]=vx[0];
01857         vy[1]=vy[0]+iof/2;
01858         posi[0] = inint(xm-rect[2]/2); 
01859         posi[1]=inint( vy[0] + iof + rect[3]);}
01860       else{
01861         vx[1]=vx[0]+barlengthx;
01862         vy[1]=vy[0]+barlengthy;
01863         posi[0] = inint( xm+2*barlengthx-rect[2]); 
01864         posi[1]=inint( ym + 2*barlengthy + rect[3]);}
01865       
01866       /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
01867       C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);       
01868       
01869       
01870       if(CheckDisplay(fact_h, fact_w, ppsubwin->logflags[0],foo,posi,fontid,old_rect) == 0)
01871         continue; /*  graduation too close, DO NOT display the graduation ! */
01872       
01873       
01874       C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01875       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01876       if ( ppsubwin->logflags[0] == 'l' )
01877         {
01878           int smallersize = fontid[1]-2;
01879           int old_rect10[4];
01880           int posi10[2];
01881 
01882           posi10[0] = posi[0] - logrect[2];
01883           posi10[1] = posi[1] + logrect[3];
01884           
01885           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01886           
01887           C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01888           
01889           posi[0] = old_rect10[0] + old_rect10[2];
01890           posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);
01891           
01892           C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01893           C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01894           
01895           /* update old_rect */
01896           old_rect[2] = (int)(fact_w*(old_rect[2] + old_rect10[2]));
01897           old_rect[3] = (int)(fact_h*(old_rect[3] + old_rect10[3] + (int) (old_rect10[3]*.1)));
01898           old_rect[0] = old_rect10[0];
01899           old_rect[1] = old_rect[1];
01900           
01901           nb_grads_max++;
01902           
01903           /* put back the current fontid */
01904           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01905         }
01906       else{
01907         /* update old_rect */
01908         C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01909         old_rect[3] = (int)(fact_h* old_rect[3]);
01910         old_rect[2] = (int)(fact_w* old_rect[2]);
01911         nb_grads_max++;
01912       }
01913     }
01914   
01915   if(ppsubwin->logflags[0] != 'l')
01916     if(nb_grads_max == 1) /* only one grad. can be displayed : we choose to display the average value (max+min)/2 */
01917       {
01918         ppsubwin->axes.xgrads[0] = (grads_tmp[0]+grads_tmp[lastxindex])/2.;
01919         ppsubwin->axes.nxgrads = 1;
01920         if ( !ppsubwin->flagNax )
01921         {
01922           ppsubwin->axes.nbsubtics[0] = 1;
01923         }
01924         return 0;
01925       }
01926   
01927   
01928   pas = nbtics - 2; /* pas == grads number - 2 */
01929   
01930   possible_pas = -99;
01931   possible_compteur = -99;
01932   
01933   while(pas > 0)
01934     {
01935       int tmp = 0;
01936       compteur = 0;
01937       for(;;)
01938         {
01939           tmp = tmp + pas;
01940           compteur++;
01941           
01942           if((tmp == (nbtics - 1)) && (compteur < nb_grads_max)){
01943             possible_pas = pas;
01944             possible_compteur = ++compteur;
01945             break;
01946           }
01947           
01948           if(tmp > (nbtics - 1))
01949             break;
01950         }
01951       
01952       pas--;
01953     }
01954   
01955   
01956   if(possible_compteur != -99){
01957     compteur = possible_compteur;
01958     pas = possible_pas;
01959     
01960     for(i=0;i<compteur;i++)
01961       ppsubwin->axes.xgrads[i] = grads_tmp[i*pas];
01962     
01963     ppsubwin->axes.nxgrads = compteur;
01964     
01965     /* Nb of subtics computation and storage */
01966     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
01967     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTicsFor3dUse(psubwin,
01968                                                            ppsubwin->axes.nxgrads,
01969                                                            ppsubwin->logflags[0],
01970                                                            ppsubwin->axes.xgrads,
01971                                                            ppsubwin->axes.nbsubtics[0]); 
01972   }
01973   else{
01974     ppsubwin->axes.xgrads[0] = grads_tmp[0];
01975     ppsubwin->axes.xgrads[1] = grads_tmp[lastxindex];
01976     ppsubwin->axes.nxgrads = 2;
01977     /* Nb of subtics computation and storage */
01978     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
01979     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTicsFor3dUse(psubwin,
01980                                                            ppsubwin->axes.nxgrads,
01981                                                            ppsubwin->logflags[0],
01982                                                            ppsubwin->axes.xgrads,
01983                                                            ppsubwin->axes.nbsubtics[0]); 
01984     
01985     if(ppsubwin->logflags[0] == 'n'){
01986       if(nb_grads_max > 4) {
01987         /* we could display at least 4 graduations but we did not find a proper interval... */
01988         /* To avoid to display only the min and max (see above), we add 2 newly created grads by interpolating between min and max */
01989         double pas_ = (grads_tmp[lastxindex]-grads_tmp[0])/3;
01990         for(i=0;i<3;i++){
01991           ppsubwin->axes.xgrads[i] = grads_tmp[0] + i*pas_;
01992         }
01993         
01994         ppsubwin->axes.xgrads[3] = grads_tmp[lastxindex]; /* exact max */
01995         ppsubwin->axes.nxgrads = 4;
01996         
01997         /* Nb of subtics computation and storage */
01998         /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
01999         ppsubwin->axes.nbsubtics[0] = ComputeNbSubTicsFor3dUse(psubwin,
02000                                                                ppsubwin->axes.nxgrads,
02001                                                                'n',
02002                                                                ppsubwin->axes.xgrads,
02003                                                                ppsubwin->axes.nbsubtics[0]); 
02004       }
02005     }
02006   }
02007   
02008   return 0;
02009 }

Here is the call graph for this function:

int AdaptGraduationsOnXBottomRight	(	int	iof,
		int	x,
		int	y,
		int	size,
		integer *	Ticsdir,
		int *	fontid,
		sciPointObj *	psubwin,
		double	xminval,
		double	xmaxval,
		double	fx,
		double	fy,
		double	fz
	)

Definition at line 2238 of file DrawObjects.c.

References sciSubWindow::axes, C2F, CheckDisplay(), ChoixFormatE(), ChooseFormatForOneGrad(), ComputeGoodTrans3d(), dr(), foo(), sciSubWindow::FRect, i, inint, int, InvAxis(), IsDownAxes(), sciSubWindow::logflags, AXES::nbsubtics, AXES::nxgrads, pas, pSUBWIN_FEATURE, AXES::reverse, TRUE, and AXES::xgrads.

02239 {
02240   int i;
02241   int nbtics, nbsubtics;
02242   int lastxindex;
02243   int old_rect[4];
02244   int nb_grads_max = 0;
02245   int vx[2], vy[2];
02246   int xm, ym;
02247   double grads_tmp[20];
02248   char c_format[5];
02249   integer barlengthx = 0,barlengthy = 0;
02250   integer rect[4],posi[2]; 
02251   integer textcolor = -1;
02252   int logrect[4] ;
02253   int XX = 0;
02254   int YY = 0 ;
02255   int pas;
02256   double fact_h = 1.5, fact_w = 1.5;
02257   int compteur = 0;
02258 
02259   int possible_pas, possible_compteur;
02260   
02261   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
02262   
02263   for(i=0;i<4;i++) old_rect[i] = 0; /* Init. old_rect to force first grad. to be displayed */
02264   
02265   lastxindex = ppsubwin->axes.nxgrads - 1;
02266   
02267   if(lastxindex == 0)
02268     ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.xgrads[0]));
02269   else
02270     ChoixFormatE(c_format,
02271                  ppsubwin->axes.xgrads[0],
02272                  ppsubwin->axes.xgrads[lastxindex],
02273                  ((ppsubwin->axes.xgrads[lastxindex])-(ppsubwin->axes.xgrads[0]))/(lastxindex));
02274   
02275   nbtics = ppsubwin->axes.nxgrads;
02276   nbsubtics = ppsubwin->axes.nbsubtics[0];
02277   
02278   
02279   for(i=0;i<nbtics;i++) grads_tmp[i] = ppsubwin->axes.xgrads[i];
02280 
02281   for(i=0;i<nbtics;i++)
02282     {
02283       char foo[256]; 
02284       double xtmp = ppsubwin->axes.xgrads[i];
02285                   
02286       sprintf(foo,c_format,xtmp);
02287 
02288       /***************************************************************/
02289       /************************* COMMON PART *************************/
02290       /***************************************************************/
02291       if(ppsubwin->axes.reverse[0] == TRUE)
02292         xtmp = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp);
02293                   
02294       ComputeGoodTrans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz);
02295                   
02296       vx[0]=xm;vy[0]=ym; 
02297                   
02298       barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
02299       barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
02300 
02301       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
02302       C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02303       
02304 
02305       if (IsDownAxes(psubwin)){
02306         vx[1]=vx[0];
02307         vy[1]=vy[0]+iof/2;
02308         posi[0] = inint(xm-rect[2]/2); 
02309         posi[1]=inint( vy[0] + iof + rect[3]);}
02310       else{
02311         vx[1]=vx[0]+barlengthx;
02312         vy[1]=vy[0]+barlengthy;
02313         posi[0] = inint( xm+2*barlengthx);
02314         posi[1]=inint( ym + 2*barlengthy + rect[3]);}
02315                       
02316       
02317       /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
02318       C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);       
02319       
02320       
02321       if(CheckDisplay(fact_h, fact_w, ppsubwin->logflags[0],foo,posi,fontid,old_rect) == 0)
02322         continue; /*  graduation too close, DO NOT display the graduation ! */
02323       
02324       
02325       C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02326       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02327       if ( ppsubwin->logflags[0] == 'l' )
02328         {
02329           int smallersize = fontid[1]-2;
02330           int old_rect10[4];
02331           int posi10[2];
02332 
02333           posi10[0] = posi[0] - logrect[2];
02334           posi10[1] = posi[1] + logrect[3];
02335           
02336           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02337           
02338           C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02339           
02340           posi[0] = old_rect10[0] + old_rect10[2];
02341           posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);
02342           
02343           C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02344           C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02345           
02346           /* update old_rect */
02347           old_rect[2] = (int)(fact_w*(old_rect[2] + old_rect10[2]));
02348           old_rect[3] = (int)(fact_h*(old_rect[3] + old_rect10[3] + (int) (old_rect10[3]*.1)));
02349           old_rect[0] = old_rect10[0];
02350           old_rect[1] = old_rect[1];
02351           
02352           nb_grads_max++;
02353           
02354           /* put back the current fontid */
02355           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02356         }
02357       else{
02358         /* update old_rect */
02359         C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02360         old_rect[3] = (int)(fact_h* old_rect[3]);
02361         old_rect[2] = (int)(fact_w* old_rect[2]);
02362         nb_grads_max++;
02363       }
02364     }
02365   
02366   if(ppsubwin->logflags[0] != 'l')
02367     if(nb_grads_max == 1) /* only one grad. can be displayed : we choose to display the average value (max+min)/2 */
02368       {
02369         ppsubwin->axes.xgrads[0] = (grads_tmp[0]+grads_tmp[lastxindex])/2.;
02370         ppsubwin->axes.nxgrads = 1;
02371         if ( !ppsubwin->flagNax )
02372         {
02373           ppsubwin->axes.nbsubtics[0] = 1;
02374         }
02375         return 0;
02376       }
02377   
02378   
02379   pas = nbtics - 2; /* pas == grads number - 2 */
02380   
02381   possible_pas = -99;
02382   possible_compteur = -99;
02383   
02384   while(pas > 0)
02385     {
02386       int tmp = 0;
02387       compteur = 0;
02388       for(;;)
02389         {
02390           tmp = tmp + pas;
02391           compteur++;
02392           
02393           if((tmp == (nbtics - 1)) && (compteur < nb_grads_max)){
02394             possible_pas = pas;
02395             possible_compteur = ++compteur;
02396             break;
02397           }
02398           
02399           if(tmp > (nbtics - 1))
02400             break;
02401         }
02402       
02403       pas--;
02404     }
02405   
02406   
02407   if(possible_compteur != -99){
02408     compteur = possible_compteur;
02409     pas = possible_pas;
02410     
02411     for(i=0;i<compteur;i++)
02412       ppsubwin->axes.xgrads[i] = grads_tmp[i*pas];
02413     
02414     ppsubwin->axes.nxgrads = compteur;
02415     
02416     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTicsFor3dUse(psubwin,
02417                                                            ppsubwin->axes.nxgrads,
02418                                                            ppsubwin->logflags[0],
02419                                                            ppsubwin->axes.xgrads,
02420                                                            ppsubwin->axes.nbsubtics[0]);
02421   }
02422   else{
02423     ppsubwin->axes.xgrads[0] = grads_tmp[0];
02424     ppsubwin->axes.xgrads[1] = grads_tmp[lastxindex];
02425     ppsubwin->axes.nxgrads = 2;
02426     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTicsFor3dUse(psubwin,
02427                                                            ppsubwin->axes.nxgrads,
02428                                                            ppsubwin->logflags[0],
02429                                                            ppsubwin->axes.xgrads,
02430                                                            ppsubwin->axes.nbsubtics[0]);
02431     if(ppsubwin->logflags[0] == 'n'){
02432       if(nb_grads_max > 4) {
02433         /* we could display at least 4 graduations but we did not find a proper interval... */
02434         /* To avoid to display only the min and max (see above), we add 2 newly created grads by interpolating between min and max */
02435         double pas_ = (grads_tmp[lastxindex]-grads_tmp[0])/3;
02436         for(i=0;i<3;i++){
02437           ppsubwin->axes.xgrads[i] = grads_tmp[0] + i*pas_;
02438         }
02439         
02440         ppsubwin->axes.xgrads[3] = grads_tmp[lastxindex]; /* exact max */
02441         ppsubwin->axes.nxgrads = 4;
02442         ppsubwin->axes.nbsubtics[0] = ComputeNbSubTicsFor3dUse(psubwin,
02443                                                                ppsubwin->axes.nxgrads,
02444                                                                'n',
02445                                                                ppsubwin->axes.xgrads,
02446                                                                ppsubwin->axes.nbsubtics[0] );
02447       }
02448     }
02449   }
02450   
02451   return 0;
02452 }

Here is the call graph for this function:

int AdaptGraduationsOnYBottomLeft	(	int	iof,
		int	x,
		int	y,
		int	size,
		integer *	Ticsdir,
		int *	fontid,
		sciPointObj *	psubwin,
		double	yminval,
		double	ymaxval,
		double	fx,
		double	fy,
		double	fz
	)

Definition at line 1565 of file DrawObjects.c.

References sciSubWindow::axes, C2F, CheckDisplay(), ChoixFormatE(), ChooseFormatForOneGrad(), ComputeGoodTrans3d(), dr(), foo(), sciSubWindow::FRect, i, inint, int, InvAxis(), IsDownAxes(), sciSubWindow::logflags, AXES::nbsubtics, AXES::nygrads, pas, pSUBWIN_FEATURE, AXES::reverse, TRUE, and AXES::ygrads.

01566 {
01567   int i;
01568   int nbtics, nbsubtics;
01569   int lastyindex;
01570   int old_rect[4];
01571   int nb_grads_max = 0;
01572   int vx[2], vy[2];
01573   int xm, ym;
01574   double grads_tmp[20];
01575   char c_format[5];
01576   integer barlengthx = 0,barlengthy = 0;
01577   integer rect[4],posi[2];
01578   integer textcolor = -1;
01579   int logrect[4] ;
01580   int XX = 0 ;
01581   int YY = 0 ;
01582   int pas;
01583   double fact_h = 1.5, fact_w = 1.5;
01584   int compteur = 0;
01585 
01586   int possible_pas, possible_compteur;
01587   
01588   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
01589   
01590   for(i=0;i<4;i++) { old_rect[i] = 0 ; } /* Init. old_rect to force first grad. to be displayed */
01591   
01592   lastyindex = ppsubwin->axes.nygrads - 1;
01593   
01594   if(lastyindex == 0)
01595     ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.ygrads[0]));
01596   else
01597     ChoixFormatE(c_format,
01598                  ppsubwin->axes.ygrads[0],
01599                  ppsubwin->axes.ygrads[lastyindex],
01600                  ((ppsubwin->axes.ygrads[lastyindex])-(ppsubwin->axes.ygrads[0]))/(lastyindex));
01601   
01602   nbtics = ppsubwin->axes.nygrads;
01603   nbsubtics = ppsubwin->axes.nbsubtics[1];
01604   
01605   
01606   for(i=0;i<nbtics;i++) grads_tmp[i] = ppsubwin->axes.ygrads[i];
01607 
01608   for(i=0;i<nbtics;i++)
01609     {
01610       char foo[256];
01611       double ytmp = ppsubwin->axes.ygrads[i];
01612                   
01613                   
01614       sprintf(foo,c_format,ytmp);
01615 
01616       /***************************************************************/
01617       /************************* COMMON PART *************************/
01618       /***************************************************************/
01619       if(ppsubwin->axes.reverse[1] == TRUE)
01620         ytmp = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp);
01621                   
01622       ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz);
01623                   
01624       vx[0]=xm;vy[0]=ym;
01625                   
01626       barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
01627       barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
01628 
01629       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
01630       C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01631                       
01632       
01633       if (IsDownAxes(psubwin)){
01634         vx[1]=vx[0];
01635         vy[1]=vy[0]+iof/2;
01636         posi[0] = inint(xm-rect[2]/2);
01637         posi[1]=inint( vy[0] + iof + rect[3]);}
01638       else{
01639         vx[1]=vx[0]+barlengthx;
01640         vy[1]=vy[0]+barlengthy;
01641         posi[0] = inint( xm+2*barlengthx-rect[2]);
01642         posi[1]=inint( ym + 2*barlengthy + rect[3]);}
01643       
01644       /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
01645       C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01646       
01647       
01648       if(CheckDisplay(fact_h, fact_w, ppsubwin->logflags[1],foo,posi,fontid,old_rect) == 0)
01649         continue; /*  graduation too close, DO NOT display the graduation ! */
01650       
01651       
01652       C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01653       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01654       if ( ppsubwin->logflags[1] == 'l' )
01655         {
01656           int smallersize = fontid[1]-2;
01657           int old_rect10[4];
01658           int posi10[2];
01659 
01660           posi10[0] = posi[0] - logrect[2];
01661           posi10[1] = posi[1] + logrect[3];
01662           
01663           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01664           
01665           C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01666           
01667           posi[0] = old_rect10[0] + old_rect10[2];
01668           posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);
01669           
01670           C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01671           C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01672           
01673           /* update old_rect */
01674           old_rect[2] = (int)(fact_w*(old_rect[2] + (double)old_rect10[2]));
01675           old_rect[3] = (int)(fact_h*(old_rect[3] + old_rect10[3] + (int) (old_rect10[3]*.1)));
01676           old_rect[0] = old_rect10[0];
01677           old_rect[1] = old_rect[1];
01678           
01679           nb_grads_max++;
01680           
01681           /* put back the current fontid */
01682           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01683         }
01684       else{
01685         /* update old_rect */
01686         C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01687         old_rect[3] = (int)(fact_h* old_rect[3]);
01688         old_rect[2] = (int)(fact_w* old_rect[2]);
01689         nb_grads_max++;
01690       }
01691     }
01692   
01693   if(ppsubwin->logflags[1] != 'l')
01694     if(nb_grads_max == 1) /* only one grad. can be displayed : we choose to display the average value (max+min)/2 */
01695       {
01696         ppsubwin->axes.ygrads[0] = (grads_tmp[0]+grads_tmp[lastyindex])/2.;
01697         ppsubwin->axes.nygrads = 1;
01698         
01699         if ( !ppsubwin->flagNax )
01700         {
01701           /* don't change the number if it aldready has been specified */
01702           ppsubwin->axes.nbsubtics[1] = 1 ;
01703         }
01704         return 0;
01705       }
01706   
01707   
01708   pas = nbtics - 2; /* pas == grads number - 2 */
01709   
01710   possible_pas = -99;
01711   possible_compteur = -99;
01712   
01713   while(pas > 0)
01714     {
01715       int tmp = 0;
01716       compteur = 0;
01717       for(;;)
01718         {
01719           tmp = tmp + pas;
01720           compteur++;
01721           
01722           if((tmp == (nbtics - 1)) && (compteur < nb_grads_max)){
01723             possible_pas = pas;
01724             possible_compteur = ++compteur;
01725             break;
01726           }
01727           
01728           if(tmp > (nbtics - 1))
01729             break;
01730         }
01731       
01732       pas--;
01733     }
01734   
01735   
01736   if(possible_compteur != -99){
01737     compteur = possible_compteur;
01738     pas = possible_pas;
01739     
01740     for(i=0;i<compteur;i++)
01741       ppsubwin->axes.ygrads[i] = grads_tmp[i*pas];
01742     
01743     ppsubwin->axes.nygrads = compteur;
01744     
01745     /* Nb of subtics computation and storage */
01746     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
01747     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTicsFor3dUse(psubwin,
01748                                                            ppsubwin->axes.nygrads,
01749                                                            ppsubwin->logflags[1],
01750                                                            ppsubwin->axes.ygrads,
01751                                                            ppsubwin->axes.nbsubtics[1]);
01752   }
01753   else{
01754     ppsubwin->axes.ygrads[0] = grads_tmp[0];
01755     ppsubwin->axes.ygrads[1] = grads_tmp[lastyindex];
01756     ppsubwin->axes.nygrads = 2;
01757     /* Nb of subtics computation and storage */
01758     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
01759     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTicsFor3dUse(psubwin,
01760                                                            ppsubwin->axes.nygrads,
01761                                                            ppsubwin->logflags[1],
01762                                                            ppsubwin->axes.ygrads,
01763                                                            ppsubwin->axes.nbsubtics[1]);
01764     
01765     if(ppsubwin->logflags[1] == 'n'){
01766       if(nb_grads_max > 4) {
01767         /* we could display at least 4 graduations but we did not find a proper interval... */
01768         /* To avoid to display only the min and max (see above), we add 2 newly created grads by interpolating between min and max */
01769         double pas_ = (grads_tmp[lastyindex]-grads_tmp[0])/3;
01770         for(i=0;i<3;i++){
01771           ppsubwin->axes.ygrads[i] = grads_tmp[0] + i*pas_;
01772         }
01773         
01774         ppsubwin->axes.ygrads[3] = grads_tmp[lastyindex]; /* exact max */
01775         ppsubwin->axes.nygrads = 4;
01776         /* Nb of subtics computation and storage */
01777         ppsubwin->axes.nbsubtics[1] = ComputeNbSubTicsFor3dUse(psubwin,
01778                                                                ppsubwin->axes.nygrads,
01779                                                                'n',
01780                                                                ppsubwin->axes.ygrads,
01781                                                                ppsubwin->axes.nbsubtics[1]);
01782       }
01783     }
01784   }
01785   
01786   return 0;
01787 }

Here is the call graph for this function:

int AdaptGraduationsOnYBottomRight	(	int	iof,
		int	x,
		int	y,
		int	size,
		integer *	Ticsdir,
		int *	fontid,
		sciPointObj *	psubwin,
		double	yminval,
		double	ymaxval,
		double	fx,
		double	fy,
		double	fz
	)

Definition at line 2013 of file DrawObjects.c.

References sciSubWindow::axes, C2F, CheckDisplay(), ChoixFormatE(), ChooseFormatForOneGrad(), ComputeGoodTrans3d(), dr(), foo(), sciSubWindow::FRect, i, inint, int, InvAxis(), IsDownAxes(), sciSubWindow::logflags, AXES::nbsubtics, AXES::nygrads, pas, pSUBWIN_FEATURE, AXES::reverse, TRUE, and AXES::ygrads.

02014 {
02015   int i;
02016   int nbtics, nbsubtics;
02017   int lastyindex;
02018   int old_rect[4];
02019   int nb_grads_max = 0;
02020   int vx[2], vy[2];
02021   int xm, ym;
02022   double grads_tmp[20];
02023   char c_format[5];
02024   integer barlengthx = 0,barlengthy = 0;
02025   integer rect[4],posi[2]; 
02026   integer textcolor = -1;
02027   int logrect[4] ;
02028   int XX = 0 ;
02029   int YY = 0 ;
02030   int pas;
02031   double fact_h = 1.5, fact_w = 1.5;
02032   int compteur = 0;
02033 
02034   int possible_pas, possible_compteur;
02035   
02036   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
02037   
02038   for(i=0;i<4;i++) old_rect[i] = 0; /* Init. old_rect to force first grad. to be displayed */
02039   
02040   lastyindex = ppsubwin->axes.nygrads - 1;
02041   
02042   if(lastyindex == 0)
02043     ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.ygrads[0]));
02044   else
02045     ChoixFormatE(c_format,
02046                  ppsubwin->axes.ygrads[0],
02047                  ppsubwin->axes.ygrads[lastyindex],
02048                  ((ppsubwin->axes.ygrads[lastyindex])-(ppsubwin->axes.ygrads[0]))/(lastyindex));
02049   
02050   nbtics = ppsubwin->axes.nygrads;
02051   nbsubtics = ppsubwin->axes.nbsubtics[1];
02052   
02053   
02054   for(i=0;i<nbtics;i++) grads_tmp[i] = ppsubwin->axes.ygrads[i];
02055 
02056   for(i=0;i<nbtics;i++)
02057     {
02058       char foo[256]; 
02059       double ytmp = ppsubwin->axes.ygrads[i];
02060                   
02061       sprintf(foo,c_format,ytmp);
02062 
02063       /***************************************************************/
02064       /************************* COMMON PART *************************/
02065       /***************************************************************/
02066       if(ppsubwin->axes.reverse[1] == TRUE)
02067         ytmp = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp);
02068                   
02069       ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz);
02070                   
02071       vx[0]=xm;vy[0]=ym; 
02072                   
02073       barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
02074       barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
02075 
02076       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
02077       C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02078       
02079 
02080       if (IsDownAxes(psubwin)){
02081         vx[1]=vx[0];
02082         vy[1]=vy[0]+iof/2;
02083         posi[0] = inint(xm-rect[2]/2); 
02084         posi[1]=inint( vy[0] + iof + rect[3]);}
02085       else{
02086         vx[1]=vx[0]+barlengthx;
02087         vy[1]=vy[0]+barlengthy;
02088         posi[0] = inint( xm+2*barlengthx);
02089         posi[1]=inint( ym + 2*barlengthy + rect[3]);}
02090                       
02091       
02092       /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
02093       C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);       
02094       
02095       
02096       if(CheckDisplay(fact_h, fact_w, ppsubwin->logflags[1],foo,posi,fontid,old_rect) == 0)
02097         continue; /*  graduation too close, DO NOT display the graduation ! */
02098       
02099       
02100       C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02101       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02102       if ( ppsubwin->logflags[1] == 'l' )
02103         {
02104           int smallersize = fontid[1]-2;
02105           int old_rect10[4];
02106           int posi10[2];
02107 
02108           posi10[0] = posi[0] - logrect[2];
02109           posi10[1] = posi[1] + logrect[3];
02110           
02111           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02112           
02113           C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02114           
02115           posi[0] = old_rect10[0] + old_rect10[2];
02116           posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);
02117           
02118           C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02119           C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02120           
02121           /* update old_rect */
02122           old_rect[2] = (int)(fact_w*(old_rect[2] + old_rect10[2]));
02123           old_rect[3] = (int)(fact_h*(old_rect[3] + old_rect10[3] + (int) (old_rect10[3]*.1)));
02124           old_rect[0] = old_rect10[0];
02125           old_rect[1] = old_rect[1];
02126           
02127           nb_grads_max++;
02128           
02129           /* put back the current fontid */
02130           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02131         }
02132       else{
02133         /* update old_rect */
02134         C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02135         old_rect[3] = (int)(fact_h* old_rect[3]);
02136         old_rect[2] = (int)(fact_w* old_rect[2]);
02137         nb_grads_max++;
02138       }
02139     }
02140   
02141   if(ppsubwin->logflags[1] != 'l')
02142     if(nb_grads_max == 1) /* only one grad. can be displayed : we choose to display the average value (max+min)/2 */
02143       {
02144         ppsubwin->axes.ygrads[0] = (grads_tmp[0]+grads_tmp[lastyindex])/2.;
02145         ppsubwin->axes.nygrads = 1;
02146         if ( !ppsubwin->flagNax )
02147         {
02148           ppsubwin->axes.nbsubtics[1] = 1;
02149         }
02150         return 0;
02151       }
02152   
02153   
02154   pas = nbtics - 2; /* pas == grads number - 2 */
02155   
02156   possible_pas = -99;
02157   possible_compteur = -99;
02158   
02159   while(pas > 0)
02160     {
02161       int tmp = 0;
02162       compteur = 0;
02163       for(;;)
02164         {
02165           tmp = tmp + pas;
02166           compteur++;
02167           
02168           if((tmp == (nbtics - 1)) && (compteur < nb_grads_max)){
02169             possible_pas = pas;
02170             possible_compteur = ++compteur;
02171             break;
02172           }
02173           
02174           if(tmp > (nbtics - 1))
02175             break;
02176         }
02177       
02178       pas--;
02179     }
02180   
02181   
02182   if(possible_compteur != -99){
02183     compteur = possible_compteur;
02184     pas = possible_pas;
02185     
02186     for(i=0;i<compteur;i++)
02187       ppsubwin->axes.ygrads[i] = grads_tmp[i*pas];
02188     
02189     ppsubwin->axes.nygrads = compteur;
02190     
02191     /* Nb of subtics computation and storage */
02192     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
02193     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTicsFor3dUse(psubwin,
02194                                                            ppsubwin->axes.nygrads,
02195                                                            ppsubwin->logflags[1],
02196                                                            ppsubwin->axes.ygrads,
02197                                                            ppsubwin->axes.nbsubtics[1]);
02198   }
02199   else{
02200     ppsubwin->axes.ygrads[0] = grads_tmp[0];
02201     ppsubwin->axes.ygrads[1] = grads_tmp[lastyindex];
02202     ppsubwin->axes.nygrads = 2;
02203 
02204     /* Nb of subtics computation and storage */
02205     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
02206     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTicsFor3dUse(psubwin,
02207                                                            ppsubwin->axes.nygrads,
02208                                                            ppsubwin->logflags[1],
02209                                                            ppsubwin->axes.ygrads,
02210                                                            ppsubwin->axes.nbsubtics[1]);
02211     
02212     if(ppsubwin->logflags[1] == 'n'){
02213       if(nb_grads_max > 4) {
02214         /* we could display at least 4 graduations but we did not find a proper interval... */
02215         /* To avoid to display only the min and max (see above), we add 2 newly created grads by interpolating between min and max */
02216         double pas_ = (grads_tmp[lastyindex]-grads_tmp[0])/3;
02217         for(i=0;i<3;i++){
02218           ppsubwin->axes.ygrads[i] = grads_tmp[0] + i*pas_;
02219         }
02220         
02221         ppsubwin->axes.ygrads[3] = grads_tmp[lastyindex]; /* exact max */
02222         ppsubwin->axes.nygrads = 4;
02223         /* Nb of subtics computation and storage */
02224         /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
02225         ppsubwin->axes.nbsubtics[1] = ComputeNbSubTicsFor3dUse(psubwin,
02226                                                                ppsubwin->axes.nygrads,
02227                                                                'n',
02228                                                                ppsubwin->axes.ygrads,
02229                                                                ppsubwin->axes.nbsubtics[1]);
02230       }
02231     }
02232   }
02233   
02234   return 0;
02235 }

Here is the call graph for this function:

int AdaptGraduationsOnZ	(	int	x,
		int	y,
		int	size,
		integer *	Ticsdir,
		int *	fontid,
		sciPointObj *	psubwin,
		double	zminval,
		double	zmaxval,
		double	fx,
		double	fy,
		double	fz
	)

Definition at line 2454 of file DrawObjects.c.

References sciSubWindow::axes, C2F, CheckDisplay(), ChoixFormatE(), ChooseFormatForOneGrad(), ComputeGoodTrans3d(), dr(), foo(), sciSubWindow::FRect, i, inint, int, InvAxis(), sciSubWindow::logflags, AXES::nbsubtics, AXES::nzgrads, pas, pSUBWIN_FEATURE, AXES::reverse, TRUE, and AXES::zgrads.

02455 {
02456   int i;
02457   int nbtics, nbsubtics;
02458   int lastzindex;
02459   int old_rect[4];
02460   int nb_grads_max = 0;
02461   int vx[2], vy[2];
02462   int xm, ym;
02463   double grads_tmp[20];
02464   char c_format[5];
02465   integer barlengthx = 0,barlengthy = 0;
02466   integer rect[4],posi[2]; 
02467   integer textcolor = -1;
02468   int logrect[4] ;
02469   int XX = 0 ;
02470   int YY = 0 ;
02471   int pas;
02472   double fact_h = 1.5, fact_w = 1.;
02473   int compteur;
02474 
02475   int possible_pas, possible_compteur;
02476   
02477   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
02478   
02479   for(i=0;i<4;i++) old_rect[i] = 0; /* Init. old_rect to force first grad. to be displayed */
02480   
02481 
02482 
02483   lastzindex = ppsubwin->axes.nzgrads - 1;
02484   
02485   if(lastzindex == 0)
02486     ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.zgrads[0]));
02487   else
02488     ChoixFormatE(c_format,
02489                  ppsubwin->axes.zgrads[0],
02490                  ppsubwin->axes.zgrads[lastzindex],
02491                  ((ppsubwin->axes.zgrads[lastzindex])-(ppsubwin->axes.zgrads[0]))/(lastzindex));
02492   
02493   nbtics = ppsubwin->axes.nzgrads;
02494   nbsubtics = ppsubwin->axes.nbsubtics[2];
02495 
02496 
02497   for(i=0;i<nbtics;i++) grads_tmp[i] = ppsubwin->axes.zgrads[i];
02498   
02499   for(i=0;i<nbtics;i++)
02500     {
02501       char foo[256];
02502       double ztmp = ppsubwin->axes.zgrads[i];
02503 
02504       sprintf(foo,c_format,ztmp);
02505       
02506       /***************************************************************/
02507       /************************* COMMON PART *************************/
02508       /***************************************************************/
02509       if(ppsubwin->axes.reverse[2] == TRUE)
02510         ztmp = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],ztmp);
02511       
02512       ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&ztmp);
02513             
02514       
02515       vx[0]=xm;vy[0]=ym;
02516       
02517       barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
02518       barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
02519       vx[1]=vx[0]+barlengthx;
02520       vy[1]=vy[0]+barlengthy;
02521       
02522       /* foo is set above with sprintf(foo,c_format,xtmp); */
02523               
02524       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
02525       C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02526       posi[0] = inint( xm+2*barlengthx - rect[2]); 
02527       posi[1]=inint( ym + 2*barlengthy + rect[3]/2);
02528 
02529 
02530       /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
02531       C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);       
02532       
02533       
02534       if(CheckDisplay(fact_h, fact_w, ppsubwin->logflags[2],foo,posi,fontid,old_rect) == 0)
02535         continue; /*  graduation too close, DO NOT display the graduation ! */
02536               
02537       C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02538       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02539       if ( ppsubwin->logflags[2] == 'l' )
02540         {
02541           int smallersize = fontid[1]-2;
02542           int old_rect10[4];
02543           int posi10[2];
02544           
02545           posi10[0] = posi[0] - logrect[2];
02546           posi10[1] = posi[1] + logrect[3];
02547           
02548           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02549           
02550           C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02551           
02552           posi[0] = old_rect10[0] + old_rect10[2];
02553           posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);
02554           
02555           C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02556           C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02557           
02558           /* update old_rect */
02559           old_rect[2] = (int)(fact_w*(old_rect[2] + old_rect10[2]));
02560           old_rect[3] = (int)(fact_h*(old_rect[3] + old_rect10[3] + (int) (old_rect10[3]*.1)));
02561           old_rect[0] = old_rect10[0];
02562           old_rect[1] = old_rect[1];
02563           
02564           nb_grads_max++;
02565           
02566           
02567           /* put back the current fontid */
02568           C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02569         }
02570       else{
02571         /* update old_rect */
02572         C2F(dr)("xstringl",foo,(&posi[0]),(&posi[1]),old_rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
02573         old_rect[3] = (int)(fact_h* old_rect[3]);
02574         old_rect[2] = (int)(fact_w* old_rect[2]);
02575         nb_grads_max++;
02576       }
02577     }
02578   
02579   
02580   if(ppsubwin->logflags[2] != 'l')
02581     if(nb_grads_max == 1) /* only one grad. can be displayed : we choose to display the average value (max+min)/2 */
02582       {
02583         ppsubwin->axes.zgrads[0] = (grads_tmp[0]+grads_tmp[lastzindex])/2.;
02584         ppsubwin->axes.nzgrads = 1;
02585         if ( !ppsubwin->flagNax )
02586         {
02587           ppsubwin->axes.nbsubtics[2] = 1;
02588         }
02589         return 0;
02590       }
02591   
02592   pas = nbtics - 2; /* pas == grads number - 2 */
02593 
02594   possible_pas = -99;
02595   possible_compteur = -99;
02596 
02597   while(pas > 0)
02598     {
02599       int tmp = 0;
02600       compteur = 0;
02601       for(;;)
02602         {
02603           tmp = tmp + pas;
02604           compteur++;
02605           
02606           if((tmp == (nbtics - 1)) && (compteur < nb_grads_max)){
02607             possible_pas = pas;
02608             possible_compteur = ++compteur;
02609             break;
02610           }
02611           
02612           if(tmp > (nbtics - 1))
02613             break;
02614         }
02615       
02616       pas--;
02617     }
02618   
02619   if(possible_compteur != -99){
02620     compteur = possible_compteur;
02621     pas = possible_pas;
02622     
02623     for(i=0;i<compteur;i++)
02624       ppsubwin->axes.zgrads[i] = grads_tmp[i*pas];
02625     
02626     ppsubwin->axes.nzgrads = compteur;
02627     
02628     /* Nb of subtics computation and storage */
02629     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
02630     ppsubwin->axes.nbsubtics[2] = ComputeNbSubTicsFor3dUse(psubwin,
02631                                                            ppsubwin->axes.nzgrads,
02632                                                            ppsubwin->logflags[2],
02633                                                            ppsubwin->axes.zgrads,
02634                                                            ppsubwin->axes.nbsubtics[2]); 
02635   }
02636   else{
02637     ppsubwin->axes.zgrads[0] = grads_tmp[0];
02638     ppsubwin->axes.zgrads[1] = grads_tmp[lastzindex];
02639     ppsubwin->axes.nzgrads = 2;
02640     /* Nb of subtics computation and storage */
02641     /* jb Silvy 01/2006 : default value was Max((int) abs((13-compteur)/2),2) */
02642     ppsubwin->axes.nbsubtics[2] = ComputeNbSubTicsFor3dUse(psubwin,
02643                                                            ppsubwin->axes.nzgrads,
02644                                                            ppsubwin->logflags[2],
02645                                                            ppsubwin->axes.zgrads,
02646                                                            ppsubwin->axes.nbsubtics[2]); 
02647   }
02648   
02649   return 0;
02650 }

Here is the call graph for this function:

int ChildrenCounter ( sciPointObj * pparent )

Definition at line 1246 of file DrawObjects.c.

References ChildrenCounter(), N, NULL, tagSons::pnext, tagSons::pointobj, SCI_AGREG, SCI_POLYLINE, SCI_RECTANGLE, SCI_SEGS, SCI_SURFACE, sciGetEntityType(), and sciGetSons().

Referenced by ChildrenCounter(), and Objplot3d().

01247 {
01248   int N,q=0;
01249   sciSons * psonstmp = sciGetSons (pparent);
01250   
01251   while (psonstmp != (sciSons *) NULL) {   
01252     switch (sciGetEntityType (psonstmp->pointobj)) {  
01253     case SCI_SURFACE:
01254       N=1;
01255       break;
01256     case  SCI_POLYLINE:
01257       N = 1; 
01258       break;
01259     case  SCI_SEGS: 
01260       N=1;
01261       break;
01262     case  SCI_RECTANGLE: 
01263       N = 1;
01264       break;
01265     case SCI_AGREG:
01266       N = ChildrenCounter(psonstmp->pointobj);
01267       break;
01268     default:
01269       N=0;
01270     }
01271     q+=N;
01272     psonstmp = psonstmp->pnext;
01273   }
01274 
01275   return q;
01276 }

Here is the call graph for this function:

Here is the caller graph for this function:

int ChooseFormatForOneGrad	(	char *	c_format,
		double *	grad
	)

Definition at line 2694 of file DrawObjects.c.

References abs.

Referenced by AdaptGraduationsOnXBottomLeft(), AdaptGraduationsOnXBottomRight(), AdaptGraduationsOnYBottomLeft(), AdaptGraduationsOnYBottomRight(), and AdaptGraduationsOnZ().

02695 {
02696   int compteur = 0;
02697   double epsilon = 1e-16;
02698   
02699   if((double)(abs((int)*grad)) < epsilon){ /* case where grad is strictly equal to 0. */
02700     *grad = 0.;
02701     strcpy(c_format,"%d");
02702     return 0;
02703   }
02704   
02705   while((int) (*grad) == 0){
02706     compteur++;
02707     *grad = 10*(*grad);
02708     
02709     if(compteur > 100){
02710       Scierror(999,"Error in function ChooseFormatForOneGrad\n");
02711       return -1;
02712     }
02713   }
02714   
02715   sprintf(c_format,"%%.%df",compteur);
02716   
02717   return 0;
02718 }

Here is the caller graph for this function:

int ComputeCorrectXindAndInsideUD	(	double	Teta,
		double	Alpha,
		double *	dbox,
		integer *	xind,
		integer *	InsideU,
		integer *	InsideD
	)

Definition at line 938 of file DrawObjects.c.

References sciAxesVerticesIndices(), sciGetAxisBox(), and sciUpdateScaleAngles().

Referenced by axis_3ddraw().

00939 {
00940   double xbox[8], ybox[8], zbox[8];
00941 
00942   Teta = 0.1; /* Little offset to compute correct values for xind,  InsideU and InsideD */
00943 
00944   /* update Cscale.m from the new viewing angles */
00945   sciUpdateScaleAngles( Teta, Alpha ) ;
00946  
00947   sciGetAxisBox( dbox, xbox, ybox, zbox ) ;
00948  
00949   sciAxesVerticesIndices( InsideU, InsideD, xbox, ybox, xind ) ;
00950 
00951   return 0;
00952 }

Here is the call graph for this function:

Here is the caller graph for this function:

int ComputeGoodTrans3d	(	sciPointObj *	psubwin,
		int	n,
		int *	xm,
		int *	ym,
		double *	fx,
		double *	fy,
		double *	fz
	)

Definition at line 956 of file DrawObjects.c.

References sciSubWindow::logflags, pSUBWIN_FEATURE, and trans3d().

Referenced by AdaptGraduationsOnXBottomLeft(), AdaptGraduationsOnXBottomRight(), AdaptGraduationsOnYBottomLeft(), AdaptGraduationsOnYBottomRight(), and AdaptGraduationsOnZ().

00957 {
00958   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
00959 
00960   
00961   double tmp_fx = *fx;
00962   double tmp_fy = *fy;
00963   double tmp_fz = *fz;
00964   
00965   if(ppsubwin->logflags[0] == 'l')
00966     tmp_fx = exp10(tmp_fx);
00967   
00968   if(ppsubwin->logflags[1] == 'l')
00969     tmp_fy = exp10(tmp_fy);
00970   
00971   if(ppsubwin->logflags[2] == 'l')
00972     tmp_fz = exp10(tmp_fz);
00973   
00974   trans3d(psubwin, n, xm, ym, &tmp_fx, &tmp_fy, &tmp_fz);
00975   
00976   return 0;
00977 }

Here is the call graph for this function:

Here is the caller graph for this function:

void computeLabelAutoPos	(	sciPointObj *	pLabel,
		int	axisStart[2],
		int	axisEnd[2],
		int	offsets[2]
	)

Update the coordinates of a label to put it in the middle of a segment (normally an axis) but with a little orthogonal offset. Let Ri i=0:3 be the four corners of the label boudinbg box. The algorithm will put the center of the bounding box C on the middle of the segment I. Then we compute for each corner the needed translation to put them at a distance given by offset. The translation is done along an axis orthogonal to the segment. Finally we transalte the box from I with the longest translation, so each corner is at least at the wanted distance.

Parameters:

	pLabel	pointer to the label to place.
	axisStart	Starting point of the segment.
	axisEnd	The other end of the segment. The order of the two points determine the side in which the label will be placed.
	offsets	The label is not put exactly on the middle of the segment. It is moved from a little offset orthogonally from the segment.

Definition at line 2900 of file DrawObjects.c.

References Abs, DOT_PROD_2D, getTextBoundingBox(), Max, normalize2d(), NULL, pLABEL_FEATURE, round, sciSetPosition(), XPixel2Double, and YPixel2Double.

Referenced by labels2D_draw().

02901 {
02902   /* computation are done in double to avoid loss of data */
02903   double centerDir[2]  ; /* give the direction of the line on which is the center. */
02904                          /* it is orthogonal with the axis direction */
02905   double axisMiddle[2] ; /* middle of the axis = ( axisStart + axisEnd ) / 2 */
02906   int    bbox[4][2]    ; /* real bounding box of the label */
02907   double corners[4][2] ; /* the four corners of the boundign box */
02908   double centerDist    ; /* final distance between the center and the axis */
02909   int wantedBlPoint[2] ; /* the position we want for the bottom left point of the axis */
02910   double distance      ;
02911   double rectCenter[2] ;
02912 
02913   if ( axisStart[0] == axisEnd[0] && axisStart[1] == axisEnd[1] )
02914   {
02915     /* the axis is invisible. Its label is not displayed also. */
02916     return ;
02917   }
02918 
02919   /* normalized vector orthogonal to the axe */
02920   /* its direction (+ or -) determines on which side will be displayed the axis */
02921   centerDir[0] = axisStart[1] - axisEnd[1]   ;
02922   centerDir[1] = axisEnd[0]   - axisStart[0] ;
02923   normalize2d( centerDir ) ;
02924 
02925   /* the distance between the aabb and the axis is offsets[0] if the axis is vertical, */
02926   /* offest[1] if horizontal and something in between otherwise */
02927   distance = Abs( (double)offsets[0] * centerDir[0] ) + Abs( (double)offsets[1] * centerDir[1] ) ;
02928 
02929   axisMiddle[0] = ( axisStart[0] + axisEnd[0] ) / 2.0 ;
02930   axisMiddle[1] = ( axisStart[1] + axisEnd[1] ) / 2.0 ;
02931   
02932   /* get the size of the label axis aligned bouding box. */
02933   getTextBoundingBox( pLABEL_FEATURE(pLabel)->text, bbox, NULL ) ;
02934 
02935   /* get the center of the rectangle */
02936   rectCenter[0] = ( bbox[0][0] + bbox[1][0] + bbox[2][0] + bbox[3][0] ) / 4.0 ;
02937   rectCenter[1] = ( bbox[0][1] + bbox[1][1] + bbox[2][1] + bbox[3][1] ) / 4.0 ;
02938 
02939   /* We suppose the box is centered on I and we compute IRi, i=0:3 */
02940   corners[0][0] = bbox[0][0] - rectCenter[0] ;
02941   corners[0][1] = bbox[0][1] - rectCenter[1] ;
02942   corners[1][0] = bbox[1][0] - rectCenter[0] ;
02943   corners[1][1] = bbox[1][1] - rectCenter[1] ;
02944   corners[2][0] = bbox[2][0] - rectCenter[0] ;
02945   corners[2][1] = bbox[2][1] - rectCenter[1] ;
02946   corners[3][0] = bbox[3][0] - rectCenter[0] ;
02947   corners[3][1] = bbox[3][1] - rectCenter[1] ;
02948 
02949   /* compute IRi.v, i=0:3 to get the current distance between Ri and the axis. */
02950   /* Then for each Ri we can compute the need displacment along the centerDir to push it */
02951   /* at distance dist of the axis. Finally, the needed displacement is the maximum of the 4. */
02952   centerDist = distance - DOT_PROD_2D( corners[0], centerDir ) ;
02953   centerDist = Max( centerDist, distance - DOT_PROD_2D( corners[1], centerDir ) ) ;
02954   centerDist = Max( centerDist, distance - DOT_PROD_2D( corners[2], centerDir ) ) ;
02955   centerDist = Max( centerDist, distance - DOT_PROD_2D( corners[3], centerDir ) ) ;
02956 
02957   /* the wanted center is C = I + a.v */
02958   wantedBlPoint[0] = round( axisMiddle[0] + centerDist * centerDir[0] + corners[0][0] ) ;
02959   wantedBlPoint[1] = round( axisMiddle[1] + centerDist * centerDir[1] + corners[0][1] ) ;
02960 
02961   sciSetPosition( pLabel,
02962                   XPixel2Double( wantedBlPoint[0] ),
02963                   YPixel2Double( wantedBlPoint[1] ) ) ;
02964 
02965 }

Here is the call graph for this function:

Here is the caller graph for this function:

int ComputeNbSubTics	(	sciPointObj *	pobj,
		int	nbtics,
		char	logflag,
		double *	grads,
		int	nbsubtics_input
	)

Definition at line 890 of file DrawObjects.c.

References FALSE, sciSubWindow::flagNax, i, and pSUBWIN_FEATURE.

Referenced by sci_update_frame_bounds_2d(), sci_update_frame_bounds_3d(), set_x_ticks_property(), set_y_ticks_property(), and set_z_ticks_property().

00891 {
00892   int ticsval[] =    {2 ,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
00893   int subticsval[] = {10,7,5,5,4,4,3,2,2 ,2 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 };
00894   int i;
00895   sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
00896 
00897 
00898   if(logflag =='l'){
00899     if((grads[1]-grads[0])==1) /* intervalle de type ...10^n 10^(n+1)...*/
00900       {
00901         return 9; /* 9 subtics to have a pretty tics/grid in log.*/
00902       }
00903     else
00904       {
00905         return 1; /* no subtics at all (1 but draw on a tics place) */
00906       }
00907   }
00908   else{
00909     if(ppsubwin->flagNax == FALSE) /* if auto subtics mode == ON */
00910       { 
00911         for(i=0;i<19;i++)
00912           if(nbtics == ticsval[i])
00913             {
00914               return subticsval[i];
00915             }
00916       }
00917     else /* if auto subtics mode == OFF already computed in Plo2dn.c, Champ.c routines... */
00918       {  /* or given via a.subtics=[nbsubtics_on_x, nbsubtics_on_y, nbsubtics_on_z] command */
00919         return nbsubtics_input;
00920       }
00921   }
00922   
00923   return -1;
00924 }

Here is the caller graph for this function:

int ComputeNbSubTicsFor3dUse	(	sciPointObj *	pobj,
		int	nbtics,
		char	logflag,
		double *	grads,
		int	nbsubtics_input
	)

Definition at line 2654 of file DrawObjects.c.

References FALSE, sciSubWindow::flagNax, i, and pSUBWIN_FEATURE.

02655 {
02656   int ticsval[] =    {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
02657   int subticsval[] = {6,4,4,3,3,3,2,2,2 ,2 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1};
02658   int i;
02659   sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
02660 
02661 
02662   if(logflag =='l'){
02663     if( (grads[1]-grads[0]) == 1 ) /* intervalle de type ...10^n 10^(n+1)...*/
02664       {
02665         return 9; /* 9 subtics to have a pretty tics/grid in log.*/
02666       }
02667     else
02668       {
02669         return 1; /* no subtics at all (1 but draw on a tics place) */
02670       }
02671   }
02672   else
02673   {
02674     if(ppsubwin->flagNax == FALSE) /* if auto subtics mode == ON */
02675     { 
02676       for(i=0;i<19;i++)
02677       {
02678         if(nbtics == ticsval[i])
02679         {
02680           return subticsval[i];
02681         }
02682       }
02683     }
02684     else /* if auto subtics mode == OFF already computed in Plo2dn.c, Champ.c routines... */
02685     {  /* or given via a.subtics=[nbsubtics_on_x, nbsubtics_on_y, nbsubtics_on_z] command */
02686       return nbsubtics_input;
02687     }
02688   }
02689   
02690   return -1;
02691 }

void DrawAxes ( sciPointObj * pobj )

Definition at line 1000 of file DrawObjects.c.

References axis_draw2(), C2F, dr(), NULL, pSUBWIN_FEATURE, rebuild_strflag(), sciGetForeground(), sciGetLineStyle(), sciGetLineWidth(), sciGetMarkStyle(), sciGetParentSubwin(), sciGetVisibility(), sciSetSelectedSubWin(), set_scale(), v, and x.

Referenced by DrawAxesIfRequired().

01001 {
01002   sciPointObj * psubwin = sciGetParentSubwin(pobj);
01003   /*   sciPointObj * pfigure = sciGetParentFigure(pobj); */
01004   char STRFLAG[4];
01005   integer x[6], v, markidsizenew[2];
01006   double dv;
01007 
01008   if (!sciGetVisibility(pobj)) return;
01009   
01010   x[0] = sciGetForeground (psubwin);
01011   x[2] = sciGetLineWidth (psubwin);
01012   x[3] = sciGetLineStyle (psubwin);
01013   markidsizenew[0] = sciGetMarkStyle(psubwin);
01014   markidsizenew[1] = sciGetLineWidth (psubwin);
01015   x[4] = 0;
01016   v = 0;
01017   dv = 0;
01018 
01019   
01020   sciSetSelectedSubWin(psubwin); 
01021   
01022   set_scale ("tttftt", pSUBWIN_FEATURE (psubwin)->WRect, pSUBWIN_FEATURE (psubwin)->FRect,
01023              NULL, pSUBWIN_FEATURE (psubwin)->logflags, 
01024              pSUBWIN_FEATURE (psubwin)->ARect); 
01025      
01026   if (!pSUBWIN_FEATURE (psubwin)->is3d)   /* we are in 2D mode...*/
01027     {
01028       /* F.Leray 07.12.04 */
01029       /* TO CORRECT the bug 1115 : Big object (grayplots) could cover axes*/
01030       C2F (dr) ("xset","dashes",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
01031       C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
01032       C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01033       C2F (dr) ("xset","mark",&markidsizenew[0],&markidsizenew[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01034 
01035       rebuild_strflag(psubwin,STRFLAG);
01036       axis_draw2 (STRFLAG); /* Axes is rebuilt here to avoid being covered by the new created object */
01037     }
01038 }

Here is the call graph for this function:

Here is the caller graph for this function:

void DrawAxesIfRequired ( sciPointObj * pobj )

DrawAxesIfRequired Draws Axes (only the basic graphicobject under subwindows) in its SubWindow or figure if and only if pFIGURE_FEATURE(pobj)->auto_redraw == TRUE !! Only used inside High Level functions calls (sucha as plot2d, plot3d...)

Parameters:

sciPointObj

* pobj: the pointer to the entity

Returns:: int 0 if OK, -1 if not

Definition at line 987 of file DrawObjects.c.

References DrawAxes(), pFIGURE_FEATURE, and sciGetParentFigure().

Referenced by champg(), fec(), plot2dn(), xgray(), xgray1(), and xgray2().

00988 {
00989   sciPointObj * pfigure = sciGetParentFigure(pobj);
00990   
00991   if( pFIGURE_FEATURE(pfigure)->auto_redraw && pFIGURE_FEATURE(pfigure)->visible )
00992   {
00993     DrawAxes(pobj);
00994   }
00995   
00996 }

Here is the call graph for this function:

Here is the caller graph for this function:

double C2F() dsort ( )

Definition at line 292 of file x_test_loop.c.

00292 {};

int Gen3DPoints	(	integer	type,
		integer *	polyx,
		integer *	polyy,
		integer *	fill,
		integer	whiteid,
		double	zmin,
		double	zmax,
		double *	,
		double *	,
		double *	,
		integer	i,
		integer	j,
		integer	jj1,
		integer *	p,
		integer	dc,
		integer	fg,
		sciPointObj *	psurface
	)

DJ.Abdemouche 2003

Definition at line 1106 of file DrawObjects.c.

References sciSubWindow::axes, sciSurface::flag_x, sciSurface::flag_y, inint, pSUBWIN_FEATURE, pSURFACE_FEATURE, AXES::reverse, sciGetCurrentSubWin(), trans3d(), and TRUE.

Referenced by plot3dn().

01107 {
01108   sciPointObj *pobj;
01109   int facteur = 1;
01110 
01111   sciPointObj *psubwin = sciGetCurrentSubWin();
01112   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
01113   sciSurface * ppsurface = pSURFACE_FEATURE (psurface);
01114   
01115   pobj = sciGetCurrentSubWin(); 
01116   if (trans3d(pobj ,1, &(polyx[  5*jj1]),&(polyy[  5*jj1]),&(x[i]),&(y[j]),&(z[i+(*p)*j]))==0) return 0; 
01117   if (trans3d(pobj ,1, &(polyx[1+  5*jj1]),&(polyy[1+  5*jj1]),&(x[i]),&(y[j+1]),&(z[i+(*p)*(j+1)]))==0) return 0; 
01118   if (trans3d(pobj ,1, &(polyx[2+  5*jj1]),&(polyy[2+  5*jj1]),&(x[i+1]),&(y[j+1]),&(z[(i+1)+(*p)*(j+1)]))==0) return 0; 
01119   if (trans3d(pobj ,1, &(polyx[3+  5*jj1]),&(polyy[3+  5*jj1]),&(x[i+1]),&(y[j]),&(z[(i+1)+(*p)*j]))==0) return 0;   
01120   if (trans3d(pobj ,1, &(polyx[4+  5*jj1]),&(polyy[4+  5*jj1]),&(x[i]),&(y[j]),&(z[i+(*p)*j]))==0) return 0; 
01121   
01122   
01123   if(ppsubwin->axes.reverse[0] == TRUE) facteur = -facteur;
01124   if(ppsubwin->axes.reverse[1] == TRUE) facteur = -facteur;
01125   if(ppsubwin->axes.reverse[2] == TRUE) facteur = -facteur;
01126   
01127   /* try */
01128   facteur = ppsurface->flag_x * ppsurface->flag_y * facteur;
01129   
01130   /* type == flagcolor and dc == color_mode */
01131   /* fg = hidden color */
01132   
01133   if ((((polyx[1+5*jj1]-polyx[0+5*jj1])*(polyy[2+5*jj1]-polyy[0+5*jj1])-
01134         (polyy[1+5*jj1]-polyy[0+5*jj1])*(polyx[2+5*jj1]-polyx[0+5*jj1]))*facteur <  0) && (fg >=0 )) 
01135     {
01136       
01137       /* ------------------- */
01138       /* Beneath the surface */
01139       /* ------------------- */
01140 
01141       if (type != 0) /* flagcolor = 1 case : special treatment compared to flagcolor = 0 */
01142                      /* don't know why... F.Leray */
01143         fill[jj1]= (dc < 0 ) ? -fg : fg ;
01144       else           /* flagcolor = 0 :  No shading at all, fixed facecolor. */
01145         fill[jj1]=  (dc != 0 ) ? fg : dc ;
01146     }
01147   else
01148     {
01149 
01150       /* ------------------- */
01151       /* Above the surface */
01152       /* ------------------- */
01153 
01154      if (type != 0)
01155         {  /* flagcolor = 1 :  Z-level flat shading. */
01156           fill[jj1]=inint((whiteid-1)*((1/4.0*( z[i+(*p)*j]+ z[i+1+(*p)*j]+
01157                                                 z[i+(*p)*(j+1)]+ z[i+1+(*p)*(j+1)])-zmin)
01158                                        /(zmax-zmin)))+1;
01159           if ( dc < 0 ) fill[jj1]= -fill[jj1];  
01160         }
01161       else
01162         fill[jj1]= dc;     
01163     }
01164   
01165   return(1);
01166   
01167 }

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL GetIsAxes2D ( sciPointObj * psubwin )

Definition at line 927 of file DrawObjects.c.

References sciSubWindow::axes, AXES::axes_visible, FALSE, pSUBWIN_FEATURE, and TRUE.

Referenced by rebuild_strflag().

00928 {
00929   sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
00930   
00931   if((ppsubwin->axes.axes_visible[0] == FALSE)
00932      && (ppsubwin->axes.axes_visible[1] == FALSE))
00933     return FALSE;
00934   else
00935     return TRUE;
00936 }

Here is the caller graph for this function:

void GradFixedlog	(	double	minVal,
		double	maxVal,
		double *	ticks,
		int	nbGrads
	)

Definition at line 393 of file DrawObjects.c.

References FALSE, FREE, GradLog(), i, MALLOC, NULL, removeBadTicks(), round, and TRUE.

Referenced by GradLog().

00394 {
00395   int initSize ;
00396   int i ;
00397 
00398   /* intialize the array as usual */
00399   GradLog( minVal, maxVal, ticks, &initSize, FALSE ) ;
00400 
00401   if ( initSize > nbGrads )
00402   {
00403     /* we create a smaller vector from a bigger one */
00404     int nbRemove = initSize - nbGrads ;
00405     
00406     BOOL * removedTicks ;
00407     if( ( removedTicks = MALLOC( initSize * sizeof(BOOL) ) ) == NULL )
00408     {
00409       return ;
00410     }
00411 
00412     for ( i = 0 ; i < initSize ; i++ )
00413     {
00414       removedTicks[i] = FALSE ;
00415     }
00416 
00417     /* we now remove the nbremove indexes : round( ( 0.5 + i ) * size / nbRemove ) */
00418     /* i=0..nbReg-1 should do the thing */
00419     for ( i = 0 ; i < nbRemove ; i++ )
00420     {
00421       int remIndex = 1 + (int) round(  i  * ((double) initSize - 2 ) / ( (double) nbRemove ) ) ;
00422       removedTicks[remIndex] = TRUE ;
00423     }
00424 
00425     removeBadTicks( ticks, removedTicks, &initSize ) ;
00426 
00427     FREE( removedTicks ) ;
00428 
00429   }
00430 
00431 }

Here is the call graph for this function:

Here is the caller graph for this function:

int GradLog	(	double	_min,
		double	_max,
		double *	_grads,
		int *	n_grads,
		int	compNgrads
	)

Definition at line 437 of file DrawObjects.c.

References GradFixedlog(), i, int, j, pas, size, and val.

Referenced by GradFixedlog(), updateXaxesTics(), and updateYaxesTics().

00442 {
00443   int i;
00444   int log_min, log_max;
00445   int size;
00446   
00447   if ( compNgrads )
00448   {
00449     GradFixedlog( _min, _max, _grads, *n_grads ) ;
00450     return 0 ;
00451   }
00452 
00453   log_max =  (int) ceil(_max);
00454   log_min =  (int) floor(_min);
00455   
00456 
00457   size = log_max - log_min +1;
00458   /*  tab=(int *)MALLOC(size*sizeof(int)); */
00459   
00460   /*   for(i=0;i<size;i++) tab[i]=log_min+i; */
00461 
00462   *n_grads = 0 ;
00463 
00464   if(size<=7)    {
00465       for(i=0;i<size;i++)
00466         {
00467           /*    _grads[i] = exp10(tab[i]); */
00468           _grads[i] = log_min+i;
00469           *n_grads = (*n_grads) + 1;
00470           /*      sciprint("Juste en sortie, _grads[%d] = %lf\n",i, _grads[i]); */
00471         }
00472     }
00473   else
00474     {
00475       int pas = 0, old_pas= 0,j;
00476       int val = size, passed = 0;
00477       
00478       for(j=val-1;j>1;j--)
00479         if(val%j == 0){
00480           old_pas = pas;
00481           pas=j; 
00482           passed = 1;
00483 
00484           if((7*pas)<=val){ 
00485             if(old_pas != 0) {pas = old_pas; }
00486             break;
00487           }
00488         }
00489       
00490       if(passed != 1 || (size/pas)>15 ) pas = size;
00491             
00492       if(pas==size)
00493         {
00494           _grads[0] = log_min;
00495           _grads[1] = log_max;
00496           *n_grads =2;
00497         }
00498       else
00499       {
00500         for(i=0;i<=(int )(size/pas);i++)
00501           {
00502             _grads[i] = log_min+(i*pas);
00503             
00504             *n_grads = (*n_grads) + 1;
00505             /*      sciprint("Juste en sortie, _grads[%d] = %lf\n",i, _grads[i]); */
00506           }
00507       }
00508     }
00509   
00510   return 0;
00511 }

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL IsDownAxes ( sciPointObj * pobj )

Definition at line 369 of file DrawObjects.c.

References alpha, FALSE, pSUBWIN_FEATURE, SCI_SUBWIN, sciGetEntityType(), and TRUE.

Referenced by AdaptGraduationsOnXBottomLeft(), AdaptGraduationsOnXBottomRight(), AdaptGraduationsOnYBottomLeft(), and AdaptGraduationsOnYBottomRight().

00370 {
00371   double alpha,cof;
00372   
00373   if (sciGetEntityType(pobj) == SCI_SUBWIN){
00374     alpha = pSUBWIN_FEATURE (pobj)->alpha;   
00375     if (!(pSUBWIN_FEATURE (pobj)->isoview))
00376       cof=10.0;
00377     else
00378       cof = 5.0; /* F.Leray : hard fixed here */
00379     if (cof == 0 ) cof =5;
00380     if ((alpha <=(-90.0+cof) ) && (alpha >= (-90.0-cof))) 
00381       return TRUE;
00382     if ((alpha <=(-270.0+cof) ) && (alpha >= (-270.0-cof)))
00383       return TRUE;
00384     if ((alpha <=(90.0+cof) ) && (alpha >= (90.0-cof)))
00385       return TRUE;
00386     if ((alpha <=(270.0+cof) ) && (alpha >= (270.0-cof)))
00387       return TRUE;
00388   }
00389   return FALSE;
00390 }

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL Ishidden ( sciPointObj * pobj )

Definition at line 350 of file DrawObjects.c.

References alpha, FALSE, pSUBWIN_FEATURE, SCI_SUBWIN, sciGetEntityType(), and TRUE.

Referenced by axis_3ddraw().

00351 {
00352   double alpha;
00353   if (sciGetEntityType(pobj) == SCI_SUBWIN){
00354     alpha = pSUBWIN_FEATURE (pobj)->alpha;
00355     if ((alpha <0.0 ) && (alpha > -90.0))
00356       return TRUE;
00357     if ((alpha <360.0 ) && (alpha > 270.0)) /* missing case added to fix bug 839 F.Leray */
00358       return TRUE;
00359     if ((alpha <-180.0 ) && (alpha > -270.0))
00360       return TRUE;
00361     if ((alpha <180.0 ) && (alpha > 90.0))
00362       return TRUE;
00363   }
00364   return FALSE;
00365 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Merge3d ( sciPointObj * psubwin )

Definition at line 1346 of file DrawObjects.c.

References ConstructMerge(), DestroyMerge(), FREE, MALLOC, Merge3dBuildTable(), Merge3dDimension(), NULL, pSUBWIN_FEATURE, SCI_SUBWIN, sciGetEntityType(), sciGetMerge(), sciprint(), and TRUE.

Referenced by Objplot3d(), plot2dn(), sci_set(), sci_xfpoly(), sci_xfpolys(), sci_xpoly(), sci_xpolys(), sci_xrect(), sci_xrects(), sci_xsegs(), and updateMerge().

01347 {
01348   integer q,k; 
01349   sciPointObj *pmerge; 
01350   int *index_in_entity;
01351   long *from_entity;
01352   
01353   if(sciGetEntityType (psubwin) != SCI_SUBWIN) return; 
01354   if ((pmerge= sciGetMerge(psubwin)) != (sciPointObj *) NULL)
01355     DestroyMerge(pmerge); 
01356   
01357   /* ========================================================================
01358    * Compute the number of facets, segments,... included in all the subwin 
01359    * children
01360    * ========================================================================*/
01361   
01362   
01363   q =  Merge3dDimension(psubwin);
01364   
01365   
01366   /* ========================================================================
01367    * allocate tables for index and handles
01368    * ========================================================================*/
01369   
01370   /* q now contains the total number of elements */
01371   if ((index_in_entity = (int *) MALLOC (q * sizeof (int))) == (int *)NULL) {
01372     sciprint("Merge3d : not enough memory to allocate \n");
01373     return;
01374   }
01375   if ((from_entity   = (long *) MALLOC (q * sizeof (long))) == (long *) NULL) {
01376     sciprint("Merge3d : not enough memory to allocate \n");
01377     FREE(index_in_entity);
01378   }
01379   
01380   /* ========================================================================
01381    * fill the index and handles tables
01382    * ========================================================================*/
01383   k=0;
01384   Merge3dBuildTable(psubwin, index_in_entity, from_entity, &k);
01385   
01386   /* ========================================================================
01387    * create the Merge data structure
01388    * ========================================================================*/
01389   
01390   if ((pmerge=ConstructMerge ((sciPointObj *) psubwin,q,index_in_entity,from_entity)) == (sciPointObj *) NULL) {
01391     FREE(index_in_entity);
01392     FREE(from_entity);
01393     sciprint ("\r\n No merge supported");}
01394   else /* inform the subwindow to display Merge instead of individual children */
01395     pSUBWIN_FEATURE (psubwin)->facetmerge = TRUE;
01396   
01397 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Merge3dBuildTable	(	sciPointObj *	pparent,
		int *	index_in_entity,
		long *	from_entity,
		int *	pos
	)

Definition at line 1279 of file DrawObjects.c.

References i, long, Merge3dBuildTable(), N, sciSegs::Nbr1, sciSegs::Nbr2, NULL, tagSons::pnext, tagSons::pointobj, pPOLYLINE_FEATURE, pSEGS_FEATURE, pSURFACE_FEATURE, sciSegs::ptype, SCI_AGREG, SCI_PLOT3D, SCI_POLYLINE, SCI_RECTANGLE, SCI_SEGS, SCI_SURFACE, sciGetEntityType(), sciGetHandle(), sciGetIsMark(), and sciGetSons().

Referenced by Merge3d(), and Merge3dBuildTable().

01280 {
01281   sciSons *psonstmp;
01282   int i,N;
01283 
01284   psonstmp = sciGetSons (pparent);
01285 
01286   while (psonstmp != (sciSons *) NULL) {   
01287     switch (sciGetEntityType (psonstmp->pointobj)) {  
01288     case SCI_SURFACE:
01289       if (pSURFACE_FEATURE (psonstmp->pointobj)->typeof3d == SCI_PLOT3D) 
01290         N=(pSURFACE_FEATURE (psonstmp->pointobj)->dimzx-1)*(pSURFACE_FEATURE (psonstmp->pointobj)->dimzy-1);
01291       else
01292         N = pSURFACE_FEATURE (psonstmp->pointobj)->dimzy;
01293       break;
01294     case  SCI_POLYLINE:
01295       if ( pPOLYLINE_FEATURE(psonstmp->pointobj)->n1 == 0 )
01296       {
01297         N = 0 ;
01298       }
01299       else if (pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 5)
01300       {/*polyline*/
01301         N = pPOLYLINE_FEATURE (psonstmp->pointobj)->n1-1;
01302         if ((pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 2) && 
01303             (sciGetIsMark((sciPointObj *)psonstmp->pointobj) == 1))
01304         {
01305           N = N + 1 ;
01306         }
01307       }
01308       else /* patch */
01309       {
01310         N = 1 ;
01311       }
01312       break;
01313     case  SCI_SEGS: 
01314       {
01315         sciSegs * ppSegs = pSEGS_FEATURE(psonstmp->pointobj) ;
01316         if ( ppSegs->ptype == 0 )
01317         { 
01318           N = ppSegs->Nbr1 / 2 ;
01319         }
01320         else
01321         {
01322           N = ppSegs->Nbr1 * ppSegs->Nbr2 ;
01323         }
01324       }
01325       break;
01326     case  SCI_RECTANGLE: 
01327       N = 4;
01328       break;
01329     case SCI_AGREG:
01330       Merge3dBuildTable(psonstmp->pointobj, index_in_entity, from_entity, pos);
01331       break;
01332     default:
01333       N = 0;
01334     }
01335     if (sciGetEntityType (psonstmp->pointobj) != SCI_AGREG)
01336       for (i=0 ; i<N; i++) {
01337         index_in_entity[*pos]=i;
01338         from_entity[*pos]=(long) sciGetHandle (psonstmp->pointobj);
01339         *pos=*pos+1;
01340       }
01341     psonstmp = psonstmp->pnext;
01342   }
01343 }

Here is the call graph for this function:

Here is the caller graph for this function:

int Merge3dDimension ( sciPointObj * pparent )

Definition at line 1171 of file DrawObjects.c.

References Merge3dDimension(), N, sciSegs::Nbr1, sciSegs::Nbr2, NULL, tagSons::pnext, tagSons::pointobj, pPOLYLINE_FEATURE, pSEGS_FEATURE, pSURFACE_FEATURE, sciSegs::ptype, SCI_AGREG, SCI_PLOT3D, SCI_POLYLINE, SCI_RECTANGLE, SCI_SEGS, SCI_SURFACE, sciGetEntityType(), sciGetIsMark(), and sciGetSons().

Referenced by Merge3d(), and Merge3dDimension().

01172 {
01173   integer N,q; 
01174   sciSons *psonstmp;
01175 
01176   /* ========================================================================
01177    * Compute the number of facets, segments,... included in all the subwin 
01178    * children
01179    * Each entities to merge; is decomposed in a set of basic elements 
01180    *  (facet, segment, point,...)
01181    * Each basic element is represented in the Merge structure by the handle of its entity and an 
01182    *   index within this entity
01183    * ========================================================================*/
01184 
01185   q=0;
01186   psonstmp = sciGetSons (pparent);
01187   while (psonstmp != (sciSons *) NULL) {   
01188     switch (sciGetEntityType (psonstmp->pointobj)) {  
01189     case SCI_SURFACE:
01190       if (pSURFACE_FEATURE (psonstmp->pointobj)->typeof3d == SCI_PLOT3D) 
01191         N=(pSURFACE_FEATURE (psonstmp->pointobj)->dimzx-1)*(pSURFACE_FEATURE (psonstmp->pointobj)->dimzy-1);
01192       else
01193         N = pSURFACE_FEATURE (psonstmp->pointobj)->dimzy;
01194       break;
01195 
01196     case  SCI_POLYLINE:
01197       {
01198         if ( pPOLYLINE_FEATURE(psonstmp->pointobj)->n1 == 0 )
01199         {
01200           N = 0 ;
01201         }
01202         else if (pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 5)
01203         {/*polyline*/
01204           N = pPOLYLINE_FEATURE (psonstmp->pointobj)->n1-1;
01205           if ((pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 2) && 
01206             (sciGetIsMark((sciPointObj *)psonstmp->pointobj) == 1))
01207           {
01208             N = N + 1 ;
01209           }
01210         }
01211         else /* patch */
01212         {
01213           N = 1 ;
01214         }
01215       }
01216       break;
01217     case  SCI_SEGS:
01218       {
01219         sciSegs * ppSegs = pSEGS_FEATURE(psonstmp->pointobj) ;
01220         if ( ppSegs->ptype == 0 )
01221         { 
01222           N = ppSegs->Nbr1 / 2 ;
01223         }
01224         else
01225         {
01226           N = ppSegs->Nbr1 * ppSegs->Nbr2 ;
01227         }
01228       }
01229       break;
01230     case  SCI_RECTANGLE: 
01231       N = 4;
01232       break;
01233     case SCI_AGREG:
01234       N =  Merge3dDimension(psonstmp->pointobj);
01235       break;
01236     default:
01237       N=0;
01238     }
01239     q+=N;
01240     psonstmp = psonstmp->pnext;
01241   }
01242 
01243   return q;
01244 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Nextind	(	integer	ind1,
		integer *	ind2,
		integer *	ind3
	)

Nextind

Author:: Djalel Abdemouche 10/2003 Should be in Action.c file

Definition at line 331 of file DrawObjects.c.

Referenced by sciAxesVerticesIndices().

00332 {
00333   *ind2 = ind1+1;
00334   *ind3 = ind1-1;
00335   if (ind1 > 3)
00336     {
00337       if (*ind2 == 8) *ind2 = 4;
00338       if (*ind3 == 3) *ind3 = 7;
00339     }
00340   else
00341     {
00342       if (*ind2 == 4) *ind2 = 0;
00343       if (*ind3 == -1) *ind3 = 3;
00344     }
00345 }

Here is the caller graph for this function:

BOOL sci_update_frame_bounds_2d ( sciPointObj * pobj )

Definition at line 603 of file DrawObjects.c.

References sciSubWindow::axes, ComputeNbSubTics(), FALSE, sciSubWindow::FRect, i, sciSubWindow::logflags, AXES::nbsubtics, NULL, AXES::nxgrads, AXES::nygrads, pSUBWIN_FEATURE, sciGetDisplayedBounds(), TheTicks(), AXES::xgrads, and AXES::ygrads.

Referenced by drawSubWinEntity(), update_specification_bounds(), updateSubWinScale(), and UpdateSubwinScale().

00604 {
00605   double xmax, xmin, ymin, ymax, zmin, zmax ;
00606   double hx,hy,hx1,hy1;
00607   int i;
00608   
00609   sciSubWindow * ppsubwin =  pSUBWIN_FEATURE (pobj);
00610   double FRect[4],WRect[4],ARect[4]; 
00611   char logscale[2];
00612   
00613   /* Temp variables only used when called from update_specification_bounds */
00614   /* to know if we have to redraw all the figure */
00615   double ExistingFRect[4]; /* the Existing FRect at start to be compared at the end of this routine */
00616   /* in order to determine wheter or not the bounds have changed... */
00617   int nbsubtics[2];
00618   int nbgrads[2];
00619   /* End of Temp variables */
00620   
00621   for(i=0;i<4;i++) ExistingFRect[i] =  ppsubwin->FRect[i]; /* store old initial bounds*/
00622 
00623   for(i=0;i<2;i++) nbsubtics[i] = ppsubwin->axes.nbsubtics[i];
00624   nbgrads[0] = ppsubwin->axes.nxgrads;
00625   nbgrads[1] = ppsubwin->axes.nygrads;
00626   
00627   /* nbtics on z put to 0 */
00628   /*   ppsubwin->axes.nzgrads = 0; */
00629   
00630 
00631   sciGetDisplayedBounds( pobj, &xmin, &xmax, &ymin, &ymax, &zmin, &zmax ) ;
00632 
00633 
00634   /* _grad Init. to 0. */
00635   for(i=0;i<20;i++) 
00636     {
00637       ppsubwin->axes.xgrads[i] = 0.;
00638       ppsubwin->axes.ygrads[i] = 0.;
00639     }
00640    
00641  
00642   if ( ppsubwin->logflags[0]=='n') { /* x-axis */
00643     TheTicks(&xmin, &xmax, &(ppsubwin->axes.xgrads[0]), &ppsubwin->axes.nxgrads, FALSE); 
00644     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'n',NULL,ppsubwin->axes.nbsubtics[0]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
00645   }
00646   else{ /* log. case */
00647     GradLog(xmin,xmax,ppsubwin->axes.xgrads,&ppsubwin->axes.nxgrads, FALSE );
00648     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'l',ppsubwin->axes.xgrads,0);
00649   }
00650    
00651   if ( ppsubwin->logflags[1]=='n') { /* y-axis */
00652     TheTicks(&ymin, &ymax, &(ppsubwin->axes.ygrads[0]), &ppsubwin->axes.nygrads, FALSE);
00653     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'n',NULL, ppsubwin->axes.nbsubtics[1]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
00654   }
00655   else{ /* log. case */
00656     GradLog(ymin,ymax,ppsubwin->axes.ygrads,&ppsubwin->axes.nygrads, FALSE );
00657     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'l',ppsubwin->axes.ygrads,0);
00658   }
00659    
00660   if(ppsubwin->tight_limits == FALSE )
00661     {
00662       xmin = ppsubwin->axes.xgrads[0];
00663       xmax = ppsubwin->axes.xgrads[ ppsubwin->axes.nxgrads - 1];
00664       ymin = ppsubwin->axes.ygrads[0];
00665       ymax = ppsubwin->axes.ygrads[ ppsubwin->axes.nygrads - 1];
00666     }
00667 
00668   /*****************************************************************
00669    * modify  bounds if  isoview requested 
00670    *****************************************************************/
00671   if ( ppsubwin->isoview == TRUE) {      
00672     int verbose=0,wdim[2],narg; 
00673         
00674     C2F(dr)("xget","wdim",&verbose,wdim,&narg, PI0, PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
00675     hx=xmax-xmin;
00676     hy=ymax-ymin;
00677     getscale2d(WRect,FRect,logscale,ARect);
00678     
00679     wdim[0]=linint((double)wdim[0] *WRect[2]);
00680     wdim[1]=linint((double)wdim[1] *WRect[3]);
00681     
00682     if ( hx/(double)wdim[0]  <hy/(double) wdim[1] ) {
00683       hx1=wdim[0]*hy/wdim[1];
00684       xmin=xmin-(hx1-hx)/2.0;
00685       xmax=xmax+(hx1-hx)/2.0;
00686     }
00687     else {
00688       hy1=wdim[1]*hx/wdim[0];
00689       ymin=ymin-(hy1-hy)/2.0;
00690       ymax=ymax+(hy1-hy)/2.0;
00691     }
00692     
00693     /* F.Leray 28.09.04 */
00694     /* I need to recompute the correct xgrads and ygrads vector to have a good display */
00695      
00696     if ( ppsubwin->logflags[0]=='n') { /* x-axis */
00697       TheTicks(&xmin, &xmax, &(ppsubwin->axes.xgrads[0]), &ppsubwin->axes.nxgrads, FALSE);
00698       ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'n',NULL, ppsubwin->axes.nbsubtics[0]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
00699     }
00700     else{ /* log. case */
00701       GradLog(xmin,xmax,ppsubwin->axes.xgrads,&ppsubwin->axes.nxgrads, FALSE);
00702       ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'l',ppsubwin->axes.xgrads,0);
00703     }
00704 
00705  
00706 
00707     if ( ppsubwin->logflags[1]=='n') { /* y-axis */
00708       TheTicks(&ymin, &ymax, &(ppsubwin->axes.ygrads[0]), &ppsubwin->axes.nygrads, FALSE);
00709       ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'n',NULL, ppsubwin->axes.nbsubtics[1]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
00710     }
00711     else{ /* log. case */
00712       GradLog(ymin,ymax,ppsubwin->axes.ygrads,&ppsubwin->axes.nygrads, FALSE );
00713       ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'l',ppsubwin->axes.ygrads,0);
00714     }
00715    
00716    
00717     /* END ISO if */
00718   }
00719   
00720   /* Changement ci-dessous F.Leray 21.09.04 */
00721   ppsubwin->axes.xlim[0]=xmin;
00722   ppsubwin->axes.xlim[1]=xmax;
00723   ppsubwin->axes.xlim[2]=0;
00724   ppsubwin->axes.ylim[0]=ymin;
00725   ppsubwin->axes.ylim[1]=ymax;
00726   ppsubwin->axes.ylim[2]=0;
00727    
00728    
00729    
00730   /*****************************************************************
00731    * set the actual bounds in subwindow data structure
00732    *****************************************************************/
00733    
00734    
00735   ppsubwin->FRect[0]=xmin;
00736   ppsubwin->FRect[2]=xmax;
00737   ppsubwin->FRect[1]=ymin;
00738   ppsubwin->FRect[3]=ymax;
00739    
00740   ppsubwin->axes.xlim[3] = ppsubwin->axes.nxgrads;
00741   ppsubwin->axes.ylim[3] = ppsubwin->axes.nygrads;
00742    
00743   /*   ppsubwin->axes.reverse[0] = FALSE; /\*TRUE;*\/  /\* TEST en DUR F.Leray ICIIIIIIIIIIIII 12.10.04 *\/ */
00744   /*    ppsubwin->axes.reverse[1] = FALSE; /\*TRUE;*\/  */
00745    
00746    
00747   set_scale("tftftf",NULL,ppsubwin->FRect,NULL,ppsubwin->logflags,NULL); 
00748    
00749    
00750   for(i=0;i<4;i++)
00751     if(ppsubwin->FRect[i] != ExistingFRect[i]){
00752       return TRUE;
00753       break;
00754     } 
00755    
00756   for(i=0;i<2;i++) 
00757     if(nbsubtics[i] != ppsubwin->axes.nbsubtics[i]){
00758       return TRUE;
00759       break;
00760     }
00761    
00762   if(nbgrads[0] != ppsubwin->axes.nxgrads) return TRUE;
00763   if(nbgrads[1] != ppsubwin->axes.nygrads) return TRUE;
00764    
00765   return FALSE;
00766 }

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL sci_update_frame_bounds_3d ( sciPointObj * pobj )

update_3dbounds -> renammed sci_update_frame_bounds_3d

Author:: Djalel Abdemouche 10/2003 Should be in Plo2dEch.c file

Definition at line 772 of file DrawObjects.c.

References sciSubWindow::axes, ComputeNbSubTics(), FALSE, sciSubWindow::FRect, i, sciSubWindow::logflags, AXES::nbsubtics, NULL, AXES::nxgrads, AXES::nygrads, AXES::nzgrads, pSUBWIN_FEATURE, sciGetDisplayedBounds(), TheTicks(), AXES::xgrads, AXES::ygrads, and AXES::zgrads.

Referenced by update_specification_bounds(), and updateScale3d().

00773 {
00774   double xmin,xmax,ymin,ymax,zmin,zmax; 
00775   int i;
00776   sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj); 
00777 
00778   /* Temp variables only used when called from update_specification_bounds */
00779   /* to know if we have to redraw all the figure */
00780   double ExistingFRect[6]; /* the Existing FRect at start to be compared at the end of this routine */
00781   /* in order to determine wheter or not the bounds have changed... */
00782   int nbsubtics[3];
00783   int nbgrads[3];
00784   /* End of Temp variables */
00785 
00786   for(i=0;i<6;i++) ExistingFRect[i] =  ppsubwin->FRect[i]; /* store old initial bounds*/
00787   
00788   for(i=0;i<3;i++) nbsubtics[i] = ppsubwin->axes.nbsubtics[i];
00789   nbgrads[0] = ppsubwin->axes.nxgrads;
00790   nbgrads[1] = ppsubwin->axes.nygrads;
00791   nbgrads[2] = ppsubwin->axes.nzgrads;
00792 
00793   sciGetDisplayedBounds( pobj, &xmin, &xmax, &ymin, &ymax, &zmin, &zmax ) ;
00794   
00795 
00796   /* _grad Init. to 0. */
00797   for(i=0;i<20;i++) 
00798     {
00799       ppsubwin->axes.xgrads[i] = 0.;
00800       ppsubwin->axes.ygrads[i] = 0.;
00801       ppsubwin->axes.zgrads[i] = 0.;
00802     }
00803    
00804   
00805   if ( ppsubwin->logflags[0]=='n') { /* x-axis */
00806     TheTicks(&xmin, &xmax, &(ppsubwin->axes.xgrads[0]), &ppsubwin->axes.nxgrads, FALSE);
00807     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'n',NULL,ppsubwin->axes.nbsubtics[0]); /* Nb of subtics computation and storage */
00808   }
00809   else{ /* log. case */
00810     GradLog(xmin,xmax,ppsubwin->axes.xgrads,&ppsubwin->axes.nxgrads, FALSE );
00811     ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'l',ppsubwin->axes.xgrads,0);
00812   }
00813   
00814   if ( ppsubwin->logflags[1]=='n') { /* y-axis */
00815     TheTicks(&ymin, &ymax, &(ppsubwin->axes.ygrads[0]), &ppsubwin->axes.nygrads, FALSE);
00816     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'n',NULL, ppsubwin->axes.nbsubtics[1]); /* Nb of subtics computation and storage */
00817   }
00818   else{ /* log. case */
00819     GradLog(ymin,ymax,ppsubwin->axes.ygrads,&ppsubwin->axes.nygrads, FALSE );
00820     ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'l',ppsubwin->axes.ygrads,0);
00821   }
00822   
00823   if ( ppsubwin->logflags[2]=='n') { /* z-axis */
00824     TheTicks(&zmin, &zmax, &(ppsubwin->axes.zgrads[0]), &ppsubwin->axes.nzgrads, FALSE);
00825     ppsubwin->axes.nbsubtics[2] = ComputeNbSubTics(pobj,ppsubwin->axes.nzgrads,'n',NULL, ppsubwin->axes.nbsubtics[2]); /* Nb of subtics computation and storage */
00826   }
00827   else{ /* log. case */
00828     GradLog(zmin,zmax,ppsubwin->axes.zgrads,&ppsubwin->axes.nzgrads, FALSE );
00829     ppsubwin->axes.nbsubtics[2] = ComputeNbSubTics(pobj,ppsubwin->axes.nzgrads,'l',ppsubwin->axes.zgrads,0);
00830   }
00831   
00832   if(ppsubwin->tight_limits == FALSE )
00833     {
00834       xmin = ppsubwin->axes.xgrads[0];
00835       xmax = ppsubwin->axes.xgrads[ ppsubwin->axes.nxgrads - 1];
00836       ymin = ppsubwin->axes.ygrads[0];
00837       ymax = ppsubwin->axes.ygrads[ ppsubwin->axes.nygrads - 1];
00838       zmin = ppsubwin->axes.zgrads[0];
00839       zmax = ppsubwin->axes.zgrads[ ppsubwin->axes.nzgrads - 1];
00840     }
00841 
00842   ppsubwin->axes.xlim[0]=xmin;
00843   ppsubwin->axes.xlim[1]=xmax;
00844   ppsubwin->axes.xlim[2]=0;
00845   ppsubwin->axes.ylim[0]=ymin;
00846   ppsubwin->axes.ylim[1]=ymax;
00847   ppsubwin->axes.ylim[2]=0;
00848   ppsubwin->axes.zlim[0]=zmin; /* rajout pour z */
00849   ppsubwin->axes.zlim[1]=zmax;
00850   ppsubwin->axes.zlim[2]=0;
00851      
00852   ppsubwin->FRect[0]=xmin;
00853   ppsubwin->FRect[2]=xmax;
00854   ppsubwin->FRect[1]=ymin;
00855   ppsubwin->FRect[3]=ymax;
00856   ppsubwin->FRect[4]=zmin;
00857   ppsubwin->FRect[5]=zmax;
00858     
00859   ppsubwin->axes.xlim[3] = ppsubwin->axes.nxgrads;
00860   ppsubwin->axes.ylim[3] = ppsubwin->axes.nygrads;
00861   ppsubwin->axes.zlim[3] = ppsubwin->axes.nzgrads;
00862    
00863   set_scale("tftftf",NULL,ppsubwin->FRect,NULL,ppsubwin->logflags,NULL); 
00864     
00865   for(i=0;i<6;i++)
00866     if(ppsubwin->FRect[i] != ExistingFRect[i]){
00867       return TRUE;
00868       break;
00869     } 
00870     
00871   for(i=0;i<3;i++) 
00872     if(nbsubtics[i] != ppsubwin->axes.nbsubtics[i]){
00873       return TRUE;
00874       break;
00875     }
00876   
00877   if(nbgrads[0] != ppsubwin->axes.nxgrads) return TRUE;
00878   if(nbgrads[1] != ppsubwin->axes.nygrads) return TRUE;
00879   if(nbgrads[2] != ppsubwin->axes.nzgrads) return TRUE;
00880   
00881   return FALSE;  
00882 }

Here is the call graph for this function:

Here is the caller graph for this function:

void sciAxesVerticesIndices	(	integer	insideU[4],
		integer	insideD[4],
		double	xbox[8],
		double	ybox[8],
		integer	xind[8]
	)

Definition at line 2787 of file DrawObjects.c.

References i, ind, Maxi(), MaxiInd(), Nextind(), and sciprint().

Referenced by axis_3ddraw(), and ComputeCorrectXindAndInsideUD().

02792 {
02793   int    i      ;
02794   int    ind    ;
02795   int    ind2   ;
02796   int    ind3   ;
02797   double xmaxi  ;
02798   int    tmpind ;
02799 
02800   /* F.Leray 23.02.04 Mise a 0 du tableau xind pour corriger bug*/
02801   /* dans le cas ind < 3 ET ybox[tmpind] < ybox[tmpind]*/
02802   for( i = 0 ; i < 8 ; i++ )
02803   { 
02804     xind[i] = 0 ;
02805   }
02806 
02807   /* indices */
02808   /* determine the indices for the 3d represention */
02809   xmaxi = ( (double) Maxi(xbox,8L) ) ;
02810   ind = -1 ;
02811   MaxiInd( xbox, 8L, &ind, xmaxi ) ;
02812   if ( ind > 3 )
02813   {
02814     xind[0]=ind;
02815   }
02816   tmpind = ind ;  
02817   MaxiInd(xbox,8L,&ind,xmaxi);
02818   if ( ind > 3 )
02819   {
02820     xind[0] = ind ;
02821   }
02822   if (ybox[tmpind] > ybox[ind] )
02823   {
02824     xind[0] = tmpind ;
02825   }
02826   
02827   if (ind < 0 || ind > 8) 
02828   {
02829     sciprint("xind out of bounds");
02830     xind[0]=0;
02831   }
02832   Nextind(xind[0],&ind2,&ind3);
02833   if (ybox[ind2] > ybox[ind3]) 
02834   {
02835     xind[1]=ind2;insideU[0]=ind3;
02836   }
02837   else 
02838   {
02839     xind[1]=ind3;insideU[0]=ind2;
02840   }
02841   Nextind(ind2,&ind2,&ind3); insideU[1]=xind[0];
02842   insideU[2]=ind2; 
02843   if ( insideU[0] > 3 )
02844   {
02845     insideU[3] = insideU[0] - 4 ;
02846   }
02847   else
02848   {
02849     insideU[3] = insideU[0] + 4 ;
02850   }
02851   xind[2]=ind2;
02852   /* le pointeger en bas qui correspond */        
02853   if ( ind2 > 3 )
02854   {
02855     xind[3] = ind2 - 4 ;
02856   }
02857   else
02858   {
02859     xind[3] = ind2 + 4 ;
02860   }
02861   Nextind(xind[3],&ind2,&ind3);
02862   if (ybox[ind2] < ybox[ind3]) 
02863   {
02864     xind[4]=ind2;insideD[0]=ind3;
02865   }
02866   else  
02867   {
02868     xind[4]=ind3;insideD[0]=ind2;
02869   }
02870   Nextind(ind2,&ind2,&ind3);
02871   insideD[1]=xind[3];
02872   insideD[2]=ind2;
02873   if ( insideD[0] > 3 )
02874   {
02875     insideD[3]=insideD[0] - 4 ;
02876   }
02877   else
02878   {
02879     insideD[3]=insideD[0] + 4 ;
02880   }
02881   xind[5]=ind2;
02882          
02883 }

Here is the call graph for this function:

Here is the caller graph for this function:

void sciDrawFigure ( int numFigure )

draw the figure number numFigure.

Definition at line 1403 of file DrawObjects.c.

References sciDrawObj(), sciGetCurrentFigure(), sciGetNumFigure(), and sciSetUsedWindow().

01404 {
01405   int curFigure = sciGetNumFigure( sciGetCurrentFigure() ) ;
01406   sciSetUsedWindow( numFigure ) ;
01407   sciDrawObj( sciGetCurrentFigure() ) ;
01408   sciSetUsedWindow( curFigure ) ;
01409 }

Here is the call graph for this function:

int sciDrawObj ( sciPointObj * pobj )

sciDrawObj Draws Object (only the basic graphicobject under subwindows) in its SubWindow or figure

Parameters:

sciPointObj

* pobj: the pointer to the entity

Returns:: int 0 if OK, -1 if not

Definition at line 1475 of file DrawObjects.c.

References drawArcEntity(), drawAxesEntity(), drawCompoundEntity(), drawFecEntity(), drawFigureEntity(), drawGrayplotEntity(), drawLegendEntity(), drawMergeEntity(), drawPolylineEntity(), drawRectangleEntity(), drawSegsEntity(), drawSubWinEntity(), drawSurfaceEntity(), drawTextEntity(), GetDriverId(), isGraphicSessionOpened(), SCI_AGREG, SCI_ARC, SCI_AXES, SCI_FEC, SCI_FIGURE, SCI_GRAYPLOT, SCI_LEGEND, SCI_LIGHT, SCI_MENU, SCI_MENUCONTEXT, SCI_MERGE, SCI_PANNER, SCI_POLYLINE, SCI_RECTANGLE, SCI_SBH, SCI_SBV, SCI_SEGS, SCI_STATUSB, SCI_SUBWIN, SCI_SURFACE, SCI_TEXT, and sciGetEntityType().

Referenced by champg(), drawCompoundEntity(), drawFigureEntity(), drawSubWinEntity(), fec(), Objplot3d(), plot2dn(), sci_copy(), sci_delete(), sci_draw(), sci_drawnow(), sci_set(), sci_xend(), sci_xfpoly(), sci_xfpolys(), sci_xgrid(), sci_xpoly(), sci_xpolys(), sci_xrect(), sci_xrects(), sci_xsegs(), sciDrawFigure(), sciDrawObjIfRequired(), scig_toPs(), sciInitdrawmode(), sciRedrawF(), sciRedrawFigure(), sciRelocateHandles(), sciXbasc(), sciXclear(), swapHandles(), unzoom(), unzoom_one_axes(), xgray(), xgray1(), xgray2(), and zoom_box().

01476 {
01477  
01478   
01479   /* driver test */  
01480   if((GetDriverId() != 0) && ( isGraphicSessionOpened() )){
01481     return -1;
01482   }
01483 
01484   switch (sciGetEntityType (pobj))
01485     {
01486     case SCI_FIGURE:
01487       return drawFigureEntity( pobj ) ;
01488       break;
01489     case SCI_SUBWIN:
01490       return drawSubWinEntity( pobj ) ;
01491       break ;
01492     case SCI_AGREG:
01493       return drawCompoundEntity( pobj ) ;
01494       break;
01495     case SCI_LEGEND:
01496       return drawLegendEntity( pobj ) ;
01497       break;   
01498     case SCI_FEC:
01499       return drawFecEntity( pobj ) ;
01500       break;      
01501     case SCI_SEGS:
01502       return drawSegsEntity( pobj ) ;
01503       break;
01504     case SCI_GRAYPLOT:
01505       return drawGrayplotEntity( pobj ) ;
01506       break;
01507     case SCI_POLYLINE:   
01508       return drawPolylineEntity( pobj ) ;
01509       break;
01510     case SCI_ARC:
01511       return drawArcEntity( pobj ) ;
01512       break;
01513     case SCI_RECTANGLE:
01514       return drawRectangleEntity( pobj ) ;
01515       break;
01516     case SCI_TEXT:
01517       return drawTextEntity( pobj ) ;
01518       break;
01519     case SCI_AXES:
01520       return drawAxesEntity(pobj) ;
01521       break;
01522     case SCI_MERGE:
01523       return drawMergeEntity(pobj) ;
01524       break ;
01525     case SCI_SURFACE:
01526       return drawSurfaceEntity(pobj) ;
01527       break;
01528     case SCI_LIGHT:
01529     case SCI_PANNER:
01530     case SCI_SBH:
01531     case SCI_SBV:
01532     case SCI_MENU:
01533     case SCI_MENUCONTEXT:
01534     case SCI_STATUSB:
01535     default:
01536       return -1;
01537       break;
01538     }
01539   /*sciSetSelectedSubWin (curSubWin);*/
01540   return -1;
01541 }

Here is the call graph for this function:

Here is the caller graph for this function:

int sciDrawObjIfRequired ( sciPointObj * pobj )

sciDrawObjIfRequired Draws Object (only the basic graphicobject under subwindows) in its SubWindow or figure if and only if pFIGURE_FEATURE(pobj)->auto_redraw == TRUE !! Only used inside High Level functions calls (sucha as plot2d, plot3d...)

Parameters:

sciPointObj

* pobj: the pointer to the entity

Returns:: int 0 if OK, -1 if not

Definition at line 1457 of file DrawObjects.c.

References pFIGURE_FEATURE, sciDrawObj(), and sciGetParentFigure().

Referenced by champg(), fec(), Objarc(), Objdrawaxis(), Objfpoly(), Objpoly(), Objrect(), Objsegs(), Objstring(), Objtitle(), plot2dn(), sci_xfpoly(), sci_xfpolys(), sci_xpoly(), sci_xpolys(), sci_xrect(), sci_xrects(), sci_xsegs(), sciRefreshObj(), xgray(), xgray1(), and xgray2().

01458 {
01459   sciPointObj * pfigure = sciGetParentFigure(pobj);
01460 
01461   if( pFIGURE_FEATURE(pfigure)->auto_redraw && pFIGURE_FEATURE(pfigure)->visible )
01462   {
01463     sciDrawObj(pobj);
01464   }
01465 
01466   return 0;
01467 }

Here is the call graph for this function:

Here is the caller graph for this function:

void sciGetAxisBox	(	double	limits[6],
		double	xbox[8],
		double	ybox[8],
		double	zbox[8]
	)

Definition at line 2725 of file DrawObjects.c.

References TRX, TRY, and TRZ.

Referenced by ComputeCorrectXindAndInsideUD(), and updateScale3d().

02726 {
02727   xbox[0]=TRX(limits[0],limits[2],limits[4]); /* transfo. 3D of [xmin,ymin,zmin] */
02728   ybox[0]=TRY(limits[0],limits[2],limits[4]); /* into [xbox[0],ybox[0],zbox[0] ] */
02729   zbox[0]=TRZ(limits[0],limits[2],limits[4]); /*                                 */ 
02730   
02731   xbox[1]=TRX(limits[0],limits[3],limits[4]); /* transfo. 3D of [xmin,ymax,zmin] */
02732   ybox[1]=TRY(limits[0],limits[3],limits[4]); /* into [xbox[1],ybox[1],zbox[1] ] */
02733   zbox[1]=TRZ(limits[0],limits[3],limits[4]); /*                                 */
02734   
02735   xbox[2]=TRX(limits[1],limits[3],limits[4]); /* transfo. 3D of [xmax,ymax,zmin] */
02736   ybox[2]=TRY(limits[1],limits[3],limits[4]); /* into [xbox[2],ybox[2],zbox[2] ] */
02737   zbox[2]=TRZ(limits[1],limits[3],limits[4]); /*                                 */
02738   
02739   xbox[3]=TRX(limits[1],limits[2],limits[4]); /* transfo. 3D of [xmax,ymin,zmin] */
02740   ybox[3]=TRY(limits[1],limits[2],limits[4]); /* into [xbox[3],ybox[3],zbox[3] ] */
02741   zbox[3]=TRZ(limits[1],limits[2],limits[4]); /*                                 */
02742   
02743   xbox[4]=TRX(limits[0],limits[2],limits[5]); /* transfo. 3D of [xmin,ymin,zmax] */
02744   ybox[4]=TRY(limits[0],limits[2],limits[5]); /* into [xbox[4],ybox[4],zbox[4] ] */
02745   zbox[4]=TRZ(limits[0],limits[2],limits[5]); /*                                 */
02746   
02747   xbox[5]=TRX(limits[0],limits[3],limits[5]); /* transfo. 3D of [xmin,ymax,zmax] */
02748   ybox[5]=TRY(limits[0],limits[3],limits[5]); /* into [xbox[5],ybox[5],zbox[5] ] */
02749   zbox[5]=TRZ(limits[0],limits[3],limits[5]); /*                                 */
02750   
02751   xbox[6]=TRX(limits[1],limits[3],limits[5]); /* transfo. 3D of [xmax,ymax,zmax] */
02752   ybox[6]=TRY(limits[1],limits[3],limits[5]); /* into [xbox[6],ybox[6],zbox[6] ] */
02753   zbox[6]=TRZ(limits[1],limits[3],limits[5]); /*                                 */
02754   
02755   xbox[7]=TRX(limits[1],limits[2],limits[5]); /* transfo. 3D of [xmax,ymin,zmax] */
02756   ybox[7]=TRY(limits[1],limits[2],limits[5]); /* into [xbox[7],ybox[7],zbox[7] ] */
02757   zbox[7]=TRZ(limits[1],limits[2],limits[5]); /*                                 */
02758 }

Here is the caller graph for this function:

void sciGetDisplayedBounds	(	sciPointObj *	pSubWin,
		double *	xmin,
		double *	xmax,
		double *	ymin,
		double *	ymax,
		double *	zmin,
		double *	zmax
	)

Definition at line 531 of file DrawObjects.c.

References sciSubWindow::logflags, pSUBWIN_FEATURE, sciGetLogExponent(), sciGetZooming(), sciprint(), sciSubWindow::SRect, and sciSubWindow::ZRect.

Referenced by sci_update_frame_bounds_2d(), sci_update_frame_bounds_3d(), updateXaxesTics(), and updateYaxesTics().

00538 {
00539   sciSubWindow * ppsubwin =  pSUBWIN_FEATURE ( pSubWin ) ;
00540     /*****************************************************************
00541      * get initial bounds
00542    *****************************************************************/
00543   if( sciGetZooming( pSubWin ) )
00544   {
00545     *xmin = ppsubwin->ZRect[0] ; 
00546     *ymin = ppsubwin->ZRect[1] ; 
00547     *xmax = ppsubwin->ZRect[2] ;
00548     *ymax = ppsubwin->ZRect[3] ;
00549     *zmin = ppsubwin->ZRect[4] ;
00550     *zmax = ppsubwin->ZRect[5] ;
00551   }
00552   else
00553   {
00554     *xmin = ppsubwin->SRect[0] ;
00555     *ymin = ppsubwin->SRect[2] ;
00556     *xmax = ppsubwin->SRect[1] ;
00557     *ymax = ppsubwin->SRect[3] ;
00558     *zmin = ppsubwin->SRect[4] ;
00559     *zmax = ppsubwin->SRect[5] ;
00560   }
00561   
00562   
00563    
00564   /*****************************************************************
00565    * modify  bounds and aaint  if using log scaling X axis
00566    *****************************************************************/
00567   if ( ppsubwin->logflags[0] == 'l' )
00568   {
00569     if ( sciGetLogExponent( *xmin, *xmax, xmin, xmax ) != 0 )
00570     {
00571       sciprint("Warning: Can't use Log on X-axis xmin is negative. \n");
00572     }
00573   }
00574 
00575   /*****************************************************************
00576    * modify  bounds and aaint  if using log scaling Y axis
00577    *****************************************************************/
00578   if ( ppsubwin->logflags[1] == 'l' )
00579   {
00580     if ( sciGetLogExponent( *ymin, *ymax, ymin, ymax ) != 0 )
00581     {
00582       sciprint("Warning: Can't use Log on Y-axis ymin is negative. \n");
00583     }
00584   }
00585 
00586   /*****************************************************************
00587    * modify  bounds and aaint  if using log scaling Z axis
00588    *****************************************************************/
00589   if ( ppsubwin->logflags[2] == 'l' )
00590   {
00591     if ( sciGetLogExponent( *zmin, *zmax, zmin, zmax ) != 0 )
00592     {
00593       sciprint("Warning: Can't use Log on Z-axis zmin is negative. \n");
00594     }
00595   }
00596 
00597 }

Here is the call graph for this function:

Here is the caller graph for this function:

int sciGetLogExponent	(	double	minBound,
		double	maxBound,
		double *	expMin,
		double *	expMax
	)

get the exponent used for log axis from given data bounds

Returns:: 0 if OK, -1 if negative bounds.

Definition at line 517 of file DrawObjects.c.

Referenced by sciGetDisplayedBounds().

00518 {
00519   if ( minBound > 0 )
00520   {
00521     *expMin = floor( log10( minBound ) ) ;
00522     *expMax = ceil(  log10( maxBound ) ) ;
00523     return 0 ;
00524   }
00525   *expMax = 1.0 ;
00526   *expMin = 0.0 ;
00527   return -1 ;
00528 }

Here is the caller graph for this function:

int scilab_shade	(	integer *	polyx,
		integer *	polyy,
		integer *	fill,
		integer	polysize,
		integer	flag
	)

void sciRedrawF ( int * value )

Definition at line 120 of file DrawObjects.c.

References C2F, cur, dr(), L, na, NULL, PD0, PI0, sciDrawObj(), and sciIsExistingFigure().

Referenced by scig_replay_hdc().

00122 { 
00123   sciPointObj *figure; 
00124   integer cur,na,verb=0;
00125   figure= (sciPointObj *) sciIsExistingFigure(value); 
00126   /* F.Leray 13.04.04 : Test if returned sciPointObj* is NULL (means Figure has been destroyed) */
00127 
00128   if(figure == (sciPointObj *)  NULL)
00129     {
00130       /* Do nothing */
00131     }
00132   else
00133     {
00134       C2F (dr) ("xget", "window",&verb,&cur,&na,PI0,PI0,PI0,PD0,PD0,PD0,PD0,4L,6L);
00135       C2F (dr) ("xset", "window",value,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,4L,6L);
00136       sciDrawObj (figure);
00137       C2F (dr) ("xset", "window",&cur,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,4L,6L);
00138     }
00139 }

Here is the call graph for this function:

Here is the caller graph for this function:

void sciRedrawFigure ( void )

Definition at line 115 of file DrawObjects.c.

References sciDrawObj(), and sciGetCurrentFigure().

Referenced by I3dRotation(), sci_xset(), sci_xtitle(), scig_expose(), scig_replay(), and scig_resize().

00116 {
00117   sciDrawObj (sciGetCurrentFigure ());
00118 }

Here is the call graph for this function:

Here is the caller graph for this function:

int sciRefreshObj ( sciPointObj * pobj )

Definition at line 1416 of file DrawObjects.c.

References C2F, dr(), sciDrawObjIfRequired(), sciGetNum(), and sciGetParentFigure().

Referenced by Objmove().

01417 {
01418   
01419   int parentId = sciGetNum( sciGetParentFigure( pobj ) ) ;
01420   int currentId             ;
01421   int status                ;
01422   int verboseGet        = 0 ;
01423   int iDontKnowWhatItIs     ;
01424   /* get current Id in ScilabXgc */
01425   C2F (dr) ("xget", "window",&verboseGet,&currentId,&iDontKnowWhatItIs,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01426 
01427   /* set the parent figure of the object as the current figure */
01428   if ( parentId != currentId )
01429   {
01430     C2F (dr) ("xset", "window",&parentId,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01431   }
01432   
01433   /* draw the object */
01434   status = sciDrawObjIfRequired( pobj ) ;
01435 
01436   /* set back the values */
01437   if ( parentId != currentId )
01438   {
01439     C2F (dr) ("xset", "window",&currentId,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
01440   }
01441 
01442   return status ;
01443   
01444   
01445 }

Here is the call graph for this function:

Here is the caller graph for this function:

void sciUpdateScaleAngles	(	double	theta,
		double	alpha
	)

Definition at line 2761 of file DrawObjects.c.

References cost, Cscale, DEG2RAD, wcscalelist::m, and sint.

Referenced by ComputeCorrectXindAndInsideUD(), drawSubWinEntity(), and updateScale3d().

02762 {
02763   double cost = 0.5 ;
02764   double sint = 0.5 ;
02765   double cosa = 0.5 ;
02766   double sina = 0.5 ;
02767 
02768   cost = cos( DEG2RAD(theta) ) ;
02769   cosa = cos( DEG2RAD(alpha) ) ;
02770   sint = sin( DEG2RAD(theta) ) ;
02771   sina = sin( DEG2RAD(alpha) ) ;
02772   
02773   Cscale.m[0][0]= -sint        ;
02774   Cscale.m[0][1]=  cost        ;
02775   Cscale.m[0][2]=  0           ;
02776   Cscale.m[1][0]= -cost * cosa ;
02777   Cscale.m[1][1]= -sint * cosa ;
02778   Cscale.m[1][2]=  sina        ;
02779   Cscale.m[2][0]=  cost * sina ;
02780   Cscale.m[2][1]=  sint * sina ;
02781   Cscale.m[2][2]=  cosa        ;
02782 
02783 }

Here is the caller graph for this function:

void sciXbasc ( void )

Definition at line 141 of file DrawObjects.c.

References ConstructSubWin(), DestroyAllGraphicsSons(), BCG::mafigure, NULL, sciDrawObj(), sciGetCurrentFigure(), sciSetCurrentObj(), and sciSetOriginalSubWin().

Referenced by sci_delete(), sci_xset(), sciDelGraphicObj(), and scig_erase().

00142 {  
00143   static sciPointObj *mafigure;
00144   static sciPointObj *masousfen;  
00145  
00146   mafigure= (sciPointObj *) sciGetCurrentFigure(); 
00147   DestroyAllGraphicsSons((sciPointObj *)mafigure);
00148   
00149    
00150   if ((masousfen = ConstructSubWin (mafigure, 'o')) != NULL){
00151     sciSetCurrentObj(masousfen);
00152     sciSetOriginalSubWin (mafigure, masousfen);}
00153   sciDrawObj(sciGetCurrentFigure ());      
00154 }

Here is the call graph for this function:

Here is the caller graph for this function:

void sciXclear ( void )

Definition at line 156 of file DrawObjects.c.

References FALSE, NULL, tagSons::pnext, tagSons::pointobj, SCI_SUBWIN, sciDrawObj(), sciGetCurrentFigure(), sciGetCurrentSubWin(), sciGetEntityType(), sciGetSons(), sciSetdrawmode(), and sciSetSelectedSubWin().

Referenced by sci_xclear().

00157 {
00158   static sciPointObj *masousfen, *tmpsousfen;
00159   sciSons *psonstmp; 
00160      
00161   tmpsousfen= sciGetCurrentSubWin();
00162   psonstmp = sciGetSons (sciGetCurrentFigure());
00163   
00164   while (psonstmp != (sciSons *) NULL)  
00165     {  
00166       if(sciGetEntityType (psonstmp->pointobj) == SCI_SUBWIN)
00167         {
00168           masousfen= (sciPointObj *)psonstmp->pointobj;
00169           sciSetSelectedSubWin (masousfen);
00170           sciSetdrawmode (FALSE); 
00171         }
00172       psonstmp = psonstmp->pnext;
00173     }
00174   sciSetSelectedSubWin (tmpsousfen);
00175   sciDrawObj(sciGetCurrentFigure ());      
00176 }

Here is the call graph for this function:

Here is the caller graph for this function:

void updateScale3d	(	sciPointObj *	pobj,
		double	dbox[6],
		double	xbox[8],
		double	ybox[8],
		double	zbox[8]
	)

Definition at line 179 of file DrawObjects.c.

References sciSubWindow::alpha, wcscalelist::alpha, sciSubWindow::axes, wcscalelist::bbox1, C2F, Cscale, sciSubWindow::cube_scaling, dr(), dx, dy, AXES::flag, sciSubWindow::FRect, getscale2d(), hmax, i, L, linint, Maxi(), wcscalelist::metric3d, Mini(), NULL, PD0, PI0, pSUBWIN_FEATURE, R, sci_update_frame_bounds_3d(), sciGetAxisBox(), sciUpdateScaleAngles(), set_scale(), sciSubWindow::theta, and wcscalelist::theta.

Referenced by axis_3ddraw(), and updateSubWinScale().

00184 {
00185   int    flag     ;
00186   int    i        ;
00187   double xmmin    ;
00188   double xmmax    ;
00189   double ymmin    ;
00190   double ymmax    ;
00191   double wmax     ;
00192   double hmax     ;
00193   integer aaint[] = {2,10,2,10} ;
00194   sciSubWindow * ppsubwin =  pSUBWIN_FEATURE (pobj);
00195 
00196   sci_update_frame_bounds_3d( pobj ) ;
00197        
00198   dbox[0] =  ppsubwin->FRect[0] ; /*xmin*/
00199   dbox[1] =  ppsubwin->FRect[2] ; /*xmax*/
00200   dbox[2] =  ppsubwin->FRect[1] ; /*ymin*/
00201   dbox[3] =  ppsubwin->FRect[3] ; /*ymax*/
00202   dbox[4] =  ppsubwin->FRect[4] ; /*zmin*/
00203   dbox[5] =  ppsubwin->FRect[5] ; /*zmax*/
00204 
00205   if( ppsubwin->cube_scaling )
00206   {
00207     dbox[0] =  0.; 
00208     dbox[1] =  1.;
00209     dbox[2] =  0.;
00210     dbox[3] =  1.;
00211     dbox[4] =  0.;
00212     dbox[5] =  1.;
00213   }
00214 
00215 
00217   flag = ( ppsubwin->axes.flag[1] + 1 ) / 2 ; /* F.Leray Adding HERE 19.04.04 */
00218 
00219   Cscale.alpha = ppsubwin->alpha ;
00220   Cscale.theta = ppsubwin->theta ;
00221       
00222   /* update Cscale.m from the new viewing angles */
00223   sciUpdateScaleAngles( ppsubwin->theta, ppsubwin->alpha ) ;
00224       
00225   for ( i = 0 ; i < 6 ; i++ ) 
00226   { 
00227     if ( flag == 0 )
00228     { 
00229       dbox[i] = Cscale.bbox1[i];
00230     }
00231     else
00232     { 
00233       Cscale.bbox1[i] = dbox[i];
00234     }
00235   }
00236 
00237   /* get the vertices of the axes box */
00238   sciGetAxisBox( dbox, xbox, ybox, zbox ) ;
00239       
00241   if ( flag == 1 || flag == 3 ) /* ALL the expanded cases : flag[1] = 1 or 2 or 5 or 6 */
00242   {
00243     xmmin =  Mini(xbox,8L) ;
00244     xmmax =  Maxi(xbox,8L) ; /* search for x Min/Max on all the edges (there are 8 edges that compose the box) F.Leray 13.10.04 */
00245     ymmax = -Mini(ybox,8L) ; /* same thing on ybox vector ( 1) why - (minus) ? see 2) )*/
00246     ymmin = -Maxi(ybox,8L);
00247   }
00248   
00249   if ( flag == 2 || flag == 3 ) /* ALL the isometric cases : flag[1] = 3 or 4 or 5 or 6 */
00250   {
00251     int verbose = 0 ;
00252     int narg        ;
00253     int wdim[2]     ;
00254     double FRect[4] ;
00255     double WRect[4] ;
00256     double ARect[4] ;
00257     char   logf_[2]  ;
00258     /* get current window size */
00259     C2F(dr)("xget","wdim",&verbose,wdim,&narg, PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
00260     getscale2d(WRect,FRect,logf_,ARect);
00261     wmax=linint((double)wdim[0] * WRect[2]);
00262     hmax=linint((double)wdim[1] * WRect[3]); 
00263   }
00264   
00265   if ( flag == 2 ) /* the "NON expanded isometric" cases : flag[1] = 3 or 4 */
00266   {
00267     double R  ;
00268     double xo ;
00269     double yo ;
00270     double zo ;
00271     double dx ;
00272     double dy ;
00273     double dz ;
00274     
00275     /* radius and center of the sphere circumscribing the box */
00276     dx = dbox[1] - dbox[0] ;
00277     dy = dbox[3] - dbox[2] ;
00278     dz = dbox[5] - dbox[4] ;
00279     
00280     R  = sqrt( dx*dx + dy*dy + dz*dz)/2;
00281     xo = ( xbox[0] + xbox[6] ) / 2.0 ;
00282     yo = ( ybox[0] + ybox[6] ) / 2.0 ;
00283     zo = ( zbox[0] + zbox[6] ) / 2.0 ;
00284     
00285     xmmin=   xo - R ;
00286     xmmax=   xo + R ;
00287     ymmax=  -yo + R ;
00288     ymmin=  -yo - R ;
00289   }
00290 
00291   if (flag==2 || flag==3)
00292   {
00293     double hx ;
00294     double hy  ;
00295     hx=xmmax-xmmin;
00296     hy=ymmax-ymmin;
00297     if ( hx/(double)wmax  < hy/(double)hmax ) 
00298     {
00299       double hx1 ;
00300       hx1   = wmax * hy / hmax ;
00301       xmmin = xmmin - ( hx1 - hx ) / 2.0 ;
00302       xmmax = xmmax + ( hx1 - hx ) / 2.0 ;
00303     }
00304     else 
00305     {
00306       double hy1 ;
00307       hy1 = hmax * hx / wmax ;
00308       ymmin = ymmin - ( hy1 - hy ) / 2.0 ;
00309       ymmax = ymmax + ( hy1 - hy ) / 2.0 ;
00310     }
00311   }
00312 
00313   if (flag != 0 ) /* != using current 3D scale */
00314   {
00315     double FRect[4] ;
00316     /* FRect = [Xmin,Ymin,Xmax,Ymax] */
00317     FRect[0] =  xmmin ;
00318     FRect[1] = -ymmax ;
00319     FRect[2] =  xmmax ;
00320     FRect[3] = -ymmin ; /* 2) ... (why - (minus) ? )*/
00321     set_scale("tftttf",NULL,FRect,aaint,"nn",NULL);
00322     Cscale.metric3d = flag; 
00323   }
00324 }

Here is the call graph for this function:

Here is the caller graph for this function:

void UpdateSubwinScale ( sciPointObj * pobj )

Definition at line 1046 of file DrawObjects.c.

References sciSubWindow::axes, axis_3ddraw(), FALSE, AXES::flag, sciSubWindow::is3d, sciSubWindow::isoview, long, NULL, pSUBWIN_FEATURE, sci_update_frame_bounds_2d(), sciGetCurrentSubWin(), sciGetVisibility(), sciSetSelectedSubWin(), sciSetVisibility(), and TRUE.

Referenced by plot2dn(), and sciInitIs3d().

01047 {
01048   sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
01049   sciPointObj * currentsubwin = NULL;
01050   BOOL vis_save = FALSE;
01051   double xbox[8],ybox[8],zbox[8];
01052   static integer InsideU[4],InsideD[4];
01053         
01054   currentsubwin = sciGetCurrentSubWin();
01055 
01056   sciSetSelectedSubWin(pobj); 
01057   
01058   /*   set_scale ("tttftt", pSUBWIN_FEATURE (pobj)->WRect, pSUBWIN_FEATURE (pobj)->FRect, */
01059   /*         NULL, pSUBWIN_FEATURE (pobj)->logflags,  */
01060   /*         pSUBWIN_FEATURE (pobj)->ARect);  */
01061   
01062   if (ppsubwin->is3d) 
01063     {  /* 3D Coordinates */ /* verifier si c'est encore utile SS */
01064       /*To have directly all the possible ISOVIEW Modes*/
01065       long isoflag = (long)(ppsubwin->axes.flag[1]+1)/2; 
01066       
01067       if(ppsubwin->isoview == TRUE) {
01068         if(isoflag ==2 || isoflag == 3){                }
01069         else {
01070           if((ppsubwin->axes.flag[1] == 0)
01071              || (ppsubwin->axes.flag[1] == 2))
01072             /* The default isoview mode is type=4 3d isometric bounds 
01073                derived from the data, to similarily type=2  */
01074             ppsubwin->axes.flag[1] = 4; 
01075           else if(ppsubwin->axes.flag[1] == 1)
01076             ppsubwin->axes.flag[1] = 3;
01077         }
01078       }
01079       else {
01080         if((ppsubwin->axes.flag[1] == 3) 
01081            || (ppsubwin->axes.flag[1] == 5))
01082           ppsubwin->axes.flag[1] = 1; /* computed from ebox*/
01083         else if((ppsubwin->axes.flag[1] == 4) 
01084                 || (ppsubwin->axes.flag[1] == 6))
01085           /* The default NON-isoview mode is 2 computed from data*/
01086           ppsubwin->axes.flag[1] = 2; 
01087       }
01088       
01089 
01090       vis_save = sciGetVisibility(pobj);
01091 
01092       sciSetVisibility(pobj,FALSE);
01093       axis_3ddraw(pobj,xbox,ybox,zbox,InsideU,InsideD); /* TEST on sciGetVisibility inside */
01094       /* because axis_3ddraw displays 3d axes BUT ALSO compute + reset the 3d scale BEFORE !! */
01095       sciSetVisibility(pobj,vis_save);
01096     }
01097   else /* we are in 2D mode...*/
01098     {
01099       sci_update_frame_bounds_2d(pobj);
01100     }
01101 
01102   sciSetSelectedSubWin(currentsubwin); 
01103   
01104 }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned short defcolors[]

Definition at line 77 of file DrawObjects.c.


Defines
#define	round(a) (int)(((a)<0.0)?(a)-.5:(a)+.5)
Functions
double C2F()	dsort ()
int	scilab_shade (integer polyx, integer polyy, integer *fill, integer polysize, integer flag)
void	GradFixedlog (double minVal, double maxVal, double *ticks, int nbGrads)
int	sciGetLogExponent (double minBound, double maxBound, double expMin, double expMax)
void	sciRedrawFigure (void)
void	sciRedrawF (int *value)
void	sciXbasc ()
void	sciXclear ()
void	updateScale3d (sciPointObj *pobj, double dbox[6], double xbox[8], double ybox[8], double zbox[8])
void	Nextind (integer ind1, integer ind2, integer ind3)
BOOL	Ishidden (sciPointObj *pobj)
BOOL	IsDownAxes (sciPointObj *pobj)
int	GradLog (double _min, double _max, double _grads, int n_grads, int compNgrads)
void	sciGetDisplayedBounds (sciPointObj pSubWin, double xmin, double xmax, double ymin, double ymax, double zmin, double *zmax)
BOOL	sci_update_frame_bounds_2d (sciPointObj *pobj)
BOOL	sci_update_frame_bounds_3d (sciPointObj *pobj)
int	ComputeNbSubTics (sciPointObj pobj, int nbtics, char logflag, double grads, int nbsubtics_input)
BOOL	GetIsAxes2D (sciPointObj *psubwin)
int	ComputeCorrectXindAndInsideUD (double Teta, double Alpha, double dbox, integer xind, integer InsideU, integer InsideD)
int	ComputeGoodTrans3d (sciPointObj psubwin, int n, int xm, int ym, double fx, double fy, double fz)
void	DrawAxesIfRequired (sciPointObj *pobj)
void	DrawAxes (sciPointObj *pobj)
void	UpdateSubwinScale (sciPointObj *pobj)
int	Gen3DPoints (integer type, integer polyx, integer polyy, integer fill, integer whiteid, double zmin, double zmax, double x, double y, double z, integer i, integer j, integer jj1, integer p, integer dc, integer fg, sciPointObj psurface)
int	Merge3dDimension (sciPointObj *pparent)
int	ChildrenCounter (sciPointObj *pparent)
void	Merge3dBuildTable (sciPointObj pparent, int index_in_entity, long from_entity, int pos)
void	Merge3d (sciPointObj *psubwin)
void	sciDrawFigure (int numFigure)
int	sciRefreshObj (sciPointObj *pobj)
int	sciDrawObjIfRequired (sciPointObj *pobj)
int	sciDrawObj (sciPointObj *pobj)
int	AdaptGraduationsOnYBottomLeft (int iof, int x, int y, int size, integer Ticsdir, int fontid, sciPointObj *psubwin, double yminval, double ymaxval, double fx, double fy, double fz)
int	AdaptGraduationsOnXBottomLeft (int iof, int x, int y, int size, integer Ticsdir, int fontid, sciPointObj *psubwin, double xminval, double xmaxval, double fx, double fy, double fz)
int	AdaptGraduationsOnYBottomRight (int iof, int x, int y, int size, integer Ticsdir, int fontid, sciPointObj *psubwin, double yminval, double ymaxval, double fx, double fy, double fz)
int	AdaptGraduationsOnXBottomRight (int iof, int x, int y, int size, integer Ticsdir, int fontid, sciPointObj *psubwin, double xminval, double xmaxval, double fx, double fy, double fz)
int	AdaptGraduationsOnZ (int x, int y, int size, integer Ticsdir, int fontid, sciPointObj *psubwin, double zminval, double zmaxval, double fx, double fy, double fz)
int	ComputeNbSubTicsFor3dUse (sciPointObj pobj, int nbtics, char logflag, double grads, int nbsubtics_input)
int	ChooseFormatForOneGrad (char c_format, double grad)
void	sciGetAxisBox (double limits[6], double xbox[8], double ybox[8], double zbox[8])
void	sciUpdateScaleAngles (double theta, double alpha)
void	sciAxesVerticesIndices (integer insideU[4], integer insideD[4], double xbox[8], double ybox[8], integer xind[8])
void	computeLabelAutoPos (sciPointObj *pLabel, int axisStart[2], int axisEnd[2], int offsets[2])
Variables
unsigned short	defcolors []

DrawObjects.c File Reference

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation