dxfngc

1) /* drawing (DXF) to G-code (NGC) converter
2)  * Copyright 2013 Stefan Schuermans <stefan@schuermans.info>
3)  * Copyleft: CC-BY-SA http://creativecommons.org/licenses/by-sa/3.0/
4)  */
5) 
6) #include <fstream>
7) #include <iostream>

8) #include <math.h>

9) #include <sstream>
10) #include <string>
11) 
12) #include "cmdparser.h"
13) #include "drawing.h"
14) #include "filename.h"
15) #include "gcode.h"

16) #include "polygons.h"

17) #include "settings.h"
18) 

19) /**
20)  * @brief get layer by name from stream
21)  * @param[in] strm stream to read layer name from
22)  * @param[out] name layer name from stream
23)  * @param[out] layer layer indicated by name from stream
24)  * @return if layer could be found
25)  */
26) bool CmdParser::getLayer(std::istream &strm, std::string &name,
27)                          const Layer *&layer) const
28) {
29)   // get layer name argument
30)   strm >> name;
31)   if (strm.fail()) {
32)     std::cerr << "missing layer name" << std::endl;
33)     return false;
34)   }
35) 
36)   // get layer
37)   Drawing::Layers::const_iterator itLayer = mDrawing.mLayers.find(name);
38)   if (itLayer == mDrawing.mLayers.end()) {
39)     std::cerr << "layer \"" << name << "\" not found" << std::endl;
40)     return false;
41)   }
42)   layer = &itLayer->second;
43) 
44)   return true;
45) }
46) 
47) /**
48)  * @brief get layer by name from stream and convert to polygons
49)  * @param[in] strm stream to read layer name from
50)  * @param[out] name layer name from stream
51)  * @param[out] layer layer indicated by name from stream
52)  * @param[in,out] polys polygons created from layer
53)  * @return if layer could be found and converted to polygons
54)  */
55) bool CmdParser::getLayerPolys(std::istream &strm, std::string &name,
56)                               const Layer *&layer, Polygons &polys) const
57) {
58)   // get layer
59)   if (!getLayer(strm, name, layer))
60)     return false;
61) 
62)   // convert layer to polygons
63)   if (!polys.loadLayer(*layer, mSettings.precision)) {
64)     std::cerr << "cannot convert layer \"" << name << "\" to polygons"
65)               << std::endl;
66)     return false;
67)   }
68) 
69)   return true;
70) }
71) 

72) /**
73)  * @brief process cmd command
74)  * @param[in] strm stream to read command arguments from
75)  * @return if processing command was successful
76)  */
77) bool CmdParser::procCmd_cmd(std::istream &strm)
78) {
79)   // skip whitespace and use rest of line as custom command
80)   strm >> std::ws;
81)   std::string cmd;
82)   getline(strm, cmd);
83) 
84)   // add custom command to G-code
85)   mGCode.appendCustom(cmd);
86) 
87)   return true;
88) }
89) 
90) /**
91)  * @brief process cut command
92)  * @param[in] strm stream to read command arguments from
93)  * @return if processing command was successful
94)  */
95) bool CmdParser::procCmd_cut(std::istream &strm)
96) {

97)   // get layer from arguments

98)   std::string layerName;

99)   const Layer *layer;
100)   if (!getLayer(strm, layerName, layer))

101)     return false;
102) 

103)   // convert layer to G-code
104)   layer->toGCode(mSettings, mGCode);
105) 
106)   return true;
107) }
108) 
109) /**
110)  * @brief process cut_inside command
111)  * @param[in] strm stream to read command arguments from
112)  * @return if processing command was successful
113)  */
114) bool CmdParser::procCmd_cut_inside(std::istream &strm)
115) {
116)   // get layer from arguments and convert to polygons
117)   std::string layerName;
118)   const Layer *layer;
119)   Polygons polys;
120)   if (!getLayerPolys(strm, layerName, layer, polys))

121)     return false;
122) 

123)   // inner offset polygons

124)   Polygons newPolys;

125)   if (!polys.createInnerOffset(mSettings.tool_diameter * 0.5, newPolys)) {
126)     std::cerr << "creating inner offset polygons failed" << std::endl;
127)     return false;
128)   }

129) 
130)   // convert polygons back to layer (containing paths)

131)   Layer newLayer;

132)   newPolys.writeToLayer(newLayer);

133)   newLayer.improvePaths(mSettings.precision);

134) 
135)   // convert layer to G-code
136)   newLayer.toGCode(mSettings, mGCode);

137) 
138)   return true;
139) }
140) 
141) /**
142)  * @brief process cut_outside command
143)  * @param[in] strm stream to read command arguments from
144)  * @return if processing command was successful
145)  */
146) bool CmdParser::procCmd_cut_outside(std::istream &strm)
147) {
148)   // get layer from arguments and convert to polygons
149)   std::string layerName;
150)   const Layer *layer;
151)   Polygons polys;
152)   if (!getLayerPolys(strm, layerName, layer, polys))
153)     return false;
154) 

155)   // outer offset polygons
156)   Polygons newPolys;
157)   if (!polys.createOuterOffset(mSettings.tool_diameter * 0.5, newPolys)) {
158)     std::cerr << "creating outer offset polygons failed" << std::endl;
159)     return false;
160)   }
161) 
162)   // convert polygons back to layer (containing paths)

163)   Layer newLayer;

164)   newPolys.writeToLayer(newLayer);

165)   newLayer.improvePaths(mSettings.precision);

166) 
167)   // convert layer to G-code
168)   newLayer.toGCode(mSettings, mGCode);

169) 
170)   return true;
171) }
172) 
173) /**
174)  * @brief process cut_pocket command
175)  * @param[in] strm stream to read command arguments from
176)  * @return if processing command was successful
177)  */
178) bool CmdParser::procCmd_cut_pocket(std::istream &strm)
179) {
180)   // get layer from arguments and convert to polygons
181)   std::string layerName;
182)   const Layer *layer;
183)   Polygons polys;
184)   if (!getLayerPolys(strm, layerName, layer, polys))
185)     return false;
186) 

187)   // fill insides of polygons by creating inner offset polygons
188)   Polygons newPolys;
189)   if (!polys.fillInnerOffset(mSettings.tool_diameter * 0.5, newPolys)) {
190)     std::cerr << "filling insides of polygons failed" << std::endl;
191)     return false;
192)   }
193) 
194)   // convert polygons back to layer (containing paths)

195)   Layer newLayer;

196)   newPolys.writeToLayer(newLayer);

197)   newLayer.improvePaths(mSettings.precision);

198) 
199)   // convert layer to G-code
200)   newLayer.toGCode(mSettings, mGCode);

201) 
202)   return true;
203) }
204) 
205) /**
206)  * @brief process read_dxf command
207)  * @param[in] strm stream to read command arguments from
208)  * @return if processing command was successful
209)  */
210) bool CmdParser::procCmd_read_dxf(std::istream &strm)
211) {
212)   // get arguments
213)   std::string fileName;
214)   strm >> fileName;
215)   if (strm.fail()) {
216)     std::cerr << "missing DXF file name" << std::endl;
217)     return false;
218)   }
219) 
220)   // re-base DXF file name
221)   fileName = filename_rebase(fileName, mBaseDir);
222) 
223)   // read DXF file

224)   if (!mDrawing.loadDxf(fileName, mSettings.precision)) {

225)     std::cerr << "could not read DXF file \"" << fileName << "\""
226)               << std::endl;
227)     return false;
228)   }
229) 

230)   // improve paths in layers
231)   mDrawing.improvePaths(mSettings.precision);
232) 

233)   return true;
234) }
235) 
236) /**
237)  * @brief process set_base_z command
238)  * @param[in] strm stream to read command arguments from
239)  * @return if processing command was successful
240)  */
241) bool CmdParser::procCmd_set_base_z(std::istream &strm)
242) {
243)   // get arguments
244)   double z;
245)   strm >> z;
246)   if (strm.fail()) {
247)     std::cerr << "missing z coordinate" << std::endl;
248)     return false;
249)   }
250) 
251)   // update settings
252)   mSettings.base_z = z;
253)   return true;
254) }
255) 
256) /**
257)  * @brief process set_cut_z command
258)  * @param[in] strm stream to read command arguments from
259)  * @return if processing command was successful
260)  */
261) bool CmdParser::procCmd_set_cut_z(std::istream &strm)
262) {
263)   // get arguments
264)   double z;
265)   strm >> z;
266)   if (strm.fail()) {
267)     std::cerr << "missing z coordinate" << std::endl;
268)     return false;
269)   }
270) 
271)   // update settings
272)   mSettings.cut_z = z;
273)   return true;
274) }
275) 
276) /**
277)  * @brief process set_cut_z_step command
278)  * @param[in] strm stream to read command arguments from
279)  * @return if processing command was successful
280)  */
281) bool CmdParser::procCmd_set_cut_z_step(std::istream &strm)
282) {
283)   // get arguments and check them
284)   double z;
285)   strm >> z;
286)   if (strm.fail()) {
287)     std::cerr << "missing z value" << std::endl;
288)     return false;
289)   }
290)   if (z <= 0.0) {

291)     std::cerr << "invalid z cut step value (" << z
292)               << ", expected > 0.0)" << std::endl;

293)     return false;
294)   }
295) 
296)   // update settings
297)   mSettings.cut_z_step = z;
298)   return true;
299) }
300) 

301) /**
302)  * @brief process set_dwell_time command
303)  * @param[in] strm stream to read command arguments from
304)  * @return if processing command was successful
305)  */
306) bool CmdParser::procCmd_set_dwell_time(std::istream &strm)
307) {
308)   // get arguments and check them
309)   double dwell_time;
310)   strm >> dwell_time;
311)   if (strm.fail()) {
312)     std::cerr << "missing dwell time" << std::endl;
313)     return false;
314)   }
315)   if (dwell_time < 0.0) {

316)     std::cerr << "invalid dwell time (" << dwell_time
317)               << ", expected >= 0.0)" << std::endl;

318)     return false;
319)   }
320) 
321)   // update settings
322)   mSettings.dwell_time = dwell_time;
323)   return true;
324) }
325) 

326) /**
327)  * @brief process set_feed_drill command
328)  * @param[in] strm stream to read command arguments from
329)  * @return if processing command was successful
330)  */
331) bool CmdParser::procCmd_set_feed_drill(std::istream &strm)
332) {
333)   // get arguments and check them
334)   double feed;
335)   strm >> feed;
336)   if (strm.fail()) {
337)     std::cerr << "missing feed rate" << std::endl;
338)     return false;
339)   }
340)   if (feed <= 0.0) {

341)     std::cerr << "invalid feed rate (" << feed
342)               << ", expected > 0.0)" << std::endl;

343)     return false;
344)   }
345) 
346)   // update settings
347)   mSettings.feed_drill = feed;
348)   return true;
349) }
350) 
351) /**
352)  * @brief process set_feed_mill command
353)  * @param[in] strm stream to read command arguments from
354)  * @return if processing command was successful
355)  */
356) bool CmdParser::procCmd_set_feed_mill(std::istream &strm)
357) {
358)   // get arguments and check them
359)   double feed;
360)   strm >> feed;
361)   if (strm.fail()) {
362)     std::cerr << "missing feed rate" << std::endl;
363)     return false;
364)   }
365)   if (feed <= 0.0) {

366)     std::cerr << "invalid feed rate (" << feed
367)               << ", expected > 0.0)" << std::endl;

368)     return false;
369)   }
370) 
371)   // update settings
372)   mSettings.feed_mill = feed;
373)   return true;
374) }
375) 

376) /**
377)  * @brief process set_layer_mode command
378)  * @param[in] strm stream to read command arguments from
379)  * @return if processing command was successful
380)  */
381) bool CmdParser::procCmd_set_layer_mode(std::istream &strm)
382) {
383)   // get arguments
384)   std::string layer_mode_str;
385)   strm >> layer_mode_str;
386)   if (strm.fail()) {
387)     std::cerr << "missing layer mode (\"level_by_level\", \"path_by_path\")"
388)               << std::endl;
389)     return false;
390)   }
391) 
392)   // check argument and update settings
393)   if (layer_mode_str == "level_by_level") {
394)     mSettings.layer_mode = Settings::LevelByLevel;
395)     return true;
396)   } else if (layer_mode_str == "path_by_path") {
397)     mSettings.layer_mode = Settings::PathByPath;
398)     return true;
399)   } else {
400)     std::cerr << "invalid layer mode (\"" << layer_mode_str
401)               << "\", expected: \"level_by_level\", \"path_by_path\")"
402)               << std::endl;
403)     return false;
404)   }
405) }
406) 

407) /**
408)  * @brief process set_move_z command
409)  * @param[in] strm stream to read command arguments from
410)  * @return if processing command was successful
411)  */
412) bool CmdParser::procCmd_set_move_z(std::istream &strm)
413) {
414)   // get arguments
415)   double z;
416)   strm >> z;
417)   if (strm.fail()) {
418)     std::cerr << "missing z coordinate" << std::endl;
419)     return false;
420)   }
421) 
422)   // update settings
423)   mSettings.move_z = z;
424)   return true;
425) }
426) 

427) /**
428)  * @brief process set_offset_x command
429)  * @param[in] strm stream to read command arguments from
430)  * @return if processing command was successful
431)  */
432) bool CmdParser::procCmd_set_offset_x(std::istream &strm)
433) {
434)   // get arguments
435)   double x;
436)   strm >> x;
437)   if (strm.fail()) {
438)     std::cerr << "missing x coordinate" << std::endl;
439)     return false;
440)   }
441) 
442)   // update settings
443)   mSettings.offset_x = x;
444)   return true;
445) }
446) 
447) /**
448)  * @brief process set_offset_y command
449)  * @param[in] strm stream to read command arguments from
450)  * @return if processing command was successful
451)  */
452) bool CmdParser::procCmd_set_offset_y(std::istream &strm)
453) {
454)   // get arguments
455)   double y;
456)   strm >> y;
457)   if (strm.fail()) {
458)     std::cerr << "missing y coordinate" << std::endl;
459)     return false;
460)   }
461) 
462)   // update settings
463)   mSettings.offset_y = y;
464)   return true;
465) }
466) 

467) /**
468)  * @brief process set_precision command
469)  * @param[in] strm stream to read command arguments from
470)  * @return if processing command was successful
471)  */
472) bool CmdParser::procCmd_set_precision(std::istream &strm)
473) {
474)   // get arguments and check them
475)   double precision;
476)   strm >> precision;
477)   if (strm.fail()) {
478)     std::cerr << "missing precision" << std::endl;
479)     return false;
480)   }
481)   if (precision < 1.0e-8 || precision > 1.0) {

482)     std::cerr << "invalid precision (" << precision
483)               << ", expected 1.0e-8 ... 1.0)" << std::endl;

484)     return false;
485)   }
486) 
487)   // update settings
488)   mSettings.precision = precision;
489)   return true;
490) }
491) 

492) /**
493)  * @brief process set_tool_diameter command
494)  * @param[in] strm stream to read command arguments from
495)  * @return if processing command was successful
496)  */
497) bool CmdParser::procCmd_set_tool_diameter(std::istream &strm)
498) {
499)   // get arguments and check them
500)   double diameter;
501)   strm >> diameter;
502)   if (strm.fail()) {
503)     std::cerr << "missing tool diameter" << std::endl;
504)     return false;
505)   }
506)   if (diameter < 0.0) {

507)     std::cerr << "invalid tool diameter (" << diameter
508)               << ", expected >= 0.0)" << std::endl;

509)     return false;
510)   }
511) 
512)   // update settings
513)   mSettings.tool_diameter = diameter;
514)   return true;
515) }
516) 
517) /**
518)  * @brief process write_ngc command
519)  * @param[in] strm stream to read command arguments from
520)  * @return if processing command was successful
521)  */
522) bool CmdParser::procCmd_write_ngc(std::istream &strm)
523) {
524)   // get arguments
525)   std::string fileName;
526)   strm >> fileName;
527)   if (strm.fail()) {
528)     std::cerr << "missing NGC file name" << std::endl;
529)     return false;
530)   }
531) 
532)   // re-base NGC file name
533)   fileName = filename_rebase(fileName, mBaseDir);
534) 

535)   // calculate number of digits after decimal point
536)   unsigned int digits = (unsigned int)ceil(-log10(mSettings.precision));
537) 

538)   // write NGC file

539)   if (!mGCode.toFile(fileName, digits)) {

540)     std::cerr << "could not write NGC file \"" << fileName << "\""
541)               << std::endl;
542)     return false;
543)   }
544) 
545)   return true;
546) }
547) 
548) /**
549)  * @brief process command from line of text
550)  * @param[in] strLine line containing command to process
551)  * @return if processing command was successful
552)  */
553) bool CmdParser::procLine(const std::string &strLine)
554) {
555)   std::stringstream strm(strLine);
556) 
557)   // read command
558)   std::string cmd;
559)   strm >> cmd;
560)   if (strm.fail())
561)     return true; // ignore empty lines
562) 
563)   // commands
564)   if (cmd == "cmd")
565)     return procCmd_cmd(strm);
566)   else if (cmd == "cut")
567)     return procCmd_cut(strm);

568)   else if (cmd == "cut_inside")
569)     return procCmd_cut_inside(strm);
570)   else if (cmd == "cut_outside")
571)     return procCmd_cut_outside(strm);
572)   else if (cmd == "cut_pocket")
573)     return procCmd_cut_pocket(strm);

574)   else if (cmd == "read_dxf")
575)     return procCmd_read_dxf(strm);
576)   else if (cmd == "set_base_z")
577)     return procCmd_set_base_z(strm);
578)   else if (cmd == "set_cut_z")
579)     return procCmd_set_cut_z(strm);
580)   else if (cmd == "set_cut_z_step")
581)     return procCmd_set_cut_z_step(strm);

582)   else if (cmd == "set_dwell_time")
583)     return procCmd_set_dwell_time(strm);

584)   else if (cmd == "set_feed_drill")
585)     return procCmd_set_feed_drill(strm);
586)   else if (cmd == "set_feed_mill")
587)     return procCmd_set_feed_mill(strm);

588)   else if (cmd == "set_layer_mode")
589)     return procCmd_set_layer_mode(strm);

590)   else if (cmd == "set_move_z")
591)     return procCmd_set_move_z(strm);

592)   else if (cmd == "set_offset_x")
593)     return procCmd_set_offset_x(strm);
594)   else if (cmd == "set_offset_y")
595)     return procCmd_set_offset_y(strm);

596)   else if (cmd == "set_precision")
597)     return procCmd_set_precision(strm);