nasıl <br/> o pürüzsüz hale getirmek için nasıl kadar düzgün değil, tüm orta

Question

Merhaba çizgileri olmadan pürüzsüz fırça yapmak için? harmanın

<Grid x:Name="LayoutRoot"> 
     <Grid.Background> 
      <LinearGradientBrush EndPoint="0.452,1.962" StartPoint="1.164,-0.352"> 
       <GradientStop Color="#FF202020" Offset="0"/> 
       <GradientStop Color="#FF545454" Offset="1"/> 
      </LinearGradientBrush> 
     </Grid.Background> 
    </Grid> 

Answer 1

ile oluşturmak (satır kaldırma o) bantlama gradyan algoritmasının bir ürünü olan. Her biri biraz farklı bir renkle doldurulmuş bantlara alan ayırmak zorundadır. Kenarlar aslında, onları düşündüğünüzden daha görünür hale getirme etkisine sahip bir optik yanılsamadır. Bu etkiyi azaltmak için her bir bandın genişliğini azaltmanız gerekir.

çözeltilerdir:

1. daha küçük bir alana Dolgu - her bir bant daha dardır.
2. Bant sayısını artırın. İki ekstremite arasındaki kontrastı büyütün.
3. Ekranın renk çözünürlüğünü artırın. Seçebileceğiniz daha fazla renk varsa, iki bitiş rengi arasında daha geniş kullanılabilir bir alan olacaktır.

Bu çözümlerin ya a) mümkün olmadığını ya da b) pratik olmadığını anlıyorum. Bu yaşamak zorunda kalacak bir problem.

Pratik bir çözüm, fırçayı Photoshop veya başka bir görüntü işleme paketinde oluşturulan bir görüntüyle değiştirmek olabilir. Bu size daha az şeritli bir görüntü verebilir - ancak görüntü boyutuna göre sınırlandırılırsınız - pikselleştirme olmadan büyüyemezsiniz.

Answer 2

Bir süre önce WPF projem için düzgün doğrusal gradyan yazdım. Bu bantlama kaldırır, ancak iki uyarılar vardır:

• Bu veri sınırlama renkler veya {DynamicResource} için kullanılamaz.
• Halen hepsi olduğu gibi
Sanki dynamicly Ordered Dithering kullanarak, ImageBrush oluşturulan uygulandığı

ihtiyacı sadece dikey eğimi destekler. Ek olarak, bir Brush sınıfını (hepsi mühürlü) sadece miras edemediğinden, aynı zamanda MarkupExtension. kaynak sözlükte

/// <summary> 
/// Brush that lets you draw vertical linear gradient without banding. 
/// </summary> 
[MarkupExtensionReturnType(typeof(Brush))] 
public class SmoothLinearGradientBrush : MarkupExtension 
{ 
    private static PropertyInfo dpiX_; 
    private static PropertyInfo dpiY_; 
    private static byte[,] bayerMatrix_ = 
    { 
     { 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); 
    } 

    /// <summary> 
    /// Gradient color at the top 
    /// </summary> 
    public Color From { get; set; } 

    /// <summary> 
    /// Gradient color at the bottom 
    /// </summary> 
    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 stride = 4 * ((width * PixelFormats.Bgr24.BitsPerPixel + 31)/32); 

     //dithering parameters 
     double bayerMatrixCoefficient = 1.0/(bayerMatrix_.Length + 1); 
     int bayerMatrixSize = bayerMatrix_.GetLength(0); 

     //Create pixel data of image 
     byte[] buffer = new byte[height * stride]; 

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

Kullanımı:

<local:SmoothLinearGradientBrush x:Key="WindowBackgroundBrush" 
           From="{StaticResource WindowBackgroundColorLight}" 
           To="{StaticResource WindowBackgroundColorDark}" /> 

ve sonra kontrol tarzında:

Ekleme:

<Style ...> 
    <Setter Property="Background" Value="{StaticResource WindowBackgroundBrush}" /> 
</Style> 

Answer 3

benim başka cevap A ucuz ve kirli seçenek budur Bir konteynere gradyan, küçük bir negatif marj verir, bu yüzden biraz dökülür, bir BlurEffect ekleyin Degrade ve sonra üst konteynerde ClipToBounds açın. Bu şekilde degrade, performansın pahasına biraz daha güzel çıkar. Bununla birlikte, kullanım durumunuza bağlı olarak, bu geçerli olmayabilir.

Örnek: kenarlarda saydam hale gelmeyecek şekilde

<Grid Height="26" Margin="-5,0" ClipToBounds="True"> 
    <Grid Margin="-5"> 
     <Grid.Effect> 
      <BlurEffect Radius="6" /> 
     </Grid.Effect> 
     <Grid.Background> 
      <LinearGradientBrush> 
       <GradientStop x:Name="GradientStop7" Color="Magenta" Offset="0.0" /> 
       <GradientStop x:Name="GradientStop8" Color="DarkOrchid" Offset=".2" /> 
       <GradientStop x:Name="GradientStop9" Color="Purple" Offset="1" /> 
      </LinearGradientBrush> 
     </Grid.Background> 
    </Grid> 
</Grid> 

negatif gradyan bulanıklık yarıçapına eşit olmalıdır.