boundary.h

#ifndef BOUNDARY_H
#define BOUNDARY_H 1

#include "project_utilities.h"

BEGIN_C_DECLARATIONS

#define INIT_LEN 512

#define NOT_AN_ANGLE -HUGE_VAL
#define NOT_A_WIDTH -HUGE_VAL

#define TINY (1e-16)

#define MISSING_BRIGHTNESS DARKNESS

#define MID_GRAY ((PIXEL)127.0)

#define NCOEFF 4

#define NPOINTS 4

#define MAX_BOUND_ANGLE (0.45*M_PI)

#define SEARCH_TOLERANCE 0.35

#define MATCH_TOLERANCE 0.125

#define MEASURE_TOLERANCE 0.083333333

#define SRADIUS 5
#define SDIAMETER (2*SRADIUS+1)

#define SUBIMAGE_MARGIN_FRACTION 0.125

/* define round function */

/* #define round(x) ((x-floor(x))>0.5 ? (ceil(x)) : (floor(x))) */

#define mosaic_point(M,I,R,C) (M->data[0][R - I->voffset[C]][C])

#define project_on_principal_axis(P,A,X,Y,Z) X = P->xpos - A->centroid.xpos; \
  Y = P->ypos - A->centroid.ypos; \
  Z = Y*cos(A->centroid.theta) + X*sin(A->centroid.theta)

#define rb_balance(U,D) tmp = sub->parent->parent->D; \
if((tmp!=NULL) &&(tmp->rbcolor==red) ) \
  { \
    sub->parent->rbcolor = black; \
    tmp->rbcolor = black; \
    sub->parent->parent->rbcolor = red; \
    sub = sub->parent->parent; \
  } \
else \
  { \
    if (sub == sub->parent->D) \
      { \
        sub = sub->parent; \
        rb_rotate_##U (root,sub) ; \
      } \
    sub->parent->rbcolor = black; \
    sub->parent->parent->rbcolor = red; \
    rb_rotate_##D (root, sub->parent->parent) ; \
  } \


#define make_rotator(U,D) static void \
rb_rotate_##U (RBNODE**root, RBNODE*sub)  \
{ \
  RBNODE * tmp; \
  tmp = sub->D; \
  sub->D = tmp->U; \
  if(tmp->U != NULL)  \
    tmp->U->parent = sub; \
  tmp->parent = sub->parent; \
  if(sub == *root) \
    { \
      *root = tmp; \
    } \
  else if (sub == sub->parent->U) \
    { \
      sub->parent->U = tmp; \
    } \
  else \
    { \
      sub->parent->D = tmp; \
    } \
  tmp->U = sub; \
  sub->parent = tmp; \
} \


typedef struct
{
  double minx; 
  double miny; 
  double maxx; 
  double maxy; 
} RECTANGLE;

typedef struct boundpoint
{
  double xpos; 
  double ypos; 
  double theta; 
  int valid; 
  struct boundpoint *next; 
} BOUNDPOINT;

typedef enum
{ red = 0, black = 1 } rbcolortype;

typedef struct rbnode
{
  rbcolortype rbcolor;
  double key;
  BOUNDPOINT *point;
  struct rbnode *parent;
  struct rbnode *left;
  struct rbnode *right;
} RBNODE;

typedef struct
{
  RECTANGLE enclosure;
  BOUNDPOINT centroid;
  BOUNDPOINT *points;
  BOUNDPOINT *endpoint;
  RBNODE *point_index;
  int stale;
} BOUNDER;

typedef struct
{
  double *d;
  int n;
  int block;
} WIDTHS;

typedef struct
{
  long double xsum;
  long double xsumsq;
  long double ysum;
  long double ysumsq;
  long double prodsum;
  int n;
} SUMSTATE;

typedef struct imagecontext
{
  void *image;
  void *imageindex;
  double (*accessor) (double, double, struct imagecontext *);
} IMAGE_CONTEXT;

#define image_access(X,Y,I) (I->accessor(X, Y, I))

typedef struct boundarycontext
{
  void *points;
  int hasnext;
  int prevx;
  int prevy;
  double xpos;
  double ypos;
  int valid;
  int nterms;
  double *xc;
  double *yc;
  struct boundarycontext *(*iterator) (struct boundarycontext *);
} BOUNDARY_CONTEXT;

#define iterate(B) (B = B->iterator(B))

double find_width (BOUNDER * in, BOUNDER * out, IMAGE_CONTEXT * mosaic,
                   PROFILE_LIST * last_ringprofile);

BOUNDER * make_boundary (BOUNDARY_CONTEXT * bcon);

void discard_boundary (BOUNDER * bound);

void initialize_mosaic_context (IMAGE_BYTE * im, MOSAIC_INDEX * imindex,
                                IMAGE_CONTEXT * newcontext);

void initialize_chaincode_context (LIST_NODE * chain_boundary,
                                   BOUNDARY_CONTEXT * newcontext);

void initialize_image_context (IMAGE * im, IMAGE_CONTEXT * newcontext);

void build_index (BOUNDER * bound);

void demolish_index (RBNODE * ix);

END_C_DECLARATIONS

#endif /* !BOUNDARY_H */

---