void Crate::draw(cv::Mat& image) {
// Draw the fiducial points
cv::circle(image, points[0], 1, cv::Scalar(255, 0, 0), 2);
cv::circle(image, points[1], 1, cv::Scalar(0, 255, 0), 2);
cv::circle(image, points[2], 1, cv::Scalar(0, 0, 255), 2);
cv::RotatedRect rect = this->rect();
// Draw rect
{
cv::Point2f pt1(
rect.center.x + (rect.size.width / 2.0) * cos(-rect.angle)
- (rect.size.height / 2.0) * sin(-rect.angle),
rect.center.y + (rect.size.height / 2.0) * cos(-rect.angle)
+ (rect.size.width / 2.0) * sin(-rect.angle));
cv::Point2f pt2(
rect.center.x - (rect.size.width / 2.0) * cos(-rect.angle)
- (rect.size.height / 2.0) * sin(-rect.angle),
rect.center.y + (rect.size.height / 2.0) * cos(-rect.angle)
- (rect.size.width / 2.0) * sin(-rect.angle));
cv::Point2f pt3(
rect.center.x - (rect.size.width / 2.0) * cos(-rect.angle)
+ (rect.size.height / 2.0) * sin(-rect.angle),
rect.center.y - (rect.size.height / 2.0) * cos(-rect.angle)
- (rect.size.width / 2.0) * sin(-rect.angle));
cv::Point2f pt4(
rect.center.x + (rect.size.width / 2.0) * cos(-rect.angle)
+ (rect.size.height / 2.0) * sin(-rect.angle),
rect.center.y - (rect.size.height / 2.0) * cos(-rect.angle)
+ (rect.size.width / 2.0) * sin(-rect.angle));
cv::line(image, pt1, pt2, cv::Scalar(0,255,0), 2);
cv::line(image, pt2, pt3, cv::Scalar(0,255,0), 2);
cv::line(image, pt3, pt4, cv::Scalar(0,255,0), 2);
cv::line(image, pt4, pt1, cv::Scalar(0,255,0), 2);
}
// Draw arrow
{
cv::Point pt1 = rect.center;
cv::Point pt2(pt1.x - 50 * cos(-rect.angle+M_PI/2.0),
pt1.y - 50 * sin(-rect.angle+M_PI/2.0));
cv::line(image, pt1, pt2, cv::Scalar(0, 0, 0), 2);
cv::line(image, pt2,
cv::Point(pt2.x + 10 * cos(-rect.angle+3*M_PI/4.0),
pt2.y + 10 * sin(-rect.angle+3*M_PI/4.0)),
cv::Scalar(0, 0, 0), 2);
cv::line(image, pt2,
cv::Point(pt2.x + 10 * cos(-rect.angle+M_PI/4.0),
pt2.y + 10 * sin(-rect.angle+M_PI/4.0)),
cv::Scalar(0, 0, 0), 2);
std::stringstream ss;
ss << cv::saturate_cast<int>(rect.angle / (M_PI/180.0));
cv::putText(image, ss.str(), pt1-cv::Point(15,0), CV_FONT_HERSHEY_SIMPLEX, .5, cv::Scalar(255,0,0), 2);
}
if(!name.empty()) {
cv::putText(image, name, cv::Point(rect.center.x, rect.center.y-20), CV_FONT_HERSHEY_COMPLEX, 1, cv::Scalar(0,0,255), 2);
}
}
int main(void)
{
point pt1(3, 5);
pt1.print();
#if 1
point pt2 = pt1;
pt2.print();
#endif
point pt3 = get_point();
pt3.print();
#if 1
point pt4(98, 6);
pt4 = pt4;
pt4.print();
#endif
#if 1
point pt5;
pt5 = pt4;//call the assign operator, remind the self assignment
pt5.print();
#endif
return 0;
}
TopoDS_Shape CreateRectangle::executeCreation() const
{
try
{
gp_Pnt pt1(point);
gp_Pnt pt2(point.X() + width, point.Y(), point.Z());
gp_Pnt pt3(point.X() + width, point.Y() + height, point.Z());
gp_Pnt pt4(point.X(), point.Y() + height, point.Z());
Handle(Geom_TrimmedCurve) segment1 = GC_MakeSegment(pt1, pt2);
Handle(Geom_TrimmedCurve) segment2 = GC_MakeSegment(pt2, pt3);
Handle(Geom_TrimmedCurve) segment3 = GC_MakeSegment(pt3, pt4);
Handle(Geom_TrimmedCurve) segment4 = GC_MakeSegment(pt4, pt1);
TopoDS_Edge edge1 = BRepBuilderAPI_MakeEdge(segment1);
TopoDS_Edge edge2 = BRepBuilderAPI_MakeEdge(segment2);
TopoDS_Edge edge3 = BRepBuilderAPI_MakeEdge(segment3);
TopoDS_Edge edge4 = BRepBuilderAPI_MakeEdge(segment4);
TopoDS_Wire wire = BRepBuilderAPI_MakeWire(edge1 , edge2 , edge3, edge4);
BRepBuilderAPI_MakeFace makeFace(wire);
return makeFace.Shape();
}
catch(const StdFail_NotDone& ex)
{
throw Common::Exception(QObject::tr("Create rectangle error"));
}
}
void test_wait_for_either_of_five_futures_5()
{
boost::packaged_task<int> pt(make_int_slowly);
boost::unique_future<int> f1(pt.get_future());
boost::packaged_task<int> pt2(make_int_slowly);
boost::unique_future<int> f2(pt2.get_future());
boost::packaged_task<int> pt3(make_int_slowly);
boost::unique_future<int> f3(pt3.get_future());
boost::packaged_task<int> pt4(make_int_slowly);
boost::unique_future<int> f4(pt4.get_future());
boost::packaged_task<int> pt5(make_int_slowly);
boost::unique_future<int> f5(pt5.get_future());
boost::thread(::cast_to_rval(pt5));
unsigned const future=boost::wait_for_any(f1,f2,f3,f4,f5);
BOOST_CHECK(future==4);
BOOST_CHECK(!f1.is_ready());
BOOST_CHECK(!f2.is_ready());
BOOST_CHECK(!f3.is_ready());
BOOST_CHECK(!f4.is_ready());
BOOST_CHECK(f5.is_ready());
BOOST_CHECK(f5.get()==42);
}
double Error(size_t sample, const Model& model) const
{
// Calculate the distance from the point to the plane normal as the dot
// product
// D = (P-A).N/|N|
openMVG::Vec3 pt3 = _pt.col(sample);
openMVG::Vec4 pt4(pt3(0), pt3(1), pt3(2), 1.0);
return fabs(model.dot(pt4));
}
TopoDS_Shape OCCPartFactory::makeCube( const Standard_Real width,
const Standard_Real height,
const Standard_Real depth)
{
// define points
gp_Pnt pt1( -width / 2.0, 0.0, 0.0 );
gp_Pnt pt2( -width / 2.0, -depth / 2.0, 0.0 );
gp_Pnt pt3( width / 2.0, -depth / 2.0, 0.0 );
gp_Pnt pt4( width /2.0, 0.0, 0.0 );
// define segments
Handle_Geom_TrimmedCurve seg1 = GC_MakeSegment( pt1, pt2 );
Handle_Geom_TrimmedCurve seg2 = GC_MakeSegment( pt2, pt3 );
Handle_Geom_TrimmedCurve seg3 = GC_MakeSegment( pt3, pt4 );
// make edge
TopoDS_Edge edge1 = BRepBuilderAPI_MakeEdge( seg1 );
TopoDS_Edge edge2 = BRepBuilderAPI_MakeEdge( seg2 );
TopoDS_Edge edge3 = BRepBuilderAPI_MakeEdge( seg3 );
// make wire
TopoDS_Wire wire1 = BRepBuilderAPI_MakeWire( edge1, edge2, edge3 );
//Complete Profile
gp_Ax1 xAxis = gp::OX();
gp_Trsf transfer;
transfer.SetMirror( xAxis );
BRepBuilderAPI_Transform aBRepTrsf( wire1 , transfer );
TopoDS_Shape mirroredShape = aBRepTrsf.Shape();
TopoDS_Wire mirroredWire1 = TopoDS::Wire( mirroredShape );
BRepBuilderAPI_MakeWire mkWire;
mkWire.Add( wire1 );
mkWire.Add( mirroredWire1 );
TopoDS_Wire wireProfile = mkWire.Wire();
//Body : Prism the Profile
TopoDS_Face faceProfile = BRepBuilderAPI_MakeFace( wireProfile );
gp_Vec prismVec( 0.0 , 0.0 , height );
TopoDS_Shape cube = BRepPrimAPI_MakePrism( faceProfile, prismVec);
// cube.setMaterial( Graphic3d_NOM_JADE );
// Handle_AIS_Shape shape = new AIS_Shape( cube );
// shape->SetColor( Quantity_NOC_RED );
// return shape;
return cube;
}
void HelloScene::drawAfter()
{
SGraphic.drawLine(10, 10, 300, 300);
CBPoint pt1(100,50);
CBPoint pt2(125,50);
CBPoint pt3(125,75);
CBPoint pt4(100,75);
SGraphic.drawLineLoop(pt1, pt2, pt3, pt4);
CBRect rect(100,100,30,30);
SGraphic.drawRect(rect);
CBPoint pt5(200, 100);
SGraphic.drawCircle(pt5, 50);
}
void HelloScene::drawAfter()
{
SGraphic.drawLine(10, 10, 300, 300);
CBPoint pt1(200,100);
CBPoint pt2(250,100);
CBPoint pt3(250,150);
CBPoint pt4(200,150);
SGraphic.drawLineLoop(pt1, pt2, pt3, pt4);
CBRect rect(200,200,50,50);
SGraphic.drawRect(rect);
CBPoint pt5(400, 200);
SGraphic.drawCircle(pt5, 100);
}
void check_equal()
{
bool are_equal;
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Equal_2 equal = traits.equal_2_object();
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
//create some curves
Conic_point_2 ps1(Rational(1,4), 4);
Conic_point_2 pt1(2, Rational(1,2));
Conic_curve_2 c1(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps1, pt1);
Conic_point_2 ps2(Rational(1,4), 4);
Conic_point_2 pt2(2, Rational(1,2));
Conic_curve_2 c2(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps2, pt2);
Rat_point_2 ps3(Rational(1,4), 4);
Rat_point_2 pmid3(Rational(3,2), 2);
Rat_point_2 pt3(2, Rational(1,3));
Conic_curve_2 c3(ps3, pmid3, pt3);
Rat_point_2 ps4(1, 5);
Rat_point_2 pmid4(Rational(3,2), 3);
Rat_point_2 pt4(3, Rational(1,3));
Conic_curve_2 c4(ps4, pmid4, pt4);
// //make x_monotone
Polycurve_conic_traits_2::X_monotone_curve_2 xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc3 =
construct_x_monotone_curve_2(c3);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc4 =
construct_x_monotone_curve_2(c4);
are_equal = equal(xmc1, xmc2);
std::cout << "Two equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
are_equal = equal(xmc3, xmc2);
std::cout << "Two un-equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
are_equal = equal(xmc3, xmc4);
std::cout << "Two un-equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
}
main()
{
page pg;
pg.adjustparams = adjust;
xy pt1(-7,4), pt2(0,0), pt3(-7,-4), pt4(8,0);
FeynDiagram fdA(pg,1,4,5.5);
line_plain L1A(fdA,pt1,pt2), L2A(fdA,pt2,pt3);
line_zigzag L3A(fdA,pt2,pt4);
FeynDiagram fdB(pg,4.5,7.5,5.5);
line_plain L1B(fdB,pt1,pt2), L2B(fdB,pt2,pt3);
line_wiggle L3B(fdB,pt2,pt4);
pg.output();
return 0;
}
void mark(cv::Mat& img, PPoint2d &p, unsigned char l) {
int r = 10;
//draw_circle(img, p, r, l);
// draw_circle(img, p[0], p[1], 10, l);
// draw_line(img, p[0]-r/2, p[1]-r/2, p[0]+r/2, p[1]+r/2, l);
// draw_line(img, p[0]-r/2, p[1]+r/2, p[0]+r/2, p[1]-r/2, l);
double x = p.x();
double y = p.y();
cv::Point2d pt(x,y);
cv::Point2d pt1(x - r / 2, y - r / 2);
cv::Point2d pt2(x + r / 2, y + r / 2);
cv::Point2d pt3(x - r / 2, y + r / 2);
cv::Point2d pt4(x + r / 2, y - r / 2);
cout << p << endl;
if (x >= 0 && y >= 0 && x <= img.rows && y <= img.cols) {
cv::circle(img, pt, 10, l);
cv::line(img, pt1, pt2, l);
cv::line(img, pt3, pt4, l);
}
}
void DrawResult(IplImage* image, windage::Matrix3 homography, CvScalar color = CV_RGB(255, 0, 0), int thickness = 1)
{
windage::Vector3 pt1(0.0, 0.0, 1.0);
windage::Vector3 pt2(TEMPLATE_WIDTH, 0.0, 1.0);
windage::Vector3 pt3(TEMPLATE_WIDTH, TEMPLATE_HEIGHT, 1.0);
windage::Vector3 pt4(0.0, TEMPLATE_HEIGHT, 1.0);
windage::Vector3 outPoint1 = homography * pt1;
windage::Vector3 outPoint2 = homography * pt2;
windage::Vector3 outPoint3 = homography * pt3;
windage::Vector3 outPoint4 = homography * pt4;
outPoint1 /= outPoint1.z;
outPoint2 /= outPoint2.z;
outPoint3 /= outPoint3.z;
outPoint4 /= outPoint4.z;
cvLine(image, cvPoint((int)outPoint1.x, (int)outPoint1.y), cvPoint((int)outPoint2.x, (int)outPoint2.y), color, thickness);
cvLine(image, cvPoint((int)outPoint2.x, (int)outPoint2.y), cvPoint((int)outPoint3.x, (int)outPoint3.y), color, thickness);
cvLine(image, cvPoint((int)outPoint3.x, (int)outPoint3.y), cvPoint((int)outPoint4.x, (int)outPoint4.y), color, thickness);
cvLine(image, cvPoint((int)outPoint4.x, (int)outPoint4.y), cvPoint((int)outPoint1.x, (int)outPoint1.y), color, thickness);
}
TEST(NumLib, SpatialFunctionInterpolationSurface)
{
// create geometry
GeoLib::Point pt1(0.0, 0.0, 0.0);
GeoLib::Point pt2(10.0, 0.0, 0.0);
GeoLib::Point pt3(10.0, 10.0, 0.0);
GeoLib::Point pt4(0.0, 10.0, 0.0);
std::vector<GeoLib::Point*> pnts = {&pt1, &pt2, &pt3, &pt4};
GeoLib::Polyline ply0(pnts);
ply0.addPoint(0);
ply0.addPoint(1);
ply0.addPoint(2);
ply0.addPoint(3);
ply0.addPoint(0);
std::unique_ptr<GeoLib::Surface> sfc1(GeoLib::Surface::createSurface(ply0));
// define a function
const std::vector<std::size_t> vec_point_ids = {{0, 1, 2, 3}};
const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
NumLib::LinearInterpolationOnSurface interpolate(*sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
// normal
for (unsigned k=0; k<10; k++) {
ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,0,0)));
ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,5,0)));
ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,10,0)));
}
// failure
// x, y
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,-1,0)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,-1,0)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,11,0)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,11,0)));
// z
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,1)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,-1)));
}
void BlockingInfoRenderer::render(Camera* cam, Layer* layer, RenderList& instances) {
CellGrid* cg = layer->getCellGrid();
if (!cg) {
FL_WARN(_log, "No cellgrid assigned to layer, cannot draw grid");
return;
}
Rect cv = cam->getViewPort();
RenderList::const_iterator instance_it = instances.begin();
for (;instance_it != instances.end(); ++instance_it) {
Instance* instance = (*instance_it)->instance;
if (!instance->getObject()->isBlocking() || !instance->isBlocking()) {
continue;
}
std::vector<ExactModelCoordinate> vertices;
cg->getVertices(vertices, instance->getLocationRef().getLayerCoordinates());
std::vector<ExactModelCoordinate>::const_iterator it = vertices.begin();
int halfind = vertices.size() / 2;
ScreenPoint firstpt = cam->toScreenCoordinates(cg->toMapCoordinates(*it));
Point pt1(firstpt.x, firstpt.y);
Point pt2;
++it;
for (; it != vertices.end(); it++) {
ScreenPoint pts = cam->toScreenCoordinates(cg->toMapCoordinates(*it));
pt2.x = pts.x; pt2.y = pts.y;
Point cpt1 = pt1;
Point cpt2 = pt2;
m_renderbackend->drawLine(cpt1, cpt2, m_color.r, m_color.g, m_color.b);
pt1 = pt2;
}
m_renderbackend->drawLine(pt2, Point(firstpt.x, firstpt.y), m_color.r, m_color.g, m_color.b);
ScreenPoint spt1 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[0]));
Point pt3(spt1.x, spt1.y);
ScreenPoint spt2 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[halfind]));
Point pt4(spt2.x, spt2.y);
m_renderbackend->drawLine(pt3, pt4, m_color.r, m_color.g, m_color.b);
}
}
Cube::Cube(){
geoType = CUBE_GEO;
p = new Poly();
Point pt1(0,0,0);
Point pt2(0,0,10);
Point pt3(10,0,10);
Point pt4(10,0,0);
Point pt5(10,10,0);
Point pt6(10,10,10);
Point pt7(0,10,10);
Point pt8(0,10,0);
p->addFace(pt1, pt2, pt7, pt8); // bottom
p->addFace(pt3, pt4, pt5, pt6); // right
p->addFace(pt1, pt2, pt3, pt4); // front
p->addFace(pt5, pt6, pt7, pt8); // top
p->addFace(pt1, pt4, pt5, pt8); // left
p->addFace(pt2, pt3, pt6, pt7); // back
p->computeNormals();
this->addPoly(p); // this adds it to scene
p->bound();
this->bound();
}
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));
}
QBezier QBezier::mapBy(const QTransform &transform) const
{
return QBezier::fromPoints(transform.map(pt1()), transform.map(pt2()), transform.map(pt3()), transform.map(pt4()));
}
bool QgsEllipseSymbolLayerV2::writeDxf( QgsDxfExport& e, double mmMapUnitScaleFactor, const QString& layerName, const QgsSymbolV2RenderContext* context, const QgsFeature* f, const QPointF& shift ) const
{
//width
double symbolWidth = mSymbolWidth;
QgsExpression* widthExpression = expression( "width" );
if ( widthExpression ) //1. priority: data defined setting on symbol layer level
{
symbolWidth = widthExpression->evaluate( const_cast<QgsFeature*>( f ) ).toDouble();
}
else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
{
symbolWidth = mSize;
}
if ( mSymbolWidthUnit == QgsSymbolV2::MM )
{
symbolWidth *= mmMapUnitScaleFactor;
}
//height
double symbolHeight = mSymbolHeight;
QgsExpression* heightExpression = expression( "height" );
if ( heightExpression ) //1. priority: data defined setting on symbol layer level
{
symbolHeight = heightExpression->evaluate( const_cast<QgsFeature*>( f ) ).toDouble();
}
else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
{
symbolHeight = mSize;
}
if ( mSymbolHeightUnit == QgsSymbolV2::MM )
{
symbolHeight *= mmMapUnitScaleFactor;
}
//outline width
double outlineWidth = mOutlineWidth;
QgsExpression* outlineWidthExpression = expression( "outline_width" );
if ( outlineWidthExpression )
{
outlineWidth = outlineWidthExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toDouble();
}
if ( mOutlineWidthUnit == QgsSymbolV2::MM )
{
outlineWidth *= outlineWidth;
}
//color
QColor c = mFillColor;
QgsExpression* fillColorExpression = expression( "fill_color" );
if ( fillColorExpression )
{
c = QColor( fillColorExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toString() );
}
int colorIndex = e.closestColorMatch( c.rgb() );
//symbol name
QString symbolName = mSymbolName;
QgsExpression* symbolNameExpression = expression( "symbol_name" );
if ( symbolNameExpression )
{
QgsExpression* symbolNameExpression = expression( "symbol_name" );
symbolName = symbolNameExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toString();
}
//offset
double offsetX = 0;
double offsetY = 0;
markerOffset( *context, offsetX, offsetY );
QPointF off( offsetX, offsetY );
//priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle)
double rotation = 0.0;
QgsExpression* rotationExpression = expression( "rotation" );
if ( rotationExpression )
{
rotation = rotationExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toDouble();
}
else if ( !qgsDoubleNear( mAngle, 0.0 ) )
{
rotation = mAngle;
}
rotation = -rotation; //rotation in Qt is counterclockwise
if ( rotation )
off = _rotatedOffset( off, rotation );
QTransform t;
t.translate( shift.x() + offsetX, shift.y() + offsetY );
if ( rotation != 0 )
t.rotate( rotation );
double halfWidth = symbolWidth / 2.0;
double halfHeight = symbolHeight / 2.0;
if ( symbolName == "circle" )
{
//soon...
}
else if ( symbolName == "rectangle" )
{
QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) );
QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) );
QPointF pt3( t.map( QPointF( -halfWidth, halfHeight ) ) );
QPointF pt4( t.map( QPointF( halfWidth, halfHeight ) ) );
e.writeSolid( layerName, colorIndex, QgsPoint( pt1.x(), pt1.y() ), QgsPoint( pt2.x(), pt2.y() ), QgsPoint( pt3.x(), pt3.y() ), QgsPoint( pt4.x(), pt4.y() ) );
return true;
}
else if ( symbolName == "cross" )
{
QgsPolyline line1( 2 );
QPointF pt1( t.map( QPointF( -halfWidth, 0 ) ) );
QPointF pt2( t.map( QPointF( halfWidth, 0 ) ) );
line1[0] = QgsPoint( pt1.x(), pt1.y() );
line1[1] = QgsPoint( pt2.x(), pt2.y() );
e.writePolyline( line1, layerName, "CONTINUOUS", colorIndex, outlineWidth, false );
QgsPolyline line2( 2 );
QPointF pt3( t.map( QPointF( 0, halfHeight ) ) );
QPointF pt4( t.map( QPointF( 0, -halfHeight ) ) );
line2[0] = QgsPoint( pt3.x(), pt3.y() );
line2[1] = QgsPoint( pt3.x(), pt3.y() );
e.writePolyline( line2, layerName, "CONTINUOUS", colorIndex, outlineWidth, false );
return true;
}
else if ( symbolName == "triangle" )
{
QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) );
QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) );
QPointF pt3( t.map( QPointF( 0, halfHeight ) ) );
QPointF pt4( t.map( QPointF( 0, halfHeight ) ) );
e.writeSolid( layerName, colorIndex, QgsPoint( pt1.x(), pt1.y() ), QgsPoint( pt2.x(), pt2.y() ), QgsPoint( pt3.x(), pt3.y() ), QgsPoint( pt4.x(), pt4.y() ) );
return true;
}
return false; //soon...
}
void OVRScene::timestep(double /*absTime*/, double dt)
{
(void)dt;
if (m_pHmd == NULL)
return;
const ovrTrackingState ts = ovrHmd_GetTrackingState(m_pHmd, ovr_GetTimeInSeconds());
const ovrVector3f& hp = ts.HeadPose.ThePose.Position;
glm::vec4 headPt(hp.x, hp.y, hp.z, 1.0f);
// Get camera pose as a matrix
const ovrPosef& cp = ts.CameraPose;
OVR::Matrix4f camMtx = OVR::Matrix4f();
camMtx *= OVR::Matrix4f::Translation(cp.Position)
* OVR::Matrix4f(OVR::Quatf(cp.Orientation));
const glm::mat4 gcamMtx = glm::make_mat4(&camMtx.Inverted().Transposed().M[0][0]);
headPt = gcamMtx * headPt;
m_tanFromCameraCenterline.x = fabs(headPt.x / headPt.z);
m_tanFromCameraCenterline.y = fabs(headPt.y / headPt.z);
#if 0
std::vector<glm::vec3> txFrustumPts = m_frustumVerts;
for (std::vector<glm::vec3>::const_iterator it = txFrustumPts.begin();
it != txFrustumPts.end();
++it)
{
glm::vec3 pt = *it;
glm::vec4 pt4(pt, 1.0f);
pt4 = gcamMtx * pt4;
pt.x = pt4.x;
pt.y = pt4.y;
pt.z = pt4.z;
}
// Calculate minimum distance to frustum
std::vector<glm::ivec3> planeIndices;
planeIndices.push_back(glm::ivec3(2, 3, 4));
planeIndices.push_back(glm::ivec3(8, 7, 6));
planeIndices.push_back(glm::ivec3(2, 3, 7));
planeIndices.push_back(glm::ivec3(3, 4, 8));
planeIndices.push_back(glm::ivec3(4, 5, 9));
planeIndices.push_back(glm::ivec3(5, 2, 6));
float minDist = 999.0f;
for (std::vector<glm::ivec3>::const_iterator it = planeIndices.begin();
it != planeIndices.end();
++it)
{
const glm::ivec3& idxs = *it;
// Assume this point has already been transformed
// If our indices are out of bounds, we're hosed
const glm::vec3& p1 = txFrustumPts[idxs.x];
const glm::vec3& p2 = txFrustumPts[idxs.y];
const glm::vec3& p3 = txFrustumPts[idxs.z];
const glm::vec3 v1 = p1 - p2;
const glm::vec3 v2 = p3 - p2;
const glm::vec3 norm = glm::normalize(glm::cross(v1, v2));
const glm::vec3 ptDist = headPt - p2;
const float dist = fabs(glm::dot(norm, ptDist)); // shouldn't need fabs if ordering is correct
minDist = std::min(minDist, dist);
}
m_distanceToFrustum = minDist;
#endif
}
bool QgsEllipseSymbolLayerV2::writeDxf( QgsDxfExport& e, double mmMapUnitScaleFactor, const QString& layerName, const QgsSymbolV2RenderContext* context, const QgsFeature* f, const QPointF& shift ) const
{
//width
double symbolWidth = mSymbolWidth;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_WIDTH ) ) //1. priority: data defined setting on symbol layer le
{
symbolWidth = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_WIDTH, f, mSymbolWidth ).toDouble();
}
else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
{
symbolWidth = mSize;
}
if ( mSymbolWidthUnit == QgsSymbolV2::MM )
{
symbolWidth *= mmMapUnitScaleFactor;
}
//height
double symbolHeight = mSymbolHeight;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_HEIGHT ) ) //1. priority: data defined setting on symbol layer level
{
symbolHeight = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_HEIGHT, f, mSymbolHeight ).toDouble();
}
else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
{
symbolHeight = mSize;
}
if ( mSymbolHeightUnit == QgsSymbolV2::MM )
{
symbolHeight *= mmMapUnitScaleFactor;
}
//outline width
double outlineWidth = mOutlineWidth;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_WIDTH ) )
{
outlineWidth = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_WIDTH, f, mOutlineWidth ).toDouble();
}
if ( mOutlineWidthUnit == QgsSymbolV2::MM )
{
outlineWidth *= outlineWidth;
}
//fill color
bool ok;
QColor fc = mFillColor;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_FILL_COLOR ) )
{
QString colorString = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_FILL_COLOR, f, QVariant(), &ok ).toString();
if ( ok )
fc = QColor( colorString );
}
//outline color
QColor oc = mOutlineColor;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_COLOR ) )
{
QString colorString = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_COLOR, f, QVariant(), &ok ).toString();
if ( ok )
oc = QColor( colorString );
}
//symbol name
QString symbolName = mSymbolName;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_SYMBOL_NAME ) )
{
symbolName = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_SYMBOL_NAME, f, mSymbolName ).toString();
}
//offset
double offsetX = 0;
double offsetY = 0;
markerOffset( *context, offsetX, offsetY );
QPointF off( offsetX, offsetY );
//priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle)
double rotation = 0.0;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_ROTATION ) )
{
rotation = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_ROTATION, f, mAngle ).toDouble() + mLineAngle;
}
else if ( !qgsDoubleNear( mAngle + mLineAngle, 0.0 ) )
{
rotation = mAngle + mLineAngle;
}
rotation = -rotation; //rotation in Qt is counterclockwise
if ( rotation )
off = _rotatedOffset( off, rotation );
QTransform t;
t.translate( shift.x() + offsetX, shift.y() + offsetY );
if ( rotation != 0 )
t.rotate( rotation );
double halfWidth = symbolWidth / 2.0;
double halfHeight = symbolHeight / 2.0;
if ( symbolName == "circle" )
{
if ( qgsDoubleNear( halfWidth, halfHeight ) )
{
QPointF pt( t.map( QPointF( 0, 0 ) ) );
e.writeFilledCircle( layerName, oc, pt, halfWidth );
}
else
{
QgsPolyline line;
double stepsize = 2 * M_PI / 40;
for ( int i = 0; i < 39; ++i )
{
double angle = stepsize * i;
double x = halfWidth * cos( angle );
double y = halfHeight * sin( angle );
QPointF pt( t.map( QPointF( x, y ) ) );
line.push_back( pt );
}
//close ellipse with first point
line.push_back( line.at( 0 ) );
if ( mBrush.style() != Qt::NoBrush )
e.writePolygon( QgsPolygon() << line, layerName, "SOLID", fc );
if ( mPen.style() != Qt::NoPen )
e.writePolyline( line, layerName, "CONTINUOUS", oc, outlineWidth );
}
}
else if ( symbolName == "rectangle" )
{
QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) );
QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) );
QPointF pt3( t.map( QPointF( -halfWidth, halfHeight ) ) );
QPointF pt4( t.map( QPointF( halfWidth, halfHeight ) ) );
if ( mBrush.style() != Qt::NoBrush )
e.writeSolid( layerName, fc, pt1, pt2, pt3, pt4 );
QgsPolyline line( 5 );
line[0] = pt1;
line[1] = pt2;
line[2] = pt3;
line[3] = pt4;
line[4] = pt1;
if ( mPen.style() != Qt::NoPen )
e.writePolyline( line, layerName, "CONTINUOUS", oc, outlineWidth );
return true;
}
else if ( symbolName == "cross" && mPen.style() != Qt::NoPen )
{
QgsPolyline line1( 2 );
QPointF pt1( t.map( QPointF( -halfWidth, 0 ) ) );
QPointF pt2( t.map( QPointF( halfWidth, 0 ) ) );
line1[0] = pt1;
line1[1] = pt2;
e.writePolyline( line1, layerName, "CONTINUOUS", oc, outlineWidth );
QgsPolyline line2( 2 );
QPointF pt3( t.map( QPointF( 0, halfHeight ) ) );
QPointF pt4( t.map( QPointF( 0, -halfHeight ) ) );
line2[0] = pt3;
line2[1] = pt4;
e.writePolyline( line2, layerName, "CONTINUOUS", oc, outlineWidth );
return true;
}
else if ( symbolName == "triangle" )
{
QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) );
QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) );
QPointF pt3( t.map( QPointF( 0, halfHeight ) ) );
QPointF pt4( t.map( QPointF( 0, halfHeight ) ) );
if ( mBrush.style() != Qt::NoBrush )
e.writeSolid( layerName, fc, pt1, pt2, pt3, pt4 );
if ( mPen.style() != Qt::NoPen )
{
QgsPolyline line( 4 );
line[0] = pt1;
line[1] = pt2;
line[2] = pt3;
line[3] = pt4;
e.writePolyline( line, layerName, "CONTINUOUS", oc, outlineWidth );
}
return true;
}
return false; //soon...
}
virtual void draw(GiGraphics& gs, const Matrix2d& w2d) const {
Point2d pt3(pt1 * w2d);
Point2d pt4(pt2 * w2d);
gs.getCanvas()->drawLine(pt3.x, pt3.y, pt4.x, pt4.y);
}
int main( int nArgc, char ** papszArgv )
{
// register drivers
GDALAllRegister();
if( nArgc < 2 )
return EXIT_FAILURE;
double dfaCornersX[5] = {0};
double dfaCornersY[5] = {0};
CPLString sFileName;
// parse input values
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-nw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[1] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[1] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-ne"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[2] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[2] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-se"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[3] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[3] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-sw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[4] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[4] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-c"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[0] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[0] = CPLAtofM(pszCoord);
}
else if(sFileName.empty())
sFileName = papszArgv[iArg];
}
OGRSpatialReference oOGRSpatialReference(SRS_WKT_WGS84);
int nZoneNo = ceil( (180.0 + dfaCornersX[0]) / 6.0 );
OGRSpatialReference oDstSpatialReference(SRS_WKT_WGS84);
oDstSpatialReference.SetUTM(nZoneNo, dfaCornersY[0] > 0);
// transform coordinates from WGS84 to UTM
OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( &oOGRSpatialReference, &oDstSpatialReference);
if(!poCT)
{
Usage("get coordinate transformation failed");
return EXIT_FAILURE;
}
int nResult = poCT->Transform(5, dfaCornersX, dfaCornersY, NULL);
if(!nResult)
{
Usage("transformation failed");
return EXIT_FAILURE;
}
// open input dataset
GDALDataset *poSrcDataset = (GDALDataset *) GDALOpen( sFileName, GA_ReadOnly ); // GA_Update
char* pszSpaRefDef = NULL;
if( oDstSpatialReference.exportToWkt(&pszSpaRefDef) != OGRERR_NONE)
{
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
return EXIT_FAILURE;
}
// search point along image
// add GCP to opened raster
OGRPoint ptCenter(dfaCornersX[0], dfaCornersY[0]);
OGRPoint pt1(dfaCornersX[1], dfaCornersY[1]); // NW Cormer
OGRPoint pt2(dfaCornersX[2], dfaCornersY[2]); // NE Corner
OGRPoint pt3(dfaCornersX[3], dfaCornersY[3]); // SE Corner
OGRPoint pt4(dfaCornersX[4], dfaCornersY[4]); // SW Corner
int nGCPCount = 0;
OGREnvelope DstEnv;
GDAL_GCP *paGSPs = PrepareGCP(sFileName, &pt1, &pt2, &pt3, &pt4, &ptCenter, oDstSpatialReference, poSrcDataset->GetRasterXSize(), poSrcDataset->GetRasterYSize(), nGCPCount, DstEnv);
if(poSrcDataset->SetGCPs(nGCPCount, paGSPs, pszSpaRefDef) != CE_None)
{
Usage( "Set GCPs failed" );
return EXIT_FAILURE;
}
// create warper
char **papszTO = NULL;
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
papszTO = CSLSetNameValue( papszTO, "NUM_THREADS", "4" );
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "INSERT_CENTER_LONG", "FALSE" );
GDALDriver *poOutputDriver = (GDALDriver *) GDALGetDriverByName( "GTiff" );
CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" );
void* hTransformArg = GDALCreateGenImgProjTransformer2( poSrcDataset, NULL, papszTO );
GDALTransformerInfo* psInfo = (GDALTransformerInfo*)hTransformArg;
double adfThisGeoTransform[6];
double adfExtent[4];
int nThisPixels, nThisLines;
// suggest the raster output size
if( GDALSuggestedWarpOutput2( poSrcDataset, psInfo->pfnTransform, hTransformArg, adfThisGeoTransform, &nThisPixels, &nThisLines, adfExtent, 0 ) != CE_None )
{
Usage( "Suggest Output failed" );
return EXIT_FAILURE;
}
adfThisGeoTransform[0] = DstEnv.MinX;
adfThisGeoTransform[3] = DstEnv.MaxY;
int nPixels = (int) ((DstEnv.MaxX - DstEnv.MinX) / adfThisGeoTransform[1] + 0.5);
int nLines = (int) ((DstEnv.MaxY - DstEnv.MinY) / -adfThisGeoTransform[5] + 0.5);
GDALSetGenImgProjTransformerDstGeoTransform( hTransformArg, adfThisGeoTransform);
// create new raster
CPLString sOutputRasterPath = CPLResetExtension(sFileName, "tif");
GDALDataset *poDstDataset = poOutputDriver->Create(sOutputRasterPath, nPixels, nLines, poSrcDataset->GetRasterCount(), GDT_Byte, NULL );
if( NULL == poDstDataset )
{
Usage( "Create Output failed" );
return EXIT_FAILURE;
}
poDstDataset->SetProjection( pszSpaRefDef );
poDstDataset->SetGeoTransform( adfThisGeoTransform );
#ifdef APRROX_MAXERROR
hTransformArg = GDALCreateApproxTransformer( GDALGenImgProjTransform, hTransformArg, APRROX_MAXERROR);
GDALTransformerFunc pfnTransformer = GDALApproxTransform;
GDALApproxTransformerOwnsSubtransformer(hTransformArg, TRUE);
#else
GDALTransformerFunc pfnTransformer = GDALGenImgProjTransform;
#endif // APRROX_MAXERROR
// warp
GDALWarpOptions *psWO = GDALCreateWarpOptions();
psWO->eWorkingDataType = GDT_Byte;
psWO->eResampleAlg = GRA_NearestNeighbour;
psWO->hSrcDS = poSrcDataset;
psWO->hDstDS = poDstDataset;
psWO->pfnTransformer = pfnTransformer;
psWO->pTransformerArg = hTransformArg;
psWO->pfnProgress = GDALTermProgress;
psWO->nBandCount = poSrcDataset->GetRasterCount();
psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
for(int i = 0; i < psWO->nBandCount; ++i )
{
psWO->panSrcBands[i] = i+1;
psWO->panDstBands[i] = i+1;
}
GDALWarpOperation oWO;
if( oWO.Initialize( psWO ) == CE_None )
{
#ifdef MULTI
if( oWO.ChunkAndWarpMulti( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#else //MULTI
if( oWO.ChunkAndWarpImage( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#endif //MULTI
{
const char* err = CPLGetLastErrorMsg();
Usage( CPLSPrintf("Warp failed.%s", err) );
return EXIT_FAILURE;
}
}
// cleanup
GDALDestroyWarpOptions( psWO );
CSLDestroy( papszTO );
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
GDALClose( (GDALDatasetH) poDstDataset );
GDALDestroyDriverManager();
return EXIT_SUCCESS;
}
static gboolean
expose (GtkWidget *da, GdkEventExpose *event, gpointer user_data)
{
GdkGLContext *glcontext = gtk_widget_get_gl_context (da);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (da);
// g_print (" :: expose\n");
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
{
g_assert_not_reached ();
}
/* draw in here */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glDepthFunc(GL_GREATER); // The Type Of Depth Testing (Less Or Equal)
glEnable(GL_DEPTH_TEST);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material_diffuse);
glPushMatrix();
glRotatef (ang, 1, 0, 1);
// glRotatef (ang, 0, 1, 0);
// glRotatef (ang, 0, 0, 1);
glShadeModel(GL_SMOOTH);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
/*
glBegin (GL_LINES);
glColor3f (1., 0., 0.);
glVertex3f (0., 0., 0.);
glVertex3f (1., 0., 0.);
glEnd ();
glBegin (GL_LINES);
glColor3f (0., 1., 0.);
glVertex3f (0., 0., 0.);
glVertex3f (0., 1., 0.);
glEnd ();
glBegin (GL_LINES);
glColor3f (0., 0., 1.);
glVertex3f (0., 0., 0.);
glVertex3f (0., 0., 1.);
glEnd (); */
FreeREP::Init();
Geom_Vec3 pt1(0,0,0);
Geom_Vec3 pt2(0,1,0);
Geom_Vec3 pt3(1,1,0);
Geom_Vec3 pt4(1,0,0);
Geom_Vec3 pt5(0.5,0.5,0);
Geom_Vec3 pt6(0.5,.75,0);
Geom_Vec3 pt7(.75,.75,0);
Topo_Line *l1 = new Topo_Line(pt1,pt2);
Topo_Line *l2 = new Topo_Line(pt2,pt3);
Topo_Line *l3 = new Topo_Line(pt3,pt4);
Topo_Arc *a1 = new Topo_Arc(Geom_Ax2(pt4,Geom_Vec3(0,0,-1),Geom_Vec3(-1,0,0)),1,M_PI/2,0);
Topo_Line *l4 = new Topo_Line(pt5,pt6);
Topo_Line *l5 = new Topo_Line(pt6,pt7);
Topo_Line *l6 = new Topo_Line(pt7,pt5);
/*
Topo_Edge *e1 = new Topo_Edge();
e1->Add(l1);
e1->Add(l2);
//e1->Add(l3);
e1->Add(a1);
e1->Reverse();
Topo_Edge *e2 = new Topo_Edge();
e2->Add(l4);
e2->Add(l5);
e2->Add(l6);
*/
/*
glBegin(GL_LINE_STRIP);
e1->GetVertices(.01,vCall);
glEnd();
glBegin(GL_LINE_STRIP);
e2->GetVertices(.01,vCall);
glEnd(); */
/*
Topo_Face *face = new Topo_Face_Planar(Geom_Plane(Geom_Vec3(0,0,0),Geom_Vec3(0,0,-1)));
face->Add(e1);
face->Add(e2);*/
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_AUTO_NORMAL);
//Draw a coordinate axis on the screen
glBegin(GL_LINES);
glVertex3d(0,0,0);
glVertex3d(0,0,.5);
glVertex3d(0,0,0);
glVertex3d(0,.5,0);
glVertex3d(0,0,0);
glVertex3d(.5,0,0);
glEnd();
glPushMatrix();
glScaled(.25,.25,.25);
glPushMatrix();
glTranslated(-.5,.5,0);
t3dDraw3D("Y", 0, 0, 0.05f);
glPopMatrix();
glPushMatrix();
glTranslated(.5,-.5,0);
glRotated(90,0,0,1);
t3dDraw3D("X", 0, 0, 0.05f);
glPopMatrix();
glTranslated(-.5,0,0.5);
glRotated(90,1,0,0);
t3dDraw3D("Z", 0, 0, 0.05f);
glPopMatrix();
glBegin(GL_TRIANGLES);
//face->Triangulate(.01,vCall);
glEnd();
Topo_Face_Spheric *sphere = new Topo_Face_Spheric(Geom_Ax2(Geom_Vec3(0,0,0),Geom_Vec3(0,0,1),Geom_Vec3(1,0,0)),1);
glBegin(GL_TRIANGLES);
//sphere->Triangulate(.01,vCall);
glEnd();
Topo_Face_Toroidal *toroid = new Topo_Face_Toroidal(Geom_Ax2(Geom_Vec3(0,0,0),Geom_Vec3(0,0,1),Geom_Vec3(1,0,0)),.5,.125);
glBegin(GL_TRIANGLES);
//toroid->Triangulate(.01,vCall);
glEnd();
//Topo_Solid *solid = BrepAlgoExtrude(face,Geom_Vec3(0,0,.5));
glBegin(GL_TRIANGLES);
//solid->Triangulate(.001,vCall);
glEnd();
std::vector<Topo_Shape*> shapes = ReadIGES("Tests/Pawn.igs");// = ReadFREP("Tests/SimpleFaces.FREP");
// shapes.push_back(MakeSphere(Geom_Ax2(Geom_Vec3(0,0,0),Geom_Vec3(0,0,1),Geom_Vec3(1,0,0)),1));
// shapes.push_back(MakeSphere(Geom_Ax2(Geom_Vec3(0,0,0),Geom_Vec3(0,0,1),Geom_Vec3(1,0,0)),0.25));
// shapes.push_back(MakeCone(Geom_Ax2(Geom_Vec3(0,0,0),Geom_Vec3(0,0,1),Geom_Vec3(1,0,0)),.5,1,1));
for(int i=0; i < shapes.size(); i++)
{
ICanTriangulate *obj = dynamic_cast<ICanTriangulate*>(shapes[i]);
if(obj)
{
#ifdef DRAWFACES
glBegin(GL_TRIANGLES);
obj->Triangulate(.01,vCall);
glEnd();
#endif
#ifdef DRAWEDGES
Topo_Face *face = dynamic_cast<Topo_Face*>(shapes[i]);
if(face)
{
Topo_Edge* edge = face->GetFirstEdge();
while(edge)
{
glBegin(GL_LINE_STRIP);
edge->GetVertices(.01,dvCall);
glEnd();
edge = face->GetNextEdge();
}
}
Topo_Solid *solid = dynamic_cast<Topo_Solid*>(shapes[i]);
if(solid)
{
face = solid->GetFirstFace();
while(face)
{
Topo_Edge* edge = face->GetFirstEdge();
while(edge)
{
glBegin(GL_LINE_STRIP);
edge->GetVertices(.01,dvCall);
glEnd();
edge = face->GetNextEdge();
}
face = solid->GetNextFace();
}
}
#endif
}
else
{
Topo_Edge *edge = dynamic_cast<Topo_Edge*>(shapes[i]);
if(edge)
{
glBegin(GL_LINE_STRIP);
edge->GetVertices(.01,dvCall);
glEnd();
}
Topo_Wire *wire = dynamic_cast<Topo_Wire*>(shapes[i]);
if(wire)
{
glBegin(GL_LINE_STRIP);
wire->GetVertices(.01,dvCall);
glEnd();
}
}
}
/* Topo_Face *tface = solid->GetFirstFace();
while(tface)
{
Topo_Edge *tedge = tface->GetFirstEdge();
while(tedge)
{
glBegin(GL_LINE_STRIP);
tedge->GetVertices(.01,vCall);
glEnd();
tedge = tface->GetNextEdge();
}
tface = solid->GetNextFace();
}*/
glPopMatrix ();
if (gdk_gl_drawable_is_double_buffered (gldrawable))
gdk_gl_drawable_swap_buffers (gldrawable);
else
glFlush ();
gdk_gl_drawable_gl_end (gldrawable);
return TRUE;
}
void CFWL_CheckBoxTP::InitCheckPath(FX_FLOAT fCheckLen) {
if (!m_pCheckPath) {
m_pCheckPath.reset(new CFX_Path);
m_pCheckPath->Create();
FX_FLOAT fWidth = kSignPath;
FX_FLOAT fHeight = -kSignPath;
FX_FLOAT fBottom = kSignPath;
CFX_PointF pt1(fWidth / 15.0f, fBottom + fHeight * 2 / 5.0f);
CFX_PointF pt2(fWidth / 4.5f, fBottom + fHeight / 16.0f);
CFX_PointF pt3(fWidth / 3.0f, fBottom);
CFX_PointF pt4(fWidth * 14 / 15.0f, fBottom + fHeight * 15 / 16.0f);
CFX_PointF pt5(fWidth / 3.6f, fBottom + fHeight / 3.5f);
CFX_PointF pt12(fWidth / 7.0f, fBottom + fHeight * 2 / 7.0f);
CFX_PointF pt21(fWidth / 5.0f, fBottom + fHeight / 5.0f);
CFX_PointF pt23(fWidth / 4.4f, fBottom + fHeight * 0 / 16.0f);
CFX_PointF pt32(fWidth / 4.0f, fBottom);
CFX_PointF pt34(fWidth * (1 / 7.0f + 7 / 15.0f),
fBottom + fHeight * 4 / 5.0f);
CFX_PointF pt43(fWidth * (1 / 7.0f + 7 / 15.0f),
fBottom + fHeight * 4 / 5.0f);
CFX_PointF pt45(fWidth * 7 / 15.0f, fBottom + fHeight * 8 / 7.0f);
CFX_PointF pt54(fWidth / 3.4f, fBottom + fHeight / 3.5f);
CFX_PointF pt51(fWidth / 3.6f, fBottom + fHeight / 4.0f);
CFX_PointF pt15(fWidth / 3.5f, fBottom + fHeight * 3.5f / 5.0f);
m_pCheckPath->MoveTo(pt1.x, pt1.y);
FX_FLOAT px1 = pt12.x - pt1.x;
FX_FLOAT py1 = pt12.y - pt1.y;
FX_FLOAT px2 = pt21.x - pt2.x;
FX_FLOAT py2 = pt21.y - pt2.y;
m_pCheckPath->BezierTo(pt1.x + px1 * FX_BEZIER, pt1.y + py1 * FX_BEZIER,
pt2.x + px2 * FX_BEZIER, pt2.y + py2 * FX_BEZIER,
pt2.x, pt2.y);
px1 = pt23.x - pt2.x;
py1 = pt23.y - pt2.y;
px2 = pt32.x - pt3.x;
py2 = pt32.y - pt3.y;
m_pCheckPath->BezierTo(pt2.x + px1 * FX_BEZIER, pt2.y + py1 * FX_BEZIER,
pt3.x + px2 * FX_BEZIER, pt3.y + py2 * FX_BEZIER,
pt3.x, pt3.y);
px1 = pt34.x - pt3.x;
py1 = pt34.y - pt3.y;
px2 = pt43.x - pt4.x;
py2 = pt43.y - pt4.y;
m_pCheckPath->BezierTo(pt3.x + px1 * FX_BEZIER, pt3.y + py1 * FX_BEZIER,
pt4.x + px2 * FX_BEZIER, pt4.y + py2 * FX_BEZIER,
pt4.x, pt4.y);
px1 = pt45.x - pt4.x;
py1 = pt45.y - pt4.y;
px2 = pt54.x - pt5.x;
py2 = pt54.y - pt5.y;
m_pCheckPath->BezierTo(pt4.x + px1 * FX_BEZIER, pt4.y + py1 * FX_BEZIER,
pt5.x + px2 * FX_BEZIER, pt5.y + py2 * FX_BEZIER,
pt5.x, pt5.y);
px1 = pt51.x - pt5.x;
py1 = pt51.y - pt5.y;
px2 = pt15.x - pt1.x;
py2 = pt15.y - pt1.y;
m_pCheckPath->BezierTo(pt5.x + px1 * FX_BEZIER, pt5.y + py1 * FX_BEZIER,
pt1.x + px2 * FX_BEZIER, pt1.y + py2 * FX_BEZIER,
pt1.x, pt1.y);
FX_FLOAT fScale = fCheckLen / kSignPath;
CFX_Matrix mt;
mt.Set(1, 0, 0, 1, 0, 0);
mt.Scale(fScale, fScale);
CFX_PathData* pData = m_pCheckPath->GetPathData();
pData->Transform(&mt);
}
}
int main (int argc, char *argv[])
{
std::vector<double> punto1(1,0.0);
std::vector<double> punto2(1,1.0);
std::vector<double> punto3(1,2.0);
std::vector<double> punto4(1,3.0);
Punto<1> pt1(punto1);
Punto<1> pt2(punto2);
Punto<1> pt3(punto3);
Punto<1> pt4(punto4);
std::vector<Punto<1> >element1;
element1.push_back(pt1);
element1.push_back(pt2);
std::vector<Punto<1> >element2;
element2.push_back(pt2);
element2.push_back(pt3);
std::vector<Punto<1> >element3;
element3.push_back(pt3);
element3.push_back(pt4);
myelement<1> el1(element1);
myelement<1> el2(element2);
myelement<1> el3(element3);
std::vector<myelement<1> > raccoltael;
raccoltael.push_back(el1);
raccoltael.push_back(el2);
raccoltael.push_back(el3);
std::cout<<raccoltael.size()<<std::endl;
mymesh<myelement<1> > dominiop(raccoltael);
std::cout<<dominiop.size_element()<<std::endl;
QuadFactory::RulesFactory & rulesFactory(QuadFactory::RulesFactory::Instance());
const Quadrature1D * therule = rulesFactory.create("Trapezi");
therule->ShowMe();
NumericalQuad<1> integrale(therule,dominiop);
std::cout<<integrale.apply(&xquad)<<std::endl;
/*therule = rulesFactory.create("Simpson");
therule->ShowMe();
integrale.SetRule(therule);
std::cout<<integrale.apply(&xquad)<<std::endl;
therule = rulesFactory.create("MidPoint");
therule->ShowMe();
integrale.SetRule(therule);
std::cout<<integrale.apply(&xquad)<<std::endl;
*/
/*
MidPoint mid;
Trapezi trap;
Simpson simp;
std::vector<double> dominio;
double a = 0;
double b = 6;
double step = 0;
double value = 0;
NumericalQuad integrale;
std::ofstream file("Errori.txt");
unsigned int maxit = 15;
for(size_t i(2);i<maxit;i++)
{
dominio.resize(i+1);
step = (b-a)/i;
for(size_t k(0);k<=i;k++) dominio[k]=a+k*step;
integrale.SetDom(dominio);
integrale.SetRule(&mid);
value = integrale.apply(&xquad);
std::cout<<"Midpoint = "<<value<<std::endl;
file<<fabs(value - 6*6*6*6*6)<<'\t';
integrale.SetRule(&trap);
value = integrale.apply(&xquad);
std::cout<<"Trapezi = "<<value<<std::endl;
file<<fabs(value - 6*6*6*6*6)<<'\t';
integrale.SetRule(&simp);
value = integrale.apply(&xquad);
std::cout<<"Simpson = "<<value<<std::endl;
file<<fabs(value - 6*6*6*6*6);
file<<std::endl;
}
file.close();*/
return 0;
}
