dxfngc

1) /* drawing (DXF) to G-code (NGC) converter
2)  * Copyright 2013 Stefan Schuermans <stefan@schuermans.info>

3)  * Copyleft: GNU public license - http://www.gnu.org/copyleft/gpl.html

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 clear_ngc command
74)  * @param[in] strm stream to read command arguments from
75)  * @return if processing command was successful
76)  */
77) bool CmdParser::procCmd_clear_ngc(std::istream &strm)
78) {
79)   // clear G-code
80)   mGCode.mGCmds.clear();
81) 
82)   return true;
83)   (void)strm;
84) }
85) 

86) /**
87)  * @brief process cmd command
88)  * @param[in] strm stream to read command arguments from
89)  * @return if processing command was successful
90)  */
91) bool CmdParser::procCmd_cmd(std::istream &strm)
92) {
93)   // skip whitespace and use rest of line as custom command
94)   strm >> std::ws;
95)   std::string cmd;
96)   getline(strm, cmd);
97) 
98)   // add custom command to G-code
99)   mGCode.appendCustom(cmd);
100) 
101)   return true;
102) }
103) 
104) /**
105)  * @brief process cut command
106)  * @param[in] strm stream to read command arguments from
107)  * @return if processing command was successful
108)  */
109) bool CmdParser::procCmd_cut(std::istream &strm)
110) {

111)   // get layer from arguments

112)   std::string layerName;

113)   const Layer *layer;
114)   if (!getLayer(strm, layerName, layer))

115)     return false;
116) 

117)   // convert layer to G-code
118)   layer->toGCode(mSettings, mGCode);
119) 
120)   return true;
121) }
122) 
123) /**
124)  * @brief process cut_inside command
125)  * @param[in] strm stream to read command arguments from
126)  * @return if processing command was successful
127)  */
128) bool CmdParser::procCmd_cut_inside(std::istream &strm)
129) {
130)   // get layer from arguments and convert to polygons
131)   std::string layerName;
132)   const Layer *layer;
133)   Polygons polys;
134)   if (!getLayerPolys(strm, layerName, layer, polys))

135)     return false;
136) 

137)   // inner offset polygons

138)   Polygons newPolys;

139)   if (!polys.createInnerOffset(mSettings.tool_diameter * 0.5, newPolys)) {
140)     std::cerr << "creating inner offset polygons failed" << std::endl;
141)     return false;
142)   }

143) 
144)   // convert polygons back to layer (containing paths)

145)   Layer newLayer;

146)   newPolys.writeToLayer(newLayer);

147)   newLayer.improvePaths(mSettings.precision);

148) 
149)   // convert layer to G-code
150)   newLayer.toGCode(mSettings, mGCode);

151) 
152)   return true;
153) }
154) 
155) /**
156)  * @brief process cut_outside command
157)  * @param[in] strm stream to read command arguments from
158)  * @return if processing command was successful
159)  */
160) bool CmdParser::procCmd_cut_outside(std::istream &strm)
161) {
162)   // get layer from arguments and convert to polygons
163)   std::string layerName;
164)   const Layer *layer;
165)   Polygons polys;
166)   if (!getLayerPolys(strm, layerName, layer, polys))
167)     return false;
168) 

169)   // outer offset polygons
170)   Polygons newPolys;
171)   if (!polys.createOuterOffset(mSettings.tool_diameter * 0.5, newPolys)) {
172)     std::cerr << "creating outer offset polygons failed" << std::endl;
173)     return false;
174)   }
175) 
176)   // convert polygons back to layer (containing paths)

177)   Layer newLayer;

178)   newPolys.writeToLayer(newLayer);

179)   newLayer.improvePaths(mSettings.precision);

180) 
181)   // convert layer to G-code
182)   newLayer.toGCode(mSettings, mGCode);

183) 
184)   return true;
185) }
186) 
187) /**
188)  * @brief process cut_pocket command
189)  * @param[in] strm stream to read command arguments from
190)  * @return if processing command was successful
191)  */
192) bool CmdParser::procCmd_cut_pocket(std::istream &strm)
193) {
194)   // get layer from arguments and convert to polygons
195)   std::string layerName;
196)   const Layer *layer;
197)   Polygons polys;
198)   if (!getLayerPolys(strm, layerName, layer, polys))
199)     return false;
200) 

201)   // fill insides of polygons by creating inner offset polygons
202)   Polygons newPolys;
203)   if (!polys.fillInnerOffset(mSettings.tool_diameter * 0.5, newPolys)) {
204)     std::cerr << "filling insides of polygons failed" << std::endl;
205)     return false;
206)   }
207) 
208)   // convert polygons back to layer (containing paths)

209)   Layer newLayer;

210)   newPolys.writeToLayer(newLayer);

211)   newLayer.improvePaths(mSettings.precision);

212) 
213)   // convert layer to G-code
214)   newLayer.toGCode(mSettings, mGCode);

215) 
216)   return true;
217) }
218) 
219) /**
220)  * @brief process read_dxf command
221)  * @param[in] strm stream to read command arguments from
222)  * @return if processing command was successful
223)  */
224) bool CmdParser::procCmd_read_dxf(std::istream &strm)
225) {
226)   // get arguments
227)   std::string fileName;
228)   strm >> fileName;
229)   if (strm.fail()) {
230)     std::cerr << "missing DXF file name" << std::endl;
231)     return false;
232)   }
233) 
234)   // re-base DXF file name
235)   fileName = filename_rebase(fileName, mBaseDir);
236) 
237)   // read DXF file

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

239)     std::cerr << "could not read DXF file \"" << fileName << "\""
240)               << std::endl;
241)     return false;
242)   }
243) 

244)   // improve paths in layers
245)   mDrawing.improvePaths(mSettings.precision);
246) 

247)   return true;
248) }
249) 
250) /**
251)  * @brief process set_base_z command
252)  * @param[in] strm stream to read command arguments from
253)  * @return if processing command was successful
254)  */
255) bool CmdParser::procCmd_set_base_z(std::istream &strm)
256) {
257)   // get arguments
258)   double z;
259)   strm >> z;
260)   if (strm.fail()) {
261)     std::cerr << "missing z coordinate" << std::endl;
262)     return false;
263)   }
264) 
265)   // update settings
266)   mSettings.base_z = z;
267)   return true;
268) }
269) 
270) /**
271)  * @brief process set_cut_z command
272)  * @param[in] strm stream to read command arguments from
273)  * @return if processing command was successful
274)  */
275) bool CmdParser::procCmd_set_cut_z(std::istream &strm)
276) {
277)   // get arguments
278)   double z;
279)   strm >> z;
280)   if (strm.fail()) {
281)     std::cerr << "missing z coordinate" << std::endl;
282)     return false;
283)   }
284) 
285)   // update settings
286)   mSettings.cut_z = z;
287)   return true;
288) }
289) 
290) /**
291)  * @brief process set_cut_z_step command
292)  * @param[in] strm stream to read command arguments from
293)  * @return if processing command was successful
294)  */
295) bool CmdParser::procCmd_set_cut_z_step(std::istream &strm)
296) {
297)   // get arguments and check them
298)   double z;
299)   strm >> z;
300)   if (strm.fail()) {
301)     std::cerr << "missing z value" << std::endl;
302)     return false;
303)   }
304)   if (z <= 0.0) {

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

307)     return false;
308)   }
309) 
310)   // update settings
311)   mSettings.cut_z_step = z;
312)   return true;
313) }
314) 

315) /**
316)  * @brief process set_dwell_time command
317)  * @param[in] strm stream to read command arguments from
318)  * @return if processing command was successful
319)  */
320) bool CmdParser::procCmd_set_dwell_time(std::istream &strm)
321) {
322)   // get arguments and check them
323)   double dwell_time;
324)   strm >> dwell_time;
325)   if (strm.fail()) {
326)     std::cerr << "missing dwell time" << std::endl;
327)     return false;
328)   }
329)   if (dwell_time < 0.0) {

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

332)     return false;
333)   }
334) 
335)   // update settings
336)   mSettings.dwell_time = dwell_time;
337)   return true;
338) }
339) 

340) /**
341)  * @brief process set_feed_drill command
342)  * @param[in] strm stream to read command arguments from
343)  * @return if processing command was successful
344)  */
345) bool CmdParser::procCmd_set_feed_drill(std::istream &strm)
346) {
347)   // get arguments and check them
348)   double feed;
349)   strm >> feed;
350)   if (strm.fail()) {
351)     std::cerr << "missing feed rate" << std::endl;
352)     return false;
353)   }
354)   if (feed <= 0.0) {

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

357)     return false;
358)   }
359) 
360)   // update settings
361)   mSettings.feed_drill = feed;
362)   return true;
363) }
364) 
365) /**
366)  * @brief process set_feed_mill command
367)  * @param[in] strm stream to read command arguments from
368)  * @return if processing command was successful
369)  */
370) bool CmdParser::procCmd_set_feed_mill(std::istream &strm)
371) {
372)   // get arguments and check them
373)   double feed;
374)   strm >> feed;
375)   if (strm.fail()) {
376)     std::cerr << "missing feed rate" << std::endl;
377)     return false;
378)   }
379)   if (feed <= 0.0) {

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

382)     return false;
383)   }
384) 
385)   // update settings
386)   mSettings.feed_mill = feed;
387)   return true;
388) }
389) 

390) /**
391)  * @brief process set_layer_mode command
392)  * @param[in] strm stream to read command arguments from
393)  * @return if processing command was successful
394)  */
395) bool CmdParser::procCmd_set_layer_mode(std::istream &strm)
396) {
397)   // get arguments
398)   std::string layer_mode_str;
399)   strm >> layer_mode_str;
400)   if (strm.fail()) {
401)     std::cerr << "missing layer mode (\"level_by_level\", \"path_by_path\")"
402)               << std::endl;
403)     return false;
404)   }
405) 
406)   // check argument and update settings
407)   if (layer_mode_str == "level_by_level") {
408)     mSettings.layer_mode = Settings::LevelByLevel;
409)     return true;
410)   } else if (layer_mode_str == "path_by_path") {
411)     mSettings.layer_mode = Settings::PathByPath;
412)     return true;
413)   } else {
414)     std::cerr << "invalid layer mode (\"" << layer_mode_str
415)               << "\", expected: \"level_by_level\", \"path_by_path\")"
416)               << std::endl;
417)     return false;
418)   }
419) }
420) 

421) /**
422)  * @brief process set_move_z command
423)  * @param[in] strm stream to read command arguments from
424)  * @return if processing command was successful
425)  */
426) bool CmdParser::procCmd_set_move_z(std::istream &strm)
427) {
428)   // get arguments
429)   double z;
430)   strm >> z;
431)   if (strm.fail()) {
432)     std::cerr << "missing z coordinate" << std::endl;
433)     return false;
434)   }
435) 
436)   // update settings
437)   mSettings.move_z = z;
438)   return true;
439) }
440) 

441) /**
442)  * @brief process set_offset_x command
443)  * @param[in] strm stream to read command arguments from
444)  * @return if processing command was successful
445)  */
446) bool CmdParser::procCmd_set_offset_x(std::istream &strm)
447) {
448)   // get arguments
449)   double x;
450)   strm >> x;
451)   if (strm.fail()) {
452)     std::cerr << "missing x coordinate" << std::endl;
453)     return false;
454)   }
455) 
456)   // update settings
457)   mSettings.offset_x = x;
458)   return true;
459) }
460) 
461) /**
462)  * @brief process set_offset_y command
463)  * @param[in] strm stream to read command arguments from
464)  * @return if processing command was successful
465)  */
466) bool CmdParser::procCmd_set_offset_y(std::istream &strm)
467) {
468)   // get arguments
469)   double y;
470)   strm >> y;
471)   if (strm.fail()) {
472)     std::cerr << "missing y coordinate" << std::endl;
473)     return false;
474)   }
475) 
476)   // update settings
477)   mSettings.offset_y = y;
478)   return true;
479) }
480) 

481) /**
482)  * @brief process set_precision command
483)  * @param[in] strm stream to read command arguments from
484)  * @return if processing command was successful
485)  */
486) bool CmdParser::procCmd_set_precision(std::istream &strm)
487) {
488)   // get arguments and check them
489)   double precision;
490)   strm >> precision;
491)   if (strm.fail()) {
492)     std::cerr << "missing precision" << std::endl;
493)     return false;
494)   }
495)   if (precision < 1.0e-8 || precision > 1.0) {

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

498)     return false;
499)   }
500) 
501)   // update settings
502)   mSettings.precision = precision;
503)   return true;
504) }
505) 

506) /**
507)  * @brief process set_rotation_z command
508)  * @param[in] strm stream to read command arguments from
509)  * @return if processing command was successful
510)  */
511) bool CmdParser::procCmd_set_rotation_z(std::istream &strm)
512) {
513)   // get arguments
514)   double z_angle;
515)   strm >> z_angle;
516)   if (strm.fail()) {
517)     std::cerr << "missing Z axis rotation angle" << std::endl;
518)     return false;
519)   }
520) 
521)   // update settings
522)   mSettings.rotation_z = z_angle;
523)   return true;
524) }
525) 

526) /**
527)  * @brief process set_scale_x command
528)  * @param[in] strm stream to read command arguments from
529)  * @return if processing command was successful
530)  */
531) bool CmdParser::procCmd_set_scale_x(std::istream &strm)
532) {
533)   // get arguments
534)   double x;
535)   strm >> x;
536)   if (strm.fail()) {
537)     std::cerr << "missing x scale factor" << std::endl;
538)     return false;
539)   }
540) 
541)   // update settings
542)   mSettings.scale_x = x;
543)   return true;
544) }
545) 
546) /**
547)  * @brief process set_scale_y command
548)  * @param[in] strm stream to read command arguments from
549)  * @return if processing command was successful
550)  */
551) bool CmdParser::procCmd_set_scale_y(std::istream &strm)
552) {
553)   // get arguments
554)   double y;
555)   strm >> y;
556)   if (strm.fail()) {
557)     std::cerr << "missing y scale factor" << std::endl;
558)     return false;
559)   }
560) 
561)   // update settings
562)   mSettings.scale_y = y;
563)   return true;
564) }
565) 

566) /**
567)  * @brief process set_tool_diameter command
568)  * @param[in] strm stream to read command arguments from
569)  * @return if processing command was successful
570)  */
571) bool CmdParser::procCmd_set_tool_diameter(std::istream &strm)
572) {
573)   // get arguments and check them
574)   double diameter;
575)   strm >> diameter;
576)   if (strm.fail()) {
577)     std::cerr << "missing tool diameter" << std::endl;
578)     return false;
579)   }
580)   if (diameter < 0.0) {

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

583)     return false;
584)   }
585) 
586)   // update settings
587)   mSettings.tool_diameter = diameter;
588)   return true;
589) }
590) 
591) /**
592)  * @brief process write_ngc command
593)  * @param[in] strm stream to read command arguments from
594)  * @return if processing command was successful
595)  */
596) bool CmdParser::procCmd_write_ngc(std::istream &strm)
597) {
598)   // get arguments
599)   std::string fileName;
600)   strm >> fileName;
601)   if (strm.fail()) {
602)     std::cerr << "missing NGC file name" << std::endl;
603)     return false;
604)   }
605) 
606)   // re-base NGC file name
607)   fileName = filename_rebase(fileName, mBaseDir);
608) 

609)   // calculate number of digits after decimal point
610)   unsigned int digits = (unsigned int)ceil(-log10(mSettings.precision));
611) 

612)   // write NGC file

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

614)     std::cerr << "could not write NGC file \"" << fileName << "\""
615)               << std::endl;
616)     return false;
617)   }
618) 
619)   return true;
620) }
621) 
622) /**
623)  * @brief process command from line of text
624)  * @param[in] strLine line containing command to process
625)  * @return if processing command was successful
626)  */
627) bool CmdParser::procLine(const std::string &strLine)
628) {
629)   std::stringstream strm(strLine);
630) 
631)   // read command
632)   std::string cmd;
633)   strm >> cmd;
634)   if (strm.fail())
635)     return true; // ignore empty lines
636) 
637)   // commands

638)   if (cmd == "clear_ngc")
639)     return procCmd_clear_ngc(strm);
640)   else if (cmd == "cmd")

641)     return procCmd_cmd(strm);
642)   else if (cmd == "cut")
643)     return procCmd_cut(strm);

644)   else if (cmd == "cut_inside")
645)     return procCmd_cut_inside(strm);
646)   else if (cmd == "cut_outside")
647)     return procCmd_cut_outside(strm);
648)   else if (cmd == "cut_pocket")
649)     return procCmd_cut_pocket(strm);

650)   else if (cmd == "read_dxf")
651)     return procCmd_read_dxf(strm);
652)   else if (cmd == "set_base_z")
653)     return procCmd_set_base_z(strm);
654)   else if (cmd == "set_cut_z")
655)     return procCmd_set_cut_z(strm);
656)   else if (cmd == "set_cut_z_step")
657)     return procCmd_set_cut_z_step(strm);

658)   else if (cmd == "set_dwell_time")
659)     return procCmd_set_dwell_time(strm);

660)   else if (cmd == "set_feed_drill")
661)     return procCmd_set_feed_drill(strm);
662)   else if (cmd == "set_feed_mill")
663)     return procCmd_set_feed_mill(strm);

664)   else if (cmd == "set_layer_mode")
665)     return procCmd_set_layer_mode(strm);

666)   else if (cmd == "set_move_z")
667)     return procCmd_set_move_z(strm);

668)   else if (cmd == "set_offset_x")
669)     return procCmd_set_offset_x(strm);
670)   else if (cmd == "set_offset_y")
671)     return procCmd_set_offset_y(strm);

672)   else if (cmd == "set_precision")
673)     return procCmd_set_precision(strm);

674)   else if (cmd == "set_rotation_z")
675)     return procCmd_set_rotation_z(strm);

676)   else if (cmd == "set_scale_x")
677)     return procCmd_set_scale_x(strm);
678)   else if (cmd == "set_scale_y")
679)     return procCmd_set_scale_y(strm);