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