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 "settings.h"
17) 
18) /**
19)  * @brief process cmd command
20)  * @param[in] strm stream to read command arguments from
21)  * @return if processing command was successful
22)  */
23) bool CmdParser::procCmd_cmd(std::istream &strm)
24) {
25)   // skip whitespace and use rest of line as custom command
26)   strm >> std::ws;
27)   std::string cmd;
28)   getline(strm, cmd);
29) 
30)   // add custom command to G-code
31)   mGCode.appendCustom(cmd);
32) 
33)   return true;
34) }
35) 
36) /**
37)  * @brief process cut command
38)  * @param[in] strm stream to read command arguments from
39)  * @return if processing command was successful
40)  */
41) bool CmdParser::procCmd_cut(std::istream &strm)
42) {
43)   // get arguments
44)   std::string layerName;
45)   strm >> layerName;
46)   if (strm.fail()) {
47)     std::cerr << "missing layer name" << std::endl;
48)     return false;
49)   }
50) 
51)   // get layer
52)   Drawing::Layers::const_iterator layer = mDrawing.mLayers.find(layerName);
53)   if (layer == mDrawing.mLayers.end()) {
54)     std::cerr << "layer \"" << layerName << "\" not found" << std::endl;
55)     return false;
56)   }
57) 
58)   // convert layer to G-code
59)   layer->second.toGCode(mSettings, mGCode);
60) 
61)   return true;
62) }
63) 
64) /**
65)  * @brief process read_dxf command
66)  * @param[in] strm stream to read command arguments from
67)  * @return if processing command was successful
68)  */
69) bool CmdParser::procCmd_read_dxf(std::istream &strm)
70) {
71)   // get arguments
72)   std::string fileName;
73)   strm >> fileName;
74)   if (strm.fail()) {
75)     std::cerr << "missing DXF file name" << std::endl;
76)     return false;
77)   }
78) 
79)   // re-base DXF file name
80)   fileName = filename_rebase(fileName, mBaseDir);
81) 
82)   // read DXF file
83)   if (!mDrawing.loadDxf(fileName)) {
84)     std::cerr << "could not read DXF file \"" << fileName << "\""
85)               << std::endl;
86)     return false;
87)   }
88) 
89)   return true;
90) }
91) 
92) /**
93)  * @brief process set_base_z command
94)  * @param[in] strm stream to read command arguments from
95)  * @return if processing command was successful
96)  */
97) bool CmdParser::procCmd_set_base_z(std::istream &strm)
98) {
99)   // get arguments
100)   double z;
101)   strm >> z;
102)   if (strm.fail()) {
103)     std::cerr << "missing z coordinate" << std::endl;
104)     return false;
105)   }
106) 
107)   // update settings
108)   mSettings.base_z = z;
109)   return true;
110) }
111) 
112) /**
113)  * @brief process set_cut_z command
114)  * @param[in] strm stream to read command arguments from
115)  * @return if processing command was successful
116)  */
117) bool CmdParser::procCmd_set_cut_z(std::istream &strm)
118) {
119)   // get arguments
120)   double z;
121)   strm >> z;
122)   if (strm.fail()) {
123)     std::cerr << "missing z coordinate" << std::endl;
124)     return false;
125)   }
126) 
127)   // update settings
128)   mSettings.cut_z = z;
129)   return true;
130) }
131) 
132) /**
133)  * @brief process set_cut_z_step command
134)  * @param[in] strm stream to read command arguments from
135)  * @return if processing command was successful
136)  */
137) bool CmdParser::procCmd_set_cut_z_step(std::istream &strm)
138) {
139)   // get arguments and check them
140)   double z;
141)   strm >> z;
142)   if (strm.fail()) {
143)     std::cerr << "missing z value" << std::endl;
144)     return false;
145)   }
146)   if (z <= 0.0) {
147)     std::cerr << "invalid z cut step value (" << z << ")" << std::endl;
148)     return false;
149)   }
150) 
151)   // update settings
152)   mSettings.cut_z_step = z;
153)   return true;
154) }
155) 
156) /**
157)  * @brief process set_feed_drill command
158)  * @param[in] strm stream to read command arguments from
159)  * @return if processing command was successful
160)  */
161) bool CmdParser::procCmd_set_feed_drill(std::istream &strm)
162) {
163)   // get arguments and check them
164)   double feed;
165)   strm >> feed;
166)   if (strm.fail()) {
167)     std::cerr << "missing feed rate" << std::endl;
168)     return false;
169)   }
170)   if (feed <= 0.0) {
171)     std::cerr << "invalid feed rate (" << feed << ")" << std::endl;
172)     return false;
173)   }
174) 
175)   // update settings
176)   mSettings.feed_drill = feed;
177)   return true;
178) }
179) 
180) /**
181)  * @brief process set_feed_mill command
182)  * @param[in] strm stream to read command arguments from
183)  * @return if processing command was successful
184)  */
185) bool CmdParser::procCmd_set_feed_mill(std::istream &strm)
186) {
187)   // get arguments and check them
188)   double feed;
189)   strm >> feed;
190)   if (strm.fail()) {
191)     std::cerr << "missing feed rate" << std::endl;
192)     return false;
193)   }
194)   if (feed <= 0.0) {
195)     std::cerr << "invalid feed rate (" << feed << ")" << std::endl;
196)     return false;
197)   }
198) 
199)   // update settings
200)   mSettings.feed_mill = feed;
201)   return true;
202) }
203) 
204) /**
205)  * @brief process set_move_z command
206)  * @param[in] strm stream to read command arguments from
207)  * @return if processing command was successful
208)  */
209) bool CmdParser::procCmd_set_move_z(std::istream &strm)
210) {
211)   // get arguments
212)   double z;
213)   strm >> z;
214)   if (strm.fail()) {
215)     std::cerr << "missing z coordinate" << std::endl;
216)     return false;
217)   }
218) 
219)   // update settings
220)   mSettings.move_z = z;
221)   return true;
222) }
223) 

224) /**
225)  * @brief process set_precision command
226)  * @param[in] strm stream to read command arguments from
227)  * @return if processing command was successful
228)  */
229) bool CmdParser::procCmd_set_precision(std::istream &strm)
230) {
231)   // get arguments and check them
232)   double precision;
233)   strm >> precision;
234)   if (strm.fail()) {
235)     std::cerr << "missing precision" << std::endl;
236)     return false;
237)   }
238)   if (precision < 1.0e-8 || precision > 1.0) {
239)     std::cerr << "invalid precision (" << precision << ")" << std::endl;
240)     return false;
241)   }
242) 
243)   // update settings
244)   mSettings.precision = precision;
245)   return true;
246) }
247) 

248) /**
249)  * @brief process set_tool_diameter command
250)  * @param[in] strm stream to read command arguments from
251)  * @return if processing command was successful
252)  */
253) bool CmdParser::procCmd_set_tool_diameter(std::istream &strm)
254) {
255)   // get arguments and check them
256)   double diameter;
257)   strm >> diameter;
258)   if (strm.fail()) {
259)     std::cerr << "missing tool diameter" << std::endl;
260)     return false;
261)   }
262)   if (diameter < 0.0) {
263)     std::cerr << "invalid tool diameter (" << diameter << ")" << std::endl;
264)     return false;
265)   }
266) 
267)   // update settings
268)   mSettings.tool_diameter = diameter;
269)   return true;
270) }
271) 
272) /**
273)  * @brief process write_ngc command
274)  * @param[in] strm stream to read command arguments from
275)  * @return if processing command was successful
276)  */
277) bool CmdParser::procCmd_write_ngc(std::istream &strm)
278) {
279)   // get arguments
280)   std::string fileName;
281)   strm >> fileName;
282)   if (strm.fail()) {
283)     std::cerr << "missing NGC file name" << std::endl;
284)     return false;
285)   }
286) 
287)   // re-base NGC file name
288)   fileName = filename_rebase(fileName, mBaseDir);
289) 

290)   // calculate number of digits after decimal point
291)   unsigned int digits = (unsigned int)ceil(-log10(mSettings.precision));
292) 

293)   // write NGC file

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

295)     std::cerr << "could not write NGC file \"" << fileName << "\""
296)               << std::endl;
297)     return false;
298)   }
299) 
300)   return true;
301) }
302) 
303) /**
304)  * @brief process command from line of text
305)  * @param[in] strLine line containing command to process
306)  * @return if processing command was successful
307)  */
308) bool CmdParser::procLine(const std::string &strLine)
309) {
310)   std::stringstream strm(strLine);
311) 
312)   // read command
313)   std::string cmd;
314)   strm >> cmd;
315)   if (strm.fail())
316)     return true; // ignore empty lines
317) 
318)   // commands
319)   if (cmd == "cmd")
320)     return procCmd_cmd(strm);
321)   else if (cmd == "cut")
322)     return procCmd_cut(strm);
323)   else if (cmd == "read_dxf")
324)     return procCmd_read_dxf(strm);
325)   else if (cmd == "set_base_z")
326)     return procCmd_set_base_z(strm);
327)   else if (cmd == "set_cut_z")
328)     return procCmd_set_cut_z(strm);
329)   else if (cmd == "set_cut_z_step")
330)     return procCmd_set_cut_z_step(strm);
331)   else if (cmd == "set_feed_drill")
332)     return procCmd_set_feed_drill(strm);
333)   else if (cmd == "set_feed_mill")
334)     return procCmd_set_feed_mill(strm);
335)   else if (cmd == "set_move_z")
336)     return procCmd_set_move_z(strm);

337)   else if (cmd == "set_precision")
338)     return procCmd_set_precision(strm);