![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Coord.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / bcp|
Return to Coord.h CVS log | Up to [Research Unix] / researchv10dc / cmd / bcp |
1.1 root 1: /* Copyright (c) 1989, 1990 AT&T --- All Rights Reserved. */
2: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T. */
3: /* The copyright notice does not imply actual or intended publication. */
4: /* AUTHORS: */
5: /* H. S. Baird - ATT-BL MH - first versions */
6: /* Coord.h - defines, typedefs, Inits, empties, and function declarations
7: for basic Coordinate geometry data items.
8: See Coord.c for associated functions.
9: */
10:
11: /* Round signed floating-pt no. F:
12: (a) ROUND - to nearest integer;
13: (b) ROUND_UP - up to next int;
14: (c) ROUND_DN - down to prior int.
15: Evaluates the argument exactly once. */
16: static double _round,_round_up,_round_dn;
17: #define ROUND(F) ((int)(((_round=(F))>=0.0)? _round+0.5: _round-0.5))
18: #define ROUND_UP(F) ((int)(((_round_up=(F))>=0.0)? _round_up+0.999999: _round_up))
19: #define ROUND_DN(F) ((int)(((_round_dn=(F))>=0.0)? _round_dn: _round_dn-0.999999))
20:
21: /* The basic unit is the scanner pixel, located in the X,Y plane. As in many
22: graphics coordinate systems, X increases left-to-right, while Y increases
23: top-down. Pixel coordinates are usually integer values. The physical extent
24: of integer coordinate `x' along the real X-axis is the half-open interval
25: [x,x+1), and similarly for Y. The actual digitizing resolution (e.g.
26: pixels/inch) represented can vary from document to document, and is almost
27: always known to the algorithms. X & Y resolution can be different, though
28: for simplicity of discussion we will usually assume that they are equal,
29: i.e. that pixels are square. Thus pixel (x,y) may be thought of as the region
30: [x,x+1)X[y,y+1) in the real plane.
31: Half-pixel resolution is also supported, with its own data types for
32: clarity. However, to avoid distracting struggles with the type system, they
33: are for the most part #defined to be identical to ordinary coordinates. The
34: principle effect is that the limits of scanner coordinates have been halved
35: to allow for safe use of half-pixels everywhere. (This still permits images
36: 80 inches square at 400 pixels/inch, assuming `short' is at least 16-bit 2's
37: complement.)
38: Half-pixel coordinates can also be used to describe boundaries of regions,
39: as a set of ideal point locations at the corners and edge midpoints of pixels.
40: The half-pixel data type is used; boundary points are identified by flags
41: in the Bdy "boundary" structure, and may be displayed differently. */
42:
43: #define Scoor short /* Scanner pixel coordinate value */
44: #define Hcoor Scoor /* Half-pixel coordinate value */
45: #define Bcoor Hcoor /* Half-pixel boundary coordinate value */
46:
47: /* Each Scoor value `v' is associated of course with two Hcoor values `a' < `b'.
48: Conventionally, the physical extent of the `a' half-coordinate is the real
49: interval [v,v+0.5), and `b' is [v+0.5,v+1). */
50: #define StoHa(S) ((S)*2)
51: #define StoHb(S) ((S)*2+1)
52: #define HtoS(H) ((H)/2)
53:
54: /* The 3 half-pixel boundary points of a pixel coordinate `C' are: */
55: #define StoBa(S) (StoHa((S))) /* minimum of interval */
56: #define StoBb(S) (StoHb((S))) /* midpoint of interval */
57: #define StoBc(S) (StoHa((S)+1)) /* maximum of interval */
58:
59: #define Scoor_MIN (SHRT_MIN/2) /* minimum possible value */
60: #define Scoor_MAX (SHRT_MAX/2) /* maximum possible value */
61:
62: #define Hcoor_MIN (SHRT_MIN) /* minimum possible value */
63: #define Hcoor_MAX (SHRT_MAX) /* maximum possible value */
64:
65: #define fwri_Scoor(F,V) fwri_int2((F),(V))
66: #define frdi_Scoor(F) frdi_int2(F)
67:
68: #define fwri_Hcoor(F,V) fwri_int2((F),(V))
69: #define frdi_Hcoor(F) frdi_int2(F)
70:
71: #define fwri_Bcoor(F,V) fwri_int2((F),(V))
72: #define frdi_Bcoor(F) frdi_int2(F)
73:
74: typedef struct Sp { /* point: pixel address */
75: Scoor x; /* increases left-to-right: Scoor_MIN is left of image */
76: Scoor y; /* increases down: Scoor_MIN is top of image */
77: } Sp;
78: #define Hp Sp /* Half-pixel point */
79:
80: #define Init_Zero_Sp {0,0}
81: #define Init_Min_Sp {Scoor_MIN,Scoor_MIN}
82: #define Init_Max_Sp {Scoor_MAX,Scoor_MAX}
83:
84: #if MAIN
85: Sp zero_Sp = Init_Zero_Sp;
86: #else
87: extern Sp zero_Sp;
88: #endif
89:
90: #define fwri_Sp(F,P) { fwri_Scoor((F),(P)->x); fwri_Scoor((F),(P)->y); }
91: #define frdi_Sp(F,P) (feof(F)? 0: ( \
92: (P)->x=frdi_Scoor(F), \
93: (P)->y=frdi_Scoor(F), \
94: (ferror(F)? -errno: 1) ) )
95:
96: /* Is Sp *p1 exactly equal to Sp *p2? */
97: #define sp_eq(p1,p2) ( \
98: ((p1)->x == (p2)->x) \
99: && ((p1)->y == (p2)->y) \
100: )
101:
102: typedef struct Sps { /* Set of Points */
103: int mny; /* no. points (mny==0 ==> pa==NULL) */
104: Sp **pa; /* NULL-terminated Sp *pa[mny+1] (malloc space)*/
105: } Sps;
106:
107: #define Init_Sps {0,NULL}
108: #if MAIN
109: Sps empty_Sps = Init_Sps;
110: #else
111: extern Sps empty_Sps;
112: #endif
113:
114: typedef struct Spa { /* array of Points */
115: int mny; /* no. points in array */
116: Sp *a; /* Sp a[mny] (malloc space)*/
117: } Spa;
118: /** #define Pointa Spa **/ /* OBSOLESCENT */
119:
120: #define Init_Spa {0,NULL}
121: #if MAIN
122: Spa empty_Spa = Init_Spa;
123: #else
124: extern Spa empty_Spa;
125: #endif
126:
127: /* An edge is an ordered pair of vertices. */
128: typedef struct Edge {
129: Sp a,b; /* endpoints */
130: } Edge;
131:
132: #define Init_Edge {Init_Zero_Sp,Init_Zero_Sp}
133: #if MAIN
134: Edge empty_Edge = Init_Edge;
135: #else
136: extern Edge empty_Edge;
137: #endif
138:
139: #define fwri_Edge(F,P) { fwri_Sp((F),&((P)->a)); fwri_Sp((F),&((P)->b)); }
140: #define frdi_Edge(F,P) ( feof(F)? 0: ( \
141: frdi_Sp(F,&((P)->a)), \
142: frdi_Sp(F,&((P)->b)), \
143: (ferror(F)? -errno: 1) ) )
144:
145: /* A bounding box is a rectangle */
146: typedef struct { /* bounding box: inclusive of boundary values */
147: Sp a; /* top-left corner */
148: Sp b; /* bottom-right corner */
149: } Bbx;
150:
151: typedef struct DSp { /* point: pixel address */
152: double x; /* increases down the page, MinScoor at top */
153: double y; /* increases across the page, MinScoor at left */
154: } DSp;
155:
156: #define Init_Bbx {Init_Max_Sp,Init_Min_Sp}
157: #define Init_Max_Bbx {Init_Min_Sp,Init_Max_Sp}
158: #if MAIN
159: Bbx empty_Bbx = Init_Bbx;
160: Bbx max_Bbx = Init_Max_Bbx;
161: #else
162: extern Bbx empty_Bbx;
163: extern Bbx max_Bbx;
164: #endif
165:
166: #define fwri_Bbx(F,P) { fwri_Sp((F),&((P)->a)); fwri_Sp((F),&((P)->b)); }
167: #define frdi_Bbx(F,P) ( feof(F)? 0: ( \
168: frdi_Sp(F,&((P)->a)), \
169: frdi_Sp(F,&((P)->b)), \
170: (ferror(F)? -errno: 1) ) )
171:
172: /* OBSOLESCENT: */
173: #if MAIN
174: Bbx null_Bbx = {Init_Max_Sp,Init_Min_Sp};
175: #else
176: extern Bbx null_Bbx;
177: #endif
178:
179: /* height, width, area of Bbx in pixels */
180: #define bbx_hgt(bxp) ((bxp)->b.y-(bxp)->a.y+1)
181: #define bbx_wid(bxp) ((bxp)->b.x-(bxp)->a.x+1)
182: #define bbx_area(bxp) (bbx_hgt((bxp))*bbx_wid((bxp)))
183:
184: /* Is Bbx *b1 exactly equal to Bbx *b2? */
185: #define bbx_eq(b1,b2) ( \
186: ((b1)->a.x == (b2)->a.x) \
187: && ((b1)->a.y == (b2)->a.y) \
188: && ((b1)->b.x == (b2)->b.x) \
189: && ((b1)->b.y == (b2)->b.y) \
190: )
191:
192: /* Is Bbx *b1 wholly inside Bbx *b2? */
193: #define bbx_inside_all(b1,b2) ( \
194: ((b1)->a.x >= (b2)->a.x) \
195: && ((b1)->a.y >= (b2)->a.y) \
196: && ((b1)->b.x <= (b2)->b.x) \
197: && ((b1)->b.y <= (b2)->b.y) \
198: )
199:
200: /* Is any of Bbx *b1 inside Bbx *b2? */
201: #define bbx_inside_any(b1,b2) ( \
202: ((b1)->a.x <= (b2)->b.x) \
203: && ((b1)->a.y <= (b2)->b.y) \
204: && ((b1)->b.x >= (b2)->a.x) \
205: && ((b1)->b.y >= (b2)->a.y) \
206: )
207:
208: typedef struct Bbxs { /* A set of Bbxs */
209: int mny; /* if mny==0, then pa==NULL */
210: Bbx **pa; /* NULL-terminated array (in malloc space) of `mny+1'
211: pointers to Bbxs (in malloc space) */
212: int alloc; /* no. slots in pa[] actually allocated (>=mny+1) */
213: int incr; /* no. slots in pa[] to reallocate at a time */
214: } Bbxs;
215:
216: #define Init_Bbxs {0,NULL,0,512}
217: #if MAIN
218: Bbxs empty_Bbxs = Init_Bbxs;
219: #else
220: extern Bbxs empty_Bbxs;
221: #endif
222:
223: Sp *alloc_sp();
224: free_sp();
225: char *sp_toa(); /* Sp to ascii printable string */
226: Sp *ato_sp(); /* Sp from ascii printable string */
227: frda_sps();
228: Sps *dup_sps();
229: Sp *append_sp_sps();
230: Sp *append_sp_spa();
231: Sp *rotate_Sp(); /* rotate Sp about given fixed-point */
232: Sp *hshear_Sp(); /* horiz-shear Sp about given fixed-point */
233: Edge *alloc_edge();
234: free_edge();
235: char *edge_toa(); /* Edge to ascii printable string */
236: Edge *ato_edge(); /* Edge from ascii printable string */
237: Bbx *alloc_bbx();
238: Bbx *append_bbx();
239: Bbxs *dup_bbxs();
240: char *bbx_toa(); /* Bbx to ascii printable string */
241: Bbx *ato_bbx(); /* Bbx from ascii printable string */
242: Bbx *translate_bbx();
243: boolean bbx_inside_most(); /* Is Bbx 1 mostly inside Bbx 2? */
244: Bbx *expand_bbx();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.