在C中生成顏色梯度＃

我的問題與the question here類似，但我正在使用C＃。在C中生成顏色梯度＃

我有兩種顏色，我有一個預定義的步驟。如何檢索Color s的列表，它們是兩者之間的漸變？

這是我試過了，沒有工作的方法：

int argbMax = Color.Chocolate.ToArgb(); 
int argbMin = Color.Blue.ToArgb(); 
var colorList = new List<Color>(); 

for(int i=0; i<size; i++) 
{ 
    var colorAverage= argbMin + (int)((argbMax - argbMin) *i/size); 
    colorList.Add(Color.FromArgb(colorAverage)); 
}

如果你嘗試上面的代碼，你會發現，在argb逐漸上升不符合視覺逐漸增加在顏色。

對此有何想法？

來源

2010-01-06 Graviton

您將不得不提取R，G，B分量，並對它們分別執行相同的線性插值，然後重新組合。

int rMax = Color.Chocolate.R; 
int rMin = Color.Blue.R; 
// ... and for B, G 
var colorList = new List<Color>(); 
for(int i=0; i<size; i++) 
{ 
    var rAverage = rMin + (int)((rMax - rMin) * i/size); 
    var gAverage = gMin + (int)((gMax - gMin) * i/size); 
    var bAverage = bMin + (int)((bMax - bMin) * i/size); 
    colorList.Add(Color.FromArgb(rAverage, gAverage, bAverage)); 
}

來源

2010-01-06 09:03:23

也許這個功能可以幫助：

public IEnumerable<Color> GetGradients(Color start, Color end, int steps) 
{ 
    Color stepper = Color.FromArgb((byte)((end.A - start.A)/(steps - 1)), 
            (byte)((end.R - start.R)/(steps - 1)), 
            (byte)((end.G - start.G)/(steps - 1)), 
            (byte)((end.B - start.B)/(steps - 1))); 

    for (int i = 0; i < steps; i++) 
    { 
     yield return Color.FromArgb(start.A + (stepper.A * i), 
            start.R + (stepper.R * i), 
            start.G + (stepper.G * i), 
            start.B + (stepper.B * i)); 
    } 
}

來源

2010-01-06 09:43:00 Oliver

這是非常接近，但我不得不說是打破了一些負面步長值。我也發佈了我的更改解決方案。 – jocull 2013-01-09 20:57:44

public static List<Color> GetGradientColors(Color start, Color end, int steps) 
    { 
     return GetGradientColors(start, end, steps, 0, steps - 1); 
    } 

    public static List<Color> GetGradientColors(Color start, Color end, int steps, int firstStep, int lastStep) 
    { 
     var colorList = new List<Color>(); 
     if (steps <= 0 || firstStep < 0 || lastStep > steps - 1) 
      return colorList; 

     double aStep = (end.A - start.A)/steps; 
     double rStep = (end.R - start.R)/steps; 
     double gStep = (end.G - start.G)/steps; 
     double bStep = (end.B - start.B)/steps; 

     for (int i = firstStep; i < lastStep; i++) 
     { 
      var a = start.A + (int)(aStep * i); 
      var r = start.R + (int)(rStep * i); 
      var g = start.G + (int)(gStep * i); 
      var b = start.B + (int)(bStep * i); 
      colorList.Add(Color.FromArgb(a, r, g, b)); 
     } 

     return colorList; 
    }

來源

2012-10-11 16:16:13 Steinwolfe

奧利弗的回答很接近......但對我來說我的一些需要步進編號爲負。將步進值轉換爲Color結構時，我的值從負值變爲較高值，例如， -1變成類似於254.我設置我的步驟值單獨來解決這個問題。

public static IEnumerable<Color> GetGradients(Color start, Color end, int steps) 
{ 
    int stepA = ((end.A - start.A)/(steps - 1)); 
    int stepR = ((end.R - start.R)/(steps - 1)); 
    int stepG = ((end.G - start.G)/(steps - 1)); 
    int stepB = ((end.B - start.B)/(steps - 1)); 

    for (int i = 0; i < steps; i++) 
    { 
     yield return Color.FromArgb(start.A + (stepA * i), 
            start.R + (stepR * i), 
            start.G + (stepG * i), 
            start.B + (stepB * i)); 
    } 
}

來源

2013-01-09 20:57:06 jocull

這是超級簡單，看起來真棒和工作。謝謝：-） – 2016-07-13 14:57:51

使用雙，而不是INT：

double stepA = ((end.A - start.A)/(double)(steps - 1)); 
double stepR = ((end.R - start.R)/(double)(steps - 1)); 
double stepG = ((end.G - start.G)/(double)(steps - 1)); 
double stepB = ((end.B - start.B)/(double)(steps - 1));

和：

yield return Color.FromArgb((int)start.A + (int)(stepA * step), 
              (int)start.R + (int)(stepR * step), 
              (int)start.G + (int)(stepG * step), 
              (int)start.B + (int)(stepB * step));

來源

2014-08-25 11:51:10 DjCzermino

在C中生成顏色梯度＃

回答

相關問題