X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.utils.ui%2Fsrc%2Forg%2Fsimantics%2Futils%2Fui%2Fcolor%2FColor.java;fp=bundles%2Forg.simantics.utils.ui%2Fsrc%2Forg%2Fsimantics%2Futils%2Fui%2Fcolor%2FColor.java;h=b1f67289065c7a99d60ad339fb4b4727a6a59c56;hp=0000000000000000000000000000000000000000;hb=969bd23cab98a79ca9101af33334000879fb60c5;hpb=866dba5cd5a3929bbeae85991796acb212338a08 diff --git a/bundles/org.simantics.utils.ui/src/org/simantics/utils/ui/color/Color.java b/bundles/org.simantics.utils.ui/src/org/simantics/utils/ui/color/Color.java new file mode 100644 index 000000000..b1f672890 --- /dev/null +++ b/bundles/org.simantics.utils.ui/src/org/simantics/utils/ui/color/Color.java @@ -0,0 +1,339 @@ +/******************************************************************************* + * Copyright (c) 2007, 2010 Association for Decentralized Information Management + * in Industry THTH ry. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * VTT Technical Research Centre of Finland - initial API and implementation + *******************************************************************************/ +package org.simantics.utils.ui.color; + +import org.eclipse.swt.graphics.Device; +import org.eclipse.swt.graphics.RGB; + +/** + * Color class that can use both RGB and HSV values. + * + * @author Marko Luukkainen + * + */ +public class Color implements Comparable{ + + private int r; + + private int g; + + private int b; + + private float h; + + private float s; + + private float v; + + public Color() { + r = 255; + g = 255; + b = 255; + updateHSV(); + } + + public Color(int r, int g, int b) { + this.r = r; + this.g = g; + this.b = b; + updateHSV(); + } + + public Color(float h, float s, float v) { + this.h = h; + this.s = s; + this.v = v; + updateRGB(); + } + + public Color(double h, double s, double v) { + this.h = (float)h; + this.s = (float)s; + this.v = (float)v; + updateRGB(); + } + + public Color(RGB rgb) { + this.r = rgb.red; + this.g = rgb.green; + this.b = rgb.blue; + updateHSV(); + } + + public Color(Color color) { + this.r = color.r; + this.g = color.g; + this.b = color.b; + this.h = color.h; + this.s = color.s; + this.v = color.v; + } + + /** + * Sets color form AWT color. Alpha component is omitted. + * @param color + */ + public Color(java.awt.Color color) { + this.r = color.getRed(); + this.g = color.getGreen(); + this.b = color.getBlue(); + updateHSV(); + } + + public Color(org.eclipse.swt.graphics.Color color) { + this.r = color.getRed(); + this.g = color.getGreen(); + this.b = color.getBlue(); + updateHSV(); + } + + /** + * @return Returns the r component of RGB color. + */ + public int getR() { + return r; + } + + /** + * @return Returns the b component of RGB color. + */ + public int getB() { + return b; + } + + /** + * @return Returns the g component of RGB color. + */ + public int getG() { + return g; + } + + /** + * @return Returns the h component of HSV color . + */ + public float getH() { + return h; + } + + /** + * @return Returns the s component of HSV color. + */ + public float getS() { + return s; + } + + /** + * @return Returns the v component of HSV color. + */ + public float getV() { + return v; + } + + + public Color getWhite() { + return new Color(255, 255, 255); + } + + public Color getBlack() { + return new Color(0, 0, 0); + } + + public Color getRed() { + return new Color(255, 0, 0); + } + + public Color getGreen() { + return new Color(0, 255, 0); + } + + public Color getBlue() { + return new Color(0, 0, 255); + } + + /** + * Returns random color + * @return random color + */ + public static Color getRandom() { + return new Color((int) (Math.random() * 255), (int) (Math.random() * 255), (int) (Math.random() * 255)); + } + + /** + * Returns random color + * @param minSaturation minimum satuation of random color + * @param minValue minimum value of random color + * @return random color with specified mimimum allowed saturation and value + */ + public static Color getRandomHSV(float minSaturation, float minValue) { + float randS = (float)Math.random() * (1.f - minSaturation) + minSaturation; + float randV = (float)Math.random() * (1.f - minValue) + minValue; + return new Color((float)Math.random() * 360.f, randS, randV); + } + + /** + * Returns AWT Color + * @return + */ + public java.awt.Color getAWTColor() { + return new java.awt.Color(r,g,b); + } + + /** + * Returns SWT Color + * @param device + * @return + */ + public org.eclipse.swt.graphics.Color getSWTColor(Device device) { + return new org.eclipse.swt.graphics.Color(device,r,g,b); + } + + public RGB getRgb() { + return new RGB(r,g,b); + } + + /** + * Updates HSV values from RGB values + * + */ + private void updateHSV() { + float tr = (float) r / 255.f; + float tg = (float) g / 255.f; + float tb = (float) b / 255.f; + + v = Math.max(tr, tg); + v = Math.max(v, tb); + float min = Math.min(tr, tg); + min = Math.min(min, tb); + + float delta = v - min; + + if (v < 0.01f) { + s = 0.f; + } else { + s = delta / v; + } + + if (s == 0.f) { + h = Float.NaN; // saturation is 0 -> achromatic color + } else { + if (tr == v) { + h = 60.f * (tg - tb); + } else if (tg == v) { + h = 120.f + 60.f * (tb - tr); + } else { + h = 240.f + 60.f * (tr - tg); + } + if (h < 0.f) + h += 360.f; + } + + } + + private int floatToInt(float v) { + return (int) (v * 255.f); + } + + /** + * Updates RGB values from HSV values + * + */ + private void updateRGB() { + if (s == 0.f) { + //if (Float.isNaN(h)) { + h = Float.NaN; + r = floatToInt(v); + g = floatToInt(v); + b = floatToInt(v); + //} else { + // throw new RuntimeException("Saturation is 0 -> Hue must be undefined"); + //} + } else { + while (h < 0.f) + h+= 360.f; + while (h >= 360.f) + h-=360.f; + int hi = (int) Math.floor(h / 60.f); + float f = h / 60.f - hi; + float p = v * (1.f - s); + float q = v * (1.f - (f * s)); + float t = v * (1.f - ((1.f - f) * s)); + switch (hi) { + case 0: + r = floatToInt(v); + g = floatToInt(t); + b = floatToInt(p); + break; + case 1: + r = floatToInt(q); + g = floatToInt(v); + b = floatToInt(p); + break; + case 2: + r = floatToInt(p); + g = floatToInt(v); + b = floatToInt(t); + break; + case 3: + r = floatToInt(p); + g = floatToInt(q); + b = floatToInt(v); + break; + case 4: + r = floatToInt(t); + g = floatToInt(p); + b = floatToInt(v); + break; + case 5: + r = floatToInt(v); + g = floatToInt(p); + b = floatToInt(q); + break; + } + } + + } + + @Override + public int hashCode() { + return r ^ (g << 8) ^ (b << 16); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof Color)) + return false; + Color c = (Color) obj; + return (c.r==r && c.g==g && c.b==b); + } + + // Uses Hue value for comparisons. + @Override + public int compareTo(Color arg0) { + int d = (int)((h - arg0.h)*10000.f); + if (d == 0) { + d = r - arg0.r; + if (d == 0) { + d = g - arg0.g; + if (d == 0) { + d = b - arg0.b; + } + } + } + return d; + + } + + void setH(float h) { + this.h = h; + } + +}