// Could have been a dependency property that pieces of the UI bind to, but the interaction is complex enough
        // to make this the easier route:
        public void SetCurrentColor(HSVColor value)
        {
            this.currentColor = value;
              Color rgbColor = ColorConverter.HSVToRGB(value);

              this.ResetButton.IsEnabled = true;

              this.PreviewTile.Fill = new SolidColorBrush(rgbColor);

              // Only update the TextBox if this isn't being done in response to typing.  That prevents
              // text like "red" from changing to "#FF0000" and prevents the cursor from jumping to the beginning.
              if (!keyPressed)
            this.ColorTextBox.Text = value.ToString();

              this.HueGradientStop.Color = ColorConverter.HSVToRGB(new HSVColor { A = 255, H = value.H, S = 1, V = 1 });
              Canvas.SetLeft(this.HueThumb, (value.H / 360) * this.HueSlider.Width - this.HueThumb.Width / 2);

              // Update AlphaSlider and AlphaThumb:
              Color opaqueColor = rgbColor;
              opaqueColor.A = 255;
              Color transparentColor = rgbColor;
              transparentColor.A = 0;
              this.alphaGradientStop.Color = opaqueColor;
              this.alphaGradientStop2.Color = transparentColor;
              Canvas.SetLeft(this.AlphaThumb, ((double)value.A / 255) * this.AlphaSlider.Width - this.AlphaThumb.Width / 2);

              // Update SaturationValueMap:
              Point saturationValuePoint = new Point(value.S * this.SaturationValueMap.Width, value.V * this.SaturationValueMap.Height);
              this.SelectionLineX1.X1 = this.SelectionLineX1.X2 = saturationValuePoint.X;
              this.SelectionLineX2.X1 = this.SelectionLineX2.X2 = saturationValuePoint.X;
              this.SelectionLineY1.Y1 = this.SelectionLineY1.Y2 = saturationValuePoint.Y;
              this.SelectionLineY2.Y1 = this.SelectionLineY2.Y2 = saturationValuePoint.Y;
        }
  public static Color ToRGB(HSVColor hsv)
  {
    float r = hsv.h;
    float g = hsv.h;
    float b = hsv.h;
    if (hsv.s != 0)
    {
      float max = hsv.v;
      float diff = hsv.v * hsv.s;
      float min = hsv.v - diff;

      float h = hsv.h * 360.0f;

      if (h < 60.0f * 1)
      {
        r = max;
        g = h * diff / 60.0f + min;
        b = min;
      }
      else if (h < 60.0f * 2)
      {
        r = -(h - 120.0f) * diff / 60.0f + min;
        g = max;
        b = min;
      }
      else if (h < 60.0f * 3)
      {
        r = min;
        g = max;
        b = +(h - 120.0f) * diff / 60.0f + min;
      }
      else if (h < 60.0f * 4)
      {
        r = min;
        g = -(h - 240.0f) * diff / 60.0f + min;
        b = max;
      }
      else if (h < 60.0f * 5)
      {
        r = +(h - 240.0f) * diff / 60.0f + min;
        g = min;
        b = max;  
      }
      else if (h <= 60.0f * 6)
      {
        r = max;
        g = min;
        b = -(h - 360.0f) * diff / 60.0f + min;
      }
      else 
      {
        r = 0;
        g = 0;
        b = 0;
      }
    }
    return new Color(Mathf.Clamp01(r), Mathf.Clamp01(g), Mathf.Clamp01(b), hsv.a);
  }
Beispiel #3
0
 public ViewModel()
 {
     // Set default colour to white, full brightness
     rgbColor = new RGBColor(1.0f, 1.0f, 1.0f);
     hsvColor = new HSVColor(0.0f, 0.0f, 1.0f);
     temperature = ColorTemperature.Neutral;
     brightness = 1.0f;
     ColorChanged();
 }
Beispiel #4
0
        public void HoldColor(HSVColor color, LightZone zones, float duration, bool priority = false)
        {
            int frames = (int)Math.Round(duration * FPS);

            for (int i = 0; i < frames; i++)
            {
                LEDData data = LEDData.Empty;
                ApplyColorToZones(data, zones, color);
                SendFrame(data, zones, priority);
            }
        }
 public ColorScale(Color min, Color max, float minValue, float maxValue)
 {
     if (minValue >= maxValue)
     {
         throw new System.Exception("invalid parameters");
     }
     this.min      = new HSVColor(min);
     this.max      = new HSVColor(max);
     this.minValue = minValue;
     this.maxValue = maxValue;
 }
Beispiel #6
0
 private void OnCastE()
 {
     Task.Run(async() =>
     {
         await Task.Delay(1000);
         if (!rCastInProgress)
         {
             _ = animator.ColorBurst(HSVColor.FromRGB(229, 115, 255), 0.15f);
         }
     });
 }
Beispiel #7
0
 private IEnumerator WhileTimerTicking()
 {
     // Update the interface while the timer is going.
     while (true)
     {
         clockText.text             = string.Format(secondsFormat, drivingTimer.RemainingSeconds);
         radialFillImage.fillAmount = 1 - drivingTimer.Interpolant;
         radialFillImage.color      = HSVColor.Lerp(filledColor, emptyColor, drivingTimer.Interpolant).AsRGB;
         yield return(null);
     }
 }
        public static HSVColor ConvertRGBToHSV(double r, double b, double g)
        {
            double delta, min;
            double h = 0, s, v;

            min   = Math.Min(Math.Min(r, g), b);
            v     = Math.Max(Math.Max(r, g), b);
            delta = v - min;

            if (v.Equals(0))
            {
                s = 0;
            }
            else
            {
                s = delta / v;
            }

            if (s.Equals(0))
            {
                h = 360;
            }
            else
            {
                if (r.Equals(v))
                {
                    h = (g - b) / delta;
                }
                else if (g.Equals(v))
                {
                    h = 2 + (b - r) / delta;
                }
                else if (b.Equals(v))
                {
                    h = 4 + (r - g) / delta;
                }

                h *= 60;
                if (h <= 0.0)
                {
                    h += 360;
                }
            }

            HSVColor hsvColor = new HSVColor
            {
                H = 360 - h,
                S = s,
                V = v / 255
            };

            return(hsvColor);
        }
Beispiel #9
0
    //No need to test other values, because Unity's h values are only defined from [0, 1)
    public void GetNew_Test(float value)
    {
        // setup
        float    expected = value;
        HSVColor hsvColor = new HSVColor(Color.blue);

        // perform
        hsvColor = hsvColor.GetNew(value);

        // assert
        Assert.AreEqual(value, (float)Math.Round(hsvColor.h, 1));
    }
Beispiel #10
0
        bool Match(HSVColor ex, double hd, double sd, HSVColor test)
        {
            if (Math.Abs(ex.H - test.H) > hd)
            {
                return(false);
            }
            double ss     = ex.S - test.S;
            double vv     = ex.V - test.V;
            double svdist = Math.Sqrt(ss * ss + vv * vv);

            return(svdist <= sd);
        }
Beispiel #11
0
        List <string> colorValue(HSVColor hsvColor, ColorModel colorModel)
        {
            Color color = hsvColor.toColor();

            if (colorModel == ColorModel.hex)
            {
                return(new List <string>()
                {
                    color.red.ToString("X2"),
                    color.green.ToString("X2"),
                    color.blue.ToString("X2"),
                    $"{(color.opacity * 100).round()}%"
                });
            }
            else if (colorModel == ColorModel.rgb)
            {
                return(new List <string>()
                {
                    color.red.ToString(),
                    color.green.ToString(),
                    color.blue.ToString(),
                    $"{(color.opacity * 100).round()}%"
                });
            }
            else if (colorModel == ColorModel.hsv)
            {
                return(new List <string>()
                {
                    $"{hsvColor.hue.round()}°",
                    $"{(hsvColor.saturation * 100).round()}%",
                    $"{(hsvColor.value * 100).round()}%",
                    $"{(hsvColor.alpha * 100).round()}%",
                });
            }
            else if (colorModel == ColorModel.hsl)
            {
                HSLColor hslColor = Utils.hsvToHsl(hsvColor);
                return(new List <string>()
                {
                    $"{hslColor.hue.round()}°",
                    $"{(hslColor.saturation * 100).round()}%",
                    $"{(hslColor.lightness * 100).round()}%",
                    $"{(hslColor.alpha * 100).round()}%",
                });
            }
            else
            {
                return(new List <string>()
                {
                    "??", "??", "??", "??"
                });
            }
        }
Beispiel #12
0
        public static HSVColor GetColorFromJsonClass(JSONClass colorObject)
        {
            var h        = LoadFloatFromJsonFloatProperty(colorObject, "h", 0);
            var s        = LoadFloatFromJsonFloatProperty(colorObject, "s", 0);
            var v        = LoadFloatFromJsonFloatProperty(colorObject, "v", 0);
            var newColor = new HSVColor();

            newColor.H = h ?? 0;
            newColor.S = s ?? 0;
            newColor.V = v ?? 0;
            return(newColor);
        }
Beispiel #13
0
        public void TestSClamping_validValue()
        {
            HSVColor actual = new HSVColor(0.5f, 0.5f, 0.5f);

            actual.Saturation = 0.7f;

            HSVColor expected = new HSVColor(0.5f, 0.7f, 0.5f);

            Assert.That(actual.Hue, Is.EqualTo(expected.Hue));
            Assert.That(actual.Saturation, Is.EqualTo(expected.Saturation));
            Assert.That(actual.Value, Is.EqualTo(expected.Value));
        }
Beispiel #14
0
        public void TestHClamping_TooHighValue()
        {
            HSVColor actual = new HSVColor(0.5f, 0.5f, 0.5f);

            actual.Hue = 2.7f;

            HSVColor expected = new HSVColor(1.0f, 0.5f, 0.5f);

            Assert.That(actual.Hue, Is.EqualTo(expected.Hue));
            Assert.That(actual.Saturation, Is.EqualTo(expected.Saturation));
            Assert.That(actual.Value, Is.EqualTo(expected.Value));
        }
Beispiel #15
0
 public Widget colorPickerSlider(TrackType trackType)
 {
     return(new ColorPickerSlider(
                trackType,
                currentHsvColor,
                (HSVColor color) => {
         setState(() => { currentHsvColor = color; });
         widget.onColorChanged(currentHsvColor);
     },
                displayThumbColor: widget.displayThumbColor
                ));
 }
        public Led[] DoFrame()             // TODO: Latency issues...
        {
            leds.FadeToBlackAllLeds(0.3f); // 0.3f * delta que es 20 ms se supone
            if (!newAudioAvailable)
            {
                return(this.leds);
            }
            newAudioAvailable = false;
            var y_in = FFTUtil.ProcessAudio(audio);

            if (y_in.Length < this.lastIndex)
            {
                return(this.leds);
            }
            var y = new double[this.lastIndex];

            Array.Copy(y_in, 0, y, 0, this.lastIndex);
            y = y.Select(x => x < 0 ? 0 : x).ToArray();
            double[] y_scaled = new double[this.lastIndex];

            for (int i = 0; i < this.lastIndex; i++)
            {
                var    freq = FFTUtil.GetFreqForIndex(i, FFT_SPACING_HZ);
                var    val  = y[i];
                double scaled;
                if (freq <= BASS_MAX_FREQ)
                {
                    scaled = Utils.Scale(val, 0, BASS_TOP_LIMIT, 0, 1);
                }
                else
                {
                    scaled = Utils.Scale(val, 0, MID_TOP_LIMIT, 0, 1);
                }
                y_scaled[i] = scaled;
            }

            HSVColor[] yColors = new HSVColor[this.lastIndex];
            for (int i = 0; i < this.lastIndex; i++)
            {
                yColors[i] = UtilsLED.ValueToHSV(this.ledCount / 2, this.freqArray[i], y_scaled[i]);
            }

            for (int i = 0; i < this.lastIndex; i++)
            {
                if (this.freqArray[i] == this.ledCount / 2)
                {
                    break;
                }
                leds.AddSymmetricColorAroundLeds(this.freqArray[i], yColors[i]);
            }

            return(this.leds);
        }
Beispiel #17
0
    public static HSVColor RGBToHSV(Color color)
    {
        HSVColor ret = new HSVColor(0f, 0f, 0f, color.a);

        float r = color.r;
        float g = color.g;
        float v = color.b;

        float max = Mathf.Max(r, Mathf.Max(g, v));

        if (max <= 0f)
        {
            return(ret);
        }

        float min = Mathf.Min(r, Mathf.Min(g, v));
        float dif = max - min;

        if (max > min)
        {
            if (WadeUtils.AreEqual(g, max))
            {
                ret.h = (v - r) / dif * 60f + 120f;
            }
            else if (WadeUtils.AreEqual(v, max))
            {
                ret.h = (r - g) / dif * 60f + 240f;
            }
            else if (v > g)
            {
                ret.h = (g - v) / dif * 60f + 360f;
            }
            else
            {
                ret.h = (g - v) / dif * 60f;
            }

            if (WadeUtils.IsNegative(ret.h))
            {
                ret.h = ret.h + 360f;
            }
        }
        else
        {
            ret.h = 0f;
        }

        ret.h *= 1f / 360f;
        ret.s  = (dif / max) * 1f;
        ret.v  = max;

        return(ret);
    }
Beispiel #18
0
        private void ApplyColorToZones(LEDData frameData, LightZone zones, HSVColor color)
        {
            List <Led[]> colArrays = frameData.GetArraysForZones(zones);

            foreach (Led[] arr in colArrays)
            {
                foreach (Led l in arr)
                {
                    l.Color(color);
                }
            }
        }
Beispiel #19
0
        protected void SetupPluginUI()
        {
            List <string> choices = new List <string>();

            choices.Add("None");
            choices.Add("FPS");
            choices.Add("Load Dir");
            choices.Add("Total Atoms");

            JSONStorableStringChooser jsonTypeTopLeft = new JSONStorableStringChooser("TopLeft", choices, typeTopLeft, "Top Left", SetTopLeft);
            UIDynamicPopup            dropdownTopLeft = CreatePopup(jsonTypeTopLeft);

            dropdownTopLeft.labelWidth = 300f;

            JSONStorableStringChooser jsonTypeTopRight = new JSONStorableStringChooser("TopRight", choices, typeTopRight, "Top Right", SetTopRight);
            UIDynamicPopup            dropdownTopRight = CreatePopup(jsonTypeTopRight, true);

            dropdownTopRight.labelWidth = 300f;

            JSONStorableStringChooser jsonTypeBottomLeft = new JSONStorableStringChooser("BottomLeft", choices, typeBottomLeft, "Bottom Left", SetBottomLeft);
            UIDynamicPopup            dropdownBottomLeft = CreatePopup(jsonTypeBottomLeft);

            dropdownBottomLeft.labelWidth = 300f;

            JSONStorableStringChooser jsonTypeBottomRight = new JSONStorableStringChooser("BottomRight", choices, typeBottomRight, "Bottom Right", SetBottomRight);
            UIDynamicPopup            dropdownBottomRight = CreatePopup(jsonTypeBottomRight, true);

            dropdownBottomRight.labelWidth = 300f;

            // let user adjust scale and top for HMD viewport differences and personal preference.
            JSONStorableFloat jsonTopOffset = new JSONStorableFloat("Top Offset", topOffset, SetTopOffset, -2f, +2f, true);

            RegisterFloat(jsonTopOffset);
            sliderTopOffset = CreateSlider(jsonTopOffset);

            JSONStorableFloat jsonScale = new JSONStorableFloat("HUD Scale", hudScale, SetScale, 10f, 200f, true);

            RegisterFloat(jsonScale);
            sliderScale = CreateSlider(jsonScale);

            JSONStorableFloat jsonFontSize = new JSONStorableFloat("Text Size", fontSize, SetFontSize, 10f, 100f, true);

            RegisterFloat(jsonFontSize);
            sliderFontSize = CreateSlider(jsonFontSize);


            // JSONStorableColor example
            HSVColor          hsvc          = HSVColorPicker.RGBToHSV(textColor.r, textColor.g, textColor.b);
            JSONStorableColor jsonTextColor = new JSONStorableColor("Text Color", hsvc, SetTextColor);

            RegisterColor(jsonTextColor);
            CreateColorPicker(jsonTextColor, true);
        }
Beispiel #20
0
    public HSVColorBuffer(int width, int height, Color[] colorData)
    {
        this.width  = width;
        this.height = height;

        this.data = new HSVColor[colorData.Length];

        for (int i = 0; i < colorData.Length; i++)
        {
            this.data[i] = HSVColor.FromColor(colorData[i]);
        }
    }
        public static Animation LoadFromFile(string path)
        {
            string text = "";

            try
            {
                text = File.ReadAllText(path);
            } catch (Exception e)
            {
                Debug.WriteLine(e.StackTrace);
                throw new ArgumentException("File does not exist.", e);
            }
            try
            {
                string[] lines         = text.Split('\n');
                string[] data          = lines[0].Split(',');
                int      numLeds       = int.Parse(data[0]);
                int      numFrames     = int.Parse(data[1]);
                string   animationData = "";
                if (lines.Length > 2)
                {
                    // multiline format
                    for (int i = 1; i <= numFrames; i++)
                    {
                        lines[i]       = lines[i].Replace("\r", "");
                        lines[i]       = lines[i].Replace("\n", ",");
                        animationData += lines[i];
                    }
                }
                else
                {
                    animationData = lines[1];
                }
                string[]          bytes     = animationData.Split(',');
                List <HSVColor[]> animation = new List <HSVColor[]>();
                for (int i = 0; i < numFrames; i++)
                {
                    animation.Add(new HSVColor[numLeds]);
                    for (int j = 0; j < numLeds; j++)
                    {
                        Color    rgb = Color.FromArgb(int.Parse(bytes[i * numLeds * 3 + j * 3 + 0]), int.Parse(bytes[i * numLeds * 3 + j * 3 + 1]), int.Parse(bytes[i * numLeds * 3 + j * 3 + 2]));
                        HSVColor c   = HSVColor.FromRGB(rgb);
                        animation[i][j] = c;
                    }
                }
                return(new Animation(animation));
            } catch (Exception e)
            {
                Debug.WriteLine("Error reading animation");
                Debug.WriteLine(e.StackTrace);
                throw e;
            }
        }
    void Init()
    {
        delaunayTriangulation = new DelaunayTriangulation();
        Color.RGBToHSV(color, out hsvColor.h, out hsvColor.s, out hsvColor.v);

        orgPosList = new List <Vector3> ();
        // randomPoints
        for (var i = 0; i < num; i++)
        {
            orgPosList.Add(createVector(random(rect.xMin, rect.xMax), random(rect.yMin, rect.yMax)));
        }
        int pointCount = orgPosList.Count;

        // speed
        spList = new List <Vector3> ();
        for (int i = 0; i < pointCount; i++)
        {
            Vector3 sp = new Vector3(Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f));
            spList.Add(sp);
        }

        // current
        currentPosList = new List <Vector3> ();
        currentPosList.AddRange(orgPosList);
        movePosList = new List <Vector3> ();
        for (int i = 0; i < pointCount; i++)
        {
            movePosList.Add(Vector3.zero);
        }

        // v color
        float h = hsvColor.h;

        hsvColors = new List <HSVColor> ();
        for (int i = 0; i < 7; i++)
        {
            HSVColor c = new HSVColor(h, 0, 0);
            hsvColors.Add(c);
        }

        for (int i = 0; i < pointCount; i++)
        {
            float    s = Random.Range(0.5f, 1) * 0.5f;
            float    b = Random.Range(0.3f, 1) * 0.5f;
            HSVColor c = new HSVColor(h, s, b);
            hsvColors.Add(c);
        }

        // mesh
        mesh    = new Mesh();
        mf.mesh = mesh;
    }
    public static HSVColor FromColor(Color color)
    {
        HSVColor ret = new HSVColor(0f, 0f, 0f, color.a);

        float r = color.r;
        float g = color.g;
        float b = color.b;

        float max = Mathf.Max(r, Mathf.Max(g, b));

        if (max <= 0)
        {
            return(ret);
        }

        float min = Mathf.Min(r, Mathf.Min(g, b));
        float dif = max - min;

        if (max > min)
        {
            if (g == max)
            {
                ret.h = (b - r) / dif * 60f + 120f;
            }
            else if (b == max)
            {
                ret.h = (r - g) / dif * 60f + 240f;
            }
            else if (b > g)
            {
                ret.h = (g - b) / dif * 60f + 360f;
            }
            else
            {
                ret.h = (g - b) / dif * 60f;
            }
            if (ret.h < 0)
            {
                ret.h = ret.h + 360f;
            }
        }
        else
        {
            ret.h = 0;
        }

        ret.h *= 1f / 360f;
        ret.s  = (dif / max) * 1f;
        ret.v  = max;

        return(ret);
    }
Beispiel #24
0
	public static HSVColor FromColor(Color color)
	{
		HSVColor ret = new HSVColor(0f, 0f, 0f, color.a);

		float r = color.r;
		float g = color.g;
		float b = color.b;

		float max = Mathf.Max(r, Mathf.Max(g, b));

		if (max <= 0)
		{
			return ret;
		}

		float min = Mathf.Min(r, Mathf.Min(g, b));
		float dif = max - min;

		if (max > min)
		{
			if (g == max)
			{
				ret.h = (b - r) / dif * 60f + 120f;
			}
			else if (b == max)
			{
				ret.h = (r - g) / dif * 60f + 240f;
			}
			else if (b > g)
			{
				ret.h = (g - b) / dif * 60f + 360f;
			}
			else
			{
				ret.h = (g - b) / dif * 60f;
			}
			if (ret.h < 0)
			{
				ret.h = ret.h + 360f;
			}
		}
		else
		{
			ret.h = 0;
		}

		ret.h *= 1f / 360f;
		ret.s = (dif / max) * 1f;
		ret.v = max;

		return ret;
	}
        private static void GoldView(Led[] leds, LightingMode lightMode, GameState gameState)
        {
            HSVColor col = HSVColor.Black;

            if (gameState.ActivePlayer.CurrentGold >= GoldNotificationThreshold)
            {
                col = GoldColor;
            }
            foreach (int k in goldKeys)
            {
                leds[k].Color(col);
            }
        }
        private void GoldView(LEDData data, GameState gameState)
        {
            HSVColor col = HSVColor.Black;

            if (gameState.ActivePlayer.CurrentGold >= GoldNotificationThreshold)
            {
                col = GoldColor;
            }
            foreach (int k in goldKeys)
            {
                data.Keyboard[k].Color(col);
            }
        }
Beispiel #27
0
            public override void Update(GameTime gt)
            {
                base.Update(gt);

                foreach (var tile in GetTiles())
                {
                    //Convert color to HSV, increase hue, then put it back
                    HSVColor hsv = ColorMath.RGBtoHSV(tile.Color);
                    hsv.H            += HUEINCREASE;
                    tile.Color        = ColorMath.HSVtoRGB(hsv);
                    tile.Color.Action = ColorOutOfBoundsAction.WrapAround;
                }
            }
Beispiel #28
0
    public void ToRGBAfterGetNew_Test(float h, float r, float g, float b)
    {
        // setup
        Color    expected = new Color(r, g, b);
        HSVColor hsvColor = new HSVColor(Color.red);

        // perform
        hsvColor = hsvColor.GetNew(h);
        Color actual = hsvColor.ToRGB();

        // assert
        Assert.AreEqual(expected, actual);
    }
Beispiel #29
0
 public ColorPickerSlider(
     TrackType trackType,
     HSVColor hsvColor,
     ValueChanged <HSVColor> onColorChanged = null,
     bool displayThumbColor = false,
     bool fullThumbColor    = false
     )
 {
     this.trackType         = trackType;
     this.hsvColor          = hsvColor;
     this.onColorChanged    = onColorChanged;
     this.displayThumbColor = displayThumbColor;
     this.fullThumbColor    = fullThumbColor;
 }
Beispiel #30
0
        public override void paint(Canvas canvas, Size size)
        {
            Rect rect      = Offset.zero & size;
            var  gradientV = new LinearGradient(
                begin: Alignment.topCenter,
                end: Alignment.bottomCenter,
                colors: new List <Color> {
                Colors.white, Colors.black
            }
                );
            var gradientH = new LinearGradient(
                colors: new List <Color> {
                Colors.white,
                HSVColor.fromAHSV(1f, hsvColor.hue, 1f, 1f).toColor()
            }
                );

            var paint = new Paint()
            {
                strokeWidth = 1.5f, style = PaintingStyle.stroke
            };

            if (pointerColor != null)
            {
                paint.color = pointerColor;
            }
            else if (Utils.useWhiteForeground(hsvColor.toColor()))
            {
                paint.color = Colors.white;
            }
            else
            {
                paint.color = Colors.black;
            }


            canvas.drawRect(rect, new Paint()
            {
                shader = gradientV.createShader(rect)
            });
            canvas.drawRect(rect, new Paint()
            {
                blendMode = BlendMode.multiply, shader = gradientH.createShader(rect)
            });
            canvas.drawCircle(
                new Offset(size.width * hsvColor.saturation, size.height * (1 - hsvColor.value)),
                size.height * 0.04f,
                paint
                );
        }
Beispiel #31
0
 public Widget colorPickerArea()
 {
     return(new ClipRRect(
                borderRadius: widget.pickerAreaBorderRadius,
                child: new ColorPickerArea(
                    currentHsvColor,
                    (HSVColor color) => {
         setState(() => { currentHsvColor = color; });
         widget.onColorChanged(currentHsvColor);
     },
                    widget.paletteType
                    ) //ColorPickerArea
                ));   //ClipRRect
 }
Beispiel #32
0
        void UpdateRGBAControls(ColorValue value, object ignoreControl)
        {
            HSVColor hsvColor = HSVColor.FromRGB(value);

            if (ignoreControl != colorWheel)
            {
                colorWheel.HsvColor = hsvColor;
            }
            if (ignoreControl != colorGradientControl)
            {
                colorGradientControl.Value       = (int)(hsvColor.Value * 255);
                colorGradientControl.TopColor    = new HSVColor(hsvColor.Hue, hsvColor.Saturation, 1).ToColor();
                colorGradientControl.BottomColor = Color.Black;
            }

            if (ignoreControl != numericUpDownRed)
            {
                numericUpDownRed.Value = (decimal)MathEx.Saturate(value.Red) * 255;
            }
            if (ignoreControl != numericUpDownGreen)
            {
                numericUpDownGreen.Value = (decimal)MathEx.Saturate(value.Green) * 255;
            }
            if (ignoreControl != numericUpDownBlue)
            {
                numericUpDownBlue.Value = (decimal)MathEx.Saturate(value.Blue) * 255;
            }
            if (ignoreControl != numericUpDownAlpha)
            {
                numericUpDownAlpha.Value = (decimal)(MathEx.Saturate(noAlpha ? 1 : value.Alpha) * 255);
            }

            if (ignoreControl != trackBarRed)
            {
                trackBarRed.Value = (int)(MathEx.Saturate(value.Red) * 1000);
            }
            if (ignoreControl != trackBarGreen)
            {
                trackBarGreen.Value = (int)(MathEx.Saturate(value.Green) * 1000);
            }
            if (ignoreControl != trackBarBlue)
            {
                trackBarBlue.Value = (int)(MathEx.Saturate(value.Blue) * 1000);
            }
            if (ignoreControl != trackBarAlpha)
            {
                trackBarAlpha.Value = (int)(MathEx.Saturate(noAlpha ? 1 : value.Alpha) * 1000);
            }
        }
Beispiel #33
0
 public Widget colorPickerSlider(TrackType trackType)
 {
     return(new ColorPickerSlider(
                trackType,
                currentHsvColor,
                (HSVColor color) =>
     {
         //UnityEngine.Debug.Log(color.toColor());
         setState(() => { currentHsvColor = color; });
         widget.onColorChanged(currentHsvColor.toColor());
     },
                displayThumbColor: widget.displayThumbColor,
                fullThumbColor: true
                ));
 }
Beispiel #34
0
    public Color temperatureColor(float temperature)
    {
        HSVColor magenta = new HSVColor(0.90f, 1, 1);
        HSVColor red     = new HSVColor(0, 1, 1);
        float    t       = MyMath.remap(temperature, min, max, 0, 1.166f);

        if (t >= 0.166f)
        {
            return(HSVColor.lerpHue(magenta, red, t - 0.166f).toRGB());
        }
        else
        {
            return(Color.Lerp(Color.white, magenta.toRGB(), t / 0.166f));
        }
    }
  public static HSVColor FromRGB(Color rgb)
  {
    HSVColor hsv = new HSVColor(0.0f, 0.0f, 0.0f, rgb.a);

    float r = rgb.r;
    float g = rgb.g;
    float b = rgb.b;

    float max = Mathf.Max(r, g, b);
    if (max <= 0)
      return hsv;

    float min = Mathf.Min(r, g, b);
    float diff = max - min;

    if (max > min)
    {
      if (g == max)
      {
        hsv.h = (b - r) / diff * 60.0f + 60.0f * 2;
      }
      else if (b == max)
      {
        hsv.h = (r - g) / diff * 60.0f + 60.0f * 4;
      } 
      else if (b > g)
      {
        hsv.h = (g - b) / diff * 60.0f + 60.0f * 6;
      }
      else
      {
        hsv.h = (g - b) / diff * 60.0f + 60.0f * 0;
      }
      if (hsv.h < 0)
      {
        hsv.h = hsv.h + 360.0f;
      }
    }
    hsv.h *= 1.0f / 360.0f;
    hsv.s = (diff / max) * 1.0f;
    hsv.v = max;

    return hsv;
  }
	private Color GetNewBuildingColor() {
		HSVColor color = new HSVColor(hue, Random.Range(0.4f, 0.6f), Random.Range(0.7f, 0.9f));
		return color.HSVToRGB();
	}
Beispiel #37
0
    public static Color HSVToRGB(HSVColor hsvColor)
    {
        int hi = Convert.ToInt32(Math.Floor(hsvColor.H / 60)) % 6;
        double f = hsvColor.H / 60 - Math.Floor(hsvColor.H / 60);

        hsvColor.V = hsvColor.V * 255;
        byte v = Convert.ToByte(hsvColor.V);
        byte p = Convert.ToByte(hsvColor.V * (1 - hsvColor.S));
        byte q = Convert.ToByte(hsvColor.V * (1 - f * hsvColor.S));
        byte t = Convert.ToByte(hsvColor.V * (1 - (1 - f) * hsvColor.S));

        if (hi == 0)
          return Color.FromArgb(hsvColor.A, v, t, p);
        else if (hi == 1)
          return Color.FromArgb(hsvColor.A, q, v, p);
        else if (hi == 2)
          return Color.FromArgb(hsvColor.A, p, v, t);
        else if (hi == 3)
          return Color.FromArgb(hsvColor.A, p, q, v);
        else if (hi == 4)
          return Color.FromArgb(hsvColor.A, t, p, v);
        else
          return Color.FromArgb(hsvColor.A, v, p, q);
    }
Beispiel #38
0
    // Generate random colour values into colour arrays and set color
    void generateNewColor(int index)
    {
        double range = 360d / ingredients.Length;
        double myHue = 0d;
        if (!initialPass)
        {
            myHue = ingredHues[index];
            updateAvailableHues(index, (int)range, (int)myHue, true);
        }
        int hue;
        if(index < 5)
        {
            int[] a = new int[availableHuesLeft.Count];
            availableHuesLeft.CopyTo(a);
            hue = a[r.Next(a.Length)];           
        }
        else
        {
            int[] a = new int[availableHuesRight.Count];
            availableHuesRight.CopyTo(a);
            hue = a[r.Next(a.Length)];
        }
        updateAvailableHues(index, (int)range, (int)hue, false);

        myHue = (double)hue + r.NextDouble() * Math.Pow(-1d, r.Next(2));

        ingredHues[index] = myHue;
        Color32 color = new HSVColor(ingredHues[index], saturation, value).RgbColor;
        Renderer rend = ingredients[index].GetComponent<Renderer>();
        rend.material.color = color;
    }
Beispiel #39
0
 private void CieXYZChanged()
 {
     rgbColor = xyzColor;
     xyyColor = xyzColor;
     hsvColor = rgbColor;
 }
Beispiel #40
0
	public void BurstTrailColor(Color color) {
		isBursting = true;
		currentColorHSV = WadeUtils.RGBToHSV(color);
	}
Beispiel #41
0
 private void SetColorsHSV(int index, float h, float s, float v)
 {
     colors[0][index] = new HSVColor(h, 1f, 1f).ToColor(255);
     colors[1][index] = new Color32(255, 255, 255, (byte)((1 - s) * 255));
     colors[2][index] = new Color32(0, 0, 0, (byte)((1 - v) * 255));
 }
Beispiel #42
0
 private void RgbChanged()
 {
     hsvColor = (HSVColor)rgbColor;
     xyzColor = rgbColor;
     xyyColor = xyzColor;
     //application.color = rgbColor;
 }
 public static void Extract1Channel(HSV161616Image image, HSVColor plane, DoubleImage chan) {
   VisionLabPINVOKE.Extract1Channel__SWIG_78(HSV161616Image.getCPtr(image), (int)plane, DoubleImage.getCPtr(chan));
   if (VisionLabPINVOKE.SWIGPendingException.Pending) throw VisionLabPINVOKE.SWIGPendingException.Retrieve();
 }
Beispiel #44
0
 private void CiexyYChanged()
 {
     xyzColor = xyyColor;
     rgbColor = xyzColor;
     hsvColor = rgbColor;
 }
Beispiel #45
0
	public static void Test()
	{
		HSVColor color;

		color = new HSVColor(Color.red);
		Debug.Log("red: " + color);

		color = new HSVColor(Color.green);
		Debug.Log("green: " + color);

		color = new HSVColor(Color.blue);
		Debug.Log("blue: " + color);

		color = new HSVColor(Color.grey);
		Debug.Log("grey: " + color);

		color = new HSVColor(Color.white);
		Debug.Log("white: " + color);

		color = new HSVColor(new Color(0.4f, 1f, 0.84f, 1f));
		Debug.Log("0.4, 1f, 0.84: " + color);

		Debug.Log("164,82,84   .... 0.643137f, 0.321568f, 0.329411f  :" + ToColor(new HSVColor(new Color(0.643137f, 0.321568f, 0.329411f))));
	}
Beispiel #46
0
    public static void BlendColors(Color color2)
    {
        HSVColor c1 = new HSVColor(color);
        HSVColor c2 = new HSVColor(color2);

        Debug.Log("4r=" + color.r + " g=" + color.g + " b=" + color.b);
        Debug.Log("h1=" + c1.hue + " h2=" + c2.hue);

        double delta1;
        double delta2;

        if (c1.hue > c2.hue)
        {
            delta1 = (360d - c1.hue) + c2.hue;
        }
        else
        {
            delta1 = (360d - c2.hue) + c1.hue;
        }

        delta2 = c2.hue - c1.hue;

        if (Math.Abs(delta1) >= Math.Abs(delta2))
        {
            c1.hue += blendFactor * delta2;
            Debug.Log("diff=" + delta2);
        }
        else
        {
            Debug.Log("diff=" + delta1);
            if (c1.hue > c2.hue)
            {
                c1.hue += blendFactor * delta1;
                c1.hue %= 360;
            }
            else
            {
                c1.hue -= blendFactor * delta1;
                if (c1.hue < 0)
                {
                    c1.hue = 360 + c1.hue;
                }
            }
        }

        Debug.Log("5new hue=" + c1.hue);
        h = c1.hue;
        color = c1.RgbColor;
        Debug.Log("r=" + color.r + " g=" + color.g + " b=" + color.b);
    }
Beispiel #47
0
	public static Color ToColor(HSVColor hsvColor)
	{
		float r = hsvColor.v;
		float g = hsvColor.v;
		float b = hsvColor.v;
		if (hsvColor.s != 0)
		{
			float max = hsvColor.v;
			float dif = hsvColor.v * hsvColor.s;
			float min = hsvColor.v - dif;

			float h = hsvColor.h * 360f;

			if (h < 60f)
			{
				r = max;
				g = h * dif / 60f + min;
				b = min;
			}
			else if (h < 120f)
			{
				r = -(h - 120f) * dif / 60f + min;
				g = max;
				b = min;
			}
			else if (h < 180f)
			{
				r = min;
				g = max;
				b = (h - 120f) * dif / 60f + min;
			}
			else if (h < 240f)
			{
				r = min;
				g = -(h - 240f) * dif / 60f + min;
				b = max;
			}
			else if (h < 300f)
			{
				r = (h - 240f) * dif / 60f + min;
				g = min;
				b = max;
			}
			else if (h <= 360f)
			{
				r = max;
				g = min;
				b = -(h - 360f) * dif / 60 + min;
			}
			else
			{
				r = 0;
				g = 0;
				b = 0;
			}
		}

		return new Color(Mathf.Clamp01(r),Mathf.Clamp01(g),Mathf.Clamp01(b),hsvColor.a);
	}
 public static string HSVColorToStr(HSVColor col) {
   string ret = VisionLabPINVOKE.HSVColorToStr((int)col);
   if (VisionLabPINVOKE.SWIGPendingException.Pending) throw VisionLabPINVOKE.SWIGPendingException.Retrieve();
   return ret;
 }
Beispiel #49
0
	public static HSVColor Lerp(HSVColor a, HSVColor b, float t)
	{
		float h,s;

		//check special case black (color.b==0): interpolate neither hue nor saturation!
		//check special case grey (color.s==0): don't interpolate hue!
		if(a.v==0){
			h=b.h;
			s=b.s;
		}else if(b.v==0){
			h=a.h;
			s=a.s;
		}else{
			if(a.s==0){
				h=b.h;
			}else if(b.s==0){
				h=a.h;
			}else{
				// works around bug with LerpAngle
				float angle = Mathf.LerpAngle(a.h * 360f, b.h * 360f, t);
				while (angle < 0f)
					angle += 360f;
				while (angle > 360f)
					angle -= 360f;
				h=angle/360f;
			}
			s=Mathf.Lerp(a.s,b.s,t);
		}
		return new HSVColor(h, s, Mathf.Lerp(a.v, b.v, t), Mathf.Lerp(a.a, b.a, t));
	}
Beispiel #50
0
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

              if (this.State.ContainsKey("CurrentColor"))
              {
            SetCurrentColor((HSVColor)this.State["CurrentColor"]);
              }
              else if (NavigationContext.QueryString.ContainsKey("currentColor"))
              {
            Color color;
            if (TryGetColorFromText("#" + NavigationContext.QueryString["currentColor"], out color))
              SetCurrentColor(ColorConverter.RGBToHSV(color));
              }

              if (NavigationContext.QueryString.ContainsKey("defaultColor"))
              {
            Color color;
            if (TryGetColorFromText("#" + NavigationContext.QueryString["defaultColor"], out color))
              defaultColor = ColorConverter.RGBToHSV(color);

            if (defaultColor == currentColor)
            {
              this.Focus(); // So focus doesn't go to TextBox and bring up keyboard
              this.ResetButton.IsEnabled = false;
            }
              }

              if (NavigationContext.QueryString.ContainsKey("settingName"))
            settingName = NavigationContext.QueryString["settingName"];

              if (NavigationContext.QueryString.ContainsKey("showOpacity"))
              {
            bool newValue = Convert.ToBoolean(NavigationContext.QueryString["showOpacity"]);

            // Only do this if switching from showing to not showing, to guard against multiple navigations to this page
            // (for example, from locking/unlocking the phone)
            if (showOpacity && !newValue)
            {
              // Hide options for non-opaque colors
              AlphaPanel.Visibility = Visibility.Collapsed;
              TransparentPresetColor.Visibility = Visibility.Collapsed;

              // Spread out remaining UI
              Canvas.SetTop(ColorPresetsPanel, Canvas.GetTop(ColorPresetsPanel) + 14);
              Canvas.SetTop(SaturationValuePanel, Canvas.GetTop(SaturationValuePanel) + 30);
              Canvas.SetTop(HuePanel, Canvas.GetTop(HuePanel) + 50);
            }
            showOpacity = newValue;
              }
        }
Beispiel #51
0
 private void TemperatureChanged()
 {
     xyzColor = (CIEXYZColour)temperature;
     xyyColor = (CIEXYYColor)xyzColor;
     rgbColor = (RGBColor)xyzColor;
     hsvColor = (HSVColor)rgbColor;
     //this.RgbChanged();
 }