Plo3d.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int C2F()	box3d (double *xbox, double *ybox, double *zbox)
void	DrawAxis (double *xbox, double *ybox, integer *Indices, integer style)
void	Convex_Box (double *xbox, double *ybox, integer *InsideU, integer *InsideD, char *legend, integer *flag, double *bbox)
void	AxesStrings (integer axflag, integer *ixbox, integer *iybox, integer *xind, char *legend, double *bbox)
int	triangleSort (integer *polyxin, integer *polyyin, integer *fillin, integer *polyx, integer *polyy, integer *fill)
int	scilab_shade (integer *polyx, integer *polyy, integer *fill, integer polysize, integer flag)
void	BBoxToval (double *x, double *y, double *z, integer ind, double bbox[6])

---

Function Documentation

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:

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:

void DrawAxis	(	double *	xbox,
		double *	ybox,
		integer *	Indices,
		integer	style
	)

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

Definition at line 849 of file Plo3d.c.

References Abs, C2F, dr(), dx, dy, FREE, i, ie, is, L, linint, MALLOC, n, NULL, PD0, PI0, s, sciprint(), triangleSort(), x, and y.

Referenced by DrawMerge3d(), drawPolylineEntity(), fac3dn(), and fillpolylines_1().

{
  integer px[5],py[5],fil[4],is[3],ie[3],n[3];
  integer npoly=1,k,col,cols,psize,i,s,e;
  integer polyxs[4],polyys[4],fills[4],*x[3],*y[3];
  double dx,dy;

  if (polysize == 3) { /* The triangle case */
 
    triangleSort(polyx,polyy,fill,polyxs,polyys,fills);
  
    is[0]=0; ie[0]=1;
    is[1]=1; ie[1]=2;
    is[2]=0; ie[2]=2;
     
    /* Computation of coordinates of elementary polygons for each side */
     
    for(i=0;i<3;i++) {

      s=is[i];
      e=ie[i];
      n[i]=fills[s]-fills[e];

      if (n[i]) {
        
        x[i]=(integer *)MALLOC((n[i]+2)*sizeof(integer));
        y[i]=(integer *)MALLOC((n[i]+2)*sizeof(integer)); 
        if (x[i]==NULL || y[i]==NULL) {
          sciprint("shade : MALLOC No more Place\n");
          return 0;
        }
                
        dx=((double)(polyxs[e]-polyxs[s]))/(double)n[i];
        dy=((double)(polyys[e]-polyys[s]))/(double)n[i];

        x[i][0]=polyxs[s];
        y[i][0]=polyys[s];
           
        for(k=0;k<n[i];k++) {
          x[i][k+1]=linint((double)polyxs[s] + (0.5+k)*dx);
          y[i][k+1]=linint((double)polyys[s] + (0.5+k)*dy);
        }
           
        x[i][n[i]+1]=polyxs[e];
        y[i][n[i]+1]=polyys[e];
      }
    }
     
    /* Fill the whole triangle with color fill[1] if all colors are equal */
         
    if (!n[0] && !n[1]) {

      psize=3;
      col=fills[0];
      C2F(dr)("xliness","str",polyxs,polyys,(cols=-Abs(col),&cols),&npoly,&psize ,PI0,PD0,PD0,PD0,PD0,0L,0L);
      /*          return(0);*/
    }
     
    if (n[0]) {
      psize=4;
      col=fills[0];  
      for(i=0;i<=n[0];i++) {
        px[0]=x[2][i]; px[1]=x[0][i]; px[2]=x[0][i+1]; px[3]=x[2][i+1];
        py[0]=y[2][i]; py[1]=y[0][i]; py[2]=y[0][i+1]; py[3]=y[2][i+1];
        C2F(dr)("xliness","str",px,py,(cols=-Abs(col),&cols),&npoly,&psize ,PI0,PD0,PD0,PD0,PD0,0L,0L);
        col--;
      }
      FREE(x[0]);
      FREE(y[0]);
    }
     
    if (n[1]) {
      psize=4;
      col=fills[1];
      for(i=0;i<=n[1];i++) {
        px[0]=x[2][n[0]+i]; px[1]=x[1][i]; px[2]=x[1][i+1]; px[3]=x[2][n[0]+i+1];
        py[0]=y[2][n[0]+i]; py[1]=y[1][i]; py[2]=y[1][i+1]; py[3]=y[2][n[0]+i+1];
        C2F(dr)("xliness","str",px,py,(cols=-Abs(col),&cols),&npoly,&psize ,PI0,PD0,PD0,PD0,PD0,0L,0L);
        col--;
      }
      FREE(x[1]);
      FREE(y[1]);  
    }

    if (n[2]) {
      FREE(x[2]);
      FREE(y[2]);
    }

  }
   
  else { /* The 4 vertices case  */
     
    px[0]=polyx[0]; px[1]=polyx[1]; px[2]=polyx[2];
    py[0]=polyy[0]; py[1]=polyy[1]; py[2]=polyy[2];
    fil[0]=fill[0]; fil[1]=fill[1]; fil[2]=fill[2];
    scilab_shade(px,py,fil,3,-1);

    px[0]=polyx[0]; px[1]=polyx[2]; px[2]=polyx[3];
    py[0]=polyy[0]; py[1]=polyy[2]; py[2]=polyy[3];
    fil[0]=fill[0]; fil[1]=fill[2]; fil[2]=fill[3];
    scilab_shade(px,py,fil,3,-1);
  }
   
  /* If flag>0 then the contour is drawn */
   
  if (flag > 0) { 
    fil[0]=0;
    polysize+=1;
    C2F (dr) ("xliness", "str", polyx, polyy, fil, &npoly,
              &polysize, 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 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:

---