Plo3d.c File Reference

#include <string.h>
#include <math.h>
#include <stdio.h>
#include "math_graphics.h"
#include "PloEch.h"
#include "GetProperty.h"
#include "SetProperty.h"
#include "DrawObjects.h"
#include "Xcall1.h"
#include "Plo3d.h"
#include "axesScale.h"
#include "BasicAlgos.h"
#include "sciprint.h"
#include "Format.h"
#include "periScreen.h"
#include "CurrentObjectsManagement.h"
#include "MALLOC.h"

Include dependency graph for Plo3d.c:

Go to the source code of this file.

Defines
#define	PGEOX(x1, y1, z1)   inint(xx1= Cscale.Wscx1*(TRX(x1,y1,z1)-Cscale.frect[0]) +Cscale.Wxofset1);
#define	PGEOY(x1, y1, z1)   inint(yy1= Cscale.Wscy1*(-TRY(x1,y1,z1)+Cscale.frect[3])+Cscale.Wyofset1);
Functions
void wininfo	__PARAMS ((char *fmt,...))
double C2F()	dsort ()
char	GetDriver (void)
int	Check3DPlots (char *, integer *)
int	scilab_shade (integer *polyx, integer *polyy, integer *fill, integer polysize, integer flag)
static void dbox	__PARAMS ((void))
int C2F()	box3d (double *xbox, double *ybox, double *zbox)
void	SetEch3d1 (double *xbox, double *ybox, double *zbox, double *bbox, double *teta, double *alpha, integer flag)
void	UpNext (integer ind1, integer *ind2, integer *ind3)
void	DownNext (integer ind1, integer *ind2, integer *ind3)
void	Convex_Box (double *xbox, double *ybox, integer *InsideU, integer *InsideD, char *legend, integer *flag, double *bbox)
void C2F()	TDdrawaxis (double size, double FPval, double LPval, integer *nax, integer *FPoint, integer *LPoint, integer *Ticsdir)
void	TDAxis (integer flag, double FPval, double LPval, integer *nax, integer *FPoint, integer *LPoint, integer *Ticsdir)
void	AxesStrings (integer axflag, integer *ixbox, integer *iybox, integer *xind, char *legend, double *bbox)
void	BBoxToval (double *x, double *y, double *z, integer ind, double bbox[6])
int	I3dRotation (void)
static void	dbox (void)
int	triangleSort (integer *polyxin, integer *polyyin, integer *fillin, integer *polyx, integer *polyy, integer *fill)
Variables
static double	theta
static double	alpha

---

Define Documentation

#define PGEOX	(	x1,
		y1,
		z1		)	inint(xx1= Cscale.Wscx1*(TRX(x1,y1,z1)-Cscale.frect[0]) +Cscale.Wxofset1);

PGEOX and PGEOY are like GEOX or GEOY in PloEch.h but we keep values in xx1 and yy1 for finite check

Definition at line 34 of file Plo3d.c.

#define PGEOY	(	x1,
		y1,
		z1		)	inint(yy1= Cscale.Wscy1*(-TRY(x1,y1,z1)+Cscale.frect[3])+Cscale.Wyofset1);

Definition at line 35 of file Plo3d.c.

---

Function Documentation

static void dbox __PARAMS

(

(void)

)

[static]

void wininfo __PARAMS

(

(char *fmt,...)

)

void AxesStrings	(	integer	axflag,
		integer *	ixbox,
		integer *	iybox,
		integer *	xind,
		char *	legend,
		double *	bbox
	)

xind : indices des points de l'enveloppe cvxe ds xbox et ybox

le cot\'e gauche ( c'est tjrs un axe des Z

le cot\^e en bas \`a gauche

le cot\'e en bas a droite

Definition at line 453 of file Plo3d.c.

References BBoxToval(), C2F, dr(), FREE, inint, L, MALLOC, NULL, PD0, PI0, sciprint(), TDAxis(), x, and y.

Referenced by Convex_Box().

{
  integer verbose=0,narg_,xz[2];
  integer iof;
  char *loc = NULL;
  /*   char * buff = NULL; */
  char * legx = NULL;
  char * legy = NULL;
  char * legz = NULL;
  integer rect[4],flag=0,x,y;
  double ang=0.0;

  loc=(char *) MALLOC( (strlen(legend)+1)*sizeof(char));
  if ( loc == NULL)
    {
      sciprint("AxesString : No more Place to store Legends\n");
      return;
    }
  
  strcpy(loc,legend);
  /*   legx=strtok_r(loc,"@",&buff); */
  /*   legy=strtok_r(NULL,"@",&buff); */
  /*   legz=strtok_r(NULL,"@",&buff); */
 
  legx=strtok(loc,"@");
  legy=strtok(NULL,"@");
  legz=strtok(NULL,"@");

  C2F(dr)("xget","wdim",&verbose,xz,&narg_, PI0, PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  iof = (xz[0]+xz[1])/50;

  x = (integer) (ixbox[2]-(xz[0]+xz[1])/20) ;
  y = (integer) (0.5*iybox[3]+0.5*iybox[2]);
  /*** le z scaling ***/
  if ( axflag>=4)
    {
      double fx,fy,fz,lx,ly,lz;
      integer LPoint[2],FPoint[2],Ticsdir[2],xnax[2];
      xnax[0]=5;xnax[1]=2;
      FPoint[0]=ixbox[2];FPoint[1]=iybox[2];
      LPoint[0]=ixbox[3];LPoint[1]=iybox[3];
      Ticsdir[0]= -1;
      Ticsdir[1]=0;
      BBoxToval(&fx,&fy,&fz,xind[2],bbox);
      BBoxToval(&lx,&ly,&lz,xind[3],bbox);
      TDAxis(1L,fz,lz,xnax,FPoint,LPoint,Ticsdir);
    }
  if (legz != NULL)
    {
      C2F(dr)("xstringl",legz,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      C2F(dr)("xstring",legz,(x=x - rect[2],&x),&y,PI0,&flag
              ,PI0,PI0,&ang,PD0,PD0,PD0,0L,0L);
    }
  x=inint((ixbox[3]+ixbox[4])/2.0 -iof);
  y=inint((1/3.0)*iybox[3]+(2/3.0)*iybox[4]+(xz[0]+xz[1])/30);

  if ( xind[3]+xind[4] == 3)
    {
      if ( axflag>=4)
        {
          double fx,fy,fz,lx,ly,lz;
          integer LPoint[2],FPoint[2],Ticsdir[2],xnax[2];
          xnax[0]=5;xnax[1]=2;
          FPoint[0]=ixbox[3];FPoint[1]=iybox[3];
          LPoint[0]=ixbox[4];LPoint[1]=iybox[4];
          Ticsdir[0]=ixbox[4]-ixbox[5];
          Ticsdir[1]=iybox[4]-iybox[5];
          BBoxToval(&fx,&fy,&fz,xind[3],bbox);
          BBoxToval(&lx,&ly,&lz,xind[4],bbox);
          TDAxis(2L,fx,lx,xnax,FPoint,LPoint,Ticsdir);
        }
      if (legx != NULL)
        {

          C2F(dr)("xstringl",legx,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          C2F(dr)("xstring",legx,(x=x-rect[2],&x),&y,PI0,&flag
                  ,PI0,PI0,&ang,PD0,PD0,PD0,0L,0L);
        }
    }
  else 
    {
      if ( axflag>=4)
        {
          double fx,fy,fz,lx,ly,lz;
          integer LPoint[2],FPoint[2],Ticsdir[2],xnax[2];
          xnax[0]=5;xnax[1]=2;
          FPoint[0]=ixbox[3];FPoint[1]=iybox[3];
          LPoint[0]=ixbox[4];LPoint[1]=iybox[4];
          Ticsdir[0]=ixbox[4]-ixbox[5];
          Ticsdir[1]=iybox[4]-iybox[5];
          BBoxToval(&fx,&fy,&fz,xind[3],bbox);
          BBoxToval(&lx,&ly,&lz,xind[4],bbox);
          TDAxis(2L,fy,ly,xnax,FPoint,LPoint,Ticsdir);
        }
      if (legy != NULL)
        {

          C2F(dr)("xstringl",legy,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          C2F(dr)("xstring",legy,(x=x-rect[2],&x),&y,PI0,&flag
                  ,PI0,PI0,&ang,PD0,PD0,PD0,0L,0L);
        }
    }
  x=inint((ixbox[4]+ixbox[5])/2+(xz[0]+xz[1])/30);
  y=inint(((2/3.0)*iybox[4]+(1/3.0)*iybox[5])+iof);

  if ( xind[4]+xind[5] == 3)
  {
      if ( axflag>=4)
        {
          double fx,fy,fz,lx,ly,lz;
          integer LPoint[2],FPoint[2],Ticsdir[2],xnax[2];
          xnax[0]=5;xnax[1]=2;
          FPoint[0]=ixbox[4];FPoint[1]=iybox[4];
          LPoint[0]=ixbox[5];LPoint[1]=iybox[5];
          Ticsdir[0]=ixbox[4]-ixbox[3];
          Ticsdir[1]=iybox[4]-iybox[3];
          BBoxToval(&fx,&fy,&fz,xind[4],bbox);
          BBoxToval(&lx,&ly,&lz,xind[5],bbox);
          TDAxis(3L,fx,lx,xnax,FPoint,LPoint,Ticsdir); 
        }
      if (legx != NULL) 
        {
          C2F(dr)("xstring",legx,&x,&y,PI0,&flag,PI0,PI0,&ang,PD0,PD0,PD0,0L,0L);
        }
    }
  else 
    {
      if ( axflag>=4)
        {
          double fx,fy,fz,lx,ly,lz;
          integer LPoint[2],FPoint[2],Ticsdir[2],xnax[2];
          xnax[0]=5;xnax[1]=2;
          FPoint[0]=ixbox[4];FPoint[1]=iybox[4];
          LPoint[0]=ixbox[5];LPoint[1]=iybox[5];
          Ticsdir[0]=ixbox[4]-ixbox[3];
          Ticsdir[1]=iybox[4]-iybox[3];
          BBoxToval(&fx,&fy,&fz,xind[4],bbox);
          BBoxToval(&lx,&ly,&lz,xind[5],bbox);
          TDAxis(3L,fy,ly,xnax,FPoint,LPoint,Ticsdir); 
        }
      if (legy != NULL) 
        {
          C2F(dr)("xstring",legy,&x,&y,PI0,&flag,PI0,PI0,&ang,PD0,PD0,PD0,0L,0L);
        }
    }  
  FREE(loc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BBoxToval	(	double *	x,
		double *	y,
		double *	z,
		integer	ind,
		double	bbox[6]
	)

Returns the [x,y,z] values of a pointeger given its xbox or ybox indices

Definition at line 609 of file Plo3d.c.

Referenced by AxesStrings().

{
  switch ( ind)
    {
    case 0:     *x=bbox[0],*y=bbox[2],*z=bbox[4];break;
    case 1:     *x=bbox[0],*y=bbox[3],*z=bbox[4];break;
    case 2:     *x=bbox[1],*y=bbox[3],*z=bbox[4];break;
    case 3:     *x=bbox[1],*y=bbox[2],*z=bbox[4];break;
    case 4:     *x=bbox[0],*y=bbox[2],*z=bbox[5];break;
    case 5:     *x=bbox[0],*y=bbox[3],*z=bbox[5];break;
    case 6:     *x=bbox[1],*y=bbox[3],*z=bbox[5];break;
    case 7:     *x=bbox[1],*y=bbox[2],*z=bbox[5];break;
    }
}

Here is the caller graph for this function:

int C2F() box3d	(	double *	xbox,
		double *	ybox,
		double *	zbox
	)

Definition at line 43 of file Plo3d.c.

References wcscalelist::bbox1, C2F, Convex_Box(), Cscale, dr(), DrawAxis(), FREE, getStrMatElement(), L, m, MALLOC, sciSubWindow::mon_x_label, sciSubWindow::mon_y_label, sciSubWindow::mon_z_label, n, NULL, PD0, PI0, pSUBWIN_FEATURE, sciGetCurrentSubWin(), sciGetText(), sciprint(), XScale(), and YScale().

Referenced by dbox(), and zoom_box().

{  
 
  static integer InsideU[4],InsideD[4],flag[]={1,1,3};
  static integer ixbox[4],iybox[4], n=2, m=1;
  char * legends = NULL;
  sciPointObj * psubwin = NULL;
  sciSubWindow * ppsubwin =  NULL;
  
  char * legx = NULL;
  char * legy = NULL;
  char * legz = NULL;
  psubwin = sciGetCurrentSubWin();
  ppsubwin = pSUBWIN_FEATURE (psubwin);

  legx = getStrMatElement( sciGetText(ppsubwin->mon_x_label), 0, 0 ) ;
  legy = getStrMatElement( sciGetText(ppsubwin->mon_y_label), 0, 0 ) ;
  legz = getStrMatElement( sciGetText(ppsubwin->mon_z_label), 0, 0 ) ;

  if ((legends = MALLOC ((strlen(legx)+
    strlen(legy)+
    strlen(legz)+
    7)*sizeof (char))) == NULL)
    sciprint("box3d : No more Place to store legends (3D labels)\n");

  if(legx == NULL)
    strcpy(legends,"");
  else
    strcpy(legends,legx);

  strcat(legends,"@"); 

  if(legy == NULL)
    strcat(legends,"");
  else
    strcat(legends,legy);

  strcat(legends,"@"); 

  if(legz == NULL)
    strcat(legends,"");
  else
    strcat(legends,legz);

  Convex_Box(xbox,ybox,InsideU,InsideD,legends,flag,Cscale.bbox1);
  FREE(legends); legends = NULL;


  C2F (dr) ("xset","thickness",&m,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);    
  if (zbox[InsideU[0]] > zbox[InsideD[0]])
    DrawAxis(xbox,ybox,InsideU,2);
  else 
    DrawAxis(xbox,ybox,InsideD,2);    
  if (zbox[InsideU[0]] > zbox[InsideD[0]])
    DrawAxis(xbox,ybox,InsideD,2);
  else 
    DrawAxis(xbox,ybox,InsideU,2);

  ixbox[0]=XScale(xbox[0]);ixbox[1]=XScale(xbox[2]);
  ixbox[2]=XScale(xbox[1]);ixbox[3]=XScale(xbox[3]);
  iybox[0]=YScale(ybox[0]); iybox[1]=YScale(ybox[2]);
  iybox[2]=YScale(ybox[1]); iybox[3]=YScale(ybox[3]);
  C2F(dr)("xpolys","v",ixbox,iybox,&n,&m,&n,PI0,PD0,PD0,PD0,PD0,0L,0L);  
  C2F(dr)("xpolys","v",ixbox+2,iybox+2,&n,&m,&n,PI0,PD0,PD0,PD0,PD0,0L,0L); 



  return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Check3DPlots	(	char *	,
		integer *
	)

void Convex_Box	(	double *	xbox,
		double *	ybox,
		integer *	InsideU,
		integer *	InsideD,
		char *	legend,
		integer *	flag,
		double *	bbox
	)

Definition at line 275 of file Plo3d.c.

References AxesStrings(), C2F, DownNext(), dr(), i, ind, j, L, Maxi(), MaxiInd(), n, p, PD0, PI0, sciprint(), UpNext(), XScale(), and YScale().

{
  double xmaxi;
  integer ixbox[8],iybox[8];
  integer xind[8];
  integer ind2,ind3,ind;
  integer p,n,dvect[1],dash[6];
  integer verbose=0,narg_,pat;
  integer i,j;
  /*      4 ----- 5        */
  /*       /    /|         */
  /*     7----6  |         */
  /*      | 0 | / 1        */
  /*     3----- 2          */
  xmaxi=((double) Maxi(xbox,8L));
  ind= -1;
  for (i =0 ; i < 8 ; i++)
    {
      MaxiInd(xbox,8L,&ind,xmaxi);
      if ( ind > 3)
        {
          xind[0]=ind;
          break;
        }
    }
  if (ind < 0 || ind > 8) 
    {
      sciprint("xind out of bounds");
      xind[0]=0;
    }
  UpNext(xind[0],&ind2,&ind3);
  if (ybox[ind2] > ybox[ind3]) 
    {
      xind[1]=ind2;InsideU[0]=ind3;
    }
  else 
    {
      xind[1]=ind3;InsideU[0]=ind2;
    }
  UpNext(ind2,&ind2,&ind3); InsideU[1]=xind[0];
  InsideU[2]=ind2; InsideU[3]=InsideU[0]-4;
  xind[2]=ind2;
  /* le pointeger en bas qui correspond */
  xind[3]=ind2-4;
  DownNext(xind[3],&ind2,&ind3);
  if (ybox[ind2] < ybox[ind3]) 
    {
      xind[4]=ind2;InsideD[0]=ind3;
    }
  else  
    {
      xind[4]=ind3;InsideD[0]=ind2;
    }
  DownNext(ind2,&ind2,&ind3);
  InsideD[1]=xind[3];
  InsideD[2]=ind2;
  InsideD[3]=InsideD[0]+4;
  xind[5]=ind2;
  for (i=0; i < 6 ; i++)
    {
      ixbox[i]=XScale(xbox[xind[i]]);
      iybox[i]=YScale(ybox[xind[i]]);
    }
  ixbox[6]=ixbox[0];iybox[6]=iybox[0];
  p=7,n=1;
  dvect[0]=2;       
  C2F(dr)("xget","line style",&verbose,dash,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","line style",(j=1,&j),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F (dr) ("xset","thickness",(j=1,&j),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);     
  if (flag[2]>=3){
    C2F(dr)("xpolys","v",ixbox,iybox,dvect,&n,&p
            ,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }
  C2F(dr)("xget","pattern",&verbose,&pat,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","pattern",dvect,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
  if (flag[2]>=3)
    AxesStrings(flag[2],ixbox,iybox,xind,legend,bbox);
  C2F(dr)("xset","pattern",&pat,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

}

Here is the call graph for this function:

static void dbox

(

void

)

[static]

Definition at line 797 of file Plo3d.c.

References box3d(), C2F, dr(), L, PD0, and PI0.

Referenced by axis_3ddraw(), and I3dRotation().

{
  double xbox[8],ybox[8],zbox[8];
#ifdef _MSC_VER
  integer verbose_=0,pat,pat1=3,narg_,un=1;
  C2F(dr)("xget","pattern",&verbose_,&pat,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","pattern",&pat1,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F (dr) ("xset", "line style",&un,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
#endif
  SetEch3d1(xbox,ybox,zbox,Cscale.bbox1,&theta,&alpha,Cscale.metric3d);
  C2F(box3d)(xbox,ybox,zbox);
#ifdef _MSC_VER
  C2F(dr)("xset","pattern",&pat,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 261 of file Plo3d.c.

Referenced by Convex_Box().

{
  *ind2 = ind1+1;
  *ind3 = ind1-1;
  if (*ind2 == 4) *ind2 = 0;
  if (*ind3 == -1) *ind3 = 3;
}

Here is the caller graph for this function:

double C2F() dsort

(

)

Definition at line 292 of file x_test_loop.c.

{};

char GetDriver

(

void

)

Definition at line 323 of file Xcall.c.

{return(DriverName[0]);}

int I3dRotation

(

void

)

Definition at line 631 of file Plo3d.c.

References Abs, wcscalelist::alpha, sciSubWindow::axes, wcscalelist::bbox1, C2F, CheckClickedSubwin(), Cscale, sciSubWindow::cube_scaling, dbox(), dr(), dr1(), echelle2d(), AXES::flag, wcscalelist::frect, sciSubWindow::FRect, int, sciSubWindow::is3d, L, long, wcscalelist::metric3d, NULL, Obj_RedrawNewAngle(), PD0, pFIGURE_FEATURE, PI0, tagSons::pnext, tagSons::pointobj, pSUBWIN_FEATURE, ReleaseWinHdc(), SCI_SUBWIN, sciGetCurrentFigure(), sciGetCurrentSubWin(), sciGetEntityType(), sciGetLastSons(), sciGetSons(), SciMouseCapture(), SciMouseRelease(), sciRedrawFigure(), sciSetSelectedSubWin(), SetWinhdc(), wcscalelist::theta, TRUE, wininfo(), x, xr, y, and yr.

Referenced by scig_3drot().

{
  integer pixmode,alumode,verbose=0,narg_,ww;
  double xx,yy;
  double theta0,alpha0;
  static int one=1;

  static integer modes[]={1,0};/* for xgemouse only get mouse mouvement*/ 
  sciSons *psonstmp;
  sciPointObj *psubwin, *tmpsubwin;
  sciPointObj *pold = NULL;
  /*  sciPointObj *psurface; */
  integer xr, yr;


  integer ibutton,in,iwait=0,istr=0;
  integer verbose_=0,ww_;
  double x0,yy0,x,y,xl,yl ;

  C2F(dr1)("xget","window",&verbose,&ww,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

  C2F(dr)("xget","pixmap",&verbose,&pixmode,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xget","alufunction",&verbose,&alumode,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);


#ifdef _MSC_VER
  SetWinhdc();
  SciMouseCapture();  
#endif
  C2F(dr)("xclick","one",&ibutton,&xr,&yr,&iwait,&istr,PI0,PD0,PD0,PD0,PD0,0L,0L);
#ifdef _MSC_VER
  ReleaseWinHdc();
  SciMouseRelease();
#endif
  theta=Cscale.theta ;
  alpha=Cscale.alpha ;
  theta0=theta;
  alpha0=alpha;

  ibutton=-1;
  tmpsubwin = sciGetCurrentSubWin() ;   
  if ( pFIGURE_FEATURE(sciGetCurrentFigure())->rotstyle == 0)    
  {
    psubwin = CheckClickedSubwin(xr,yr);
    if( psubwin != NULL )
    {
      sciSubWindow * ppSubWin = pSUBWIN_FEATURE(psubwin) ;
      sciSetSelectedSubWin (psubwin);

      theta0 = ppSubWin-> theta; 
      alpha0 = ppSubWin-> alpha;
      ppSubWin->is3d = TRUE;
      Cscale.metric3d = (long)(ppSubWin->axes.flag[1]+1)/2; 

      /* Modif. HERE F.Leray 24.05.04 : we take advantage of update_specification_bounds and update_3dbounds previous call */
      /* brect variable should not exist any more.*/
      Cscale.bbox1[0] = ppSubWin->FRect[0]; 
      Cscale.bbox1[1] = ppSubWin->FRect[2];
      Cscale.bbox1[2] = ppSubWin->FRect[1];
      Cscale.bbox1[3] = ppSubWin->FRect[3];
      Cscale.bbox1[4] = ppSubWin->FRect[4];
      Cscale.bbox1[5] = ppSubWin->FRect[5];

      if( ppSubWin->cube_scaling )
      {
        Cscale.bbox1[0] =  0.; 
        Cscale.bbox1[1] =  1.;
        Cscale.bbox1[2] =  0.;
        Cscale.bbox1[3] =  1.;
        Cscale.bbox1[4] =  0.;
        Cscale.bbox1[5] =  1.;
      }
    }
    else
    {
      wininfo("No 3d object selected");
      return 0;
    }
  }
  else
  {                  
    psonstmp = sciGetLastSons (sciGetCurrentFigure());  
    while (psonstmp != (sciSons *) NULL)
    {  
      if(sciGetEntityType (psonstmp->pointobj) == SCI_SUBWIN) 
        break;   
      psonstmp = psonstmp->pnext;
    } 
    sciSetSelectedSubWin (psonstmp->pointobj);
  } 
  xx=1.0/Abs(Cscale.frect[0]-Cscale.frect[2]);
  yy=1.0/Abs(Cscale.frect[1]-Cscale.frect[3]);

  C2F(echelle2d)(&x0,&yy0,&xr,&yr,&one,&one,"i2f",3L);
  x0=(x0-Cscale.frect[0])*xx;
  yy0=(yy0-Cscale.frect[1])*yy;
  x=x0;y=yy0;

#ifdef _MSC_VER
  SetWinhdc();
  SciMouseCapture();
#endif

  if ( pixmode == 0 ) C2F(dr1)("xset","alufunction",(in=6,&in),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

  while ( ibutton == -1 ) 
  {
    /* dessin d'un rectangle */
    theta= ((int)(theta0 - 180.0*(x-x0)) % 360);
    alpha= ((int)(alpha0 + 180.0*(y-yy0)) % 360);
    wininfo("alpha=%.1f,theta=%.1f",alpha,theta); 
    if ( pixmode == 1) C2F(dr1)("xset","wwpc",PI0,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    dbox();
    if ( pixmode == 1) C2F(dr1)("xset","wshow",PI0,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    C2F(dr1)("xgetmouse","one",&ibutton,&iwait,PI0,PI0,modes,PI0,&xl, &yl,PD0,PD0,0L,0L);
    if (ibutton==-100) return 1;/* window has been closed */
    /* effacement du rectangle */
    dbox();
    xx=1.0/Abs(Cscale.frect[0]-Cscale.frect[2]);
    yy=1.0/Abs(Cscale.frect[1]-Cscale.frect[3]);
    x=(xl-Cscale.frect[0])*xx;
    y=(yl-Cscale.frect[1])*yy;
  }
  if ( pixmode == 0) C2F(dr1)("xset","alufunction",(in=3,&in),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr1)("xget","window",&verbose_,&ww_,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr1)("xset","alufunction",&alumode,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
#ifdef _MSC_VER
  ReleaseWinHdc();
  SciMouseRelease();
#endif

  if (pFIGURE_FEATURE((sciPointObj *)sciGetCurrentFigure())->rotstyle == 0){
    pold = sciGetCurrentSubWin();
    sciSetSelectedSubWin(psubwin);
    Obj_RedrawNewAngle(psubwin,theta,alpha);
    sciSetSelectedSubWin(pold);
  }
  else
  { 
    psonstmp = sciGetSons (sciGetCurrentFigure());  
    while (psonstmp != (sciSons *) NULL)        
    {  
      if(sciGetEntityType (psonstmp->pointobj) == SCI_SUBWIN){
        pold = sciGetCurrentSubWin();
        sciSetSelectedSubWin(psonstmp->pointobj);
        Obj_RedrawNewAngle(psonstmp->pointobj,theta,alpha);
        sciSetSelectedSubWin(pold);
      }
      psonstmp = psonstmp->pnext;
    } 
  }
  sciRedrawFigure(); 
  wininfo("alpha=%.1f,theta=%.1f",alpha,theta); 
  sciSetSelectedSubWin (tmpsubwin);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

void SetEch3d1	(	double *	xbox,
		double *	ybox,
		double *	zbox,
		double *	bbox,
		double *	teta,
		double *	alpha,
		integer	flag
	)

Definition at line 128 of file Plo3d.c.

References wcscalelist::alpha, Alpha, wcscalelist::bbox1, C2F, cost, Cscale, dr(), dx, dy, getscale2d(), hmax, ib, L, linint, wcscalelist::m, M_PI, Maxi(), wcscalelist::metric3d, Mini(), NULL, PD0, PI0, R, set_scale(), sint, wcscalelist::theta, TRX, TRY, and TRZ.

{
  double xmmin,ymmax,xmmax,ymmin,FRect[4],WRect[4],ARect[4];
  integer ib;
  static integer aaint[]={2,10,2,10};
  int verbose=0,wdim[2],narg_;
  char logf_[2];
  double R,xo,yo,zo,dx,dy,dz,hx,hy,hx1,hy1,Teta,Alpha;
  integer wmax,hmax;
  static double cost=0.5,sint=0.5,cosa=0.5,sina=0.5;
  Teta=*teta;
  Alpha=*alpha;
  /*  if (flag==0) {
      Alpha=Cscale.alpha;
      Teta=Cscale.theta;
      }
      else {
      Cscale.alpha = Alpha;
      Cscale.theta = Teta;
      }*/
  Cscale.alpha = Alpha;
  Cscale.theta = Teta;
  cost=cos((Teta)*M_PI/180.0);
  sint=sin((Teta)*M_PI/180.0);
  cosa=cos((Alpha)*M_PI/180.0);
  sina=sin((Alpha)*M_PI/180.0);
  Cscale.m[0][0]= -sint    ;    Cscale.m[0][1]= cost      ;    Cscale.m[0][2]= 0;
  Cscale.m[1][0]= -cost*cosa;   Cscale.m[1][1]= -sint*cosa;    Cscale.m[1][2]= sina;
  Cscale.m[2][0]=  cost*sina;   Cscale.m[2][1]= sint*sina;     Cscale.m[2][2]= cosa;
  /* Coordonn\'ees apr\`es transformation g\'eometrique de la
   * boite qui entoure le plot3d                            
   * le plan de projection est defini par x et y            
   */
  for (ib=0;ib<6 ;ib++) 
    { 
      if (flag==0) 
        bbox[ib]=Cscale.bbox1[ib];
      else 
        Cscale.bbox1[ib]=bbox[ib];
    }
  xbox[0]=TRX(bbox[0],bbox[2],bbox[4]);
  ybox[0]=TRY(bbox[0],bbox[2],bbox[4]);
  zbox[0]=TRZ(bbox[0],bbox[2],bbox[4]);
  xbox[1]=TRX(bbox[0],bbox[3],bbox[4]);
  ybox[1]=TRY(bbox[0],bbox[3],bbox[4]);
  zbox[1]=TRZ(bbox[0],bbox[3],bbox[4]);
  xbox[2]=TRX(bbox[1],bbox[3],bbox[4]);
  ybox[2]=TRY(bbox[1],bbox[3],bbox[4]);
  zbox[2]=TRZ(bbox[1],bbox[3],bbox[4]);
  xbox[3]=TRX(bbox[1],bbox[2],bbox[4]);
  ybox[3]=TRY(bbox[1],bbox[2],bbox[4]);
  zbox[3]=TRZ(bbox[1],bbox[2],bbox[4]);
  xbox[4]=TRX(bbox[0],bbox[2],bbox[5]);
  ybox[4]=TRY(bbox[0],bbox[2],bbox[5]);
  zbox[4]=TRZ(bbox[0],bbox[2],bbox[5]);
  xbox[5]=TRX(bbox[0],bbox[3],bbox[5]);
  ybox[5]=TRY(bbox[0],bbox[3],bbox[5]);
  zbox[5]=TRZ(bbox[0],bbox[3],bbox[5]);
  xbox[6]=TRX(bbox[1],bbox[3],bbox[5]);
  ybox[6]=TRY(bbox[1],bbox[3],bbox[5]);
  zbox[6]=TRZ(bbox[1],bbox[3],bbox[5]);
  xbox[7]=TRX(bbox[1],bbox[2],bbox[5]);
  ybox[7]=TRY(bbox[1],bbox[2],bbox[5]);
  zbox[7]=TRZ(bbox[1],bbox[2],bbox[5]);
  if ( flag == 1 || flag == 3 )
    {
      xmmin=  (double) Mini(xbox,8L);xmmax= (double) Maxi(xbox,8L);
      ymmax=  (double) - Mini(ybox,8L);
      ymmin=  (double) - Maxi(ybox,8L);
    }
  /* code added by es: isoview scaling */
  if ( flag == 2 || flag == 3 )
    {
      /* get current window size */
      C2F(dr)("xget","wdim",&verbose,wdim,&narg_, PI0,PI0,PI0,
              PD0,PD0,PD0,PD0,0L,0L);
      getscale2d(WRect,FRect,logf_,ARect);
      wmax=linint((double)wdim[0] * WRect[2]);
      hmax=linint((double)wdim[1] * WRect[3]); 
    }
  if ( flag == 2 )
    {
      /* radius and center of the sphere circumscribing the box */
      dx=bbox[1]-bbox[0]; dy=bbox[3]-bbox[2]; dz=bbox[5]-bbox[4];
      R= (double) sqrt(dx*dx + dy*dy + dz*dz)/2;
      xo= (double) (xbox[0]+xbox[6])/2 ;
      yo= (double) (ybox[0]+ybox[6])/2 ;
      zo= (double) (zbox[0]+zbox[6])/2 ;
      xmmin=  (double) xo - R ;
      xmmax=  (double) xo + R ;
      ymmax=  (double) -yo + R ;
      ymmin=  (double) -yo - R ;
    }
  if (flag==2 || flag==3)
    {
      /* adjust limits (code adapted from Plo2d.c & Stephane's patch) */
      hx=xmmax-xmmin;
      hy=ymmax-ymmin;
      if ( hx/(double)wmax  < hy/(double)hmax ) 
        {
          hx1=wmax*hy/hmax;
          xmmin=xmmin-(hx1-hx)/2.0;
          xmmax=xmmax+(hx1-hx)/2.0;
        }
      else 
        {
          hy1=hmax*hx/wmax;
          ymmin=ymmin-(hy1-hy)/2.0;
          ymmax=ymmax+(hy1-hy)/2.0;
        }
    }
  if (flag !=0 )
    {
      FRect[0]=xmmin;FRect[1]= -ymmax;FRect[2]=xmmax;FRect[3]= -ymmin;
      set_scale("tftttf",NULL,FRect,aaint,"nn",NULL);
      Cscale.metric3d=flag; /* the metric mode is stored into the
                             * List of Scales */
    }
  /* end of code added by es */
}

Here is the call graph for this function:

void TDAxis	(	integer	flag,
		double	FPval,
		double	LPval,
		integer *	nax,
		integer *	FPoint,
		integer *	LPoint,
		integer *	Ticsdir
	)

Definition at line 398 of file Plo3d.c.

References Abs, C2F, ChoixFormatE(), dr(), dx, dy, foo(), i, inint, L, lp, Max, Min, PD0, PI0, and TDdrawaxis().

Referenced by AxesStrings().

{
  char fornum[100];
  integer i,barlength;
  double xp, dx,dy,ticsx,ticsy,size;
  integer verbose=0,narg_,xz[2];
  C2F(dr)("xget","wdim",&verbose,xz,&narg_, PI0, PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  size = xz[0]>=xz[1] ? xz[1]/50.0 : xz[0]/50.0; 
  C2F(TDdrawaxis)(size,FPval,LPval,nax,FPoint,LPoint,Ticsdir) ;
  ChoixFormatE(fornum,Min(FPval,LPval),Max(LPval,FPval),
    Abs((LPval-FPval))/nax[1]);
  xp= FPval;
  barlength=inint(1.2*size);
  dx= ((double) LPoint[0]-FPoint[0])/((double)nax[1]);
  dy= ((double) LPoint[1]-FPoint[1])/((double)nax[1]);
  if ( Ticsdir[0] == 0 && Ticsdir[1] == 0) 
  {
    ticsx= ticsy = 0;
  }
  else 
  {
    ticsx= barlength*( Ticsdir[0])/
      sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1]);
    ticsy= barlength*( Ticsdir[1])/
      sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1]);
  }
  for (i=0; i <= nax[1];i++)
  { double angle=0.0;
  integer flag1=0;
  integer xx=0,yy=0, posi[2],rect[4];
  char foo[100];/*** JPC : must be cleared properly **/
  double lp;
  lp = xp + i*(LPval-FPval)/((double)nax[1]);
  sprintf(foo,fornum,lp);   
  C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  posi[0]=inint(FPoint[0]+ i*dx + 2*ticsx );
  posi[1]=inint(FPoint[1]+ i*dy + 2*ticsy +rect[3]/2 );
  switch ( flag)
  {
  case 1: posi[0] -= rect[2];
    if ( i== nax[1]) posi[1] -= rect[3]/2;
    break;
  case 2: posi[0] -= rect[2];break;
  }
  C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag1,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);
  } 
}

Here is the call graph for this function:

Here is the caller graph for this function:

void C2F() TDdrawaxis	(	double	size,
		double	FPval,
		double	LPval,
		integer *	nax,
		integer *	FPoint,
		integer *	LPoint,
		integer *	Ticsdir
	)

Definition at line 369 of file Plo3d.c.

References C2F, dr(), dx, dy, i, iflag, L, linint, PD0, PI0, style, x, and y.

Referenced by TDAxis().

{ 
  integer i;
  double dx,dy,ticsx,ticsy;
  dx= ((double) LPoint[0]-FPoint[0])/((double)nax[1]*nax[0]);
  dy= ((double) LPoint[1]-FPoint[1])/((double)nax[1]*nax[0]);
  if ( Ticsdir[0] == 0 && Ticsdir[1] == 0) 
  {
    ticsx= ticsy = 0;
  }
  else 
  {
    ticsx= ( Ticsdir[0])/
      sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1]);
    ticsy= ( Ticsdir[1])/
      sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1]);
  }
  for (i=0; i <= nax[1]*nax[0];i++)
  {       
    integer siz=2,x[2],y[2],iflag=0,style=0;
    x[0] =linint(FPoint[0]+ ((double)i)*dx );
    y[0] =linint(FPoint[1]+ ((double)i)*dy );
    x[1] =linint(x[0]+ ticsx*size);
    y[1] =linint(y[0]+ ticsy*size);
    C2F(dr)("xsegs","v",x,y,&siz,&style,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int triangleSort	(	integer *	polyxin,
		integer *	polyyin,
		integer *	fillin,
		integer *	polyx,
		integer *	polyy,
		integer *	fill
	)

Definition at line 817 of file Plo3d.c.

References Abs.

Referenced by scilab_shade().

{ 
  integer tmp,k;
  for (k=0;k<3;k++) {polyx[k]=polyxin[k]; polyy[k]=polyyin[k]; fill[k]=Abs(fillin[k]);}
      
  if (fill[0]<fill[1]) {  
    tmp=fill[0]; fill[0]=fill[1]; fill[1]=tmp;
    tmp=polyx[0]; polyx[0]=polyx[1]; polyx[1]=tmp;
    tmp=polyy[0]; polyy[0]=polyy[1]; polyy[1]=tmp;
  }
  if (fill[0]<fill[2]) {  
    tmp=fill[0]; fill[0]=fill[2]; fill[2]=tmp;
    tmp=polyx[0]; polyx[0]=polyx[2]; polyx[2]=tmp;
    tmp=polyy[0]; polyy[0]=polyy[2]; polyy[2]=tmp;
  }
  if (fill[1]<fill[2]) {  
    tmp=fill[1]; fill[1]=fill[2]; fill[2]=tmp;
    tmp=polyx[1]; polyx[1]=polyx[2]; polyx[2]=tmp;
    tmp=polyy[1]; polyy[1]=polyy[2]; polyy[2]=tmp;
  }
  return 0;
}

Here is the caller graph for this function:

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

Definition at line 253 of file Plo3d.c.

Referenced by Convex_Box().

{
  *ind2 = ind1+1;
  *ind3 = ind1-1;
  if (*ind2 == 8) *ind2 = 4;
  if (*ind3 == 3) *ind3 = 7;
}

Here is the caller graph for this function:

---

Variable Documentation

double alpha [static]

Definition at line 629 of file Plo3d.c.

double theta [static]

Changement interactif de 3d

Definition at line 629 of file Plo3d.c.

Referenced by sci_param3d(), sci_param3d1(), sci_plot3d(), and set_rotation_angles_property().

---