void CCurve::ExtractSeparateCurves(const std::list<Point> &ordered_points, std::list<CCurve> &separate_curves)const { // returns separate curves for this curve split at points // the points must be in order along this curve, already, and lie on this curve const Point *prev_p = NULL; if(ordered_points.size() == 0) { separate_curves.push_back(*this); return; } CCurve current_curve; std::list<Point>::const_iterator PIt = ordered_points.begin(); Point point = *PIt; for(std::list<CVertex>::const_iterator VIt = m_vertices.begin(); VIt != m_vertices.end(); VIt++) { const CVertex& vertex = *VIt; if(prev_p)// not the first vertex { Span span(*prev_p, vertex); while((PIt != ordered_points.end()) && span.On(point)) { CVertex v(vertex); v.m_p = point; current_curve.m_vertices.push_back(v); if(current_curve.m_vertices.size() > 1)// don't add single point curves separate_curves.push_back(current_curve); // add the curve current_curve = CCurve();// make a new curve current_curve.m_vertices.push_back(v); // add it's first point PIt++; if(PIt != ordered_points.end())point = *PIt; // increment the point } // add the end of span if(current_curve.m_vertices.back().m_p != vertex.m_p) current_curve.m_vertices.push_back(vertex); } if((current_curve.m_vertices.size() == 0) || (current_curve.m_vertices.back().m_p != vertex.m_p)) { // very first vertex, start the current curve current_curve.m_vertices.push_back(vertex); } prev_p = &(vertex.m_p); } // add whatever is left if(current_curve.m_vertices.size() > 1)// don't add single point curves separate_curves.push_back(current_curve); // add the curve }
void reorder_zigs() { for(std::list<ZigZag>::iterator It = zigzag_list_for_zigs.begin(); It != zigzag_list_for_zigs.end(); It++) { ZigZag &zigzag = *It; add_reorder_zig(zigzag); } zigzag_list_for_zigs.clear(); for(std::list< std::list<ZigZag> >::iterator It = reorder_zig_list_list.begin(); It != reorder_zig_list_list.end(); It++) { std::list<ZigZag> &zigzag_list = *It; if(zigzag_list.size() == 0)continue; curve_list_for_zigs->push_back(CCurve()); for(std::list<ZigZag>::const_iterator It = zigzag_list.begin(); It != zigzag_list.end();) { const ZigZag &zigzag = *It; for(std::list<CVertex>::const_iterator It2 = zigzag.zig.m_vertices.begin(); It2 != zigzag.zig.m_vertices.end(); It2++) { if(It2 == zigzag.zig.m_vertices.begin() && It != zigzag_list.begin())continue; // only add the first vertex if doing the first zig const CVertex &v = *It2; curve_list_for_zigs->back().m_vertices.push_back(v); } It++; if(It == zigzag_list.end()) { for(std::list<CVertex>::const_iterator It2 = zigzag.zag.m_vertices.begin(); It2 != zigzag.zag.m_vertices.end(); It2++) { if(It2 == zigzag.zag.m_vertices.begin())continue; // don't add the first vertex of the zag const CVertex &v = *It2; curve_list_for_zigs->back().m_vertices.push_back(v); } } } } reorder_zig_list_list.clear(); }
void CArea::MakeOnePocketCurve(std::list<CCurve> &curve_list, const CAreaPocketParams ¶ms)const { if(CArea::m_please_abort)return; #if 0 // simple offsets with feed or rapid joins CArea area_for_feed_possible = *this; area_for_feed_possible.Offset(-params.tool_radius - 0.01); CArea a_offset = *this; std::list<CArea> arealist; recur(arealist, a_offset, params, 0); bool first = true; for(std::list<CArea>::iterator It = arealist.begin(); It != arealist.end(); It++) { CArea& area = *It; for(std::list<CCurve>::iterator It = area.m_curves.begin(); It != area.m_curves.end(); It++) { CCurve& curve = *It; if(!first) { // try to join these curves with a feed move, if possible and not too long CCurve &prev_curve = curve_list.back(); const Point &prev_p = prev_curve.m_vertices.back().m_p; const Point &next_p = curve.m_vertices.front().m_p; if(feed_possible(area_for_feed_possible, prev_p, next_p, params.tool_radius)) { // join curves prev_curve += curve; } else { curve_list.push_back(curve); } } else { curve_list.push_back(curve); } first = false; } } #else pocket_params = ¶ms; if(m_curves.size() == 0) { CArea::m_processing_done += CArea::m_single_area_processing_length; return; } CurveTree top_level(m_curves.front()); std::list<IslandAndOffset> offset_islands; for(std::list<CCurve>::const_iterator It = m_curves.begin(); It != m_curves.end(); It++) { const CCurve& c = *It; if(It != m_curves.begin()) { IslandAndOffset island_and_offset(&c); offset_islands.push_back(island_and_offset); top_level.offset_islands.push_back(&(offset_islands.back())); if(m_please_abort)return; } } MarkOverlappingOffsetIslands(offset_islands); CArea::m_processing_done += CArea::m_single_area_processing_length * 0.1; double MakeOffsets_processing_length = CArea::m_single_area_processing_length * 0.8; CArea::m_after_MakeOffsets_length = CArea::m_processing_done + MakeOffsets_processing_length; double guess_num_offsets = sqrt(GetArea(true)) * 0.5 / params.stepover; CArea::m_MakeOffsets_increment = MakeOffsets_processing_length / guess_num_offsets; top_level.MakeOffsets(); if(CArea::m_please_abort)return; CArea::m_processing_done = CArea::m_after_MakeOffsets_length; curve_list.push_back(CCurve()); CCurve& output = curve_list.back(); GetCurveItem::to_do_list.push_back(GetCurveItem(&top_level, output.m_vertices.end())); while(GetCurveItem::to_do_list.size() > 0) { GetCurveItem item = GetCurveItem::to_do_list.front(); item.GetCurve(output); GetCurveItem::to_do_list.pop_front(); } // delete curve_trees non-recursively std::list<CurveTree*> CurveTreeDestructList; for(std::list<CurveTree*>::iterator It = top_level.inners.begin(); It != top_level.inners.end(); It++) { CurveTreeDestructList.push_back(*It); } while(CurveTreeDestructList.size() > 0) { CurveTree* curve_tree = CurveTreeDestructList.front(); CurveTreeDestructList.pop_front(); for(std::list<CurveTree*>::iterator It = curve_tree->inners.begin(); It != curve_tree->inners.end(); It++) { CurveTreeDestructList.push_back(*It); } delete curve_tree; } CArea::m_processing_done += CArea::m_single_area_processing_length * 0.1; #endif }