Jak mogę skalować kreskowania rysowane w prostokącie?

Question

Używam rysunków .Net do rysowania diagramu. Jest to zasadniczo skumulowany wykres słupkowy. Mam problem polegający na tym, że chcę zmniejszyć ilość linii w stylu kreskowania, tak aby w pewnym stopniu skalować go tak, aby był wyraźniejszy. Rozejrzałem się, ale nie natknąłem się na nic, co mogłoby mi pomóc.

Rysuję prostokąt, a następnie używam go do wypełnienia, ale ze względu na rozmiar obrazu kreskowanie staje się mniej wyraźne. Dziękuję za wszelkie sugestie.

Style kreskowania i szczotki są przechowywane w db i używam funkcji pomocnika, aby je zwrócić. Rysuję więc prostokąt i po zdobyciu pędzla wypełniam prostokąt. Zasadniczo chcę zwiększyć wypełnienie kreskowania, jeśli można to zrobić.

g.DrawRectangle(gridpen, startX, startY, BOREHOLE_RECT_WIDTH, layerRectHeight); 

brush = GetBoreholeBrush(l.SoilTypeMatrixLevel1Id.PrimaryBrushType, 
          l.SoilTypeMatrixLevel1Id.PrimaryFillStyle, 
          l.SoilTypeMatrixLevel1Id.PrimaryColour); 

g.FillRectangle(brush, startX, startY, BOREHOLE_RECT_WIDTH, layerRectHeight); 

I funkcja getBrush; rodzaj pędzla, styl właz i kolor są przechowywane w db i wykorzystywane do tworzenia wracającą szczotki:

//=================================== 
    private Brush GetBoreholeBrush(string BrushType, string HatchStyle, string Colour) 
    //=================================== 
    { 
     //Decide on what brush type has been chosen. 
     Brush brush; 
     if (BrushType.ToLower() == BrushTypes.HatchBrush.ToString().ToLower()) 
     { 
      brush = new HatchBrush(GetHatchStyle(HatchStyle), 
            Color.Black, ColorTranslator.FromHtml(Colour)); 
     } 
     else if (BrushType.ToLower() == BrushTypes.SolidBrush.ToString().ToLower()) 
     { 
      brush = new HatchBrush(GetHatchStyle(HatchStyle), 
            Color.Black, ColorTranslator.FromHtml(Colour)); 
     } 
     else if (BrushType.ToLower() == BrushTypes.TextureBrush.ToString().ToLower()) 
     { 
      brush = new HatchBrush(GetHatchStyle(HatchStyle), 
            Color.Black, ColorTranslator.FromHtml(Colour)); 
     } 
     else 
     { 
      brush = new HatchBrush(GetHatchStyle(HatchStyle), 
            Color.Black, ColorTranslator.FromHtml(Colour)); 
     } 

     return brush; 
    } 

Funkcja powrotu styl kreskowania:

//=================================== 
    private HatchStyle GetHatchStyle(string FillStyle) 
    //=================================== 
    { 
     //Loop through each hatch tyle and return the correct one. 
     foreach (HatchStyle style in Enum.GetValues(typeof(HatchStyle))) 
     { 
      if (style.ToString().ToLower() == FillStyle.ToLower()) 
      { 
       return style; 
      } 
     } 
     return HatchStyle.Vertical; 
    } 

Jak widać na obrazku poniżej styl kreskowania nie jest jasny.

Answer 1

najbardziej bezpośredni, ale chyba nie bardzo pomocne odpowiedź brzmi: Nie, nie można skalować wzór kreskowania o HatchBrush.

Ma zawsze wyglądać ostro na poziomie pikseli i nie podlega nawet skalowaniu obiektu Graphics.

Patrząc na twoje pytanie, zastanawiam się: czy na pewno używasz HatchBrush? Otrzymujesz pędzel z funkcji GetBoreholeBrush. Jeśli naprawdę masz zapisane indeksy do 50 HatchStyle, to domyślam się, że naprawdę używasz HatchBrush.

Teraz, używając HatchBrush nie będzie działać Myślę, że można użyć TextureBrush zamiast ..

Można przekształcać wzory kreskowania do większych wersjach od zwiększenia ich zastosowania; to nie jest zwykła konwersja. Bezpośrednie podejście do rysowania większego przez współczynnik całkowity i bez wygładzania jest proste i może być wystarczająco dobre.

Ale może trzeba dostosować je, gdyż w ten sposób wszystkie piksele, czyli oba linia pikseli i tło pikseli uzyskać powiększenie, a także wszystkie przekątne będzie wyglądał postrzępione.

Musisz więc zrównoważyć rozmiar kreskowania i szerokość obrysu i odtworzyć wszystkie potrzebne wzory od zera w większych rozmiarach.

Oto przykład ilustrujący problemy związane z prostym rozwiązaniem; pierwszy wiersz to oryginalny wzór kreskowania, pozostałe to proste wyniki pędzla tekstury, skalowane przez 1x, 2x i 3x.:

Pierwsza funkcja przekształcić HatchBrush do TextureBrush

TextureBrush TBrush(HatchBrush HBrush) 
{ 
    using (Bitmap bmp = new Bitmap(8,8)) 
    using (Graphics G = Graphics.FromImage(bmp)) 
    { 
     G.FillRectangle(HBrush, 0, 0, 8, 8); 
     TextureBrush tb = new TextureBrush(bmp); 
     return tb; 
    } 
} 

Należy pamiętać, że wzór właz jest 8x8 pikseli.

Teraz kod Paint wykorzystane do powyższego obrazka:

private void panel1_Paint(object sender, PaintEventArgs e) 
{ 
    var hs = (HatchStyle[])Enum.GetValues(typeof(HatchStyle)); 

    for (int i = 0; i < hs.Length; i++) 
     using (HatchBrush hbr = new HatchBrush(hs[i], Color.GreenYellow)) 
     using (HatchBrush hbr2 = new HatchBrush(hs[i], Color.LightCyan)) 
     { 
      e.Graphics.FillRectangle(hbr, new Rectangle(i * 20, 10,16,60)); 
      using (TextureBrush tbr = TBrush(hbr2)) 
      { 
       e.Graphics.FillRectangle(tbr, new Rectangle(i * 20, 80, 16, 60)); 
       tbr.ScaleTransform(2, 2); 
       e.Graphics.FillRectangle(tbr, new Rectangle(i * 20, 150, 16, 60)); 
       tbr.ResetTransform(); 
       tbr.ScaleTransform(3,3); 
       e.Graphics.FillRectangle(tbr, new Rectangle(i * 20, 220, 16, 60)); 
      } 
     } 
} 

Należy zauważyć, że podczas gdy TextureBrush ma ładne metody modyfikowania tekstur, HatchBrush ma nic takiego w ogóle ..