Show the percentage of painted surface on the wall

Questions & Answers
1

I want to show the percentage of painted surface on the wall. Here is the code I used to paint the wall.

private void MyPaintOn(Vector2 textureCoord, float[,] splashTexture, Color targetColor)
    {
        if (m_isEnabled)
        {
            lock (m_lockFlag)
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                int reqnx = splashTexture.GetLength(0);
                int reqny = splashTexture.GetLength(1);
                int reqX = (int)(textureCoord.x * textureSize) - (reqnx / 2);
                int reqY = (int)(textureCoord.y * textureSize) - (reqny / 2);
                int right = m_texture.width - 1;
                int bottom = m_texture.height - 1;

                int x = IntMax(reqX, 0);
                int y = IntMax(reqY, 0);
                int nx = IntMin(x + reqnx, right) - x;
                int ny = IntMin(y + reqny, bottom) - y;

                Color[] pixels = m_texture.GetPixels(x, y, nx, ny);

                int counter = 0;
                for (int i = 0; i < nx; ++i)
                {
                    for (int j = 0; j < ny; ++j)
                    {
                        float currAlpha = splashTexture[i, j];
                        if (currAlpha == 1)
                            pixels[counter] = targetColor;
                        else
                        {
                            Color currColor = pixels[counter];
                            // resulting color is an addition of splash texture to the texture based on alpha
                            Color newColor = Color.Lerp(currColor, targetColor, currAlpha);
                            // but resulting alpha is a sum of alphas (adding transparent color should not make base color more transparent)
                            newColor.a = pixels[counter].a + currAlpha;
                            pixels[counter] = newColor;
                        }
                        counter++;
                    }

                    m_texture.SetPixels(x, y, nx, ny, pixels);
                    m_texture.Apply();
                    sw.Stop();
                }
            }
        }
    }
2

You can calculate color fill and overall similarity values by treating colors as n-dimensional vectors inside a unit cube (or equivalent). This enables you to express color differences with a single numerical value - distance between them.

static float CalculateFill ( Color[] colors , Color reference , float tolerance )
{
    Vector3 target = new Vector3{ x=reference.r , y=reference.g , z=reference.b };
    int numHits = 0;
    const float sqrt_3 = 1.73205080757f;
    for( int i=0 ; i<colors.Length ; i++ )
    {
        Vector3 next = new Vector3{ x=colors.r , y=colors_.g , z=colors*.b };
			float mag = Vector3.Magnitude( target - next ) / sqrt_3;
        numHits += mag<=tolerance ? 1 : 0;
    }
    return (float)numHits / (float)colors.Length;;
}
static float CalculateSimilarity ( Color[] colors , Color reference )
{
    Vector3 target = new Vector3{ x=reference.r , y=reference.g , z=reference.b };
    float accu = 0;
		const float sqrt_3 = 1.73205080757f;
    for( int i=0 ; i<colors.Length ; i++ )
    {
        Vector3 next = new Vector3{ x=colors.r , y=colors_.g , z=colors*.b };
			accu += Vector3.Magnitude( target - next ) / sqrt_3;
    }
    return 1f - ( (float)accu / (float)colors.Length );
}

I’m sure you can simplify this further to meet your project requirements. Optimizing this for runtime-use is whole another topic.

Here is a full source for an editor tool to check how well it works**. Some test results: