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 );
}
}
}
