Genera il gradiente di colore in C#

Question

La mia domanda è simile a the question here, tranne che sto lavorando con C#.

Ho due colori e ho una procedura predefinita. Come recuperare un elenco di Color s che sono i gradienti tra i due?

Si tratta di un approccio che ho provato, che non ha funzionato:

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)); 
} 

Se si tenta il codice di cui sopra, troverete che un graduale aumento argb non corrisponde a un aumento graduale visiva nel colore

Qualche idea su questo?

Answer 1

Sarà necessario estrarre i componenti R, G, B ed eseguire la stessa interpolazione lineare su ciascuno di essi singolarmente, quindi ricombinare.

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)); 
} 

Answer 2

Forse questa funzione può aiutare: risposta

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)); 
    } 
} 

Answer 3

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; 
    } 

Answer 4

di Oliver era molto vicino ... ma nel mio caso alcuni dei miei numeri passo-passo necessari per essere negativo. Quando si convertono i valori stepper in una struct , i miei valori andavano dai valori negativi a quelli superiori, ad es. -1 diventa qualcosa come 254. Ho impostato i miei valori di passo individualmente per risolvere questo problema.

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)); 
    } 
} 

Answer 5

Doppia uso invece di 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)); 

e:

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));