Annotation of OpenXM_contrib/gnuplot/binary.c, Revision 1.1.1.1
1.1 maekawa 1: #ifndef lint
2: static char *RCSid = "$Id: binary.c,v 1.10 1998/04/14 00:14:49 drd Exp $";
3: #endif
4:
5: /*
6: * The addition of gnubin and binary, along with a small patch
7: * to command.c, will permit gnuplot to plot binary files.
8: * gnubin - contains the code that relies on gnuplot include files
9: * and other definitions
10: * binary - contains those things that are independent of those
11: * definitions and files
12: *
13: * With these routines, hidden line removal of your binary data is possible!
14: *
15: * Last update: 3/29/92 memory allocation bugs fixed. jvdwoude@hut.nl
16: * 3/09/92 spelling errors, general cleanup, use alloc with no
17: * nasty fatal errors
18: * 3/03/92 for Gnuplot 3.24.
19: * Created from code for written by RKC for gnuplot 2.0b.
20: *
21: * Copyright (c) 1991,1992 Robert K. Cunningham, MIT Lincoln Laboratory
22: *
23: */
24:
25: #include "plot.h" /* We have to get TRUE and FALSE */
26: #include "stdfn.h"
27: #include "binary.h"
28:
29: /*
30: * This routine scans the first block of the file to see if the file is a
31: * binary file. A file is considered binary if 10% of the characters in it
32: * are not in the ascii character set. (values < 128), or if a NUL is found.
33: * I hope this doesn't break when used on the bizzare PC's.
34: */
35: int is_binary_file(fp)
36: register FILE *fp;
37: {
38: register int i, len;
39: register int odd; /* Contains a count of the odd characters */
40: long where;
41: register unsigned char *c;
42: unsigned char buffer[512];
43:
44: if ((where = ftell(fp)) == -1) { /* Find out where we start */
45: fprintf(stderr, "Notice: Assuming unseekable data is not binary\n");
46: return (FALSE);
47: } else {
48: rewind(fp);
49:
50: len = fread(buffer, sizeof(char), 512, fp);
51: if (len <= 0) /* Empty file is declared ascii */
52: return (FALSE);
53:
54: c = buffer;
55:
56: /* now scan buffer to look for odd characters */
57: odd = 0;
58: for (i = 0; i < len; i++, c++) {
59: if (!*c) { /* NUL _never_ allowed in text */
60: odd += len;
61: break;
62: } else if ((*c & 128) || /* Meta-characters--we hope it's not formatting */
63: (*c == 127) || /* DEL */
64: (*c < 32 &&
65: *c != '\n' && *c != '\r' && *c != '\b' &&
66: *c != '\t' && *c != '\f' && *c != 27 /*ESC */ ))
67: odd++;
68: }
69:
70: fseek(fp, where, 0); /* Go back to where we started */
71:
72: if (odd * 10 > len) /* allow 10% of the characters to be odd */
73: return (TRUE);
74: else
75: return (FALSE);
76: }
77: }
78:
79:
80: /*========================= I/O Routines ================================
81: These may be useful for situations other than just gnuplot. Note that I
82: have included the reading _and_ the writing routines, so others can create
83: the file as well as read the file.
84: */
85:
86: /*
87: This function reads a matrix from a stream
88:
89: This routine never returns anything other than vectors and arrays
90: that range from 0 to some number.
91:
92: */
93: #define START_ROWS 100 /* Each of these must be at least 1 */
94: #define ADD_ROWS 50
95: int fread_matrix(fin, ret_matrix, nr, nc, row_title, column_title)
96: FILE *fin;
97: float GPFAR *GPFAR * GPFAR * ret_matrix, GPFAR * GPFAR * row_title,
98: GPFAR * GPFAR * column_title;
99: int *nr, *nc;
100: {
101: float GPFAR *GPFAR * m, GPFAR * rt, GPFAR * ct;
102: register int num_rows = START_ROWS;
103: register int num_cols;
104: register int current_row = 0;
105: register float GPFAR *GPFAR * temp_array;
106: float fdummy;
107:
108: if (fread(&fdummy, sizeof(fdummy), 1, fin) != 1)
109: return FALSE;
110:
111: num_cols = (int) fdummy;
112:
113: /*
114: Choose a reasonable number of rows,
115: allocate space for it and continue until this space
116: runs out, then extend the matrix as necessary.
117: */
118: ct = vector(0, num_cols - 1);
119: fread(ct, sizeof(*ct), num_cols, fin);
120:
121: rt = vector(0, num_rows - 1);
122: m = matrix(0, num_rows - 1, 0, num_cols - 1);
123:
124: while (fread(&rt[current_row], sizeof(rt[current_row]), 1, fin) == 1) {
125: /* We've got another row */
126: if (fread(m[current_row], sizeof(*(m[current_row])), num_cols, fin) != num_cols)
127: return (FALSE); /* Not a True matrix */
128:
129: current_row++;
130: if (current_row >= num_rows) { /* We've got to make a bigger rowsize */
131: temp_array = extend_matrix(m, 0, num_rows - 1, 0, num_cols - 1,
132: num_rows + ADD_ROWS - 1, num_cols - 1);
133: rt = extend_vector(rt, 0, num_rows - 1, num_rows + ADD_ROWS - 1);
134:
135: num_rows += ADD_ROWS;
136: m = temp_array;
137: }
138: }
139: /* finally we force the matrix to be the correct row size */
140: /* bug fixed. procedure called with incorrect 6th argument.
141: * jvdwoude@hut.nl */
142: temp_array = retract_matrix(m, 0, num_rows - 1, 0, num_cols - 1, current_row - 1, num_cols - 1);
143: /* Now save the things that change */
144: *ret_matrix = temp_array;
145: *row_title = retract_vector(rt, 0, num_rows - 1, current_row - 1);
146: *column_title = ct;
147: *nr = current_row; /* Really the total number of rows */
148: *nc = num_cols;
149: return (TRUE);
150: }
151:
152: /* This writes a matrix to a stream
153: Note that our ranges are inclusive ranges--and we can specify subsets.
154: This behaves similarly to the xrange and yrange operators in gnuplot
155: that we all are familiar with.
156: */
157: int fwrite_matrix(fout, m, nrl, nrh, ncl, nch, row_title, column_title)
158: register FILE *fout;
159: register float GPFAR *GPFAR * m, GPFAR * row_title, GPFAR * column_title;
160: register int nrl, nrh, ncl, nch;
161: {
162: register int j;
163: float length;
164: register int col_length;
165: register int status;
166: float GPFAR *title = NULL;
167:
168: length = (float) (col_length = nch - ncl + 1);
169:
170: if ((status = fwrite((char *) &length, sizeof(float), 1, fout)) != 1) {
171: fprintf(stderr, "fwrite 1 returned %d\n", status);
172: return (FALSE);
173: }
174: if (!column_title) {
175: column_title = title = vector(ncl, nch);
176: for (j = ncl; j <= nch; j++)
177: title[j] = (float) j;
178: }
179: fwrite((char *) column_title, sizeof(float), col_length, fout);
180: if (title) {
181: free_vector(title, ncl, nch);
182: title = NULL;
183: }
184: if (!row_title) {
185: row_title = title = vector(nrl, nrh);
186: for (j = nrl; j <= nrh; j++)
187: title[j] = (float) j;
188: }
189: for (j = nrl; j <= nrh; j++) {
190: fwrite((char *) &row_title[j], sizeof(float), 1, fout);
191: fwrite((char *) (m[j] + ncl), sizeof(float), col_length, fout);
192: }
193: if (title)
194: free_vector(title, nrl, nrh);
195:
196: return (TRUE);
197: }
198:
199: /*===================== Support routines ==============================*/
200:
201: /******************************** VECTOR *******************************
202: * The following routines interact with vectors.
203: *
204: * If there is an error we don't really return - int_error breaks us out.
205: *
206: * This subroutine based on a subroutine listed in "Numerical Recipies in C",
207: * by Press, Flannery, Teukoilsky and Vetterling (1988).
208: *
209: */
210: float GPFAR *vector(nl, nh)
211: register int nl, nh;
212: {
213: register float GPFAR *vec;
214:
215: if (!(vec = (float GPFAR *) gp_alloc((unsigned long) (nh - nl + 1) * sizeof(float), NULL))) {
216: int_error("not enough memory to create vector", NO_CARET);
217: return NULL; /* Not reached */
218: }
219: return (vec - nl);
220: }
221:
222:
223: /*
224: * Free a vector allocated above
225: *
226: * This subroutine based on a subroutine listed in "Numerical Recipies in C",
227: * by Press, Flannery, Teukoilsky and Vetterling (1988).
228: *
229: */
230: void free_vector(vec, nl, nh)
231: float GPFAR *vec;
232: int nl, nh;
233: {
234: free(vec + nl);
235: }
236:
237: /************ Routines to modify the length of a vector ****************/
238: float GPFAR *
239: extend_vector(vec, old_nl, old_nh, new_nh)
240: float GPFAR *vec;
241: register int old_nl, old_nh, new_nh;
242: {
243: register float GPFAR *new_v;
244: new_v = (float GPFAR *) gp_realloc((void *) (vec + old_nl),
245: (unsigned long) (new_nh - old_nl + 1) * sizeof(float),
246: "extend vector");
247: return new_v - old_nl;
248: }
249:
250: float GPFAR *
251: retract_vector(v, old_nl, old_nh, new_nh)
252: float GPFAR *v;
253: register int old_nl, old_nh, new_nh;
254: {
255: register float GPFAR *new_v;
256: new_v = (float GPFAR *) gp_realloc((void *) (v + old_nl),
257: (unsigned long) (new_nh - old_nl + 1) * sizeof(float), "retract vector");
258: return new_v - old_nl;
259: }
260:
261:
262: /***************************** MATRIX ************************
263: *
264: * The following routines work with matricies
265: *
266: * I always get confused with this, so here I write it down:
267: * for nrl<= nri <=nrh and
268: * for ncl<= ncj <=nch
269: *
270: * This matrix is accessed as:
271: *
272: * matrix[nri][ncj];
273: * where nri is the offset to the pointer to a vector where the
274: * ncjth element lies.
275: *
276: * If there is an error we don't really return - int_error breaks us out.
277: *
278: * This subroutine based on a subroutine listed in "Numerical Recipies in C",
279: * by Press, Flannery, Teukoilsky and Vetterling (1988).
280: *
281: */
282: float
283: GPFAR *GPFAR * matrix(nrl, nrh, ncl, nch)
284: register int nrl, nrh, ncl, nch;
285: {
286: register int i;
287: register float GPFAR *GPFAR * m;
288:
289: m = (float GPFAR * GPFAR *) gp_alloc((unsigned long) (nrh - nrl + 1) * sizeof(float GPFAR *), "matrix");
290: m -= nrl;
291:
292: for (i = nrl; i <= nrh; i++) {
293: if (!(m[i] = (float GPFAR *) gp_alloc((unsigned long) (nch - ncl + 1) * sizeof(float), NULL))) {
294: free_matrix(m, nrl, i - 1, ncl, nch);
295: int_error("not enough memory to create matrix", NO_CARET);
296: return NULL;
297: }
298: m[i] -= ncl;
299: }
300: return m;
301: }
302: /*
303: * Free a matrix allocated above
304: *
305: *
306: * This subroutine based on a subroutine listed in "Numerical Recipies in C",
307: * by Press, Flannery, Teukoilsky and Vetterling (1988).
308: *
309: */
310: void free_matrix(m, nrl, nrh, ncl, nch)
311: float GPFAR *GPFAR * m;
312: unsigned nrl, nrh, ncl, nch;
313: {
314: register unsigned int i;
315:
316: for (i = nrl; i <= nrh; i++)
317: free((char GPFAR *) (m[i] + ncl));
318: free((char GPFAR *) (m + nrl));
319: }
320:
321: /*
322: This routine takes a sub matrix and extends the number of rows and
323: columns for a new matrix
324: */
325: float GPFAR *GPFAR * extend_matrix(a, nrl, nrh, ncl, nch, srh, sch)
326: register float GPFAR *GPFAR * a;
327: register int nrl, nrh, ncl, nch;
328: register int srh, sch;
329: {
330: register int i;
331: register float GPFAR *GPFAR * m;
332:
333: m = (float GPFAR * GPFAR *) gp_realloc((void *) (a + nrl), (unsigned long) (srh - nrl + 1) * sizeof(float GPFAR *), "extend matrix");
334:
335: m -= nrl;
336:
337: if (sch != nch) {
338: for (i = nrl; i <= nrh; i++) { /* Copy and extend rows */
339: if (!(m[i] = extend_vector(m[i], ncl, nch, sch))) {
340: free_matrix(m, nrl, nrh, ncl, sch);
341: int_error("not enough memory to extend matrix", NO_CARET);
342: return NULL;
343: }
344: }
345: }
346: for (i = nrh + 1; i <= srh; i++) {
347: if (!(m[i] = (float GPFAR *) gp_alloc((unsigned long) (nch - ncl + 1) * sizeof(float), NULL))) {
348: free_matrix(m, nrl, i - 1, nrl, sch);
349: int_error("not enough memory to extend matrix", NO_CARET);
350: return NULL;
351: }
352: m[i] -= ncl;
353: }
354: return m;
355: }
356: /*
357: this routine carves a large matrix down to size
358: */
359: float GPFAR *GPFAR * retract_matrix(a, nrl, nrh, ncl, nch, srh, sch)
360: register float GPFAR *GPFAR * a;
361: register int nrl, nrh, ncl, nch;
362: register int srh, sch;
363: {
364: register int i;
365: register float GPFAR *GPFAR * m;
366:
367: for (i = srh + 1; i <= nrh; i++) {
368: free_vector(a[i], ncl, nch);
369: }
370:
371: m = (float GPFAR * GPFAR *) gp_realloc((void *) (a + nrl), (unsigned long) (srh - nrl + 1) * sizeof(float GPFAR *), "retract matrix");
372:
373: m -= nrl;
374:
375: if (sch != nch) {
376: for (i = nrl; i <= srh; i++)
377: if (!(m[i] = retract_vector(m[i], ncl, nch, sch))) { { /* Shrink rows */
378: free_matrix(m, nrl, srh, ncl, sch);
379: int_error("not enough memory to retract matrix", NO_CARET);
380: return NULL;
381: }
382: }
383: }
384: return m;
385: }
386:
387: float
388: GPFAR *GPFAR * convert_matrix(a, nrl, nrh, ncl, nch)
389: float GPFAR *a;
390: register int nrl, nrh, ncl, nch;
391:
392: /* allocate a float matrix m[nrl...nrh][ncl...nch] that points to the
393: matrix declared in the standard C manner as a[nrow][ncol], where
394: nrow=nrh-nrl+1, ncol=nch-ncl+1. The routine should be called with
395: the address &a[0][0] as the first argument. This routine does
396: not free the memory used by the original array a but merely assigns
397: pointers to the rows. */
398:
399: {
400: register int i, j, ncol, nrow;
401: register float GPFAR *GPFAR * m;
402:
403: nrow = nrh - nrl + 1;
404: ncol = nch - ncl + 1;
405: m = (float GPFAR * GPFAR *) gp_alloc((unsigned long) (nrh - nrl + 1) * sizeof(float GPFAR *), "convert_matrix");
406: m -= nrl;
407:
408: m[nrl] = a - ncl;
409: for (i = 1, j = nrl + 1; i <= nrow - 1; i++, j++)
410: m[j] = m[j - 1] + ncol;
411: return m;
412: }
413:
414:
415: void free_convert_matrix(b, nrl, nrh, ncl, nch)
416: float GPFAR *GPFAR * b;
417: register int nrl, nrh, ncl, nch;
418: {
419: free((char *) (b + nrl));
420: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to binary.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot