3dpcp/.svn/pristine/55/55cdb4c8f35086ef92bdd6432b628e418257ae5c.svn-base

211 lines
6.8 KiB
Text
Raw Normal View History

2012-09-16 12:33:11 +00:00
/////////////////////////////////////////////////////////////////////////////
// Name: geometry.cpp
// Author: John Labenski
// Created: 07/01/02
// Copyright: John Labenski, 2002
// License: wxWidgets v2
/////////////////////////////////////////////////////////////////////////////
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "geometry.h"
#endif
// For compilers that support precompilation, includes "wx/wx.h".
#include <wx/wxprec.h>
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "wx/things/geometry.h"
/*
2.4 : How do I generate a circle through three points?
Let the three given points be a, b, c. Use _0 and _1 to represent x and y coordinates. The coordinates of the center p=(p_0,p_1) of the circle determined by a, b, and c are:
A = b_0 - a_0; B = b_1 - a_1; C = c_0 - a_0; D = c_1 - a_1;
E = A*(a_0 + b_0) + B*(a_1 + b_1); F = C*(a_0 + c_0) + D*(a_1 + c_1);
G = 2.0*(A*(c_1 - b_1)-B*(c_0 - b_0));
p_0 = (D*E - B*F) / G; p_1 = (A*F - C*E) / G;
If G is zero then the three points are collinear and no finite-radius circle through them exists. Otherwise, the radius of the circle is:
r^2 = (a_0 - p_0)^2 + (a_1 - p_1)^2
[O' Rourke (C)] p. 201. Simplified by Jim Ward.
*/
wxCircleDouble::wxCircleDouble(const wxPoint2DDouble &p1,
const wxPoint2DDouble &p2,
const wxPoint2DDouble &p3)
{
wxDouble A = p2.m_x - p1.m_x,
B = p2.m_y - p1.m_y,
C = p3.m_x - p1.m_x,
D = p3.m_y - p1.m_y;
wxDouble E = A*(p1.m_x + p2.m_x) + B*(p1.m_y + p2.m_y),
F = C*(p1.m_x + p3.m_x) + D*(p1.m_y + p3.m_y),
G = 2.0*(A*(p3.m_y - p2.m_y)-B*(p3.m_x - p2.m_x));
if (G == 0)
{
m_x = m_y = m_r = 0;
return;
}
m_x = (D*E - B*F) / G,
m_y = (A*F - C*E) / G;
m_r = sqrt( (p1.m_x - m_x)*(p1.m_x - m_x) + (p1.m_y - m_y)*(p1.m_y - m_y) );
}
int wxCircleDouble::IntersectLine( const wxRay2DDouble &line,
wxPoint2DDouble *pt1,
wxPoint2DDouble *pt2 ) const
{
//if (line.GetDistanceToPoint(m_origin) > m_r) return 0;
wxDouble l1_x = m_x-m_r, l1_y = line.GetYFromX(l1_x);
wxDouble l2_x = m_x+m_r, l2_y = line.GetYFromX(l2_x);
// quick check to see it it intersects at all
//wxDouble top = m_origin.m_y-m_r, bot = m_origin.m_y+m_r;
//if (((l1_y < top)&&(l2_y < top))||((l1_y > bot)&&(l2_y > bot))) return 0;
wxDouble l2_l1_x = l2_x - l1_x, l2_l1_y = l2_y - l1_y;
wxDouble a = l2_l1_x*l2_l1_x + l2_l1_y*l2_l1_y;
wxDouble b = 2.0 * (l2_l1_x * (l1_x - m_x) + l2_l1_y * (l1_y - m_y) );
wxDouble c = m_x*m_x + m_y*m_y + l1_x*l1_x + l1_y*l1_y - 2.0*(m_x*l1_x + m_y*l1_y) - m_r*m_r;
wxDouble det = b*b - 4.0*a*c;
if ( det < 0 )
{
return 0;
}
else if ( det == 0 )
{
if (pt1)
{
wxDouble u = -b/(2.0*a);
pt1->m_x = l2_x + u*l2_l1_x;
pt1->m_y = l2_y + u*l2_l1_y;
}
return 1;
}
// else det > 0 so 2 points intersect
wxDouble e = sqrt(det);
if (pt1)
{
wxDouble u1 = (-b - e)/( 2.0*a );
pt1->m_x = l1_x + u1*l2_l1_x;
pt1->m_y = l1_y + u1*l2_l1_y;
}
if (pt2)
{
wxDouble u2 = (-b + e)/( 2.0*a );
pt2->m_x = l1_x + u2*l2_l1_x;
pt2->m_y = l1_y + u2*l2_l1_y;
}
return 2;
}
/*
int wxEllipseInt::IntersectLine( const wxLine2DInt &line,
wxPoint2DInt &pt1,
wxPoint2DInt &pt2 ) const
{
//Intersection.intersectEllipseLine = function(c, rx, ry, a1, a2) {
//var result;
//line.m_pt // var origin = new Vector2D(a1.x, a1.y);
wxPoint2DInt dir = pt2 - p21; // var dir = Vector2D.fromPoints(a1, a2);
//m_origin //var center = new Vector2D(c.x, c.y);
wxPoint2DInt diff = line.m_pt - m_origin; //var diff = origin.subtract(center);
//var mDir = new Vector2D( dir.x/(rx*rx), dir.y/(ry*ry) );
wxPoint2DDouble mDir = wxPoint2DDouble(wxDouble(dir.m_x)/(m_radius.m_x*m_radius.m_x),
wxDouble(dir.m_y)/(m_radius.m_y*m_radius.m_y));
//var mDiff = new Vector2D( diff.x/(rx*rx), diff.y/(ry*ry) );
wxPoint2DDouble mDiff = wxPoint2DDouble(wxDouble(diff.m_x)/(m_radius.m_x*m_radius.m_x),
wxDouble(diff.m_y)/(m_radius.m_y*m_radius.m_y));
wxDouble a = dir.GetDotProduct(mDir); //var a = dir.dot(mDir);
wxDouble b = dir.GetDotProduct(mDiff); //var b = dir.dot(mDiff);
wxDouble c = diff.GetDotProduct(m_diff); //var c = diff.dot(mDiff) - 1.0;
wxDouble d = b*b - a*c; //var d = b*b - a*c;
if ( d < 0 )
{
return 0; //result = new Intersection("Outside");
}
else if ( d > 0 )
{
wxDouble root = sqrt(d); //var root = Math.sqrt(d);
wxDouble t_a = (-b - root)/a; //var t_a = (-b - root) / a;
wxDouble t_b = (-b + root)/a; //var t_b = (-b + root) / a;
if ( (t_a < 0 || 1 < t_a) && (t_b < 0 || 1 < t_b) )
{
if ( (t_a < 0 && t_b < 0) || (t_a > 1 && t_b > 1) )
result = new Intersection("Outside");
else
result = new Intersection("Inside");
}
else
{
result = new Intersection("Intersection");
if ( 0 <= t_a && t_a <= 1 )
result.appendPoint( a1.lerp(a2, t_a) );
if ( 0 <= t_b && t_b <= 1 )
result.appendPoint( a1.lerp(a2, t_b) );
}
}
else
{
var t = -b/a;
if ( 0 <= t && t <= 1 )
{
result = new Intersection("Intersection");
result.appendPoint( a1.lerp(a2, t) );
} else
{
result = new Intersection("Outside");
}
}
return result;
}
*/
/*
> I am looking for the algorithm to calculate the intersection of a line
with
> an ellipse, that is not necessarily parrallel to x,y axis.
>
> I cannot find anything that is easy to understand.
The ellipse can be represented by a quadratic polynomial,
a00+a10*x+a01*y+a20*x^2+a11*x*y+a02*y^2 = 0.
The line is b0+b1*x+b2*y = 0 where one of b1 or b2 is
not zero. For the sake of argument, suppose b2 is not
zero. Solve for y = -(b0+b1*x)/b2. Replace this in the
quadratic equation and multiply through by b2^2 to get
Q(x) = c0 + c1*x + c2*x^2 = 0 where
c0 = a02*b0^2-a01*b0*b2+a00*b2^2
c1 = 2*a02*b0*b1-a11*b0*b2-a01*b1*b2+a10*b2^2
c2 = a02*b1^2-a11*b1*b2+a02*b2^2
If Q(x) has no real roots, the line and ellipse do not intersect.
If Q(x) has a single, repeated real root x0, the line and ellipse
are tangent. The y-value is y0 = -(b0+b1*x0)/b2. If Q(x)
has two distinct real roots x0 and x1, the line and ellipse
intersect in two points (x0,y0) and (x1,y1) where
y0 = -(b0+b1*x0)/b2 and y1 = -(b0+b1*x1)/b2.
*/