void LineSegment::updateGrips(int* grips, QRectF* grip) const
{
*grips = 3;
QPointF pp(pagePos());
QPointF pp1(pp);
QPointF pp2(pos2() + pp);
QPointF pp3(pos2() * .5 + pp);
grip[2].translate(pp3);
grip[1].translate(pp2);
grip[0].translate(pp1);
}
void ParsePositionTest::TestParsePosition()
{
ParsePosition pp1(0);
if (pp1.getIndex() == 0) {
logln("PP constructor() tested.");
}else{
errln("*** PP getIndex or constructor() result");
}
{
int to = 5;
ParsePosition pp2( to );
if (pp2.getIndex() == 5) {
logln("PP getIndex and constructor(int32_t) tested.");
}else{
errln("*** PP getIndex or constructor(int32_t) result");
}
pp2.setIndex( 3 );
if (pp2.getIndex() == 3) {
logln("PP setIndex tested.");
}else{
errln("*** PP getIndex or setIndex result");
}
}
ParsePosition pp2(3), pp3(5);
//pp2 = new ParsePosition( 3 );
//pp3 = new ParsePosition( 5 );
ParsePosition pp4(5);
if ( pp2 != pp3) {
logln("PP not equals tested.");
}else{
errln("*** PP not equals fails");
}
if (pp3 == pp4) {
logln("PP equals tested.");
}else{
errln(UnicodeString("*** PP equals fails (") + pp3.getIndex() + " != " + pp4.getIndex() + ")");
}
ParsePosition pp5;
pp5 = pp4;
if (pp4 == pp5) {
logln("PP operator= tested.");
}else{
errln("*** PP operator= operator== or operator != result");
}
ParsePosition *ppp = pp5.clone();
if(ppp == &pp5 || *ppp != pp5) {
errln("ParsePosition.clone() failed");
}
delete ppp;
}
TEST_F(TimusProblemsTestClass, TestProblem_1815) // NOLINT
{
Pt p1(0.f, 0.f);
Pt p2(p1);
p2.x = p2.y = 1.f;
ASSERT_EQ(0.f, p1.x);
ASSERT_EQ(1.f, p2.x);
ASSERT_TRUE(sqrt(2.f) - p1.dist(p2) < 0.000001f);
Pt pp1(0.f, 0.f);
Pt pp2(1.f, 0.f);
Pt pp3(0.f, 1.f);
double result = solve_1815(pp1, pp2, pp3, 1, 1, 1);
ASSERT_TRUE(result - 1.9318516526 < 0.0000000001);
}
void LineSegment::updateGrips(int* grips, QRectF* grip) const
{
*grips = 3;
/* if (line()->anchor() == Spanner::ANCHOR_NOTE) {
grip[0].translate(pos());
grip[1].translate(pos2());
grip[2].translate(pos2() * .5);
return;
}
*/
QPointF pp(pagePos());
QPointF pp1(pp);
QPointF pp2(pos2() + pp);
QPointF pp3(pos2() * .5 + pp);
grip[2].translate(pp3);
grip[1].translate(pp2);
grip[0].translate(pp1);
}
cv::Mat TestProjection::test(double userX, double userY, double userZ,
const char* filename) {
//Coordinates of the projection in the real world
/*cv::Point3f p11(-480, 735, -420);
cv::Point3f p12(0, 935, 0);
cv::Point3f p13(0, 220, 0);
cv::Point3f p14(-480, 240, -420);
Plane3d proj1(p11, p12, p13, p14);
cv::Point3f p21(0, 935, 0);
cv::Point3f p22(480, 735, -420);
cv::Point3f p23(480, 240, -420);
cv::Point3f p24(0, 220, 0);
Plane3d proj2(p21, p22, p23, p24);*/
cv::Point3f p11(-590, 725, -350);
cv::Point3f p12(0, 955, 0);
cv::Point3f p13(0, 200, 0);
cv::Point3f p14(-590, 227, -350);
Plane3d proj1(p11, p12, p13, p14);
cv::Point3f p21(0, 955, 0);
cv::Point3f p22(567, 755, -350);
cv::Point3f p23(567, 227, -350);
cv::Point3f p24(0, 200, 0);
Plane3d proj2(p21, p22, p23, p24);
std::vector<Plane3d> planes;
planes.push_back(proj1);
planes.push_back(proj2);
Projection proj(planes);
// proj.print();
//Create the user with the obtained projection coordinates
User u(proj);
//Update his position
u.updatePosition(userX, userY, userZ);
// u.print();
//Create the distorted-corrected plane pairs, using the projections
//on the user's view plane
//Plane 1
//****************************************************************************************************
Plane2d p1 = u.getProjectedPlanes().at(0).to2d();
Plane2d p2(cv::Point2f(0, 0), cv::Point2f(480, 0), cv::Point2f(480, 540), cv::Point2f(0, 540));
// Plane2d p2(cv::Point2f(0, 0), cv::Point2f(230, 0), cv::Point2f(230, 520), cv::Point2f(0, 520));
// Plane2d p2(cv::Point2f(0, 0), cv::Point2f(270, 0), cv::Point2f(270, 405), cv::Point2f(0, 405));
//****************************************************************************************************
//Invert the plane y coordinates
Plane2d inv1 = p1.yInverted();
//Move it so that it's closer to the target plane
cv::Vec2f dist = pjs::distance(inv1, p2);
Plane2d pp1(cv::Point2f(inv1.getPoint(0).x - dist[0], inv1.getPoint(0).y - dist[1]),
cv::Point2f(inv1.getPoint(1).x - dist[0], inv1.getPoint(1).y - dist[1]),
cv::Point2f(inv1.getPoint(2).x - dist[0], inv1.getPoint(2).y - dist[1]),
cv::Point2f(inv1.getPoint(3).x - dist[0], inv1.getPoint(3).y - dist[1]));
//Plane 2
//****************************************************************************************************
Plane2d p3 = u.getProjectedPlanes().at(1).to2d();
Plane2d p4(cv::Point2f(0, 0), cv::Point2f(480, 0), cv::Point2f(480, 540), cv::Point2f(0, 540));
// Plane2d p4(cv::Point2f(0, 0), cv::Point2f(230, 0), cv::Point2f(230, 520), cv::Point2f(0, 520));
// Plane2d p4(cv::Point2f(0, 0), cv::Point2f(270, 0), cv::Point2f(270, 405), cv::Point2f(0, 405));
//****************************************************************************************************
//Invert the plane y coordinates
Plane2d inv2 = p3.yInverted();
//Move it so that it's closer to the target plane
dist = pjs::distance(inv2, p4);
Plane2d pp3(cv::Point2f(inv2.getPoint(0).x - dist[0], inv2.getPoint(0).y - dist[1]),
cv::Point2f(inv2.getPoint(1).x - dist[0], inv2.getPoint(1).y - dist[1]),
cv::Point2f(inv2.getPoint(2).x - dist[0], inv2.getPoint(2).y - dist[1]),
cv::Point2f(inv2.getPoint(3).x - dist[0], inv2.getPoint(3).y - dist[1]));
//***********************
//Load the target image
//***********************
cv::Mat img = cv::imread(filename, CV_LOAD_IMAGE_COLOR);
if (!img.data) {
std::cout << " --(!) Error reading image" << std::endl;
throw std::exception();
}
//Helper object
Utils utils;
//Divide the image in two
// std::vector<cv::Mat> images = utils.divideImageInTwo(img);
//Build the surfaces with their reference planes and their corresponding
//image
Surface s1(pp1, p2);
Surface s2(pp3, p4);
std::vector<Surface*> surfaces;
surfaces.push_back(&s1);
surfaces.push_back(&s2);
int originX;
int padding;
int screenWidth = 1280;
int screenHeight = 800;
//TODO recursive position correction
int width1 = s1.getWidth();
int width2 = s2.getWidth();
int diffW = width1 - width2;
if (diffW < 0) {
originX = screenWidth / 2 - width1;
padding = 0;
} else {
originX = 0 + screenWidth / 2 - width1;
padding = 0;
}
//1st position correction
cv::Point2f origin(originX, 0);
s1.correctBBPosition(origin);
cv::Point2f s1ur = s1.getUpperRightCorner();
s2.correctPosition(s1ur);
cv::Point2f upperLeft = s2.getUpperLeftCorner();
cv::Point2f upperRight = s2.getUpperRightCorner();
double topY;
if (upperLeft.y < upperRight.y) {
topY = upperLeft.y;
} else {
topY = upperRight.y;
}
cv::Size size = utils.getFinalSize(surfaces);
int diffH = screenHeight - size.height;
//2nd position correction if necessary (if second plane is still outside)
if (!topY < 0) {
topY = 0;
}
cv::Point2f newOrigin(originX, -topY + diffH / 2);
s1.correctBBPosition(newOrigin);
s1ur = s1.getUpperRightCorner();
s2.correctPosition(s1ur);
// cv::Size size = utils.getFinalSize(surfaces);
size.width += padding;
size.width = std::max(screenWidth, size.width);
size.height = screenHeight;
cv::Size sizeS1(size.width / 2, size.height);
s1.setSize(sizeS1);
s2.setSize(size);
std::vector<cv::Mat> images = utils.divideImageInTwo(img);
s1.setImage(images.at(0));
s2.setImage(images.at(1));
s1.applyHomography();
s2.applyHomography();
// s1.addTransparency();
// s2.addTransparency();
cv::Mat finalImage = utils.getImageFromSurfaces(surfaces);
surfaces.clear();
return finalImage;
}
void test_RT()
{
typedef RT Cls;
// _test_cls_regular_3( Cls() );
typedef traits::Bare_point Point;
typedef traits::Weighted_point Weighted_point;
typedef typename Cls::Vertex_handle Vertex_handle;
typedef typename Cls::Cell_handle Cell_handle;
typedef typename Cls::Facet Facet;
typedef typename Cls::Edge Edge;
typedef std::list<Weighted_point> list_point;
typedef typename Cls::Finite_cells_iterator Finite_cells_iterator;
// temporary version
int n, m;
int count = 0;
// For dimension 0, we need to check that the point of highest weight is the
// one that finally ends up in the vertex.
std::cout << " test dimension 0 " << std::endl;
Cls T0;
T0.insert(Weighted_point( Point (0,0,0), 0) );
T0.insert(Weighted_point( Point (0,0,0), 1) );
T0.insert(Weighted_point( Point (0,0,0), -1) );
assert(T0.dimension() == 0);
assert(T0.number_of_vertices() == 1);
assert(T0.finite_vertices_begin()->point().weight() == 1);
std::cout << " test dimension 1 " << std::endl;
Cls T1;
std::cout << " number of inserted points : " ;
Weighted_point p[5];
for ( m=0; m<5; m++) {
if ( (m%2)== 0 )
p[m] = Weighted_point( Point( 2*m,0,0 ), 2 );
else
p[m] = Weighted_point( Point( -2*m+1,0,0 ), 2 );
T1.insert( p[m] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
assert( T1.is_valid() );
std::cout << std::endl << " number of vertices : "
<< T1.number_of_vertices() << std::endl;
std::cout << " number of inserted points : " ;
Weighted_point q[5];
for ( m=0; m<5; m++) {
if ( (m%2)== 0 )
q[m] = Weighted_point( Point( 2*m+1,0,0 ), 5 );
else
q[m] = Weighted_point( Point( -2*m+1,0,0 ), 5 );
T1.insert( q[m] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
assert( T1.is_valid() );
std::cout << std::endl << " number of vertices : "
<< T1.number_of_vertices() << std::endl;
std::cout << " number of inserted points : " ;
Weighted_point r[10];
for ( m=0; m<10; m++) {
if ( (m%2)== 0 )
r[m] = Weighted_point( Point( m,0,0 ), 1 );
else
r[m] = Weighted_point( Point( -m,0,0 ), 1 );
T1.insert( r[m] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
assert( T1.is_valid() );
std::cout << std::endl << " number of vertices : "
<< T1.number_of_vertices() << std::endl;
assert( T1.dimension()==1 );
// The following is distilled from a bug report by Wulue Zhao
// ([email protected]), a student of Tamal Dey.
Point pt0(0,0,0);
Point pt1( 1,0,0), pt2(2,0,0), pt3(3,0,0);
Point pt4(-1,0,0), pt5(-2,0,0), pt6(-3,0,0);
Weighted_point wp0(pt0,10.0);
Weighted_point wp1(pt1,0.0), wp2(pt2,0.0), wp3(pt3,0.0);
Weighted_point wp4(pt4,0.0), wp5(pt5,0.0), wp6(pt6,0.0);
Cls T11;
T11.insert(wp0);
T11.insert(wp1);
T11.insert(wp2);
T11.insert(wp3);
T11.insert(wp4);
T11.insert(wp5);
T11.insert(wp6);
assert(T11.is_valid());
// And another distilled bug report from the same guy.
{
Point p1(-0.07, 0.04, 0.04);
Point p2(0.09, 0.04, 0.04);
Point p3(0.09, -0.05, 0.04);
Point p4(0.05, -0.05, 0.04);
Point p5(0.05, 0.0, 0.04);
Point p6(-0.07, 0.0, 0.04);
Point p7(-0.07, 0.04, -0.04);
Point p8(0.09, 0.04, -0.04);
Point p9(0.09, -0.05, -0.04);
Point p10(0.05, -0.05, -0.04);
Point p11(0.05, 0.0, -0.04);
Point p12(-0.07, 0.0, -0.04);
Weighted_point wp1(p1,0);
Weighted_point wp2(p2,0);
Weighted_point wp3(p3,0);
Weighted_point wp4(p4,0);
Weighted_point wp5(p5,0);
Weighted_point wp6(p6,0);
Weighted_point wp7(p7,0);
Weighted_point wp8(p8,0);
Weighted_point wp9(p9,0);
Weighted_point wp10(p10,0);
Weighted_point wp11(p11,0);
Weighted_point wp12(p12,0);
Weighted_point wp13(p3,0.3); // wp13 has the same coordinates with wp3
Cls T111;
T111.insert(wp1);
T111.insert(wp2);
T111.insert(wp3);
T111.insert(wp13); // it doesnot work inserting wp13 here
T111.insert(wp4);
T111.insert(wp5);
T111.insert(wp6);
T111.insert(wp7);
T111.insert(wp8);
T111.insert(wp9);
T111.insert(wp10);
T111.insert(wp11);
T111.insert(wp12);
assert(T111.is_valid());
}
std::cout << " test dimension 2 " << std::endl;
std::cout << " number of inserted points : " ;
Cls T2;
count = 0 ;
int px=1, py=1;
int qx=-1, qy=2;
Weighted_point s[400];
for (m=0; m<10; m++)
for (n=0; n<10; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), 1 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
for (m=10; m<20; m++)
for (n=0; n<10; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), -1 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
for (m=0; m<10; m++)
for (n=10; n<20; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), -2 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
for (m=10; m<20; m++)
for (n=10; n<20; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), 5 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
std::cout << std::endl << " number of vertices : "
<< T2.number_of_vertices() << std::endl;
assert( T2.dimension()==2 );
assert( T2.is_valid() );
// dimension 3
std::cout << " test dimension 3" << std::endl;
Cls T;
list_point lp;
int a, b, d;
for (a=0;a!=10;a++)
// for (b=0;b!=10;b++)
for (b=0;b!=5;b++)
// for (d=0;d!=10;d++)
for (d=0;d!=5;d++)
lp.push_back(Weighted_point( Point(a*b-d*a + (a-b)*10 +a ,
a-b+d +5*b,
a*a-d*d+b),
a*b-a*d) );
list_point::iterator it;
count = 0 ;
std::cout << " number of inserted points : " ;
for (it=lp.begin(); it!=lp.end(); ++it){
count++;
T.insert(*it);
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
if (count < 1000)
std::cout << count << '\b' << '\b' << '\b' ;
else
std::cout << count << std::endl;
std::cout.flush();
}
std::cout << std::endl;
std::cout << " number of vertices : "
<< T.number_of_vertices() << std::endl;
assert(T.is_valid());
assert(T.dimension()==3);
T.clear();
std::cout << " test iterator range insert" << std::endl;
T.insert (lp.begin(), lp.end());
std::cout << " number of vertices : "
<< T.number_of_vertices() << std::endl;
assert(T.is_valid());
assert(T.dimension()==3);
//test nearest_power_vertex
std::cout << " test nearest_power_vertex " << std::endl;
Point pp1(0.0, 0.0, 0.0);
Point pp2(1.0, 0.0, 0.0);
Point pp3(0.0, 1.0, 0.0);
Point pp4(0.0, 0.0, 1.0);
Point pp5(1.0, 1.0, 0.0);
Point pp6(0.0, 1.0, 1.0);
Point pp7(1.0, 0.0, 1.0);
Point pp8(1.0, 1.0, 1.0);
Weighted_point wpp1(pp1, 1.0);
Weighted_point wpp2(pp2, 2.0);
Weighted_point wpp3(pp3, 1.0);
Weighted_point wpp4(pp4, 4.0);
Weighted_point wpp5(pp5, 1.0);
Weighted_point wpp6(pp6, 1.0);
Weighted_point wpp7(pp7, 1.0);
Weighted_point wpp8(pp8, 8.0);
Cls T3;
T3.insert(wpp1);
Vertex_handle v2 = T3.insert(wpp2);
assert( T3.nearest_power_vertex(Point(0.5,0.5,0.5)) == v2);
T3.insert(wpp3);
Vertex_handle v4 = T3.insert(wpp4);
assert( T3.nearest_power_vertex(Point(0.5,0.5,0.5)) == v4);
T3.insert(wpp5);
T3.insert(wpp6);
T3.insert(wpp7);
// Avoid inserting the same point twice, now that hidden points are handled,
// insert (existing_point) returns Vertex_handle().
// T3.insert(wpp8);
Vertex_handle v8 = T3.insert(wpp8);
Point query(0.5,0.5,0.5);
assert(T3.nearest_power_vertex(query) == v8);
assert(T3.nearest_power_vertex(Weighted_point(query,1.0)) == v8 );
assert(T3.nearest_power_vertex_in_cell(query ,v8->cell()) == v8);
// test dual
std::cout << " test dual member functions" << std::endl;
Finite_cells_iterator fcit = T3.finite_cells_begin();
for( ; fcit != T3.finite_cells_end(); ++fcit) {
Point cc = T3.dual(fcit);
Vertex_handle ncc = T3.nearest_power_vertex(cc);
assert(fcit->has_vertex(ncc));
}
// test Gabriel
std::cout << " test is_Gabriel " << std::endl;
Point q0(0.,0.,0.);
Point q1(2.,0.,0.);
Point q2(0.,2.,0.);
Point q3(0.,0.,2.);
Weighted_point wq0(q0,0.);
Weighted_point wq1(q1,0.);
Weighted_point wq2(q2,0.);
Weighted_point wq3(q3,0.);
Weighted_point wq01(q0,2.);
Cls T4;
Vertex_handle v0 = T4.insert(wq0);
Vertex_handle v1 = T4.insert(wq1);
v2 = T4.insert(wq2);
Vertex_handle v3 = T4.insert(wq3);
Cell_handle c;
int i,j,k,l;
assert(T4.is_facet(v0,v1,v2,c,j,k,l));
i = 6 - (j+k+l);
Facet f = std::make_pair(c,i);
assert(T4.is_Gabriel(c,i));
assert(T4.is_Gabriel(f));
assert(T4.is_facet(v1,v2,v3,c,j,k,l));
i = 6 - (j+k+l);
assert(!T4.is_Gabriel(c,i));
assert(T4.is_edge(v0,v1,c,i,j));
assert(T4.is_Gabriel(c,i,j));
Edge e = make_triple(c,i,j);
assert(T4.is_Gabriel(e));
assert(T4.is_edge(v2,v3,c,i,j));
assert(T4.is_Gabriel(c,i,j));
Vertex_handle v01 = T4.insert(wq01);
(void) v01; // kill warning
assert(T4.is_edge(v2,v3,c,i,j));
assert(!T4.is_Gabriel(c,i,j));
Weighted_point wwq0(q0,0.);
Weighted_point wwq1(q1,0.);
Weighted_point wwq2(q2,0.);
Weighted_point wwq3(q3,5.);
Cls T5;
v0 = T5.insert(wwq0);
v1 = T5.insert(wwq1);
v2 = T5.insert(wwq2);
v3 = T5.insert(wwq3);
assert(T5.nearest_power_vertex(v3->point().point()) == v3);
assert(T5.nearest_power_vertex(v0->point().point()) == v3);
assert(T5.is_Gabriel(v3));
assert(!T5.is_Gabriel(v0));
}
