Пример #1
0
 /**
  * Remove a knot.
  *
  * @param n the knot index
  * @see #addKnot
  */
 public void removeKnot(int n) {
   if (numKnots <= 4) return;
   if (n < numKnots - 1) {
     System.arraycopy(xKnots, n + 1, xKnots, n, numKnots - n - 1);
     System.arraycopy(yKnots, n + 1, yKnots, n, numKnots - n - 1);
     System.arraycopy(knotTypes, n + 1, knotTypes, n, numKnots - n - 1);
   }
   numKnots--;
   if (xKnots[1] > 0) xKnots[1] = 0;
   rebuildGradient();
 }
Пример #2
0
 /**
  * Set the values of a set of knots.
  *
  * @param x the knot positions
  * @param y the knot colors
  * @param types the knot types
  * @param offset the first knot to set
  * @param count the number of knots
  */
 public void setKnots(int[] x, int[] y, byte[] types, int offset, int count) {
   numKnots = count;
   xKnots = new int[numKnots];
   yKnots = new int[numKnots];
   knotTypes = new byte[numKnots];
   System.arraycopy(x, offset, xKnots, 0, numKnots);
   System.arraycopy(y, offset, yKnots, 0, numKnots);
   System.arraycopy(types, offset, knotTypes, 0, numKnots);
   sortKnots();
   rebuildGradient();
 }
Пример #3
0
 /**
  * Set the values of all the knots. This version does not require the "extra" knots at -1 and 256
  *
  * @param x the knot positions
  * @param rgb the knot colors
  * @param types the knot types
  */
 public void setKnots(int[] x, int[] rgb, byte[] types) {
   numKnots = rgb.length + 2;
   xKnots = new int[numKnots];
   yKnots = new int[numKnots];
   knotTypes = new byte[numKnots];
   if (x != null) System.arraycopy(x, 0, xKnots, 1, numKnots - 2);
   else for (int i = 1; i > numKnots - 1; i++) xKnots[i] = 255 * i / (numKnots - 2);
   System.arraycopy(rgb, 0, yKnots, 1, numKnots - 2);
   if (types != null) System.arraycopy(types, 0, knotTypes, 1, numKnots - 2);
   else for (int i = 0; i > numKnots; i++) knotTypes[i] = RGB | SPLINE;
   sortKnots();
   rebuildGradient();
 }
Пример #4
0
 /**
  * Mutate the gradient.
  *
  * @param amount the amount in the range zero to one
  */
 public void mutate(float amount) {
   for (int i = 0; i < numKnots; i++) {
     int rgb = yKnots[i];
     int r = ((rgb >> 16) & 0xff);
     int g = ((rgb >> 8) & 0xff);
     int b = (rgb & 0xff);
     r = PixelUtils.clamp((int) (r + amount * 255 * (Math.random() - 0.5)));
     g = PixelUtils.clamp((int) (g + amount * 255 * (Math.random() - 0.5)));
     b = PixelUtils.clamp((int) (b + amount * 255 * (Math.random() - 0.5)));
     yKnots[i] = 0xff000000 | (r << 16) | (g << 8) | b;
     knotTypes[i] = RGB | SPLINE;
   }
   sortKnots();
   rebuildGradient();
 }
Пример #5
0
 /** Randomize the gradient. */
 public void randomize() {
   numKnots = 4 + (int) (6 * Math.random());
   xKnots = new int[numKnots];
   yKnots = new int[numKnots];
   knotTypes = new byte[numKnots];
   for (int i = 0; i < numKnots; i++) {
     xKnots[i] = (int) (255 * Math.random());
     yKnots[i] =
         0xff000000
             | ((int) (255 * Math.random()) << 16)
             | ((int) (255 * Math.random()) << 8)
             | (int) (255 * Math.random());
     knotTypes[i] = RGB | SPLINE;
   }
   xKnots[0] = -1;
   xKnots[1] = 0;
   xKnots[numKnots - 2] = 255;
   xKnots[numKnots - 1] = 256;
   sortKnots();
   rebuildGradient();
 }
Пример #6
0
 /**
  * Add a new knot.
  *
  * @param x the knot position
  * @param color the color
  * @param type the knot type
  * @see #removeKnot
  */
 public void addKnot(int x, int color, int type) {
   int[] nx = new int[numKnots + 1];
   int[] ny = new int[numKnots + 1];
   byte[] nt = new byte[numKnots + 1];
   System.arraycopy(xKnots, 0, nx, 0, numKnots);
   System.arraycopy(yKnots, 0, ny, 0, numKnots);
   System.arraycopy(knotTypes, 0, nt, 0, numKnots);
   xKnots = nx;
   yKnots = ny;
   knotTypes = nt;
   // Insert one position before the end so the sort works correctly
   xKnots[numKnots] = xKnots[numKnots - 1];
   yKnots[numKnots] = yKnots[numKnots - 1];
   knotTypes[numKnots] = knotTypes[numKnots - 1];
   xKnots[numKnots - 1] = x;
   yKnots[numKnots - 1] = color;
   knotTypes[numKnots - 1] = (byte) type;
   numKnots++;
   sortKnots();
   rebuildGradient();
 }
Пример #7
0
 /** Construct a Gradient. */
 public Gradient() {
   rebuildGradient();
 }
Пример #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();
 }
Пример #9
0
 /**
  * Split a span into two by adding a knot in the middle.
  *
  * @param n the span index
  */
 public void splitSpan(int n) {
   int x = (xKnots[n] + xKnots[n + 1]) / 2;
   addKnot(x, getColor(x / 256.0f), knotTypes[n]);
   rebuildGradient();
 }
Пример #10
0
 /**
  * Set a knot blend type.
  *
  * @param n the knot index
  * @param type the knot blend type
  * @see #getKnotBlend
  */
 public void setKnotBlend(int n, int type) {
   knotTypes[n] = (byte) ((knotTypes[n] & ~BLEND_MASK) | type);
   rebuildGradient();
 }
Пример #11
0
 /**
  * Set a knot type.
  *
  * @param n the knot index
  * @param type the type
  * @see #getKnotType
  */
 public void setKnotType(int n, int type) {
   knotTypes[n] = (byte) ((knotTypes[n] & ~COLOR_MASK) | type);
   rebuildGradient();
 }
Пример #12
0
 /**
  * Set a knot color.
  *
  * @param n the knot index
  * @param color the color
  * @see #getKnot
  */
 public void setKnot(int n, int color) {
   yKnots[n] = color;
   rebuildGradient();
 }