Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
Colori - Grafica.cs

Grafica.cs

Caricato da: Poggi Marco
Scarica il programma completo

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Drawing;
  7.  
  8. namespace Colori
  9. {
  10.  
  11.     struct Tratto
  12.     {
  13.         public PointF inizio;
  14.         public PointF fine;
  15.  
  16.         public Tratto(float x0, float y0, float xf, float yf)
  17.         {
  18.             inizio = new PointF(x0, y0);
  19.             fine = new PointF(xf, yf);
  20.         }
  21.        
  22.         public float Distanza()
  23.         {
  24.             float dx, dy;
  25.             dx = fine.X - inizio.X;
  26.             dy = fine.Y - inizio.Y;
  27.             return (float)(Math.Sqrt(dx * dx + dy * dy));
  28.         }
  29.     }
  30.  
  31.     class Grafica
  32.     {
  33.         private Graphics foglio = null;
  34.         private Tratto limiti;
  35.         private PointF scale;
  36.         private Point estremiFoglio;
  37.         private Pen pennino;
  38.  
  39.         public Grafica()
  40.         {
  41.             foglio = null;
  42.             limiti = new Tratto();
  43.             scale = new PointF(0f, 0f);
  44.             estremiFoglio = new Point(0, 0);
  45.             pennino = null;
  46.         }
  47.  
  48.         protected void Dimensiona(Graphics posto, Tratto diagonale)
  49.         {
  50.             foglio = posto;
  51.             Normalizza(ref diagonale);
  52.             limiti = diagonale;
  53.             LimitiFoglio();
  54.             scale.X = estremiFoglio.X / (limiti.fine.X - limiti.inizio.X);
  55.             scale.Y = estremiFoglio.Y / (limiti.fine.Y - limiti.inizio.Y);
  56.             pennino = new Pen(Color.FromArgb(10, 10, 10), 1);
  57.         }
  58.  
  59.         protected void Dimensiona(Graphics posto, float x0, float y0, float xf)
  60.         {
  61.             foglio = posto;
  62.             limiti.inizio.X = x0;
  63.             limiti.inizio.Y = y0;
  64.             limiti.fine.X = xf;
  65.             LimitiFoglio();
  66.             scale.X=estremiFoglio.X / (limiti.fine.X - limiti.inizio.X);
  67.             scale.Y = scale.X;
  68.             limiti.fine.Y = (estremiFoglio.Y / scale.Y) + limiti.inizio.X;
  69.             pennino = new Pen(Color.FromArgb(10, 10, 10), 1);
  70.         }
  71.  
  72.         public void Linea(Tratto segmento)
  73.         {
  74.             Trasla(ref segmento.inizio);
  75.             Trasla(ref segmento.fine);
  76.             foglio.DrawLine(pennino, segmento.inizio, segmento.fine);
  77.         }
  78.  
  79.         public void Linea(float x0, float y0, float xf, float yf)
  80.         {
  81.             Linea(new Tratto(x0, y0, xf, yf));
  82.         }
  83.  
  84.         public void Rettangolo(Tratto estremi)
  85.         {
  86.             Trasla(ref estremi.inizio);
  87.             Trasla(ref estremi.fine);
  88.             foglio.FillRectangle(pennino.Brush, new RectangleF(estremi.inizio.X, estremi.inizio.Y, Math.Abs(estremi.fine.X - estremi.inizio.X), Math.Abs(estremi.fine.Y - estremi.inizio.Y)));
  89.         }
  90.  
  91.         public void Cerchio(PointF centro, double raggio)
  92.         {
  93.             double alfa, omega, passo;
  94.             Tratto linea = new Tratto();
  95.             linea.inizio.X = (float)(centro.X + raggio);
  96.             linea.inizio.Y = centro.Y;
  97.             omega = Math.PI * 2.0;
  98.             alfa = 0.0;
  99.             passo = (omega - alfa) / 200.0;
  100.             while (alfa <= omega)
  101.             {
  102.                 alfa += passo;
  103.                 linea.fine.X = (float)(centro.X + raggio * Math.Cos(alfa));
  104.                 linea.fine.Y = (float)(centro.Y + raggio * Math.Sin(alfa));
  105.                 this.Linea(linea);
  106.                 linea.inizio = linea.fine;
  107.             }
  108.  
  109.         }
  110.  
  111.         public void IlluminaPunto(PointF coordinata)
  112.         {
  113.             Trasla(ref coordinata);
  114.             foglio.DrawLine(pennino, coordinata.X, coordinata.Y, coordinata.X + 1f, coordinata.Y);
  115.         }
  116.  
  117.         public void Assi(Pen penninoAssi)
  118.         {
  119.             if (penninoAssi != null)
  120.             {
  121.                 PointF origine = new PointF(0f, 0f);
  122.                 Trasla(ref origine);
  123.                 foglio.DrawLine(penninoAssi, 0f, origine.Y, estremiFoglio.X, origine.Y);
  124.                 foglio.DrawLine(penninoAssi, origine.X, 0f, origine.X, estremiFoglio.Y);
  125.             }
  126.         }
  127.  
  128.         public void Cancella(Color sfondo)
  129.         {
  130.             foglio.Clear(sfondo);
  131.         }
  132.  
  133.         public Pen Penna
  134.         {
  135.             get
  136.             {
  137.                 return pennino;
  138.             }
  139.             set
  140.             {
  141.                 pennino = new Pen(value.Color, value.Width)
  142.                 {
  143.                     DashCap = value.DashCap
  144.                 };
  145.             }
  146.         }
  147.  
  148.         private void Trasla(ref PointF punto)
  149.         {
  150.             punto.X = scale.X * (punto.X - limiti.inizio.X);
  151.             punto.Y = estremiFoglio.Y - (scale.Y * (punto.Y - limiti.inizio.Y));
  152.             if (punto.X < 0f)
  153.             {
  154.                 punto.X = -1f;
  155.             }
  156.             if (punto.X > estremiFoglio.X)
  157.             {
  158.                 punto.X = estremiFoglio.X + 1f;
  159.             }
  160.             if (punto.Y < 0f)
  161.             {
  162.                 punto.Y = -1f;
  163.             }
  164.             if (punto.Y > estremiFoglio.Y)
  165.             {
  166.                 punto.Y = estremiFoglio.Y + 1f;
  167.             }
  168.         }
  169.  
  170.         private void Normalizza(ref Tratto segmento)
  171.         {
  172.             float temp;
  173.             if (segmento.inizio.X > segmento.fine.X)
  174.             {
  175.                 temp = segmento.inizio.X;
  176.                 segmento.inizio.X = segmento.fine.X;
  177.                 segmento.fine.X = temp;
  178.             }
  179.             if (segmento.inizio.Y > segmento.fine.Y)
  180.             {
  181.                 temp = segmento.inizio.Y;
  182.                 segmento.inizio.Y = segmento.fine.Y;
  183.                 segmento.fine.Y = temp;
  184.             }
  185.         }
  186.  
  187.         private void LimitiFoglio()
  188.         {
  189.             int x=1, y=1;
  190.             while (foglio.IsVisible(x, 1))
  191.             {
  192.                 x++;
  193.             }
  194.             while (foglio.IsVisible(1, y))
  195.             {
  196.                 y++;
  197.             }
  198.             estremiFoglio.X = x;
  199.             estremiFoglio.Y = y;
  200.         }
  201.  
  202.     }
  203. }