500055388

Build Type

github

Committed by GitHub

Commit Message

Merge 4f1b34745 into 0a2804513

Pull Request Pull Request #516: Don't crash when the outline file is empty

Run Details

4618 of 7941 branches covered (58.15%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

34 existing lines in 4 files now uncovered.

3162 of 3414 relevant lines covered (92.62%)

32398.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.41

/ngc_exporter.cpp

/*
 * This file is part of pcb2gcode.
 * 
 * Copyright (C) 2009, 2010 Patrick Birnzain <pbirnzain@users.sourceforge.net> and others
 * Copyright (C) 2010 Bernhard Kubicek <kubicek@gmx.at>
 * Copyright (C) 2013 Erik Schuster <erik@muenchen-ist-toll.de>
 * Copyright (C) 2014, 2015 Nicola Corna <nicola@corna.info>
 *
 * pcb2gcode is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * pcb2gcode is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with pcb2gcode.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "ngc_exporter.hpp"
#include "options.hpp"
#include <boost/algorithm/string.hpp>
#include "bg_operators.hpp"
#include <iostream>
using std::cerr;
using std::flush;
using std::ios_base;
using std::left;
#include <string>
using std::to_string;
using std::string;
using std::cout;
using std::endl;

#include <vector>
using std::vector;

#include <utility>
using std::pair;

#include <cmath>
using std::ceil;

#include <memory>
using std::shared_ptr;
using std::dynamic_pointer_cast;

#include <iomanip>

#include <boost/format.hpp>
using boost::format;

#include "units.hpp"

NGC_Exporter::NGC_Exporter(shared_ptr<Board> board)
    : board(board), ocodes(1), globalVars(100) {}

/******************************************************************************/
/*
 */
/******************************************************************************/
void NGC_Exporter::add_header(string header)
{
    this->header.push_back(header);
}

/******************************************************************************/
/*
 */
/******************************************************************************/
void NGC_Exporter::export_all(boost::program_options::variables_map& options)
{

    bMetricinput = options["metric"].as<bool>();      //set flag for metric input
    bMetricoutput = options["metricoutput"].as<bool>();      //set flag for metric output
    bZchangeG53 = options["zchange-absolute"].as<bool>();
    string outputdir = options["output-dir"].as<string>();
    
    //set imperial/metric conversion factor for output coordinates depending on metricoutput option
    cfactor = bMetricoutput ? 25.4 : 1;
    
    tileInfo = Tiling::generateTileInfo( options, board->get_height(), board->get_width() );

    for ( string layername : board->list_layers() )
    {
        if (options["zero-start"].as<bool>()) {
          xoffset = board->get_bounding_box().min_corner().x();
          yoffset = board->get_bounding_box().min_corner().y();
        } else {
          xoffset = 0;
          yoffset = 0;
        }
        xoffset -= options["x-offset"].as<Length>().asInch(bMetricinput ? 1.0/25.4 : 1);
        yoffset -= options["y-offset"].as<Length>().asInch(bMetricinput ? 1.0/25.4 : 1);
        if (layername == "back" ||
            (layername == "outline" && !workSide(options, "cut"))) {
            xoffset = -xoffset + tileInfo.boardWidth*(tileInfo.tileX-1);
            xoffset -= 2 * options["mirror-axis"].as<Length>().asInch(bMetricinput ? 1.0/25.4 : 1);
        }

        boost::optional<autoleveller> leveller = boost::none;
        if ((options["al-front"].as<bool>() && layername == "front") ||
            (options["al-back"].as<bool>() && layername == "back")) {
          leveller.emplace(options, &ocodes, &globalVars,
                           xoffset, yoffset, tileInfo);
        }

        std::stringstream option_name;
        option_name << layername << "-output";
        string of_name = build_filename(outputdir, options[option_name.str()].as<string>());
        cout << "Exporting " << layername << "... " << flush;
        export_layer(board->get_layer(layername), of_name, leveller);
        cout << "DONE." << " (Height: " << board->get_height() * cfactor
             << (bMetricoutput ? "mm" : "in") << " Width: "
             << board->get_width() * cfactor << (bMetricoutput ? "mm" : "in")
             << ")";
        if (layername == "outline")
            cout << " The board should be cut from the " << ( workSide(options, "cut") ? "FRONT" : "BACK" ) << " side. ";
        cout << endl;
    }
}

/* Assume that we start at a safe height above the first point in path.  Cut
 * around the path, handling bridges where needed.  The bridges are identified
 * by where the bridges begins.  So the bridges is from points with indecies x
 * to x+1 for each element in the bridges vector.  We can always assume that the
 * bridge segment and the segments on either side form a straight line. */
void NGC_Exporter::cutter_milling(std::ofstream& of, shared_ptr<Cutter> cutter, const linestring_type_fp& path,
                                  const vector<size_t>& bridges, const double xoffsetTot, const double yoffsetTot) {
  const unsigned int steps_num = ceil(-cutter->zwork / cutter->stepsize);

  for (unsigned int i = 0; i < steps_num; i++) {
    const double z = cutter->zwork / steps_num * (i + 1);

    /* Lift between steps if this is not the first pass and the path
       is not a closed loop. */
    if (i > 0 && path.front() != path.back()) {
      of << "G00 Z" << cutter->zsafe * cfactor << " ( retract )\n";
      of << "G00 X" << ( path.begin()->x() - xoffsetTot ) * cfactor << " Y"
         << ( path.begin()->y() - yoffsetTot ) * cfactor << " ( rapid move to begin. )\n";
    }

    of << "G01 Z" << z * cfactor << " F" << cutter->vertfeed * cfactor << " ( plunge. )\n";
    of << "G04 P0 ( dwell for no time -- G64 should not smooth over this point )\n";
    of << "G01 F" << cutter->feed * cfactor << "\n";

    auto current_bridge = bridges.cbegin();

    bool in_bridge = false;
    // Start at 1 because the caller already moved to the start.
    for (size_t current = 1; current < path.size(); current++) {
      while (current_bridge != bridges.cend() && *current_bridge < current - 1) {
        current_bridge++;
      }
      // We are now cutting to current.
      // Is this a bridge cut?
      auto is_bridge_cut = current_bridge != bridges.cend() && *current_bridge == current-1;
      if (is_bridge_cut && z < cutter->bridges_height && !in_bridge) {
        // We're about to make a bridge cut so we need to go up.
        of << "G00 Z" << cutter->bridges_height * cfactor << '\n';
        in_bridge = true;
      } else if (!is_bridge_cut && in_bridge) {
        // Now plunge back down if needed.
        of << "G01 Z" << z * cfactor << " F" << cutter->vertfeed * cfactor << '\n';
        of << "G01 F" << cutter->feed * cfactor << '\n';
        in_bridge = false;
      }

      // Now cut horizontally.
      of << "G01 X" << (path.at(current).x() - xoffsetTot) * cfactor
         << " Y"    << (path.at(current).y() - yoffsetTot) * cfactor << '\n';
    }
  }
}

void NGC_Exporter::isolation_milling(std::ofstream& of, shared_ptr<RoutingMill> mill, const linestring_type_fp& path,
                                     boost::optional<autoleveller>& leveller, const double xoffsetTot, const double yoffsetTot) {
  of << "G01 F" << mill->vertfeed * cfactor << '\n';

  if (!mill->pre_milling_gcode.empty()) {
    of << "( begin pre-milling-gcode )\n";
    of << mill->pre_milling_gcode << "\n";
    of << "( end pre-milling-gcode )\n";
  }

  const unsigned int steps_num = ceil(-mill->zwork / mill->stepsize);

  for (unsigned int i = 0; i < steps_num; i++) {
    const double z = mill->zwork / steps_num * (i + 1);
    linestring_type_fp::const_iterator iter = path.cbegin();
    of << "( Mill infeed pass " << i+1 << "/" << steps_num << " )\n";

    /* Lift between steps if this is not the first pass and the path
       is not a closed loop. */
    if (i > 0 && path.front() != path.back()) {
      of << "G00 Z" << mill->zsafe * cfactor << " ( retract )\n";
      of << "G00 X" << ( path.begin()->x() - xoffsetTot ) * cfactor << " Y"
         << ( path.begin()->y() - yoffsetTot ) * cfactor << " ( rapid move to begin. )\n";
    }

    if (leveller) {
      leveller->setLastChainPoint(point_type_fp((path.begin()->x() - xoffsetTot) * cfactor,
                                                (path.begin()->y() - yoffsetTot) * cfactor));
      of << leveller->g01Corrected(point_type_fp((path.begin()->x() - xoffsetTot) * cfactor,
                                                 (path.begin()->y() - yoffsetTot) * cfactor),
                                   z * cfactor);
    } else {
      of << "G01 Z" << z * cfactor << "\n";
    }
    of << "G04 P0 ( dwell for no time -- G64 should not smooth over this point )\n";
    of << "G01 F" << mill->feed * cfactor << '\n';
    while (iter != path.cend()) {
      if (leveller) {
        of << leveller->addChainPoint(point_type_fp((iter->x() - xoffsetTot) * cfactor,
                                                    (iter->y() - yoffsetTot) * cfactor),
                                      z * cfactor);
      } else {
        of << "G01 X" << (iter->x() - xoffsetTot) * cfactor << " Y"
           << (iter->y() - yoffsetTot) * cfactor << '\n';
      }
      ++iter;
    }
  }
  if (!mill->post_milling_gcode.empty()) {
    of << "( begin post-milling-gcode )\n";
    of << mill->post_milling_gcode << "\n";
    of << "( end post-milling-gcode )\n";
  }
}


void NGC_Exporter::export_layer(shared_ptr<Layer> layer, string of_name, boost::optional<autoleveller> leveller) {
    string layername = layer->get_name();
    shared_ptr<RoutingMill> mill = layer->get_manufacturer();
    vector<pair<coordinate_type_fp, multi_linestring_type_fp>> all_toolpaths = layer->get_toolpaths();

    if (all_toolpaths.size() < 1) {
      return; // Nothing to do.
    }

    globalVars.getUniqueCode();
    globalVars.getUniqueCode();

    // open output file
    std::ofstream of;
    of.open(of_name.c_str());

    // write header to .ngc file
    for ( string s : header )
    {
        of << "( " << s << " )\n";
    }

    if( leveller || ( tileInfo.enabled && tileInfo.software != Software::CUSTOM ) )
        of << "( Gcode for " << tileInfo.software << " )\n";
    else
        of << "( Software-independent Gcode )\n";

    of.setf(ios_base::fixed);      //write floating-point values in fixed-point notation
    of.precision(5);              //Set floating-point decimal precision

    of << "\n" << preamble;       //insert external preamble

    if (bMetricoutput) {
      of << "G94 ( Millimeters per minute feed rate. )\n"
         << "G21 ( Units == Millimeters. )\n\n";
    } else {
      of << "G94 ( Inches per minute feed rate. )\n"
         << "G20 ( Units == INCHES. )\n\n";
    }

    of << "G90 ( Absolute coordinates. )\n"
       << "G00 S" << left << mill->speed << " ( RPM spindle speed. )\n";

    if (mill->explicit_tolerance) {
      of << "G64 P" << mill->tolerance * cfactor << " ( set maximum deviation from commanded toolpath )\n";
    }

    of << "G01 F" << mill->feed * cfactor << " ( Feedrate. )\n\n";

    if (leveller) {
      leveller->prepareWorkarea(all_toolpaths);
      leveller->header(of);
    }

    shared_ptr<Cutter> cutter = dynamic_pointer_cast<Cutter>(mill);
    shared_ptr<Isolator> isolator = dynamic_pointer_cast<Isolator>(mill);

    // One list of bridges for each path.
    vector<vector<size_t>> all_bridges;
    if (cutter) {
      for (auto& path : all_toolpaths[0].second) {  // Cutter layer can only have one tool_diameter.
        auto bridges = layer->get_bridges(path);
        all_bridges.push_back(bridges);
      }
    }

    uniqueCodes main_sub_ocodes(200);
    for (size_t toolpaths_index = 0; toolpaths_index < all_toolpaths.size(); toolpaths_index++) {
      const auto& toolpaths = all_toolpaths[toolpaths_index].second;
      if (toolpaths.size() < 1) {
        continue; // Nothing to do for this mill size.
      }
      Tiling tiling(tileInfo, cfactor, main_sub_ocodes.getUniqueCode());
      if (toolpaths_index == all_toolpaths.size() - 1) {
        tiling.setGCodeEnd(string("\nG04 P0 ( dwell for no time -- G64 should not smooth over this point )\n")
                           + (bZchangeG53 ? "G53 " : "") + "G00 Z" + str( format("%.6f") % ( mill->zchange * cfactor ) ) +
                           " ( retract )\n\n" + postamble + "M5 ( Spindle off. )\nG04 P" +
                           to_string(mill->spindown_time) + "\n");
      }

      // Start the new tool.
      of << endl
         << (bZchangeG53 ? "G53 " : "") << "G00 Z" << mill->zchange * cfactor << " (Retract to tool change height)" << endl
         << "T" << toolpaths_index << endl
         << "M5      (Spindle stop.)" << endl
         << "G04 P" << mill->spindown_time << " (Wait for spindle to stop)" << endl;
      if (cutter) {
        of << "(MSG, Change tool bit to cutter diameter ";
      } else if (isolator) {
        of << "(MSG, Change tool bit to mill diameter ";
      } else {
        throw std::logic_error("Can't cast to Cutter nor Isolator.");
      }
      const auto& tool_diameter = all_toolpaths[toolpaths_index].first;
      if (bMetricoutput) {
        of << (tool_diameter * 25.4) << "mm)" << endl;
      } else {
        of << tool_diameter << "in)" << endl;
      }
      of << "M6      (Tool change.)" << endl
         << "M0      (Temporary machine stop.)" << endl
         << "M3 ( Spindle on clockwise. )" << endl
         << "G04 P" << mill->spinup_time << " (Wait for spindle to get up to speed)" << endl;

      tiling.header( of );

      for( unsigned int i = 0; i < tileInfo.forYNum; i++ ) {
        double yoffsetTot = yoffset - i * tileInfo.boardHeight;
        for( unsigned int j = 0; j < tileInfo.forXNum; j++ ) {
          double xoffsetTot = xoffset - ( i % 2 ? tileInfo.forXNum - j - 1 : j ) * tileInfo.boardWidth;

          if( tileInfo.enabled && tileInfo.software == Software::CUSTOM )
            of << "( Piece #" << j + 1 + i * tileInfo.forXNum << ", position [" << j << ";" << i << "] )\n\n";

          // contours
          for(size_t path_index = 0; path_index < toolpaths.size(); path_index++) {
            const linestring_type_fp& path = toolpaths[path_index];
            if (path.size() < 1) {
              continue; // Empty path.
            }

            // retract, move to the starting point of the next contour
            of << "G04 P0 ( dwell for no time -- G64 should not smooth over this point )\n";
            of << "G00 Z" << mill->zsafe * cfactor << " ( retract )" << endl << endl;
            of << "G00 X" << ( path.begin()->x() - xoffsetTot ) * cfactor << " Y"
               << ( path.begin()->y() - yoffsetTot ) * cfactor << " ( rapid move to begin. )\n";

            /* if we're cutting, perhaps do it in multiple steps, but do isolations just once.
             * i know this is partially repetitive, but this way it's easier to read
             */
            if (cutter) {
              cutter_milling(of, cutter, path, all_bridges[path_index], xoffsetTot, yoffsetTot);
            } else {
              isolation_milling(of, mill, path, leveller, xoffsetTot, yoffsetTot);
            }
          }
        }
      }

      tiling.footer( of );
    }
    if (leveller) {
      leveller->footer(of);
    }
    of << "M9 ( Coolant off. )" << endl
       << "M2 ( Program end. )" << endl << endl;


    of.close();
}

/******************************************************************************/
/*
 */
/******************************************************************************/
void NGC_Exporter::set_preamble(string _preamble)
{
    preamble = _preamble;
}

/******************************************************************************/
/*
 */
/******************************************************************************/
void NGC_Exporter::set_postamble(string _postamble)
{
    postamble = _postamble;
}

/* vim: set tabstop=2 : */

1	/*
2	* This file is part of pcb2gcode.
3	*
4	* Copyright (C) 2009, 2010 Patrick Birnzain <pbirnzain@users.sourceforge.net> and others
5	* Copyright (C) 2010 Bernhard Kubicek <kubicek@gmx.at>
6	* Copyright (C) 2013 Erik Schuster <erik@muenchen-ist-toll.de>
7	* Copyright (C) 2014, 2015 Nicola Corna <nicola@corna.info>
8	*
9	* pcb2gcode is free software: you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation, either version 3 of the License, or
12	* (at your option) any later version.
13	*
14	* pcb2gcode is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with pcb2gcode. If not, see <http://www.gnu.org/licenses/>.
21	*/
22
23	#include "ngc_exporter.hpp"
24	#include "options.hpp"
25	#include <boost/algorithm/string.hpp>
26	#include "bg_operators.hpp"
27	#include <iostream>
28	using std::cerr;
29	using std::flush;
30	using std::ios_base;
31	using std::left;
32	#include <string>
33	using std::to_string;
34	using std::string;
35	using std::cout;
36	using std::endl;
37
38	#include <vector>
39	using std::vector;
40
41	#include <utility>
42	using std::pair;
43
44	#include <cmath>
45	using std::ceil;
46
47	#include <memory>
48	using std::shared_ptr;
49	using std::dynamic_pointer_cast;
50
51	#include <iomanip>
52
53	#include <boost/format.hpp>
54	using boost::format;
55
56	#include "units.hpp"
57
58	NGC_Exporter::NGC_Exporter(shared_ptr<Board> board)	69✔
59	: board(board), ocodes(1), globalVars(100) {}	69✔
60
61	/******************************************************************************/
62	/*
63	*/
64	/******************************************************************************/
65	void NGC_Exporter::add_header(string header)	69✔
66	{
67	this->header.push_back(header);	69✔
68	}	69✔
69
70	/******************************************************************************/
71	/*
72	*/
73	/******************************************************************************/
74	void NGC_Exporter::export_all(boost::program_options::variables_map& options)	69✔
75	{
76
77	bMetricinput = options["metric"].as<bool>(); //set flag for metric input	138!
78	bMetricoutput = options["metricoutput"].as<bool>(); //set flag for metric output	138!
79	bZchangeG53 = options["zchange-absolute"].as<bool>();	138!
80	string outputdir = options["output-dir"].as<string>();	69!
81
82	//set imperial/metric conversion factor for output coordinates depending on metricoutput option
83	cfactor = bMetricoutput ? 25.4 : 1;	131!
84
85	tileInfo = Tiling::generateTileInfo( options, board->get_height(), board->get_width() );	69!
86
87	for ( string layername : board->list_layers() )	248!
88	{
89	if (options["zero-start"].as<bool>()) {	220!
90	xoffset = board->get_bounding_box().min_corner().x();	7✔
91	yoffset = board->get_bounding_box().min_corner().y();	7✔
92	} else {
93	xoffset = 0;	103✔
94	yoffset = 0;	103✔
95	}
96	xoffset -= options["x-offset"].as<Length>().asInch(bMetricinput ? 1.0/25.4 : 1);	330!
97	yoffset -= options["y-offset"].as<Length>().asInch(bMetricinput ? 1.0/25.4 : 1);	330!
98	if (layername == "back" \|\|	177✔
99	(layername == "outline" && !workSide(options, "cut"))) {	173!
100	xoffset = -xoffset + tileInfo.boardWidth*(tileInfo.tileX-1);	62✔
101	xoffset -= 2 * options["mirror-axis"].as<Length>().asInch(bMetricinput ? 1.0/25.4 : 1);	186!
102	}
103
104	boost::optional<autoleveller> leveller = boost::none;
105	if ((options["al-front"].as<bool>() && layername == "front") \|\|	356!
106	(options["al-back"].as<bool>() && layername == "back")) {	341!
107	leveller.emplace(options, &ocodes, &globalVars,	17!
108	xoffset, yoffset, tileInfo);	17!
109	}
110
111	std::stringstream option_name;	220!
112	option_name << layername << "-output";	110!
113	string of_name = build_filename(outputdir, options[option_name.str()].as<string>());	220!
114	cout << "Exporting " << layername << "... " << flush;
115	export_layer(board->get_layer(layername), of_name, leveller);	347!
116	cout << "DONE." << " (Height: " << board->get_height() * cfactor	110!
117	<< (bMetricoutput ? "mm" : "in") << " Width: "	213!
118	<< board->get_width() * cfactor << (bMetricoutput ? "mm" : "in")	110!
119	<< ")";	213!
120	if (layername == "outline")	110✔
121	cout << " The board should be cut from the " << ( workSide(options, "cut") ? "FRONT" : "BACK" ) << " side. ";	107!
122	cout << endl;
123	}
124	}	69✔
125
126	/* Assume that we start at a safe height above the first point in path. Cut
127	* around the path, handling bridges where needed. The bridges are identified
128	* by where the bridges begins. So the bridges is from points with indecies x
129	* to x+1 for each element in the bridges vector. We can always assume that the
130	* bridge segment and the segments on either side form a straight line. */
131	void NGC_Exporter::cutter_milling(std::ofstream& of, shared_ptr<Cutter> cutter, const linestring_type_fp& path,	108✔
132	const vector<size_t>& bridges, const double xoffsetTot, const double yoffsetTot) {
133	const unsigned int steps_num = ceil(-cutter->zwork / cutter->stepsize);	108✔
134
135	for (unsigned int i = 0; i < steps_num; i++) {	535✔
136	const double z = cutter->zwork / steps_num * (i + 1);	427✔
137
138	/* Lift between steps if this is not the first pass and the path
139	is not a closed loop. */
140	if (i > 0 && path.front() != path.back()) {	427✔
UNCOV 141	of << "G00 Z" << cutter->zsafe * cfactor << " ( retract )\n";	×
UNCOV 142	of << "G00 X" << ( path.begin()->x() - xoffsetTot ) * cfactor << " Y"	×
UNCOV 143	<< ( path.begin()->y() - yoffsetTot ) * cfactor << " ( rapid move to begin. )\n";	×
144	}
145
146	of << "G01 Z" << z * cfactor << " F" << cutter->vertfeed * cfactor << " ( plunge. )\n";	854✔
147	of << "G04 P0 ( dwell for no time -- G64 should not smooth over this point )\n";	427✔
148	of << "G01 F" << cutter->feed * cfactor << "\n";	427✔
149
150	auto current_bridge = bridges.cbegin();	427✔
151
152	bool in_bridge = false;
153	// Start at 1 because the caller already moved to the start.
154	for (size_t current = 1; current < path.size(); current++) {	32,676✔
155	while (current_bridge != bridges.cend() && *current_bridge < current - 1) {	18,787✔
156	current_bridge++;
157	}
158	// We are now cutting to current.
159	// Is this a bridge cut?
160	auto is_bridge_cut = current_bridge != bridges.cend() && *current_bridge == current-1;	15,911✔
161	if (is_bridge_cut && z < cutter->bridges_height && !in_bridge) {	2,918✔
162	// We're about to make a bridge cut so we need to go up.
163	of << "G00 Z" << cutter->bridges_height * cfactor << '\n';	2,604✔
164	in_bridge = true;
165	} else if (!is_bridge_cut && in_bridge) {	14,609✔
166	// Now plunge back down if needed.
167	of << "G01 Z" << z * cfactor << " F" << cutter->vertfeed * cfactor << '\n';	3,834✔
168	of << "G01 F" << cutter->feed * cfactor << '\n';	2,556✔
169	in_bridge = false;
170	}
171
172	// Now cut horizontally.
173	of << "G01 X" << (path.at(current).x() - xoffsetTot) * cfactor	15,911✔
174	<< " Y" << (path.at(current).y() - yoffsetTot) * cfactor << '\n';	31,822✔
175	}
176	}
177	}	108✔
178
179	void NGC_Exporter::isolation_milling(std::ofstream& of, shared_ptr<RoutingMill> mill, const linestring_type_fp& path,	1,665✔
180	boost::optional<autoleveller>& leveller, const double xoffsetTot, const double yoffsetTot) {
181	of << "G01 F" << mill->vertfeed * cfactor << '\n';	3,330✔
182
183	if (!mill->pre_milling_gcode.empty()) {	1,665✔
184	of << "( begin pre-milling-gcode )\n";	1✔
185	of << mill->pre_milling_gcode << "\n";	1✔
186	of << "( end pre-milling-gcode )\n";	1✔
187	}
188
189	const unsigned int steps_num = ceil(-mill->zwork / mill->stepsize);	1,665✔
190
191	for (unsigned int i = 0; i < steps_num; i++) {	3,367✔
192	const double z = mill->zwork / steps_num * (i + 1);	1,702✔
193	linestring_type_fp::const_iterator iter = path.cbegin();	1,702✔
194	of << "( Mill infeed pass " << i+1 << "/" << steps_num << " )\n";	1,702✔
195
196	/* Lift between steps if this is not the first pass and the path
197	is not a closed loop. */
198	if (i > 0 && path.front() != path.back()) {	1,702✔
199	of << "G00 Z" << mill->zsafe * cfactor << " ( retract )\n";	12✔
200	of << "G00 X" << ( path.begin()->x() - xoffsetTot ) * cfactor << " Y"	12✔
201	<< ( path.begin()->y() - yoffsetTot ) * cfactor << " ( rapid move to begin. )\n";	12✔
202	}
203
204	if (leveller) {	1,702✔
205	leveller->setLastChainPoint(point_type_fp((path.begin()->x() - xoffsetTot) * cfactor,	225✔
206	(path.begin()->y() - yoffsetTot) * cfactor));	225!
207	of << leveller->g01Corrected(point_type_fp((path.begin()->x() - xoffsetTot) * cfactor,	450!
208	(path.begin()->y() - yoffsetTot) * cfactor),	225!
209	z * cfactor);
210	} else {
211	of << "G01 Z" << z * cfactor << "\n";	1,477✔
212	}
213	of << "G04 P0 ( dwell for no time -- G64 should not smooth over this point )\n";	1,702✔
214	of << "G01 F" << mill->feed * cfactor << '\n';	3,404✔
215	while (iter != path.cend()) {	127,484✔
216	if (leveller) {	125,782✔
217	of << leveller->addChainPoint(point_type_fp((iter->x() - xoffsetTot) * cfactor,	24,196✔
218	(iter->y() - yoffsetTot) * cfactor),	12,098✔
219	z * cfactor);	12,098✔
220	} else {
221	of << "G01 X" << (iter->x() - xoffsetTot) * cfactor << " Y"	227,368✔
222	<< (iter->y() - yoffsetTot) * cfactor << '\n';	227,368✔
223	}
224	++iter;
225	}
226	}
227	if (!mill->post_milling_gcode.empty()) {	1,665✔
228	of << "( begin post-milling-gcode )\n";	1✔
229	of << mill->post_milling_gcode << "\n";	1✔
230	of << "( end post-milling-gcode )\n";	1✔
231	}
232	}	1,665✔
233
234
235	void NGC_Exporter::export_layer(shared_ptr<Layer> layer, string of_name, boost::optional<autoleveller> leveller) {	110✔
236	string layername = layer->get_name();
237	shared_ptr<RoutingMill> mill = layer->get_manufacturer();	110!
238	vector<pair<coordinate_type_fp, multi_linestring_type_fp>> all_toolpaths = layer->get_toolpaths();	220!
239
240	if (all_toolpaths.size() < 1) {	110!
UNCOV 241	return; // Nothing to do.	×
242	}
243
244	globalVars.getUniqueCode();
245	globalVars.getUniqueCode();
246
247	// open output file
248	std::ofstream of;	220!
249	of.open(of_name.c_str());	110!
250
251	// write header to .ngc file
252	for ( string s : header )	220✔
253	{
254	of << "( " << s << " )\n";	110!
255	}
256
257	if( leveller \|\| ( tileInfo.enabled && tileInfo.software != Software::CUSTOM ) )	110✔
258	of << "( Gcode for " << tileInfo.software << " )\n";	21!
259	else
260	of << "( Software-independent Gcode )\n";	89!
261
262	of.setf(ios_base::fixed); //write floating-point values in fixed-point notation
263	of.precision(5); //Set floating-point decimal precision
264
265	of << "\n" << preamble; //insert external preamble
266
267	if (bMetricoutput) {	110✔
268	of << "G94 ( Millimeters per minute feed rate. )\n"
269	<< "G21 ( Units == Millimeters. )\n\n";	7!
270	} else {
271	of << "G94 ( Inches per minute feed rate. )\n"
272	<< "G20 ( Units == INCHES. )\n\n";	103!
273	}
274
275	of << "G90 ( Absolute coordinates. )\n"
276	<< "G00 S" << left << mill->speed << " ( RPM spindle speed. )\n";	110!
277
278	if (mill->explicit_tolerance) {	110✔
279	of << "G64 P" << mill->tolerance * cfactor << " ( set maximum deviation from commanded toolpath )\n";	103!
280	}
281
282	of << "G01 F" << mill->feed * cfactor << " ( Feedrate. )\n\n";	110!
283
284	if (leveller) {	110✔
285	leveller->prepareWorkarea(all_toolpaths);	17!
286	leveller->header(of);	17!
287	}
288
289	shared_ptr<Cutter> cutter = dynamic_pointer_cast<Cutter>(mill);	110✔
290	shared_ptr<Isolator> isolator = dynamic_pointer_cast<Isolator>(mill);	110✔
291
292	// One list of bridges for each path.
293	vector<vector<size_t>> all_bridges;	110✔
294	if (cutter) {	110✔
295	for (auto& path : all_toolpaths[0].second) { // Cutter layer can only have one tool_diameter.	102✔
296	auto bridges = layer->get_bridges(path);	58!
297	all_bridges.push_back(bridges);	58!
298	}
299	}
300
301	uniqueCodes main_sub_ocodes(200);
302	for (size_t toolpaths_index = 0; toolpaths_index < all_toolpaths.size(); toolpaths_index++) {	344✔
303	const auto& toolpaths = all_toolpaths[toolpaths_index].second;
304	if (toolpaths.size() < 1) {	124✔
305	continue; // Nothing to do for this mill size.	2✔
306	}
307	Tiling tiling(tileInfo, cfactor, main_sub_ocodes.getUniqueCode());	122!
308	if (toolpaths_index == all_toolpaths.size() - 1) {	244✔
309	tiling.setGCodeEnd(string("\nG04 P0 ( dwell for no time -- G64 should not smooth over this point )\n")	218!
310	+ (bZchangeG53 ? "G53 " : "") + "G00 Z" + str( format("%.6f") % ( mill->zchange * cfactor ) ) +	545!
311	" ( retract )\n\n" + postamble + "M5 ( Spindle off. )\nG04 P" +	327!
312	to_string(mill->spindown_time) + "\n");	436!
313	}
314
315	// Start the new tool.
316	of << endl
317	<< (bZchangeG53 ? "G53 " : "") << "G00 Z" << mill->zchange * cfactor << " (Retract to tool change height)" << endl	363!
318	<< "T" << toolpaths_index << endl
319	<< "M5 (Spindle stop.)" << endl
320	<< "G04 P" << mill->spindown_time << " (Wait for spindle to stop)" << endl;	122!
321	if (cutter) {	122✔
322	of << "(MSG, Change tool bit to cutter diameter ";	44!
323	} else if (isolator) {	78!
324	of << "(MSG, Change tool bit to mill diameter ";	78!
325	} else {
UNCOV 326	throw std::logic_error("Can't cast to Cutter nor Isolator.");	×
327	}
328	const auto& tool_diameter = all_toolpaths[toolpaths_index].first;	122✔
329	if (bMetricoutput) {	122✔
330	of << (tool_diameter * 25.4) << "mm)" << endl;	8!
331	} else {
332	of << tool_diameter << "in)" << endl;	114!
333	}
334	of << "M6 (Tool change.)" << endl
335	<< "M0 (Temporary machine stop.)" << endl
336	<< "M3 ( Spindle on clockwise. )" << endl
337	<< "G04 P" << mill->spinup_time << " (Wait for spindle to get up to speed)" << endl;	122!
338
339	tiling.header( of );	122!
340
341	for( unsigned int i = 0; i < tileInfo.forYNum; i++ ) {	272✔
342	double yoffsetTot = yoffset - i * tileInfo.boardHeight;	150✔
343	for( unsigned int j = 0; j < tileInfo.forXNum; j++ ) {	357✔
344	double xoffsetTot = xoffset - ( i % 2 ? tileInfo.forXNum - j - 1 : j ) * tileInfo.boardWidth;	207✔
345
346	if( tileInfo.enabled && tileInfo.software == Software::CUSTOM )	207✔
347	of << "( Piece #" << j + 1 + i * tileInfo.forXNum << ", position [" << j << ";" << i << "] )\n\n";	204!
348
349	// contours
350	for(size_t path_index = 0; path_index < toolpaths.size(); path_index++) {	2,187✔
351	const linestring_type_fp& path = toolpaths[path_index];
352	if (path.size() < 1) {	1,773!
353	continue; // Empty path.
354	}
355
356	// retract, move to the starting point of the next contour
357	of << "G04 P0 ( dwell for no time -- G64 should not smooth over this point )\n";	1,773!
358	of << "G00 Z" << mill->zsafe * cfactor << " ( retract )" << endl << endl;	1,773!
359	of << "G00 X" << ( path.begin()->x() - xoffsetTot ) * cfactor << " Y"	1,773!
360	<< ( path.begin()->y() - yoffsetTot ) * cfactor << " ( rapid move to begin. )\n";	1,773!
361
362	/* if we're cutting, perhaps do it in multiple steps, but do isolations just once.
363	* i know this is partially repetitive, but this way it's easier to read
364	*/
365	if (cutter) {	1,773✔
366	cutter_milling(of, cutter, path, all_bridges[path_index], xoffsetTot, yoffsetTot);	216!
367	} else {
368	isolation_milling(of, mill, path, leveller, xoffsetTot, yoffsetTot);	3,330!
369	}
370	}
371	}
372	}
373
374	tiling.footer( of );	122!
375	}
376	if (leveller) {	110✔
377	leveller->footer(of);
378	}
379	of << "M9 ( Coolant off. )" << endl
380	<< "M2 ( Program end. )" << endl << endl;
381
382
383	of.close();	110!
384	}
385
386	/******************************************************************************/
387	/*
388	*/
389	/******************************************************************************/
390	void NGC_Exporter::set_preamble(string _preamble)	1✔
391	{
392	preamble = _preamble;	1✔
393	}	1✔
394
395	/******************************************************************************/
396	/*
397	*/
398	/******************************************************************************/
399	void NGC_Exporter::set_postamble(string _postamble)	1✔
400	{
401	postamble = _postamble;	1✔
402	}	1✔
403
404	/* vim: set tabstop=2 : */

pcb2gcode / pcb2gcode / 500055388

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous