home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 10 Tools
/
10-Tools.zip
/
wxos2240.zip
/
wxWindows-2.4.0
/
contrib
/
src
/
canvas
/
liner.cpp
< prev
next >
Wrap
C/C++ Source or Header
|
2001-06-17
|
20KB
|
661 lines
/*
Program wxLine.CPP
Purpose Mainly used for calculating crossings
Last Update 05-12-1995
*/
#ifdef __GNUG__
#pragma implementation "liner.cpp"
#endif
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include <math.h>
#include <stdlib.h>
#include "wx/canvas/liner.h"
wxLine::wxLine( double x1, double y1, double x2, double y2 )
{
m_AA = 0.0;
m_BB = 0.0;
m_CC = 0.0;
m_a=wxPoint2DDouble(x1,y1);
m_b=wxPoint2DDouble(x2,y2);
if (m_a==m_b)
assert(0);
m_valid_parameters = FALSE;
}
wxLine::~wxLine()
{
}
wxLine::wxLine(const wxPoint2DDouble& a,const wxPoint2DDouble& b)
{
if (a==b)
assert(0);
m_a=a;
m_b=b;
m_valid_parameters = FALSE;
}
// ActionOnTable1
// This function decide which action must be taken, after PointInLine
// has given the results of two points in relation to a wxLine. See table 1 in the report
//
// input Result_beginPoint:
// Result_endPoint :
// The results can be R_R_LEFT_SIDE, R_R_RIGHT_SIDE, R_R_ON_AREA, R_R_IN_AREA
//
// return -1: Illegal combination
// 0: No action, no crosspoints
// 1: Investigate results points in relation to the other wxLine
// 2: endPoint is a crosspoint, no further investigation
// 3: beginPoint is a crosspoint, no further investigation
// 4: beginPoint and endPoint are crosspoints, no further investigation
// 5: beginPoint is a crosspoint, need further investigation
// 6: endPoint is a crosspoint, need further investigation
int wxLine::ActionOnTable1(R_PointStatus Result_beginPoint, R_PointStatus Result_endPoint)
{
// beginPoint and endPoint are crosspoints
if (
(Result_beginPoint == R_IN_AREA)
&&
(Result_endPoint == R_IN_AREA)
)
return 4;
// there are no crosspoints, no action
if (
(
(Result_beginPoint == R_LEFT_SIDE)
&&
(Result_endPoint == R_LEFT_SIDE)
)
||
(
(Result_beginPoint == R_RIGHT_SIDE)
&&
(Result_endPoint == R_RIGHT_SIDE)
)
)
return 0;
// maybe there is a crosspoint, further investigation needed
if (
(
(Result_beginPoint == R_LEFT_SIDE)
&&
(
(Result_endPoint == R_RIGHT_SIDE)
||
(Result_endPoint == R_ON_AREA)
)
)
||
(
(Result_beginPoint == R_RIGHT_SIDE)
&&
(
(Result_endPoint == R_LEFT_SIDE)
||
(Result_endPoint == R_ON_AREA)
)
)
||
(
(Result_beginPoint == R_ON_AREA)
&&
(
(Result_endPoint == R_LEFT_SIDE)
||
(Result_endPoint == R_RIGHT_SIDE)
||
(Result_endPoint == R_ON_AREA)
)
)
)
return 1;
//there is a crosspoint
if (
(
(Result_beginPoint == R_LEFT_SIDE)
||
(Result_beginPoint == R_RIGHT_SIDE)
)
&&
(Result_endPoint == R_IN_AREA)
)
return 2;
// there is a crosspoint
if (
(Result_beginPoint == R_IN_AREA)
&&
(
(Result_endPoint == R_LEFT_SIDE)
||
(Result_endPoint == R_RIGHT_SIDE)
)
)
return 3;
// beginPoint is a crosspoint, further investigation needed
if (
(Result_beginPoint == R_IN_AREA)
&&
(Result_endPoint == R_ON_AREA)
)
return 5;
// endPoint is a crosspoint, further investigation needed
if (
(Result_beginPoint == R_ON_AREA)
&&
(Result_endPoint == R_IN_AREA)
)
return 6;
// All other combinations are illegal
return -1;
}
// ActionOnTable2
// This function decide which action must be taken, after PointInLine
// has given the results of two points in relation to a wxLine. It can only give a
// correct decision if first the relation of the points from the wxLine
// are investigated in relation to the wxLine wich can be constucted from the points.
//
// input Result_beginPoint:
// Result_endPoint :
// The results can be R_LEFT_SIDE, R_RIGHT_SIDE, R_ON_AREA, R_IN_AREA
//
// return -1: Illegal combination
// 0: No action, no crosspoints
// 1: Calculate crosspoint
// 2: endPoint is a crosspoint
// 3: beginPoint is a crosspoint
// 4: beginPoint and endPoint are crosspoints
int wxLine::ActionOnTable2(R_PointStatus Result_beginPoint, R_PointStatus Result_endPoint)
{
// beginPoint and eindpoint are crosspoints
if (
(Result_beginPoint == R_IN_AREA)
&&
(Result_endPoint == R_IN_AREA)
)
return 4;
// there are no crosspoints
if (
(
(Result_beginPoint == R_LEFT_SIDE)
&&
(
(Result_endPoint == R_LEFT_SIDE)
||
(Result_endPoint == R_ON_AREA)
)
)
||
(
(Result_beginPoint == R_RIGHT_SIDE)
&&
(
(Result_endPoint == R_RIGHT_SIDE)
||
(Result_endPoint == R_ON_AREA)
)
)
||
(
(Result_beginPoint == R_ON_AREA)
&&
(
(Result_endPoint == R_LEFT_SIDE)
||
(Result_endPoint == R_RIGHT_SIDE)
||
(Result_endPoint == R_ON_AREA)
)
)
)
return 0;
// there is a real intersection, which must be calculated
if (
(
(Result_beginPoint == R_LEFT_SIDE)
&&
(Result_endPoint == R_RIGHT_SIDE)
)
||
(
(Result_beginPoint == R_RIGHT_SIDE)
&&
(Result_endPoint == R_LEFT_SIDE)
)
)
return 1;
// endPoint is a crosspoint
if (
(
(Result_beginPoint == R_LEFT_SIDE)
||
(Result_beginPoint == R_RIGHT_SIDE)
||
(Result_beginPoint == R_ON_AREA)
)
&&
(Result_endPoint == R_IN_AREA)
)
return 2;
// beginPoint is a crosspoint
if (
(Result_beginPoint == R_IN_AREA)
&&
(
(Result_endPoint == R_LEFT_SIDE)
||
(Result_endPoint == R_RIGHT_SIDE)
||
(Result_endPoint == R_ON_AREA)
)
)
return 3;
// All other combinations are illegal
return -1;
}
// Calculate the Y when the X is given
double wxLine::Calculate_Y(double X)
{
CalculateLineParameters();
if (m_AA != 0)
return -(m_AA * X + m_CC) / m_BB;
else
// horizontal wxLine
return m_a.m_y;
}
void wxLine::Virtual_Point(wxPoint2DDouble& a_point,double distance) const
{
assert(m_valid_parameters);
//calculate the distance using the slope of the wxLine
//and rotate 90 degrees
a_point.m_y=a_point.m_y + (distance * -m_BB);
a_point.m_x=a_point.m_x - (distance * m_AA );
}
//
// Calculate the lineparameters for the wxLine if nessecary
//
void wxLine::CalculateLineParameters()
{
// if not valid_parameters calculate the parameters
if (!m_valid_parameters)
{
double length;
// bp AND ep may not be the same
if (m_a == m_b)
assert (0);
m_AA = (m_b.m_y - m_a.m_y); // A = (Y2-Y1)
m_BB = (m_a.m_x - m_b.m_x); // B = (X1-X2)
// the parameters A end B can now be normalized
length = sqrt(m_AA*m_AA + m_BB*m_BB);
assert(length !=0);
m_AA = (m_AA / length);
m_BB = (m_BB / length);
m_CC = -((m_AA * m_a.m_x) + (m_a.m_y * m_BB));
m_valid_parameters = TRUE;
}
}
// Checks if a wxLine intersect with another wxLine
// inout wxLine : another wxLine
// Marge: optional, standard on MARGE (declared in MISC.CPP)
//
// return true : wxLines are crossing
// false: wxLines are not crossing
//
bool wxLine::CheckIntersect (wxLine& lijn, double Marge)
{
double distance=0;
// bp AND ep may not be the same
if (m_a == m_b)
assert (0);
int Take_Action1, Take_Action2;
bool Total_Result=FALSE;
R_PointStatus Result_beginPoint,Result_endPoint;
Result_beginPoint = PointInLine(lijn.m_a,distance,Marge);
Result_endPoint = PointInLine(lijn.m_b,distance,Marge);
Take_Action1 = ActionOnTable1(Result_beginPoint,Result_endPoint);
switch (Take_Action1)
{
case 0: Total_Result = FALSE ; break;
case 1: {
Result_beginPoint = lijn.PointInLine(m_a,distance,Marge);
Result_endPoint = lijn.PointInLine(m_b,distance,Marge);
Take_Action2 = ActionOnTable2(Result_beginPoint,Result_endPoint);
switch (Take_Action2)
{
case 0: Total_Result = FALSE; break;
case 1: case 2: case 3: case 4: Total_Result = TRUE; break;
}
}; break; // This break belongs to the switch(Take_Action1)
case 2: case 3: case 4: case 5: case 6: Total_Result = TRUE; break;
}
return Total_Result; //This is the final decision
}
//
// Get the beginPoint from the wxLine
// usage: Point aPoint = a_line.GetBeginPoint()
//
wxPoint2DDouble wxLine::GetBeginPoint()
{
return m_a;
}
//
// Get the endPoint from the wxLine
// usage: Point aPoint = a_line.GetEndPoint()
//
wxPoint2DDouble wxLine::GetEndPoint()
{
return m_b;
}
// Intersects two wxLines
// input wxLine : another wxLine
// Marge: optional, standard on MARGE
//
// return 0: If there are no crossings
// 1: If there is one crossing
// 2: If there are two crossings
int wxLine::Intersect(wxLine& lijn, wxPoint2DDouble& c1 ,wxPoint2DDouble& c2 , double Marge)
{
double distance=0;
// bp AND ep may not be the same
if (m_a == m_b)
assert (0);
R_PointStatus Result_beginPoint,Result_endPoint;
int Take_Action1, Take_Action2, Number_of_Crossings = 0;
Result_beginPoint = PointInLine(lijn.m_a,distance,Marge);
Result_endPoint = PointInLine(lijn.m_b,distance,Marge);
Take_Action1 = ActionOnTable1(Result_beginPoint,Result_endPoint);
// 0: No action, no crosspoints
// 1: Investigate results points in relation to the other wxLine
// 2: endPoint is a crosspoint, no further investigation
// 3: beginPoint is a crosspoint, no further investigation
// 4: beginPoint and endPoint are crosspoints, no further investigation
// 5: beginPoint is a crosspoint, need further investigation
// 6: endPoint is a crosspoint, need further investigation
// The first switch will insert a crosspoint immediatly
switch (Take_Action1)
{
case 2: case 6: c1=lijn.m_b;
Number_of_Crossings = 1;
break;
case 3: case 5: c1=lijn.m_a;
Number_of_Crossings = 1;
break;
case 4: c1=lijn.m_a;
c2=lijn.m_b;
Number_of_Crossings = 2;
break;
default:
break;
}
// This switch wil investigate the points of this wxLine in relation to lijn
// 1: Investigate results points in relation to the other wxLine
// 5: beginPoint is a crosspoint, need further investigation
// 6: endPoint is a crosspoint, need further investigation
switch (Take_Action1)
{
case 1: case 5: case 6:
{
Result_beginPoint = lijn.PointInLine(m_a,distance,Marge);
Result_endPoint = lijn.PointInLine(m_b,distance,Marge);
Take_Action2 = ActionOnTable2(Result_beginPoint,Result_endPoint);
// return -1: Illegal combination
// 0: No action, no crosspoints
// 1: Calculate crosspoint
// 2: endPoint is a crosspoint
// 3: beginPoint is a crosspoint
// 4: beginPoint and endPoint are crosspoints
switch (Take_Action2)
{
// for the cases see the returnvalue of ActionTable2
case 1: { // begin of scope to calculate the intersection
double X, Y, Denominator;
CalculateLineParameters();
Denominator = (m_AA * lijn.m_BB) - (lijn.m_AA * m_BB);
// Denominator may not be 0
assert(Denominator != 0.0);
// Calculate intersection of both linesegments
X = ((m_BB * lijn.m_CC) - (lijn.m_BB * m_CC)) / Denominator;
Y = ((lijn.m_AA * m_CC) - (m_AA * lijn.m_CC)) / Denominator;
c1.m_x=X;
c1.m_y=Y;
}
Number_of_Crossings++;
break;
case 2: c2=m_a;
Number_of_Crossings++;
break;
case 3: c2=m_b;
Number_of_Crossings++;
break;
case 4: c1=m_a;
c2=m_b;
Number_of_Crossings = 2;
break;
}
};
break;
default:
break;
}
return Number_of_Crossings; //This is de final number of crossings
}
//
// test if a point lies in the linesegment. If the point isn't on the wxLine
// the function returns a value that indicates on which side of the
// wxLine the point is (in linedirection from first point to second point
//
// returns R_LEFT_SIDE, when point lies on the left side of the wxLine
// R_RIGHT_SIDE, when point lies on the right side of the wxLine
// R_ON_AREA, when point lies on the infinite wxLine within a range
// R_IN_AREA, when point lies in the area of the linesegment
// the returnvalues are declared in (wxLine.H)
R_PointStatus wxLine::PointInLine(const wxPoint2DDouble& a_Point, double& Distance,double Marge)
{
Distance=0;
// Point may not be the same
assert(m_a != m_b);
int Result_ofm_BBox=FALSE;
R_PointStatus Result_of_Online;
//quick test if point is begin or endpoint
if (a_Point == m_a || a_Point == m_b)
return R_IN_AREA;
// Checking if point is in bounding-box with marge
double xmin=wxMin(m_a.m_x,m_b.m_x);
double xmax=wxMax(m_a.m_x,m_b.m_x);
double ymin=wxMin(m_a.m_y,m_b.m_y);
double ymax=wxMax(m_a.m_y,m_b.m_y);
if ( a_Point.m_x >= (xmin - Marge) && a_Point.m_x <= (xmax + Marge) &&
a_Point.m_y >= (ymin - Marge) && a_Point.m_y <= (ymax + Marge) )
Result_ofm_BBox=TRUE;
// Checking if point is on the infinite wxLine
Result_of_Online = PointOnLine(a_Point, Distance, Marge);
// point in boundingbox of the wxLine and is on the wxLine then the point is R_IN_AREA
if ((Result_ofm_BBox) && (Result_of_Online == R_ON_AREA))
return R_IN_AREA;
else
return Result_of_Online;
}
//
// test if a point lies on the wxLine. If the point isn't on the wxLine
// the function returns a value that indicates on which side of the
// wxLine the point is (in linedirection from first point to second point
//
// returns R_LEFT_SIDE, when point lies on the left side of the wxLine
// R_ON_AREA, when point lies on the infinite wxLine within a range
// R_RIGHT_SIDE, when point lies on the right side of the wxLine
// R_LEFT_SIDE , R_RIGHT_SIDE , R_ON_AREA
R_PointStatus wxLine::PointOnLine(const wxPoint2DDouble& a_Point, double& Distance, double Marge)
{
Distance=0;
// Point may not be queal
assert(m_a!=m_b);
//quick test if point is begin or endpoint
if (a_Point == m_a || a_Point == m_b)
return R_ON_AREA;
CalculateLineParameters();
// calculate the distance of a_Point in relation to the wxLine
Distance = (m_AA * a_Point.m_x)+(m_BB * a_Point.m_y) + m_CC;
if (Distance < -Marge)
return R_LEFT_SIDE;
else
{
if (Distance > Marge)
return R_RIGHT_SIDE;
else
return R_ON_AREA;
}
}
// makes a wxLine same as these
// usage : wxLine1 = wxLine2;
wxLine& wxLine::operator=(const wxLine& a_line)
{
m_AA = a_line.m_AA;
m_BB = a_line.m_BB;
m_CC = a_line.m_CC;
m_a= a_line.m_a;
m_b= a_line.m_b;
m_valid_parameters = a_line.m_valid_parameters;
return *this;
}
void wxLine::OffsetContour(const wxLine& nextline,double factor,wxPoint2DDouble& offsetpoint) const
{
wxPoint2DDouble offs_begin(m_a);
wxPoint2DDouble offs_end(m_b);
wxPoint2DDouble offs_bgn_next(nextline.m_a);
wxPoint2DDouble offs_end_next(nextline.m_b);
// make a wxPoint2DDouble from this point
Virtual_Point(offs_begin,factor);
Virtual_Point(offs_end,factor);
wxLine offs_currentline(offs_begin,offs_end);
nextline.Virtual_Point(offs_bgn_next,factor);
nextline.Virtual_Point(offs_end_next,factor);
wxLine offs_nextline(offs_bgn_next, offs_end_next);
offs_nextline.CalculateLineParameters();
offs_currentline.CalculateLineParameters();
offs_currentline.Intersect(offs_nextline,offsetpoint);
}
// Return the position of the second wxLine compared to this wxLine
// Result = IS_ON | IS_LEFT | IS_RIGHT
// Here Left and Right is defined as being left or right from
// the this wxLine towards the center (common) node
// direction of vetors taken as begin to endpoint with end of this at
// begin of wxLine two
OUTPRODUCT wxLine::OutProduct(const wxLine& two,double accur)
{
R_PointStatus uitp;
double distance;
if (two.m_a==two.m_b)
assert(0);
if (m_a==m_b)
assert(0);
uitp=PointOnLine(two.m_b, distance, accur);
/*double uitp= (_x - first._x) * (third._y - _y) -
(_y - first._y) * (third._x - _x);
if (uitp>0) return IS_LEFT;
if (uitp<0) return IS_RIGHT;
return IS_ON;*/
//depending on direction of this link (going to or coming from centre)
if (uitp==R_LEFT_SIDE)
return R_IS_LEFT;
if (uitp==R_RIGHT_SIDE)
return R_IS_RIGHT;
return R_IS_ON;
}
// Intersects two lines if a crossing return TRUE
// else FALSE
bool wxLine::Intersect(wxLine& lijn,wxPoint2DDouble& crossing)
{
// lijn must exist
assert(m_valid_parameters);
assert(lijn.m_valid_parameters);
double X, Y, Denominator;
Denominator = (m_AA * lijn.m_BB) - (lijn.m_AA * m_BB);
// Denominator may not be 0
if (Denominator == 0.0)
return FALSE;
// Calculate intersection of both linesegments
X = ((m_BB * lijn.m_CC) - (lijn.m_BB * m_CC)) / Denominator;
Y = ((lijn.m_AA * m_CC) - (m_AA * lijn.m_CC)) / Denominator;
crossing.m_x=X;
crossing.m_y=Y;
return TRUE;
}