/* This snippet of code (all_get_image) defines images 1 through 9,
   where the processors are in a "v x w" logical processor grid, each
    holding a "q x r" tile of pixels.
 */

int mapRow(int rowsGrid, int colsGrid, int proc_id) {
/* Return the row of processor proc_id in a rowsGrid x colsGrid
   processor 2d array */
    return(proc_id / colsGrid);
}
   
int mapCol(int rowsGrid, int colsGrid, int proc_id) {
/* Return the column of processor proc_id in a rowsGrid x colsGrid
   processor 2d array */
    return(proc_id % colsGrid);
}

#define BARSIZE_DEFAULT 5

/***************************************************/
void all_get_image(int v, int w, int q, int r,
		   int X[v][w]::[q][r], int k, int image_option) 
/***************************************************/
{
    register int
	i, j,          /* each local pixel */
	ii, jj,        /* my logical grid */
	I, J,          /* a pixel's position */
	barSize;

    int	(*locX)[r];

    double n, m,
	m1[6], m2[6];

    locX = tolocal(X[mapRow(v,w,MYPROC)][mapCol(v,w,MYPROC)]);

    barSize = BARSIZE_DEFAULT;

    n = (double) (v * q);
    m = (double) (w * r);
    
    m1[0] = 0.125 * n;
    m1[1] = 0.375 * n;
    m1[2] = 0.625 * n;
    m1[3] = 0.875 * n;
    m1[4] = 0.5   * n;
    m1[5] = 0.75  * n;

    m2[0] = 0.125 * m;
    m2[1] = 0.375 * m;
    m2[2] = 0.625 * m;
    m2[3] = 0.875 * m;
    m2[4] = 0.5   * m;
    m2[5] = 0.75  * m;

    ii   = mapRow(v,w,MYPROC);
    jj   = mapCol(v,w,MYPROC);

/**********************************************/
/* Initialize Image Array X                   */
/**********************************************/

    for (i=0 ; i<q ; i++) {
	I = ii*q + i;
	for (j=0 ; j<r ; j++) {
	    J = jj*r + j;
	    switch (image_option) {
	    case 1 : locX[i][j] =    /* Rows */
		((I % (2*barSize)) < barSize); break;
	    case 2 : locX[i][j] =    /* Columns */
		((J % (2*barSize)) < barSize); break;
	    case 3 : locX[i][j] =    /* Diagonals / */
		(((I+J) % (2*barSize)) < barSize); break;
	    case 4 : locX[i][j] =    /* Diagonals \ */
		(((I>J ? I-J : J-I) % (2*barSize)) < barSize); break;
	    case 5 : locX[i][j] =    /* Cross */
		((I>=m1[0])&&(I<=m1[3])&&(J>=m2[1])&&(J<=m2[2]) ||
		 (I>=m1[1])&&(I<=m1[2])&&(J>=m2[0])&&(J<=m2[3]));
		break;
	    case 6 : locX[i][j] =    /* Disc */
		sqrt((I-m1[4])*(I-m1[4]) + (J-m2[4])*(J-m2[4]))
		<= (n>m? m2[5] : m1[5])*0.4;
		break;
	    case 7 : locX[i][j] =    /* Concentric Circles */
		(int)floor(sqrt((I-m1[4])*(I-m1[4]) + (J-m2[4])*(J-m2[4])))
		% (2*barSize) < barSize;
		break;
	    case 8 : locX[i][j] =    /* Four Boxes */
		((I>=m1[0])&&(I<=m1[3])&&(J>=m2[0])&&(J<=m2[3])) &&
		(!((I>=m1[0])&&(I<=m1[3])&&(J>=m2[1])&&(J<=m2[2]) ||
		 (I>=m1[1])&&(I<=m1[2])&&(J>=m2[0])&&(J<=m2[3])));
		break;
	    case 9 : locX[i][j] =    /* Spiral */
		(int)floor(sqrt(( J<=m2[4] ?  /* left half? */
		   ((I-m1[4]-barSize)*(I-m1[4]-barSize)) :
		   ((I-m1[4]+barSize)*(I-m1[4]+barSize)) ) +
		   (J-m2[4])*(J-m2[4]))) % (barSize) < barSize/2;
		break;
	    default : locX[i][j] = 1;
	    }
	}
    }

    barrier();
}