void attempt_ten(int dim, pixel *src, pixel *dst)
{
int a,b,i,j;
int sav=0; //LICM
int sav1=0; //LICM
int sav2=0; //LICM
int adj_dim = dim-1;
for (j=0; j<dim; j+=32)
{
sav = adj_dim-j;
for (i=0; i<dim; i+=8)
{
//Using for loop unrolling
for (b=0; b<32; b++)
{
sav1 = sav - b;
sav2 = j+b;
//Use for loop unrolling
for (a=0; a<8; a++)
dst[RIDX(sav1, i+a, dim)] = src[RIDX(i+a, sav2, dim)];
}
}
}
}
static pixel check_average(int dim, int i, int j, pixel *src) {
pixel result;
int num = 0;
int ii, jj;
int sum0, sum1, sum2;
int top_left_i, top_left_j;
int bottom_right_i, bottom_right_j;
top_left_i = max(i-1, 0);
top_left_j = max(j-1, 0);
bottom_right_i = min(i+1, dim-1);
bottom_right_j = min(j+1, dim-1);
sum0 = sum1 = sum2 = 0;
for(ii=top_left_i; ii <= bottom_right_i; ii++) {
for(jj=top_left_j; jj <= bottom_right_j; jj++) {
num++;
sum0 += (int) src[RIDX(ii,jj,dim)].red;
sum1 += (int) src[RIDX(ii,jj,dim)].green;
sum2 += (int) src[RIDX(ii,jj,dim)].blue;
}
}
result.red = (unsigned short) (sum0/num);
result.green = (unsigned short) (sum1/num);
result.blue = (unsigned short) (sum2/num);
return result;
}
void naive_rotate(int dim, pixel *src, pixel *dst)
{
int i, j;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
dst[RIDX(dim-1-j, i, dim)] = src[RIDX(i, j, dim)];
}
void rotate3(int dim, pixel *src, pixel *dst)
{
int i,j, ii;
for (i = 0; i < dim; i = i + 16)
{
for (j = 0; j < dim; j++)
{
for(ii = 0; ii < 16; ii++)
{
dst[RIDX(dim-1-j, i+ii, dim)] = src[RIDX(i+ii, j, dim)];
}
}
}
/*
blocking
*/
}
/*
* check_rotate - Make sure the rotate actually works.
* The orig array should not have been tampered with!
*/
static int check_rotate(int dim)
{
int err = 0;
int i, j;
int badi = 0;
int badj = 0;
pixel orig_bad = {0}, res_bad = {0};
/* return 1 if the original image has been changed */
if (check_orig(dim))
return 1;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
if (compare_pixels(orig[RIDX(i,j,dim)],
result[RIDX(dim-1-j,i,dim)])) {
err++;
badi = i;
badj = j;
orig_bad = orig[RIDX(i,j,dim)];
res_bad = result[RIDX(dim-1-j,i,dim)];
}
if (err) {
printf("\n");
printf("ERROR: Dimension=%d, %d errors\n", dim, err);
printf("E.g., The following two pixels should have equal value:\n");
printf("src[%d][%d].{red,green,blue} = {%d,%d,%d}\n",
badi, badj, orig_bad.red, orig_bad.green, orig_bad.blue);
printf("dst[%d][%d].{red,green,blue} = {%d,%d,%d}\n",
(dim-1-badj), badi, res_bad.red, res_bad.green, res_bad.blue);
}
return err;
}
void rotate(int dim, pixel *src, pixel *dst)
{
int i,j;
pixel *dptr,*sptr;
for(i=0;i<dim;i+=16)
for(j=dim-1;j>=0;j--){
dptr=dst+RIDX(dim-1-j,i,dim);
sptr=src+RIDX(i,j,dim);
*(dptr)=*(sptr);sptr+=dim;
*(dptr+1)=*(sptr);sptr+=dim;
*(dptr+2)=*(sptr);sptr+=dim;
*(dptr+3)=*(sptr);sptr+=dim;
*(dptr+4)=*(sptr);sptr+=dim;
*(dptr+5)=*(sptr);sptr+=dim;
*(dptr+6)=*(sptr);sptr+=dim;
*(dptr+7)=*(sptr);sptr+=dim;
*(dptr+8)=*(sptr);sptr+=dim;
*(dptr+9)=*(sptr);sptr+=dim;
*(dptr+10)=*(sptr);sptr+=dim;
*(dptr+11)=*(sptr);sptr+=dim;
*(dptr+12)=*(sptr);sptr+=dim;
*(dptr+13)=*(sptr);sptr+=dim;
*(dptr+14)=*(sptr);sptr+=dim;
*(dptr+15)=*(sptr);
}
}
void naive_rotate_unrolled(int dim, pixel *src, pixel *dst)
{
int i, j;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j+=4)
{
dst[RIDX(dim-1-j, i, dim)] = src[0];
dst[RIDX(dim-1-(j + 1), i, dim)] = src[1];
dst[RIDX(dim-1-(j + 2), i, dim)] = src[2];
dst[RIDX(dim-1-(j + 3), i, dim)] = src[3];
// dst[RIDX(dim-1-(j + 4), i, dim)] = *(src + 4);
// dst[RIDX(dim-1-(j + 5), i, dim)] = *(src + 5);
// dst[RIDX(dim-1-(j + 6), i, dim)] = *(src + 6);
// dst[RIDX(dim-1-(j + 7), i, dim)] = *(src + 7);
// dst[RIDX(dim-1-(j + 8), i, dim)] = *(src + 8);
// dst[RIDX(dim-1-(j + 9), i, dim)] = *(src + 9);
// dst[RIDX(dim-1-(j + 10), i, dim)] = *(src + 10);
// dst[RIDX(dim-1-(j + 11), i, dim)] = *(src + 11);
// dst[RIDX(dim-1-(j + 12), i, dim)] = *(src + 12);
// dst[RIDX(dim-1-(j + 13), i, dim)] = *(src + 13);
// dst[RIDX(dim-1-(j + 14), i, dim)] = *(src + 14);
// dst[RIDX(dim-1-(j + 15), i, dim)] = *(src + 15);
src += 4;
}
}
void rotate2(int dim, pixel *src, pixel *dst)
{
int i,j, ii;
for (i = 0; i < dim; i = i + 16)
{
for (j = 0; j < dim; j++)
{
for(ii = 0; ii < 16; ii++)
{
dst[RIDX(dim-1-j, i+ii, dim)] = src[RIDX(i+ii, j, dim)];
}
}
}
/*
unrolling the first loop offers ~ 245% increase in speedup by completing 16
rotations per iteration of i instead of 1.
*/
}
void attempt_two(int dim, pixel *src, pixel *dst)
{
int i, j;
for (j = 0; j < dim; j++)
for (i = 0; i < dim; i++)
dst[RIDX(dim-1-j, i, dim)] = src[RIDX(i, j, dim)];
}
void rotate2(int dim, pixel *src, pixel *dst) {
int i, j, ridx11, ridx12, ridx21, ridx22, dim2 = dim<<1;
/*if(src == dst) { printf("Aliasing!\n"); return; }*/
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j+=32) {
ridx11 = RIDX(dim-1-j, i, dim);
ridx12 = RIDX(dim-2-j, i, dim);
ridx21 = RIDX(i, j, dim);
ridx22 = RIDX(i, j, dim) + 1;
dst[ridx11] = src[ridx21];
dst[ridx12] = src[ridx22];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
dst[(ridx11-=dim2)] = src[ridx21+=2];
dst[(ridx12-=dim2)] = src[ridx22+=2];
}
}
void attempt_three(int dim, pixel *src, pixel *dst)
{
int i, j, i1, j1;
int x = dim-1;
int T = dim/4;
for (j = 0; j < dim; j+=8)
for (i = 0; i < dim; i+=T)
for (j1 = j; j1 < MIN(dim, j + 8); j1++)
for (i1 = i; i1 < MIN(dim, i + T); i1++)
dst[RIDX(x - j1, i1, dim)] = src[RIDX(i1, j1, dim)];
}
void smooth4(int dim, pixel *src, pixel *dst)
{
int i,j,x;
for (i = 0; i < dim; i+=16)
{
for (j = 0; j < dim; j++)
{
for(x = 0; x<16;x++)
{
int ii, jj;
pixel_sum sum;
pixel_sum *sum1;
sum1 = ∑
pixel current_pixel;
pixel *curr;
curr = ¤t_pixel;
//initialize_pixel_sum(&sum);
//pixel_sum *sum;
sum1->red = sum1->green = sum1->blue = 0;
sum1->num = 0;
for(ii = max(i+x-1, 0); ii <= min(i+x+1, dim-1); ii++)
{
for(jj = max(j-1, 0); jj <= min(j+1, dim-1); jj++)
{
/*accumulate_sum(&sum, src[RIDX(ii, jj, dim)]);*/
pixel p = src[RIDX(ii, jj, dim)];
/*pixel pp = &p;*/
sum1->red += (int) p.red;
sum1->green += (int) p.green;
sum1->blue += (int) p.blue;
sum1->num++;
}
}
curr->red = (unsigned short) (sum.red/sum.num);
curr->green = (unsigned short) (sum.green/sum.num);
curr->blue = (unsigned short) (sum.blue/sum.num);
dst[RIDX(i, j, dim)] = current_pixel;
}
}
}
}
void rotate(int dim, pixel *src, pixel *dst)
{
int i, j, i1, j1;
int x = dim-1;
int W = 8;
int L = 128;
for (j = 0; j < dim; j+=L)
for (i = 0; i < dim; i+=W)
for (j1 = j; j1 < MIN(dim, j + L); j1++)
for (i1 = i; i1 < MIN(dim, i + W); i1++)
dst[RIDX(x - j1, i1, dim)] = src[RIDX(i1, j1, dim)];
}
void rotate1(int dim, pixel *src, pixel *dst) {
int i, j, ridx1, ridx2;
/*if(src == dst) { printf("Aliasing!\n"); return; }*/
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j+=32) {
ridx1 = RIDX(dim-1-j, i, dim);
ridx2 = RIDX(i, j, dim);
dst[ridx1] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
dst[(ridx1-=dim)] = src[ridx2++];
}
}
void line_7(int dim, pixel *src, pixel *dst) {
int x0 = 0;
int y0 = floor (dim / 3); /* left endpoint */
int x1 = dim - 1;
int y1 = ceil (dim - 1 - dim / 3); /* right endpoint */
double dy = y1 - y0;
double dx = x1 - x0;
double slope = dy / dx;
double slope2 = slope*2;
double slope3 = slope*3;
double slope4 = slope*4;
double slope5 = slope*5;
double slope6 = slope*6;
double slope7 = slope*7;
double slope8 = slope*8;
double y = y0;
int x = x0;
pixel max = *maximum_7(dim, src);
for (; x <= x1; x+=8) {
dst[RIDX(x, (int)rint(y), dim)] = max;
dst[RIDX(x+1, (int)rint(y+slope), dim)] = max;
dst[RIDX(x+2, (int)rint(y+slope2), dim)] = max;
dst[RIDX(x+3, (int)rint(y+slope3), dim)] = max;
dst[RIDX(x+4, (int)rint(y+slope4), dim)] = max;
dst[RIDX(x+5, (int)rint(y+slope5), dim)] = max;
dst[RIDX(x+6, (int)rint(y+slope6), dim)] = max;
dst[RIDX(x+7, (int)rint(y+slope7), dim)] = max;
y += slope8;
}
}
void new_rotate(int dim, pixel *src, pixel *dst, int iB, int jB)
{
int i, j, ii, jj, ii_limit, jj_limit;
for (i = 0; i < dim; i+=iB)
{
ii_limit = MIN(dim, i+iB);
for (j = 0; j < dim; j+=jB)
{
jj_limit = MIN(dim, j+jB);
for (ii = i; ii < ii_limit; ii++)
{
for (jj = j; jj < jj_limit; jj++)
{
dst[RIDX(dim-1-ii, jj, dim)] = src[RIDX(jj, ii, dim)];
}
ii++;
for (jj = j; jj < jj_limit; jj++)
{
dst[RIDX(dim-1-ii, jj, dim)] = src[RIDX(jj, ii, dim)];
}
ii++;
for (jj = j; jj < jj_limit; jj++)
{
dst[RIDX(dim-1-ii, jj, dim)] = src[RIDX(jj, ii, dim)];
}
ii++;
for (jj = j; jj < jj_limit; jj++)
{
dst[RIDX(dim-1-ii, jj, dim)] = src[RIDX(jj, ii, dim)];
}
}
}
}
}
/* Make sure the orig array is unchanged */
static int check_orig(int dim)
{
int i, j;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
if (compare_pixels(orig[RIDX(i,j,dim)], copy_of_orig[RIDX(i,j,dim)])) {
printf("\n");
printf("Error: Original image has been changed!\n");
return 1;
}
return 0;
}
void attempt_eleven(int dim, pixel *src, pixel *dst) {
int tile_num = 2;
int tile_size = dim/tile_num;
int i, j, x, y;
for (x=0; x<tile_num; x++){
int baseI = x*tile_size;
for (y=0; y<tile_num; y++){
int baseJ = y*tile_size;
for (i = 0; i < tile_size; i++)
for (j = 0; j < tile_size; j++)
dst[RIDX(dim-1-baseJ-j, baseI+i, dim)] = src[RIDX(baseI+i, baseJ+j, dim)];
}
}
}
void rotate3(int dim, pixel *src, pixel *dst) {
int i, j, i5, j5, ii, jj, div = dim >> 5; /* dim/32 */
for(i = 0; i < div; i++) {
i5 = i<<5;
for(j = 0; j < div; j++) { /* which block */
j5 = j<<5;
for(ii = 0; ii < 32; ii++) {
for(jj = 0; jj < 32; jj++) {
dst[RIDX(dim-1-(j5+jj), i5+ii, dim)] = src[RIDX(i5+ii, j5+jj, dim)];
}
}
}
}
}
void less_less_naive_rotate(int dim, pixel *src, pixel *dst)
{
int i, j, k, l;
int blocksizei = 16;
int blocksizej = 8;
for (i = 0; i < dim; i += blocksizei) {
for (j = 0; j < dim; j += blocksizej) {
for (k = i; k < i + blocksizei; k++) {
for (l = j; l < j + blocksizej; l++) {
dst[RIDX(l, dim-1-k, dim)] = src[RIDX(k, l, dim)];
}
}
}
}
}
/*
* maximum - Returns the adress of the pixel with the highest intensity in src
*/
static pixel *maximum(int dim, pixel *src)
{
int ii, jj;
pixel *maxi = src;
int darkness = 0;
for(jj = dim-1; jj >= 0; jj--)
for(ii = 0; ii <= dim-1; ii++)
if (intensity (src[RIDX(ii, jj, dim)]) > darkness)
{
darkness = intensity (src[RIDX(ii, jj, dim)]);
maxi = &(src[RIDX(ii, jj, dim)]);
}
return maxi;
}
/******************************************************
* Your different versions of the rotate kernel go here
******************************************************/
void my_rotate(int dim, pixel *src, pixel *dst)
{
int i, j, i1, j1, im, jm;
int block=32;//blocking the Matrix
for(i=0; i<dim; i+=block)
for(j=0; j<dim; j+=block)
{
//block*block mini matrix
im = i+block;
for(i1=i; i1<i+block; i1++) {
jm = j+block;
for(j1=j; j1<j+block; j1++)
dst[RIDX(i1, j1, dim)] = src[RIDX(j1, dim-i1-1, dim)];
}
}
}
void attempt_four(int dim, pixel *src, pixel *dst)
{
//tiling with square matrix
int register B = 32;
//walk through blocks
int register i,j,k,l;
int register ib, jb;
int register dimMinusOne = dim-1;
int register kdim;
for(i=0; i<dim; i+=B){
for(j=0;j<dim; j+=B){
ib = i+B;
jb = j+B;
//walk through sub blocks
for(k=i;k<ib;k++){
kdim = k*dim;
for(l=j;l<jb;l++){
dst[RIDX(dimMinusOne-l, k, dim)] = src[kdim+l];
}
}
}
}
}
void rotate6(int dim, pixel *src, pixel *dst) {
int i, j, i5, j5, ii, div = dim >> 5; /* dim/32 */
pixel *source, *dest;
for(i = 0; i < div; i++) {
i5 = i<<5;
for(j = 0; j < div; j++) { /* which block */
j5 = j<<5;
for(ii = 0; ii < 32; ii++) {
source = src+RIDX(i5+ii, j5, dim);
dest = dst+RIDX(dim-1-(j5), i5+ii, dim)+dim;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
*(dest-=dim) = *source++;
}
}
}
}
void attempt_four(int dim, pixel *src, pixel *dst) {
if (dim < 256)
return naive_rotate(dim, src, dst);
int tile_num = 256;
int tile_size = dim/tile_num;
int i, j, x, y;
for (x=0; x<tile_num; x++){
int baseI = x*tile_size;
for (y=0; y<tile_num; y++){
int baseJ = y*tile_size;
for (i = 0; i < tile_size; i++)
for (j = 0; j < tile_size; j++)
dst[RIDX(dim-1-baseJ-j, baseI+i, dim)] = src[RIDX(baseI+i, baseJ+j, dim)];
}
}
}
void naive_smooth(int dim, pixel *src, pixel *dst)
{
int i, j;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
dst[RIDX(i, j, dim)] = avg(dim, i, j, src);
}
void attempt_four(int dim, pixel *src, pixel *dst)
{
int i, j;
int ii, jj;
int block_size = 32;
for (j = 0; j < dim; j+=block_size) {
for (i = 0; i < dim; i+=block_size) {
for (jj=j; jj < j+block_size; jj++) {
for (ii=i; ii < i+block_size; ii++) {
dst[RIDX(dim - 1 - jj, ii, dim)] = src[RIDX(ii, jj, dim)];
}
}
}
}
}
void attempt_three(int dim, pixel *src, pixel *dst)
{
//tiling with square matrix
int register B = 32;
//walk through blocks
int register i,j,k,l;
for(i=0; i<dim; i+=B){
for(j=0;j<dim; j+=B){
//walk through sub blocks
for(k=i;k<i+B;k++)
for(l=j;l<j+B;l++)
dst[RIDX(dim-1-l, k, dim)] = src[RIDX(k, l, dim)];
}
}
}
void rotate4(int dim, pixel *src, pixel *dst) {
int i, j, i5, j5, ii, ridix, rid2, div = dim >> 5; /* dim/32 */
for(i = 0; i < div; i++) {
i5 = i<<5;
for(j = 0; j < div; j++) { /* which block */
j5 = j<<5;
for(ii = 0; ii < 32; ii++) {
ridix = RIDX(i5+ii, j5, dim);
rid2 = RIDX(dim-1-(j5), i5+ii, dim)+dim;
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
dst[(rid2-=dim)] = src[ridix++];
}
}
}
}
/*
* check_smooth - Make sure the smooth function actually works. The
* orig array should not have been tampered with!
*/
static int check_smooth(int dim) {
int err = 0;
int i, j;
int badi = 0;
int badj = 0;
pixel right, wrong;
/* +++++ egm 10/26/2005
* Added initialization code to quiet warnings
* from gcc 4.0.2 compiler.
* -----
*/
right.red = right.green = right.blue = 0;
wrong.red = wrong.green = wrong.blue = 0;
/* return 1 if original image has been changed */
if (check_orig(dim))
return 1;
for (i = 0; i < dim; i++) {
for (j = 0; j < dim; j++) {
pixel smoothed = check_average(dim, i, j, orig);
if (compare_pixels(result[RIDX(i,j,dim)], smoothed)) {
err++;
badi = i;
badj = j;
wrong = result[RIDX(i,j,dim)];
right = smoothed;
}
}
}
if (err) {
printf("\n");
printf("ERROR: Dimension=%d, %d errors\n", dim, err);
printf("E.g., \n");
printf("You have dst[%d][%d].{red,green,blue} = {%d,%d,%d}\n",
badi, badj, wrong.red, wrong.green, wrong.blue);
printf("It should be dst[%d][%d].{red,green,blue} = {%d,%d,%d}\n",
badi, badj, right.red, right.green, right.blue);
}
return err;
}
