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)   // improve paths in layers
90)   mDrawing.improvePaths(mSettings.precision);
91) 

92)   return true;
93) }
94) 
95) /**
96)  * @brief process set_base_z command
97)  * @param[in] strm stream to read command arguments from
98)  * @return if processing command was successful
99)  */
100) bool CmdParser::procCmd_set_base_z(std::istream &strm)
101) {
102)   // get arguments
103)   double z;
104)   strm >> z;
105)   if (strm.fail()) {
106)     std::cerr << "missing z coordinate" << std::endl;
107)     return false;
108)   }
109) 
110)   // update settings
111)   mSettings.base_z = z;
112)   return true;
113) }
114) 
115) /**
116)  * @brief process set_cut_z command
117)  * @param[in] strm stream to read command arguments from
118)  * @return if processing command was successful
119)  */
120) bool CmdParser::procCmd_set_cut_z(std::istream &strm)
121) {
122)   // get arguments
123)   double z;
124)   strm >> z;
125)   if (strm.fail()) {
126)     std::cerr << "missing z coordinate" << std::endl;
127)     return false;
128)   }
129) 
130)   // update settings
131)   mSettings.cut_z = z;
132)   return true;
133) }
134) 
135) /**
136)  * @brief process set_cut_z_step command
137)  * @param[in] strm stream to read command arguments from
138)  * @return if processing command was successful
139)  */
140) bool CmdParser::procCmd_set_cut_z_step(std::istream &strm)
141) {
142)   // get arguments and check them
143)   double z;
144)   strm >> z;
145)   if (strm.fail()) {
146)     std::cerr << "missing z value" << std::endl;
147)     return false;
148)   }
149)   if (z <= 0.0) {
150)     std::cerr << "invalid z cut step value (" << z << ")" << std::endl;
151)     return false;
152)   }
153) 
154)   // update settings
155)   mSettings.cut_z_step = z;
156)   return true;
157) }
158) 
159) /**
160)  * @brief process set_feed_drill command
161)  * @param[in] strm stream to read command arguments from
162)  * @return if processing command was successful
163)  */
164) bool CmdParser::procCmd_set_feed_drill(std::istream &strm)
165) {
166)   // get arguments and check them
167)   double feed;
168)   strm >> feed;
169)   if (strm.fail()) {
170)     std::cerr << "missing feed rate" << std::endl;
171)     return false;
172)   }
173)   if (feed <= 0.0) {
174)     std::cerr << "invalid feed rate (" << feed << ")" << std::endl;
175)     return false;
176)   }
177) 
178)   // update settings
179)   mSettings.feed_drill = feed;
180)   return true;
181) }
182) 
183) /**
184)  * @brief process set_feed_mill command
185)  * @param[in] strm stream to read command arguments from
186)  * @return if processing command was successful
187)  */
188) bool CmdParser::procCmd_set_feed_mill(std::istream &strm)
189) {
190)   // get arguments and check them
191)   double feed;
192)   strm >> feed;
193)   if (strm.fail()) {
194)     std::cerr << "missing feed rate" << std::endl;
195)     return false;
196)   }
197)   if (feed <= 0.0) {
198)     std::cerr << "invalid feed rate (" << feed << ")" << std::endl;
199)     return false;
200)   }
201) 
202)   // update settings
203)   mSettings.feed_mill = feed;
204)   return true;
205) }
206) 
207) /**
208)  * @brief process set_move_z command
209)  * @param[in] strm stream to read command arguments from
210)  * @return if processing command was successful
211)  */
212) bool CmdParser::procCmd_set_move_z(std::istream &strm)
213) {
214)   // get arguments
215)   double z;
216)   strm >> z;
217)   if (strm.fail()) {
218)     std::cerr << "missing z coordinate" << std::endl;
219)     return false;
220)   }
221) 
222)   // update settings
223)   mSettings.move_z = z;
224)   return true;
225) }
226) 

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

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

293)   // calculate number of digits after decimal point
294)   unsigned int digits = (unsigned int)ceil(-log10(mSettings.precision));
295) 

296)   // write NGC file

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

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

340)   else if (cmd == "set_precision")
341)     return procCmd_set_precision(strm);