/* magnify2.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. */

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;
  int n_horizontal, d_horizontal, n_vertical, d_vertical, j, k, l, m, index;
  int L_horizontal[MAX_OUT_WIDTH], L_vertical[MAX_OUT_HEIGHT];
  unsigned char f[MAX_IN_HEIGHT][MAX_IN_WIDTH];
  unsigned char g[MAX_OUT_HEIGHT][MAX_OUT_WIDTH];
  float x;
  float c_horizontal[4][MAX_OUT_WIDTH], c_vertical[4][MAX_OUT_HEIGHT];
  float h[MAX_IN_WIDTH];

  /*
   * INSERT CODE HERE WHICH INITIALIZES n_horizontal, d_horizontal, n_vertical,
   * d_vertical, in_width, in_height, out_width, AND out_height AND READS INPUT
   * IMAGE INTO f[][].
   */

  for (k = 0; k < out_width; k++)
    L_horizontal[k] = (k * d_horizontal) / n_horizontal;

  for (k = 0; k < out_height; k++)
    L_vertical[k] = (k * d_vertical) / n_vertical;

  for (k = 0; k < n_horizontal; k++) {
    x = (float)((k * d_horizontal) % n_vertical) / (float)n_vertical;
    c_horizontal[0][k] = C0(x);
    c_horizontal[1][k] = C1(x);
    c_horizontal[2][k] = C2(x);
    c_horizontal[3][k] = C3(x);
  }
  for (k = n_horizontal; k < out_width; k++)
    for (l = 0; l < 4; l++)
      c_horizontal[l][k] = c_horizontal[l][k % n_horizontal];

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

  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_vertical[k] + l - 1;
        if (index < 0)
          h[j] += f[0][j] * c_vertical[3 - l][k];
        else if (index < in_height)
          h[j] += f[index][j] * c_vertical[3 - l][k];
        else
          h[j] += f[in_height - 1][j] * c_vertical[3 - l][k];
      }
    }
    for (m = 0; m < out_width; m++) {
      x = 0.5f;
      for (l = 0; l < 4; l++) {
        index = L_horizontal[m] + l - 1;
        if (index < 0)
          x += h[0] * c_horizontal[3 - l][m];
        else if (index < in_width)
          x += h[index] * c_horizontal[3 - l][m];
        else
          x += h[in_width - 1] * c_horizontal[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. */

}