Beispiel #1
0
  public int[] blendPixels(int x, int y, int w, int h, int[] pixels, int off, int stride) {
    int[] newPixels = new int[w * h];
    int edge = 8;
    int i = 0;

    for (int row = 0; row < h; row++) {
      for (int col = 0; col < w; col++) {
        if (row < edge || col < edge) {
          int row2 = row < edge ? h - edge - 1 + row : row;
          int col2 = col < edge ? w - edge - 1 + col : col;
          if (row < edge && col < edge) {
            float frow = (float) row / (float) edge;
            float fcol = (float) col / (float) edge;
            int i2 = row2 * w + col2;
            int i3 = row * w + col2;
            int i4 = row2 * w + col;
            int left = ImageMath.mixColors(frow, pixels[i4], pixels[i]);
            int right = ImageMath.mixColors(frow, pixels[i2], pixels[i3]);
            newPixels[i] = ImageMath.mixColors(fcol, right, left);
          } else {
            float f = (float) Math.min(row, col) / (float) edge;
            int i2 = row2 * w + col2;
            newPixels[i] = ImageMath.mixColors(f, pixels[i2], pixels[i]);
          }
        } else newPixels[i] = pixels[i];
        i++;
      }
    }
    return newPixels;
  }
Beispiel #2
0
 /**
  * Set a knot color.
  *
  * @param n the knot index
  * @param color the color
  */
 @Override
 public void setColor(int n, int color) {
   int firstColor = map[0];
   int lastColor = map[256 - 1];
   if (n > 0)
     for (int i = 0; i < n; i++) map[i] = ImageMath.mixColors((float) i / n, firstColor, color);
   if (n < 256 - 1)
     for (int i = n; i < 256; i++)
       map[i] = ImageMath.mixColors((float) (i - n) / (256 - n), color, lastColor);
 }
  public int getPixel(int x, int y, int[] inPixels, int width, int height) {
    float nx = m00 * x + m01 * y;
    float ny = m10 * x + m11 * y;
    nx /= scale;
    ny /= scale * stretch;
    nx += 1000;
    ny += 1000; // Reduce artifacts around 0,0
    float f = evaluate(nx, ny);

    float f1 = results[0].distance;
    float f2 = results[1].distance;
    int srcx = ImageMath.clamp((int) ((results[0].x - 1000) * scale), 0, width - 1);
    int srcy = ImageMath.clamp((int) ((results[0].y - 1000) * scale), 0, height - 1);
    int v = inPixels[srcy * width + srcx];
    f = (f2 - f1) / edgeThickness;
    f = ImageMath.smoothStep(0, edgeThickness, f);
    if (fadeEdges) {
      srcx = ImageMath.clamp((int) ((results[1].x - 1000) * scale), 0, width - 1);
      srcy = ImageMath.clamp((int) ((results[1].y - 1000) * scale), 0, height - 1);
      int v2 = inPixels[srcy * width + srcx];
      v2 = ImageMath.mixColors(0.5f, v2, v);
      v = ImageMath.mixColors(f, v2, v);
    } else v = ImageMath.mixColors(f, edgeColor, v);
    return v;
  }
  @Override
  protected void transformInverse(int x, int y, float[] out) {
    float dx = x - icentreX;
    float dy = y - icentreY;
    float theta = (float) Math.atan2(-dy, -dx) + angle;
    float r = (float) Math.sqrt(dx * dx + dy * dy);

    theta = ImageMath.mod(theta, 2 * (float) Math.PI);

    out[0] = iWidth * theta / (spreadAngle + 0.00001f);
    out[1] = iHeight * (1 - (r - radius) / (height + 0.00001f));
  }
  protected BufferedImage filterPixelsNN(
      BufferedImage dst, int width, int height, int[] inPixels, Rectangle transformedSpace) {
    int srcWidth = width;
    int srcHeight = height;
    int outWidth = transformedSpace.width;
    int outHeight = transformedSpace.height;
    int outX, outY, srcX, srcY;
    int[] outPixels = new int[outWidth];

    outX = transformedSpace.x;
    outY = transformedSpace.y;
    int[] rgb = new int[4];
    float[] out = new float[2];

    for (int y = 0; y < outHeight; y++) {
      for (int x = 0; x < outWidth; x++) {
        transformInverse(outX + x, outY + y, out);
        srcX = (int) out[0];
        srcY = (int) out[1];
        // int casting rounds towards zero, so we check out[0] < 0, not srcX < 0
        if (out[0] < 0 || srcX >= srcWidth || out[1] < 0 || srcY >= srcHeight) {
          int p;
          switch (edgeAction) {
            case ZERO:
            default:
              p = 0;
              break;
            case WRAP:
              p =
                  inPixels[
                      (ImageMath.mod(srcY, srcHeight) * srcWidth) + ImageMath.mod(srcX, srcWidth)];
              break;
            case CLAMP:
              p =
                  inPixels[
                      (ImageMath.clamp(srcY, 0, srcHeight - 1) * srcWidth)
                          + ImageMath.clamp(srcX, 0, srcWidth - 1)];
              break;
            case RGB_CLAMP:
              p =
                  inPixels[
                          (ImageMath.clamp(srcY, 0, srcHeight - 1) * srcWidth)
                              + ImageMath.clamp(srcX, 0, srcWidth - 1)]
                      & 0x00ffffff;
          }
          outPixels[x] = p;
        } else {
          int i = srcWidth * srcY + srcX;
          rgb[0] = inPixels[i];
          outPixels[x] = inPixels[i];
        }
      }
      setRGB(dst, 0, y, transformedSpace.width, 1, outPixels);
    }
    return dst;
  }
 private final int getPixel(int[] pixels, int x, int y, int width, int height) {
   if (x < 0 || x >= width || y < 0 || y >= height) {
     switch (edgeAction) {
       case ZERO:
       default:
         return 0;
       case WRAP:
         return pixels[(ImageMath.mod(y, height) * width) + ImageMath.mod(x, width)];
       case CLAMP:
         return pixels[
             (ImageMath.clamp(y, 0, height - 1) * width) + ImageMath.clamp(x, 0, width - 1)];
       case RGB_CLAMP:
         return pixels[
                 (ImageMath.clamp(y, 0, height - 1) * width) + ImageMath.clamp(x, 0, width - 1)]
             & 0x00ffffff;
     }
   }
   return pixels[y * width + x];
 }
Beispiel #7
0
  private void rebuildGradient() {
    xKnots[0] = -1;
    xKnots[numKnots - 1] = 256;
    yKnots[0] = yKnots[1];
    yKnots[numKnots - 1] = yKnots[numKnots - 2];

    for (int i = 1; i < numKnots - 1; i++) {
      float spanLength = xKnots[i + 1] - xKnots[i];
      int end = xKnots[i + 1];
      if (i == numKnots - 2) end++;
      for (int j = xKnots[i]; j < end; j++) {
        int rgb1 = yKnots[i];
        int rgb2 = yKnots[i + 1];
        float hsb1[] = Color.RGBtoHSB((rgb1 >> 16) & 0xff, (rgb1 >> 8) & 0xff, rgb1 & 0xff, null);
        float hsb2[] = Color.RGBtoHSB((rgb2 >> 16) & 0xff, (rgb2 >> 8) & 0xff, rgb2 & 0xff, null);
        float t = (j - xKnots[i]) / spanLength;
        int type = getKnotType(i);
        int blend = getKnotBlend(i);

        if (j >= 0 && j <= 255) {
          switch (blend) {
            case CONSTANT:
              t = 0;
              break;
            case LINEAR:
              break;
            case SPLINE:
              //						map[i] = ImageMath.colorSpline(j, numKnots, xKnots, yKnots);
              t = ImageMath.smoothStep(0.15f, 0.85f, t);
              break;
            case CIRCLE_UP:
              t = t - 1;
              t = (float) Math.sqrt(1 - t * t);
              break;
            case CIRCLE_DOWN:
              t = 1 - (float) Math.sqrt(1 - t * t);
              break;
          }
          //					if (blend != SPLINE) {
          switch (type) {
            case RGB:
              map[j] = ImageMath.mixColors(t, rgb1, rgb2);
              break;
            case HUE_CW:
            case HUE_CCW:
              if (type == HUE_CW) {
                if (hsb2[0] <= hsb1[0]) hsb2[0] += 1.0f;
              } else {
                if (hsb1[0] <= hsb2[1]) hsb1[0] += 1.0f;
              }
              float h = ImageMath.lerp(t, hsb1[0], hsb2[0]) % (ImageMath.TWO_PI);
              float s = ImageMath.lerp(t, hsb1[1], hsb2[1]);
              float b = ImageMath.lerp(t, hsb1[2], hsb2[2]);
              map[j] = 0xff000000 | Color.HSBtoRGB(h, s, b); // FIXME-alpha
              break;
          }
          //					}
        }
      }
    }
  }
Beispiel #8
0
 /**
  * Set a knot position.
  *
  * @param n the knot index
  * @param x the knot position
  * @see #setKnotPosition
  */
 public void setKnotPosition(int n, int x) {
   xKnots[n] = ImageMath.clamp(x, 0, 255);
   sortKnots();
   rebuildGradient();
 }
  public BufferedImage filter(BufferedImage src, BufferedImage dst) {
    int width = src.getWidth();
    int height = src.getHeight();
    int type = src.getType();
    WritableRaster srcRaster = src.getRaster();

    originalSpace = new Rectangle(0, 0, width, height);
    transformedSpace = new Rectangle(0, 0, width, height);
    transformSpace(transformedSpace);

    if (dst == null) {
      ColorModel dstCM = src.getColorModel();
      dst =
          new BufferedImage(
              dstCM,
              dstCM.createCompatibleWritableRaster(transformedSpace.width, transformedSpace.height),
              dstCM.isAlphaPremultiplied(),
              null);
    }
    WritableRaster dstRaster = dst.getRaster();

    int[] inPixels = getRGB(src, 0, 0, width, height, null);

    if (interpolation == NEAREST_NEIGHBOUR)
      return filterPixelsNN(dst, width, height, inPixels, transformedSpace);

    int srcWidth = width;
    int srcHeight = height;
    int srcWidth1 = width - 1;
    int srcHeight1 = height - 1;
    int outWidth = transformedSpace.width;
    int outHeight = transformedSpace.height;
    int outX, outY;
    int index = 0;
    int[] outPixels = new int[outWidth];

    outX = transformedSpace.x;
    outY = transformedSpace.y;
    float[] out = new float[2];

    for (int y = 0; y < outHeight; y++) {
      for (int x = 0; x < outWidth; x++) {
        transformInverse(outX + x, outY + y, out);
        int srcX = (int) Math.floor(out[0]);
        int srcY = (int) Math.floor(out[1]);
        float xWeight = out[0] - srcX;
        float yWeight = out[1] - srcY;
        int nw, ne, sw, se;

        if (srcX >= 0 && srcX < srcWidth1 && srcY >= 0 && srcY < srcHeight1) {
          // Easy case, all corners are in the image
          int i = srcWidth * srcY + srcX;
          nw = inPixels[i];
          ne = inPixels[i + 1];
          sw = inPixels[i + srcWidth];
          se = inPixels[i + srcWidth + 1];
        } else {
          // Some of the corners are off the image
          nw = getPixel(inPixels, srcX, srcY, srcWidth, srcHeight);
          ne = getPixel(inPixels, srcX + 1, srcY, srcWidth, srcHeight);
          sw = getPixel(inPixels, srcX, srcY + 1, srcWidth, srcHeight);
          se = getPixel(inPixels, srcX + 1, srcY + 1, srcWidth, srcHeight);
        }
        outPixels[x] = ImageMath.bilinearInterpolate(xWeight, yWeight, nw, ne, sw, se);
      }
      setRGB(dst, 0, y, transformedSpace.width, 1, outPixels);
    }
    return dst;
  }