private void test5ToolStripMenuItem_Click(object sender,EventArgs e) { Line2D lin = new Line2D(0,0,1,1); Raggio ray0 = new Raggio(lin,700); Matrix mm = Matrix.Lower(4); Matrix mm1 = !mm; Point2D p1 = new Point2D(1, 0); Point2D p2 = new Point2D(0, 1); Point2D p3 = new Point2D (0,2); Point2D pc = new Point2D (0,0); Point2D p4 = new Point2D (2, 1); Point2D p1w = new Point2D(1, -0.01); Arc2D ar1 = new Arc2D(pc, p1, p2); Line2D ln1 = new Line2D(p2, p3); Line2D ln2 = new Line2D(p4, p3); Line2D ln3; ln3 = new Line2D(p4,p1); CorpoOttico cc = new CorpoOttico(new MaterialeOttico("vetro",1.4)); cc.Add(new Contorno(ln3)); cc.Add(new Contorno(ln2)); cc.Add(new Contorno(ln1)); cc.Add(new Contorno(ar1)); cc.Validate(); Point2D po = new Point2D(1.5, -1); Arc2D cerchio = new Arc2D(po, 4); Raggio ray; ray = new Raggio(new Line2D(po, p1 + new Point2D(0.05,0)),Ottica.LunghezzaOnda.Rosso); List<Intersection> intersezioni = cc.TrovaIntersezioniPositive(ray); Contorno xx = cc.Contorno(intersezioni[0].tr2); #pragma warning disable int tmp; tmp = 1; }
private void test3ToolStripMenuItem_Click(object sender,EventArgs e) { Point2D p1 = new Point2D(1, 0); Point2D p2 = new Point2D(0, 1); Point2D p3 = new Point2D (1,1); Point2D pc = new Point2D (0,0); Arc2D ar1 = new Arc2D(pc, p1, p2); Arc2D ar2 = new Arc2D(pc, p2, p1); Arc2D ar3 = new Arc2D(p3, p2); Line2D ln1 = new Line2D(p1, p2); Line2D ln2 = new Line2D(pc, p3); Line2D ln3 = new Line2D(0,0,30,3,false,true); List<Contorno> profilo = new List<Contorno>(); profilo.Add(new Contorno(ln1)); profilo.Add(new Contorno(ln2)); profilo.Add(new Contorno(ar1)); List<Intersection> li1 = Function2D.Intersect(ln1, profilo[1].Tratto); CorpoOttico blocco = new CorpoOttico(new MaterialeOttico("vetro",1.4)); #pragma warning disable int tmp; tmp = 1; #pragma warning restore }
private void test4ToolStripMenuItem_Click(object sender,EventArgs e) { Point2D p1 = new Point2D(1, 0); Point2D p2 = new Point2D(0, 1); Point2D p3 = new Point2D (0,2); Point2D pc = new Point2D (0,0); Point2D p4 = new Point2D (2, 1); Point2D p1w = new Point2D(1, -0.01); Arc2D ar1 = new Arc2D(pc, p1, p2); Line2D ln1 = new Line2D(p2, p3); Line2D ln2 = new Line2D(p4, p3); Line2D ln3; ln3 = new Line2D(p4,p1); // ln3 = new Line2D(p4,p1w); CorpoOttico cc = new CorpoOttico(new MaterialeOttico("vetro",1.4)); cc.Add(new Contorno(ln3)); cc.Add(new Contorno(ln2)); cc.Add(new Contorno(ln1)); cc.Add(new Contorno(ar1)); cc.Validate(); Point2D po = new Point2D(1.5, -1); Line2D ray; ray = new Line2D(po, p1 + new Point2D(0.05,0)); ray.Normalize(); List<Intersection> intersezioni = cc.TrovaIntersezioniPositive(ray); #pragma warning disable int tmp; tmp = 1; #pragma warning restore }
/// <summary>Costruttore di copia</summary> /// <param name="sorgente"></param> public SorgenteOttica(SorgenteOttica sorgente) : base(sorgente.Nome) { this.tipoSorgente = sorgente.tipoSorgente; this.arco = sorgente.arco; this.diametro = sorgente.diametro; this.divergenza = sorgente.divergenza; this.lambda = sorgente.lambda; this.nraggi = sorgente.nraggi; this.lineaRaggio = sorgente.lineaRaggio; Validate(); }
private void test1ToolStripMenuItem_Click(object sender, EventArgs e) { Point2D p1 = new Point2D(1, 0); Point2D p2 = new Point2D(0, 1); Point2D p3 = new Point2D (1,1); Point2D pc = new Point2D (0,0); Point2D p4 = new Point2D (0, -1); Point2D p5 = new Point2D (1, 2); Point2D p6 = new Point2D (1, -1); Arc2D ar1 = new Arc2D(pc, p1, p2); Arc2D ar1x = new Arc2D(p1, p2, pc, Arc2D.TrePunti.Estremi_e_Centro); Arc2D ar2 = new Arc2D(pc, p2, p1); Arc2D ar2x = new Arc2D(p2, p1, pc, Arc2D.TrePunti.Estremi_e_Centro); Arc2D ar3 = new Arc2D(p3, p2); Line2D ln1 = new Line2D(p1, p2); Line2D ln2 = new Line2D(pc, p3); Line2D ln3 = new Line2D(0,0,30,3,false,true); Line2D ln4 = new Line2D(pc, p2, true); Line2D ln5 = new Line2D(p2, p3); bool b1 = ar1.Belongs(0); bool b2 = ar1.Belongs(Math.PI/4); bool b3 = ar1.Belongs(Math.PI / 8); bool b4 = ln1.Belongs(p1); bool c1 = ar1.Belongs(new Point2D(0,1)); bool c2 = ar1.Belongs(new Point2D(1,0)); bool c3 = ar1.Belongs(new Point2D(Math.Sqrt(2)/2,Math.Sqrt(2)/2)); List<Intersection> li1 = Function2D.Intersect(ln1, ln2); List<Intersection> li2 = Function2D.Intersect(ln2, ar1); List<Intersection> li3 = Function2D.Intersect(ln2, ar1, true, true); List<Intersection> li4 = Function2D.Intersect(ln3, ar1); List<Intersection> li5 = Function2D.Intersect(ln2, ar2, false, true); List<Intersection> li6 = Function2D.Intersect(ln4, ar3, false, false); List<Intersection> li7 = Function2D.Intersect(ln5, ln3); Point2D[] nr = new Point2D[3]; double[] nrd = new double[3]; Function2D.Nearest(p2, ln2, out nr[0], out nrd[0]); Function2D.Nearest(p4, ln3, out nr[1], out nrd[1], true); Function2D.Nearest(p6, ln3, out nr[2], out nrd[2]); Point2D[] nrx = new Point2D[3]; nrx[0] = Function2D.Nearest(p2, ln2); nrx[1] = Function2D.Nearest(p4, ln3, true); nrx[2] = Function2D.Nearest(p6, ln3); Point2D[] pr = new Point2D[4]; bool[] prb = new bool[4]; prb[0] = Function2D.Projection(p3, ln2, out pr[0]); prb[1] = Function2D.Projection(p4, ln2, out pr[1]); prb[2] = Function2D.Projection(p6, ln2, out pr[2]); prb[3] = Function2D.Projection(p2, ln3, out pr[3]); Point2D[] prx = new Point2D[4]; prx[0] = Function2D.Projection(p3, ln2); prx[1] = Function2D.Projection(p4, ln2); prx[2] = Function2D.Projection(p6, ln2); prx[3] = Function2D.Projection(p2, ln3); Point2D[] pra = new Point2D[5]; bool[] prab = new bool[5]; prab[0] = Function2D.Projection(p6, ar2, out pra[0], true); prab[1] = Function2D.Projection(p5, ar1, out pra[1], true); prab[2] = Function2D.Projection(p5, ar2, out pra[2], true); prab[3] = Function2D.Projection(p5, ar2, out pra[3], false); prab[4] = Function2D.Projection(p4, ar3, out pra[4], true); Point2D[] prax = new Point2D[5]; prax[0] = Function2D.Projection(p6, ar2, true); prax[1] = Function2D.Projection(p5, ar1, true); prax[2] = Function2D.Projection(p5, ar2, true); prax[3] = Function2D.Projection(p5, ar2); prax[4] = Function2D.Projection(p4, ar3, true); Point2D x = new Point2D(10,-1); x = -x; Line2D[] vout = new Line2D[3]; bool[] bv = new bool[3]; bv[0] = Function2D.LineOut(pra[0], ar2, out vout[0], p6); bv[1] = Function2D.LineOut(pr[3], ln3, out vout[1], p3); bv[2] = Function2D.LineOut(pra[0], ar2, out vout[2], p2); Line2D[] voux = new Line2D[3]; voux[0] = Function2D.LineOut(pra[0], ar2, p6); voux[1] = Function2D.LineOut(pr[3], ln3, p3); voux[2] = Function2D.LineOut(pra[0], ar2, p2); Point2D[] vettori = new Point2D[3]; vettori[0] = voux[0].Vector(); vettori[1] = voux[1].Vector(); vettori[2] = voux[2].Vector(); Point2D[] vvout = new Point2D[3]; bool[] bvv = new bool[3]; bvv[0] = Function2D.VersorOut(pra[0], ar2, out vvout[0], p6); bvv[1] = Function2D.VersorOut(pr[3], ln3, out vvout[1], p3); bvv[2] = Function2D.VersorOut(pra[0], ar2, out vvout[2], p2); Point2D[] vvoux = new Point2D[3]; vvoux[0] = Function2D.VersorOut(pra[0], ar2, p6); vvoux[1] = Function2D.VersorOut(pr[3], ln3, p3); vvoux[2] = Function2D.VersorOut(pra[0], ar2, p2); double[] scalari = new double[3]; scalari[0] = vvoux[0]^vettori[0]; scalari[1] = vvoux[1]^vettori[1]; scalari[2] = vvoux[2]^vettori[2]; Point2D Punto2 = new Point2D(-5.17,9.91); Point2D Punto3 = new Point2D(-4.82,-10.08); Point2D centroX = new Point2D(94.48,1.64); Arc2D Arco = new Arc2D(Punto2,Punto3,centroX,Arc2D.TrePunti.Estremi_e_Centro); #pragma warning disable int tmp; tmp = 1; #pragma warning restore }
/// <summary> /// Linea (modulo unitario) per il punto p normale ad un arco /// </summary> /// <param name="p">Punto p</param> /// <param name="a">Arco</param> /// <param name="ext">Punto esterno opzionale per definire il verso</param> /// <returns>La linea normale o null se non trovata</returns> public static Line2D LineOut( Point2D p, Arc2D a, Point2D ext = null) { Line2D vOut; if( ! LineOut( p, a, out vOut, ext)) vOut = null; return vOut; }
/// <summary> /// Versore (modulo unitario) per il punto p normale ad un arco /// </summary> /// <param name="p">Punto p</param> /// <param name="a">Arco</param> /// <param name="ext">Punto esterno opzionale per definire il verso</param> /// <returns>Il versore normale o null se non trovato</returns> public static Point2D VersorOut( Point2D p, Arc2D a, Point2D ext = null) { Point2D vOut; if( ! VersorOut( p, a, out vOut, ext)) vOut = null; return vOut; }
/// <summary> /// Proiezione di un punto su un arco /// </summary> /// <param name="p">Punto</param> /// <param name="a">Arco</param> /// <param name="bInside">true se richiesta appartenenza proiezione all'interno della linea</param> /// <returns>La proiezione</returns> public static Point2D Projection( Point2D p, Arc2D a, bool bInside = false) { Point2D proj; if( ! Projection( p, a, out proj, bInside)) // Cerca il punto proj = null; // Se non trova: imposta a null return proj; }
/// <summary> /// Versore (modulo unitario) per il punto p normale ad un arco /// </summary> /// <param name="p">Punto p</param> /// <param name="a">Arco</param> /// <param name="vOut">Versore normale (parametro out)</param> /// <param name="ext">Punto esterno opzionale per definire il verso</param> /// <returns>true se trovato</returns> public static bool VersorOut( Point2D p, Arc2D a, out Point2D vOut, Point2D ext = null) { bool prf; Point2D pr; vOut = null; prf = Projection(p, a, out pr, true); // Proiezione su curva (appartenente) if(prf) // Se trovata... { Point2D normale = (pr - a.Center); // Normale per il punto di proiezione bool test = normale.Normalize(); // Normalizza modulo (false se fallisce) if(ext != null) { double scalare = (ext-pr) ^ normale; // Scalare tra vettore uscente e normale calcolata if(scalare < 0) normale = -normale; // Inverte } if(test) // controllo extra vOut = normale; // Linea uscente da pr, lunghezza unitaria } return prf; // restituisce false se errore }
/// <summary> /// Proiezione di un punto su un arco /// </summary> /// <param name="p">Punto</param> /// <param name="a">Arco</param> /// <param name="projection">Proiezione (parametro out)</param> /// <param name="bInside">true se richiesta appartenenza proiezione all'interno dell'arco</param> /// <returns>true se trovata</returns> public static bool Projection( Point2D p, Arc2D a, out Point2D projection, bool bInside = false) { Point2D proj = null; // La proiezione, se trovata Point2D dir = p - a.Center; // Calcola il vettore dal centro al punto if(dir.Normalize()) // Lo normalizza. Se nessun errore... { Point2D proj1 = a.Center + a.Radius * dir; // Calcola le due proiezioni sul cerchio. Point2D proj2 = a.Center - a.Radius * dir; double d1 = Function2D.Distance(proj1, p); // e le distanze tra punto e proiezione double d2 = Function2D.Distance(proj2, p); bool app1, app2; // Appartenenza all'arco delle due proiezione app1 = app2 = true; if( bInside == true) // Verifica le appartenenze all'arco { double alfa; if(a.Alfa(proj1, out alfa)) // calcola l'angolo del primo e del secondo punto proiettato { // scarta, se non appartiene all'arco if(!a.Belongs(alfa)) app1 = false; } if(a.Alfa(proj2, out alfa)) { if(!a.Belongs(alfa)) app2 = false; } } if( (app1==true) && (app2==true) ) // Se entrambi appartengono all'arco { // scarta quello con distanza maggiore if(d1 >= d2) app1 = false; else app2 = false; } if(app1) // Imposta proj con la proiezione valida... proj = proj1; // ...se c'e` else if(app2) proj = proj2; } if(proj != null) // Se trovata proiezione, esce con true... { projection = proj; return true; } projection = new Point2D(); return false; // ...se non trovata, esce con false + punto vuoto. }
/// <summary> /// Punto piu` vicino a p, su un arco /// </summary> /// <param name="p">Punto p</param> /// <param name="a">Arco</param> /// <param name="bInside">true se richiesta intersezione interna all'arco</param> /// <returns>Il punto trovato, se no null</returns> public static Point2D Nearest( Point2D p, Arc2D a, bool bInside = false) { Point2D nearest; double distance; if( ! Nearest(p, a, out nearest, out distance, bInside)) // Cerca il punto nearest = null; // Se non trova: imposta a null return nearest; }
/// <summary> /// Punto piu` vicino a p, su un arco /// </summary> /// <param name="p">Punto p</param> /// <param name="a">Arco</param> /// <param name="nearest">Punto trovato (parametro out)</param> /// <param name="distance">Distanza (parametro out)</param> /// <param name="bInside">true se richiesta intersezione interna all'arco</param> /// <returns>true se trovato</returns> public static bool Nearest( Point2D p, Arc2D a, out Point2D nearest, out double distance, bool bInside = false) { bool bFound = false; nearest = new Point2D(); distance = double.MaxValue; Point2D projection = new Point2D(); List<Point2D> plist = new List<Point2D>(); if(Function2D.Projection(p, a, out projection, bInside)) // Calcola le proiezioni di p su a usando bInside { // Se la trova, la aggiunge alla lista plist.Add(projection); } if (bInside) // Se richiesto bInside, cioe` solo punti interni... { // al segmento, ne aggiunge anche gli estremi alla lista plist.Add(a.PIni); // (se bInside e` false, la prioezione e` comunque plist.Add(a.PFin); // il piu` vicino } bFound = Function2D.Nearest(p, plist, out nearest, out distance); // Cerca il punto piu` vicino nella lista return bFound; }
/// <summary> /// Intersezioni tra linea ed arco /// </summary> /// <param name="l1">Linea</param> /// <param name="a2">Arco</param> /// <param name="bCheckInside1">Richiesta intersezione interna alla linea</param> /// <param name="bCheckInside2">Richiesta intersezione interna all'arco</param> /// <returns></returns> public static List<Intersection> Intersect( Line2D l1, Arc2D a2, bool bCheckInside1 = false, bool bCheckInside2 = false) { double[] t = new double[2]; double[] a = new double[2]; Point2D[] p = new Point2D[2]; bool[] ok = new bool[2]; // soluzione trovata e valida bool[] tg = new bool[2]; // intersezione doppia List<Intersection> intersezioni = new List<Intersection>(); // P = P1 + t (P2 - P1) equazione della retta del segmento // P = C + r (cos a, sin a) oppure equazione della circonferenza // || P - C ||^2 = r^2 altra equazione della circonferenza // || P1 - C + t (P2 - P1) ||^2 = r^2 Intersezione: punto su entrambi // A = P1 - C; B = P2 - P1 Sostituzioni // || V || = V.x^2 + V.y^2 = V ^ V (scalare) Definizione di modulo // || A + t B ||^2 = r^2 Intersezione, sostituendo... // (A.x + t B.x)^2 + (A.y + t B.y)^2 - r^2 = 0 ... // A.x^2 + t^2 B.x^2 + 2 t A.x B.x + A.y^2 + t^2 B.y^2 + 2 t A.y B.y - r^2 = 0 ... // A.x^2 + A.y^2 + t^2 ( B.x^2 + B.y^2) + 2 t ( A.y B.y + A.x B.x) - r^2 = 0 ... // t^2(B^B) + 2 t (A^B) + A^A - r^2 = 0 Equazione di secondo grado da risolvere // a=B^B 2b=2*A^B c=A^A-r^2 in a*t^2 + 2*b*t + c = 0 Coefficienti // t12 = [-2b +- sqr( (2b)^2 - 4ac) ] / 2a = [-2b +- 2sqr( b^2 - ac) ] / 2a Formula completa... // t1 = [-b +- sqr(b^2-ac)]/a ...e ridotta Point2D A = l1.P1 - a2.Center; Point2D B = l1.P2 - l1.P1; double r = a2.Radius; ok[0] = ok[1] = false; // Imposta i flag tg[0] = tg[1] = false; double aEq, bEq, cEq, dEq24, dEq2; // Calcola con formula ridotta ERRORE NELLA FORMULA ??? aEq = B^B; bEq = A^B; cEq = (A^A) - r*r; dEq24 = bEq*bEq - aEq*cEq; if(dEq24 >= 0.0) // Cerca le soluzioni, memorizza valori ed imposta i flag { // Se ci sono soluzioni if(Math.Abs(dEq24) < Function2D.epsilon) // Delta = 0, una soluzione { t[0] = -bEq / aEq; p[0] = l1.P1 + t[0] * (l1.P2 - l1.P1); if(a2.Alfa(p[0], out a[0])) // Calcola alfa dell'arco e imposta flag della soluzione { ok[0] = true; tg[0] = true; // tangente, soluzione doppia } } else // Delta > 0, due soluzioni { dEq2 = Math.Sqrt(dEq24); // Radice di delta t[0] = (-bEq - dEq2) / aEq; t[1] = (-bEq + dEq2) / aEq; p[0] = l1.P1 + t[0] * (l1.P2 - l1.P1); p[1] = l1.P1 + t[1] * (l1.P2 - l1.P1); if(a2.Alfa(p[0], out a[0])) // Calcola alfa e flag delle due soluzioni ok[0] = true; if(a2.Alfa(p[1], out a[1])) ok[1] = true; } } for(int i=0; i<2; i++) // Verifica, se richieste, le appartenenze a segmento e arco { if(ok[i]) // Esamina, se c'e', la soluzione { if(bCheckInside1) // Se richiesto punto interno verifica... { if( (t[i] < 0.0) || (t[i] > 1.0) ) // Se t trovato indica che e` esterno, imposta a false ok[i] = false; } if(bCheckInside2) // Idem per l'arco... { if(!a2.Belongs(a[i])) ok[i] = false; } } } for(int i=0; i<2; i++) // Riesamina le soluzione { if(ok[i]) // Se trovata, aggiunge intersezione alla lista { intersezioni.Add(new Intersection(p[i], t[i], a[i], l1, a2, false, tg[i])); } } return intersezioni; // Restituisce il rif. alla lista }
/// <summary> /// Crea corpo ottico dalla lente nella posizione standard /// </summary> /// <returns></returns> //public CorpoOttico CreaCorpoOttico() // { // #warning Creare funzione CreaCorpoOttivo(Transform2D) // CorpoOttico co = null; // if(this.IsValid) // { // Point2D pt1 = new Point2D(0, RL); // Punti caratteristici // Point2D pt2 = new Point2D(-ET, RL); // Point2D pt3 = new Point2D(-ET, -RL); // Point2D pt4 = new Point2D(0.0, -RL); // Point2D ct1 = new Point2D(XCC1,0.0); // Point2D ct2 = new Point2D(XCC2,0.0); // Tratto sup1, sup2; // Contorni // Tratto bordo1, bordo2; // if(TIPO1 == Lente.TipoSuperficie.piana) // sup1 = new Line2D(pt2,pt3); // else if(TIPO1 == Lente.TipoSuperficie.convessa) // sup1 = new Arc2D(pt2,pt3,ct1,Arc2D.TrePunti.Estremi_e_Centro); // else // sup1 = new Arc2D(pt3,pt2,ct1,Arc2D.TrePunti.Estremi_e_Centro); // if(TIPO2 == Lente.TipoSuperficie.piana) // sup2 = new Line2D(pt1,pt4); // else if(TIPO2 == Lente.TipoSuperficie.convessa) // sup2 = new Arc2D(pt4,pt1,ct2,Arc2D.TrePunti.Estremi_e_Centro); // else // sup2 = new Arc2D(pt1,pt4,ct2,Arc2D.TrePunti.Estremi_e_Centro); // bordo1 = new Line2D(pt1, pt2); // bordo2 = new Line2D(pt3,pt4); // string nome_materiale = GetNomeMateriale(); // Imposta i nomi // string nome_lente = GetNomeCorpoOttico(); // MaterialeOttico mat_lente = new MaterialeOttico(nome_materiale, this.N); // Crea il materiale // co = new CorpoOttico(mat_lente,nome_lente); // Crea il corpo ottico // co.Add(new Contorno(bordo1, StatoSuperficie.Opaca)); // Aggiunge i contorni // co.Add(new Contorno(sup1)); // co.Add(new Contorno(bordo2, StatoSuperficie.Opaca)); // co.Add(new Contorno(sup2)); // } // return co; // } public CorpoOttico CreaCorpoOttico(Transform2D tr = null) { CorpoOttico co = null; if(this.IsValid) { if(tr==null) { tr = new Transform2D(Matrix.Id(Transform2D.Dim2Dhom)); } Point2D pt1 = tr.Transform(new Point2D(0, RL)); // Punti caratteristici Point2D pt2 = tr.Transform(new Point2D(-ET, RL)); Point2D pt3 = tr.Transform(new Point2D(-ET, -RL)); Point2D pt4 = tr.Transform(new Point2D(0.0, -RL)); Point2D ct1 = tr.Transform(new Point2D(XCC1,0.0)); Point2D ct2 = tr.Transform(new Point2D(XCC2,0.0)); Tratto sup1, sup2; // Contorni Tratto bordo1, bordo2; if(TIPO1 == Lente.TipoSuperficie.piana) sup1 = new Line2D(pt2,pt3); else if(TIPO1 == Lente.TipoSuperficie.convessa) sup1 = new Arc2D(pt2,pt3,ct1,Arc2D.TrePunti.Estremi_e_Centro); else sup1 = new Arc2D(pt3,pt2,ct1,Arc2D.TrePunti.Estremi_e_Centro); if(TIPO2 == Lente.TipoSuperficie.piana) sup2 = new Line2D(pt1,pt4); else if(TIPO2 == Lente.TipoSuperficie.convessa) sup2 = new Arc2D(pt4,pt1,ct2,Arc2D.TrePunti.Estremi_e_Centro); else sup2 = new Arc2D(pt1,pt4,ct2,Arc2D.TrePunti.Estremi_e_Centro); bordo1 = new Line2D(pt1, pt2); bordo2 = new Line2D(pt3,pt4); string nome_materiale = GetNomeMateriale(); // Imposta i nomi string nome_lente = GetNomeCorpoOttico(); MaterialeOttico mat_lente = new MaterialeOttico(nome_materiale, this.N); // Crea il materiale co = new CorpoOttico(mat_lente,nome_lente); // Crea il corpo ottico co.Add(new Contorno(bordo1, StatoSuperficie.Opaca)); // Aggiunge i contorni co.Add(new Contorno(sup1)); co.Add(new Contorno(bordo2, StatoSuperficie.Opaca)); co.Add(new Contorno(sup2)); } return co; }