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) 
134)   // convert layer to G-code
135)   newLayer.toGCode(mSettings, mGCode);

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

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

162)   Layer newLayer;

163)   newPolys.writeToLayer(newLayer);

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

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

187)   Layer newLayer;
188)   polys.writeToLayer(newLayer);
189) 
190)   // convert layer to G-code
191)   newLayer.toGCode(mSettings, mGCode);

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

221)   // improve paths in layers
222)   mDrawing.improvePaths(mSettings.precision);
223) 

224)   return true;
225) }
226) 
227) /**
228)  * @brief process set_base_z command
229)  * @param[in] strm stream to read command arguments from
230)  * @return if processing command was successful
231)  */
232) bool CmdParser::procCmd_set_base_z(std::istream &strm)
233) {
234)   // get arguments
235)   double z;
236)   strm >> z;
237)   if (strm.fail()) {
238)     std::cerr << "missing z coordinate" << std::endl;
239)     return false;
240)   }
241) 
242)   // update settings
243)   mSettings.base_z = z;
244)   return true;
245) }
246) 
247) /**
248)  * @brief process set_cut_z command
249)  * @param[in] strm stream to read command arguments from
250)  * @return if processing command was successful
251)  */
252) bool CmdParser::procCmd_set_cut_z(std::istream &strm)
253) {
254)   // get arguments
255)   double z;
256)   strm >> z;
257)   if (strm.fail()) {
258)     std::cerr << "missing z coordinate" << std::endl;
259)     return false;
260)   }
261) 
262)   // update settings
263)   mSettings.cut_z = z;
264)   return true;
265) }
266) 
267) /**
268)  * @brief process set_cut_z_step command
269)  * @param[in] strm stream to read command arguments from
270)  * @return if processing command was successful
271)  */
272) bool CmdParser::procCmd_set_cut_z_step(std::istream &strm)
273) {
274)   // get arguments and check them
275)   double z;
276)   strm >> z;
277)   if (strm.fail()) {
278)     std::cerr << "missing z value" << std::endl;
279)     return false;
280)   }
281)   if (z <= 0.0) {
282)     std::cerr << "invalid z cut step value (" << z << ")" << std::endl;
283)     return false;
284)   }
285) 
286)   // update settings
287)   mSettings.cut_z_step = z;
288)   return true;
289) }
290) 
291) /**
292)  * @brief process set_feed_drill command
293)  * @param[in] strm stream to read command arguments from
294)  * @return if processing command was successful
295)  */
296) bool CmdParser::procCmd_set_feed_drill(std::istream &strm)
297) {
298)   // get arguments and check them
299)   double feed;
300)   strm >> feed;
301)   if (strm.fail()) {
302)     std::cerr << "missing feed rate" << std::endl;
303)     return false;
304)   }
305)   if (feed <= 0.0) {
306)     std::cerr << "invalid feed rate (" << feed << ")" << std::endl;
307)     return false;
308)   }
309) 
310)   // update settings
311)   mSettings.feed_drill = feed;
312)   return true;
313) }
314) 
315) /**
316)  * @brief process set_feed_mill command
317)  * @param[in] strm stream to read command arguments from
318)  * @return if processing command was successful
319)  */
320) bool CmdParser::procCmd_set_feed_mill(std::istream &strm)
321) {
322)   // get arguments and check them
323)   double feed;
324)   strm >> feed;
325)   if (strm.fail()) {
326)     std::cerr << "missing feed rate" << std::endl;
327)     return false;
328)   }
329)   if (feed <= 0.0) {
330)     std::cerr << "invalid feed rate (" << feed << ")" << std::endl;
331)     return false;
332)   }
333) 
334)   // update settings
335)   mSettings.feed_mill = feed;
336)   return true;
337) }
338) 
339) /**
340)  * @brief process set_move_z command
341)  * @param[in] strm stream to read command arguments from
342)  * @return if processing command was successful
343)  */
344) bool CmdParser::procCmd_set_move_z(std::istream &strm)
345) {
346)   // get arguments
347)   double z;
348)   strm >> z;
349)   if (strm.fail()) {
350)     std::cerr << "missing z coordinate" << std::endl;
351)     return false;
352)   }
353) 
354)   // update settings
355)   mSettings.move_z = z;
356)   return true;
357) }
358) 

359) /**
360)  * @brief process set_precision command
361)  * @param[in] strm stream to read command arguments from
362)  * @return if processing command was successful
363)  */
364) bool CmdParser::procCmd_set_precision(std::istream &strm)
365) {
366)   // get arguments and check them
367)   double precision;
368)   strm >> precision;
369)   if (strm.fail()) {
370)     std::cerr << "missing precision" << std::endl;
371)     return false;
372)   }
373)   if (precision < 1.0e-8 || precision > 1.0) {
374)     std::cerr << "invalid precision (" << precision << ")" << std::endl;
375)     return false;
376)   }
377) 
378)   // update settings
379)   mSettings.precision = precision;
380)   return true;
381) }
382) 

383) /**
384)  * @brief process set_tool_diameter command
385)  * @param[in] strm stream to read command arguments from
386)  * @return if processing command was successful
387)  */
388) bool CmdParser::procCmd_set_tool_diameter(std::istream &strm)
389) {
390)   // get arguments and check them
391)   double diameter;
392)   strm >> diameter;
393)   if (strm.fail()) {
394)     std::cerr << "missing tool diameter" << std::endl;
395)     return false;
396)   }
397)   if (diameter < 0.0) {
398)     std::cerr << "invalid tool diameter (" << diameter << ")" << std::endl;
399)     return false;
400)   }
401) 
402)   // update settings
403)   mSettings.tool_diameter = diameter;
404)   return true;
405) }
406) 
407) /**
408)  * @brief process write_ngc command
409)  * @param[in] strm stream to read command arguments from
410)  * @return if processing command was successful
411)  */
412) bool CmdParser::procCmd_write_ngc(std::istream &strm)
413) {
414)   // get arguments
415)   std::string fileName;
416)   strm >> fileName;
417)   if (strm.fail()) {
418)     std::cerr << "missing NGC file name" << std::endl;
419)     return false;
420)   }
421) 
422)   // re-base NGC file name
423)   fileName = filename_rebase(fileName, mBaseDir);
424) 

425)   // calculate number of digits after decimal point
426)   unsigned int digits = (unsigned int)ceil(-log10(mSettings.precision));
427) 

428)   // write NGC file

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

430)     std::cerr << "could not write NGC file \"" << fileName << "\""
431)               << std::endl;
432)     return false;
433)   }
434) 
435)   return true;
436) }
437) 
438) /**
439)  * @brief process command from line of text
440)  * @param[in] strLine line containing command to process
441)  * @return if processing command was successful
442)  */
443) bool CmdParser::procLine(const std::string &strLine)
444) {
445)   std::stringstream strm(strLine);
446) 
447)   // read command
448)   std::string cmd;
449)   strm >> cmd;
450)   if (strm.fail())
451)     return true; // ignore empty lines
452) 
453)   // commands
454)   if (cmd == "cmd")
455)     return procCmd_cmd(strm);
456)   else if (cmd == "cut")
457)     return procCmd_cut(strm);

458)   else if (cmd == "cut_inside")
459)     return procCmd_cut_inside(strm);
460)   else if (cmd == "cut_outside")
461)     return procCmd_cut_outside(strm);
462)   else if (cmd == "cut_pocket")
463)     return procCmd_cut_pocket(strm);

464)   else if (cmd == "read_dxf")
465)     return procCmd_read_dxf(strm);
466)   else if (cmd == "set_base_z")
467)     return procCmd_set_base_z(strm);
468)   else if (cmd == "set_cut_z")
469)     return procCmd_set_cut_z(strm);
470)   else if (cmd == "set_cut_z_step")
471)     return procCmd_set_cut_z_step(strm);
472)   else if (cmd == "set_feed_drill")
473)     return procCmd_set_feed_drill(strm);
474)   else if (cmd == "set_feed_mill")
475)     return procCmd_set_feed_mill(strm);
476)   else if (cmd == "set_move_z")
477)     return procCmd_set_move_z(strm);

478)   else if (cmd == "set_precision")
479)     return procCmd_set_precision(strm);