BOOL CCalculator::Value(CCalcConstExpression** ppcConst)
{
TRISTATE tResult;
CNumber cNumber;
unsigned long long int ulli;
tResult = mcParser.GetHexadecimal(&ulli);
if (tResult == TRITRUE)
{
*ppcConst = NewMalloc<CCalcConstExpression>();
(*ppcConst)->SetValue(cNumber.Init((int)ulli));
return TRUE;
}
tResult = mcParser.GetNumber(&cNumber);
if (tResult == TRITRUE)
{
mcParser.GetExactCharacter('L', FALSE);
*ppcConst = NewMalloc<CCalcConstExpression>();
(*ppcConst)->SetValue(&cNumber);
return TRUE;
}
return FALSE;
}
CNumber CCalculator::Eval(char* szText)
{
CCalcExpression* pcExpression;
CNumber cAnswer;
BOOL bResult;
CChars sz;
mcParser.Init(szText);
bResult = Expression(&pcExpression);
mcParser.Kill();
if (bResult)
{
cAnswer = pcExpression->Evaluate();
SafeKill(pcExpression);
}
else
{
sz.Init("Cannot evaluate expression [");
sz.Append(szText);
sz.Append("]\n");
gcUserError.Set(sz.Text());
sz.Kill();
cAnswer.Zero();
}
return cAnswer;
}
// The square root function for numbers
CNumber &Sqrt(CNumber &num) {
CNumber *pnumSqrt;
if(! num.Defined()) {throw ELENotDefined; }
pnumSqrt = new CNumber(sqrt(double(num))); // Make a deep copy of the original
pnumSqrt->SetAllocated(true); // We allocated the memory space
if(num.Allocated()) {delete # } // This should call for the destructor
return *pnumSqrt;
} // Sqrt
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
BOOL CPreprocessor::Evaluate(char* szText)
{
CCalculator cCalculator;
CNumber cAnswer;
cCalculator.Init();
cAnswer = cCalculator.Eval(szText);
cCalculator.Kill();
if (cAnswer.IsZero())
return FALSE;
else
return TRUE;
}
CLogControl::CLogControl() :
mCurrentEntry(NULL)
{
static CNumber threadID;
++threadID;
CString threadName = CThread::thread().name();
CString logFileName = LESTR("thread - ") + threadID.valueAsString();
if (!threadName.isEmpty())
{
logFileName += " - " + threadName;
}
logFileName += LESTR(".log");
attachToFile(logFileName, 0);
}
//dodawanie
CNumber CNumber::cAdd(CNumber &cAddend) {
if (!b_positive && cAddend.b_positive) { // (- this) + addend
b_positive = true; //na czas operacji zmieniamy znak this
CNumber c_result (cAddend.cSubtract(*this)); // c_res = addend - this
b_positive = false;
return c_result; // addend - this
}
if (!cAddend.b_positive && b_positive) { // this + (- addend)
cAddend.b_positive = true;// na czas operacji zmieniamy znak cAddend
CNumber c_result (cSubtract(cAddend)); // this - addend
cAddend.b_positive = false;
return c_result; // this - addend
}
if (!b_positive && !cAddend.b_positive) { // (-this) + (-addend)
cAddend.b_positive = true;
b_positive = true;
CNumber c_result (cAdd(cAddend)); // this + addend
c_result.b_positive = false;
b_positive = false;
cAddend.b_positive = false;
return c_result; // -(this + addend)
}
//mamy pewnosc ze obie liczby sa dodatnie
CNumber c_result (max(i_length, cAddend.i_length) + 1); //dlugosc wyniku jest maksymalnie o 1 wieksza niz dlugosc najwiekszej z liczb
int j = 0; //zmienna przesuwajaca w lewo odczyt skladnikow sumy
bool cont = true; //zmienna sterujaca petla
/*
ponizsza petla sumuje cyfry skladnikow sumy i zwieksza odpowiednia pozycje rezultatu o ww. sume poprzez funkcje increment
funkcja increment odpowiada za zapisanie odpowiedniego wyniku na pozycje cyfry i ewentualne zwiekszenie cyfry wyzszej pozycji
*/
for (int i = c_result.i_length - 1; i >= 0 && cont ; i--) {
if (i_length - 1 - j >= 0 && cAddend.i_length - 1 - j >= 0) //jestesmy w zakresie obu liczb
c_result.v_increment(i, pi_number[i_length - 1 - j] + cAddend.pi_number[cAddend.i_length - 1 - j]); //zwieksz kazda pozycje rezultatu o sume cyfr na tej pozycji skladnikow sumy
else if (i_length - 1 - j < 0 && cAddend.i_length - 1 - j < 0)
cont = false; // wyszlismy z zakresu skladnikow sumy
else if (i_length - 1 - j < 0)
c_result.v_increment(i, cAddend.pi_number[cAddend.i_length - 1 - j]); //zwiekszamy tylko o wartosc cAddend na danej pozycji
else
c_result.v_increment(i, pi_number[i_length - 1 - j]); //zwiekszamy tylko o wartosc this na danej pozycji
j++;
}//for (int i = c_result.i_length - 1; i >= 0 && cont ; i--)
return c_result;
}//CNumber CNumber::cAdd(CNumber &cAddend)
BOOL CCalculator::Identifier(CCalcConstExpression** ppcConst)
{
TRISTATE tResult;
CNumber cNumber;
int iLength;
char* sz;
tResult = mcParser.GetIdentifier(NULL, &iLength);
if (tResult == TRITRUE)
{
sz = (char*)malloc(iLength+1);
mcParser.GetIdentifier(sz);
free(sz);
*ppcConst = NewMalloc<CCalcConstExpression>();
(*ppcConst)->SetValue(cNumber.Zero());
return TRUE;
}
else
{
return FALSE;
}
}
BOOL PrivateAssertNumber(char* szExpected, CNumber* pcActual, int iLine, char* szFile)
{
CNumber* pcExpected;
CChars szExpectedAsChars;
CChars szActual;
CChars szFake;
int iIndex;
short iDecimals;
BOOL bResult;
szFake.Fake(szExpected);
iIndex = szFake.Find(0, '.');
if (iIndex != -1)
{
iDecimals = (short)(szFake.Length() - iIndex);
}
else
{
iDecimals = 0;
}
pcExpected = gcNumberControl.Add(pcActual->mcMaxWholeNumbers, iDecimals);
pcExpected->Init(szExpected, pcActual->mcMaxWholeNumbers, iDecimals);
if (!pcExpected->Equals(pcActual))
{
pcExpected->ToString(&szExpectedAsChars);
pcActual->ToString(&szActual);
bResult = Fail(szExpectedAsChars.Text(), szActual.Text(), iLine, szFile);
szExpectedAsChars.Kill();
szActual.Kill();
}
else
{
bResult = Pass();
}
gcNumberControl.Remove();
return bResult;
}
//mnozenie
CNumber CNumber::cMultiply(CNumber &cMultiplier) {
if (b_positive != cMultiplier.b_positive) {// gdy sa roznych znakow
if (!b_positive) {// this ujemny
b_positive = true;
CNumber c_result (cMultiply(cMultiplier));
c_result.b_positive = false;
b_positive = false;
return c_result;
}//if (!b_positive)
else {// multiplier ujemny
cMultiplier.b_positive = true;
CNumber c_result(cMultiply(cMultiplier));
c_result.b_positive = false;
cMultiplier.b_positive = false;
return c_result;
}//else
}//if (b_positive != cMultiplier.b_positive)
if (i_length < cMultiplier.i_length)
return cMultiplier.cMultiply(*this);
// mnozymy 2 liczby o tych samych znakach, gdzie pierwsza jest wieksza badz rowna drugiej
CNumber c_result (max(i_length, cMultiplier.i_length) * 2); //dlugosc liczby maksymalnie 2 razy wieksza niz najwiekszej z liczb
int k = 0;
for (int i = cMultiplier.i_length - 1; i >= 0; i--) {
if (cMultiplier.pi_number[i] != 0) {
for (int j = i_length - 1; j >= 0; j--)
c_result.v_increment(c_result.i_length - 1 - k - (i_length - 1 - j), cMultiplier.pi_number[i] * pi_number[j]);
}//if (cMultiplier.pi_number[i] != 0)
k++;
}//for (int i = cMultiplier.i_length - 1; i >= 0; i--)
return c_result;
}//CNumber CNumber::cMultiply(CNumber &cMultiplier)
//od this odejmij argument funkcji cSubtract
CNumber CNumber::cSubtract(CNumber &cSubtrahend) {
if (b_positive && !cSubtrahend.b_positive) { // this - (-sub)
cSubtrahend.b_positive = true;
CNumber c_result (cAdd(cSubtrahend)); // this + sub
cSubtrahend.b_positive = false;
return c_result; // this + sub
}
if (!b_positive && !cSubtrahend.b_positive) { //(-this) - (-sub)
b_positive = true;
cSubtrahend.b_positive = true;
CNumber c_result (cSubtrahend.cSubtract(*this)); // sub - this
b_positive = false;
cSubtrahend.b_positive = false;
return c_result; // sub - this
}
if (!b_positive && cSubtrahend.b_positive) { // (-this) - sub
b_positive = true;
CNumber c_result(cAdd(cSubtrahend)); // this + sub
b_positive = false;
c_result.b_positive = false;
return c_result; // = -(this + sub)
}
//mamy pewnosc ze obie liczby sa dodatnie
if (cSubtrahend.i_length > i_length) {
CNumber c_result (cSubtrahend.cSubtract(*this));
c_result.b_positive = false;
return c_result;
}
//odjemnik nie jest wiekszy od odjemnej co pozwala na na:
CNumber c_result (*this); // na pewno dluzszy nie bedzie wiekszy niz odjemna
int j = 0;
bool b_can_sub = true;
bool b_cont = true;
for (int i = c_result.i_length - 1; i >= 0 && b_cont && b_can_sub; i--) {
if (j <= cSubtrahend.i_length - 1) {
if (c_result.pi_number[i] < cSubtrahend.pi_number[cSubtrahend.i_length - 1 - j])
if (!c_result.b_borrow(i)) // gdy to wyrazenie zwroci false, wyjdz z petli
b_can_sub = false;
// tu na pewno mozna odjac
if (b_can_sub) //jesli wiemy juz ze nie konczymy petli
c_result.pi_number[i] -= cSubtrahend.pi_number[cSubtrahend.i_length - 1 - j];
j++;
}//if (j <= c_result.i_length - 1)
else
b_cont = false;
}//for (int i = c_result.i_length - 1; i >= 0 && cont; i--)
if (!b_can_sub) { // wyszlismy z petli, wiec c_result < cSubtrahent, this* - sub (nie mozna odjac)
CNumber c_res(cSubtrahend.cSubtract(c_result));
c_res.b_positive = false;
return c_res; // -(sub - this*)
}//if (!cont)
return c_result;
}//CNumber CNumber::cSubtract(CNumber &cSubtrahend)
CClass* CDecodeFlowType::readClassType ( const QDomElement& element)
{
bool bOk = false;
CClass* cl = NULL;
QDomElement id = element.firstChildElement("id");
QDomElement name = element.firstChildElement("name");
QDomElement definition = element.firstChildElement("definition");
QDomElement readOnly = element.firstChildElement("read-only");
QDomElement values = element.firstChildElement("values");
QDomElement type = element.firstChildElement("type");
switch (type.text().toInt())
{
case CClass::VOID:
{
CVoid* v = new CVoid(name.text(), definition.text());
v->setId(id.text().toInt(&bOk));
v->setReadOnly((readOnly.text().toInt(&bOk)));
cl = v;
bOk = true;
}
break;
case CClass::ENUMERATION:
{
CEnumeration* e = new CEnumeration(name.text(), definition.text());
e->setId(id.text().toInt(&bOk));
e->setReadOnly((readOnly.text().toInt(&bOk)));
QDomElement data = values.firstChildElement("string");
while (!data.isNull())
{
e->append(data.text());
data = data.nextSiblingElement("string");
}
bOk = true;
cl = e;
}
break;
case CClass::NUMBER:
{
CNumber* n = new CNumber(name.text(), definition.text());
n->setId(id.text().toInt(&bOk));
n->setReadOnly((readOnly.text().toInt(&bOk)));
QDomElement range = values.firstChildElement("range");
if (!range.isNull())
{
Range r;
r.begin = range.attribute("begin").toLongLong(&bOk);
if (!bOk)
{
// try with uLongLong
r.begin = range.attribute("begin").toULongLong(&bOk);
}
r.end = range.attribute("end").toLongLong(&bOk);
if (!bOk)
{
// try with uLongLong
r.end = range.attribute("end").toULongLong(&bOk);
}
r.beginName = range.attribute("begin-name");
r.endName = range.attribute("end-name");
n->insertRange(r);
bOk = true;
}
else
bOk = false;
cl = n;
}
break;
case CClass::FLOAT:
{
CFloat* f = new CFloat(name.text(), definition.text());
f->setId(id.text().toInt(&bOk));
f->setReadOnly((readOnly.text().toInt(&bOk)));
QDomElement range = values.firstChildElement("range");
if (!range.isNull())
{
Range r;
r.begin = range.attribute("begin").toDouble(&bOk);
r.end = range.attribute("end").toDouble(&bOk);
r.beginName = range.attribute("begin-name");
r.endName = range.attribute("end-name");
f->insertRange(r);
bOk = true;
}
else
bOk = false;
cl = f;
}
break;
case CClass::CHAR:
{
CChar* c = new CChar(name.text(), definition.text());
c->setId(id.text().toInt(&bOk));
c->setReadOnly((readOnly.text().toInt(&bOk)));
QDomElement range = values.firstChildElement("range");
if (!range.isNull())
{
Range r;
r.begin = range.attribute("begin").toInt(&bOk);
r.end = range.attribute("end").toInt(&bOk);
r.beginName = range.attribute("begin-name");
r.endName = range.attribute("end-name");
c->insertRange(r);
bOk = true;
}
else
bOk = false;
cl = c;
}
break;
case CClass::STRING:
{
CString* s = new CString(name.text(), definition.text());
s->setId(id.text().toInt(&bOk));
s->setReadOnly((readOnly.text().toInt(&bOk)));
QDomElement size = values.firstChildElement("size");
if (!size.isNull())
{
s->setSize(size.text().toInt(&bOk));
bOk = true;
}
else
bOk = false;
cl = s;
}
break;
case CClass::AGGREGATION:
{
CStructure* s = new CStructure(name.text(), definition.text());
s->setId(id.text().toInt(&bOk));
s->setReadOnly((readOnly.text().toInt(&bOk)));
QDomElement structure = values.firstChildElement("structure");
while (!structure.isNull() && !bOk)
{
Structure st;
st.name = structure.attribute("name");
st.classId = structure.attribute("type").toInt(&bOk);
st.pClass = NULL;
if (bOk == true)
{
s->insertField(st);
}
structure = structure.nextSiblingElement("structure");
}
cl = s;
}
break;
default:
bOk = false;
break;
}
if ((bOk == false) & (cl != NULL))
{
delete cl;
cl = NULL;
}
return cl;
}
void CTypeFactory::createBuildinType()
{
CNumber* nb;
CChar* ch;
Range r;
CVoid* v;
v = new CVoid(tr("void"), tr("no type"));
v->setReadOnly(true);
insertType(v);
nb = new CNumber(tr("signed char"), tr("signed integer of 8bits"));
r.begin = -128;
r.beginName = QString("-128");
r.end = 127;
r.endName = QString("127");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CNumber(tr("unsigned char"), tr("unsigned integer of 8bits"));
r.begin = 0;
r.beginName = QString("0");
r.end = 255;
r.endName = QString("255");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CNumber(tr("signed short"), tr("signed integer of 16bits"));
r.begin = -32768;
r.beginName = QString("-32768");
r.end = 32767;
r.endName = QString("32767");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CNumber(tr("unsigned short"), tr("unsigned integer of 16bits"));
r.begin = 0;
r.beginName = QString("0");
r.end = 65535;
r.endName = QString("65535");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CNumber(tr("signed long"), tr("signed integer of 32bits"));
r.begin = (int) -2147483648;
r.beginName = QString("-2147483648");
r.end = (int) 2147483647;
r.endName = QString("2147483647");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CNumber(tr("unsigned long"), tr("unsigned integer of 32bits"));
r.begin = 0;
r.beginName = QString("0");
r.end = (unsigned int) 4294967296;
r.endName = QString("4294967296");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CNumber(tr("signed long long"), tr("signed integer of 64bits"));
r.begin = (long long) 0x8000000000000000;
r.beginName = QString("2^63");
r.end = (long long) 0x7FFFFFFFFFFFFFFF;
r.endName = QString("2^63-1");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CNumber(tr("unsigned long long"), tr("unsigned integer of 64bits"));
r.begin = 0;
r.beginName = QString("0");
r.end = (unsigned long long) std::numeric_limits<unsigned long long>::max(); //0xFFFFFFFFFFFFFFFF;
r.endName = QString("2^64");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
ch = new CChar(tr("ascii character"), tr("ascii character"));
r.begin = 0;
r.beginName = QString("NUL (0)");
r.end = 127;
r.endName = QString("DEL (127)");
ch->insertRange(r);
ch->setReadOnly(true);
insertType(ch);
ch = new CChar(tr("ext. ascii character"), tr("extended ascii character"));
r.begin = 0;
r.beginName = QString("NUL (0)");
r.end = 0xFF;
r.endName = QString(" (255)");
ch->insertRange(r);
ch->setReadOnly(true);
insertType(ch);
CString* s = new CString(tr("string"), tr("string"));
s->setSize(-1);
s->setReadOnly(true);
insertType(s);
CEnumeration* b = new CEnumeration(tr("bool"), tr("boolean"));
b->append(tr("FALSE"));
b->append(tr("TRUE"));
b->setReadOnly(true);
insertType(b);
nb = new CFloat(tr("float"), tr("float single precision"));
r.begin = std::numeric_limits<qreal>::min();
r.beginName = QString("-INF");
r.end = std::numeric_limits<qreal>::max();;
r.endName = QString("+INF");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
nb = new CFloat(tr("double"), tr("float double precision"));
r.begin = std::numeric_limits<qreal>::min();
r.beginName = QString("-INF");
r.end = std::numeric_limits<qreal>::max();;
r.endName = QString("+INF");
nb->insertRange(r);
nb->setReadOnly(true);
insertType(nb);
}
void CNumber::add(CNumber toAdd){
re_ += toAdd.getRe();
im_ += toAdd.getIm();
}
CIntersection :: CIntersection (CVertexList &vl, CVertex &v)
{
#if VTDEBUG
if (!(v.m_prevVertex == NULL || v.m_leftLine.FacingTowards (v.m_prevVertex -> m_rightLine)))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
if (!(v.m_nextVertex == NULL || v.m_rightLine.FacingTowards (v.m_nextVertex -> m_leftLine)))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
#endif
CVertex &l = *v.m_prevVertex;
CVertex &r = *v.m_nextVertex;
#if VTDEBUG
if (!(v.m_leftLine.m_Angle == v.m_leftVertex -> m_leftLine.m_Angle))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
if (!(v.m_rightLine.m_Angle == v.m_rightVertex -> m_rightLine.m_Angle))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
#endif
CNumber al = v.m_axis.m_Angle - l.m_axis.m_Angle;
al.NormalizeAngle();
CNumber ar = v.m_axis.m_Angle - r.m_axis.m_Angle;
ar.NormalizeAngle();
#ifdef FELKELDEBUG
VTLOG("New Intersection i1\n");
#endif
C3DPoint i1 = v.m_axis.FacingTowards(l.m_axis) ? C3DPoint(CN_INFINITY, CN_INFINITY, CN_INFINITY) : v.m_axis.Intersection(l.m_axis);
i1.m_y = v.m_leftLine.Dist(i1) * fabs(tan(v.m_leftLine.m_Slope));
#ifdef FELKELDEBUG
VTLOG("New Intersection i1\nm_Origin(x %e y %e z %e) m_Angle %e m_Slope %e\na.m_Origin(x %e y %e z %e) a.m_Angle %e a.m_Slope %e\n",
v.m_axis.m_Origin.m_x, v.m_axis.m_Origin.m_y, v.m_axis.m_Origin.m_z, v.m_axis.m_Angle, v.m_axis.m_Slope,
l.m_axis.m_Origin.m_x, l.m_axis.m_Origin.m_y, l.m_axis.m_Origin.m_z, l.m_axis.m_Angle, l.m_axis.m_Slope);
#endif
#ifdef FELKELDEBUG
VTLOG("New Intersection i2\n");
#endif
C3DPoint i2 = v.m_axis.FacingTowards (r.m_axis) ? C3DPoint(CN_INFINITY, CN_INFINITY, CN_INFINITY) : v.m_axis.Intersection(r.m_axis);
i2.m_y = v.m_rightLine.Dist(i2) * fabs(tan(v.m_rightLine.m_Slope));
#ifdef FELKELDEBUG
VTLOG("m_Origin(x %e y %e z %e) m_Angle %e m_Slope %e\na.m_Origin(x %e y %e z %e) a.m_Angle %e a.m_Slope %e\n",
v.m_axis.m_Origin.m_x, v.m_axis.m_Origin.m_y, v.m_axis.m_Origin.m_z, v.m_axis.m_Angle, v.m_axis.m_Slope,
r.m_axis.m_Origin.m_x, r.m_axis.m_Origin.m_y, r.m_axis.m_Origin.m_z, r.m_axis.m_Angle, r.m_axis.m_Slope);
#endif
#if VTDEBUG
CNumber Oldi1y = i1.m_y;
CNumber Oldi2y = i2.m_y;
#endif
// I need to check why this code is here !!!!!!!!!
// I must of put it here bu I cannot remember why
// Getting a slope of exactly PI/2 must be rare
// but could arise from many different edge slopes and vertex angles
if (SIMILAR(v.m_axis.m_Slope, CN_PI/2))
{
i1.m_y = C3DPoint(i1 - l.m_point).LengthXZ() * fabs(tan(l.m_axis.m_Slope)) + l.m_point.m_y;
i2.m_y = C3DPoint(i2 - r.m_point).LengthXZ() * fabs(tan(r.m_axis.m_Slope)) + r.m_point.m_y;
}
else
{
i1.m_y = C3DPoint(i1 - v.m_point).LengthXZ() * fabs(tan(v.m_axis.m_Slope)) + v.m_point.m_y;
i2.m_y = C3DPoint(i2 - v.m_point).LengthXZ() * fabs(tan(v.m_axis.m_Slope)) + v.m_point.m_y;
}
// assert ((Oldi1y == i1.m_y) && (Oldi2y == i2.m_y));
CNumber d1 = v.m_point.DistXZ(i1);
CNumber d2 = v.m_point.DistXZ(i2);
// CNumber d1 = i1.m_y;
// CNumber d2 = i2.m_y;
CVertex *leftPointer, *rightPointer;
C3DPoint p;
CNumber d3 = CN_INFINITY;
CNumber av = v.m_leftLine.m_Angle - v.m_rightLine.m_Angle;
av.NormalizeAngle();
if ((av >= 0.0 || av == - CN_PI) && (v.m_leftLine.Intersection(v.m_rightLine) == v.m_point || v.m_leftLine.Intersection(v.m_rightLine) == C3DPoint(CN_INFINITY, CN_INFINITY, CN_INFINITY)))
d3 = v.NearestIntersection(vl, &leftPointer, &rightPointer, p);
// d3 = p.m_y;
#ifdef FELKELDEBUG
VTLOG("New Intersection i1\nm_Origin(x %e y %e z %e) m_Angle %e m_Slope %e\na.m_Origin(x %e y %e z %e) a.m_Angle %e a.m_Slope %e\n",
v.m_axis.m_Origin.m_x, v.m_axis.m_Origin.m_y, v.m_axis.m_Origin.m_z, v.m_axis.m_Angle, v.m_axis.m_Slope,
l.m_axis.m_Origin.m_x, l.m_axis.m_Origin.m_y, l.m_axis.m_Origin.m_z, l.m_axis.m_Angle, l.m_axis.m_Slope);
VTLOG("New Intersection i2\nm_Origin(x %e y %e z %e) m_Angle %e m_Slope %e\na.m_Origin(x %e y %e z %e) a.m_Angle %e a.m_Slope %e\n",
v.m_axis.m_Origin.m_x, v.m_axis.m_Origin.m_y, v.m_axis.m_Origin.m_z, v.m_axis.m_Angle, v.m_axis.m_Slope,
r.m_axis.m_Origin.m_x, r.m_axis.m_Origin.m_y, r.m_axis.m_Origin.m_z, r.m_axis.m_Angle, r.m_axis.m_Slope);
VTLOG("New Intersection\n al %e ar %e\ni1.x %e i1.y %e i1.z %e\ni2.x %e i2.y %e i2.z %e\np.m_x %e p.m_y %e p.m_z %e\nd1 %e d2 %e d3 %e\n",
al, ar, i1.m_x, i1.m_y, i1.m_z, i2.m_x, i2.m_y, i2.m_z, p.m_x, p.m_y, p.m_z, d1, d2, d3);
#endif
if (d3 <= d1 && d3 <= d2)
{
m_poi = p;
m_leftVertex = m_rightVertex = &v;
m_type = NONCONVEX;
if (v.InvalidIntersection (vl, *this))
{
d3 = CN_INFINITY;
m_poi = C3DPoint (CN_INFINITY, CN_INFINITY, CN_INFINITY);
}
}
if (d1 <= d2 && d1 <= d3)
{
m_leftVertex = &l;
m_rightVertex = &v;
m_poi = i1;
m_type = CONVEX;
}
else if (d2 <= d1 && d2 <= d3)
{
m_leftVertex = &v;
m_rightVertex = &r;
m_poi = i2;
m_type = CONVEX;
}
if (m_poi == C3DPoint (CN_INFINITY, CN_INFINITY, CN_INFINITY))
m_height = CN_INFINITY;
else
m_height = m_poi.m_y;
#ifdef FELKELDEBUG
VTLOG("New %s Intersection %d %d x %e y %e z %e height %e\n",
m_type == CONVEX ? "CONVEX" : "NONCONVEX",
m_leftVertex->m_ID, m_rightVertex->m_ID, m_poi.m_x, m_poi.m_y, m_poi.m_z, m_height);
#endif
}
