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 <list>

7) 
8) #include "gcode.h"
9) #include "layer.h"
10) #include "path.h"
11) #include "settings.h"
12) 
13) /**
14)  * @brief add a new empty path to the layer
15)  * @return reference to new empty path
16)  */
17) Path & Layer::addPath()
18) {
19)   mPaths.push_back(Path());
20)   return mPaths.back();
21) }
22) 

23) /**
24)  * @brief improve paths
25)  * @param[in] eqDist maximum distance of two points to be considered equal
26)  */
27) void Layer::improvePaths(double eqDist)
28) {

29)   Paths::iterator path, other, best;

30)   bool change;

31)   double smallest, dist;

32) 

33)   // remove empty paths
34)   path = mPaths.begin();
35)   while (path != mPaths.end())
36)     if (path->mPoints.empty())
37)       path = mPaths.erase(path);
38)     else
39)       ++path;
40) 

41)   // join paths with equal begin/end points
42)   do {
43)     change = false;

44)     // process all paths

45)     for (path = mPaths.begin(); path != mPaths.end(); ++path) {

46)       // check all paths following aftet the current one

47)       other = path;
48)       ++other;
49)       while (other != mPaths.end()) {

50)         // paths can be joined

51)         if (other->mPoints.front().equals(path->mPoints.back(),
52)                                           eqDist)) {
53)           path->appendPath(*other);
54)           other = mPaths.erase(other);
55)           change = true;
56)         }
57)         else if (other->mPoints.back().equals(path->mPoints.back(),
58)                                               eqDist)) {
59)           path->appendReversedPath(*other);
60)           other = mPaths.erase(other);
61)           change = true;
62)         }
63)         else if (other->mPoints.back().equals(path->mPoints.front(),
64)                                               eqDist)) {
65)           path->prependPath(*other);
66)           other = mPaths.erase(other);
67)           change = true;
68)         }
69)         else if (other->mPoints.front().equals(path->mPoints.front(),
70)                                                eqDist)) {
71)           path->prependReversedPath(*other);
72)           other = mPaths.erase(other);
73)           change = true;
74)         }

75)         // paths cannot be joined -> move to next one

76)         else
77)           ++other;

78)       } // while other
79)     } // for path

80)   } while (change);
81) 
82)   // remove nearby points in paths
83)   for (path = mPaths.begin(); path != mPaths.end(); ++path)
84)     path->removeEqPoints(eqDist);
85) 
86)   // remove empty paths
87)   path = mPaths.begin();
88)   while (path != mPaths.end())
89)     if (path->mPoints.empty())
90)       path = mPaths.erase(path);
91)     else
92)       ++path;

93) 
94)   // sort paths to minimize unproductive move distance
95)   for (path = mPaths.begin(); path != mPaths.end(); ++path) {
96)     // find path starting at closest distance from current paths end
97)     other = path;
98)     ++other;
99)     best = mPaths.end();
100)     while (other != mPaths.end()) {
101)       // calculate (squared) distance from path.end to other.begin
102)       //   path and other are never empty here
103)       //   empty paths have been removed before
104)       dist = (path->mPoints.back() - other->mPoints.front()).abs_sq();
105)       // keep path with smallest (squared) distance
106)       if (best == mPaths.end() || dist < smallest) {
107)         best = other;
108)         smallest = dist;
109)       }
110)       ++other;
111)     } // while other
112)     // use best path as next one, i.e. swap best path with next one
113)     other = path;
114)     other++;
115)     if (other != mPaths.end() && best != mPaths.end())
116)       mPaths.splice(other, mPaths, best);
117)   } // for path

118) }
119) 

120) /**
121)  * @brief convert layer to G-code
122)  * @param[in] settings G-code creation settings
123)  * @param[in,out] gcode new G-code is appended to existing G-code
124)  */
125) void Layer::toGCode(const Settings &settings, GCode &gcode) const
126) {

127)   double z;
128)   Paths::const_iterator path;
129) 
130)   switch (settings.layer_mode) {
131) 
132)     case Settings::LevelByLevel:
133) 
134)       // cut step-wise
135)       z = settings.base_z;
136)       do {
137)         z -= settings.cut_z_step;
138)         if (z < settings.cut_z)
139)           z = settings.cut_z;
140) 
141)         // cut all paths at current z
142)         for (path = mPaths.begin(); path != mPaths.end(); ++path)
143)           path->toGCode(settings, z, gcode);
144) 
145)       } while (z > settings.cut_z);
146) 
147)       break;
148) 
149)     case Settings::PathByPath:
150) 
151)       // cut each path
152)       for (path = mPaths.begin(); path != mPaths.end(); ++path) {
153) 
154)         // cut current path step-wise
155)         z = settings.base_z;
156)         do {
157)           z -= settings.cut_z_step;
158)           if (z < settings.cut_z)
159)             z = settings.cut_z;
160)           path->toGCode(settings, z, gcode);
161)         } while (z > settings.cut_z);
162) 
163)       } // for path

164) 

165)       break;

166) 

167)   } // switch (settings.layer_mode)