new ip

plotter-app/venv/lib/python3.8/site-packages/svg_to_gcode-1.5.4.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: svg-to-gcode
+Version: 1.5.4
+Summary: The definitive NPM module to construct gcode from svg files.
+Home-page: https://github.com/PadLex/SvgToGcode
+Author: Padlex
+Author-email: 
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+
+# Svg to Gcode - Flamma project
+### The definitive NPM module to construct gcode from svg files.
+Don't feel like coding? Use the [Inkscape extension](https://github.com/JTechPhotonics/J-Tech-Photonics-Laser-Tool).
+
+This library's intended purpose is to laser-cut svg images. However, it is structured such that it can be easily 
+expanded to parse other image formats or compile to different numerical control languages. 
+
+* [Installation](#Installation)
+* [Documentation](#Documentation)
+    * [Basic Usage](#Basic-Usage)
+    * [Custom interfaces](#Custom-interfaces)
+    * [Insert or Modify Geometry](#Insert-or-Modify-Geometry)
+    * [Approximation tolerance](#Approximation-tolerance)
+    * [Support for additional formats](#Support-for-additional-formats)
+* [Contribution guidelines](CONTRIBUTING.md)
+
+
+## Installation
+Svg to Gcode is available on pip. To install it, execute:
+> pip install svg-to-gcode
+
+Of course, you could also just download the sourcecode.
+
+## Documentation
+The module is divided in three sub-modules:
+* svg_to_gcode.**geometry** offers a general representation of geometric curves.
+* svg_to_gcode.**parser** parses svg files, converting them to geometric curves.
+* svg_to_gcode.**compiler** transforms geometric curves into gcode. 
+
+### Basic Usage
+If all you need is to compile an svg image to gcode, for a standard cnc machine, this is all the code you need. Just 
+remember to select your own cutting and movement speeds.  
+
+```python
+from svg_to_gcode.svg_parser import parse_file
+from svg_to_gcode.compiler import Compiler, interfaces
+
+# Instantiate a compiler, specifying the interface type and the speed at which the tool should move. pass_depth controls
+# how far down the tool moves after every pass. Set it to 0 if your machine does not support Z axis movement.
+gcode_compiler = Compiler(interfaces.Gcode, movement_speed=1000, cutting_speed=300, pass_depth=5)
+
+curves = parse_file("drawing.svg") # Parse an svg file into geometric curves
+
+gcode_compiler.append_curves(curves) 
+gcode_compiler.compile_to_file("drawing.gcode", passes=2)
+```
+
+### Custom interfaces
+Interfaces exist to abstract commands used by the compiler. In this way, you can compile for a non-standard printer or 
+to a completely new numerical control language without modifying the compiler. You can easily write custom interfaces to
+ perform additional operations (like powering a fan) or to modify the gcode commands used to perform existing operations
+  (some DIY laser cutters, for example, control the laser diode from the fan output). 
+
+The code bellow implements a custom interface which powers on a fan every time the laser is powered on. 
+```python
+from svg_to_gcode.svg_parser import parse_file
+from svg_to_gcode.compiler import Compiler, interfaces
+from svg_to_gcode.formulas import linear_map
+
+class CustomInterface(interfaces.Gcode):
+    def __init__(self):
+        super().__init__()
+        self.fan_speed = 1
+
+    # Override the laser_off method such that it also powers off the fan.
+    def laser_off(self):
+        return "M107;\n" + "M5;"  # Turn off the fan + turn off the laser
+
+    # Override the set_laser_power method
+    def set_laser_power(self, power):
+        if power < 0 or power > 1:
+            raise ValueError(f"{power} is out of bounds. Laser power must be given between 0 and 1. "
+                             f"The interface will scale it correctly.")
+
+        return f"M106 S255\n" + f"M3 S{linear_map(0, 255, power)};"  # Turn on the fan + change laser power
+
+# Instantiate a compiler, specifying the custom interface and the speed at which the tool should move.
+gcode_compiler = Compiler(CustomInterface, movement_speed=1000, cutting_speed=300, pass_depth=5)
+
+curves = parse_file("drawing.svg") # Parse an svg file into geometric curves
+
+gcode_compiler.append_curves(curves) 
+gcode_compiler.compile_to_file("drawing.gcode")
+```
+
+### Insert or Modify Geometry
+
+Before compiling, you could append or modify geometric curves. I'm not sure why you would want to, but you can.
+The code below draws a fractal and compiles it to gcode.
+
+```python
+from svg_to_gcode.svg_parser import parse_file
+from svg_to_gcode.compiler import Compiler, interfaces
+from svg_to_gcode.formulas import linear_map
+
+# Instantiate a compiler, specifying the custom interface and the speed at which the tool should move.
+gcode_compiler = Compiler(interfaces.Gcode, movement_speed=1000, cutting_speed=300, pass_depth=5)
+
+curves = parse_file("drawing.svg") # Parse an svg file into geometric curves
+
+gcode_compiler.append_curves(curves) 
+gcode_compiler.compile_to_file("drawing.gcode")
+```
+
+### Approximation tolerance
+Gcode only supports liner and circular arcs. Currently I've only implemented a line segment approximation. As such, 
+geometric curves are compiled to a chain of line-segments. The exact length of the segments is adjusted dynamically such
+that it never diverges from the original curve by more then the value of the TOLERANCES['approximation'] key.
+
+The default value is 0.1. Smaller values improve accuracy, larger ones result in shorter gcode files.
+
+```python
+from svg_to_gcode import TOLERANCES
+
+TOLERANCES['approximation'] = 0.01
+```
+
+
+### Support for additional formats
+For now, this library only converts svgs to gcode files. However, its modular design makes it simple to 
+support other formats. If you're looking to support a specific format, pull requests are always welcome. Just make sure 
+to read [CONTRIBUTING.md](CONTRIBUTING.md) to get a feeling for the internal structure and best practices.
+
+