Come posso ridimensionare lo stile di apertura disegnato in un rettangolo?

Question

Sto usando. Disegno netto per disegnare un diagramma. È essenzialmente un grafico a barre in pila. Il problema che ho è che voglio ridurre la quantità di linee nello stile di tratteggio in modo da ridimensionarlo per renderlo più chiaro. Mi sono guardato intorno ma non ho trovato nulla che potesse aiutarmi.

Disegno un rettangolo e quindi utilizzo un hatchbrush per riempirlo ma a causa delle dimensioni dell'immagine lo hatchfill diventa meno chiaro. Grazie per eventuali suggerimenti.

Il tratteggioStyle e tipi di pennello sono memorizzati nel db e io uso una funzione di supporto per restituirli. Quindi disegno il rettangolo e dopo aver ottenuto il pennello riempio il rettangolo. In sostanza, voglio aumentare il riempimento del tratteggio se ciò può essere fatto.

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

E la funzione getBrush; il tipo di pennello, stile di tratteggio e colore vengono memorizzati nel db e utilizzato per creare il pennello restituita:

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

Funzione per tornare allo stile tratteggio:

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

Come si può vedere nell'immagine qui sotto lo stile di tratteggio non è chiaro.

Answer 1

La risposta più diretta, ma probabilmente non molto utile è: No, non è possibile scalare il modello di tratteggio di un HatchBrush.

È pensato per essere sempre nitido a livello di pixel e non è nemmeno influenzato dal ridimensionamento dell'oggetto .

Guardando la tua domanda mi chiedo: sei sicuro di usare davvero un HatchBrush? Si ottiene il pennello da una funzione GetBoreholeBrush. Se hai davvero memorizzato gli indici nel numero di serie HatchStyle, suppongo che tu usi davvero uno HatchBrush.

Ora, come utilizzare un HatchBrush non funzionerà Credo che si potrebbe utilizzare un TextureBrush invece ..

Si potrebbe trasformare i modelli di tratteggio alle versioni più grandi da loro scaling up; questa non è esattamente una semplice conversione. L'approccio diretto di disegnare il più grande con un fattore intero e senza anti-aliasing è semplice e può essere abbastanza buono.

ma potrebbe essere necessario per mettere a punto loro, come in questo modo tutti i pixel, che è sia pixel linea e sfondo pixel ottenere allargata e anche tutte le diagonali guarderanno frastagliato.

Quindi è necessario bilanciare le dimensioni del portello e la larghezza del tratto e ricreare tutti i motivi necessari da zero in dimensioni maggiori.

Ecco un esempio che illustra i problemi con la soluzione semplice; la prima riga è il modello di tratteggio originale, gli altri sono semplici risultati del pennello texture, ridimensionati da 1x, 2x e 3x ..:

Prima una funzione di trasformare un HatchBrush ad un 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; 
    } 
} 

noti che il modello di tratteggio è 8x8 pixel.

Ora il codice Paint utilizzato per l'immagine qui sopra:

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

nota che mentre il TextureBrush ha metodi piacevoli per modificare la texture, la HatchBrush non ha nulla di simile a tutti ..