示例#1
0
  @NotNull
  public static Icon colorize(@NotNull final Icon source, @NotNull Color color, boolean keepGray) {
    float[] base = Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), null);

    final BufferedImage image =
        UIUtil.createImage(source.getIconWidth(), source.getIconHeight(), Transparency.TRANSLUCENT);
    final Graphics2D g = image.createGraphics();
    source.paintIcon(null, g, 0, 0);
    g.dispose();

    final BufferedImage img =
        UIUtil.createImage(source.getIconWidth(), source.getIconHeight(), Transparency.TRANSLUCENT);
    int[] rgba = new int[4];
    float[] hsb = new float[3];
    for (int y = 0; y < image.getRaster().getHeight(); y++) {
      for (int x = 0; x < image.getRaster().getWidth(); x++) {
        image.getRaster().getPixel(x, y, rgba);
        if (rgba[3] != 0) {
          Color.RGBtoHSB(rgba[0], rgba[1], rgba[2], hsb);
          int rgb = Color.HSBtoRGB(base[0], base[1] * (keepGray ? hsb[1] : 1f), base[2] * hsb[2]);
          img.getRaster()
              .setPixel(x, y, new int[] {rgb >> 16 & 0xff, rgb >> 8 & 0xff, rgb & 0xff, rgba[3]});
        }
      }
    }

    return createImageIcon(img);
  }
示例#2
0
 public static WritableRaster glowmask(Raster img) {
   Coord sz = imgsz(img);
   int nb = img.getNumBands();
   WritableRaster ret = alpharaster(sz);
   float[] hsv = new float[3];
   float max = 0;
   for (int y = 0; y < sz.y; y++) {
     for (int x = 0; x < sz.x; x++) {
       Color.RGBtoHSB(img.getSample(x, y, 0), img.getSample(x, y, 1), img.getSample(x, y, 2), hsv);
       float a = (nb > 3) ? (img.getSample(x, y, 3) / 255f) : 1f;
       float val = ((1f - hsv[1]) * hsv[2]) * a;
       max = Math.max(max, val);
     }
   }
   float imax = 1f / max;
   for (int y = 0; y < sz.y; y++) {
     for (int x = 0; x < sz.x; x++) {
       Color.RGBtoHSB(img.getSample(x, y, 0), img.getSample(x, y, 1), img.getSample(x, y, 2), hsv);
       float a = (nb > 3) ? (img.getSample(x, y, 3) / 255f) : 1f;
       float val = ((1f - hsv[1]) * hsv[2]) * a;
       ret.setSample(x, y, 0, Math.min(Math.max((int) (Math.sqrt(val * imax) * 255), 0), 255));
     }
   }
   return (ret);
 }
示例#3
0
    public void composeRGB(int[] src, int[] dst, float alpha) {
      int w = src.length;

      for (int i = 0; i < w; i += 4) {
        int sr = src[i];
        int dir = dst[i];
        int sg = src[i + 1];
        int dig = dst[i + 1];
        int sb = src[i + 2];
        int dib = dst[i + 2];
        int sa = src[i + 3];
        int dia = dst[i + 3];
        int dor, dog, dob;

        Color.RGBtoHSB(sr, sg, sb, sHSB);
        Color.RGBtoHSB(dir, dig, dib, dHSB);

        dHSB[0] = sHSB[0];

        int doRGB = Color.HSBtoRGB(dHSB[0], dHSB[1], dHSB[2]);
        dor = (doRGB & 0xff0000) >> 16;
        dog = (doRGB & 0xff00) >> 8;
        dob = (doRGB & 0xff);

        float a = alpha * sa / 255f;
        float ac = 1 - a;

        dst[i] = (int) (a * dor + ac * dir);
        dst[i + 1] = (int) (a * dog + ac * dig);
        dst[i + 2] = (int) (a * dob + ac * dib);
        dst[i + 3] = (int) (sa * alpha + dia * ac);
      }
    }
示例#4
0
  public static Color getComplementaryColor(final Color color1) {
    final Color complement =
        new Color(
            COLOR_RANGE_MAX - color1.getRed(),
            COLOR_RANGE_MAX - color1.getGreen(),
            COLOR_RANGE_MAX - color1.getBlue());
    final float[] hsb = Color.RGBtoHSB(color1.getRed(), color1.getGreen(), color1.getBlue(), null);
    final float[] cHSB =
        Color.RGBtoHSB(complement.getRed(), complement.getGreen(), complement.getBlue(), null);

    if (hsb[2] > 0.7f) return Color.getHSBColor(cHSB[0], 1.0f - hsb[1], 0f);
    else return Color.getHSBColor(cHSB[0], 1.0f - hsb[1], 1.0f);
  }
 public double getBrightness() {
   java.awt.Color col =
       new java.awt.Color(
           (float) getRed(), (float) getGreen(), (float) getBlue(), (float) getAlpha());
   float[] comps = java.awt.Color.RGBtoHSB(col.getRed(), col.getGreen(), col.getBlue(), null);
   return comps[2];
 }
    /**
     * Much of this code is copied from GlyphPainter1's implementation.
     *
     * @see javax.swing.text.GlyphView.GlyphPainter#paint(javax.swing.text.GlyphView,
     *     java.awt.Graphics, java.awt.Shape, int, int)
     */
    @Override
    public void paint(GlyphView v, Graphics g, Shape a, int p0, int p1) {
      sync(v);
      Segment text;
      TabExpander expander = v.getTabExpander();
      Rectangle alloc = (a instanceof Rectangle) ? (Rectangle) a : a.getBounds();

      // determine the x coordinate to render the glyphs
      int x = alloc.x;
      int p = v.getStartOffset();
      if (p != p0) {
        text = v.getText(p, p0);
        int width = Utilities.getTabbedTextWidth(text, metrics, x, expander, p);
        x += width;
      } // endif

      // determine the y coordinate to render the glyphs
      int y = alloc.y + metrics.getHeight() - metrics.getDescent();

      // Calculate the background highlight, it gets painted first.
      Color bg = TwoToneTextPane.getTwoToneColor(v.getElement().getAttributes());
      Color fg = g.getColor();
      if (bg == null) { // No color set, guess black or white
        float[] hsb = Color.RGBtoHSB(fg.getRed(), fg.getGreen(), fg.getBlue(), null);
        bg = hsb[2] > 0.7 ? Color.BLACK : Color.WHITE;
      } // endif
      g.setColor(bg);

      // render the glyphs, first in bg highlight, then in fg
      text = v.getText(p0, p1);
      g.setFont(metrics.getFont());
      Utilities.drawTabbedText(text, x + HORIZONTAL_OFFSET, y + VERTICAL_OFFSET, g, expander, p0);
      g.setColor(fg);
      Utilities.drawTabbedText(text, x, y, g, expander, p0);
    }
  /**
   * Compute a contrasting background color to draw the label's outline.
   *
   * @param color Label color.
   * @return A color that contrasts with {@code color}.
   */
  protected Color computeBackgroundColor(Color color) {
    float[] colorArray = new float[4];
    Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), colorArray);

    if (colorArray[2] > 0.5) return new Color(0, 0, 0, 0.7f);
    else return new Color(1, 1, 1, 0.7f);
  }
  public boolean isValidRedPixel(int red, int green, int blue) {
    float[] hsbvals = new float[3];
    hsbvals = Color.RGBtoHSB(red, green, blue, hsbvals);
    int hue = (int) (255 * hsbvals[0]);
    int sat = (int) (255 * hsbvals[1]);
    int val = (int) (255 * hsbvals[2]);

    // Green!
    if (hue > 60 && hue < 100 && sat >= 200 && val >= 100) return true;

    // GREEN?
    // if (hue > 85 && hue < 110) return true;

    // if (hue < 15 || hue > 240) return true;

    // if((hue < 10 || hue > 240) && sat >= 150 && sat <=180 && val >= 95 && val <=120)
    //	return true;
    // if(hue >= 140 && hue <= 160 && sat >= 190 && sat <=205 && val >=160 && val <=170)
    //	return true;

    // if (hue < 15 && sat >= 185 && sat <= 205 && val >= 165 && val <= 190) return true;
    // if (hue > 120 && hue <= 140 && sat >= 140 && sat <= 160 && val >= 215 && val <= 235) return
    // true;

    // if ((hue <= 15 || hue > 240) && sat >= 100 && val >= 10) return true;

    return false;
  }
  private float[] toHSB(FlatColor color) {

    java.awt.Color col =
        new java.awt.Color(
            (float) color.getRed(), (float) color.getGreen(), (float) color.getBlue(), 1.0f);
    float[] comps = java.awt.Color.RGBtoHSB(col.getRed(), col.getGreen(), col.getBlue(), null);
    return comps;
  }
  /**
   * Segment out a blob from the src image (if a good candidate exists).
   *
   * <p><code>dest</code> is a packed RGB image for a java image drawing routine. If it's not null,
   * the blob is highlighted.
   *
   * @param src the source RGB image, not packed
   * @param dest the destination RGB image, packed, may be null
   */
  public void apply(Image src, Image dest) {

    stepTiming(); // monitors the frame rate

    // Begin Student Code
    boolean hsb = true;

    int h = src.getHeight();
    int w = src.getWidth();

    int ht = h / 10;
    int wt = w / 10;

    // int ht_start = h / 2 - ht / 2;
    // int wt_start = w / 2 - wt / 2;

    int ht_start = 0;
    int wt_start = 0;

    int[] colors = new int[3];

    // Determine the average rgb/hsb pixel values in the upper left hand corner
    for (int x = wt_start; x < wt_start + wt; x++) {
      for (int y = ht_start; y < ht_start + ht; y++) {
        int red = src.getPixelRed(x, y) & 0xff;
        int green = src.getPixelGreen(x, y) & 0xff;
        int blue = src.getPixelBlue(x, y) & 0xff;
        if (!hsb) {
          colors[0] += red;
          colors[1] += green;
          colors[2] += blue;
        } else {
          float[] hsbvals = new float[3];
          Color.RGBtoHSB(red, green, blue, hsbvals);
          colors[0] += (int) (hsbvals[0] * 255);
          colors[1] += (int) (hsbvals[1] * 255);
          colors[2] += (int) (hsbvals[2] * 255);
        }
      }
    }

    colors[0] = colors[0] / (ht * wt);
    colors[1] = colors[1] / (ht * wt);
    colors[2] = colors[2] / (ht * wt);

    if (!hsb) {
      System.out.println("Upper left in RGB: " + colors[0] + ", " + colors[1] + ", " + colors[2]);
    } else {
      System.out.println("Upper left in HSB: " + colors[0] + ", " + colors[1] + ", " + colors[2]);
    }

    blobPresent(src, dest);
    // Comment out the next two lines to display the histogram overlayed over the src image
    // dest.setPixelArray(src.toArray());
    // Histogram.getHistogram(src, dest, hsb);
    // System.out.println("In apply!");
    // End Student Code
  }
示例#11
0
  public int getHue(int x, int y) {

    int red = getPixelRed(x, y) & 0xff;
    int green = getPixelGreen(x, y) & 0xff;
    int blue = getPixelBlue(x, y) & 0xff;
    float[] hsbvals = new float[3];
    hsbvals = Color.RGBtoHSB(red, green, blue, hsbvals);
    return (int) (255 * hsbvals[0]);
  }
示例#12
0
文件: LookUtils.java 项目: srnsw/xena
 /**
  * Computes and returns a Color that is slightly brighter than the specified Color.
  *
  * @param color the color used as basis for the brightened color
  * @param factor the factor used to compute the brightness
  * @return a slightly brighter color
  */
 public static Color getSlightlyBrighter(Color color, float factor) {
   float[] hsbValues = new float[3];
   Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), hsbValues);
   float hue = hsbValues[0];
   float saturation = hsbValues[1];
   float brightness = hsbValues[2];
   float newBrightness = Math.min(brightness * factor, 1.0f);
   return Color.getHSBColor(hue, saturation, newBrightness);
 }
示例#13
0
  /**
   * Conversion from RGB into HSB color space.
   *
   * <p>This method simply calls the <code>RGBtoHSB</code> method containing in the jre, in the
   * <code>java.awt.Color</code>-class.
   *
   * @see java.awt.Color#RGBtoHSB(int, int, int, float[])
   * @param rgbColor The array of red/green/blue-parts as ints.
   * @return The array of float containing the hue/saturation/brightness-parts in the range <code>
   *     0.0 : 1.0</code>.
   */
  private float[] rgbToHSB_JRE(final int[] rgbColor) {
    assert rgbColor != null;

    return Color.RGBtoHSB(
        rgbColor[RED_COMPONENT_INDEX],
        rgbColor[GREEN_COMPONENT_INDEX],
        rgbColor[BLUE_COMPONENT_INDEX],
        null);
  }
示例#14
0
  @Override
  public BufferedImage doTransform(BufferedImage src, BufferedImage dest) {
    int hueP = hue.getValue();
    int satP = saturation.getValue();
    int briP = brightness.getValue();

    if ((hueP == 0) && (satP == 0) && (briP == 0)) {
      return src;
    }

    float satShift = saturation.getValueAsPercentage();
    float briShift = brightness.getValueAsPercentage();
    float hueShift = hue.getValueAsFloat() / 360.0f;

    int[] srcData = ImageUtils.getPixelsAsArray(src);
    int[] destData = ImageUtils.getPixelsAsArray(dest);

    int length = srcData.length;
    assert length == destData.length;

    float[] tmpHSBArray = {0.0f, 0.0f, 0.0f};

    for (int i = 0; i < length; i++) {
      int rgb = srcData[i];
      int a = rgb & 0xFF000000;
      int r = (rgb >>> 16) & 0xFF;
      int g = (rgb >>> 8) & 0xFF;
      int b = (rgb) & 0xFF;

      tmpHSBArray = Color.RGBtoHSB(r, g, b, tmpHSBArray);

      float shiftedHue = tmpHSBArray[0] + hueShift;
      float shiftedSat = tmpHSBArray[1] + satShift;
      float shiftedBri = tmpHSBArray[2] + briShift;

      if (shiftedSat < 0.0f) {
        shiftedSat = 0.0f;
      }
      if (shiftedSat > 1.0f) {
        shiftedSat = 1.0f;
      }

      if (shiftedBri < 0.0f) {
        shiftedBri = 0.0f;
      }
      if (shiftedBri > 1.0f) {
        shiftedBri = 1.0f;
      }

      int newRGB = Color.HSBtoRGB(shiftedHue, shiftedSat, shiftedBri); // alpha is 255 here
      newRGB &= 0x00FFFFFF; // set alpha to 0
      destData[i] = a | newRGB; // add the real alpha
    }

    return dest;
  }
示例#15
0
 public void select(int x, int y) {
   ArrayList<Point> points = new ArrayList<Point>();
   points.add(new Point(x, y));
   Color origin = new Color(buffer.getRGB(x, y));
   float[] ori = Color.RGBtoHSB(origin.getRed(), origin.getGreen(), origin.getBlue(), null);
   while (!points.isEmpty()) {
     Point p = points.remove(0);
     Color cur = new Color(buffer.getRGB(p.x, p.y));
     Color alt = new Color(contBuffer.getRGB(p.x, p.y));
     float[] c = Color.RGBtoHSB(cur.getRed(), cur.getGreen(), cur.getBlue(), null);
     if (!cur.equals(alt) && c[2] > 0.5) {
       buffer.setRGB(p.x, p.y, contBuffer.getRGB(p.x, p.y));
       if (p.x > 0) points.add(new Point(p.x - 1, p.y));
       if (p.x < buffer.getWidth() - 1) points.add(new Point(p.x + 1, p.y));
       if (p.y > 0) points.add(new Point(p.x, p.y - 1));
       if (p.y < buffer.getHeight() - 1) points.add(new Point(p.x, p.y + 1));
     }
   }
 }
示例#16
0
 private int getBinForHSB(int rgb, float[] hsbvals) {
   final int r = (rgb & 0xFF0000) >> 16, g = (rgb & 0x00FF00) >> 8, b = (rgb & 0x0000FF);
   // TODO: AWT Color.RGBtoHSB can be sped up numerically
   Color.RGBtoHSB(r, g, b, hsbvals);
   // The values returned by RGBtoHSB are all in [0:1]
   int h = Math.min((int) Math.floor(binX * hsbvals[0]), binX - 1);
   int s = Math.min((int) Math.floor(binY * hsbvals[1]), binY - 1);
   int v = Math.min((int) Math.floor(binZ * hsbvals[2]), binZ - 1);
   return h * binY * binZ + s * binZ + v;
 }
示例#17
0
 public static float[] getHSB(Color color) {
   float[] rgb = new float[4];
   float[] hsb = new float[3];
   color.getComponents(rgb);
   int r = (int) (rgb[0] * 256);
   int g = (int) (rgb[1] * 256);
   int b = (int) (rgb[2] * 256);
   Color.RGBtoHSB(r, g, b, hsb);
   return hsb;
 }
  static {
    RAINBOW_COLOUR_0 = Color.decode("#8A56E2");

    RAINBOW_BASE_HSB = new float[3];
    Color.RGBtoHSB(
        RAINBOW_COLOUR_0.getRed(),
        RAINBOW_COLOUR_0.getGreen(),
        RAINBOW_COLOUR_0.getBlue(),
        RAINBOW_BASE_HSB);
  }
示例#19
0
 /**
  * Method which determines the color that the place p, should get depending on its average waiting
  * time. This color is returned as String in dot-form
  *
  * @param p ExtendedPlace: the place to be colored
  * @return String
  */
 private String determinePlaceColor(ExtendedPlace p) {
   String temp = "fillcolor=";
   // paint places according to their waiting time level:
   double bnd0 = 0, bnd1 = 0, wait = 0;
   Color col0, col1, col2;
   if (p.hasSettings()) {
     bnd0 = ((Double) p.getBounds().get(0)).doubleValue() * timeDivider;
     bnd1 = ((Double) p.getBounds().get(1)).doubleValue() * timeDivider;
     col0 = (Color) p.getColors().get(0);
     col1 = (Color) p.getColors().get(1);
     col2 = (Color) p.getColors().get(2);
   } else {
     bnd0 = ((Double) bounds.get(0)).doubleValue() * timeDivider;
     bnd1 = ((Double) bounds.get(1)).doubleValue() * timeDivider;
     col0 = (Color) levelColors.get(0);
     col1 = (Color) levelColors.get(1);
     col2 = (Color) levelColors.get(2);
   }
   try {
     p.calculateMetrics(currentlySelectedInstances, advancedSettings[1], failedInstances);
     wait = (p.getMeanWaitingTime());
   } catch (Exception ex) {
   }
   // array to store HSB values in
   float[] hsb = new float[3];
   if (wait <= bnd0) {
     Color.RGBtoHSB(col0.getRed(), col0.getGreen(), col0.getBlue(), hsb);
     temp += "\"" + hsb[0] + "," + hsb[1] + "," + hsb[2] + "\"";
   } else if (wait <= bnd1) {
     Color.RGBtoHSB(col1.getRed(), col1.getGreen(), col1.getBlue(), hsb);
     temp += "\"" + hsb[0] + "," + hsb[1] + "," + hsb[2] + "\"";
   } else if (wait > bnd1) {
     // final one
     Color.RGBtoHSB(col2.getRed(), col2.getGreen(), col2.getBlue(), hsb);
     temp += "\"" + hsb[0] + "," + hsb[1] + "," + hsb[2] + "\"";
   } else {
     Color.RGBtoHSB(col0.getRed(), col0.getGreen(), col0.getBlue(), hsb);
     temp += "\"" + hsb[0] + "," + hsb[1] + "," + hsb[2] + "\"";
   }
   return temp;
 }
示例#20
0
  /**
   * Creates a new color that is 30% less saturated
   *
   * @return
   */
  public Color lessSaturated() {
    float[] hsb =
        java.awt.Color.RGBtoHSB((int) (r * 255f), (int) (g * 255f), (int) (b * 255f), null);
    hsb[1] *= 0.7f;

    int rgbColor = java.awt.Color.HSBtoRGB(hsb[0], hsb[1], hsb[2]);

    int r = (rgbColor & 0x00FF0000) >> 16;
    int g = (rgbColor & 0x0000FF00) >> 8;
    int b = rgbColor & 0x000000FF;
    return new Color(r, g, b, (int) this.a * 255);
  }
示例#21
0
  /**
   * Creates a new color with the identical value component but with the brightness specified
   *
   * @param brightness 1 is bright, 0 is black
   * @return
   */
  public Color getColorWithSpecificBrighness(float brightness) {

    float[] hsb = new float[3];
    java.awt.Color.RGBtoHSB((int) (r * 255f), (int) (g * 255f), (int) (b * 255f), hsb);
    hsb[2] = brightness;
    java.awt.Color convertedColor = java.awt.Color.getHSBColor(hsb[0], hsb[1], brightness);

    return new Color(
        convertedColor.getRed() / 255f,
        convertedColor.getGreen() / 255f,
        convertedColor.getBlue() / 255f);
  }
示例#22
0
  protected void paintComponent(Graphics g) {
    String shortcuts = pref.get("fields_shortcuts", "`1234567890qwertyuiopasdfghjkl");
    // paint fields
    Field ef = new Field(Field.EMPTY);
    Field[] fs = new Field[board.getData().getFields().length + 1];
    fs[0] = ef;
    System.arraycopy(board.getData().getFields(), 0, fs, 1, board.getData().getFields().length);
    // ef.paint(g,0,0,fieldW,fieldH);
    for (int i = 0; i < fs.length; i++) {
      Field f = fs[i];
      f.paint(g, i * fieldW, 0, fieldW, fieldH);

      // paint shortcuts
      if (i >= shortcuts.length()) continue;
      Color fieldColor =
          new Color(
              (f.getColor1().getRed() + f.getColor2().getRed()) / 2,
              (f.getColor1().getGreen() + f.getColor2().getGreen()) / 2,
              (f.getColor1().getBlue() + f.getColor2().getBlue()) / 2);
      if (Color.RGBtoHSB(fieldColor.getRed(), fieldColor.getGreen(), fieldColor.getBlue(), null)[2]
          < 0.5) {
        // dark background, bright color
        g.setColor(
            new Color(
                255 - descColor.getRed(), 255 - descColor.getGreen(), 255 - descColor.getBlue()));
      } else {
        // bright background, dark color
        g.setColor(descColor);
      }
      String str = Character.toString(shortcuts.charAt(i));

      int fontSize = (int) (fieldH * 0.5) + 1;
      int strWidth;

      Font font;
      do {
        fontSize--;
        font = new Font(Font.SERIF, Font.PLAIN, fontSize);
      } while ((strWidth = g.getFontMetrics().stringWidth(str)) > 0.9 * fieldW);

      g.setFont(font);
      g.drawString(str, i * fieldW + fieldW / 4 - strWidth / 2, fieldH / 4 + fontSize / 2);
    }

    // paint grid
    g.setColor(lineColor);
    int totalWidth = (board.getData().getFields().length + 1) * fieldW;
    for (int i = 0; i < board.getData().getFields().length + 2; i++) {
      g.drawLine(i * fieldW, 0, i * fieldW, fieldH);
    }
    g.drawLine(0, 0, totalWidth, 0);
    g.drawLine(0, fieldH, totalWidth, fieldH);
  }
示例#23
0
 private static Color brightness(Color color, double newBrightness, double newBrightnessKof) {
   //        color.
   float[] hue = Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), null);
   float h = hue[0];
   float s = hue[1];
   float b =
       (float)
           (((double) hue[2] * (1d - newBrightnessKof))
               + ((double) newBrightness * newBrightnessKof));
   int rgb = Color.HSBtoRGB(h, s, b);
   return new Color(rgb);
 }
  @Override
  protected int[] getComponents(int pixel) {
    int[] components = new int[3];
    float[] hsbvals = new float[3];
    Color c = new Color(pixel);

    hsbvals = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), hsbvals);
    components[0] = (int) (hsbvals[0] * 255);
    components[1] = (int) (hsbvals[1] * 255);
    components[2] = (int) (hsbvals[2] * 255);
    return components;
  }
示例#25
0
 private void sendBoardToDisplay(MITrisBoard board, Display2D display, double brightness) {
   int width = display.getWidth();
   int height = display.getHeight();
   for (int x = 0; x < width; x++) {
     for (int y = 0; y < height; y++) {
       Piece p = board.getPosition(x, y);
       Color c = p == null ? Color.BLACK : p.getColor(board.getLevel(), gameDisplayTime);
       float[] hsb = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), new float[3]);
       hsb[2] *= brightness;
       display.setPixelHSB(x, height - 1 - y, hsb[0], hsb[1], hsb[2]);
     }
   }
 }
    private void setColor(Color color, Object source) {
      float[] hsb = new float[3];
      Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), hsb);
      myColor = color;
      myHue = hsb[0];
      mySaturation = hsb[1];
      myBrightness = hsb[2];
      myOpacity = color.getAlpha();

      fireColorChanged(source);

      repaint();
    }
示例#27
0
 public void turnQuickOn() {
   hidePanels();
   hideTabs();
   deactivateTabs();
   pHsearch1.setVisible(true);
   pHsearch1.revalidate();
   pHsearch1.repaint();
   if (tabs > 0) {
     tabButton1.setVisible(true);
     tabButton1.revalidate();
     tabButton1.repaint();
   }
   if (tabs > 1) {
     tabButton2.setVisible(true);
   }
   if (tabs > 2) {
     tabButton3.setVisible(true);
   }
   if (tabs > 3) {
     tabButton4.setVisible(true);
   }
   if (tabs > 4) {
     tabButton5.setVisible(true);
   }
   if (tabs > 0 && oldTabRef != null) {
     oldTabRef.setVisible(true);
     oldTabRef.revalidate();
     oldTabRef.repaint();
   }
   if (currentTab == 1) {
     tabButton1.activate(true);
     currentTabRef = tab1;
   } else if (currentTab == 2) {
     tabButton2.activate(true);
     currentTabRef = tab2;
   } else if (currentTab == 3) {
     tabButton3.activate(true);
     currentTabRef = tab3;
   } else if (currentTab == 4) {
     tabButton4.activate(true);
     currentTabRef = tab4;
   } else if (currentTab == 5) {
     tabButton5.activate(true);
     currentTabRef = tab5;
   }
   replaceImg();
   float[] RGBConv = Color.RGBtoHSB(94, 88, 88, null);
   pHquickSearch1.setBackground(Color.getHSBColor(RGBConv[0], RGBConv[1], RGBConv[2]));
   pHquickSearch1.changeState(true);
 }
示例#28
0
  /**
   * returns a color for a group/order and for a state
   *
   * @param order A color order number. This determines the base color (hue). <br>
   *     -2 => Wire <br>
   *     else group index
   * @param what The goal for this color. <br>
   *     0 = unselected face. <br>
   *     1 = selected face. <br>
   *     2 = unselected internal edge <br>
   *     3 = selected internal edge <br>
   *     4 = unselected external edge <br>
   *     5 = selected external edge <br>
   *     6 = selected quad <br>
   */
  public float[] getColorForOrder(int order, int what) {
    // wires have no group
    if (order == -2) {
      switch (what) {
        case 0:
          return new float[] {0.4f, 0.4f, 0.4f};
        case 1:
          return new float[] {1.0f, 1.0f, 1.0f};
        case 2:
          return new float[] {0.95f, 0.95f, 0.95f};
      }
    }

    float s, h;
    float b = 1.0f;
    Color c = baseColor.get(new Integer(order));
    float[] hsb = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), null);
    h = hsb[0];
    s = hsb[1];
    b = hsb[2];

    switch (what) {
      case 0:
        s = s * 1.0f;
        break; // unactive face has saturated color
      case 1:
        s = s * 0.75f;
        break; // selected face is whiter
      case 2:
        s = s * 0.5f;
        break; // internal edges
      case 3:
        s = s * 0.0f;
        break; // selected internal edges
      case 4:
        s = s * 1.0f;
        b = b * 0.8f;
        break; // external edges
      case 5:
        s = 0.0f;
        break; // selected external edges
      case 6:
        s = s * 0.3f;
        break; // selected quad is whiter
      default:
        s = s * 1.0f;
        break;
    }
    return Color.getHSBColor(h, s, b).getRGBColorComponents(null);
  }
    public void setColor(Color color, Object source) {
      float[] hsb = new float[3];
      Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), hsb);

      myBrightnessComponent.setValue(255 - (int) (hsb[2] * 255));
      myBrightnessComponent.repaint();

      myColorWheel.dropImage();
      if (myOpacityComponent != null && source instanceof ColorPicker) {
        myOpacityComponent.setValue(color.getAlpha());
        myOpacityComponent.repaint();
      }

      myColorWheel.setColor(color, source);
    }
示例#30
0
 public int[][][] getHSVArray() {
   int[][][] hsvArray = new int[height][width][3];
   for (int x = 0; x < width; x++) {
     for (int y = 0; y < height; y++) {
       int red = getPixelRed(x, y) & 0xff;
       int green = getPixelGreen(x, y) & 0xff;
       int blue = getPixelBlue(x, y) & 0xff;
       float[] hsbvals = new float[3];
       hsbvals = Color.RGBtoHSB(red, green, blue, hsbvals);
       hsvArray[y][x][0] = (int) (255 * hsbvals[0]);
       hsvArray[y][x][1] = (int) (255 * hsbvals[1]);
       hsvArray[y][x][2] = (int) (255 * hsbvals[2]);
     }
   }
   return hsvArray;
 }