示例#1
0
Polygon_2 remove_collinear(const Polygon_2& p, Number_type epsilon)
{
  static log4cplus::Logger logger = log4cplus::Logger::getInstance("polygon_utils.remove_collinear");

  LOG4CPLUS_TRACE(logger, pp(p));

  if (!p.is_simple()) {
    stringstream ss;
    ss << "Polygon is not simple in remove_collinear: " << pp(p);
    throw logic_error(ss.str());
  }

  Polygon_2::Vertex_circulator start = p.vertices_circulator();
  Polygon_2::Vertex_circulator c = start;
  Polygon_2::Vertex_circulator n = c;
  Polygon_2::Vertex_circulator prev = c;
  ++n;
  --prev;
  Polygon_2 newp;
  do
  {
    Triangle_2 t(*prev, *c, *n);
    Number_type a = abs(t.area());
    if (a > epsilon)
//     if (!CGAL::collinear(*prev, *c, *n))
      newp.push_back(*c);
    else
      LOG4CPLUS_TRACE(logger, "Removing collinearity at " << pp(*c) << " area = " << a);
    ++prev;
    ++c;
    ++n;
  } while (c != start);

  return newp;
}
示例#2
0
Polygon_2 xz_swap_neg(const Polygon_2& p)
{
  Polygon_2 ret;
  for (Polygon_2::Vertex_iterator it = p.vertices_begin(); it != p.vertices_end(); ++it)
    ret.push_back(xz_swap_neg(*it));
  return ret;
}
示例#3
0
void split_nonsimple(const Polygon_2& P, Out_iter out)
{
  static log4cplus::Logger logger = log4cplus::Logger::getInstance("split_nonsimple");
  
  typedef CGAL::Direction_2<Kernel> Direction_2;
  typedef CGAL::Vector_2<Kernel> Vector_2;

  std::set<Segment_2> segments;
  segments.insert(P.edges_begin(), P.edges_end());
  
  // Compute the subsegments, such that there are no interior pairwise
  // intersections between subsegments.
  std::list<Segment_2> subsegments_list;
  CGAL::compute_subcurves(segments.begin(), segments.end(), back_inserter(subsegments_list));

  // Index the subsegments by their source and target points.
  std::map<Point_2, set<Segment_2> > source2sub, target2sub;
  std::set<Segment_2> subsegments;
  BOOST_FOREACH (Segment_2 s, subsegments_list) {
    // if (segments.find(s.opposite()) != segments.end()) {
    //   s = s.opposite();
    // }
    subsegments.insert(s);

    source2sub[s.source()].insert(s);
    target2sub[s.target()].insert(s);
  }
示例#4
0
bool do_intersect(const Polygon_2& P, const Polygon_2& Q)
{
//   return CGAL::do_intersect(P, Q);
  if (boundaries_intersect(P, Q, true))
    return true;
  return P.has_on_positive_side(Q[0]) || Q.has_on_positive_side(P[0]);
}
示例#5
0
文件: offset.cpp 项目: amutu/SFCGAL
/**
 * @brief approximate an Offset_polygon_2 (filter null segments)
 */
Polygon_2 approximate( const Offset_polygon_2 & polygon, const int & n = 0 ){
	std::list<std::pair<double, double> > pair_list;

	/*
	 * iterate X_monotone_curve_2 components
	 */
	for ( Offset_polygon_2::Curve_const_iterator it = polygon.curves_begin();
			it != polygon.curves_end(); ++it ){
		it->approximate(std::back_inserter(pair_list), n ) ;
	}

	// remove duplicated last point
	pair_list.pop_back() ;

	/*
	 * convertr to polygon
	 */
	Polygon_2 result ;

	bool isFirst = true ;
	Kernel::Point_2 last ;
	for ( std::list<std::pair<double, double> >::const_iterator it = pair_list.begin(); it != pair_list.end(); ++it ){
		Kernel::Point_2 point( it->first, it->second ) ;
		if ( isFirst ){
			isFirst = false ;
		}else if ( point == last ){
			continue ;
		}
		result.push_back( point ) ;
		last = point ;
	}
	return result ;
}
//Sill function to make a polygon type.There are more intricate checks and functions that can be used with the ploygon
//class but for now it is simply an intermediate or unecessary step.
Polygon_2 PathPlanner::makePoly(Points points){
	Polygon_2 poly;
	for (int i =0 ; i < points.size(); i++){
		poly.push_back(points[i]);	
	}
	return poly;
}
示例#7
0
void minkowskiSum( const LineString& gA, const Polygon_2& gB, Polygon_set_2& polygonSet )
{
    if ( gA.isEmpty() ) {
        return ;
    }

    int npt = gA.numPoints() ;

    for ( int i = 0; i < npt - 1 ; i++ ) {
        Polygon_2 P;
        P.push_back( gA.pointN( i ).toPoint_2() );
        P.push_back( gA.pointN( i+1 ).toPoint_2() );

        //
        // We want to compute the "minkowski sum" on each segment of the line string
        // This is not very well defined. But it appears CGAL supports it.
        // However we must use the explicit "full convolution" method for that particular case in CGAL >= 4.7
#if CGAL_VERSION_NR < 1040701000 // version 4.7
        Polygon_with_holes_2 part = minkowski_sum_2( P, gB );
#else
        Polygon_with_holes_2 part = minkowski_sum_by_full_convolution_2( P, gB );
#endif

        // merge into a polygon set
        if ( polygonSet.is_empty() ) {
            polygonSet.insert( part );
        }
        else {
            polygonSet.join( part );
        }
    }
}
示例#8
0
void mapdraw()
{


    VisiLibity::Point pt1;
    //pt1=VisiLibity::Point(160.0f,180.0f);
    pt1=guest1.pos;
    pt1.snap_to_boundary_of(mapEnv);
    pt1.snap_to_vertices_of(mapEnv);

    visiPoly=VisiLibity::Visibility_Polygon(pt1,mapEnv,0.00001);

    Polygon_2 CGALvp;
    for (int j=0;j<visiPoly.n();j++){
            CGALvp.push_back(Point_2(visiPoly[j].x(),visiPoly[j].y()));
        };

 //   CGAL::difference(mapEnvOB,holeCGAL,std::back_inserter(mapEnvOB));


    Polygon_2 visRange=ngon(20,150.0);
    Pwh_list_2 intR;
    CGAL::intersection(CGALvp,visRange,std::back_inserter(intR));
    visiBounded=intR.front();

    tess = gluNewTess();
    gluTessCallback (tess, GLU_TESS_BEGIN, (GLvoid (CALLBACK *)())tcbBegin);
    gluTessCallback (tess, GLU_TESS_VERTEX, (GLvoid (CALLBACK *)())tcbVertex);
    gluTessCallback (tess, GLU_TESS_END, (GLvoid (CALLBACK *)())tcbEnd);

};
示例#9
0
bool boundaries_intersect(const Polygon_2& P, const Polygon_2& Q, bool proper)
{
  std::list<Segment_2> segments0, segments1;
  segments0.insert(segments0.end(), P.edges_begin(), P.edges_end());
  segments1.insert(segments1.end(), Q.edges_begin(), Q.edges_end());
  
  bool intersects = has_intersection(segments0.begin(), segments0.end(), 
			  segments1.begin(), segments1.end(), 
			  true, true);
  if (!intersects || !proper)
    return intersects;

  if (has_intersection(segments0.begin(), segments0.end(), 
		       segments1.begin(), segments1.end(), 
		       false, false))
    return true;

  typedef Polygon_2::Vertex_const_iterator Iter;
  for (Iter it = P.vertices_begin(); it != P.vertices_end(); ++it) {
    if (Q.has_on_bounded_side(*it))
      return true;
  }
  for (Iter it = Q.vertices_begin(); it != Q.vertices_end(); ++it) {
    if (P.has_on_bounded_side(*it))
      return true;
  }
  return false;
}
示例#10
0
int main(int argc, char** argv)
{
    //Reading polygon files
    Polygon_2 poly;
    QPolygonF poly_qt;
    read_file("models/turtle_w.txt", poly, poly_qt);

    //Compute straight skeleton
    //*****This program now works for polygon WITHOUT HOLES.
    SsPtr iss = CGAL::create_interior_straight_skeleton_2(poly.vertices_begin(), poly.vertices_end());
    SsPtr ess = CGAL::create_exterior_straight_skeleton_2(EMaxOffset, poly);

    //Constructing the graph combining the straight skeleton and polygon
    std::vector<BridgingGraph> bg;
    construct_bridging_graph(poly, *iss, *ess, bg);

    //Compute perpendiculars
    std::list<Perpendiculars> ppd;
    generate_perpendiculars(*iss, *ess, bg, ppd);
    deduplicate_perpendiculars<K>(ppd);

    //Assign mountain and valley
    std::list<Segment> mt;
    std::list<Segment> vl;
    MountainValley<K>(*iss, *ess, bg, ppd,  mt, vl);

    //Extracts skeleton from cgal and converts them to qt
    std::list<QLineF> bis_qt;
    convert_straight_skeleton(*iss, bis_qt);
    convert_straight_skeleton(*ess, bis_qt);

    std::list<QLineF> ppd_qt;
    convert_perpendiculars<K>(ppd, ppd_qt);

    std::list<QLineF> mt_qt, vl_qt;
    convert_mountain_valley<K>(mt, mt_qt);
    convert_mountain_valley<K>(vl, vl_qt);

    //SETUP QT
    //Create applicaiton
    QApplication app(argc, argv);

    //Create scene
    QGraphicsScene scene;
    createQTscene(scene, poly_qt, bis_qt, ppd_qt, mt_qt, vl_qt);

    //Create view
    QGraphicsView* view = new QGraphicsView(&scene);
    CGAL::Qt::GraphicsViewNavigation nav;
    view->installEventFilter(&nav);
    view->viewport()->installEventFilter(&nav);
    view->setRenderHint(QPainter::Antialiasing);
    //view->keyPressEvent();

    //Show view
    view->show();

    return app.exec();
}
Polygon_2 PathPlanner::convertPoints2Poly(Points in){
	Polygon_2 poly;
	for (int i = 0; i < in.size(); ++i)
	{
		poly.push_back(in[i]);
	}
	return poly;
}
示例#12
0
Point_2 centroid(const Polygon_2& P)
{
  Point_2 sum(0,0);
  BOOST_FOREACH (const Point_2& p, make_pair(P.vertices_begin(), P.vertices_end())) {
    sum = Point_2(sum.x() + p.x(), sum.y() + p.y());
  }
  return Point_2(sum.x()/P.size(), sum.y()/P.size());
}
示例#13
0
vector<Polygon_2> CPEllipse::all_render_vertices() const
{
  Polygon_2 points;
  for (int i = 0; i < 64; ++i) {
    points.push_back(_e(i/64.0));
  }
  vector<Polygon_2> ret;
  ret.push_back(points);
  return ret;
}
示例#14
0
文件: main.cpp 项目: Ezio47/SFCGAL
void insert_polygon( CDT& cdt, const Polygon_2& polygon ) {
	if (polygon.is_empty())
		return;
	CDT::Vertex_handle v_prev = cdt.insert( *CGAL::cpp0x::prev( polygon.vertices_end() ) );
	for (Polygon_2::Vertex_iterator vit = polygon.vertices_begin(); vit != polygon.vertices_end(); ++vit) {
		CDT::Vertex_handle vh = cdt.insert(*vit);
		cdt.insert_constraint(vh, v_prev);
		v_prev = vh;
	}
}
示例#15
0
void gnuplot_print_polygon(std::ostream& out, const Polygon_2& P, int z)
{
    int prec = out.precision();
    out << std::setprecision(pp_precision);
    Polygon_2::Vertex_const_iterator  vit;
    for (vit = P.vertices_begin(); vit != P.vertices_end(); ++vit)
        out << *vit << " " << z << std::endl;
    out << *(P.vertices_begin()) << " " << z << std::endl;
    out.precision(prec);
}
示例#16
0
void gnuplot_print_polygon(std::ostream& out, const Polygon_2& P)
{
    int prec = out.precision();
    out << std::setprecision(pp_precision);
    Polygon_2::Vertex_const_iterator  vit;
    for (vit = P.vertices_begin(); vit != P.vertices_end(); ++vit)
        vit->insert(out) << std::endl;//" " << vit->z() << std::endl;
    P.vertices_begin()->insert(out) << std::endl;//" " << P.vertices_begin()->z() << std::endl;
    out.precision(prec);
}
示例#17
0
bool intersects_boundary(const Polygon_2& P, const Segment_2& s, bool end_internal, bool end_end)
{
  std::list<Segment_2> segments0, segments1;
  segments0.insert(segments0.end(), P.edges_begin(), P.edges_end());
  segments1.push_back(s);
  
  return has_intersection(segments0.begin(), segments0.end(), 
			  segments1.begin(), segments1.end(), 
			  end_internal, end_end);
}
//Ohhh gosh. uhmm. gee what does this do?
Point_2 PathPlanner::getCentroid(Polygon_2 poly){	
	long double totalX =0;
	long double totalY =0;
	for (int i =0 ; i < poly.size(); i ++){
		totalX += poly[i].x();
		totalY += poly[i].y();
	}
	Point_2 centroid( (totalX/poly.size()) , (totalY/poly.size()) );
	return centroid;
}
Polygon_2 CollisionDetector::flip(const Polygon_2& robot)
{
	m_translate_helper.resize(0);
	for(int i = 0; i < robot.size(); ++i)
	{
		Vector_2 minus_p = CGAL::ORIGIN - robot.vertex(i);
		m_translate_helper.push_back(Point_2(minus_p.x(),minus_p.y()));
	}
	return Polygon_2(m_translate_helper.begin(), m_translate_helper.end());
}
示例#20
0
Polygon_2 ngon(int n, float r)
{
    Polygon_2 p;

    for (int i=0;i<n;i++)
    {       float PI=std::atan(1.0f)*4.0f;
            p.push_back(Point_2(r*cos(2*PI/n*i)+guest1.pos.x(),r*sin(2*PI/n*i)+guest1.pos.y()));
    }
    return p;
}
示例#21
0
/**
 \brief Generates a vector of polygons from a vector of segments
 \details First separes the segments in different adjacent groups (that would be the polygons). Then generates a polygon from each of the lists
 \param segments an std::vector<Segment> with CGAL segment_2
 \param &polygons INOUT A std::vector<Polygon_2> with CGAL Polygon_2
*/
void segments_to_polygons(std::vector<Segment> segments, std::vector< Polygon_2 > &polygons) {

    Segment cs;
    bool found = false;
    int pid = 0; //polygon id (possible alpha shape with different polygons)
    int count = 0;
    std::vector<Segment> osegments [255]; //initialize at 255. not more
    std::vector<Segment> segments_tmp;

    for(int i = 0; i < segments.size(); i++) {
        segments_tmp.push_back(segments[i]);
    }

    //push a first segment
    osegments[pid].push_back(segments_tmp.back());
    segments_tmp.pop_back(); //remove the element

    while(segments_tmp.size() > 0) {
        cs = osegments[pid].back();
        found = false;

        for(std::vector<Segment>::iterator it = segments_tmp.begin();
                !found && it != segments_tmp.end();
                ++it) {

            if (cs.target() == it->source()) {
                found = true;
                osegments[pid].push_back(*it);
                segments_tmp.erase(it);
            }
        }

        if (!found) {
            /*if not found. I assume that there is another polygon.
              Increase polygon id (pid) and keep going.
            */
            ++pid;
            osegments[pid].push_back(segments_tmp.back());
            segments_tmp.pop_back();
        }
    }

    for(int i=0; i<255; i++) {
        if(osegments[i].size()==0) break;
        Polygon_2 P;
        std::vector<Segment>::iterator it = osegments[i].begin();
        P.push_back(it->source()); //first point

        for(std::vector<Segment>::iterator it = osegments[i].begin(); it != osegments[i].end(); ++it) {
            P.push_back(it->target());
        }
        P.push_back(P[0]);
        polygons.push_back(P);
    }
}
int main()
{
  Polygon_2 outer ;
  
  outer.push_back( Point(-1,-1) ) ;
  outer.push_back( Point(0,-12) ) ;
  outer.push_back( Point(1,-1) ) ;
  outer.push_back( Point(12,0) ) ;
  outer.push_back( Point(1,1) ) ;
  outer.push_back( Point(0,12) ) ;
  outer.push_back( Point(-1,1) ) ;
  outer.push_back( Point(-12,0) ) ;
  
  Polygon_2 hole ;
  
  hole.push_back( Point(-1,0) ) ;
  hole.push_back( Point(0,1 ) ) ;
  hole.push_back( Point(1,0 ) ) ;
  hole.push_back( Point(0,-1) ) ;
    
  Polygon_with_holes poly( outer ) ;
  
  poly.add_hole( hole ) ;
     
  SsPtr iss = CGAL::create_interior_straight_skeleton_2(poly);
  
  print_straight_skeleton(*iss);
  
  return 0;
}
示例#23
0
list<Polygon_with_holes_2> CPEllipse::render_vertices() const
{
  Polygon_2 points;
  for (int i = 0; i < 64; ++i) {
    points.push_back(_e(i/64.0));
  }
  Polygon_with_holes_2 pwh(points);
  list<Polygon_with_holes_2> ret;
  ret.push_back(pwh);
  return ret;
}
示例#24
0
VisiLibity::Polygon ConvertPolygonCGAL2Vis(Polygon_2 pgn)
{
    VisiLibity::Polygon cPoly;
    Polygon_2::Vertex_iterator cv ;
    for (cv=pgn.vertices_begin();cv!=pgn.vertices_end();++cv)
          {
              cPoly.push_back(VisiLibity::Point(cv->x(),cv->y()));
          };
    return cPoly;

}
示例#25
0
std::string pp(const Polygon_2& P)
{
    Polygon_2::Vertex_const_iterator vit;
    std::stringstream out;
    out << std::setprecision(pp_precision);

    out << "[ " << P.size() << " vertices:";
    for (vit = P.vertices_begin(); vit != P.vertices_end(); ++vit)
        out << pp(*vit);
    out << " ]";
    return out.str();
}
void main()
{
	if ( DEBUG )
	{
		debug_func();
		return;
	}

	Polygon_2 poly;

	int numOfPoints;
	double x,y;
	std::fstream myfile;
	myfile.open ("out.txt");
	myfile >> numOfPoints;

	std::vector<int> rArray(numOfPoints);
	int r;

	for (int i=0; i<numOfPoints; ++i)
	{
		  myfile >> x >> y >> r;
		  poly.push_back( Point_2(x,y) );
		  rArray [i] = r;
	 }

	myfile.close();

	Shor shor;
	shor.load_polygon (poly);
	shor.load_rArray (rArray);
	shor.play();
	shor.build_triangulation();
	shor.simplify_triangulation();

	std::ofstream out("outC.txt");
    std::streambuf *coutbuf = std::cout.rdbuf(); //save old buf
	std::cout.rdbuf(out.rdbuf()); //redirect std::cout to out.txt!

	for ( int i = 0 , len = (int)shor.triangulated.size(); i < len ; ++i )
	{
		std::cout  << shor.triangulated[i][0][0] << " " << shor.triangulated[i][0][1] <<std::endl;

		std::cout  << shor.triangulated[i][1][0] << " " << shor.triangulated[i][1][1] <<std::endl;
														
		std::cout  << shor.triangulated[i][2][0] << " " << shor.triangulated[i][2][1] <<std::endl;

	}

	
	//system("pause");

}
示例#27
0
bool is_vertical(const Polygon_2& p)
{
  for (int i = 0; i < p.size() - 1; ++i)
    for (int j = i+1; j < p.size(); ++j)
      if (xy_equal(p[i], p[j]))
	return true;
//   for (int i = 0; i < p.size() - 2; ++i)
//     if (!collinear(p[i], p[i+1], p[i+2]))
//       return false;
//   return true;
  return false;
}
示例#28
0
/**
* Checks if plg2 is inside plg1
*/
bool is_inside(Polygon_2 plg1, Polygon_2 plg2) {
    bool ishole = true;
    for (std::vector<Point>::iterator v2 = plg2.vertices_begin();
            v2 != plg2.vertices_end();
            ++v2) {
        if(! check_inside(*v2, plg1, K())) {
            ishole = false;
            break; //stop checking
        }
    }
    return ishole;
}
示例#29
0
//-----------------------------------------------------------------------------
bool Polygon::inside(dolfin::Point p) const
{
  typedef CGAL::Cartesian<double> K;
  typedef CGAL::Point_2<K> Point_2;
  typedef CGAL::Polygon_2<K> Polygon_2;

  Polygon_2 polygon;
  for (const dolfin::Point& vertex : _vertices)
    polygon.push_back(Point_2(vertex.x(), vertex.y()));

  return polygon.has_on_bounded_side(Point_2(p.x(), p.y()));
}
示例#30
0
Polygon_set_2 join(Array polygons){
	vector<Polygon_2> polygon_vector;
	for (unsigned int i = 0; i < polygons.size(); i++) {
		Polygon_2 polygon = from_ruby<Polygon_2>(polygons[i]);
		if (polygon.is_simple()) {
			polygon_vector.push_back(polygon);
		}
	}
	Polygon_set_2 S;
	S.join(polygon_vector.begin(), polygon_vector.end());
	return S;
}