Générer des dégradés par programme ?

Question

Étant donné 2 couleurs RVB et une zone rectangulaire, j'aimerais générer un dégradé linéaire de base entre les couleurs.J'ai fait une recherche rapide et la seule chose que j'ai pu trouver est cette entrée de blog, mais l'exemple de code semble manquer, ou du moins c'était le cas au moment de cette publication.Tout est utile, les algorithmes, les exemples de code, peu importe.Cela sera écrit en Java, mais la couche d'affichage est déjà prise en charge, j'ai juste besoin de comprendre comment savoir quoi afficher.

Answer 1

vous voulez une interpolation entre la première et la deuxième couleur.L'interpolation des couleurs est facile en calculant la même interpolation pour chacune de ses composantes (R, V, B).Il existe de nombreuses façons d'interpoler.Le plus simple est d'utiliser l'interpolation linéaire :prends juste un pourcentage p de la première couleur et pourcentage 1 - p du deuxième :

R = firstCol.R * p + secondCol.R * (1 - p)

Il y a une autre question liés à cela.

Il existe d'autres méthodes d'interpolation qui fonctionnent parfois mieux.Par exemple, en utilisant un en forme de cloche (sigmoïde) La fonction d'interpolation rend la transition plus fluide.

/MODIFIER:Oups, vous voulez dire utiliser une fonction prédéfinie.OK, encore plus simple.Le billet de blog que vous avez lié contient désormais un exemple de code en Python.

En Java, vous pouvez utiliser le GradientPaint.

Answer 2

Vous pouvez utiliser le Peinture Dégradée classe.

void Paint(Graphics2D g, Regtangle r, Color c1, Color c2)
{
  GradientPaint gp = new GradientPaint(0,0,c1,r.getWidth(),r.getHeight(),c2); 
  g.setPaint(gp);
  g.fill(rect);
}

Answer 3

En utilisant les classes AWT de base, vous pourriez faire quelque chose comme ceci :

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
import javax.swing.JPanel;

public class LinearGradient extends JPanel {

    public void paint(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        Color color1 = Color.RED;
        Color color2 = Color.BLUE;
        int steps = 30;
        int rectWidth = 10;
        int rectHeight = 10;

        for (int i = 0; i < steps; i++) {
            float ratio = (float) i / (float) steps;
            int red = (int) (color2.getRed() * ratio + color1.getRed() * (1 - ratio));
            int green = (int) (color2.getGreen() * ratio + color1.getGreen() * (1 - ratio));
            int blue = (int) (color2.getBlue() * ratio + color1.getBlue() * (1 - ratio));
            Color stepColor = new Color(red, green, blue);
            Rectangle2D rect2D = new Rectangle2D.Float(rectWidth * i, 0, rectWidth, rectHeight);
            g2.setPaint(stepColor);
            g2.fill(rect2D);
        }
    }
}

Answer 4

Faisant suite à l'excellente réponse de David Crow, voici un exemple d'implémentation de Kotlin

fun gradientColor(x: Double, minX: Double, maxX: Double, 
                  from: Color = Color.RED, to: Color = Color.GREEN): Color {
    val range = maxX - minX
    val p = (x - minX) / range

   return Color(
        from.red * p + to.red * (1 - p),
        from.green * p + to.green * (1 - p),
        from.blue * p + to.blue * (1 - p),
        1.0
    )
}

Answer 5

j'ai utilisé RMagick pour ça.Si vous avez besoin d'aller plus loin dans le dégradé simple, ImageMagick et un de ses wrappers (comme RMagick ou JMagick pour Java) pourrait être utile.