/* magnify.c */

#define MAX_PIXEL_VALUE   255
#define MAX_IN_WIDTH      /* INSERT APPROPRIATE VALUE HERE. */
#define MAX_IN_HEIGHT     /* INSERT APPROPRIATE VALUE HERE. */
#define MAX_OUT_WIDTH     /* INSERT APPROPRIATE VALUE HERE. */
#define MAX_OUT_HEIGHT    /* INSERT APPROPRIATE VALUE HERE. */
#define MAX_OUT_DIMENSION ((MAX_OUT_WIDTH > MAX_OUT_HEIGHT) ? \
                           MAX_OUT_WIDTH : MAX_OUT_HEIGHT)

float a;

float C0(float t)
{
  return -a * t * t * t + a * t * t;
}

float C1(float t)
{
  return -(a + 2.0f) * t * t * t + (2.0f * a + 3.0f) * t * t - a * t;
}

float C2(float t)
{
  return (a + 2.0f) * t * t * t - (a + 3.0f) * t * t + 1.0f;
}

float C3(float t)
{
  return a * t * t * t - 2.0f * a * t * t + a * t;
}

int main(int   argc,
         char *argv[])
{
  int in_width, in_height, out_width, out_height, larger_out_dimension;
  int n, d, j, k, l, m, index;
  int L[MAX_OUT_DIMENSION];
  unsigned char f[MAX_IN_HEIGHT][MAX_IN_WIDTH];
  unsigned char g[MAX_OUT_HEIGHT][MAX_OUT_WIDTH];
  float x;
  float c[4][MAX_OUT_DIMENSION];
  float h[MAX_IN_WIDTH];

  /*
   * INSERT CODE HERE WHICH INITIALIZES n, d, in_width, in_height,
   * out_width, AND out_height AND READS INPUT IMAGE INTO f[][].
   */

  larger_out_dimension = (out_width > out_height) ? out_width
                                                  : out_height;

  for (k = 0; k < larger_out_dimension; k++)
    L[k] = (k * d) / n;

  for (k = 0; k < n; k++) {
    x = (float)((k * d) % n) / (float)n;
    c[0][k] = C0(x);
    c[1][k] = C1(x);
    c[2][k] = C2(x);
    c[3][k] = C3(x);
  }
  for (k = n; k < larger_out_dimension; k++)
    for (l = 0; l < 4; l++)
      c[l][k] = c[l][k % n];

  for (k = 0; k < out_height; k++) {
    for (j = 0; j < in_width; j++) {
      h[j] = 0.0f;
      for (l = 0; l < 4; l++) {
        index = L[k] + l - 1;
        if ((index >= 0) && (index < in_height))
          h[j] += f[index][j] * c[3 - l][k];
      }
    }
    for (m = 0; m < out_width; m++) {
      x = 0.5f;
      for (l = 0; l < 4; l++) {
        index = L[m] + l - 1;
        if ((index >= 0) && (index < in_width))
          x += h[index] * c[3 - l][m];
      }
      if (x <= 0.0f)
        g[k][m] = 0;
      else if (x >= MAX_PIXEL_VALUE)
        g[k][m] = MAX_PIXEL_VALUE;
      else
        g[k][m] = (unsigned char)x;
    }
  }

  /* INSERT CODE WHICH WRITES CONTENTS OF g[][] TO OUTPUT IMAGE FILE. */

}