clipping.c File Reference

#include "clipping.h"
#include "math_graphics.h"
#include "GetProperty.h"
#include "Xcall1.h"
#include "SetProperty.h"

Include dependency graph for clipping.c:

Go to the source code of this file.

Functions
SClipRegion	getClipRegion (struct BCG *scilabXGC)
int	sciClipPoint (integer x, integer y, SClipRegion *clipping)
void	sciClipLine (integer x1, integer yy1, integer x2, integer y2, integer *x1n, integer *yy1n, integer *x2n, integer *y2n, integer *flag, SClipRegion *clipping)
void	sciDrawInsideSegments (integer iib, integer iif, integer *vx, integer *vy, SClipRegion *clipping)
void	sciDrawOutsideSegment (integer ind, integer *vx, integer *vy, SClipRegion *clipping)
integer	sciFirstInClipRegion (integer n, integer ideb, integer *vx, integer *vy, SClipRegion *clipping)
integer	sciFirstOutClipRegion (integer n, integer ideb, integer *vx, integer *vy, SClipRegion *clipping)
void C2F()	clipPolyLine (integer n, integer *vx, integer *vy, integer closed, SClipRegion *clipping)
void	getPixelClipping (sciPointObj *pObj, SClipRegion *clipping)
void	sciClip (sciPointObj *pobj)
void	sciUnClip (sciPointObj *pobj)
void	frame_clip_on (void)
void	frame_clip_off (void)

---

Function Documentation

void C2F() clipPolyLine	(	integer	n,
		integer *	vx,
		integer *	vy,
		integer	closed,
		SClipRegion *	clipping
	)

Definition at line 306 of file clipping.c.

References C2F, close(), dr(), j, L, n, PD0, PI0, sciClipLine(), sciDrawInsideSegments(), sciDrawOutsideSegment(), sciFirstInClipRegion(), and sciFirstOutClipRegion().

{ 
  integer iib,iif,ideb=0,vxl[2],vyl[2];
  
  while (1) 
  { 
    integer j;
    iib = sciFirstInClipRegion( n, ideb, vx, vy, clipping ) ;
    if (iib == -1)
    { 
      for (j=ideb+1; j < n; j++)
      {
        sciDrawOutsideSegment( j, vx, vy, clipping ) ;
      }
      break;
    }
    else
    { 
      if ( iib - ideb > 1) 
      {
        /* un partie du polygine est totalement out de ideb a iib -1 */
        /* mais peu couper la zone */
        for ( j = ideb + 1 ; j < iib; j++ )
        {
          sciDrawOutsideSegment(j,vx,vy, clipping ) ;
        }
      }
    }
    iif = sciFirstOutClipRegion( n, iib, vx, vy, clipping ) ;
    if ( iif == -1 ) 
    {
      /* special case the polyligne is totaly inside */
      if (iib == 0) 
      {
        C2F (dr) ("xuclines", "xv", &n, vx, vy, &closed, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L) ;
        return ;
      }
      else
      { 
        sciDrawInsideSegments( iib, n-1, vx, vy, clipping ) ;
      }
      break;
    }

    sciDrawInsideSegments( iib, iif, vx, vy, clipping ) ;
    ideb=iif;
  }
  if ( closed )
  {
    /* The polyligne is closed we consider the closing segment */
    integer x1n,y1n,x2n,y2n,flag1=0;
    vxl[0]=vx[n-1];vxl[1]=vx[0];vyl[0]=vy[n-1];vyl[1]=vy[0];
    sciClipLine( vxl[0], vyl[0],
                 vxl[1], vyl[1],
                 &x1n  , &y1n  ,
                 &x2n  , &y2n  ,
                 &flag1, clipping ) ;
    
    if ( flag1==0 ) { return ; }

    if ( flag1==1 || flag1==3 )
    {
      vxl[0] = x1n ;
      vyl[0] = y1n ;
    }
    if ( flag1==2 || flag1==3 )
    {
      vxl[1] = x2n ;
      vyl[1] = y2n ;
    }
    
    {
      int nbPoints = 2 ;
      int close = 0 ;
      C2F (dr) ("xuclines", "xv", &nbPoints, vxl, vyl, &close, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
    }
    
    
  }
}

Here is the call graph for this function:

void frame_clip_off

(

void

)

disable clipping (to be called after frame_clip_on

Definition at line 486 of file clipping.c.

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

Referenced by drawGrayplotEntity(), newfec(), and plot2dn().

{
  C2F(dr)("xset","clipoff",PI0,PI0,PI0,PI0, PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void frame_clip_on

(

void

)

use current scale to set the clipping rectangle

Definition at line 480 of file clipping.c.

References C2F, Cscale, dr(), L, PD0, PI0, and wcscalelist::WIRect1.

Referenced by drawGrayplotEntity(), newfec(), plot2dn(), sciClip(), and xset_1().

{
  C2F(dr)("xset","clipping",&Cscale.WIRect1[0],&Cscale.WIRect1[1],&Cscale.WIRect1[2],
    &Cscale.WIRect1[3],PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SClipRegion getClipRegion

(

struct BCG *

scilabXGC

)

To retrieve the current clipping region

Definition at line 15 of file clipping.c.

References SClipRegion::bottomY, BCG::CurClipRegion, SClipRegion::leftX, SClipRegion::rightX, and SClipRegion::topY.

{
  SClipRegion clipping ;

  clipping.leftX   = scilabXGC->CurClipRegion[0];
  clipping.rightX  = scilabXGC->CurClipRegion[0] + scilabXGC->CurClipRegion[2];
  clipping.bottomY = scilabXGC->CurClipRegion[1] ;
  clipping.topY    = scilabXGC->CurClipRegion[1] + scilabXGC->CurClipRegion[3] ;

  return clipping ;
}

void getPixelClipping	(	sciPointObj *	pObj,
		SClipRegion *	clipping
	)

Definition at line 396 of file clipping.c.

References SClipRegion::bottomY, SClipRegion::leftX, SClipRegion::rightX, sciGetClipping(), SClipRegion::topY, XDouble2Pixel, and YDouble2Pixel.

{
  double * clipRegion = sciGetClipping( pObj ) ;
  clipping->leftX = XDouble2Pixel( clipRegion[0] ) ;
  clipping->rightX = XDouble2Pixel( clipRegion[0] + clipRegion[2] ) ;
  clipping->bottomY = YDouble2Pixel( clipRegion[1] ) ;
  clipping->topY = YDouble2Pixel( clipRegion[1] - clipRegion[3] ) ;
  
}

Here is the call graph for this function:

void sciClip

(

sciPointObj *

pobj

)

Set the clipping rectangl. Note that clipping is not supported at all in 3D mode for now : This assertion includes axes (in 3D), surfaces and parametric curves objects.

Author:

Djalel ABDEMOUCHE 29/11/2002

Definition at line 406 of file clipping.c.

References sciSubWindow::axes, C2F, dr(), frame_clip_on(), sciSubWindow::FRect, h, HDouble2Pixel, sciSubWindow::is3d, L, NULL, PD0, PI0, pSUBWIN_FEATURE, AXES::reverse, sciGetClipping(), sciGetIsClipping(), sciGetIsClipRegionValuated(), sciGetParentSubwin(), sciSetClipping(), TRUE, value, w, WDouble2Pixel, x, XDouble2Pixel, y, and YDouble2Pixel.

Referenced by drawArcEntity(), drawAxesEntity(), drawPolylineEntity(), drawRectangleEntity(), drawSegsEntity(), drawSubWinEntity(), and drawTextEntity().

{
  int x,y,w,h; 
  int value;
  double *clip_region = NULL;

  sciPointObj * psubwin = sciGetParentSubwin(pobj);
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);

  value = sciGetIsClipping(pobj);     /* clipping state */

  if(value == -1) return;
  if(ppsubwin->is3d == TRUE) return; /* no clipping in 3d */

  clip_region = sciGetClipping(pobj); /* clipping region */


  if(sciGetIsClipRegionValuated(pobj) == 0)
    value = 0; /* we use the 'clipgrf' value instead */

  if (value == 0){
    double clip[4];
    double tmpx, tmpy, tmpw, tmph;

    tmpw = fabs(ppsubwin->FRect[2] - ppsubwin->FRect[0]);
    tmph = fabs(ppsubwin->FRect[3] - ppsubwin->FRect[1]);

    tmpx = ppsubwin->FRect[0]; /* xmin */
    tmpy = ppsubwin->FRect[3]; /* ymax */

    clip[0] = tmpx;
    clip[1] = tmpy;
    clip[2] = tmpw;
    clip[3] = tmph;

    sciSetClipping(pobj,clip);

    frame_clip_on();
  }
  else if (value > 0)
  { 
    double tmpw, tmph;
    double tmpx, tmpy;

    tmpw = clip_region[2];
    tmph = clip_region[3];

    tmpx = clip_region[0];
    tmpy = clip_region[1];

    if(ppsubwin->axes.reverse[0] == TRUE)
      tmpx = tmpx + tmpw;

    if(ppsubwin->axes.reverse[1] == TRUE)
      tmpy = tmpy - tmph;

    x = XDouble2Pixel( tmpx);
    y = YDouble2Pixel( tmpy);
    w = WDouble2Pixel( tmpx, tmpw);
    h = HDouble2Pixel( tmpy, tmph);
    C2F(dr)("xset","clipping",&x, &y, &w, &h,PI0,PI0,PD0,PD0,PD0,PD0,4L,8L);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sciClipLine	(	integer	x1,
		integer	yy1,
		integer	x2,
		integer	y2,
		integer *	x1n,
		integer *	yy1n,
		integer *	x2n,
		integer *	y2n,
		integer *	flag,
		SClipRegion *	clipping
	)

Definition at line 47 of file clipping.c.

References SClipRegion::bottomY, count, dx, dy, SClipRegion::leftX, SClipRegion::rightX, sciClipPoint(), SClipRegion::topY, x, and y.

Referenced by clipPolyLine(), sciDrawInsideSegments(), and sciDrawOutsideSegment().

{
  integer  x_intr[2], y_intr[2]; /* used to store intersection points 
                                  * at most two points 
                                  */
  integer x, y, dx, dy, count, pos1, pos2; 

  *x1n=x1  ;
  *yy1n=yy1;
  *x2n=x2  ;
  *y2n=y2  ;
  *flag=4  ;

  pos1 = sciClipPoint(x1, yy1, clipping ) ;
  pos2 = sciClipPoint(x2, y2 , clipping ) ;
  if (pos1 || pos2) {
    if (pos1 & pos2) { *flag=0;return;}   
    /* segment is totally out. */

    /* Here part of the segment MAy be inside. test the intersection
     * of this segment with the 4 boundaries for hopefully 2 intersections
     * in. If non found segment is totaly out.
     */
    count = 0;
    dx = x2 - x1;
    dy = y2 - yy1;

    /* Find intersections with the x parallel bbox lines: */
    if (dy != 0) {
      x = (integer) ((int) (clipping->bottomY - y2)  * ((double) dx / (double) dy) + x2);
      /* Test for clipping.bottomY boundary. */
      if (x >= clipping->leftX && x <= clipping->rightX ) {
        x_intr[count] = x;
        y_intr[count++] = clipping->bottomY ;
      }
      x = (integer)((clipping->topY - y2) * ((double) dx / (double) dy) + x2); 
      /* Test for clipping.topY boundary. */
      if ( x >= clipping->leftX && x <= clipping->rightX ) {
        x_intr[count] = x;
        y_intr[count++] = clipping->topY;
      }
    }
    if ( count < 2 )
      {
        /* Find intersections with the y parallel bbox lines: */
        if (dx != 0) {
          y = (integer)((clipping->leftX - x2) * ((double) dy / (double) dx) + y2);   
          /* Test for clipping.leftX boundary. */
          if (y >= clipping->bottomY && y <= clipping->topY) {
            x_intr[count] = clipping->leftX;
            y_intr[count++] = y;
          }
          if ( count < 2 ) 
            {
              y = (integer)((clipping->rightX - x2) * ((double) dy / (double) dx) + y2);  
              /* Test for clipping.rightX boundary. */
              if (y >= clipping->bottomY && y <= clipping->topY) {
                x_intr[count] = clipping->rightX;
                y_intr[count++] = y;
              }
            }
        }
      }

    if (count == 2) {
      if (pos1 && pos2) {          /* Both were out - update both */
        *x1n = x_intr[0];
        *yy1n = y_intr[0];
        *x2n = x_intr[1];
        *y2n = y_intr[1];
        *flag=3;return;
      }
      else if (pos1) {       /* Only x1/yy1 was out - update only it */
        if (dx * (x2 - x_intr[0]) + dy * (y2 - y_intr[0]) >= 0) {
          *x1n = x_intr[0];
          *yy1n = y_intr[0];
          *flag=1;return;
        }
        else {
          *x1n = x_intr[1];
          *yy1n = y_intr[1];
          *flag=1;return;
        }
      }
      else {             /* Only x2/y2 was out - update only it */
        if (dx * (x_intr[0] - x1) + dy * (y_intr[0] - yy1) >= 0) {
          *x2n = x_intr[0];
          *y2n = y_intr[0];
          *flag=2;return;
        }
        else {
          *x2n = x_intr[1];
          *y2n = y_intr[1];
          *flag=2;return;
        }
      }
    }
    else 
      {
        /* count != 0 */
        *flag=0;
        return;
      }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sciClipPoint	(	integer	x,
		integer	y,
		SClipRegion *	clipping
	)

Definition at line 34 of file clipping.c.

References SClipRegion::rightX, and SClipRegion::topY.

Referenced by sciClipLine().

{
  integer ret_val = 0;

  if (x < clipping->leftX) ret_val |= (char)0x01;
  else if (x > clipping->rightX) ret_val |= (char)0x02;
  if (y < clipping->bottomY) ret_val |= (char)0x04;
  else if (y > clipping->topY ) ret_val |= (char)0x08;
  return ret_val;
}

Here is the caller graph for this function:

void sciDrawInsideSegments	(	integer	iib,
		integer	iif,
		integer *	vx,
		integer *	vy,
		SClipRegion *	clipping
	)

Definition at line 164 of file clipping.c.

References C2F, close(), dr(), L, Max, PD0, PI0, and sciClipLine().

Referenced by clipPolyLine().

{
  integer x1n,y1n,x11n,y11n,x2n,y2n,flag2=0,flag1=0;
  integer npts;
  integer * vxNew ; /* the drawn vector */
  integer * vyNew ;
  int close = 0 ;
  /* backup of the first and last bounds of the bounds of the drawn vector
     which may be changed */
  int prevBounds[4] ;

  npts = ( iib > 0) ? iif-iib+2  : iif-iib+1;  
  
  if ( iib > 0) 
  {
    sciClipLine( vx[iib-1], vy[iib-1],
                 vx[iib]  , vy[iib]  ,
                 &x1n     , &y1n     ,
                 &x2n     , &y2n     ,
                 &flag1   , clipping ) ;
  }
  sciClipLine( vx[iif-1], vy[iif-1],
               vx[iif]  , vy[iif]  ,
               &x11n    , &y11n    ,
               &x2n     , &y2n     ,
               &flag2   , clipping    ) ;
  vxNew = &vx[Max(0,iib-1)] ;
  vyNew = &vy[Max(0,iib-1)] ;

  prevBounds[0] = vxNew[0]      ;
  prevBounds[1] = vyNew[0]      ;
  prevBounds[2] = vxNew[npts-1] ;
  prevBounds[3] = vyNew[npts-1] ;

  if ( iib > 0 && (flag1==1||flag1==3) )
  {
    vxNew[0] = x1n ;
    vyNew[0] = y1n ;
  }
  if ( flag2==2 || flag2==3 )
  {
    vxNew[npts-1] = x2n ;
    vyNew[npts-1] = y2n ;
  }

  
  C2F (dr) ("xuclines", "xv", &npts, vxNew, vyNew, &close, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);

  /* restore the possibly changed bounds */
  vxNew[0]      = prevBounds[0] ;
  vyNew[0]      = prevBounds[1] ;
  vxNew[npts-1] = prevBounds[2] ;
  vyNew[npts-1] = prevBounds[3] ;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void sciDrawOutsideSegment	(	integer	ind,
		integer *	vx,
		integer *	vy,
		SClipRegion *	clipping
	)

Definition at line 227 of file clipping.c.

References C2F, close(), dr(), L, PD0, PI0, and sciClipLine().

Referenced by clipPolyLine().

{
  integer segX[2],segY[2],flag;
  sciClipLine( vx[ind-1], vy[ind-1]  ,
               vx[ind]  , vy[ind]    ,
               &segX[0]   , &segY[0],
               &segX[1]   , &segY[1]  ,
               &flag      , clipping  ) ;
  if ( flag == 3 )
  {
    int nbPoints = 2 ;
    int close    = 0 ;
    C2F (dr) ("xuclines", "xv", &nbPoints, segX, segY, &close, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

integer sciFirstInClipRegion	(	integer	n,
		integer	ideb,
		integer *	vx,
		integer *	vy,
		SClipRegion *	clipping
	)

Definition at line 255 of file clipping.c.

References SClipRegion::bottomY, i, SClipRegion::leftX, SClipRegion::rightX, and SClipRegion::topY.

Referenced by clipPolyLine().

{
  integer i;
  for (i=ideb  ; i < n ; i++)
  {
    if (    vx[i] >= clipping->leftX 
         && vx[i] <= clipping->rightX 
         && vy[i] >= clipping->bottomY 
         && vy[i] <= clipping->topY    )
    {
      return(i);
    }
  }
  return(-1);
}

Here is the caller graph for this function:

integer sciFirstOutClipRegion	(	integer	n,
		integer	ideb,
		integer *	vx,
		integer *	vy,
		SClipRegion *	clipping
	)

Definition at line 282 of file clipping.c.

References SClipRegion::bottomY, i, SClipRegion::leftX, SClipRegion::rightX, and SClipRegion::topY.

Referenced by clipPolyLine().

{
  integer i;
  for ( i=ideb  ; i < n ; i++ )
  {
    if (    vx[i] < clipping->leftX 
         || vx[i] > clipping->rightX  
         || vy[i] < clipping->bottomY
         || vy[i] > clipping->topY   ) 
    {
      return(i);
    }
  }
  return(-1);
}

Here is the caller graph for this function:

void sciUnClip

(

sciPointObj *

pobj

)

Clear the clipping rectangle

Author:

Djalel ABDEMOUCHE 29/11/2002

Definition at line 470 of file clipping.c.

References C2F, dr(), L, PD0, PI0, sciGetIsClipping(), and value.

Referenced by drawArcEntity(), drawAxesEntity(), drawPolylineEntity(), drawRectangleEntity(), drawSegsEntity(), drawSubWinEntity(), and drawTextEntity().

{
  int value = sciGetIsClipping(pobj);     /* clipping state */

  if ( value > -1 )
  {
    C2F(dr)("xset","clipoff",PI0,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,4L,7L) ;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---