589994471

Build Type

github

Committed by GitHub

Commit Message

Merge a3b953dd5 into a283cbdb6

Pull Request Pull Request #553: --tools option

Run Details

5115 of 8702 branches covered (58.78%)

Branch coverage included in aggregate %.

127 of 133 new or added lines in 4 files covered. (95.49%)

49 existing lines in 2 files now uncovered.

3523 of 3771 relevant lines covered (93.42%)

115664.28 hits per line

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

59.76

/main.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 <iostream>
#include <fstream>
#include <sstream>
#include <memory>

#include <vector>
using std::vector;

using std::cout;
using std::cerr;
using std::endl;
using std::flush;
using std::fstream;
using std::shared_ptr;
using std::make_shared;

#include <string>
using std::string;

#include "gerberimporter.hpp"
#include "ngc_exporter.hpp"
#include "board.hpp"
#include "drill.hpp"
#include "options.hpp"
#include "units.hpp"

#include <boost/algorithm/string.hpp>
#include <boost/version.hpp>

void do_pcb2gcode(int argc, const char* argv[]) {
    options::parse(argc, argv);      //parse the command line parameters

    po::variables_map& vm = options::get_vm();      //get the cli parameters

    if (vm.count("version")) {       //return version and quit
      cout << PACKAGE_VERSION << endl;
      cout << "Git commit: " << GIT_VERSION << endl;
      cout << "Boost: " << BOOST_VERSION << endl;
      cout << "Gerbv: " << GERBV_VERSION << endl;
#ifdef GEOS_VERSION
      cout << "Geos: " << GEOS_VERSION << endl;
#else
      cout << "Geos: Not installed" << endl;
#endif
      return;
    }

    if (vm.count("help")) {       //return help and quit
      cout << options::help();
      return;
    }

    options::check_parameters();      //check the cli parameters

    //---------------------------------------------------------------------------
    //deal with metric / imperial units for input parameters:

    double unit;      //factor for imperial/metric conversion

    unit = vm["metric"].as<bool>() ? (1. / 25.4) : 1;

    //---------------------------------------------------------------------------
    //prepare environment:

    const double tolerance = vm["tolerance"].as<double>() * unit;
    const bool explicit_tolerance = !vm["nog64"].as<bool>();
    const string outputdir = vm["output-dir"].as<string>();
    const double spindown_time = vm.count("spindown-time") ?
        vm["spindown-time"].as<Time>().asMillisecond(1) : vm["spinup-time"].as<Time>().asMillisecond(1);
    shared_ptr<Isolator> isolator;

    if (vm.count("front") || vm.count("back"))
    {
        isolator = make_shared<Isolator>();
        for (const auto& tool_diameter : flatten(vm["mill-diameters"].as<std::vector<CommaSeparated<Length>>>())) {
          isolator->tool_diameters_and_overlap_widths.push_back(
              std::make_pair(
                  tool_diameter.asInch(unit),
                  boost::apply_visitor(percent_visitor(tool_diameter), vm["milling-overlap"].as<boost::variant<Length, Percent>>()).asInch(unit)));
        }
        isolator->voronoi = vm["voronoi"].as<bool>();
        isolator->zwork = vm["zwork"].as<Length>().asInch(unit);
        isolator->zsafe = vm["zsafe"].as<Length>().asInch(unit);
        isolator->feed = vm["mill-feed"].as<Velocity>().asInchPerMinute(unit);
        if (vm.count("mill-vertfeed"))
            isolator->vertfeed = vm["mill-vertfeed"].as<Velocity>().asInchPerMinute(unit);
        else
            isolator->vertfeed = isolator->feed / 2;
        isolator->speed = vm["mill-speed"].as<Rpm>().asRpm(1);
        isolator->zchange = vm["zchange"].as<Length>().asInch(unit);
        isolator->extra_passes = vm["extra-passes"].as<int>();
        isolator->isolation_width = vm["isolation-width"].as<Length>().asInch(unit);
        isolator->optimise = vm["optimise"].as<Length>().asInch(unit);
        isolator->offset = vm["offset"].as<Length>().asInch(unit);
        isolator->preserve_thermal_reliefs = vm["preserve-thermal-reliefs"].as<bool>();
        isolator->eulerian_paths = vm["eulerian-paths"].as<bool>();
        isolator->path_finding_limit = vm["path-finding-limit"].as<size_t>();
        isolator->g0_vertical_speed = vm["g0-vertical-speed"].as<Velocity>().asInchPerMinute(unit);
        isolator->g0_horizontal_speed = vm["g0-horizontal-speed"].as<Velocity>().asInchPerMinute(unit);
        isolator->backtrack = vm["backtrack"].as<Velocity>().asInchPerMinute(unit);
        if (vm.count("mill-infeed")) {
          isolator->stepsize = vm["mill-infeed"].as<Length>().asInch(unit);
        } else {
          isolator->stepsize = -isolator->zwork;
        }
        isolator->tolerance = tolerance;
        isolator->explicit_tolerance = explicit_tolerance;
        isolator->pre_milling_gcode = boost::algorithm::join(
            vm["pre-milling-gcode"].as<vector<string>>(), "\n");
        isolator->post_milling_gcode = boost::algorithm::join(
            vm["post-milling-gcode"].as<vector<string>>(), "\n");
        isolator->spinup_time = vm["spinup-time"].as<Time>().asMillisecond(1);
        isolator->spindown_time = spindown_time;
    }

    auto cutter = make_shared<Cutter>();

    if (vm.count("outline") ||
        (vm.count("drill") &&
         vm["min-milldrill-hole-diameter"].as<Length>() < Length(std::numeric_limits<double>::infinity()))) {
      cutter->tool_diameter = vm["cutter-diameter"].as<Length>().asInch(unit);
      cutter->zwork = vm["zcut"].as<Length>().asInch(unit);
      cutter->zsafe = vm["zsafe"].as<Length>().asInch(unit);
      cutter->feed = vm["cut-feed"].as<Velocity>().asInchPerMinute(unit);
      if (vm.count("cut-vertfeed"))
        cutter->vertfeed = vm["cut-vertfeed"].as<Velocity>().asInchPerMinute(unit);
      else
        cutter->vertfeed = cutter->feed / 2;
      cutter->speed = vm["cut-speed"].as<Rpm>().asRpm(1);
      cutter->zchange = vm["zchange"].as<Length>().asInch(unit);
      cutter->stepsize = vm["cut-infeed"].as<Length>().asInch(unit);
      cutter->optimise = vm["optimise"].as<Length>().asInch(unit);
      cutter->offset = vm["offset"].as<Length>().asInch(unit);
      cutter->eulerian_paths = vm["eulerian-paths"].as<bool>();
      cutter->path_finding_limit = vm["path-finding-limit"].as<size_t>();
      cutter->g0_vertical_speed = vm["g0-vertical-speed"].as<Velocity>().asInchPerMinute(unit);
      cutter->g0_horizontal_speed = vm["g0-horizontal-speed"].as<Velocity>().asInchPerMinute(unit);
      cutter->tolerance = tolerance;
      cutter->explicit_tolerance = explicit_tolerance;
      cutter->spinup_time = vm["spinup-time"].as<Time>().asMillisecond(1);
      cutter->spindown_time = spindown_time;
      cutter->bridges_num = vm["bridgesnum"].as<unsigned int>();
      cutter->bridges_width = vm["bridges"].as<Length>().asInch(unit);
      if (vm.count("zbridges"))
        cutter->bridges_height = vm["zbridges"].as<Length>().asInch(unit);
      else
        cutter->bridges_height = cutter->zsafe;
    }

    shared_ptr<Driller> driller;

    if (vm.count("drill"))
    {
        driller = make_shared<Driller>();
        driller->zwork = vm["zdrill"].as<Length>().asInch(unit);
        driller->zsafe = vm["zsafe"].as<Length>().asInch(unit);
        driller->feed = vm["drill-feed"].as<Velocity>().asInchPerMinute(unit);
        driller->speed = vm["drill-speed"].as<Rpm>().asRpm(1);
        driller->tolerance = tolerance;
        driller->explicit_tolerance = explicit_tolerance;
        driller->spinup_time = vm["spinup-time"].as<Time>().asMillisecond(1);
        driller->spindown_time = spindown_time;
        driller->zchange = vm["zchange"].as<Length>().asInch(unit);
    }

    //---------------------------------------------------------------------------
    //prepare custom preamble:

    string preamble, postamble;

    if (vm.count("preamble-text"))
    {
        cout << "Importing preamble text... " << flush;
        string name = vm["preamble-text"].as<string>();
        fstream in(name.c_str(), fstream::in);

        if (!in.good()) {
          options::maybe_throw("Cannot read preamble-text file \"" + name + "\"", ERR_INVALIDPARAMETER);
        }

        string line;
        string tmp;

        while (std::getline(in, line))
        {
            tmp = line;
            boost::erase_all(tmp, " ");
            boost::erase_all(tmp, "\t");

            if( tmp.empty() )                //If there's nothing but spaces and \t
                preamble += '\n';
            else
            {
                boost::replace_all ( line, "(", "<" );       //Substitute round parenthesis with angled parenthesis
                boost::replace_all ( line, ")", ">" );
                preamble += "( " + line + " )\n";
            }
        }

        cout << "DONE\n";
    }

    if (vm.count("preamble"))
    {
        cout << "Importing preamble... " << flush;
        string name = vm["preamble"].as<string>();
        fstream in(name.c_str(), fstream::in);

        if (!in.good()) {
          options::maybe_throw("Cannot read preamble file \"" + name + "\"", ERR_INVALIDPARAMETER);
        }

        string tmp((std::istreambuf_iterator<char>(in)),
                   std::istreambuf_iterator<char>());
        preamble += tmp + "\n";
        cout << "DONE\n";
    }

    //---------------------------------------------------------------------------
    //prepare custom postamble:

    if (vm.count("postamble"))
    {
        cout << "Importing postamble... " << flush;
        string name = vm["postamble"].as<string>();
        fstream in(name.c_str(), fstream::in);

        if (!in.good()) {
          options::maybe_throw("Cannot read postamble file \"" + name + "\"", ERR_INVALIDPARAMETER);
        }

        string tmp((std::istreambuf_iterator<char>(in)),
                   std::istreambuf_iterator<char>());
        postamble = tmp + "\n";
        cout << "DONE\n";
    }

    //---------------------------------------------------------------------------

    auto board = make_shared<Board>(
        vm["fill-outline"].as<bool>(),
        outputdir,
        vm["tsp-2opt"].as<bool>(),
        vm["mill-feed-direction"].as<MillFeedDirection::MillFeedDirection>(),
        vm["invert-gerbers"].as<bool>(),
        !vm["draw-gerber-lines"].as<bool>());

    // this is currently disabled, use --outline instead
    if (vm.count("margins"))
    {
        board->set_margins(vm["margins"].as<double>());
    }

    //--------------------------------------------------------------------------
    //load files, import layer files, create surface:

    cout << "Importing front side... " << flush;
    if (vm.count("front") > 0) {
      string frontfile = vm["front"].as<string>();
      auto importer = make_shared<GerberImporter>();
      if (!importer->load_file(frontfile)) {
        options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);
      }
      board->prepareLayer("front", importer, isolator, false);
      cout << "DONE.\n";
    } else {
      cout << "not specified.\n";
    }

    cout << "Importing back side... " << flush;
    if (vm.count("back") > 0) {
      string backfile = vm["back"].as<string>();
      auto importer = make_shared<GerberImporter>();
      if (!importer->load_file(backfile)) {
        options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);
      }
      board->prepareLayer("back", importer, isolator, true);
      cout << "DONE.\n";
    } else {
      cout << "not specified.\n";
    }

    cout << "Importing outline... " << flush;
    if (vm.count("outline") > 0) {
      string outline = vm["outline"].as<string>();
      auto importer = make_shared<GerberImporter>();
      if (!importer->load_file(outline)) {
        options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);
      }
      board->prepareLayer("outline", importer, cutter, !workSide(vm, "cut"));
      cout << "DONE.\n";
    } else {
      cout << "not specified.\n";
    }

    cout << "Processing input files... " << flush;
    board->createLayers();
    cout << "DONE.\n";

    if (!vm["no-export"].as<bool>()) {
      auto exporter = make_shared<NGC_Exporter>(board);
      exporter->add_header(PACKAGE_STRING);

      if (vm.count("preamble") || vm.count("preamble-text")) {
        exporter->set_preamble(preamble);
      }

      if (vm.count("postamble")) {
        exporter->set_postamble(postamble);
      }

      exporter->export_all(vm);
    }

    //---------------------------------------------------------------------------
    //load and process the drill file

    cout << "Importing drill... " << flush;

    if (vm.count("drill") > 0) {
        try
        {
            point_type_fp min;
            point_type_fp max;

            //Check if there are layers in "board"; if not, we have to compute
            //the size of the board now, based only on the size of the drill layer
            //(the resulting drill gcode will be probably misaligned, but this is the
            //best we can do)
            if(board->get_layersnum() == 0)
            {
              auto importer = make_shared<GerberImporter>();
              if (!importer->load_file(vm["drill"].as<string>())) {
                options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);
              }
              min = importer->get_bounding_box().min_corner();
              max = importer->get_bounding_box().max_corner();
            } else {
              min = board->get_bounding_box().min_corner();
              max = board->get_bounding_box().max_corner();
            }

            ExcellonProcessor ep(vm, min, max);

            ep.add_header(PACKAGE_STRING);

            if (vm.count("preamble") || vm.count("preamble-text"))
            {
                ep.set_preamble(preamble);
            }

            if (vm.count("postamble"))
            {
                ep.set_postamble(postamble);
            }

            cout << "DONE.\n";

            boost::optional<string> drill_filename = vm["drill-output"].as<string>();
            boost::optional<string> milldrill_filename = vm["milldrill-output"].as<string>();
            if (vm["no-export"].as<bool>())
            {
                drill_filename = boost::none;
                milldrill_filename = boost::none;
            }
            // We can modify the cutter because we're not going to use it again.
            if (vm.count("milldrill-diameter")) {
              cutter->tool_diameter = vm["milldrill-diameter"].as<Length>().asInch(unit);
            }
            if (vm.count("zmilldrill")) {
              cutter->zwork = vm["zmilldrill"].as<Length>().asInch(unit);
            } else {
              cutter->zwork = vm["zdrill"].as<Length>().asInch(unit);
            }
            ep.export_ngc(outputdir, milldrill_filename, cutter,
                          vm["zchange-absolute"].as<bool>());
            ep.export_ngc(outputdir, drill_filename,
                          driller, vm["onedrill"].as<bool>(), vm["nog81"].as<bool>(),
                          vm["zchange-absolute"].as<bool>());

            cout << "DONE. The board should be drilled from the " << ( workSide(vm, "drill") ? "FRONT" : "BACK" ) << " side.\n";

        }
        catch (const drill_exception& e) {
          options::maybe_throw("ERROR: drill_exception", ERR_INVALIDPARAMETER);
        }
    } else {
        cout << "not specified.\n";
    }

    cout << "END." << endl;

}

int main(int argc, const char* argv[]) {
  try {
    do_pcb2gcode(argc, argv);
  } catch (const pcb2gcode_parse_exception& e) {
    cerr << e.what() << endl;
    return e.code();
  }
  return 0;
}

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 <iostream>
24	#include <fstream>
25	#include <sstream>
26	#include <memory>
27
28	#include <vector>
29	using std::vector;
30
31	using std::cout;
32	using std::cerr;
33	using std::endl;
34	using std::flush;
35	using std::fstream;
36	using std::shared_ptr;
37	using std::make_shared;
38
39	#include <string>
40	using std::string;
41
42	#include "gerberimporter.hpp"
43	#include "ngc_exporter.hpp"
44	#include "board.hpp"
45	#include "drill.hpp"
46	#include "options.hpp"
47	#include "units.hpp"
48
49	#include <boost/algorithm/string.hpp>
50	#include <boost/version.hpp>
51
52	void do_pcb2gcode(int argc, const char* argv[]) {	83✔
53	options::parse(argc, argv); //parse the command line parameters	83✔
54
55	po::variables_map& vm = options::get_vm(); //get the cli parameters
56
57	if (vm.count("version")) { //return version and quit	160✔
58	cout << PACKAGE_VERSION << endl;
59	cout << "Git commit: " << GIT_VERSION << endl;
60	cout << "Boost: " << BOOST_VERSION << endl;	1✔
61	cout << "Gerbv: " << GERBV_VERSION << endl;
62	#ifdef GEOS_VERSION
63	cout << "Geos: " << GEOS_VERSION << endl;
64	#else
65	cout << "Geos: Not installed" << endl;
66	#endif
67	return;	2✔
68	}
69
70	if (vm.count("help")) { //return help and quit	158✔
71	cout << options::help();	1✔
72	return;	1✔
73	}
74
75	options::check_parameters(); //check the cli parameters	78✔
76
77	//---------------------------------------------------------------------------
78	//deal with metric / imperial units for input parameters:
79
80	double unit; //factor for imperial/metric conversion
81
82	unit = vm["metric"].as<bool>() ? (1. / 25.4) : 1;	150!
83
84	//---------------------------------------------------------------------------
85	//prepare environment:
86
87	const double tolerance = vm["tolerance"].as<double>() * unit;	150!
88	const bool explicit_tolerance = !vm["nog64"].as<bool>();	150!
89	const string outputdir = vm["output-dir"].as<string>();	75!
90	const double spindown_time = vm.count("spindown-time") ?	75!
91	vm["spindown-time"].as<Time>().asMillisecond(1) : vm["spinup-time"].as<Time>().asMillisecond(1);	225!
92	shared_ptr<Isolator> isolator;	75✔
93
94	if (vm.count("front") \|\| vm.count("back"))	254!
95	{
96	isolator = make_shared<Isolator>();	59✔
97	for (const auto& tool_diameter : flatten(vm["mill-diameters"].as<std::vector<CommaSeparated<Length>>>())) {	248!
98	isolator->tool_diameters_and_overlap_widths.push_back(	71✔
99	std::make_pair(	71✔
100	tool_diameter.asInch(unit),
101	boost::apply_visitor(percent_visitor(tool_diameter), vm["milling-overlap"].as<boost::variant<Length, Percent>>()).asInch(unit)));	142!
102	}
103	isolator->voronoi = vm["voronoi"].as<bool>();	118!
104	isolator->zwork = vm["zwork"].as<Length>().asInch(unit);	118!
105	isolator->zsafe = vm["zsafe"].as<Length>().asInch(unit);	118!
106	isolator->feed = vm["mill-feed"].as<Velocity>().asInchPerMinute(unit);	118!
107	if (vm.count("mill-vertfeed"))	118!
108	isolator->vertfeed = vm["mill-vertfeed"].as<Velocity>().asInchPerMinute(unit);	6!
109	else
110	isolator->vertfeed = isolator->feed / 2;	56✔
111	isolator->speed = vm["mill-speed"].as<Rpm>().asRpm(1);	118!
112	isolator->zchange = vm["zchange"].as<Length>().asInch(unit);	118!
113	isolator->extra_passes = vm["extra-passes"].as<int>();	118!
114	isolator->isolation_width = vm["isolation-width"].as<Length>().asInch(unit);	118!
115	isolator->optimise = vm["optimise"].as<Length>().asInch(unit);	118!
116	isolator->offset = vm["offset"].as<Length>().asInch(unit);	118!
117	isolator->preserve_thermal_reliefs = vm["preserve-thermal-reliefs"].as<bool>();	118!
118	isolator->eulerian_paths = vm["eulerian-paths"].as<bool>();	118!
119	isolator->path_finding_limit = vm["path-finding-limit"].as<size_t>();	118!
120	isolator->g0_vertical_speed = vm["g0-vertical-speed"].as<Velocity>().asInchPerMinute(unit);	118!
121	isolator->g0_horizontal_speed = vm["g0-horizontal-speed"].as<Velocity>().asInchPerMinute(unit);	118!
122	isolator->backtrack = vm["backtrack"].as<Velocity>().asInchPerMinute(unit);	118!
123	if (vm.count("mill-infeed")) {	118!
124	isolator->stepsize = vm["mill-infeed"].as<Length>().asInch(unit);	4!
125	} else {
126	isolator->stepsize = -isolator->zwork;	57✔
127	}
128	isolator->tolerance = tolerance;	59✔
129	isolator->explicit_tolerance = explicit_tolerance;	59✔
130	isolator->pre_milling_gcode = boost::algorithm::join(	118!
131	vm["pre-milling-gcode"].as<vector<string>>(), "\n");	118!
132	isolator->post_milling_gcode = boost::algorithm::join(	118!
133	vm["post-milling-gcode"].as<vector<string>>(), "\n");	118!
134	isolator->spinup_time = vm["spinup-time"].as<Time>().asMillisecond(1);	118!
135	isolator->spindown_time = spindown_time;	59✔
136	}
137
138	auto cutter = make_shared<Cutter>();
139
140	if (vm.count("outline") \|\|	154!
141	(vm.count("drill") &&	107!
142	vm["min-milldrill-hole-diameter"].as<Length>() < Length(std::numeric_limits<double>::infinity()))) {	96!
143	cutter->tool_diameter = vm["cutter-diameter"].as<Length>().asInch(unit);	108!
144	cutter->zwork = vm["zcut"].as<Length>().asInch(unit);	108!
145	cutter->zsafe = vm["zsafe"].as<Length>().asInch(unit);	108!
146	cutter->feed = vm["cut-feed"].as<Velocity>().asInchPerMinute(unit);	108!
147	if (vm.count("cut-vertfeed"))	108!
148	cutter->vertfeed = vm["cut-vertfeed"].as<Velocity>().asInchPerMinute(unit);	4!
149	else
150	cutter->vertfeed = cutter->feed / 2;	52✔
151	cutter->speed = vm["cut-speed"].as<Rpm>().asRpm(1);	108!
152	cutter->zchange = vm["zchange"].as<Length>().asInch(unit);	108!
153	cutter->stepsize = vm["cut-infeed"].as<Length>().asInch(unit);	108!
154	cutter->optimise = vm["optimise"].as<Length>().asInch(unit);	108!
155	cutter->offset = vm["offset"].as<Length>().asInch(unit);	108!
156	cutter->eulerian_paths = vm["eulerian-paths"].as<bool>();	108!
157	cutter->path_finding_limit = vm["path-finding-limit"].as<size_t>();	108!
158	cutter->g0_vertical_speed = vm["g0-vertical-speed"].as<Velocity>().asInchPerMinute(unit);	108!
159	cutter->g0_horizontal_speed = vm["g0-horizontal-speed"].as<Velocity>().asInchPerMinute(unit);	162!
160	cutter->tolerance = tolerance;	54✔
161	cutter->explicit_tolerance = explicit_tolerance;	54✔
162	cutter->spinup_time = vm["spinup-time"].as<Time>().asMillisecond(1);	108!
163	cutter->spindown_time = spindown_time;	54✔
164	cutter->bridges_num = vm["bridgesnum"].as<unsigned int>();	108!
165	cutter->bridges_width = vm["bridges"].as<Length>().asInch(unit);	108!
166	if (vm.count("zbridges"))	108!
167	cutter->bridges_height = vm["zbridges"].as<Length>().asInch(unit);	88!
168	else
169	cutter->bridges_height = cutter->zsafe;	10✔
170	}
171
172	shared_ptr<Driller> driller;	75✔
173
174	if (vm.count("drill"))	150!
175	{
176	driller = make_shared<Driller>();	35✔
177	driller->zwork = vm["zdrill"].as<Length>().asInch(unit);	70!
178	driller->zsafe = vm["zsafe"].as<Length>().asInch(unit);	70!
179	driller->feed = vm["drill-feed"].as<Velocity>().asInchPerMinute(unit);	70!
180	driller->speed = vm["drill-speed"].as<Rpm>().asRpm(1);	70!
181	driller->tolerance = tolerance;	35✔
182	driller->explicit_tolerance = explicit_tolerance;	35✔
183	driller->spinup_time = vm["spinup-time"].as<Time>().asMillisecond(1);	70!
184	driller->spindown_time = spindown_time;	35✔
185	driller->zchange = vm["zchange"].as<Length>().asInch(unit);	70!
186	}
187
188	//---------------------------------------------------------------------------
189	//prepare custom preamble:
190
191	string preamble, postamble;
192
193	if (vm.count("preamble-text"))	150!
194	{
195	cout << "Importing preamble text... " << flush;
196	string name = vm["preamble-text"].as<string>();	2!
197	fstream in(name.c_str(), fstream::in);	2!
198
199	if (!in.good()) {	1!
NEW 200	options::maybe_throw("Cannot read preamble-text file \"" + name + "\"", ERR_INVALIDPARAMETER);	×
201	}
202
203	string line;
204	string tmp;
205
206	while (std::getline(in, line))	4!
207	{
208	tmp = line;
209	boost::erase_all(tmp, " ");	3!
210	boost::erase_all(tmp, "\t");	3!
211
212	if( tmp.empty() ) //If there's nothing but spaces and \t	3!
213	preamble += '\n';
214	else
215	{
216	boost::replace_all ( line, "(", "<" ); //Substitute round parenthesis with angled parenthesis	3!
217	boost::replace_all ( line, ")", ">" );	3!
218	preamble += "( " + line + " )\n";	6!
219	}
220	}
221
222	cout << "DONE\n";	1!
223	}
224
225	if (vm.count("preamble"))	150!
226	{
227	cout << "Importing preamble... " << flush;
228	string name = vm["preamble"].as<string>();	2!
229	fstream in(name.c_str(), fstream::in);	2!
230
231	if (!in.good()) {	1!
NEW 232	options::maybe_throw("Cannot read preamble file \"" + name + "\"", ERR_INVALIDPARAMETER);	×
233	}
234
235	string tmp((std::istreambuf_iterator<char>(in)),
236	std::istreambuf_iterator<char>());
237	preamble += tmp + "\n";	1!
238	cout << "DONE\n";	1!
239	}
240
241	//---------------------------------------------------------------------------
242	//prepare custom postamble:
243
244	if (vm.count("postamble"))	150!
245	{
246	cout << "Importing postamble... " << flush;
247	string name = vm["postamble"].as<string>();	2!
248	fstream in(name.c_str(), fstream::in);	2!
249
250	if (!in.good()) {	1!
NEW 251	options::maybe_throw("Cannot read postamble file \"" + name + "\"", ERR_INVALIDPARAMETER);	×
252	}
253
254	string tmp((std::istreambuf_iterator<char>(in)),
255	std::istreambuf_iterator<char>());
256	postamble = tmp + "\n";	1!
257	cout << "DONE\n";	1!
258	}
259
260	//---------------------------------------------------------------------------
261
262	auto board = make_shared<Board>(
263	vm["fill-outline"].as<bool>(),	150!
264	outputdir,
265	vm["tsp-2opt"].as<bool>(),	150!
266	vm["mill-feed-direction"].as<MillFeedDirection::MillFeedDirection>(),	150!
NEW 267	vm["invert-gerbers"].as<bool>(),	×
268	!vm["draw-gerber-lines"].as<bool>());	225!
269
270	// this is currently disabled, use --outline instead
271	if (vm.count("margins"))	150!
272	{
NEW 273	board->set_margins(vm["margins"].as<double>());	×
274	}
275
276	//--------------------------------------------------------------------------
277	//load files, import layer files, create surface:
278
279	cout << "Importing front side... " << flush;
280	if (vm.count("front") > 0) {	150!
281	string frontfile = vm["front"].as<string>();	50!
282	auto importer = make_shared<GerberImporter>();
283	if (!importer->load_file(frontfile)) {	25!
284	options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);	2!
285	}
286	board->prepareLayer("front", importer, isolator, false);	73!
287	cout << "DONE.\n";	24!
288	} else {
289	cout << "not specified.\n";	50!
290	}
291
292	cout << "Importing back side... " << flush;
293	if (vm.count("back") > 0) {	148!
294	string backfile = vm["back"].as<string>();	96!
295	auto importer = make_shared<GerberImporter>();
296	if (!importer->load_file(backfile)) {	48!
297	options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);	2!
298	}
299	board->prepareLayer("back", importer, isolator, true);	142!
300	cout << "DONE.\n";	47!
301	} else {
302	cout << "not specified.\n";	26!
303	}
304
305	cout << "Importing outline... " << flush;
306	if (vm.count("outline") > 0) {	146!
307	string outline = vm["outline"].as<string>();	96!
308	auto importer = make_shared<GerberImporter>();
309	if (!importer->load_file(outline)) {	48!
310	options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);	2!
311	}
312	board->prepareLayer("outline", importer, cutter, !workSide(vm, "cut"));	235!
313	cout << "DONE.\n";	47!
314	} else {
315	cout << "not specified.\n";	25!
316	}
317
318	cout << "Processing input files... " << flush;
319	board->createLayers();	72!
320	cout << "DONE.\n";	72!
321
322	if (!vm["no-export"].as<bool>()) {	144!
323	auto exporter = make_shared<NGC_Exporter>(board);
324	exporter->add_header(PACKAGE_STRING);	70!
325
326	if (vm.count("preamble") \|\| vm.count("preamble-text")) {	278!
327	exporter->set_preamble(preamble);	2!
328	}
329
330	if (vm.count("postamble")) {	140!
331	exporter->set_postamble(postamble);	2!
332	}
333
334	exporter->export_all(vm);	70!
335	}
336
337	//---------------------------------------------------------------------------
338	//load and process the drill file
339
340	cout << "Importing drill... " << flush;
341
342	if (vm.count("drill") > 0) {	144!
343	try
344	{
345	point_type_fp min;
346	point_type_fp max;
347
348	//Check if there are layers in "board"; if not, we have to compute
349	//the size of the board now, based only on the size of the drill layer
350	//(the resulting drill gcode will be probably misaligned, but this is the
351	//best we can do)
352	if(board->get_layersnum() == 0)	32✔
353	{
354	auto importer = make_shared<GerberImporter>();
355	if (!importer->load_file(vm["drill"].as<string>())) {	21!
UNCOV 356	options::maybe_throw("ERROR.", ERR_INVALIDPARAMETER);	×
357	}
358	min = importer->get_bounding_box().min_corner();	7!
359	max = importer->get_bounding_box().max_corner();	7!
360	} else {
361	min = board->get_bounding_box().min_corner();	25✔
362	max = board->get_bounding_box().max_corner();	25✔
363	}
364
365	ExcellonProcessor ep(vm, min, max);	63✔
366
367	ep.add_header(PACKAGE_STRING);	31!
368
369	if (vm.count("preamble") \|\| vm.count("preamble-text"))	122!
370	{
371	ep.set_preamble(preamble);	2!
372	}
373
374	if (vm.count("postamble"))	62!
375	{
376	ep.set_postamble(postamble);	2!
377	}
378
379	cout << "DONE.\n";	31!
380
381	boost::optional<string> drill_filename = vm["drill-output"].as<string>();	31!
382	boost::optional<string> milldrill_filename = vm["milldrill-output"].as<string>();	31!
383	if (vm["no-export"].as<bool>())	62!
384	{
385	drill_filename = boost::none;
386	milldrill_filename = boost::none;
387	}
388	// We can modify the cutter because we're not going to use it again.
389	if (vm.count("milldrill-diameter")) {	62!
390	cutter->tool_diameter = vm["milldrill-diameter"].as<Length>().asInch(unit);	87!
391	}
392	if (vm.count("zmilldrill")) {	62!
393	cutter->zwork = vm["zmilldrill"].as<Length>().asInch(unit);	2!
394	} else {
395	cutter->zwork = vm["zdrill"].as<Length>().asInch(unit);	60!
396	}
397	ep.export_ngc(outputdir, milldrill_filename, cutter,	93!
398	vm["zchange-absolute"].as<bool>());	62!
399	ep.export_ngc(outputdir, drill_filename,	93!
400	driller, vm["onedrill"].as<bool>(), vm["nog81"].as<bool>(),	93!
401	vm["zchange-absolute"].as<bool>());	93!
402
403	cout << "DONE. The board should be drilled from the " << ( workSide(vm, "drill") ? "FRONT" : "BACK" ) << " side.\n";	81!
404
405	}
406	catch (const drill_exception& e) {	2✔
407	options::maybe_throw("ERROR: drill_exception", ERR_INVALIDPARAMETER);	2!
408	}
409	} else {
410	cout << "not specified.\n";	40!
411	}
412
413	cout << "END." << endl;
414
415	}
416
417	int main(int argc, const char* argv[]) {	83✔
418	try {
419	do_pcb2gcode(argc, argv);	83✔
420	} catch (const pcb2gcode_parse_exception& e) {	10✔
421	cerr << e.what() << endl;	10!
422	return e.code();	10✔
423	}
424	return 0;
425	}

pcb2gcode / pcb2gcode / 589994471

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