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
}
