unt sgiRead4U (ppu ret[4], unt *dW, unt *dH, int oX, int oY, char *path, unt flags) { IMAGE *sgim; ush *rowbuf; unt sW,sH,sD; size_t rsize; int y, yI; if ( ! (sgim=iopen(path,"r"))) die("sgiRead4U: iopen(%s) failed\n",path); sW = sgim->xsize; sH = sgim->ysize; sD = sgim->zsize; rsize = sizeof(unsigned short)*sW*sD; if (! (rowbuf = (unsigned short *)malloc(rsize))) die("sgiRead4U(%s): malloc(%u)",path,rsize); sH -= oY; *dH = sH; sW -= oX; *dW = sW; switch (sD) { case 1: { ppu dst; ret[0] = dst = rowMalUnc(0,0,sW,sH); ret[1] = NULL; for (yI = sH, y = oY; yI ; y++) { getrow(sgim,rowbuf,y,1); uncUsh(dst[--yI],rowbuf+oX,sW); } } break; case 3: { ppu gry, red, grn, blu; ret[0] = gry = rowMalUnc(0,0,sW,sH); ret[1] = red = rowMalUnc(0,0,sW,sH); ret[2] = grn = rowMalUnc(0,0,sW,sH); ret[3] = blu = rowMalUnc(0,0,sW,sH); /***** ret[4] = NULL; *****/ for (yI = sH, y = oY; yI-- ; y++) { getrow(sgim, rowbuf, y, 0); uncUsh(red[yI],rowbuf+oX,sW); getrow(sgim, rowbuf, y, 1); uncUsh(grn[yI],rowbuf+oX,sW); getrow(sgim, rowbuf, y, 2); uncUsh(blu[yI],rowbuf+oX,sW); } gryRgbUnc(gry,red,grn,blu,0,0,sW,sH); } break; default: die("sgiRead4U [%s]: NOIMP for SGI image depth %u",__FILE__,sD); } free(rowbuf); iclose(sgim); if (sD == 3) return 4; else if (sD <= 1) return 1; else return 0; }
int boxcheck(int *board) { int i,j,d,sum,last,last2; for (i = 0; i < 9; i++) { for (d = 0;d < 9; d++) { sum=0; last=-1; last2=-1; for (j = 0; j < 9; j++) { if (board[boxind[i][j]] & allowbits[d]) { sum++; last2=last; last=boxind[i][j]; } else sum += ((board[boxind[i][j]] & Solve)==(d << 4)) ? 1: 0; } if (sum==0) return(0); if ((sum==1)&&(last>=0)) if (!setallowed(board,last,d)) return(0); if((sum == 2) && (last >= 0) && ( last2 >= 0) && (getrow(last) == getrow(last2))) { for (j = 0; j < 9; j++) { int c = rowind[getrow(last)][j]; if ((c != last)&&(c != last2)) { if (board[c] & allowbits[d]) { board[c] &= ~allowbits[d]; if ((board[c] & Allow)==0) return(0); } } } } if((sum == 2) && (last >= 0) && (last2 >= 0) && (getcol(last) == getcol(last2))) { for (j = 0;j <9;j++) { int c = colind[getcol(last)][j]; if ((c != last) && (c != last2)) { if (board[c] & allowbits[d]) { board[c] &= ~allowbits[d]; if ((board[c] & Allow) == 0) return(0); } } } } } } return(1); }
unt sgiReadU( ppu *ret, unt *dW, unt *dH , int oX, int oY, unt mW, unt mH, char *path, unt flags) { IMAGE *sgim; ush *rowbuf; unt sW,sH,sD; int y, yI; if ( ! (sgim=iopen(path,"r"))) die("sgiReadU: iopen(%s) failed\n",path); sW = sgim->xsize; sH = sgim->ysize; sD = sgim->zsize; yI = sizeof(unsigned short)*sW*sD; mallocAss(rowbuf,ush,yI); sW -= oX; if (sW > mW) sW = mW; *dW = sW; sH -= oY; if (sH > mH) sH = mH; *dH = sH; switch (sD) { case 1: { ppu dst; ret[0] = dst = rowMalUnc(0,0,sW,sH); /***** ret[1] = NULL; *****/ for (yI = sH, y = oY; yI ; y++) { getrow(sgim,rowbuf,y,1); uncUsh(dst[--yI],rowbuf+oX,sW); } } break; case 3: { ppu red, grn, blu; ret[0] = red = rowMalUnc(0,0,sW,sH); ret[1] = grn = rowMalUnc(0,0,sW,sH); ret[2] = blu = rowMalUnc(0,0,sW,sH); /***** ret[4] = NULL; *****/ for (yI = sH, y = oY; yI-- ; y++) { getrow(sgim, rowbuf, y, 0); uncUsh(red[yI],rowbuf+oX,sW); getrow(sgim, rowbuf, y, 1); uncUsh(grn[yI],rowbuf+oX,sW); getrow(sgim, rowbuf, y, 2); uncUsh(blu[yI],rowbuf+oX,sW); } } break; default: die("sgiReadU [%s]: NOIMP for SGI image depth %u",__FILE__,sD); } free(rowbuf); iclose(sgim); return sD; }
int access(jobqueue* k, int bank) { if(row[bank].busy == 1) { k->time = 9999999999999; //printf("busy\n"); addqueue(bank, k); if(row[bank].jsize>1) { check++; } //printf("%s\n", row[bank].rq->addr); } else { row[bank].busy = 1; if(strncmp(row[bank].rowbuffer,getrow(k->addr),4)==0) { printf("hit\n"); row[bank].jobend = k->time +154; row[bank].totalbusy += 154; return 154; } else if(strncmp(row[bank].rowbuffer, "ffff",4)==0) { printf("closed\n"); strncpy(row[bank].rowbuffer, getrow(k->addr),4); row[bank].rowbuffer[4] = '\0'; row[bank].jobend = k->time +258; row[bank].totalbusy += 258; return 258; } else { strncpy(row[bank].rowbuffer, getrow(k->addr),4); row[bank].rowbuffer[4] = '\0'; printf("miss\n"); row[bank].jobend = k->time +362; row[bank].totalbusy += 362; return 362; } } }
/* * is_unique: return 1 if grid (r, c) not empty and * grid (r, c)'s number is unique among line r, col c and * the corresponding box. 0 if not. */ int is_unique(int r, int c, int puzzle[][9]) { int i, flag[9]; // make sure (r,c) not empty! if (!is_filled(puzzle, r, c)) return 0; for (i=0; i<9; i++) flag[i] = 0; i = puzzle[r-1][c-1]; puzzle[r-1][c-1] = 0; getbox(puzzle, r, c); getrow(puzzle, r, c); getcol(puzzle, r, c); puzzle[r-1][c-1] = i; flag[puzzle[r-1][c-1] - 1] = 1; for (i=0; i<9; i++) { if (box[i] >= 1 && box[i] <= 9) flag[box[i]-1]++; if (row[i] >= 1 && row[i] <= 9) flag[row[i]-1]++; if (col[i] >= 1 && col[i] <= 9) flag[col[i]-1]++; } for (i=0; i<9; i++) if (flag[i] > 1) return 0; return 1; }
static void mkclrmap( /* make our color map */ int nc ) { register int i; if ((samplefac ? neu_init(xmax*ymax) : new_histo(xmax*ymax)) == -1) goto memerr; for (i = 0; i < ymax; i++) { getrow(i); if (samplefac) neu_colrs(scanln, xmax); else cnt_colrs(scanln, xmax); } if (samplefac) neu_clrtab(nc); else new_clrtab(nc); for (i = 0; i < nc; i++) { rmap[i] = clrtab[i][RED]; gmap[i] = clrtab[i][GRN]; bmap[i] = clrtab[i][BLU]; } if (dither && (pixscan = (uby8 *)malloc(xmax)) == NULL) goto memerr; return; memerr: fprintf(stderr, "%s: out of memory\n", progname); exit(1); }
static int cpSeparate(IMAGE* in, TIFF* out) { tdata_t buf = _TIFFmalloc(TIFFScanlineSize(out)); short *r = (short *)_TIFFmalloc(in->xsize * sizeof (short)); uint8* pp = (uint8*) buf; int x, y, z; for (z = 0; z < in->zsize; z++) { for (y = in->ysize-1; y >= 0; y--) { getrow(in, r, y, z); for (x = 0; x < in->xsize; x++) pp[x] = r[x]; if (TIFFWriteScanline(out, buf, in->ysize-y-1, z) < 0) goto bad; } } _TIFFfree(r); _TIFFfree(buf); return (1); bad: _TIFFfree(r); _TIFFfree(buf); return (0); }
R_API void r_cons_canvas_write(RConsCanvas *c, const char *_s) { int left, slen, i; char *p, *s, *str; char *line, *n; if (!c || !_s) return; str = s = strdup (_s); for (i=0; ; i++) { line = getrow (s, &n); p = prefixline (c, &left); slen = R_MIN (left, strlen (line)); if (slen<1) break; if (!G (c->x-c->sx+slen, c->y-c->sy)) { // TODO : chop slen slen = (c->w - (c->x-c->sx)); if (slen<1) break; continue; } if (!G (c->x-c->sx-slen, c->y-c->sy)) continue; memcpy (p, line, slen); if (!n) break; s = n; if (!G (c->x-c->sx, c->y+1-c->sy)) break; } free (str); }
int getbox(int cell) { int row = getrow(cell); int col = getcol(cell); return 3*(row/3)+ col/3; }
void video_backspace(){ vidmem=(char *)MAIN_SCREEN_ADDRESS; if(maxpos>0){ vidmem[--writepos]=WHITE_TXT; vidmem[--writepos]=' '; } set_cursor(getrow(),getcol()); }
unt readSgiUsh ( ppus ret[4], unt *dW, unt *dH, int oX, int oY, char *path, unt flags ) { IMAGE *sgim; unt sW,sH,sD; size_t rsize; int y, yI; if ( ! (sgim=iopen(path,"r"))) die("readSgiUsh: iopen(%s) failed\n",path); sW = sgim->xsize; sH = sgim->ysize; sD = sgim->zsize; rsize = sizeof(unsigned short)*sW*sD; sH -= oY; *dH = sH; sW -= oX; *dW = sW; switch (sD) { case 1: { ppus dst; ret[0] = dst = rowMalUsh(0,0,sW,sH); ret[1] = NULL; for (yI = sH, y = oY; yI ; y++) getrow(sgim,dst[--yI],y,1); } break; case 3: { ppus gry, red, grn, blu; ret[0] = gry = rowMalUsh(0,0,sW,sH); ret[1] = red = rowMalUsh(0,0,sW,sH); ret[2] = grn = rowMalUsh(0,0,sW,sH); ret[3] = blu = rowMalUsh(0,0,sW,sH); for (yI = sH, y = oY; yI-- ; y++) { getrow(sgim, red[yI], y, 0); getrow(sgim, grn[yI], y, 1); getrow(sgim, blu[yI], y, 2); } gryRgbUsh(gry,red,grn,blu,sW,sH); } break; default: die("readSgiUsh [%s]: NOIMP for SGI image depth %u",__FILE__,sD); } iclose(sgim); if (sD == 3) return 4; else if (sD <= 1) return 1; else return 0; }
// get the n'th [row, col, square] (dependent on group_nr) set<gen_cell*>* gen_sudoku::getgroup(const uint n, const uint group_nr) const { set<gen_cell*>* group = new set<gen_cell*>(); switch(group_nr){ case 0: getrow(n, group); break; case 1: getcolumn(n, group); break; case 2: getsquare(n, group); break; } return group; }
int setallowed(int *board, int cc, int num) { int j, d; int row, col, box; board[cc] &= ~Allow; board[cc] = (board[cc] & ~Solve) | (num << 4); row = getrow(cc); for (j = 0; j < 9; j++) { if (board[rowind[row][j]] & allowbits[num]) { board[rowind[row][j]] &= ~allowbits[num]; if ((board[rowind[row][j]] & Allow) == 0) return(0); } } col = getcol(cc); for (j = 0; j < 9; j++) { if (board[colind[col][j]] & allowbits[num]) { board[colind[col][j]] &= ~allowbits[num]; if ((board[colind[col][j]] & Allow) == 0) return(0); } } box = getbox(cc); for (j = 0;j < 9;j++) { if (board[boxind[box][j]] & allowbits[num]) { board[boxind[box][j]] &= ~allowbits[num]; if ((board[boxind[box][j]] & Allow)==0) return(0); } } for (j = 0;j < 81; j++) for (d = 0; d < 9; d++) if ((board[j] & Allow) == allowbits[d]) if (!setallowed(board, j, d)) return(0); if (!boxcheck(board)||!rowcheck(board)||!colcheck(board)) return(0); for (j = 0; j < 81; j++) for (d = 0; d < 9; d++) if ((board[j] & Allow) == allowbits[d]) if (!setallowed(board, j, d)) return(0); return(1); }
int rowhit(jobqueue *k, int bank) { if(strncmp(row[bank].rowbuffer,getrow(k->addr),4)==0) { return 1; } else { return 0; } }
void * rowReadSGI(char *path, unt *sW, unt *sH, unt *deep, unt flags) { IMAGE *sgim; ush *rowbuf; void *ret=NULL; unt xsize, ysize, zsize, y, yI, type = flags & MM_TYPE; size_t rsize; if ( ! (sgim=iopen(path,"r"))) die("rowReadSGI: iopen(%s) failed\n",path); *sW = xsize = sgim->xsize; *sH = ysize = sgim->ysize; *deep = zsize = sgim->zsize; rsize = sizeof(unsigned short)*xsize*zsize; if (! (rowbuf = (unsigned short *)malloc(rsize))) die("rowReadSGI(%s): malloc(%u)",path,rsize); switch (type) { case MM_UNC: { unc **dst = rowMalUnc(0,0,xsize,ysize); ret = dst; for (yI = ysize, y = 0; yI ; y++) { getrow(sgim,rowbuf,y,1); uncUsh(dst[--yI],rowbuf,xsize); } } break; case MM_FLT: { flt **dst = rowMalFlt(0,0,xsize,ysize); ret = dst; for (yI = ysize, y = 0; yI ; y++) { getrow(sgim,rowbuf,y,1); fltUsh(dst[--yI],rowbuf,xsize); } } break; default: die("rowReadSGI(%s): NOIMP for flags:%d",path,flags); } free(rowbuf); iclose(sgim); return ret; }
static int getgifpix( /* get a single pixel from our picture */ int x, int y ) { getrow(y); if (greyscale) return((normbright(scanln[x])*ncolors)>>8); if (pixscan != NULL) return(pixscan[x]); return(samplefac ? neu_map_pixel(scanln[x]) : map_pixel(scanln[x])); }
static void ffty( void ) { fint l, lp2; float row1[2*SIZE], row2[2*SIZE]; lp2 = 2 * NPTX; /* number of points in row */ /* * separate the data into even and odd subsequences, * transform each, phase shift the odd transform and * add them. this recursive formulation of the FFT is * here written iteratively, from the innermost * subtransform outward. */ for ( l = 0; l < LOGP2Y; l++ ) { fint i, i2l, istep, q; i2l = POWTAB[l]; istep = 2 * i2l; q = POWTAB[ MAXP2 - l - 1 ]; for ( i = 0; i < i2l; i++ ) { fint ia, ib, itab; float wr, wi; itab = i * q; /* get table entry */ wr = COSTAB[itab]; /* get cosine from table */ wi = SINTAB[itab] * SIGN; /* get sine from table */ for ( ia = i; ia < NPTY; ia += istep ) { ib = ia + i2l; getrow( row1, lp2, ia ); getrow( row2, lp2, ib ); fxcx( wr, wi, row1, row2, NPTX ); putrow( row1, lp2, ia ); putrow( row2, lp2, ib ); } } } }
void *readSGI(IMAGE *image, unsigned order, unsigned type) { int xsize = image->xsize; int ysize = image->ysize; int zsize = image->zsize; size_t count = xsize*ysize*zsize; int y,z; switch (type) { case MM_USH: { ush *mem; mallocAss(mem,ush,count); for (z=0; z < zsize; z++) { for (y=0; y < ysize; y++) { getrow(image,rowbuf,y,z); memcpy((void*)(mem+y*xsize),(void*)rowbuf,sizeof(short)*xsize); } } return mem; } case MM_CHR: case MM_UNC: { unc *mem; mallocAss(mem,unc,count); for (z=0; z < zsize; z++) { for (y=0; y < ysize; y++) { getrow(image,rowbuf,y,z); stoc(rowbuf,charbuf,xsize); memcpy((void*)(mem+y*xsize),(void*)charbuf,sizeof(unc)*xsize); } } return mem; } default: die("readSGI: NOIMP for type %d",type); return NULL; } }
void solve() { n = id_col + id_row + 2; int s = n - 1, t = n; init(); for(int i = 0 ; i < nn ;i++) for(int f = 0 ; f < m;f++) if(true == white[i][f]) { pos[i][f] = size; add(getcol(i,f),getrow(i,f) + id_col,8); } for(int i = 1;i <= id_col ;i++) add(s,i,flow_col[i]); for(int i = 1;i <= id_row; i++) add(id_col+i, t, flow_row[i]); sap(s,t); ans(); }
void video_tab(int fd){ int i=0; int size=0; int * pos; if(fd==STDOUT){ vidmem=(char *)MAIN_SCREEN_ADDRESS; size=MAIN_SCREEN_SIZE; pos=&writepos; }else if(fd==REGOUT){ vidmem=(char *)VIDMEM_ADDRESS; size=UPPER_SCREEN_SIZE; pos=&upperWritepos; } for(i=0; i<TAB_LENGTH && i<size; i++){ insertKey(' ',pos, vidmem); } if(fd==STDOUT){ set_cursor(getrow(),getcol()); } }
void writeToScreen(char key,int fd){ int size; int * pos; if(fd==STDOUT){ vidmem=(char *)MAIN_SCREEN_ADDRESS; size= MAIN_SCREEN_SIZE; if(writepos == size){ scrollMainScreen(); } insertKey(key,&writepos,vidmem); set_cursor(getrow(),getcol()); }else if(fd==REGOUT){ vidmem=(char *)VIDMEM_ADDRESS; size= (UPPER_SCREEN_SIZE)-(LINE_SIZE); if(upperWritepos == size){ upperWritepos = 0; } insertKey(key,&upperWritepos,vidmem); } }
SbBool ReadSGIImage(const SoInput& in, int &w, int &h, int &nc, unsigned char *&bytes) { i_seterror(errfunc); IMAGE *image_in; int i, j, row; if ( (image_in = fiopen(fileno(in.getCurFile()), "r")) == NULL) return FALSE; w = image_in->xsize; h = image_in->ysize; nc = image_in->zsize; bytes = new unsigned char[w*h*nc]; short *rbuf = new short[w]; int readOK = TRUE; for (row = 0; row < h; row++) { for (i = 0; i < nc; i++) { if (getrow(image_in, rbuf, row, i) < 0) { row = h; // Don't read any more rows readOK = FALSE; break; } for (j = 0; j < w; j++) { bytes[row*w*nc + j*nc + i] = (unsigned char) rbuf[j]; } } } delete [] rbuf; iclose(image_in); return TRUE; }
R_API void r_cons_canvas_write(RConsCanvas *c, const char *_s) { int left, slen; char *p, *s, *str; char *line, *n; int x; if (!c || !_s || !*_s) return; str = n = strdup (_s); do { s = n; line = getrow (s, &n); if (!line) break; if (*line == '\0' && n) continue; p = prefixline (c, &left); slen = R_MIN (left, strlen (line)); if (slen < 1) break; x = c->x - c->sx; if (!G (x, c->y - c->sy)) continue; stamp_attr(c, slen); memcpy (p, line, slen); if (!n) break; } while (G (c->x - c->sx, c->y + 1 - c->sy)); free (str); }
// return a set of cells in the same row as cell (x,y) void gen_sudoku::getrow(const uint x, const uint y, set<gen_cell*>* group) const{ getrow(y,group); }
static int cpContig(IMAGE* in, TIFF* out) { tdata_t buf = _TIFFmalloc(TIFFScanlineSize(out)); short *r = NULL; int x, y; if (in->zsize == 3) { short *g, *b; r = (short *)_TIFFmalloc(3 * in->xsize * sizeof (short)); g = r + in->xsize; b = g + in->xsize; for (y = in->ysize-1; y >= 0; y--) { uint8* pp = (uint8*) buf; getrow(in, r, y, 0); getrow(in, g, y, 1); getrow(in, b, y, 2); for (x = 0; x < in->xsize; x++) { pp[0] = r[x]; pp[1] = g[x]; pp[2] = b[x]; pp += 3; } if (TIFFWriteScanline(out, buf, in->ysize-y-1, 0) < 0) goto bad; } } else if (in->zsize == 4) { short *g, *b, *a; r = (short *)_TIFFmalloc(4 * in->xsize * sizeof (short)); g = r + in->xsize; b = g + in->xsize; a = b + in->xsize; for (y = in->ysize-1; y >= 0; y--) { uint8* pp = (uint8*) buf; getrow(in, r, y, 0); getrow(in, g, y, 1); getrow(in, b, y, 2); getrow(in, a, y, 3); for (x = 0; x < in->xsize; x++) { pp[0] = r[x]; pp[1] = g[x]; pp[2] = b[x]; pp[3] = a[x]; pp += 4; } if (TIFFWriteScanline(out, buf, in->ysize-y-1, 0) < 0) goto bad; } } else { uint8* pp = (uint8*) buf; r = (short *)_TIFFmalloc(in->xsize * sizeof (short)); for (y = in->ysize-1; y >= 0; y--) { getrow(in, r, y, 0); for (x = in->xsize-1; x >= 0; x--) pp[x] = r[x]; if (TIFFWriteScanline(out, buf, in->ysize-y-1, 0) < 0) goto bad; } } if (r) _TIFFfree(r); _TIFFfree(buf); return (1); bad: if (r) _TIFFfree(r); _TIFFfree(buf); return (0); }
static void outmap( fint lpt , /* number of points in X */ fint mpt , /* number of points in Y */ fint lmin , /* lower x map coordinate */ fint mmin , /* lower y map coordinate */ fchar set[] , /* set name */ fint sub[] , /* subset levels */ fint nset , /* number of sets */ fint modo ) /* output mode, amp./pha. or cos./sin. */ { fint i, itab, k, m, md, mi, mj, ms, mph, mphh; fint q, r, ri, rj, rs, row; fint n; fint count[MAXSET], nblank[MAXSET]; float rbuf[2*SIZE], cbuf[2*SIZE]; float datamax[MAXSET], datamin[MAXSET]; float fr, fi, zr, zi; for ( k = 0; k < nset; count[k++] = 0 ); if ( FORM == -1 ) { /* complex ---FFT---> real */ k = 0; /* set number */ rs = MIN( mpt, ( 2 * SIZE ) / lpt ); /* number of rows per pass */ for ( r = 0 ; r < mpt; r += rs ) {/* loop to get data from scratch file */ getrow( rbuf, rs * lpt, r / rs ); md = 0; do { m = shiftr( mmin, mpt, r + md ); ms = MIN( rs - md, mpt + mmin - m ); i = md * lpt; writxy( set[k], sub[k], lmin, m, &rbuf[i], lpt, ms ); md = md + ms; } while ( md != rs ); n = lpt * rs; minmax3_c( rbuf, &n, &datamin[k], &datamax[k], &nblank[k], &count[k] ); } } else if ( FORM == 0 ) { /* real ---FFT---> complex */ q = POWTAB[ MAXP2 - LOGP2Y - 1 ]; /* table offset factor */ mph = mpt / 2; /* y-dimension of transform */ mphh = mph / 2 + 1; getrow( cbuf, 2 * lpt, 0 ); /* create row MPH */ putrow( cbuf, 2 * lpt, mph ); fr = 0.5 * SIGN; fi = 0.5; for ( ri = 0; ri < mphh; ri++ ) { rj = mph - ri; itab = ri * q; /* calculate table position */ zr = 0.5 - fr * SINTAB[itab]; zi = fi * COSTAB[itab]; getrow( cbuf, 2 * lpt, ri ); getrow( rbuf, 2 * lpt, rj ); fxrl( zr, zi, cbuf, rbuf, ri, rj, lpt ); /* fixup real ---> complex */ fftx( cbuf ); /* do the FFT in x-direction */ vector( cbuf, lpt, 1, modo ); mi = shiftr( mmin, mpt, ri ); for ( k = 0; k < nset; k++ ) { i = k * lpt; writxy( set[k], sub[k], lmin, mi, &cbuf[i], lpt , 1 ); minmax3_c( &cbuf[i], &lpt, &datamin[k], &datamax[k], &nblank[k], &count[k] ); } if ( ri > 0 ) { /* do not double lines */ mirror( cbuf, lpt, -lmin ); mi = shiftr( mmin, mpt, mpt - ri ); for ( k = 0; k < nset; k++ ) { i = k * lpt; writxy( set[k], sub[k], lmin, mi, &cbuf[i], lpt, 1 ); minmax3_c( &cbuf[i], &lpt, &datamin[k], &datamax[k], &nblank[k], &count[k] ); } } if ( ri == rj ) break; /* we've done it */ fftx( rbuf ); /* do the FFT in x-direction */ vector( rbuf, lpt, 1, modo ); mj = shiftr( mmin, mpt, rj ); for ( k = 0; k < nset; k++ ) { i = k * lpt; writxy( set[k], sub[k], lmin, mj, &rbuf[i], lpt, 1 ); minmax3_c( &rbuf[i], &lpt, &datamin[k], &datamax[k], &nblank[k], &count[k] ); } if ( rj < mph ) { /* do not double lines */ mirror( rbuf, lpt, -lmin ); mj = shiftr( mmin, mpt, mpt - rj ); for ( k = 0; k < nset; k++ ) { i = k * lpt; writxy( set[k], sub[k], lmin, mj, &rbuf[i], lpt, 1 ); minmax3_c( &rbuf[i], &lpt, &datamin[k], &datamax[k], &nblank[k], &count[k] ); } } } } else if ( FORM == 1 ) { /* complex ---FFT---> complex */ for ( row = 0; row < mpt; row++ ) { getrow( cbuf, 2 * lpt, row ); vector( cbuf, lpt, 1, modo ); m = shiftr( mmin, mpt, row ); for ( k = 0; k < nset; k++ ) { i = k * lpt; writxy( set[k], sub[k], lmin, m, &cbuf[i], lpt, 1 ); minmax3_c( &cbuf[i], &lpt, &datamin[k], &datamax[k], &nblank[k], &count[k] ); } } } { fint change = 1; fint one = 1; for ( k = 0; k < nset; k++ ) { wminmax_c( set[k], &sub[k], &datamin[k], &datamax[k], &nblank[k], &one, &change ); } } }