void CSketch::ExtractSeparateSketches(std::list<HeeksObj*> &new_separate_sketches, const bool allow_individual_objects /* = false */ )
{
CSketch* re_ordered_sketch = NULL;
CSketch* sketch = this;
if(GetSketchOrder() == SketchOrderHasCircles)
{
std::list<HeeksObj*>::iterator It;
for(It=m_objects.begin(); It!=m_objects.end() ;It++)
{
HeeksObj* object = *It;
CSketch* new_object = new CSketch();
new_object->color = color;
new_object->Add(object->MakeACopy(), NULL);
new_separate_sketches.push_back(new_object);
}
}
if(GetSketchOrder() == SketchOrderTypeBad)
{
// Duplicate and reorder the sketch to see if it's possible to make separate connected sketches.
re_ordered_sketch = (CSketch*)(this->MakeACopy());
re_ordered_sketch->ReOrderSketch(SketchOrderTypeReOrder);
sketch = re_ordered_sketch;
}
if(sketch->GetSketchOrder() == SketchOrderTypeMultipleCurves)
{
// Make separate connected sketches from the child elements.
CSketchRelinker relinker(sketch->m_objects);
relinker.Do();
for(std::list< std::list<HeeksObj*> >::iterator It = relinker.m_new_lists.begin(); It != relinker.m_new_lists.end(); It++)
{
std::list<HeeksObj*>& list = *It;
CSketch* new_object = new CSketch();
new_object->color = color;
for(std::list<HeeksObj*>::iterator It2 = list.begin(); It2 != list.end(); It2++)
{
HeeksObj* object = *It2;
new_object->Add(object->MakeACopy(), NULL);
}
new_separate_sketches.push_back(new_object);
}
}
else
{
// The sketch does not seem to relink into separate connected shapes. Just export
// all the sketch's children as separate objects instead.
if (allow_individual_objects)
{
for (HeeksObj *child = sketch->GetFirstChild(); child != NULL; child = sketch->GetNextChild())
{
new_separate_sketches.push_back( child->MakeACopy() );
}
}
}
if(re_ordered_sketch)delete re_ordered_sketch;
}
void CSketch::ReverseSketch()
{
if(m_objects.size() == 0)return;
std::list<HeeksObj*> new_list;
std::list<HeeksObj*> old_list = m_objects;
for(std::list<HeeksObj*>::iterator It=m_objects.begin(); It!=m_objects.end() ;It++)
{
HeeksObj* object = *It;
HeeksObj* copy = object->MakeACopy();
ReverseObject(copy);
new_list.push_front(copy);
}
Clear();
for(std::list<HeeksObj*>::iterator It = new_list.begin(); It != new_list.end(); It++)
{
HeeksObj* object = *It;
Add(object, NULL);
}
//TODO: this is a hack. Must call remove before add, or else add has no effect. Why are we calling this here?
wxGetApp().ObserversOnChange(NULL,&old_list,NULL);
wxGetApp().ObserversOnChange(&new_list,NULL,NULL);
}
bool CSketchRelinker::AddNext()
{
// returns true, if another object was added to m_new_lists
if(m_new_back)
{
bool added = false;
// look through all of the old list, starting at m_old_front
std::list<HeeksObj*>::const_iterator It = m_old_front;
do{
It++;
if(It == m_old_list.end())It = m_old_list.begin();
HeeksObj* object = *It;
added = TryAdd(object);
}while(It != m_old_front && !added);
if(added)return true;
// nothing fits the current new list
m_new_back = NULL;
m_new_front = NULL;
if(m_old_list.size() > m_added_from_old_set.size())
{
// there are still some to add, find a unused object
for(std::list<HeeksObj*>::const_iterator It = m_old_list.begin(); It != m_old_list.end(); It++)
{
HeeksObj* object = *It;
if(m_added_from_old_set.find(object) == m_added_from_old_set.end())
{
HeeksObj* new_object = object->MakeACopy();
std::list<HeeksObj*> empty_list;
m_new_lists.push_back(empty_list);
m_new_lists.back().push_back(new_object);
m_added_from_old_set.insert(object);
m_old_front = It;
m_new_back = new_object;
m_new_front = new_object;
return true;
}
}
}
}
return false;
}
CSketch* CSketch::SplineToBiarcs(double tolerance)const
{
CSketch *new_sketch = new CSketch;
for(std::list<HeeksObj*>::const_iterator It = m_objects.begin(); It != m_objects.end(); It++)
{
HeeksObj* span = *It;
if(span->GetType() == SplineType)
{
std::list<HeeksObj*> new_spans;
((HSpline*)span)->ToBiarcs(new_spans, tolerance);
for(std::list<HeeksObj*>::iterator ItS = new_spans.begin(); ItS != new_spans.end(); ItS++)
{
new_sketch->Add(*ItS, NULL);
}
}
else
{
new_sketch->Add(span->MakeACopy(), NULL);
}
}
return new_sketch;
}
Python CWaterline::AppendTextToProgram(CMachineState *pMachineState)
{
Python python;
ReloadPointers(); // Make sure all the solids in m_solids are included as child objects.
CTool *pTool = CTool::Find(m_tool_number);
if(pTool == NULL)
{
return(python);
}
python << CDepthOp::AppendTextToProgram(pMachineState);
// write the corner radius
python << _T("corner_radius = float(");
double cr = pTool->m_params.m_corner_radius - pTool->m_params.m_flat_radius;
if(cr<0)cr = 0.0;
python << ( cr / theApp.m_program->m_units ) << _T(")\n");
heeksCAD->CreateUndoPoint();
//write stl file
std::list<HeeksObj*> solids;
for (HeeksObj *object = GetFirstChild(); object != NULL; object = GetNextChild())
{
if (object->GetType() != SolidType && object->GetType() != StlSolidType)
{
continue;
}
if (object != NULL)
{
// Need to rotate a COPY of the solid by the fixture settings.
HeeksObj* copy = object->MakeACopy();
if (copy != NULL)
{
double m[16]; // A different form of the transformation matrix.
CFixture::extract( pMachineState->Fixture().GetMatrix(CFixture::YZ), m );
copy->ModifyByMatrix(m);
CFixture::extract( pMachineState->Fixture().GetMatrix(CFixture::XZ), m );
copy->ModifyByMatrix(m);
CFixture::extract( pMachineState->Fixture().GetMatrix(CFixture::XY), m );
copy->ModifyByMatrix(m);
solids.push_back(copy);
} // End if - then
} // End if - then
} // End for
wxStandardPaths standard_paths;
wxFileName filepath( standard_paths.GetTempDir().c_str(), wxString::Format(_T("waterline%d.stl"), number_for_stl_file).c_str() );
number_for_stl_file++;
heeksCAD->SaveSTLFile(solids, filepath.GetFullPath(), m_params.m_tolerance);
// We don't need the duplicate solids any more. Delete them.
for (std::list<HeeksObj*>::iterator l_itSolid = solids.begin(); l_itSolid != solids.end(); l_itSolid++)
{
heeksCAD->Remove( *l_itSolid );
} // End for
heeksCAD->Changed();
python << _T("ocl_funcs.waterline( filepath = ") << PythonString(filepath.GetFullPath()) << _T(", ")
<< _T("tool_diameter = ") << pTool->CuttingRadius() * 2.0 << _T(", ")
<< _T("corner_radius = ") << pTool->m_params.m_corner_radius / theApp.m_program->m_units << _T(", ")
<< _T("step_over = ") << m_params.m_step_over / theApp.m_program->m_units << _T(", ")
<< _T("mat_allowance = ") << m_params.m_material_allowance / theApp.m_program->m_units << _T(", ")
<< _T("clearance = clearance, ")
<< _T("rapid_safety_space = rapid_safety_space, ")
<< _T("start_depth = start_depth, ")
<< _T("step_down = step_down, ")
<< _T("final_depth = final_depth, ")
<< _T("units = ") << theApp.m_program->m_units << _T(", ")
<< _T("x0 = ") << m_params.m_box.m_x[0] / theApp.m_program->m_units << _T(", ")
<< _T("y0 = ") << m_params.m_box.m_x[1] / theApp.m_program->m_units << _T(", ")
<< _T("x1 = ") << m_params.m_box.m_x[3] / theApp.m_program->m_units << _T(", ")
<< _T("y1 = ") << m_params.m_box.m_x[4] / theApp.m_program->m_units << _T(", ")
<< _T("tolerance = ") << m_params.m_tolerance << _T(")\n");
return(python);
}
Python CAdaptive::AppendTextToProgram(CMachineState *pMachineState )
{
Python python;
python << COp::AppendTextToProgram(pMachineState);
heeksCAD->CreateUndoPoint();
//write stl file
std::list<HeeksObj*> solids;
for(std::list<int>::iterator It = m_solids.begin(); It != m_solids.end(); It++)
{
HeeksObj* object = heeksCAD->GetIDObject(SolidType, *It);
if (object != NULL)
{
// Need to rotate a COPY of the solid by the fixture settings.
HeeksObj* copy = object->MakeACopy();
if (copy != NULL)
{
double m[16]; // A different form of the transformation matrix.
CFixture::extract( pMachineState->Fixture().GetMatrix(CFixture::YZ), m );
copy->ModifyByMatrix(m);
CFixture::extract( pMachineState->Fixture().GetMatrix(CFixture::XZ), m );
copy->ModifyByMatrix(m);
CFixture::extract( pMachineState->Fixture().GetMatrix(CFixture::XY), m );
copy->ModifyByMatrix(m);
solids.push_back(copy);
} // End if - then
} // End if - then
} // End for
// Reconfirm that our retractzheight value is sufficient.
const double small_buffer = 5.0; // Don't scrape the mountain tops.
double max_z = CAdaptive::GetMaxHeight( SolidType, m_solids );
if (m_params.m_retractzheight < (max_z + small_buffer))
{
m_params.m_retractzheight = max_z + small_buffer;
} // End if - then
max_z = CAdaptive::GetMaxHeight( SketchType, m_sketches );
if (m_params.m_boundaryclear < max_z) m_params.m_boundaryclear = max_z;
wxStandardPaths standard_paths;
wxFileName filepath;
filepath.Assign( standard_paths.GetTempDir().c_str(), wxString::Format(_T("adaptive%d.stl"), number_for_stl_file).c_str() );
number_for_stl_file++;
heeksCAD->SaveSTLFile(solids, filepath.GetFullPath());
// We don't need the duplicate solids any more. Delete them.
for (std::list<HeeksObj*>::iterator l_itSolid = solids.begin(); l_itSolid != solids.end(); l_itSolid++)
{
heeksCAD->Remove( *l_itSolid );
} // End for
python << _T("rapid(z=") << m_params.m_retractzheight << _T(")\n");
gp_Pnt start = pMachineState->Fixture().Adjustment( gp_Pnt( m_params.m_startpoint_x, m_params.m_startpoint_y, m_params.m_retractzheight ) );
python << _T("rapid(x=") << start.X() << _T(", y=") << start.Y() << _T(")\n");
python << _T("actp.setleadoffdz(") << m_params.m_leadoffdz << _T(")\n");
python << _T("actp.setleadofflen(") << m_params.m_leadofflen << _T(")\n");
python << _T("actp.setleadoffrad(") << m_params.m_leadoffrad << _T(")\n");
python << _T("actp.setretractzheight(") << m_params.m_retractzheight << _T(")\n");
python << _T("actp.setleadoffsamplestep(") << m_params.m_leadoffsamplestep << _T(")\n");
if ((((COp *)this)->m_tool_number > 0) &&
(CTool::FindTool( ((COp *)this)->m_tool_number ) > 0) )
{
// We have a tool to refer to. Get these values from there instead.
CTool *pTool = (CTool *) CTool::Find( ((COp *)this)->m_tool_number );
if (pTool != NULL)
{
python << _T("actp.settoolcornerrad(") << pTool->m_params.m_corner_radius << _T(")\n");
python << _T("actp.settoolflatrad(") << pTool->m_params.m_flat_radius << _T(")\n");
} // End if - then
} // End if - then
else
{
// This object has values and/or we don't have a tool number to refer to.
// Use these values instead.
python << _T("actp.settoolcornerrad(") << m_params.m_toolcornerrad << _T(")\n");
python << _T("actp.settoolflatrad(") << m_params.m_toolflatrad << _T(")\n");
} // End if - else
python << _T("actp.setsamplestep(") << m_params.m_samplestep << _T(")\n");
python << _T("actp.setstepdown(") << m_params.m_stepdown << _T(")\n");
python << _T("actp.setclearcuspheight(") << m_params.m_clearcuspheight << _T(")\n");
python << _T("actp.settriangleweaveres(") << m_params.m_triangleweaveres << _T(")\n");
python << _T("actp.setflatradweaveres(") << m_params.m_flatradweaveres << _T(")\n");
python << _T("actp.setdchangright(") << m_params.m_dchangright << _T(")\n");
python << _T("actp.setdchangrightoncontour(") << m_params.m_dchangrightoncontour << _T(")\n");
python << _T("actp.setdchangleft(") << m_params.m_dchangleft << _T(")\n");
python << _T("actp.setdchangefreespace(") << m_params.m_dchangefreespace << _T(")\n");
python << _T("actp.setsidecutdisplch(") << m_params.m_sidecutdisplch << _T(")\n");
python << _T("actp.setfcut(") << m_params.m_fcut << _T(")\n");
python << _T("actp.setfretract(") << m_params.m_fretract << _T(")\n");
python << _T("actp.setthintol(") << m_params.m_thintol << _T(")\n");
python << _T("actp.setstartpoint(") << start.X() << _T(", ") << start.Y() << _T(", ") << m_params.m_startvel_x << _T(", ") << m_params.m_startvel_y << _T(")\n");
python << _T("actp.setminz(") << m_params.m_minz << _T(")\n");
python << _T("actp.boundaryclear(") << m_params.m_boundaryclear << _T(")\n");
if(!m_sketches.empty())
{
std::list<HeeksObj*> sketches;
for(std::list<int>::iterator It = m_sketches.begin(); It != m_sketches.end(); It++)
{
HeeksObj* sketch = heeksCAD->GetIDObject(SketchType, *It);
if(sketch){
for(HeeksObj* span_object = sketch->GetFirstChild(); span_object; span_object = sketch->GetNextChild())
{
double s[3] = {0, 0, 0};
double e[3] = {0, 0, 0};
if(span_object){
int type = span_object->GetType();
//TODO: add support for arcs
if(type == LineType)
{
span_object->GetStartPoint(s);
pMachineState->Fixture().Adjustment(s);
span_object->GetEndPoint(e);
pMachineState->Fixture().Adjustment(e);
python << _T("actp.boundaryadd(") << s[0] << _T(", ") << s[1] << _T(")\n");
python << _T("actp.boundaryadd(") << e[0] << _T(", ") << e[1] << _T(")\n");
}
}
}
}
python << _T("actp.boundarybreak()\n");
}
}
else
{
gp_Pnt boundary[2];
boundary[0] = pMachineState->Fixture().Adjustment( gp_Pnt( m_params.m_boundary_x0, m_params.m_boundary_y0, 0.0 ) );
boundary[1] = pMachineState->Fixture().Adjustment( gp_Pnt( m_params.m_boundary_x1, m_params.m_boundary_y1, 0.0 ) );
python << _T("actp.boundaryadd(") << boundary[0].X() << _T(", ") << boundary[0].Y() << _T(")\n");
python << _T("actp.boundaryadd(") << boundary[0].X() << _T(", ") << boundary[1].Y() << _T(")\n");
python << _T("actp.boundaryadd(") << boundary[1].X() << _T(", ") << boundary[1].Y() << _T(")\n");
python << _T("actp.boundaryadd(") << boundary[1].X() << _T(", ") << boundary[0].Y() << _T(")\n");
python << _T("actp.boundarybreak()\n");
}
python << _T("actp_funcs.cut(") << PythonString(filepath.GetFullPath()) << _T(")\n");
python << _T("rapid(z=") << m_params.m_retractzheight << _T(")\n");
return(python);
}
Python CProfile::AppendTextToProgram(bool finishing_pass)
{
Python python;
CTool *pTool = CTool::Find( m_tool_number );
if (pTool == NULL)
{
if(!finishing_pass) wxMessageBox(_("Cannot generate G-Code for profile without a tool assigned"));
return(python);
} // End if - then
if(!finishing_pass || m_profile_params.m_only_finishing_pass)
{
python << CSketchOp::AppendTextToProgram();
if(m_profile_params.m_auto_roll_on || m_profile_params.m_auto_roll_off)
{
python << _T("roll_radius = float(");
python << m_profile_params.m_auto_roll_radius / theApp.m_program->m_units;
python << _T(")\n");
}
}
if(finishing_pass)
{
python << _T("feedrate_hv(") << m_profile_params.m_finishing_h_feed_rate / theApp.m_program->m_units << _T(", ");
python << m_speed_op_params.m_vertical_feed_rate / theApp.m_program->m_units << _T(")\n");
python << _T("flush_nc()\n");
python << _T("offset_extra = 0.0\n");
python << _T("depthparams.step_down = ") << m_profile_params.m_finishing_step_down << _T("\n");
python << _T("depthparams.z_finish_depth = 0.0\n");
}
else
{
python << _T("offset_extra = ") << m_profile_params.m_offset_extra / theApp.m_program->m_units << _T("\n");
}
CProfileParams::eCutMode cut_mode = finishing_pass ? m_profile_params.m_finishing_cut_mode : m_profile_params.m_cut_mode;
HeeksObj* object = heeksCAD->GetIDObject(SketchType, m_sketch);
if(object)
{
HeeksObj* sketch_to_be_deleted = NULL;
if(object->GetType() == AreaType)
{
object = heeksCAD->NewSketchFromArea(object);
sketch_to_be_deleted = object;
}
if(object->GetType() == SketchType)
{
HeeksObj* re_ordered_sketch = NULL;
SketchOrderType sketch_order = heeksCAD->GetSketchOrder(object);
if(sketch_order == SketchOrderTypeBad)
{
re_ordered_sketch = object->MakeACopy();
heeksCAD->ReOrderSketch(re_ordered_sketch, SketchOrderTypeReOrder);
object = re_ordered_sketch;
}
if(sketch_order == SketchOrderTypeMultipleCurves || sketch_order == SketchOrderHasCircles)
{
std::list<HeeksObj*> new_separate_sketches;
heeksCAD->ExtractSeparateSketches(object, new_separate_sketches, false);
for(std::list<HeeksObj*>::iterator It = new_separate_sketches.begin(); It != new_separate_sketches.end(); It++)
{
HeeksObj* one_curve_sketch = *It;
python << AppendTextForSketch(one_curve_sketch, cut_mode).c_str();
delete one_curve_sketch;
}
}
else
{
python << AppendTextForSketch(object, cut_mode).c_str();
}
if(re_ordered_sketch)
{
delete re_ordered_sketch;
}
}
else
{
python << AppendTextForSketch(object, cut_mode).c_str();
}
delete sketch_to_be_deleted;
}
return python;
} // End AppendTextToProgram() method
Python CProfile::WriteSketchDefn(HeeksObj* sketch, bool reversed )
{
// write the python code for the sketch
Python python;
if ((sketch->GetShortString() != NULL) && (wxString(sketch->GetShortString()).size() > 0))
{
python << (wxString::Format(_T("comment(%s)\n"), PythonString(sketch->GetShortString()).c_str()));
}
python << _T("curve = area.Curve()\n");
bool started = false;
std::list<HeeksObj*> spans;
switch(sketch->GetType())
{
case SketchType:
for(HeeksObj* span_object = sketch->GetFirstChild(); span_object; span_object = sketch->GetNextChild())
{
if(reversed)spans.push_front(span_object);
else spans.push_back(span_object);
}
break;
case CircleType:
spans.push_back(sketch);
break;
case AreaType:
break;
}
std::list<HeeksObj*> new_spans;
for(std::list<HeeksObj*>::iterator It = spans.begin(); It != spans.end(); It++)
{
HeeksObj* span = *It;
if(span->GetType() == SplineType)
{
std::list<HeeksObj*> new_spans2;
heeksCAD->SplineToBiarcs(span, new_spans2, CProfile::max_deviation_for_spline_to_arc);
if(reversed)
{
for(std::list<HeeksObj*>::reverse_iterator It2 = new_spans2.rbegin(); It2 != new_spans2.rend(); It2++)
{
HeeksObj* s = *It2;
new_spans.push_back(s);
}
}
else
{
for(std::list<HeeksObj*>::iterator It2 = new_spans2.begin(); It2 != new_spans2.end(); It2++)
{
HeeksObj* s = *It2;
new_spans.push_back(s);
}
}
}
else
{
new_spans.push_back(span->MakeACopy());
}
}
for(std::list<HeeksObj*>::iterator It = new_spans.begin(); It != new_spans.end(); It++)
{
HeeksObj* span_object = *It;
double s[3] = {0, 0, 0};
double e[3] = {0, 0, 0};
double c[3] = {0, 0, 0};
if(span_object){
int type = span_object->GetType();
if(type == LineType || type == ArcType || type == CircleType)
{
if(!started && type != CircleType)
{
if(reversed)span_object->GetEndPoint(s);
else span_object->GetStartPoint(s);
CNCPoint start(s);
python << _T("curve.append(area.Point(");
python << start.X(true);
python << _T(", ");
python << start.Y(true);
python << _T("))\n");
started = true;
}
if(reversed)span_object->GetStartPoint(e);
else span_object->GetEndPoint(e);
CNCPoint end(e);
if(type == LineType)
{
python << _T("curve.append(area.Point(");
python << end.X(true);
python << _T(", ");
python << end.Y(true);
python << _T("))\n");
}
else if(type == ArcType)
{
span_object->GetCentrePoint(c);
CNCPoint centre(c);
double pos[3];
heeksCAD->GetArcAxis(span_object, pos);
int span_type = ((pos[2] >=0) != reversed) ? 1: -1;
python << _T("curve.append(area.Vertex(");
python << (span_type);
python << (_T(", area.Point("));
python << end.X(true);
python << (_T(", "));
python << end.Y(true);
python << (_T("), area.Point("));
python << centre.X(true);
python << (_T(", "));
python << centre.Y(true);
python << (_T(")))\n"));
}
else if(type == CircleType)
{
std::list< std::pair<int, gp_Pnt > > points;
span_object->GetCentrePoint(c);
double radius = heeksCAD->CircleGetRadius(span_object);
// Setup the four arcs to make up the full circle using UNadjusted
// coordinates. We do this so that the offsets are expressed along the
// X and Y axes. We will adjust the resultant points later.
// The kurve code needs a start point first.
points.push_back( std::make_pair(0, gp_Pnt( c[0], c[1] + radius, c[2] )) ); // north
if(reversed)
{
points.push_back( std::make_pair(1, gp_Pnt( c[0] - radius, c[1], c[2] )) ); // west
points.push_back( std::make_pair(1, gp_Pnt( c[0], c[1] - radius, c[2] )) ); // south
points.push_back( std::make_pair(1, gp_Pnt( c[0] + radius, c[1], c[2] )) ); // east
points.push_back( std::make_pair(1, gp_Pnt( c[0], c[1] + radius, c[2] )) ); // north
}
else
{
points.push_back( std::make_pair(-1, gp_Pnt( c[0] + radius, c[1], c[2] )) ); // east
points.push_back( std::make_pair(-1, gp_Pnt( c[0], c[1] - radius, c[2] )) ); // south
points.push_back( std::make_pair(-1, gp_Pnt( c[0] - radius, c[1], c[2] )) ); // west
points.push_back( std::make_pair(-1, gp_Pnt( c[0], c[1] + radius, c[2] )) ); // north
}
CNCPoint centre(c);
for (std::list< std::pair<int, gp_Pnt > >::iterator l_itPoint = points.begin(); l_itPoint != points.end(); l_itPoint++)
{
CNCPoint pnt( l_itPoint->second );
python << (_T("curve.append(area.Vertex("));
python << l_itPoint->first << _T(", area.Point(");
python << pnt.X(true);
python << (_T(", "));
python << pnt.Y(true);
python << (_T("), area.Point("));
python << centre.X(true);
python << (_T(", "));
python << centre.Y(true);
python << (_T(")))\n"));
} // End for
}
}
}
}
// delete the spans made
for(std::list<HeeksObj*>::iterator It = new_spans.begin(); It != new_spans.end(); It++)
{
HeeksObj* span = *It;
delete span;
}
python << _T("\n");
if(m_profile_params.m_start_given || m_profile_params.m_end_given)
{
double startx, starty, finishx, finishy;
wxString start_string;
if(m_profile_params.m_start_given)
{
#ifdef UNICODE
std::wostringstream ss;
#else
std::ostringstream ss;
#endif
gp_Pnt starting(m_profile_params.m_start[0] / theApp.m_program->m_units,
m_profile_params.m_start[1] / theApp.m_program->m_units,
0.0 );
startx = starting.X();
starty = starting.Y();
ss.imbue(std::locale("C"));
ss<<std::setprecision(10);
ss << ", start = area.Point(" << startx << ", " << starty << ")";
start_string = ss.str().c_str();
}
wxString finish_string;
wxString beyond_string;
if(m_profile_params.m_end_given)
{
#ifdef UNICODE
std::wostringstream ss;
#else
std::ostringstream ss;
#endif
gp_Pnt finish(m_profile_params.m_end[0] / theApp.m_program->m_units,
m_profile_params.m_end[1] / theApp.m_program->m_units,
0.0 );
finishx = finish.X();
finishy = finish.Y();
ss.imbue(std::locale("C"));
ss<<std::setprecision(10);
ss << ", finish = area.Point(" << finishx << ", " << finishy << ")";
finish_string = ss.str().c_str();
if(m_profile_params.m_end_beyond_full_profile)beyond_string = _T(", end_beyond = True");
}
python << (wxString::Format(_T("kurve_funcs.make_smaller( curve%s%s%s)\n"), start_string.c_str(), finish_string.c_str(), beyond_string.c_str())).c_str();
}
return(python);
}
Python CPocket::AppendTextToProgram()
{
Python python;
CTool *pTool = CTool::Find( m_tool_number );
if (pTool == NULL)
{
wxMessageBox(_T("Cannot generate GCode for pocket without a tool assigned"));
return python;
} // End if - then
python << CSketchOp::AppendTextToProgram();
HeeksObj* object = wxGetApp().GetIDObject(SketchType, m_sketch);
if(object == NULL) {
wxMessageBox(wxString::Format(_("Pocket operation - Sketch doesn't exist")));
return python;
}
int type = object->GetType();
// do areas and circles first, separately
{
switch(type)
{
case CircleType:
case AreaType:
{
wxGetApp().ObjectAreaString(object, python);
WritePocketPython(python);
}
break;
}
}
if(type == SketchType)
{
python << _T("a = area.Area()\n");
python << _T("entry_moves = []\n");
if (object->GetNumChildren() == 0){
wxMessageBox(wxString::Format(_("Pocket operation - Sketch %d has no children"), object->GetID()));
return python;
}
HeeksObj* re_ordered_sketch = NULL;
SketchOrderType order = ((CSketch*)object)->GetSketchOrder();
if( (order != SketchOrderTypeCloseCW) &&
(order != SketchOrderTypeCloseCCW) &&
(order != SketchOrderTypeMultipleCurves) &&
(order != SketchOrderHasCircles))
{
re_ordered_sketch = object->MakeACopy();
((CSketch*)re_ordered_sketch)->ReOrderSketch(SketchOrderTypeReOrder);
object = re_ordered_sketch;
order = ((CSketch*)object)->GetSketchOrder();
if( (order != SketchOrderTypeCloseCW) &&
(order != SketchOrderTypeCloseCCW) &&
(order != SketchOrderTypeMultipleCurves) &&
(order != SketchOrderHasCircles))
{
switch (((CSketch*)object)->GetSketchOrder())
{
case SketchOrderTypeOpen:
{
wxMessageBox(wxString::Format(_("Pocket operation - Sketch must be a closed shape - sketch %d"), object->m_id));
delete re_ordered_sketch;
return python;
}
break;
default:
{
wxMessageBox(wxString::Format(_("Pocket operation - Badly ordered sketch - sketch %d"), object->m_id));
delete re_ordered_sketch;
return python;
}
break;
}
}
}
if(object)
{
python << WriteSketchDefn(object);
}
if(re_ordered_sketch)
{
delete re_ordered_sketch;
}
} // End for
// reorder the area, the outside curves must be made anti-clockwise and the insides clockwise
python << _T("a.Reorder()\n");
WritePocketPython(python);
return python;
}
static wxString WriteSketchDefn(HeeksObj* sketch)
{
#ifdef UNICODE
std::wostringstream gcode;
#else
std::ostringstream gcode;
#endif
gcode.imbue(std::locale("C"));
gcode << std::setprecision(10);
bool started = false;
double prev_e[3];
std::list<HeeksObj*> new_spans;
for(HeeksObj* span = sketch->GetFirstChild(); span; span = sketch->GetNextChild())
{
if(span->GetType() == SplineType)
{
((HSpline*)span)->ToBiarcs(new_spans, CPocket::max_deviation_for_spline_to_arc);
}
else
{
new_spans.push_back(span->MakeACopy());
}
}
for(std::list<HeeksObj*>::iterator It = new_spans.begin(); It != new_spans.end(); It++)
{
HeeksObj* span_object = *It;
double s[3] = {0, 0, 0};
double e[3] = {0, 0, 0};
double c[3] = {0, 0, 0};
if(span_object){
int type = span_object->GetType();
if(type == LineType || type == ArcType)
{
span_object->GetStartPoint(s);
CNCPoint start(s);
if(started && (fabs(s[0] - prev_e[0]) > 0.0001 || fabs(s[1] - prev_e[1]) > 0.0001))
{
gcode << _T("a.append(c)\n");
started = false;
}
if(!started)
{
gcode << _T("c = area.Curve()\n");
gcode << _T("c.append(area.Vertex(0, area.Point(") << start.X(true) << _T(", ") << start.Y(true) << _T("), area.Point(0, 0)))\n");
started = true;
}
span_object->GetEndPoint(e);
CNCPoint end(e);
if(type == LineType)
{
gcode << _T("c.append(area.Vertex(0, area.Point(") << end.X(true) << _T(", ") << end.Y(true) << _T("), area.Point(0, 0)))\n");
}
else if(type == ArcType)
{
span_object->GetCentrePoint(c);
CNCPoint centre(c);
double pos[3];
extract(((HArc*)span_object)->m_axis.Direction(), pos);
int span_type = (pos[2] >=0) ? 1:-1;
gcode << _T("c.append(area.Vertex(") << span_type << _T(", area.Point(") << end.X(true) << _T(", ") << end.Y(true);
gcode << _T("), area.Point(") << centre.X(true) << _T(", ") << centre.Y(true) << _T(")))\n");
}
memcpy(prev_e, e, 3*sizeof(double));
} // End if - then
else
{
if (type == CircleType)
{
if(started)
{
gcode << _T("a.append(c)\n");
started = false;
}
std::list< std::pair<int, gp_Pnt > > points;
span_object->GetCentrePoint(c);
// Setup the four arcs that will make up the circle using UNadjusted
// coordinates first so that the offsets align with the X and Y axes.
double radius = ((HCircle*)span_object)->m_radius;
points.push_back( std::make_pair(0, gp_Pnt( c[0], c[1] + radius, c[2] )) ); // north
points.push_back( std::make_pair(-1, gp_Pnt( c[0] + radius, c[1], c[2] )) ); // east
points.push_back( std::make_pair(-1, gp_Pnt( c[0], c[1] - radius, c[2] )) ); // south
points.push_back( std::make_pair(-1, gp_Pnt( c[0] - radius, c[1], c[2] )) ); // west
points.push_back( std::make_pair(-1, gp_Pnt( c[0], c[1] + radius, c[2] )) ); // north
CNCPoint centre(c);
gcode << _T("c = area.Curve()\n");
for (std::list< std::pair<int, gp_Pnt > >::iterator l_itPoint = points.begin(); l_itPoint != points.end(); l_itPoint++)
{
CNCPoint pnt( l_itPoint->second );
gcode << _T("c.append(area.Vertex(") << l_itPoint->first << _T(", area.Point(");
gcode << pnt.X(true) << (_T(", ")) << pnt.Y(true);
gcode << _T("), area.Point(") << centre.X(true) << _T(", ") << centre.Y(true) << _T(")))\n");
} // End for
gcode << _T("a.append(c)\n");
}
} // End if - else
}
}
if(started)
{
gcode << _T("a.append(c)\n");
started = false;
}
// delete the spans made
for(std::list<HeeksObj*>::iterator It = new_spans.begin(); It != new_spans.end(); It++)
{
HeeksObj* span = *It;
delete span;
}
gcode << _T("\n");
return(wxString(gcode.str().c_str()));
}
//static
void TransformTools::Translate(bool copy)
{
// pick items
if(wxGetApp().m_marked_list->size() == 0){
wxGetApp().PickObjects(_("Pick objects to move"));
}
if(wxGetApp().m_marked_list->size() == 0)return;
// get number of copies
HeeksConfig config;
int ncopies;
config.Read(_T("TranslateNumCopies"), &ncopies, 1);
if(copy)
{
// check for uncopyable objects
RemoveUncopyable();
if(wxGetApp().m_marked_list->size() == 0)return;
// input "number of copies"
if(!wxGetApp().InputInt(_("Enter number of copies"), _("number of copies"), ncopies))return;
if(ncopies < 1)return;
config.Write(_T("TranslateNumCopies"), ncopies);
}
// clear the selection
std::list<HeeksObj *> selected_items = wxGetApp().m_marked_list->list();
wxGetApp().m_marked_list->Clear(true);
// pick "from" position
if(!wxGetApp().PickPosition(_("Click position to move from"), from))return;
// pick "to" position
wxGetApp().CreateTransformGLList(selected_items, false);
wxGetApp().m_drag_matrix = gp_Trsf();
if(!copy)
{
for(std::list<HeeksObj*>::const_iterator It = selected_items.begin(); It != selected_items.end(); It++){
HeeksObj* object = *It;
if(object->m_visible)wxGetApp().m_hidden_for_drag.push_back(object);
object->m_visible = false;
}
}
double to[3];
bool move_to_accepted = wxGetApp().PickPosition(_("Click position to move to"), to, on_move_translate);
if(!copy)
{
for(std::list<HeeksObj*>::iterator It = wxGetApp().m_hidden_for_drag.begin(); It != wxGetApp().m_hidden_for_drag.end(); It++)
{
HeeksObj* object = *It;
object->m_visible = true;
}
wxGetApp().m_hidden_for_drag.clear();
}
wxGetApp().DestroyTransformGLList();
if(!move_to_accepted)return;
wxGetApp().CreateUndoPoint();
// transform the objects
if(copy)
{
for(int i = 0; i<ncopies; i++)
{
gp_Trsf mat;
mat.SetTranslationPart(make_vector(make_point(from), make_point(to)) * (i + 1));
double m[16];
extract(mat, m);
for(std::list<HeeksObj*>::iterator It = selected_items.begin(); It != selected_items.end(); It++)
{
HeeksObj* object = *It;
HeeksObj* new_object = object->MakeACopy();
#ifdef MULTIPLE_OWNERS
object->HEEKSOBJ_OWNER->Add(new_object, NULL);
#else
object->m_owner->Add(new_object, NULL);
#endif
new_object->ModifyByMatrix(m);
}
}
wxGetApp().m_marked_list->Clear(true);
}
else
{
gp_Trsf mat;
mat.SetTranslationPart(make_vector(make_point(from), make_point(to)));
double m[16];
extract(mat, m);
wxGetApp().Transform(selected_items, m);
}
wxGetApp().Changed();
}
void TransformTools::Scale(bool copy)
{
// pick items
if(wxGetApp().m_marked_list->size() == 0){
wxGetApp().PickObjects(_("Pick objects to scale"));
}
if(wxGetApp().m_marked_list->size() == 0)return;
// get number of copies
int ncopies;
HeeksConfig config;
config.Read(_T("ScaleNumCopies"), &ncopies, 1);
if(copy)
{
// check for uncopyable objects
RemoveUncopyable();
if(wxGetApp().m_marked_list->size() == 0)return;
// input "number of copies"
if(!wxGetApp().InputInt(_("Enter number of copies"), _("number of copies"), ncopies))return;
if(ncopies < 1)return;
config.Write(_T("ScaleNumCopies"), ncopies);
}
// clear the selection
std::list<HeeksObj *> selected_items = wxGetApp().m_marked_list->list();
wxGetApp().m_marked_list->Clear(true);
// pick "centre" position
if(!wxGetApp().PickPosition(_("Click centre position to scale about"), centre))return;
// enter scale factor
double scale;
config.Read(_T("ScaleFactor"), &scale, 2.0);
if(!wxGetApp().InputDouble(_("Enter scale factor"), _("scale factor"), scale))return;
config.Write(_T("ScaleFactor"), scale);
// transform the objects
wxGetApp().CreateUndoPoint();
if(copy)
{
for(int i = 0; i<ncopies; i++)
{
gp_Trsf mat;
mat.SetScale(make_point(centre), scale * (i+1));
double m[16];
extract(mat, m);
for(std::list<HeeksObj*>::iterator It = selected_items.begin(); It != selected_items.end(); It++)
{
HeeksObj* object = *It;
HeeksObj* new_object = object->MakeACopy();
#ifdef MULTIPLE_OWNERS
object->HEEKSOBJ_OWNER->Add(new_object, NULL);
#else
object->m_owner->Add(new_object, NULL);
#endif
new_object->ModifyByMatrix(m);
}
}
wxGetApp().m_marked_list->Clear(true);
}
else
{
gp_Trsf mat;
mat.SetScale(make_point(centre), scale);
double m[16];
extract(mat, m);
wxGetApp().Transform(selected_items, m);
}
wxGetApp().Changed();
}
//static
void TransformTools::Mirror(bool copy)
{
// pick items
if(wxGetApp().m_marked_list->size() == 0){
wxGetApp().PickObjects(_("Pick objects to mirror"));
}
if(wxGetApp().m_marked_list->size() == 0)return;
if(copy)
{
// check for uncopyable objects
RemoveUncopyable();
if(wxGetApp().m_marked_list->size() == 0)return;
}
// clear the selection
std::list<HeeksObj *> selected_items = wxGetApp().m_marked_list->list();
wxGetApp().m_marked_list->Clear(true);
// pick a line to mirror about
bool line_found = false;
gp_Lin line;
int save_filter = wxGetApp().m_marked_list->m_filter;
wxGetApp().PickObjects(_("Pick line to mirror about"), MARKING_FILTER_LINE | MARKING_FILTER_ILINE, true);
wxGetApp().m_marked_list->m_filter = save_filter;
for(std::list<HeeksObj *>::const_iterator It = wxGetApp().m_marked_list->list().begin(); It != wxGetApp().m_marked_list->list().end(); It++)
{
HeeksObj* object = *It;
if(object->GetType() == LineType)
{
line = ((HLine*)object)->GetLine();
line_found = true;
}
else if(object->GetType() == ILineType)
{
line = ((HILine*)object)->GetLine();
line_found = true;
}
}
if(!line_found)return;
// transform the objects
wxGetApp().CreateUndoPoint();
gp_Trsf mat;
mat.SetMirror(gp_Ax1(line.Location(), line.Direction()));
double m[16];
extract(mat, m);
if(copy)
{
for(std::list<HeeksObj*>::iterator It = selected_items.begin(); It != selected_items.end(); It++)
{
HeeksObj* object = *It;
HeeksObj* new_object = object->MakeACopy();
#ifdef MULTIPLE_OWNERS
object->HEEKSOBJ_OWNER->Add(new_object, NULL);
#else
object->m_owner->Add(new_object, NULL);
#endif
new_object->ModifyByMatrix(m);
}
wxGetApp().m_marked_list->Clear(true);
}
else
{
wxGetApp().Transform(selected_items, m);
}
wxGetApp().Changed();
}
//static
void TransformTools::Rotate(bool copy)
{
//rotation axis - Z axis by default
gp_Dir axis_Dir = gp_Dir(0,0,1);
gp_Pnt line_Pos = gp_Pnt(0,0,0);
// pick items
if(wxGetApp().m_marked_list->size() == 0){
wxGetApp().PickObjects(_("Pick objects to rotate"));
}
if(wxGetApp().m_marked_list->size() == 0)return;
// get number of copies
HeeksConfig config;
int ncopies;
config.Read(_T("RotateNumCopies"), &ncopies, 1);
if(copy)
{
// check for uncopyable objects
RemoveUncopyable();
if(wxGetApp().m_marked_list->size() == 0)return;
}
// clear the selection
std::list<HeeksObj *> selected_items = wxGetApp().m_marked_list->list();
wxGetApp().m_marked_list->Clear(true);
double angle;
config.Read(_T("RotateAngle"), &angle, 90.0);
// enter angle, plane and position
double axis[3];
double pos[3];
config.Read(_T("RotateAxisX"), &axis[0], 0.0);
config.Read(_T("RotateAxisY"), &axis[1], 0.0);
config.Read(_T("RotateAxisZ"), &axis[2], 1.0);
config.Read(_T("RotatePosX"), &pos[0], 0.0);
config.Read(_T("RotatePosY"), &pos[1], 0.0);
config.Read(_T("RotatePosZ"), &pos[2], 0.0);
double axial_shift;
config.Read(_T("RotateAxialShift"), &axial_shift, 0.0);
if(!wxGetApp().InputAngleWithPlane(angle, axis, pos, copy ? &ncopies : NULL, &axial_shift))return;
if(copy)
{
if(ncopies < 1)return;
config.Write(_T("RotateNumCopies"), ncopies);
}
config.Write(_T("RotateAngle"), angle);
config.Write(_T("RotateAxialShift"), axial_shift);
config.Write(_T("RotateAxisX"), axis[0]);
config.Write(_T("RotateAxisY"), axis[1]);
config.Write(_T("RotateAxisZ"), axis[2]);
config.Write(_T("RotatePosX"), pos[0]);
config.Write(_T("RotatePosY"), pos[1]);
config.Write(_T("RotatePosZ"), pos[2]);
axis_Dir = gp_Dir(axis[0], axis[1], axis[2]);
line_Pos = gp_Pnt(pos[0], pos[1], pos[2]);
// transform the objects
wxGetApp().CreateUndoPoint();
if(copy)
{
for(int i = 0; i<ncopies; i++)
{
gp_Trsf mat;
mat.SetRotation(gp_Ax1(line_Pos, axis_Dir), angle * M_PI/180 * (i+1));
gp_Trsf tmat;
tmat.SetTranslation(gp_Vec(axis_Dir.XYZ() * (axial_shift * ((double)(i+1)) / ncopies)));
mat = tmat * mat;
double m[16];
extract(mat, m);
for(std::list<HeeksObj*>::iterator It = selected_items.begin(); It != selected_items.end(); It++)
{
HeeksObj* object = *It;
HeeksObj* new_object = object->MakeACopy();
new_object->ModifyByMatrix(m); // Rotate the duplicate object.
#ifdef MULTIPLE_OWNERS
object->HEEKSOBJ_OWNER->Add(new_object, NULL); // And add it to this object's owner
#else
object->m_owner->Add(new_object, NULL); // And add it to this object's owner
#endif
}
}
wxGetApp().m_marked_list->Clear(true);
}
else
{
gp_Trsf mat;
mat.SetRotation(gp_Ax1(line_Pos, axis_Dir), angle * M_PI/180);
gp_Trsf tmat;
tmat.SetTranslation(gp_Vec(axis_Dir.XYZ() * axial_shift));
mat = tmat * mat;
double m[16];
extract(mat, m);
wxGetApp().Transform(selected_items, m);
}
wxGetApp().Changed();
}
Python CProfile::AppendTextToProgram(CMachineState *pMachineState, bool finishing_pass)
{
Python python;
CTool *pTool = CTool::Find( m_tool_number );
if (pTool == NULL)
{
if(!finishing_pass)wxMessageBox(_T("Cannot generate GCode for profile without a tool assigned"));
return(python);
} // End if - then
if(!finishing_pass || m_profile_params.m_only_finishing_pass)
{
python << CDepthOp::AppendTextToProgram(pMachineState);
if(m_profile_params.m_auto_roll_on || m_profile_params.m_auto_roll_off)
{
python << _T("roll_radius = float(");
python << m_profile_params.m_auto_roll_radius / theApp.m_program->m_units;
python << _T(")\n");
}
}
if(finishing_pass)
{
python << _T("feedrate_hv(") << m_profile_params.m_finishing_h_feed_rate / theApp.m_program->m_units << _T(", ");
python << m_speed_op_params.m_vertical_feed_rate / theApp.m_program->m_units << _T(")\n");
python << _T("flush_nc()\n");
python << _T("offset_extra = 0.0\n");
python << _T("step_down = ") << m_profile_params.m_finishing_step_down << _T("\n");
}
else
{
python << _T("offset_extra = ") << m_profile_params.m_offset_extra / theApp.m_program->m_units << _T("\n");
}
CProfileParams::eCutMode cut_mode = finishing_pass ? m_profile_params.m_finishing_cut_mode : m_profile_params.m_cut_mode;
#ifdef OP_SKETCHES_AS_CHILDREN
for(std::list<HeeksObj*>::iterator It = m_objects.begin(); It != m_objects.end(); It++)
{
// write a kurve definition
HeeksObj* object = *It;
if((object == NULL) || (object->GetType() != SketchType) || (object->GetNumChildren() == 0))continue;
#else
for (std::list<int>::iterator It = m_sketches.begin(); It != m_sketches.end(); It++)
{
HeeksObj* object = heeksCAD->GetIDObject(SketchType, *It);
if((object == NULL) || (object->GetNumChildren() == 0))continue;
#endif
HeeksObj* re_ordered_sketch = NULL;
SketchOrderType sketch_order = heeksCAD->GetSketchOrder(object);
if(sketch_order == SketchOrderTypeBad)
{
re_ordered_sketch = object->MakeACopy();
heeksCAD->ReOrderSketch(re_ordered_sketch, SketchOrderTypeReOrder);
object = re_ordered_sketch;
}
if(sketch_order == SketchOrderTypeMultipleCurves || sketch_order == SketchOrderHasCircles)
{
std::list<HeeksObj*> new_separate_sketches;
heeksCAD->ExtractSeparateSketches(object, new_separate_sketches, false);
for(std::list<HeeksObj*>::iterator It = new_separate_sketches.begin(); It != new_separate_sketches.end(); It++)
{
HeeksObj* one_curve_sketch = *It;
python << AppendTextForOneSketch(one_curve_sketch, pMachineState, cut_mode).c_str();
delete one_curve_sketch;
}
}
else
{
python << AppendTextForOneSketch(object, pMachineState, cut_mode).c_str();
}
if(re_ordered_sketch)
{
delete re_ordered_sketch;
}
}
return python;
} // End AppendTextToProgram() method
static unsigned char cross16[32] = {0x80, 0x01, 0x40, 0x02, 0x20, 0x04, 0x10, 0x08, 0x08, 0x10, 0x04, 0x20, 0x02, 0x40, 0x01, 0x80, 0x01, 0x80, 0x02, 0x40, 0x04, 0x20, 0x08, 0x10, 0x10, 0x08, 0x20, 0x04, 0x40, 0x02, 0x80, 0x01};
void CProfile::glCommands(bool select, bool marked, bool no_color)
{
CDepthOp::glCommands(select, marked, no_color);
if(marked && !no_color)
{
if(GetNumSketches() == 1)
{
// draw roll on point
if(!m_profile_params.m_auto_roll_on)
{
glColor3ub(0, 200, 200);
glRasterPos3dv(m_profile_params.m_roll_on_point);
glBitmap(16, 16, 8, 8, 10.0, 0.0, cross16);
}
// draw roll off point
if(!m_profile_params.m_auto_roll_on)
{
glColor3ub(255, 128, 0);
glRasterPos3dv(m_profile_params.m_roll_off_point);
glBitmap(16, 16, 8, 8, 10.0, 0.0, cross16);
}
// draw start point
if(m_profile_params.m_start_given)
{
glColor3ub(128, 0, 255);
glRasterPos3dv(m_profile_params.m_start);
glBitmap(16, 16, 8, 8, 10.0, 0.0, cross16);
}
// draw end point
if(m_profile_params.m_end_given)
{
glColor3ub(200, 200, 0);
glRasterPos3dv(m_profile_params.m_end);
glBitmap(16, 16, 8, 8, 10.0, 0.0, cross16);
}
}
}
}