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; }