/* Last edited on 2011-09-26 11:38:18 by stolfilocal */

/*
  INSPECTION  */

bz_patch_ddim_t bz_patch_get_ddim ( bz_patch_t *P );
  /* Returns the dimension of the domain of patch {P},
    namely {P.d}. */

bz_patch_rinds_t bz_patch_get_rinds ( bz_patch_t *P );
  /* Returns the number of indices of the values (and coefficients) of
    patch {P}, namely {P.r}. */


bz_patch_t bz_patch_facet_new(bz_patch_t *b, box_axis_index_t j);
  /* Returns a Bézier patch {f} suitable for storing into it a facet
    of another Bézier patch {b} that is perpendicular to axis
    {j} of {b}'s domain. Thus, the new patch {f} will have domain
    dimension {d-1}, the same range space as {b}, and its degree vector will
    be {g[0..d-1]} with element {g[j]} deleted. The coefficients
    {f.C} are newly allocated. */
void bz_patch_set_face
  ( bz_patch_t *P, 
    box_signed_dir_t dir[], 
    bz_patch_t *t
  );
  /* Assumes that {*t} is a Bezier patch that describes the shape of an 
    {s}-dimensional face {F} of patch {P}, specified by its signature {dir}. 
    Modifies {P} so that the face {F} has that shape.  The remaining control
    points of {P} are modified too, proportionally to their distance from 
    face {F}. */
    

void bz_patch_compute_steps
  ( bz_patch_t *P, /* A Bézier patch. */
    int step[],    /* (OUT) coeff index increment for each axis. */
    int *sz       /* (OUT) total number of coeffs. */
  );
  /* Stores in each {step[i]} the increment in the total coeff index 
    {e(e[0],..e[d-1])} that corresponds to a unit increment in the 
    index {e[i]}.  Also returns in {*sz} the total number of coeffs. */

void bz_patch_eval_d
  ( bz_patch_ddim_t d,     /* Dimension of parameter space. */
    bz_patch_rinds_t r,    /* Dimension of image space. */
    const bz_degree_t g[], /* Degree of each coordinarte. */
    double *c,             /* Bezier coeffs. */
    const double x[],      /* Argument vector (size {d}). */
    double fx[]            /* OUT: Image vector (size {r}). */
  );
  /* Evaluates a Bézier patch of degree {g} from {R^d} to {R^r},
    given by the coeff array {c}, at an argument vector {x[0..d-1]}.
    The result is returned in {fx[0..r-1]}. */
  
void bz_patch_eval_1
  ( bz_patch_rinds_t r,  /* Dimension of image space. */
    bz_degree_t g,       /* Degree of curve. */
    double *c,           /* Bezier coeffs. */
    double x,            /* Argument value. */
    double fx[]          /* OUT: Image vector (size {r}). */
  );
  /* Evaluates a Bézier curve (a Bézier patch with unidimensional
    domain) of degree {g}, given by the coeff array {c}, at an
    argument {x}. The result is returned in {fx[0..r-1]}. */