/** Change tools (if necessary) and assign any private fixtures. */ Python COp::AppendTextToProgram(CMachineState *pMachineState ) { Python python; if(m_comment.Len() > 0) { python << _T("comment(") << PythonString(m_comment) << _T(")\n"); } if(UsesTool())python << MACHINE_STATE_TOOL(m_tool_number); // Select the correct tool. return(python); }
Python CAttachOp::AppendTextToProgram(CMachineState *pMachineState) { Python python; #ifdef OP_SKETCHES_AS_CHILDREN ReloadPointers(); // Make sure all the solids in m_solids are included as child objects. #endif python << COp::AppendTextToProgram(pMachineState); //write stl file std::list<HeeksObj*> solids; std::list<HeeksObj*> copies_to_delete; #ifdef OP_SKETCHES_AS_CHILDREN for (HeeksObj *object = GetFirstChild(); object != NULL; object = GetNextChild()) { if (object->GetType() != SolidType && object->GetType() != StlSolidType) { continue; } #else for (std::list<int>::iterator It = m_solids.begin(); It != m_solids.end(); It++) { HeeksObj* object = heeksCAD->GetIDObject(SolidType, *It); #endif if (object != NULL) { if(1/* to do pMachineState->Fixture().GetMatrix() == gp_Trsf()*/) { solids.push_back(object); } } // End if - then } // End for wxStandardPaths standard_paths; wxFileName filepath( standard_paths.GetTempDir().c_str(), wxString::Format(_T("surface%d.stl"), number_for_stl_file).c_str() ); number_for_stl_file++; heeksCAD->SaveSTLFile(solids, filepath.GetFullPath(), 0.01); // We don't need the duplicate solids any more. Delete them. for (std::list<HeeksObj*>::iterator l_itSolid = copies_to_delete.begin(); l_itSolid != copies_to_delete.end(); l_itSolid++) { delete *l_itSolid; } // End for python << _T("nc.attach.units = ") << theApp.m_program->m_units << _T("\n"); python << _T("nc.attach.attach_begin()\n"); python << _T("nc.nc.creator.stl = ocl_funcs.STLSurfFromFile(") << PythonString(filepath.GetFullPath()) << _T(")\n"); python << _T("nc.nc.creator.minz = ") << m_min_z << _T("\n"); python << _T("nc.nc.creator.material_allowance = ") << m_material_allowance << _T("\n"); pMachineState->m_attached_to_surface = this; return(python); } // End AppendTextToProgram() method static void on_set_tolerance(double value, HeeksObj* object){((CAttachOp*)object)->m_tolerance = value;} static void on_set_min_z(double value, HeeksObj* object){((CAttachOp*)object)->m_min_z = value;} static void on_set_material_allowance(double value, HeeksObj* object){((CAttachOp*)object)->m_material_allowance = value;} void CAttachOp::GetProperties(std::list<Property *> *list) { #ifdef OP_SKETCHES_AS_CHILDREN AddSolidsProperties(list, this); #else AddSolidsProperties(list, m_solids); #endif list->push_back(new PropertyLength(_("tolerance"), m_tolerance, this, on_set_tolerance)); list->push_back(new PropertyLength(_("minimum z"), m_min_z, this, on_set_min_z)); list->push_back(new PropertyLength(_("material allowance"), m_material_allowance, this, on_set_material_allowance)); COp::GetProperties(list); }
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 & Python::operator<<( const double value ) { wxString::operator<<(PythonString(value)); return(*this); }
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); }
/** We can see what diameter tool was used to create the pocket or contour child operation. We assume that this has already occured. We want to fit down into the slot cut by these operations as far as possible but only touching the appropriate side of the material (inside or outside). We also need to make sure we don't go too deep. If the chamfering bit is small while the endmill used to cut the profile or contour was large then we may need to limit the depth of cut. */ Python CChamfer::AppendTextForProfileChildren( CMachineState *pMachineState, const double theta, HeeksObj *child, CTool *pChamferingBit ) { Python python; unsigned int number_of_bad_sketches = 0; double tolerance = heeksCAD->GetTolerance(); double start_depth = 0.0; double final_depth = 0.0; double clearance_height = 0.0; double rapid_safety_space = 0.0; std::list<HeeksObj *> sketches; CDepthOp *pDepthOp = dynamic_cast<CDepthOp *>(child); if (pDepthOp == NULL) { start_depth = m_depth_op_params.m_start_depth; final_depth = m_depth_op_params.m_final_depth; clearance_height = m_depth_op_params.ClearanceHeight(); rapid_safety_space = m_depth_op_params.m_rapid_safety_space; if (child->GetType() == SketchType) { sketches.push_back(child); } } else { start_depth = pDepthOp->m_depth_op_params.m_start_depth; final_depth = pDepthOp->m_depth_op_params.m_final_depth; clearance_height = pDepthOp->m_depth_op_params.ClearanceHeight(); rapid_safety_space = pDepthOp->m_depth_op_params.m_rapid_safety_space; for (HeeksObj *object = child->GetFirstChild(); object != NULL; object = child->GetNextChild()) { if (object->GetType() == SketchType) { sketches.push_back(object); } } } for (std::list<HeeksObj *>::iterator itChild = sketches.begin(); itChild != sketches.end(); itChild++) { HeeksObj *object = *itChild; std::list<TopoDS_Shape> wires; if (! heeksCAD->ConvertSketchToFaceOrWire( object, wires, false)) { number_of_bad_sketches++; } // End if - then else { // The wire(s) represent the sketch objects for a tool path. if (object->GetShortString() != NULL) { wxString comment; comment << _T("Chamfering of ") << object->GetShortString(); python << _T("comment(") << PythonString(comment).c_str() << _T(")\n"); } try { for(std::list<TopoDS_Shape>::iterator It2 = wires.begin(); It2 != wires.end(); It2++) { TopoDS_Shape& wire_to_fix = *It2; ShapeFix_Wire fix; fix.Load( TopoDS::Wire(wire_to_fix) ); fix.FixReorder(); TopoDS_Shape wire = fix.Wire(); wire = pMachineState->Fixture().Adjustment(wire); BRepOffsetAPI_MakeOffset offset_wire(TopoDS::Wire(wire)); // Now generate a toolpath along this wire. std::list<double> depths = GetProfileChamferingDepths(child); for (std::list<double>::iterator itDepth = depths.begin(); itDepth != depths.end(); itDepth++) { double radius = pChamferingBit->CuttingRadius(false,fabs(*itDepth - start_depth)); // We know what offset we'd really like. See how far we can offset the shape before we start // getting cross-over of graphics. double max_offset = CInlay::FindMaxOffset( radius, TopoDS::Wire(wire), radius / 10.0 ); if (radius > max_offset) radius = max_offset; // Now move the tool slightly less than this offset so that the chamfering width is // produced. double theta = pChamferingBit->m_params.m_cutting_edge_angle / 360.0 * 2.0 * PI; radius -= this->m_params.m_chamfer_width * sin(theta); switch (child->GetType()) { case ProfileType: if (((CProfile *) child)->m_profile_params.m_tool_on_side == CProfileParams::eLeftOrOutside) radius *= +1.0; if (((CProfile *) child)->m_profile_params.m_tool_on_side == CProfileParams::eRightOrInside) radius *= -1.0; if (((CProfile *) child)->m_profile_params.m_tool_on_side == CProfileParams::eOn) radius *= +1.0; break; case ContourType: if (((CContour *) child)->m_params.m_tool_on_side == CContourParams::eLeftOrOutside) radius *= +1.0; if (((CContour *) child)->m_params.m_tool_on_side == CContourParams::eRightOrInside) radius *= -1.0; if (((CContour *) child)->m_params.m_tool_on_side == CContourParams::eOn) radius *= +1.0; break; case PocketType: radius *= -1.0; break; default: if (m_params.m_tool_on_side == CContourParams::eLeftOrOutside) radius *= +1.0; if (m_params.m_tool_on_side == CContourParams::eRightOrInside) radius *= -1.0; if (m_params.m_tool_on_side == CContourParams::eOn) radius *= +1.0; break; } // End switch TopoDS_Wire tool_path_wire(TopoDS::Wire(wire)); double offset = radius; if (offset < 0) offset *= -1.0; if (offset > tolerance) { offset_wire.Perform(radius); if (! offset_wire.IsDone()) { break; } tool_path_wire = TopoDS::Wire(offset_wire.Shape()); } if (offset > tolerance) { gp_Trsf matrix; matrix.SetTranslation( gp_Vec( gp_Pnt(0,0,0), gp_Pnt( 0,0,*itDepth))); BRepBuilderAPI_Transform transform(matrix); transform.Perform(tool_path_wire, false); // notice false as second parameter tool_path_wire = TopoDS::Wire(transform.Shape()); python << CContour::GCode( tool_path_wire, pMachineState, clearance_height, rapid_safety_space, start_depth, CContourParams::ePlunge ); } // End if - then } // End for } // End for } // End try catch (Standard_Failure & error) { (void) error; // Avoid the compiler warning. Handle_Standard_Failure e = Standard_Failure::Caught(); number_of_bad_sketches++; } // End catch } // End if - else } // End for if (pMachineState->Location().Z() < (m_depth_op_params.ClearanceHeight() / theApp.m_program->m_units)) { // Move up above workpiece to relocate to the start of the next operation. python << _T("rapid(z=") << m_depth_op_params.ClearanceHeight() / theApp.m_program->m_units << _T(")\n"); CNCPoint where(pMachineState->Location()); where.SetZ(m_depth_op_params.ClearanceHeight() / theApp.m_program->m_units); pMachineState->Location(where); } if (number_of_bad_sketches > 0) { wxString message; message << _("Failed to create contours around ") << number_of_bad_sketches << _(" sketches"); wxMessageBox(message); } return(python); }