Best way to generate random Color and exclude old one

Question

Not exactly sure how to phrase the title but I want to generate a random color every second on an object. I also want this color to not be similar to the old color the object already has. If the current random color is the-same as the color the Object already has, re-generate the random color again. That object is simply a Text component.

This is the function I use to generate the color:

public Color genRandomColor()
{
    float r, g, b;
    r = UnityEngine.Random.Range(0f, 1f);
    g = UnityEngine.Random.Range(0f, 1f);
    b = UnityEngine.Random.Range(0f, 1f);

    return new Color(r, g, b);
}

For comparing if the color are similar, I ported and used the function from this answer to C#.

public double ColourDistance(Color32 c1, Color32 c2)
{
    double rmean = (c1.r + c2.r) / 2;
    int r = c1.r - c2.r;
    int g = c1.g - c2.g;
    int b = c1.b - c2.b;
    double weightR = 2 + rmean / 256;
    double weightG = 4.0;
    double weightB = 2 + (255 - rmean) / 256;
    return Math.Sqrt(weightR * r * r + weightG * g * g + weightB * b * b);
}

I put the random color generator in while loop inside a coroutine function to run over and over again until the generated color is not similar. I use yield return null; to wait for a frame each time I generate a random color so that it does not freeze the program.

const float threshold = 400f;
bool keepRunning = true;

while (keepRunning)
{
    Text text = obj.GetComponent<Text>();

    //Generate new color but make sure it's not similar to the old one
    Color randColor = genRandomColor();
    while ((ColourDistance(text.color, randColor) <= threshold))
    {
        Debug.Log("Color not original. Generating a new Color next frame");
        randColor = genRandomColor();
        yield return null;
    }

    text.color = randColor;
    yield return new WaitForSeconds(1f);
}

Everything seems to be working with one minor problem.

The problem is that it takes 1 to 3 seconds to re-generate a color that is not a similar to the old one sometimes. I removed yield return null; to prevent it from waiting each frame and it seems to work now but I risk freezing the whole game since I am now using the random function to control the while loop. Already, I've noticed tiny freezes and that's not good.

What's a better way to generate a random color that is not similar to the object's new color without freezing the game or waiting for seconds?

Answer 1

I would take a different approach:

• Generate a random integer in [0; 2] representing red, green, blue
• Add 0.5 to the color just determined in the first step but subtract -1 if greater than 1
• Generate 2 independent random float numbers in the range [0; 1] that are taken for the remaining two color components

Example: Assume we have C1 = (R1; G1; B1) = (0.71; 0.22; 0.83)

• Assume step 1 produces index 0 i.e. red
• So we take R1 + 0.5 = 0.71 + 0.5f = 0.21f
• We create G2 and B2 as new green and blue components and get (0.21f; G2; B2)

Even if G2 and B2 are identical to their predecessors the new color will be clearly distinct as R2 is shifted

Update code

public static class RandomColorGenerator
{
    public static Color GetNextPseudoRandomColor(Color current)
    {
        int keep = new System.Random().Next(0, 2);
        float red = UnityEngine.Random.Range(0f, 1f);
        float green = UnityEngine.Random.Range(0f, 1f);
        float blue = UnityEngine.Random.Range(0f, 1f);
        Color c = new Color(red, green, blue);
        float fixedComp = c[keep] + 0.5f;
        c[keep] = fixedComp - Mathf.Floor(fixedComp);
        return c;
    }
}

Test:

public class RandomColorTest
{
    [Test]
    public void TestColorGeneration()
    {
        Color c = Color.magenta;
        for (int i = 0; i < 100; i++)
        {
            Vector3 pos = new Vector3(i / 20f, 0f, 0f);
            c = RandomColorGenerator.GetNextPseudoRandomColor(c); 
            Debug.Log(i + " = " + c);
            Debug.DrawRay(pos, Vector3.up, c);
        }
    }
}

Result in scene view around (0; 0; 0) after running editor test

Answer 2

Here's another idea:

Rather than generating the RBG components, instead generate a HSV combination (and convert). As far as the human eye concerns, a difference in hue of about 15 degrees (~0.05 on the 0-1 scale) is sufficient to be considered a different color. This is the only value that's important.

For example, here's an image with red along the top ("0 degrees"). Along the bottom are 4 colors: 7, 15, 30, and 60 degrees along the "hue" slider.

The 7 degree difference can be seen but looks too close. The 15 degree shift is definitely a different color (even if I'd call both it and the next one "orange", they're at least different oranges).

You can pick whatever threshold you want and generating new colors until the new color is more than your threshold in degrees away from the old. For value and saturation, you can pretty much generate any value from 0 to 1, as even if the values are exactly the same as the previous color, the minimum enforced hue difference will result in a color that is sufficiently different.

Then, converting from HSV to RGB is pretty easy.

I've done this sort of thing in two different languages, one of which was for a project where I specifically wanted to generate two or three "different colors" while also insuring that the brightness was sufficiently high (i.e. I did not want "black" to be possible), so HSV was the only sensible solution: I could generate random hues, set value and saturation up towards max (e.g. random range [0.8,1.0]). The other project I was merging two images into a single texture: I wanted to keep the same hue and saturation of the first image but adjust the value based on the second.

You may also want to bias the Saturation and Value numbers, depending on your goals, if either Saturation or Value is too low (under 0.5) hues will start blurring together and be too similar (the colors will be all muddy). Alternatively, you could generate a single float between 0 and 1 and set the Saturation to that number and Value to one minus that number.