Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F82915778
QhullPoints_test.cpp
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Sat, Sep 14, 04:55
Size
15 KB
Mime Type
text/x-c
Expires
Mon, Sep 16, 04:55 (2 d)
Engine
blob
Format
Raw Data
Handle
20774269
Attached To
rCADDMESH CADD_mesher
QhullPoints_test.cpp
View Options
/****************************************************************************
**
** Copyright (p) 2009-2015 C.B. Barber. All rights reserved.
** $Id: //main/2011/qhull/src/qhulltest/QhullPoints_test.cpp#15 $$Change: 1868 $
** $DateTime: 2015/03/26 20:13:15 $$Author: bbarber $
**
****************************************************************************/
//pre-compiled header
#include <iostream>
#include "qhulltest/RoadTest.h" // QT_VERSION
#include "libqhullcpp/QhullPoints.h"
#include "libqhullcpp/RboxPoints.h"
#include "libqhullcpp/Qhull.h"
using std::cout;
using std::endl;
using std::ostringstream;
namespace orgQhull {
class QhullPoints_test : public RoadTest
{
Q_OBJECT
#//!\name Test slots
private slots:
void cleanup();
void t_construct_q();
void t_construct_qh();
void t_convert();
void t_getset();
void t_element();
void t_iterator();
void t_const_iterator();
void t_search();
void t_points_iterator();
void t_io();
};//QhullPoints_test
void
add_QhullPoints_test()
{
new QhullPoints_test();
}
//Executed after each testcase
void QhullPoints_test::
cleanup()
{
RoadTest::cleanup();
}
void QhullPoints_test::
t_construct_q()
{
Qhull q;
QhullPoints ps(q);
QCOMPARE(ps.dimension(), 0);
QVERIFY(ps.isEmpty());
QCOMPARE(ps.count(), 0);
QCOMPARE(ps.size(), 0u);
QCOMPARE(ps.coordinateCount(), 0);
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps2(q);
ps2.defineAs(2, 6, c);
QCOMPARE(ps2.dimension(), 2);
QVERIFY(!ps2.isEmpty());
QCOMPARE(ps2.count(), 3);
QCOMPARE(ps2.size(), 3u);
QCOMPARE(ps2.coordinates(), c);
QhullPoints ps3(q, 2, 6, c);
QCOMPARE(ps3.dimension(), 2);
QVERIFY(!ps3.isEmpty());
QCOMPARE(ps3.coordinates(), ps2.coordinates());
QVERIFY(ps3==ps2);
QVERIFY(ps3!=ps);
QhullPoints ps4= ps3;
QVERIFY(ps4==ps3);
// ps4= ps3; //compiler error
QhullPoints ps5(ps4);
QVERIFY(ps5==ps4);
QVERIFY(!(ps5!=ps4));
coordT c2[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps6(q, 2, 6, c2);
QVERIFY(ps6==ps2);
q.checkAndFreeQhullMemory();
RboxPoints rbox("c D2");
Qhull q2(rbox, "");
QhullPoints ps8(q2);
QCOMPARE(ps8.dimension(), 2);
QCOMPARE(ps8.count(), 0);
QCOMPARE(ps8.size(), 0u);
QCOMPARE(ps8.coordinateCount(), 0);
coordT c3[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps9(q2, 6, c3);
QCOMPARE(ps9.dimension(), 2);
QCOMPARE(ps9.coordinateCount(), 6);
QCOMPARE(ps9.count(), 3);
QCOMPARE(ps9.coordinates(), c3);
QCOMPARE(ps9, ps2); // DISTround
c3[1]= 1.0+1e-17;
QCOMPARE(ps9, ps2); // DISTround
c3[1]= 1.0+1e-15;
QVERIFY(ps9!=ps2); // DISTround
ps9.defineAs(6, c2);
QCOMPARE(ps9.dimension(), 2);
QCOMPARE(ps9.coordinateCount(), 6);
QCOMPARE(ps9.count(), 3);
QCOMPARE(ps9.coordinates(), c2);
q2.checkAndFreeQhullMemory();
}//t_construct_q
void QhullPoints_test::
t_construct_qh()
{
Qhull q;
QhullQh *qh= q.qh();
QhullPoints ps(qh);
QCOMPARE(ps.dimension(), 0);
QVERIFY(ps.isEmpty());
QCOMPARE(ps.count(), 0);
QCOMPARE(ps.size(), 0u);
QCOMPARE(ps.coordinateCount(), 0);
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps2(qh);
ps2.defineAs(2, 6, c);
QCOMPARE(ps2.dimension(), 2);
QVERIFY(!ps2.isEmpty());
QCOMPARE(ps2.count(), 3);
QCOMPARE(ps2.size(), 3u);
QCOMPARE(ps2.coordinates(), c);
QhullPoints ps3(qh, 2, 6, c);
QCOMPARE(ps3.dimension(), 2);
QVERIFY(!ps3.isEmpty());
QCOMPARE(ps3.coordinates(), ps2.coordinates());
QVERIFY(ps3==ps2);
QVERIFY(ps3!=ps);
QhullPoints ps4= ps3;
QVERIFY(ps4==ps3);
// ps4= ps3; //compiler error
QhullPoints ps5(ps4);
QVERIFY(ps5==ps4);
QVERIFY(!(ps5!=ps4));
coordT c2[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps6(qh, 2, 6, c2);
QVERIFY(ps6==ps2);
RboxPoints rbox("c D2");
Qhull q2(rbox, "");
QhullPoints ps8(q2.qh());
QCOMPARE(ps8.dimension(), 2);
QCOMPARE(ps8.count(), 0);
QCOMPARE(ps8.size(), 0u);
QCOMPARE(ps8.coordinateCount(), 0);
coordT c3[]= {10.0, 11.0, 12.0, 13.0, 14.0, 15.0};
QhullPoints ps9(q2.qh(), 6, c3);
QCOMPARE(ps9.dimension(), 2);
QCOMPARE(ps9.coordinateCount(), 6);
QCOMPARE(ps9.count(), 3);
QCOMPARE(ps9.coordinates(), c3);
ps9.defineAs(6, c2);
QCOMPARE(ps9.dimension(), 2);
QCOMPARE(ps9.coordinateCount(), 6);
QCOMPARE(ps9.count(), 3);
QCOMPARE(ps9.coordinates(), c2);
q2.checkAndFreeQhullMemory();
}//t_construct_qh
void QhullPoints_test::
t_convert()
{
Qhull q;
//defineAs tested above
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps(q, 3, 6, c);
QCOMPARE(ps.dimension(), 3);
QCOMPARE(ps.size(), 2u);
const coordT *c2= ps.constData();
QCOMPARE(c, c2);
const coordT *c3= ps.data();
QCOMPARE(c, c3);
coordT *c4= ps.data();
QCOMPARE(c, c4);
std::vector<QhullPoint> vs= ps.toStdVector();
QCOMPARE(vs.size(), 2u);
QhullPoint p= vs[1];
QCOMPARE(p[2], 5.0);
QList<QhullPoint> qs= ps.toQList();
QCOMPARE(qs.size(), 2);
QhullPoint p2= qs[1];
QCOMPARE(p2[2], 5.0);
q.checkAndFreeQhullMemory();
}//t_convert
void QhullPoints_test::
t_getset()
{
Qhull q;
//See t_construct for coordinates, count, defineAs, dimension, isempty, ==, !=, size
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps(q, 3, 6, c);
QhullPoints ps2(q, 3, 6, c);
QCOMPARE(ps2.dimension(), 3);
QCOMPARE(ps2.coordinates(), c);
QCOMPARE(ps2.count(), 2);
QCOMPARE(ps2.coordinateCount(), 6);
coordT c2[]= {-1.0, -2.0, -3.0, -4.0, -5.0, -6.0};
ps2.defineAs(6, c2);
QCOMPARE(ps2.coordinates(), c2);
QCOMPARE(ps2.count(), 2);
QCOMPARE(ps2.size(), 2u);
QCOMPARE(ps2.dimension(), 3);
QVERIFY(!ps2.isEmpty());
QVERIFY(ps!=ps2);
// ps2= ps; // assignment not available, compiler error
ps2.defineAs(ps);
QVERIFY(ps==ps2);
ps2.setDimension(2);
QCOMPARE(ps2.dimension(), 2);
QCOMPARE(ps2.coordinates(), c);
QVERIFY(!ps2.isEmpty());
QCOMPARE(ps2.count(), 3);
QCOMPARE(ps2.size(), 3u);
QVERIFY(ps!=ps2);
QhullPoints ps3(ps2);
ps3.setDimension(3);
ps3.defineAs(5, c2);
QCOMPARE(ps3.count(), 1);
QCOMPARE(ps3.extraCoordinatesCount(), 2);
QCOMPARE(ps3.extraCoordinates()[0], -4.0);
QVERIFY(ps3.includesCoordinates(ps3.data()));
QVERIFY(ps3.includesCoordinates(ps3.data()+ps3.count()-1));
QVERIFY(!ps3.includesCoordinates(ps3.data()-1));
QVERIFY(!ps3.includesCoordinates(ps3.data()+ps3.coordinateCount()));
q.checkAndFreeQhullMemory();
}//t_getset
void QhullPoints_test::
t_element()
{
Qhull q;
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps(q, 2, 6, c);
QCOMPARE(ps.count(), 3);
QhullPoint p(q, 2, c);
QCOMPARE(ps[0], p);
QCOMPARE(ps.at(1), ps[1]);
QCOMPARE(ps.first(), p);
QCOMPARE(ps.front(), ps.first());
QCOMPARE(ps.last(), ps.at(2));
QCOMPARE(ps.back(), ps.last());
QhullPoints ps2= ps.mid(2);
QCOMPARE(ps2.count(), 1);
QhullPoints ps3= ps.mid(3);
QVERIFY(ps3.isEmpty());
QhullPoints ps4= ps.mid(10);
QVERIFY(ps4.isEmpty());
QhullPoints ps5= ps.mid(-1);
QVERIFY(ps5.isEmpty());
QhullPoints ps6= ps.mid(1, 1);
QCOMPARE(ps6.count(), 1);
QCOMPARE(ps6[0], ps[1]);
QhullPoints ps7= ps.mid(1, 10);
QCOMPARE(ps7.count(), 2);
QCOMPARE(ps7[1], ps[2]);
QhullPoint p8(q);
QCOMPARE(ps.value(2), ps[2]);
QCOMPARE(ps.value(-1), p8);
QCOMPARE(ps.value(3), p8);
QCOMPARE(ps.value(3, p), p);
QVERIFY(ps.value(1, p)!=p);
foreach(QhullPoint p9, ps){ // Qt only
QCOMPARE(p9.dimension(), 2);
QVERIFY(p9[0]==0.0 || p9[0]==2.0 || p9[0]==4.0);
}
q.checkAndFreeQhullMemory();
}//t_element
void QhullPoints_test::
t_iterator()
{
Qhull q;
coordT c[]= {0.0, 1.0, 2.0};
QhullPoints ps(q, 1, 3, c);
QCOMPARE(ps.dimension(), 1);
QhullPoints::Iterator i(ps);
QhullPoints::iterator i2= ps.begin();
QVERIFY(i==i2);
QVERIFY(i>=i2);
QVERIFY(i<=i2);
i= ps.begin();
QVERIFY(i==i2);
i2= ps.end();
QVERIFY(i!=i2);
QhullPoint p(i); // QhullPoint is the base class for QhullPoints::iterator
QCOMPARE(p.dimension(), ps.dimension());
QCOMPARE(p.coordinates(), ps.coordinates());
i2--;
QhullPoint p2= *i2;
QCOMPARE(p[0], 0.0);
QCOMPARE(p2[0], 2.0);
QhullPoints::Iterator i5(i2);
QCOMPARE(*i2, *i5);
coordT c3[]= {0.0, -1.0, -2.0};
QhullPoints::Iterator i3(q, 1, c3);
QVERIFY(i!=i3);
QCOMPARE(*i, *i3);
(i3= i)++;
QCOMPARE((*i3)[0], 1.0);
QCOMPARE(i3->dimension(), 1);
QCOMPARE(i3[0][0], 1.0);
QCOMPARE(i3[0], ps[1]);
QVERIFY(i==i);
QVERIFY(i!=i2);
QVERIFY(i<i2);
QVERIFY(i<=i2);
QVERIFY(i2>i);
QVERIFY(i2>=i);
QhullPoints::ConstIterator i4(q, 1, c);
QVERIFY(i==i4); // iterator COMP const_iterator
QVERIFY(i<=i4);
QVERIFY(i>=i4);
QVERIFY(i4==i); // const_iterator COMP iterator
QVERIFY(i4<=i);
QVERIFY(i4>=i);
QVERIFY(i>=i4);
QVERIFY(i4<=i);
QVERIFY(i2!=i4);
QVERIFY(i2>i4);
QVERIFY(i2>=i4);
QVERIFY(i4!=i2);
QVERIFY(i4<i2);
QVERIFY(i4<=i2);
++i4;
QVERIFY(i<i4);
QVERIFY(i<=i4);
QVERIFY(i4>i);
QVERIFY(i4>=i);
i= ps.begin();
i2= ps.begin();
QCOMPARE(i, i2++);
QCOMPARE(*i2, ps[1]);
QCOMPARE(++i, i2);
QCOMPARE(i, i2--);
QCOMPARE(i2, ps.begin());
QCOMPARE(--i, i2);
QCOMPARE(i2+=3, ps.end());
QCOMPARE(i2-=3, ps.begin());
QCOMPARE(i2+0, ps.begin());
QCOMPARE(i2+3, ps.end());
i2 += 3;
i= i2-0;
QCOMPARE(i, i2);
i= i2-3;
QCOMPARE(i, ps.begin());
QCOMPARE(i2-i, 3);
//ps.begin end tested above
// QhullPoints is const-only
q.checkAndFreeQhullMemory();
}//t_iterator
void QhullPoints_test::
t_const_iterator()
{
Qhull q;
coordT c[]= {0.0, 1.0, 2.0};
const QhullPoints ps(q, 1, 3, c);
QhullPoints::ConstIterator i(ps);
QhullPoints::const_iterator i2= ps.begin();
QVERIFY(i==i2);
QVERIFY(i>=i2);
QVERIFY(i<=i2);
i= ps.begin();
QVERIFY(i==i2);
i2= ps.end();
QVERIFY(i!=i2);
QhullPoint p(i);
QCOMPARE(p.dimension(), ps.dimension());
QCOMPARE(p.coordinates(), ps.coordinates());
i2--;
QhullPoint p2= *i2;
QCOMPARE(p[0], 0.0);
QCOMPARE(p2[0], 2.0);
QhullPoints::ConstIterator i5(i2);
QCOMPARE(*i2, *i5);
coordT c3[]= {0.0, -1.0, -2.0};
QhullPoints::ConstIterator i3(q, 1, c3);
QVERIFY(i!=i3);
QCOMPARE(*i, *i3);
(i3= i)++;
QCOMPARE((*i3)[0], 1.0);
QCOMPARE(i3->dimension(), 1);
QCOMPARE(i3[0][0], 1.0);
QCOMPARE(i3[0][0], 1.0);
QCOMPARE(i3[0], ps[1]);
QVERIFY(i==i);
QVERIFY(i!=i2);
QVERIFY(i<i2);
QVERIFY(i<=i2);
QVERIFY(i2>i);
QVERIFY(i2>=i);
// See t_iterator for const_iterator COMP iterator
i= ps.begin();
i2= ps.constBegin();
QCOMPARE(i, i2++);
QCOMPARE(*i2, ps[1]);
QCOMPARE(++i, i2);
QCOMPARE(i, i2--);
QCOMPARE(i2, ps.constBegin());
QCOMPARE(--i, i2);
QCOMPARE(i2+=3, ps.constEnd());
QCOMPARE(i2-=3, ps.constBegin());
QCOMPARE(i2+0, ps.constBegin());
QCOMPARE(i2+3, ps.constEnd());
i2 += 3;
i= i2-0;
QCOMPARE(i, i2);
i= i2-3;
QCOMPARE(i, ps.constBegin());
QCOMPARE(i2-i, 3);
// QhullPoints is const-only
q.checkAndFreeQhullMemory();
}//t_const_iterator
void QhullPoints_test::
t_search()
{
Qhull q;
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 0, 1};
QhullPoints ps(q, 2, 8, c); //2-d array of 4 points
QhullPoint p= ps.first();
QhullPoint p2= ps.last();
QVERIFY(ps.contains(p));
QVERIFY(ps.contains(p2));
QVERIFY(p==p2);
QhullPoint p5= ps[2];
QVERIFY(p!=p5);
QVERIFY(ps.contains(p5));
coordT c2[]= {0.0, 1.0, 2.0, 3.0};
QhullPoint p3(q, 2, c2); //2-d point
QVERIFY(ps.contains(p3));
QhullPoint p4(q, 3, c2); //3-d point
QVERIFY(!ps.contains(p4));
p4.defineAs(2, c); //2-d point
QVERIFY(ps.contains(p4));
p4.defineAs(2, c+1); //2-d point
QVERIFY(!ps.contains(p4));
QhullPoint p6(q, 2, c2+2); //2-d point
QCOMPARE(ps.count(p), 2);
QCOMPARE(ps.count(p2), 2);
QCOMPARE(ps.count(p3), 2);
QCOMPARE(ps.count(p4), 0);
QCOMPARE(ps.count(p6), 1);
QCOMPARE(ps.indexOf(&ps[0][0]), 0);
//QCOMPARE(ps.indexOf(ps.end()), -1); //ps.end() is a QhullPoint which may match
QCOMPARE(ps.indexOf(0), -1);
QCOMPARE(ps.indexOf(&ps[3][0]), 3);
QCOMPARE(ps.indexOf(&ps[3][1], QhullError::NOthrow), 3);
QCOMPARE(ps.indexOf(ps.data()+ps.coordinateCount(), QhullError::NOthrow), -1);
QCOMPARE(ps.indexOf(p), 0);
QCOMPARE(ps.indexOf(p2), 0);
QCOMPARE(ps.indexOf(p3), 0);
QCOMPARE(ps.indexOf(p4), -1);
QCOMPARE(ps.indexOf(p5), 2);
QCOMPARE(ps.indexOf(p6), 1);
QCOMPARE(ps.lastIndexOf(p), 3);
QCOMPARE(ps.lastIndexOf(p4), -1);
QCOMPARE(ps.lastIndexOf(p6), 1);
QhullPoints ps3(q);
QCOMPARE(ps3.indexOf(ps3.data()), -1);
QCOMPARE(ps3.indexOf(ps3.data()+1, QhullError::NOthrow), -1);
QCOMPARE(ps3.indexOf(p), -1);
QCOMPARE(ps3.lastIndexOf(p), -1);
QhullPoints ps4(q, 2, 0, c);
QCOMPARE(ps4.indexOf(p), -1);
QCOMPARE(ps4.lastIndexOf(p), -1);
q.checkAndFreeQhullMemory();
}//t_search
void QhullPoints_test::
t_points_iterator()
{
Qhull q;
coordT c2[]= {0.0};
QhullPoints ps2(q, 0, 0, c2); // 0-dimensional
QhullPointsIterator i2= ps2;
QVERIFY(!i2.hasNext());
QVERIFY(!i2.hasPrevious());
i2.toBack();
QVERIFY(!i2.hasNext());
QVERIFY(!i2.hasPrevious());
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps(q, 3, 6, c); // 3-dimensional
QhullPointsIterator i(ps);
i2= ps;
QVERIFY(i2.hasNext());
QVERIFY(!i2.hasPrevious());
QVERIFY(i.hasNext());
QVERIFY(!i.hasPrevious());
i2.toBack();
i.toFront();
QVERIFY(!i2.hasNext());
QVERIFY(i2.hasPrevious());
QVERIFY(i.hasNext());
QVERIFY(!i.hasPrevious());
QhullPoint p= ps[0];
QhullPoint p2(ps[0]);
QCOMPARE(p, p2);
QVERIFY(p==p2);
QhullPoint p3(ps[1]);
// p2[0]= 0.0;
QVERIFY(p==p2);
QCOMPARE(i2.peekPrevious(), p3);
QCOMPARE(i2.previous(), p3);
QCOMPARE(i2.previous(), p);
QVERIFY(!i2.hasPrevious());
QCOMPARE(i.peekNext(), p);
// i.peekNext()= 1.0; // compiler error
QCOMPARE(i.next(), p);
QCOMPARE(i.peekNext(), p3);
QCOMPARE(i.next(), p3);
QVERIFY(!i.hasNext());
i.toFront();
QCOMPARE(i.next(), p);
q.checkAndFreeQhullMemory();
}//t_points_iterator
void QhullPoints_test::
t_io()
{
Qhull q;
QhullPoints ps(q);
ostringstream os;
os << "Empty QhullPoints\n" << ps << endl;
coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
QhullPoints ps2(q, 3, 6, c); // 3-dimensional explicit
os << "QhullPoints from c[]\n" << ps2 << endl;
q.checkAndFreeQhullMemory();
RboxPoints rcube("c");
Qhull q2(rcube,"Qt QR0"); // triangulation of rotated unit cube
QhullPoints ps3= q2.points();
os << "QhullPoints\n" << ps3;
os << ps3.print("message\n");
os << ps3.printWithIdentifier("w/ identifiers\n");
cout << os.str();
QString s= QString::fromStdString(os.str());
QCOMPARE(s.count("p"), 8+1);
q2.checkAndFreeQhullMemory();
}//t_io
}//orgQhull
#include "moc/QhullPoints_test.moc"
Event Timeline
Log In to Comment