comment rendre le pinceau lisse sans lignes au milieu

La bande est un artefact de l’algorithme de gradient. Il doit diviser la zone en bandes remplies chacune d’une couleur légèrement différente. Les contours sont en fait une illusion d’optique qui les rend plus visibles que vous ne le pensez. Pour réduire cet effet, vous devez réduire la largeur de chaque bande.

Les solutions sont:

1. Remplissez sur une zone plus petite – chaque bande est plus étroite.
2. Augmentez le nombre de bandes. Augmentez le contraste entre les deux extrêmes.
3. Augmente la résolution couleur de l’écran. Si vous avez plus de couleurs à choisir, la plage utilisable sera plus grande entre les deux couleurs finales.

Je réalise que ces solutions sont soit a) impossibles, soit b) non pratiques. C’est un problème avec lequel vous allez devoir vivre.

Une solution pratique pourrait consister à remplacer le pinceau par une image créée dans Photoshop ou un autre logiciel de traitement d’images. Cela pourrait vous donner une image avec moins de bandes – mais vous êtes alors limité à la taille de l’image – vous ne pouvez pas l’agrandir sans pixelisation.

Il y a quelque temps, j’ai écrit un dégradé linéaire régulier pour mon projet WPF. Il supprime le baguage, mais il y a deux mises en garde:

• Il ne peut pas être utilisé pour les couleurs liées aux données ou {DynamicResource} .
• Il ne supporte actuellement que le dégradé vertical, car c’était tout ce dont j’avais besoin

Il est implémenté sous la forme ImageBrush créée de manière ImageBrush , à l’aide de Dithering ordonné . De plus, c’est aussi une MarkupExtension , car on ne peut pas simplement hériter d’une classe Brush (elles sont toutes scellées).

 /// 
 /// Brush that lets you draw vertical linear gradient without banding. /// 
 [MarkupExtensionReturnType(typeof(Brush))] public class SmoothLinearGradientBrush : MarkupExtension { private static PropertyInfo dpiX_; private static PropertyInfo dpiY_; private static byte[,] bayerMasortingx_ = { { 1, 9, 3, 11 }, { 13, 5, 15, 7 }, { 1, 9, 3, 11 }, { 16, 8, 14, 6 } }; static SmoothLinearGradientBrush() { dpiX_ = typeof(SystemParameters).GetProperty("DpiX", BindingFlags.NonPublic | BindingFlags.Static); dpiY_ = typeof(SystemParameters).GetProperty("Dpi", BindingFlags.NonPublic | BindingFlags.Static); } /// 
 /// Gradient color at the top /// 
 public Color From { get; set; } /// 
 /// Gradient color at the bottom /// 
 public Color To { get; set; } public override object ProvideValue(IServiceProvider serviceProvider) { //If user changes dpi/virtual screen height during applicaiton lifetime, //wpf will scale the image up for us. int width = 20; int height = (int)SystemParameters.VirtualScreenHeight; int dpix = (int)dpiX_.GetValue(null); int dpiy = (int)dpiY_.GetValue(null); int ssortingde = 4 * ((width * PixelFormats.Bgr24.BitsPerPixel + 31) / 32); //dithering parameters double bayerMasortingxCoefficient = 1.0 / (bayerMasortingx_.Length + 1); int bayerMasortingxSize = bayerMasortingx_.GetLength(0); //Create pixel data of image byte[] buffer = new byte[height * ssortingde]; for (int line = 0; line < height; line++) { double scale = (double)line / height; for (int x = 0; x < width * 3; x += 3) { //scaling of color double blue = ((To.B * scale) + (From.B * (1.0 - scale))); double green = ((To.G * scale) + (From.G * (1.0 - scale))); double red = ((To.R * scale) + (From.R * (1.0 - scale))); //ordered dithering of color //source: http://en.wikipedia.org/wiki/Ordered_dithering buffer[x + line * stride] = (byte)(blue + bayerMatrixCoefficient * bayerMatrix_[x % bayerMatrixSize, line % bayerMatrixSize]); buffer[x + line * stride + 1] = (byte)(green + bayerMatrixCoefficient * bayerMatrix_[x % bayerMatrixSize, line % bayerMatrixSize]); buffer[x + line * stride + 2] = (byte)(red + bayerMatrixCoefficient * bayerMatrix_[x % bayerMatrixSize, line % bayerMatrixSize]); } } var image = BitmapSource.Create(width, height, dpix, dpiy, PixelFormats.Bgr24, null, buffer, stride); image.Freeze(); var brush = new ImageBrush(image); brush.Freeze(); return brush; } } 

Utilisation dans le dictionnaire de ressources:

puis en style de contrôle:

Une option bon marché et sale d’une autre réponse est la suivante:

Ajoutez le dégradé à un conteneur, donnez-lui une petite marge négative pour qu’il en déborde un peu, ajoutez un effet Flou sur le dégradé, puis activez ClipToBounds sur le conteneur parent. De cette façon, le dégradé est un peu plus agréable au désortingment des performances.

En fonction de votre cas d’utilisation, cela risque cependant de ne pas être viable.

Exemple:

Le dégradé négatif doit être égal au rayon de flou afin qu’il ne devienne pas transparent sur les bords.