sclass Gazelle22_GradientImage {

  // input

  BWImage posterized;

  double gradientThreshold = .25;

  // output

  BWImage out;

  // internal

  PosterizeBWImage op;

  BWImage unposterized;

  int w, h, brightnessLevels, singleStep;

  *(BWImage *posterized) {}

  bool init() {

    op = (PosterizeBWImage) getMetaSrc(posterized);

    if (op == null) false;

    unposterized = op.img;

    brightnessLevels = op.brightnessLevels;

    assertSameSize(unposterized, posterized);

    w = posterized.getWidth();

    h = posterized.getHeight();

    singleStep = iceil(doubleRatio(255, brightnessLevels-1));

    true;

  }

  BWImage get() {

    init();

    out = new BWImage(w*2+1, h*2+1);

    for y to h:

      for x to w: {

        if (x < w-1) checkPair(x, y, x+1, y);

        if (y < h-1) checkPair(x, y, x, y+1);

      }

    ret out;

  }

  // also returns true for inner pixels

  // may not work 100% yet (see gazelle22_highlightRegionOutline)

  bool isGradientPoint(int x, int y) {

    if (op == null) false;

    new IntMinMax posterizedMinMax;

    new IntMinMax unposterizedMinMax;

    // need to grab point and all 8 neighbors to cover all cases

    for (int y2 = max(0, y-1); y2 <= min(h-1, y+1); y2++)

      for (int x2 = max(0, x-1); x2 <= min(w-1, x+1); x2++) {

        posterizedMinMax.add(posterized.getInt(x2, y2));

        unposterizedMinMax.add(unposterized.getInt(x2, y2));

      }

    int posterizedContrast = posterizedMinMax.rangeLength();

    if (posterizedContrast > singleStep) false;

    if (posterizedContrast == 0) true;

    int unposterizedContrast = unposterizedMinMax.rangeLength();

    ret unposterizedContrast <= posterizedContrast*gradientThreshold;

  }

  void checkPair(int x, int y, int x2, int y2) {  

    int posterizedContrast = absDiff(posterized.getInt(x, y),

      posterized.getInt(x2, y2));

    if (posterizedContrast == 0) ret;

    if (posterizedContrast > singleStep) ret;

    int realContrast = absDiff(unposterized.getInt(x, y),

      unposterized.getInt(x2, y2));

    double ratio = doubleRatio(realContrast, singleStep);

    float result = cast (.5-ratio)*2;

    /*if (ratio < .5)*/ {

      out.setPixel(x*2+1-(y2-y), y*2+1, result);

      out.setPixel(x*2+1, y*2+1-(x2-x), result);

    }

  }

}