Back to index

radiance  4R0+20100331
Defines | Functions | Variables
clip.c File Reference
#include "copyright.h"
#include "fvect.h"
#include "plocate.h"

Go to the source code of this file.

Defines

#define MAXITER   6 /* maximum possible number of iterations */

Functions

int clip (RREAL *ep1, RREAL *ep2, FVECT min, FVECT max)

Variables

static const char RCSid [] = "$Id: clip.c,v 2.5 2003/06/26 00:58:09 schorsch Exp $"

Define Documentation

#define MAXITER   6 /* maximum possible number of iterations */

Definition at line 14 of file clip.c.


Function Documentation

int clip ( RREAL ep1,
RREAL ep2,
FVECT  min,
FVECT  max 
)

Definition at line 18 of file clip.c.

{
       int  itlim = MAXITER;
       int  loc1, loc2;
       int  accept;
       RREAL  *dp;
       double  d;
       register int  i, j;

       /*
        *     The Cohen-Sutherland algorithm is used to determine
        *  what part (if any) of the given line segment is contained
        *  in the box specified by the min and max vectors.
        *     The routine returns non-zero if any segment is left.
        */
       
       loc1 = plocate(ep1, min, max);
       loc2 = plocate(ep2, min, max);

                     /* check for trivial accept and reject */
                     /* trivial accept is both points inside */
                     /* trivial reject is both points to one side */
       
       while (!((accept = !(loc1 | loc2)) || (loc1 & loc2))) {
       
              if (itlim-- <= 0)    /* past theoretical limit? */
                     return(0);    /* quit fooling around */

              if (!loc1) {         /* make sure first point is outside */
                     dp = ep1; ep1 = ep2; ep2 = dp;
                     i = loc1; loc1 = loc2; loc2 = i;
              }
              
              for (i = 0; i < 3; i++) {          /* chop segment */
                     
                     if (loc1 & position(i) & BELOW) {
                            d = (min[i] - ep1[i])/(ep2[i] - ep1[i]);
                            ep1[i] = min[i];
                     } else if (loc1 & position(i) & ABOVE) {
                            d = (max[i] - ep1[i])/(ep2[i] - ep1[i]);
                            ep1[i] = max[i];
                     } else
                            continue;
                     
                     for (j = 0; j < 3; j++)
                            if (j != i)
                                   ep1[j] += (ep2[j] - ep1[j])*d;
                     break;
              }
              loc1 = plocate(ep1, min, max);
       }
       return(accept);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

const char RCSid[] = "$Id: clip.c,v 2.5 2003/06/26 00:58:09 schorsch Exp $" [static]

Definition at line 2 of file clip.c.