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)     smallest = 0;

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

119) }
120) 

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

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

165) 

166)       break;

167) 

168)   } // switch (settings.layer_mode)