Пример #1
0
		/// <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.
			}
Пример #2
0
		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

			}
Пример #3
0
		/// <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
			}