FabLab Chemnitz About/Upgrade MightyScape Get MightyScape by Git Primary:  Readme + Download + Issues (Github) Secondary: Readme + Download (Gitea) Alternative downloads available . Check the README.md on Git Spread the word https://y.stadtfabrikanten.org/mightyscape.qr https://y.stadtfabrikanten.org/mightyscape Animation Animate Order Create animated SVG preview file and show it in browser. Helps to quickly evaluate line order for cutting processes. Only applies for the complete Inkscape document. Tips Do not use "-inkscape-stroke:hairline" attribute for your paths. It will not render. Your page might be blank! If multiple paths are animated simultaneously, break apart paths into sub paths. Each sub path will start a new animation in parallel. start your browser indepently from Inkscape before running this extension . Each call we open a new browser tab then. If your browser is closed initially, the Inkscape extension will call a new process window, but Inkscape is blocked until browser is closed again. Config / Troubleshooting Browser in path Select your desired browser (must be installed and must exist in %PATH% variable). If this is not the case, configure it: Windows (Systemsteuerung\Alle Systemsteuerungselemente\System → Umgebungsvariablen) Firefox adjustments If SVG does not animate, check if file access is enabled Visit about:config → set " privacy.file_unique_origin " to " false " Still no animation? break apart paths to sub paths Raise duration time to larger value More Info https://github.com/maxwellito/vivus https://github.com/maxwellito/vivus-instant h ttp://maxwellito.github.io/vivus https://maxwellito.github.io/vivus-instan t See also Line Animator C:\Program Files\Mozilla Firefox\ Convert animated SVG to Videos/GIFs There are a lot of tools on the net but most do not work properly. Best is to use a screen capturing tool like https://wiki.ubuntuusers.de/Kazam to capture. This video can be converted to animated gif afterwards. Install Kazam on Fedora: sudo dnf install keybinder sudo dnf install python3-xlib wget https://raw.githubusercontent.com/rpmsphere/noarch/master/k/kazam-1.5.3-1.1.noarch.rpm sudo rpm -Uvh kazam-1.5.3-1.1.noarch.rpm Install Kazam on Ubuntu: sudo apt install kazam Frame Animation Sequence Source: https://github.com/yttiktak/inkscape_extension_animate Create svg path animation from frames: Place each frame of the animation in a layer named 'frame'. Each of these layers should have the same number of paths, and each path should have the same number of points as the corresponding path in other layers. The animation is applied to the paths in the first layer in the sequence, so the properties of that layer are used. Animations with different numbers of frames can be put into different sequences, named 'sequence', using sub-groups: Layers structure example  not_animated_layer1 sequence frame  path1a  path2a frame  path1b  path2b frame  path1c  path2c frame  path1d  path2d sequence frame frame frame  Use layer named exactly 'frame' and groups named exactly 'sequence', not, eg, frame1 frame2 frame3 ! SVG Example The svg:animate elements were created using this extension Visual Output: Line Animator Inkscape extension for animating paths, so it looks as if they were being drawn by hand, using CSS3 animations. Source: https://gitlab.com/Moini/ink_line_animator Example See also Animate Order Colors/Gradients/Filters Cleanup Styles This plugin is a bit similar to Blueprint Maker but has a more special use case and a lot of options! It is useful for adjusting the stroke width and opacity of large groups. Usually for good laser cutting the line width has to match a maximum width to be recognized as a hairline . Additionally, often opacity issues cause that lines are missed by laser cutter. Conversion information 1 pt = 0,352 mm = 0,0138889 in 0,0283 pt = 0,01 mm Color Harmony Open some document and select an object Result Generate Palette Source: https://github.com/olibia/inkscape-generate-palette Usage Create objects with color properties set, can be fill and/or stroke color. Select them and from the Extensions menu choose Palette and Generate. Provide a name and select the color property to grab colors from. You can also include Inkscape's default black to white colors or replace an existing palette. Notes Inkscape must be restarted for a new palette to appear. Generated palettes are located at ~/.config/inkscape/palettes or ~\AppData\Roaming\inkscape\palettes on Windows. You can delete them accessing that folder Gradient Saver Grey to MonoAlpha Converts a greyscale vector graphic to monochrome with variable opacity. Threshold setting to avoid solid colors Can be applied to stroke, fill or both Does not work for gradients! Does not work for groups. You need to pick single elements! Example Output (left image is original, right is modified) Jitter Gradients Source: https://inkscape.org/~vermette/%E2%98%85jitter-gradients Take a large selection of elements with gradients and randomly move their endpoints. Ideal when working with a large number of tiles, placing a large overarching gradient, then jittering to add texture. Replace Color And Alpha This is a plugin working for vector stuff. It's not intended to use on raster images. It's a legacy extension. Draw some path with infill (example Color #510000) Run the extension Get the result Just use the default Inkscape search+replace. This works much better! Stroke Color As Fill Example Output Cutting/Plotting/Printing Inventory Sticker This extension generates inventory stickers for thermo printers (we use Brother QL-720NW) from our Teedy instance. Teedy is an open source software document management system (DMS). Complete details can be found at 2. Etikettenkonzept and 3. Druckerkonzept . This extension is tested in Linux (Ubuntu 20 LTS) and Windows 10. Source code can be found in https://gitea.fablabchemnitz.de/FabLab_Chemnitz/mightyscape-1.2/src/branch/master/extensions/fablabchemnitz The required python module brother_ql will be installed by MightyScape requirements automatically. It might be required to add additional permissions for the user. See 3. Druckerkonzept . 100 characters in the title (maximum possible) 42 characters in the title (usual lengths) Laser Check Printing Marks Dotted This extension is an older legacy version of "Extensions → Render → Layout → Printing Marks" with small difference for offering dotted crop marks Silhouette Cameo Registration Marks Source: https://github.com/miLORD1337/silhouette-regmarks Simple Registration Dimensioning/Measuring Colorize Path Lengths / Slants This tool will help to identify paths of certain lengths to maybe delete or modify them. Please also see Filter By Length/Area which behaves similar but non-visual. Example output (left original, right is extension result) Dimensioning (Replaced by LPE) We can use the same feature by Live Path Effect: Shirt Waist (Sara May Allington) Outline the cutting lines → Ctrl + ) Move the outlines next to the current selection to see the solid lines Show Path Coordinates This extension prints X,Y coordinates of selected path nodes. Can be helpful for debugging things. Draw some path Run extension Grids/Guides Bobbin Lace - Circular Ground From Template Source of documentation: https://d-bl.github.io/inkscape-bobbinlace/Ground-from-Template Example Output See also Bobbin Lace - Regular Grid Bobbin Lace - Ground From Template Bobbin Lace - Polar Grid Bobbin Lace - Ground From Template Source of documentation: https://d-bl.github.io/inkscape-bobbinlace/Ground-from-Template Nice to have: good templates from https://tesselace.com/tools/inkscape-extension See also Bobbin Lace - Regular Grid Bobbin Lace - Circular Ground From Template Bobbin Lace - Polar Grid Bobbin Lace - Polar Grid Source of documentation: https://d-bl.github.io/inkscape-bobbinlace/Polar-Grids Example Output See also Bobbin Lace - Regular Grid Bobbin Lace - Circular Ground From Template Bobbin Lace - Ground From Template Bobbin Lace - Regular Grid Source of documentation: https://d-bl.github.io/inkscape-bobbinlace/Regular-Grids Example Output See also Bobbin Lace - Circular Ground From Template Bobbin Lace - Ground From Template Bobbin Lace - Polar Grid Card Layout Guides Example Output Checkerboard Example Output   Create Hexmap See also Hex Tiles Example Output Hex Tiles Example Output Insert Paper Template Example Output Label Guides Source: https://github.com/johnbeard/inkscape-label-guides Example Output Perspective Grid Example Output Remove Duplicate Guides This extension removes guides which are identical (overlapping), means they have the same position and orientation. You can test it the following way: Draw some line and duplicate it using CTRL + D Check XML structure having 2 paths now Convert both paths to guides pressing SHIFT + G Now run the extension We will see that one guide was removed Triangular Grid Example Output You can convert this to regular grid ("Objects to Guides") pressing SHIFT + G to get Groups and Layers Eraser Layer This plugin will erase selected shapes in same layer. Ueful for objects! It won't remove the original objects Draw some objects and put them on the same layer Select some objects to erase (leave a hole in layer) and run extension Filter To Layer Source: https://inkscape.org/~jabiertxof/%E2%98%85filter-layer Draw some object and and apply some filter Check the XML structure Run the extension and get results "Filter to current layer" → choose "add" The layer got some new attribute "style" with filter:url content Group To Layer This extension converts groups to layers. You can pick the desired depth. Draw some objects and make some groups Run the extension Remove Empty Groups This extension is totally minimal. It will just clean the whole document from groups without content (dangling groups). That usually happens if you have a group but remove it's paths for example. The group will possibly stay in the XML tree. This also applies for layers because layers are just special types of groups. See also  Optimized with svgo (*.svg) Styles To Layers This extension will re-layer your selected items or the whole document according to their color (stroke or fill). Each style will be put onto it's own layer. This way you can devide elements by their colors with ease. If you have empty layers after sorting with different types (strokes, then first or vice versa) you can use Remove Empty Groups to cleanup. You can use the separate Cleanup Styles extension to migrate these separated attributes into style attribute. This extension has possible parallels with https://wiki.evilmadscientist.com/Inkscape_and_WaterColorBot#Snap_Colors_to_Layers_.28beta.29 Ungrouper And Element Migrator/Filter This extension parses the selection and will put all elements into one single group. If you have a cluster with lots of groups and elements you will clean up this way (one top level group, all elements below it). If you select a single element or a set of elements you just wrap it like using CTRL + G (like making a usual group). You can also use this extension to filter out unwanted SVG elements at all. If your drawing gets wasted by running this extension please use Apply Transformations before because your groups just may contain some unwanted transformations like scalings and shiftings. If you have empty layers after sorting with different types (strokes, then first or vice versa) you can use Remove Empty Groups to cleanup. See also  Optimized with svgo (*.svg) Import/Export/Transfer Clip Out Source: https://gitlab.com/inklinea/clip-out Inkscape Extension to clip a background image by object outlines then export to multiple png. Supports: Exporting individual clipped objects ( normal and inverse ) Export master of all clipped objects ( normal and inverse ) Cropping to resulting image size, or exporting to background image size. The image to be clipped must be the last selected. An easy way to do this, is select all then shift & left click the image twice to make it the last selected. It does require that you have saved our svg file at least once before using (will not work on an unsaved svg). Example DXF/DWG Importer About This is an extension which allows to import DWG and DXF files into InkScape (working with Linux and Windows). DWG files are getting converted into DXF and then the DXF gets processed into SVG. The SVG result will be pushed into InkScape. Because there are so much different DXF versions a lot of files fail with the default DXF import tool from InkScape. Other solutions are there. While making this extension i stumbled upon ezdxf library, which is a powerful python implementation to deal with AutoCAD DXF format really well. To support great variety there are options for pre-processing the data by filtering out entities, because some tools like sk1 UniConvertor fail to make an SVG from DXF if there occure entities which it cannot handle. \*\*Belonging to your toolchain configuration beware. There can happen issues like:\*\* wrong transformations (width, height, viewport) and scales. Some can be fixed with Apply Transformations unselectable elements. Check the XML tree for strange clipping paths and other defs. You can try to use Ungrouper And Element Migrator/Filter large time consumption. Take one or two cups of coffee if you are going to import DWG or DXF files with 10, 100 or maybe 1000 MB size. InkScape might crash (often happens when bjnortier DXF tool is used. Try to filter entity types like ARC if this occures) Converters The following conversion tools are integrated or used by DXF/DWG Importer: https://github.com/bjnortier/dxf (bundled) ODA File Converter (if you want to convert DWG to DXF or DXF to another DXF version) - this is not bundled with. You need to install it! For minimum stress with Linux, just use the AppImage version of ODA File Converter! available for Linux and Windows - install if you want to import DWG or if you also want to re-convert DXF files (downgrading, repairing (auditing)) You might need to install a certain Qt framework version manually and to adjust the command in Linux system to make it work. Some details doing this are also included in plugin GUI. The installation files can be found at https://download.qt.io/archive/qt - install to /opt/ directory for example. Note that you need some free account for registering to continue the installation of Qt vim /usr/bin/ODAFileConverter #!/bin/sh LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/Qt5.14.2/5.14.2/gcc_64/lib/ #we add this line to satisfy the Qt framework location SV_LD_LIBRARY_PATH=$LD_LIBRARY_PATH export LD_LIBRARY_PATH=/usr/bin/ODAFileConverter_21.7.0.0:$LD_LIBRARY_PATH /usr/bin/ODAFileConverter_21.7.0.0/ODAFileConverter "$@" export LD_LIBRARY_PATH=$SV_LD_LIBRARY_PATH sk1 UniConvertor 1.1.6 - this is not bundled with. You need to install it! if you want to import high quality DXF shapes. You need to install 1.1.X version because 2.0 dropped support. On newer Linux system it's hard or impossible to install the old UniConvertor so this feature is only available for Windows users yet ezdxf and matplotlib (python modules) → check MightyScape Extension Collection for instructions regarding custom Python modules with Inkscape pip3 install ezdxf matplotlib kabeja DXF to SVG converter to use it you need to install Java vpype + vpype-dxf pip3 install vpype vpype-dxf How to test/use DXF/DWG Importer extension? Q-CAD provides some example DWG files to download: https://www.q-cad.com/samples/autocad-2d/samples . You can process those files with the DXF/DWG extension to quickly check if you made proper configuration. I tested some of them and they worked really well. Example: Q-CAD Sample bjnortier sk1 UniConverter (with ezdxf preprocessing) The result looks really good but is inverted with filtered entity of tye "ARC" because otherwise InkScape crashes. Result is inverted Some entities like lines and images are missing Why you did'nt put this extension into default menu? Because we would need to delete the existing dxf_input extension which is still helpful too. Without deletion we cannot register .dxf with another plugin (at least it did not work for me) Some more hints for ODA File Converter https://ezdxf.readthedocs.io/en/stable/addons/odafc.html C:\Program Files\ODA\ODAFileConverter_title 21.6.0\ODAFileConverter.exe --help Further reading Being constrained by proprietary software sucks. Please help to make import of DWG/DXF even more open. There are some good libraries to do this: DWG handling with Python → LibreDWG DXF handling with Python → ezdxf Note that the used DXF to SVG converters are mostly outdated. kabeja and sk1 UniConverter 1.1.X are in a high state of legacy. Export selection as ... Extension to export the current selection into different formats like SVG, DXF or PDF. This extension is a modified version of the original source code. Original Source: https://github.com/mireq/inkscape-export-selection-as-svg Usage from commandline: inkscape --actions="select-by-id:object_id; verb:sk.linuxos.export_selection.noprefs" --batch-process input.svg Important Notes Replace by png: Please convert strokes to paths. Otherwise the bounding box of the object is wrong. That leads to larger graphics in relation to the original, while the borders are cut off Example Create some objects Run extension and get the result Guillotine Plus Improved basic Inkscape guillotine extension → Added: DPI input to export window for Guillotine extension. Please see Guillotine (Papierschneidemaschine / Segmentieren) on how to use Guillotine generally. Import 3D Mesh Import STL/PLY/OBJ/OFF Files and make some cool low-poly looking vector graphics out of it. See also Low Poly Low Poly 2 Slic3r STL Input Paperfold Koplanare Flächen migrieren → quick tips for saving triangles in OBJ file format by converting flat connected triangles to larger polygons. Example Inkcut See USB-Anschluss und Inkcut Setup for more details about InkCut J Tech Photonics Laser Tool Source of documentation: https://jtechphotonics.com/?page_id=2012 https://jtechphotonics.com/?page_id=1980 https://github.com/JTechPhotonics/J-Tech-Photonics-Laser-Tool pip install svg-to-gcode For InkScape 1.0 you will need to remove all path transformation before using this tool!   JPEG Export requires Setup ImageMagick-7.0.9-1-Q16-x64-dll.exe magick.exe should be put in %PATH% system variable jpg, webp, png, tiff formats are supported natively since Inkscape 1.1; no need for this extension anymore NextGenerator This plugin replaces text strings and other XML data from a generic SVG template to make a set of parametric files for output. It replaces strings in template with data from a CSV file and exports to multiple file formats (png, svg, ps, eps, pdf). This can be useful for automatically generating conference badges and similar items. Some additional hints: link any image that you want to use as a placeholder (don't embed) put the replacement images into the same directory as the placeholder, so you only need to replace the name (didn't work for full file paths, for some reason sed complained, even with backslashes and quotes (also without)) the CSV file must end with an empty line Source of old documentation: https://www.rgb-labs.com/inkscape-161-generator-plugin-tip/ Source of new documentaion (Moini's Fork): https://gitlab.com/Moini/nextgenerator/-/tree/master/example If you like to use symbols like & < > in your text you need to escape them in your CSV like this: "1. Stellvertreter & Schriftführer" → this get's "1. Stellvertreter & Schriftführer" Enter your parameters We use https://gitlab.com/Moini/nextgenerator/-/blob/master/example data to test out the plugin Create / adjust your input CSV file for replacements example name, occupation, bg_col, photo "Ada Lovelace", Programmer, #3accd1, 1.png "Alan Turing", Code Breaker, "#e78940", 2.png "Linus Torvalds", "Kernel Developer, Linux Founder", #de88d9, 3.png Tux, Mascot, #bed7ff, 4.png Example output According to your selected output format you will receive PNG, PDF or other files Open in Roland CutStudio requires Setup CutStudio 1.27 Setup CutStudio 3.10 Update tested with CutStudio Version 3.10 Installation notes can be found at Software Setup - Roland CutStudio   Open in VisiCut This extension will add or replace the current Inkscape canvas content in VisiCut instance. Documentation can be found at https://hci.rwth-aachen.de/visicut-inkscape-plugin https://github.com/t-oster/VisiCut/tree/master/tools/inkscape_extension http://visicut.org This extension requires to install the VisiCut application itself → https://github.com/t-oster/VisiCut/releases . On Fedora it's easy to use the platform independent ZIP version ( https://download.visicut.org ). We just download, move to some system dir and add it to $PATH variable, e.g. in .basrhrc . Output Pro for Inkscape Output Pro helps implementing professional output of files for printing graphics. Links: https://inkscape.org/de/~wout/%E2%98%85output-pro https://github.com/jonata/Inkscape-OUTPUT-PRO https://github.com/vmario89/Inkscape-OUTPUT-PRO/blob/master/outputpro.py http://www.cimcomunica.com/site2/index.html Requirements You need to install imagemagick . Commands like convert , identify Should be available in %PATH% variable PyQt framework pip3 install PyQt5   Paths to OpenSCAD https://wiki.fablab-nuernberg.de/w/Ding:Zahnr%C3%A4der_mit_Inkscape#Werkzeug-Korrektur Example Draw a new gear Union paths and fill the area Save the file with a name Run "Paths to OpenSCAD" Plugin Download + Installation OpenSCAD: https://www.openscad.org/downloads.html Adjust settings if not already happened: Output file: "C:\Users\\Desktop\output.scad" View in OpenSCAD: "\openscad-2019.05\openscad.exe" "output.scad" Convert to STL: "\openscad-2019.05\openscad.exe" "{NAME}.scad" -o "output.stl" please use " " instead of ' ' - it won't work in a Windows environment please be consistent with the output file name! "Output file" has to be named correctly with path and file name. Otherwise it will try to save under InkScape folder (which might only work if running in Administrator mode if installed in Program Files directory) "Apply" → export the .svg vector file to a .scad file (and additionally to a .stl file if "Convert to STL" is enabled) View the .scad (OpenSCAD) and maybe export to STL manually, or do it automatically by the Inkscape Plugin Open Rendering Export If you forget to fill in the area in InkScape, you will see it as follows: View the STL STL Export / 3D Print http://www.freestlview.com Slic3r STL Input STL Sliced Import (by Slic3r). Supports OBJ/OFF/PLY/STL as input file formats. It requires OpenMesh: Prepare to install openmesh To run this extension you need to install OpenMesh bindings with python pip. When installing Paperfold by installing MighyScape, this will already be done for you on Linux systems. Else: Ubuntu sudo apt install cmake sudo apt install g++ sudo apt install python3-dev pip3 install openmesh Fedora sudo dnf install cmake sudo dnf install g++ sudo dnf install python3-devel pip3 install cmake pip3 install pybind11 pip3 install openmesh Windows Windows requires CMake executable Install MS Visual Studio Community Edition → If you receive an error like "NMake Makefiles does not support platform specification, but platform x64 was specified." In case the instalation fails you can also try to install precompiled Windows binaries from  https://gitlab.vci.rwth-aachen.de:9000/OpenMesh/OpenMesh Install openmesh bindings pip3 install openmesh How it works projects an STL file on the X-Y plane by cutting the objects into "slices" each "slice" is a group of polygons, with a label indicating its z position the polygons are converted to paths for better editing in inkscape use Object → Rows & Columns →  distribute the slices in a grid Warning: Requires Slicer 1.3.1-dev (the really latest build possible) Examples Download Slic3r You need the latest development version from https://slic3r.org/download . You can directly get them from https://www.dropbox.com/scl/fo/gxoj6ei7vt95p3ggzy9c6/AJBn6GpI4H-7kJbx_P8cZic/dev?dl=0&rlkey=usb5fvt9mhpqizm3269dhg036&subfolder_nav_tracking=1 Example to Import Import Procedure Svg2Shenzhen Source of documentation: https://github.com/badgeek/svg2shenzhen   Layer Clip Original idea from http://www.pernsteiner.org/inkscape/layerclip/ Ported to Inkscape 1.0 by https://gitlab.com/jczapla79/inkscape-extension-layer-clip Fixed and ported to Inkscape 1.2+ by Mario Voigt Usage See an example with screenshots Clip containing layer Select a single object and then run this extension to set that object as the clip path for the layer that contains it. This will mark the layer with "(c*)" to indicate that the layer contains an object that is being used to clip its containing layer, and with "(C)" to indicate that the layer has a clip path applied to it. (These markers are simply added to the layer name to make it easier to tell when clip paths are in use.) Clip layer above Like "Clip containing layer", but sets the object as the clip path for the layer above the one that contains it The layer containing the object will be marked with "(c+)" (instead of "(c*)" for "Clip containing layer"). Clip layer below Like "Clip containing layer", but on the layer below the layer containing the selected object. Marks the object's layer with "(c-)". Clip parent layer Like "Clip containing layer", but on the parent layer of the layer containing the selected object. Marks the object's layer with "(c**)". Remove layer clip Select an object in a clipped layer and then run this extension to remove the clip path from a layer. The "(C)" marker will also be removed, if one is present. The marker on the layer that held the actual clip path will not be removed, but you can remove it yourself by manually editing the layer name. Reset clippath transforms If you move an object that is being used as a clip path for a layer, the layer will still be clipped based on the old position. Run this extension to fix the problem. Modify existing Path(s) Blueprint Maker Example Output Close Paths This is similar to Chain Paths extension but it has less features and only "one job". It helps to close open contours. This will connect the first point and the last point of a path which has no "Z" flag (which indicates for a closed path). If the first and the last point are already coincident it will just add the Z flag to the end of the path. If there's a distance left between the points a new line segment will be created to close the path. "Close Paths" extensions is also similar to Join Paths / Create Tabs And Dimples and Line Merging (Combine Paths) . This plugin does not apply for paths in groups. Please ungroup before! Draw some path Make the path ends overlapping This won't close these contours automatically. That's the reason to use this plugin Select the paths you want to close and run extension Notice that the path was reduced from 6 to 5 nodes. This happened to the other selected paths too. Convert To Polylines This extension takes the points of a path and make a straight polyline out of it. Nothing less, nothing more. ou can do the same with default Inkscape UI (select the path → Node Tool → Straighten lines) but it might be quicker to use in some use cases. This extension handles duplicate points on a path by removing them. This extension is similar to  Approximate Curves by Straight Lines (Flatten Beziers) but works much easier (but has less control over elements). Example 1 Red outline is original curve, black one is the converted one Example 2 Left is before, right is after conversion Convert Vertical/Horizontal To Line This extension converts an SVG path's d attribute the following way: find each V (vertical line) and each H (horizontal line) and replace it by a generic line (L type). A lot of extensions do not work with V and H, but with L commands. So this is just a helper extension for other extensions. It behaves similar to To Absolute Example conversion from: M 60.403,71.0937 V 89.268022 135.773 to: M 60.403 71.0937 L 60.403 89.268 L 60.403 135.773 Ellipse by Five Points (Replaced by LPE) Note that this feature is obsolete / legacy in InkScape 0.92 and higher because of https://wiki.inkscape.org/wiki/index.php/LPE:_Ellipse_from_Points Usage (with a workaround) Draw some path with 5 control points Select the object and run extension → the plugin will rotate the object Input vs Output Fillet And Chamfer (Replaced by LPE) This extension is similar to the built-in Live Path Effect " Corners (Fillet/Chamfer) " of Inkccape and similar to Round Corners (Replaced by LPE) but it's great advantage is the possibility to quickly chamfer complete paths. This extension requires python library svgpathtools . Method description Source of image: http://launchpadlibrarian.net/12692602/rcp.svg Draw some path Run the exension and get the result Flevobezier Documentation for approximation algorithm can be found at https://gitlab.com/parclytaxel/Kinross/-/blob/master/programs/arp.pdf Draw some paths Apply the extension and get result Guilloche Contour This extension creates a Guilloche Contour from a regular path. It is needed for Guilloche Pattern extension. Guilloche Pattern This extension allows to create patterns like this: Example Draw a rectangle and some Guilloche Contour : Run the extension and get the result Open Closed Path Source:  https://gitlab.com/EllenWasbo/inkscape-extension-openpaths This extension will open up closed paths by removing all z-commands from the selected paths. Possible purposes: to save single line svg-fonts as otf or ttf fonts. These font formats require closed paths and will add a closing command to the glyphs. This closing can be removed by converting the text to paths, ungroup and then using this extension. Paths To Lowlevel Strokes This extensions does the opposite of "Strokes To Paths" Round Corners (Replaced by LPE) Source: https://github.com/jnweiger/inkscape-round-corners This extension is similar to the built-in Live Path Effect of InkScape and similar to Fillet And Chamfer (Replaced by LPE) but it's great advantage is the easy selection of individual path nodes (points) instead the whole path element. More details about this extension can be found in the source repository. Warning: the results may be error prone. See https://github.com/jnweiger/inkscape-round-corners/issues/9 Example Draw some path Run the extension and get the result Rounder Round internal SVG data to a fixed decimal positions. Added options to also round stroke width X ,Y, Width and Height, opacity and more. Does only apply to svg:path elements. Source: https://inkscape.org/~jabiertxof/%E2%98%85rounder-04 Draw some example Have a view on the 'd' attribute of the path: Run the extension and get the result Have a view on the 'd' attribute of the path again: Snap Object Points This effect snaps points in each selected object to nearby points in other selected objects.  Source:  https://inkscape.org/de/~pakin/%E2%98%85snap-object-points Draw some objects Run the extension and get the result Music Fret Ruler Example Output Guitar Fretboard Source: https://github.com/tomate44/GuitarFretboard   Piano Scale Source: https://inkscape.org/~Neon22/%E2%98%85pianoscale Open Current File Directory Similar to Open Extension Directory Open Extension Directory Just what it says to be! ... Opens the MightyScape main folder. Similar to Open Current File Directory . PathOps A tool suite to run boolean operations multiple times, like Combine, Cut Path, Division, Exclusion, Intersection, Difference, Union. This extension takes a selection of one or more groups, or of several elements (paths, shapes, text), or a mix of both, and applies a chosen path operation with the top-most valid object in paint order and each other valid object which is part of the selection (directly or as member of a processed group) that is lower in Z-order. Objects which are considered "valid" for path operations are paths, shapes and text. Other graphic elements like clones or bitmap images are silently ignored. More info about the usage can be found at https://gitlab.com/moini_ink/inx-pathops Paths - Cut/Intersect/Purge Contour Scanner And Trimmer Scanning This tool helps you to find nasty contours which might bug you and prevent your work from being ready for production. It will find open contours, closed contours and self-intersecting contours and checks for a set of other attributes. Bentley-Ottmann algorithm is used to check for those intersections. The algorithm works with the accuracy of the selected paths (epsilons). Self-intersections usually happen if you just have large overlaps where the contour crosses itself like an 'eight' character for example. Using the highlighting it's easy to find contours with unproper path handles. While in a CAD system an area of of a surface can only be calculated if the contour is closed and clean, finding self intersections in Inkscape is not required to do so. SVG format allows to calculate areas on open contours and self-twisted curves. This "artwork behaviour" makes it harder for handling machinery-like drawings for laser cutting, vinyl cutting or whatever. That's why we need to have extra sanity checks but we also have the great freedom of InkScape. Finding self-intersecting contours does only work for curves with straight line segments (polylines) because it just calculates with a set of given XY points. It does not respect bezier curve segments. Bezier curves have no regular points but special handles, which define the slope of the curve per handle side (left and right). To properly handle a bezier curve we need to split the bezier curve in a lot of small linear lines (acting like infinitessimal solution). We can use the tool Approximate Curves by Straight Lines (Flatten Beziers) to do this by hand or we use the built-in method if Contour Scanner and Trimmer (will make your curve looking edgy or ugly possible). If you want to leave the shape of the line clean (bezier type, no edgy approximation) we can also use Split Bezier (Subdivide Path) or  Add Nodes instead. But remember that your calculated self-intersection points will only be an approximation then. The higher the subdivide count is the higher the precision of the calculated self-intersecting points coordinates will be. After performing operations, which flatten or split the bezier curve, we we can or should use Chain Paths to put the pieces together again. Trimming By having a set of flattened straight line and finding global intersections we can also trim the paths using python library called "shapely". This allows to receive cut segments. Some basic tools to remove duplicates, are integrated. The result Using Contour Scanner correctly, we get a planar graph style drawing, like the definition gives: "In graph theory, a planar graph is a graph that can be embedded in the plane, i.e., it can be drawn on the plane in such a way that its edges intersect only at their endpoints. In other words, it can be drawn in such a way that no edges cross each other . Such a drawing is called a plane graph or planar embedding of the graph. A plane graph can be defined as a planar graph with a mapping from every node to a point on a plane, and from every edge to a plane curve on that plane, such that the extreme points of each curve are the points mapped from its end nodes, and all curves are disjoint except on their extreme points. " ( https://en.wikipedia.org/wiki/Planar_graph ) Tips If nothings is selected, the whole document will be processed, regardless of groups. In contrast, if you made a custom selection, check to handle or not to handle groups. Works with paths which have Live Path Effects (LPE) Convert your strokes and objects to paths before Does not work for clones. You will need to unlink them before Use extensions to filter short/unrequired paths Use extensions to purge or repair invalid paths Use 'Path → Simplify' or hit 'CTRL + L' to simplify the trimmed result. With a fine quantization setting the simplified paths will be nearly identical to the original path (except the position of control points) Do not select too much paths at once if you have got a fine settings for quantization. This extension is slow and might calculate hours on ultra high configurations. See also (similar extensions) Incadiff Occult Plugin (Hidden / Superimposed Line Removal) Purge Duplicate Path Nodes Purge Duplicate Path Segments Purge Pointy Paths Mutual Cut Line Convert To Polylines Deduplicate Plugin The user interface Quick example Using Contour Scanner and Trimmer we can check the different contours and their behaviour. Usually a contour can be open or closed and it can intersect with itself or not. This will give us 4 different combinations and we can use this information to find out where the intersections are using Bentley-Ottmann algorithm. Short examples: 4 different basic line "types" Marked paths by running the extension using colors and dot modifiers Real example Load sove graphic you want to fix Depending on the steps you want to perform with the file maybe create some duplicate. Run the extension Configure the setting depending on what you want. Fix the desired paths Select the path to see the handles. The dot indicates that there might be something faulty. In the following example there are two handles at the same coordinate. We can pick one of them to drag it away from the other one. You can now delete the marking point After rerunning the extension the dot will not appear again: Overlapping lines Contour Scanner is powerful. It can find and merge overlapping lines in the set of flattened sub split lines. We find those line intersections between lines where the same slope exists and which cover each other fully or partially (collinear overlapping lines). See the graphic to understand the problem. At the moment Contour Scanner cannot remove those overlaps in original paths. From left to right: 1st: path 1 is equal to path 2 (they share start point and end point and have the same direction) 2nd: path 1 and path 2 share direction, but not the start or end points 3rd: path 1 and path 2 share one point and direction 4rd: multiple overlapping lones Issues Trimming bezier curves There is no algorithm done to split the original bezier curve after finding intersection points and t parameters yet. green = a cutting line black = original bezier curve purple = approximated polyline magenta = intersection point between cutting line and original path (the intersection between cutting line and approximated curve would be far away as you can see) Create Links (Breakaway Connectors) To create tabs in Inkscape, we cannot properly use the integrated eraser tool. It will clip only in a cosmetic fashion but we do not get the real paths we need. Creating links (also known as microtabs, tabs, bridges, breakaway connectors, links , perforations) is sometimes required for laser cutting or vinyl cutting. This extension allows to pinch paths to create according segments - no cosmetic one's, but real segments. It will split up open or closed contours with user defined rules. To get best output please try to close open paths before using. This extensions is ideal to cut cloth/textile stuff in the laser! Also have a look at Convert to Dashes Lasercut bridges without using extensions Ein- und Auslaufschnitte, Stege, Brücken, Laschen, Perforationen Draw some contours Run the extension and get result Known issues The path is not split up? Then please check if your path contains any connected Live Path Effect (LEP) which is associated with it. Like this: You can remove it by using Apply Transformations extension for example. Further development See  https://wiki.selfhtml.org/wiki/SVG/Farben/Kontur and https://svgwg.org/specs/strokes/#StrokeDashing Create Links Extension does not support stroke-dashadjust SVG attribute yet. But if it is implemented in Inkscape, we can adjust the dash pattern none: default value stretch : if the pattern does not fully merge into the path length, strokes and gaps are stretched compress : if the pattern does not fully merge into the path length, strokes and gaps are compressed dashes : If the pattern does not fully merge into the path length, dashes are adjusted, gaps remain in the selected setting gaps : if the pattern does not fully merge into the path length, gaps are adjusted, strokes remain in the selected setting Destructive Clip An Inkscape Extension which works like Object|Clip|Set except that the paths clipped are actually modified . Thus the clipping is included when exported, for example as a DXF file. Select two or more paths then choose Extensions|Modify path|Destructive clip. The topmost path will be used to clip the others. Make some path and draw clipping border Curves (including Arcs) in paths are not supported (use Extensions → Modify path → Flatten Beziers) and non-path objects in the selection will be ignored. Use Object → Ungroup. Maybe you need to combine multiple contours with CTRL + K before running the extension Run the extension and get the result The order of selection defines what is clipped by which contour. Filter By Length/Area Paths with value smaller than the given threshold will be deleted. This extension might require to break up your object before. Take some image This is not a good example but shows the effect Run the extension Result Incadiff An Inkscape extension which applies successive difference operations on superimposed paths. Useful for plotter addicts as it removes hidden strokes. Incadiff works on paths and objects. It does not work for open paths. Incadiff does not operate like Contour Scanner And Trimmer and it does not remove duplicate lines if existing. See also PathOps Mutual Cut Line Contour Scanner And Trimmer Purge Duplicate Path Segments Source: https://github.com/incaya/incadiff Mutual Cut Line This extension cuts exactly 2 (ideally straight) path segments and will create intersected elements. Depending on the path direction (which can be reversed) the ends are going to be cut against each other Draw some paths Duplicate the paths (CTRL + D) and give some different color This step is optional but helps to understand what's going on here Check the result We repeat the previous step and this step for all variants to show the possible outputs. You can reverse the path using "Path → Reverse" Two regular paths First and second path reversed First path reversed Second path reversed Output with original as  overlap Result only Path Intersections In case your resulting intersection markings are displaced please run Apply Transformations before running this. Draw some example with intersecting paths Run the extension Check the intersections Purge Duplicate Path Nodes https://gitlab.com/EllenWasbo/inkscape-extension-removeduplicatenodes Annotation belonging to the lines This extension might turn straight lines into strange looking "d" content like the following #using the extension will make m 47.127583,101.78891 h 9.944022 z #to M 47.1276 101.789 C 47.1276 101.789 57.0716 101.789 57.0716 101.789 C 57.0716 101.789 47.1276 101.789 47.1276 101.789 Z #selecting the line and moving it up/down/left/right will turn it into m 47.1276,101.789 c 0,0 9.944,0 9.944,0 0,0 -9.944,0 -9.944,0 z   Purge Duplicate Path Segments A common problem while laser cutting or vinyl cutting for example, is the problem with duplicating lines which are overlapping invisibly. Often you won't find them in your drawing. If you use graphics without filtered duplications you might run into issues like burnt edges, rough-cut edges, long running cutting processes, etc. This plugin removes duplicates from paths with respect to their type (bezier or straight line segments). Please note that maybe you need to combine all lines/paths to one common path to make this work. So this plugin is ideal to remove common edges like professional nesting software is doing too. Key phrases: remove overlapping lines, remove duplicated lines, purge redundant lines, purge doubled lines, remove common edges, remove occulted lines, hidden line removal, retrace edges, chain paths, clean paths Annotation belonging to the lines This extension also helps removing straight line duplications where start or end point is duplicated by using "z" or "Z" in "d" descriptor, which invokes a closing contour, like the following #turns m 47.127583,101.78891 h 9.944022 z #into M 47.1276 101.789 L 57.0716 101.789 Example on how to remove duplicates Draw a line and copy/paste it for each line a path 'd' is defined: Make the paths overlapping  visually (to enforce having some example of duplicated, invisible path) Combine the lines (Ctrl + K) The path is now duplicated. See entry 'd' - this is repeated Run the extension Now check the XML element tree to see the cleaned up path Real example and known limitation(s) Get some parts you want to optimize by rearranging and removing common edges Check the node count Calculate the total number of nodes by clicking through XML tree and noting down the nodes count. We use this information to check how good we can reduce the duplicates in the drawing. For this example we have 13 paths witha total of 38 * 5 + 21 *8 = 358 nodes Check the total line length We can also get a goodcomparison by measuring the total length of all paths before and after purging duplicate lines. Rearrange and combine all paths CTRL + K to combine the things. You might need to ungroup all items before. Run the extension and get the result Check the line length again Known Limitation: We reduced the set by 8 nodes (only). The limitation can be found in detail: Duplicated paths are only removed if start and end point of the line segment are equal. It will not work if one line segment is shorter or longer because the X1Y1 or X2Y2 coordinate will be different. A more complicated algorithm is required to get optimal results. The following screenshots just shows one line segments moved to reveal the remaining underlying common edge. To avoid this problem we would need to intersect all lines with each other to receive the whole set of intersecting points. Then we proceed to remove duplicate segments. Check the total line length again We reduced the line length from 2893.74 mm to 2882.45 mm. Not a great saving for this example, but still a reduction. Purge Pointy Paths This filter deletes paths which render as point only, like: m 45.250809,91.692739 - this path contains onyl one command - a single point m 45.250809,91.692739 z - this path contains two commands, but only one coordinate. It's a single point, the path is closed by a Z command m 45.250809,91.692739 l 45.250809,91.692739 - this path contains two commands, but the first and second coordinate are the same. It will render als point m 45.250809,91.692739 l 45.250809,91.692739 z - this path contains three commands, but the first and second coordinate are the same. It will render als point, the path is closed by a Z command Remove Duplicate Line Segments An Inkscape extension to remove duplicate line segments with an option to add a tolerance for regarding the segments as a match. See http://cutlings.wasbo.net/inkscape-extension-removeduplicatelines See also Purge Duplicate Path Segments Contour Scanner And Trimmer Purge Duplicate Path Nodes Deduplicate Plugin Split And Break Bezier At t Splits a path at value t=0..1 (t=0.5 means 50%) Applies independently for each sub path in selection. Allows better control over splitting than Add Nodes or Split Bezier (Subdivide Path) . Draw some path Run the extension Splitted path Split Bezier (Subdivide Path) Function is like Modify Path →  Add Nodes but it provides additional features like splitting path into disconnected sub paths (break apart) choose units Please note that the plugin will sub-divide each path segment (from path handle to path handle). So it does not split the whole curve into given amount of piece like acting "as one item". Each bezier segment is it's own element. Draw some example Run the extension Note that "Live preview" will only work if "Break apart" is not selected Tip: Breaking apart the curve can also be done by ... Selecting the path and show handles Select all handles and break Break apart the path SHIFT + CTRL + K Tip: Splitted paths can be combined again nearly the same look like before by ... Example for bezier path Draw some curve and split it up running the extension Duplicate the path CTRL + D to duplicate. We use this to check the quality of simplification Run Path → Simplify As you can see the result has other handles than before. The right image shows a black curve (curve before simplification), the green shows the simplified curve. You can see that the curve is not exactly the same. So we can say that simplification for bezier curves is not the best in all use cases, but it will work absolutely fine for straight line segments: As you can see the result has other handles than before. The right image shows a black curve (curve before simplification), the green shows the simplified curve. You can see that the curve is not exactly the same. So we can say that simplification for bezier curves is not the best in all use cases, but it will work absolutely fine for straight line segments: Example for path with straight line segments only Draw some curve and split it up running the extension Run Path → Simplify Paths - Join/Order Chain Paths Source of documentation: https://github.com/fablabnbg/inkscape-chain-paths An inkscape extension to combine paths. Like really combining path snippets into longer paths. The stock inkscape path operation "combine" does not do that. It only creates a single path object consisting of multiple distinct segments. Many commercial CAD packages create object contours consisting of separate path snippets using adjacent end points. Such objects cannot be used in path operations like "add", "intersect", "difference", as they are technically a set of objects, rather than a single stroke. This extension forms a longer path from multiple shorter path segments. It is irrelevant if the path segments are separate path objects in Inkscape, or if the path segments belong to the same path object. If two path segments have an end point in common, or if their end points are close together, they are linked together to form a longer path. It is optional weather the linking end points meld into a single common point, or if an optional straight line ('chain link') fills the gap, if any. The maximum distance for end points is a user setting. Usually a fraction of a millimeter works fine. Usage Select multiple pathlike objects. If the status line shows you different object types, then use "Path → Object to Path". This is needed as we operate only on paths only. You can choose the maximum endpoint distance for path ends to be linked, and the combination method: snap the points together, or create a linking path segment. Note, that paths never fork . This means, that if there are three or more path ends at the same location, only two are chained together. The others are left unchanged. Additional notes this plugin can be used to reduces node by chaining (linking) overlapping points by selecting "Snap connecting ends together" you are creating closed loops. Otherwise they are open! This plugin does not apply for paths in groups. Please ungroup before! Step 1 - Having a loose set of lines Step 2 - Apply extension Step 3 - Get closed (chained) contours Similar extensions: Line Merging (Combine Paths) , Close Paths , Join Paths / Create Tabs And Dimples Circle Tangents (Replaced by Snap Objects Feature) 1. Draw some circles 2. Apply the extension You can have two different outputs: If you want to get sort of tangents at the path's point handles instead you can also try to run the extension Draw Handles Duplicate + Reverse + Join An extension to effectively convert a single line svg font to a stick font by duplicating, reversing and joining each selected path and subpath. Read more on http://cutlings.wasbo.net/single-line-font-to-stick-font Join Paths / Create Tabs And Dimples This extension works on the selected paths. The paths will be joined based on their Z-order (i.e. the lowest one in the document first and then the next one and so on) at their end nodes with a straight line segment. If the ending nodes of the paths coincide, they are merged and no new segment is created. If you check the option "optimized", the paths are joined starting with the one with the lowest Z-order (one at the bottom most position in the document) and the successive paths to be joined are chosen based on the distance of their end nodes to the ending node of the earlier path, i.e. the one with one of the end nodes closest to the ending node of the earlier path is joined to it. See also Line Merging (Combine Paths) , Close Paths and Chain Paths for similar tools operating on path closing and joining. Draw some lines and select them Run the extension Get the joined path This plugin might fail in case there are any groups within selection or just groups (not selected) in the document at all!  This plugin generally does not apply for paths in groups. Please ungroup before! return super().__getitem__(self._to_key(key)) KeyError: 'path8' Creating tabs / dimples This extension also deals with creating tabs and/or dimples. See also  Tab Generator and Quick Joint Draw some path Create some gaps We use Create Links (Breakaway Connectors) Creeate dimples More examples: Sheetmal: This is for a pattern like this: Longest Continuous Path Source of documentation: https://github.com/Daekkyn/inkscapeOptimizePath An Inkscape extension that tries to make the longest continuous paths. It converts the paths to a graph, converts the graph to an Eulerian graph and finds an Eulerian cycle. It was written for the Axidraw pen plotter to reduce writing time of graph-like drawings like Voronoi diagrams and meshes. Usage Make sure to ungroup everything → Extensions → Reorder → Deep Ungroup Make sure that the paths use only absolute coordinates (see trick below) or use → Extensions → Modify Path → To Absolute Make sure to not have transforms on the paths. You can use the Apply Transformations extension to remove them Select all the paths you want to optimize (currently only works with polylines). Conversion to polylines can be done with Approximate Curves by Straight Lines (Flatten Beziers) or Convert To Polylines (as second choice). Bezier curves, which were not converted, are getting lost running this extension Open the extension Set the merge tolerance (0.1 should work in most cases) Choose the Overwrite rule: "Allow" means that the result will be a single path which might (probably) will have some overlapping edges. "Allow none" means that the results will be multiple disconnected paths but there will be no overlapping edges. "Allow some" is an in-between, overlapping edges are allowed, but only in short numbers. This is probably the best choice in most cases. Apply Trick to remove relative coordinates Change the preferences for 'SVG Output > Path Data' to always use absolute coordinates. This will only affect newly created paths, or existing objects for which a rewrite of the path data is triggered. For existing paths, use 'Edit > Select All in All Layers', and nudge the selection with the arrow keys (e.g. one step up and one back down again). This will trigger a rewrite of the path data in 'd' which will follow the changed preferences for optimized path data. Another Example Draw some paths and put the ends together by drag and drop with snap Get the result The red contour is an optimized contour. It works similar like Close Paths , Chain Paths or Join Paths / Create Tabs And Dimples except that it will not handle bezier curves but only polylines. So it acts like a combination of those plugins in junction with Approximate Curves by Straight Lines (Flatten Beziers) or Convert To Polylines . This extension can also create really cool artwork Move Path Node Extension to change starting / end node of a path and visualize it by dots and numbers. You can also use this extension as a trimmer for open paths. It is additionally highly useful when using the function to map text to path. By moving the node, the mapped path is moving too. It helps for fine-tuning a lot. Use "Path → Reverse" to change path direction Use extension Chain Paths to make closed paths out of segments. Optimize Sequence: Small Holes First Souce of Documentation: https://github.com/L0laapk3/inkscape-laser-sequence-extension If you use(d) inkscape to create models for laser cutting, chances are you have ran into the following problem: the laser cutter first cuts the large shape, then it ever so slightly moves, then the holes in that shape are created but with a small offset. Thats why I created this simple extension to deal with this! The extension exists out of a couple lines of code that will re-arrange the order of the vectors for you, so the small holes get cut first. You might need to combine the desired contours using ctrl + K to build up a long "total path" object. Also have a look at  Line Sorting and Optimize Sequence: Travel Distances Example Draw some closed contours. Make some "bad" order (first rectangle in the middle, then a small one, then a large outer one) Combine and check Combine the paths to common contour using ctrl + K. Check the 'd' node of the XML item to see how the path actually looks alike. M 7.1105146,29.996967 H 173.07073 V 142.51136 H 7.1105146 Z M 23.630058,57.496723 h 41.639881 v 26.55864 H 23.630058 Z M 21.166666,44.450001 H 137.58332 V 120.65 H 21.166666 Z Run the extension and check the 'd' node again M 7.1105146,29.996967 H 173.07073 V 142.51136 H 7.1105146 Z M 23.630058,57.496723 h 41.639881 v 26.55864 H 23.630058 Z M 21.166666,44.450001 H 137.58332 V 120.65 H 21.166666 Z Optimize Sequence: Travel Distances Source documentation: https://wiki.evilmadscientist.com/Reorder_Paths_for_Speed In normal use, and by default, elements within a document are plotted in the same order in which they appear in the file. This order is generally the order in which the objects were created; it might also be referred to as “bottom to top.” For example, suppose that you draw a circle and then a rectangle. Then, when you plot the file, the EggBot will plot the two objects in the order that you created them: The circle will plot before the rectangle. The rectangle in this example can also be described as being “above” the circle— a description that makes sense if you imagine painting one object and then painting the other on top of it. You can use the tools in the Object menu to rearrange the order of objects, for example with the Object > Raise and Object > Lower menu commands. If you raise our example circle above the rectangle, then the rectangle will plot before the circle. This extension can re-order the objects in your plot so as to reduce the travel time spent with the pen up. Experimentation has shown that it can often reduce plotting time by 30% or more. Using this extension does impact your Inkscape drawing. This extension changes the order in which pieces of your drawing are drawn. For the Eggbot, this should produce no visual change in the finished plot. The first option, Reorder within groups will re-order objects and groups within each layer of your document. Grouped objects will remain grouped. But, objects (and other groups) within any given group will be re-ordered. The second option, Preserve groups will re-order elements and groups within any given layer of your document, but the order of elements with groups will not be altered. The third option, Break apart groups will ungroup all elements within each layer of your document and then re-order them for speed. This option removes the groups from your file. Also have a look at  Line Sorting and Optimize Sequence: Small Holes First Reverse Order Of Subpaths Reverse order of subpaths (combined paths) without changing the direction of each subpath. When drawing paths and combining these the order of the subpaths is from the last to the first drawn. This extension reverse the order of the subpaths and thus the order in which the paths were drawn can be restored. Use together with the extension to Number Subpaths to visualize the effect of reversing the subpaths. See https://inkscape.org/~EllenWasbo/%E2%98%85reverse-order-of-subpaths and https://gitlab.com/EllenWasbo/inkscape-extension-reverse-order-of-subpaths Ray Tracing Sources: https://inkscape.org/de/~dbloch/%E2%98%85ray-optics https://github.com/damienBloch/inkscape-raytracing Reload drawing An extension which allows to reload the drawing in case of any change without opening the file in a new window. Helpful if the file is opened and changes in background by another instance of Inkscape or any routine which processes and overwrites it in the meatime. Acts also as kind of "reset", because we can skip executing all undo's from the history Shape/Pattern from existing Object(s) Clones In Perspective See also Create patterns Draw some random stuff and group Create a whole group of all objects you want to make off some pattern Adjust the center of rotation (move the vanishing point) Select the group and click one time more to get the object rotation anchors. This will also show the rotation center point which can then be selected and moved Move the vanishing point Fill Rectangle With Circles Hatches And Grains Source: https://gitlab.com/marcjeanmougin/inkscape-carto-ext/-/tree/master/ This mapping module is intended for the community of geographers and cartographers. It makes it possible to create visual variables like "hatch" or "grain" on surface or point implantation, in order to differentiate or prioritize the cartographic information. Draw some object or path and apply hatches or grains: IFS Fractals https://github.com/dylex/inkscape-ifs Draw some objects Check the result Living Hinge (Fit To Rectangle) This plugin only works für rectangles of the type "Object". So you may not convert the rectangle to a path before! See https://wiki.lvl1.org/Inkscape_Extension_to_Render_a_Living_Hinge . Draw a rectangle object (do not convert to path!) See also Living Hinge (Size Input) Box Maker - Living Hinge Buxtronix Living Hinges Low Poly 2 This is similar to Low Poly extension but works different regarding to the path handling. Allure a wannabe cat into Inkscape - thanks Charlie! Draw some lines at prominent positions You can use freehand drawing tool. This is really quick and handy Select all paths and the image, then run the extension Low Poly Charlie Not the best example but it shows how the plugin works Shapes Source of documentation: https://www.arakne.es/en/inkscape-1-0-shapes-extension-new-version/ This plugin works for Object selection as well as Path selection Sheriff Star Source of documentation: https://github.com/garykac/pathmonkey Sheriff stars typically have 5 or 6 points and also have a circle at the end of each point so that the badge can't accidentally stab the officer while they're wearing the badge. 6-pointed Sheriff Stars Shapes created by extension Remove original circle Union the shapes The components (star, circles) are kept separate so that additional processing can be performed on each component if desired. To produce a sheriff star outline, just union the various shapes together. 5- and 7-pointed Sheriff Stars   If the "Show inner circle" option is selected, then a circle touching the inner points of the star will be included in the output. Here is an example for a 5-pointed star: This extension works with circles and ellipsis objects   X-Agram Source of documentation: https://github.com/garykac/pathmonkey X-agrams are stars with a circumscribed circle. While these can be drawn separately, it can be tricky to properly align the circle and the star, especially for odd-count stars where the center of the star's bounding box is not the true center of the star. Pentagram (5-agram) Create and select a circle Vertex skip = 1 (pentagon) Vertex skip = 2 (pentagram) Septagram (7-agram) Vertex skip = 1 Vertex skip = 2 Vertex skip = 3 In addition to connecting each point along the outer circle, they can also be connected via an inner circle. Septagram (7-agram) with inner connection Vertex skip = 1 Vertex skip = 2 Vertex skip = 3 Vertex skip = 4 Vertex skip = 5 This extension works with circles and ellipsis objects Draw a circle object Shape/Pattern from existing Path(s) Bounding Box This is a simple but useful extension to create rectangles and/or circles around selected items. In Inkscape 1.2.1 the option to set some margins around the object were removed, so this extension is even more useful, as it acts a similar way. Select one or more objects Example 2 (multiple objects at once) The same can be done with Live Path effects! Convex Hull Creates a convex hull for the current selection of paths. Does not apply to objects and only works for polylines and not for bezier curves! Example for a long fuzzy polyline Bad example with bezier paths Delaunay Triangulation Draw some paths Apply extension The result Dots To Path Points Draw some guidance path and some object The object will be cloned so it will be attached to each control path's point   Run the extension First select the object, then the control path The result Draw Directions / Travel Moves This extensions marks start and end point of opened (red + blue) and closed paths (green + yellow). See also Move Path Node . Example 1: Draw dots Draw some paths Run the extension and get the result Example 2: Draw travel moves Hatch Fill Netting This effect (alternatingly) nets in the selected paths. Based on the work of Sunabe Kazumichi. See http://dp48069596.lolipop.jp Original Path All with all Alternatingly       Number Subpaths Visualize the order of subpaths within one path. Each start and end node will be marked with green/red dots and a text flag according to its order. Optionally the path ID could be visualized if working with more than one combined path. I use this for various projects where combining paths is needed and the order is of importance - embroidery designs, developing and testing extensions for cutting/plotting. This extension is based on the Inkscape included extension Visualize Path → Number Nodes by Aaron Spike from 2005. Number Subpaths can be found in the same menu when installed. See https://inkscape.org/~EllenWasbo/%E2%98%85number-subpaths and https://gitlab.com/EllenWasbo/inkscape-extension-number-subpaths Offset Paths Create offset for open or closed paths from non-bezier paths (destructive method). Python library  pyclipper needs to be installed (which is automatically done, if you install MightyScape completely). Use Approximate Curves by Straight Lines (Flatten Beziers) extension in advance of this plugin to convert your paths. This extensions' code is based on  https://github.com/TimeTravel-0/ofsplot Draw some Ratchet (as example) Tests with Bezier curves Input Spiral without Approximate Curves by Straight Lines (Flatten Beziers) Spiral with Approximate Curves by Straight Lines (Flatten Beziers) Strip Line Generates a strip line from linear path segments. The whole document will be parsed. This extension does not respect the user selection. Please remove existing transformations before using. You can use Apply Transformations to do this. Draw some line pattern Run the extension Get strip lines Travel Source of documentation: https://github.com/rkp8000/inkscape-travel Copy an object along a precise parametric trajectory. Usage Select two objects to use this extension: a rectangle and a template. The rectangle must be below the template, and the template must be a path or group of paths. If any path within the template has "arc" elements (e.g. ellipse/arc objects that have been converted to paths) you will encounter errors using the rotation function (sorry, unfortunately this isn't an easy fix). Specify the timepoints at which your template will be copied using "start time", "end time", and either "number of steps", "fps", or "time interval". For example, if "start time" is 1, "end time" is 2, and "number of steps" is 6, then 6 copies of the template will be made, corresponding to times 1, 1.2, 1.4, 1.6, 1.8, and 2.0. If "number of steps" is zero, then "fps" can be used to specify frames per second, and if "fps" is also zero, "time interval" can be used to specify the interval between time points from "start time" to "end time". Next, write in equations for x(t) and y(t) using Python syntax (e.g. x = t, y = t ** 2 yields part of a parabola). The units of x and y are relative to the size of the rectangle, for example, if X scale = 2, then one rectangle width corresponds to 2 units along the x-axis. If Y scale = 3, then one rectangle height corresponds to 3 units along the y-axis. The point (0, 0) corresponds to the lower left corner of the rectangle. The equations for x_size and y_size are relative to the size of the object. E.g. if x_size(t) = 1, and y_size(t) = t, then the width of the copies will be identical to the template, but their height will increase with increasing t. Finally, specify the rotation angle (theta) as a function of time. If the rotation anchor is set, the object will be rotated around it, otherwise it will be rotated around its center. Draw a rectangle (leave as object) and some path you want to let "travel"(convert from object to path if required) The rectangle has to be in bottom layer in relation to the travel object Some example travel Twist Source: https://wiki.evilmadscientist.com/Twist Draw some path Apply extension Check the result Special factor 0.5 Unwind Paths An extension to wrap off paths to receive horizontal lines or extruded bands. Can be used for paper crafting, analysis and other works. You can also just use it to colorize path segments. Tips: You can use Move Path Node  to change the starting nodes of paths. You can use Offset Paths to offset the root paths You can use Joinery - Laschen, Ösen, Nasen, Stege in 2D-Modelle einarbeiten to add tabs, flaps or other connectors Note: Unwind Paths is similar to https://inkscape.org/~Shoshanaz/%E2%98%85horizontal-lines-effect-hlines , but it is more andvanced as it supports bezier curves and allows to create extruded bands, style config, etc. See also: Paperfold Box Maker - Path To Flex Zigzag Nodes Draw a path (circle in this example) Add nodes to path to generate a good base Modify Path → Add Nodes Shape/Pattern from Generator Archimedes Spiral The extension draws a spiral by a lot of fine-grained line segments. The quality can be set by "Step". a is a constant  r is the length of the radius from the centre or beginning of the spiral vor 6 Tagen Examples Buxtronix Living Hinges Examples Source: https://github.com/buxtronix/living-hinge See also: Living Hinge (Size Input) Living Hinge (Fit To Rectangle) Box Maker - Living Hinge Fibonacci Pattern Examples Inklin Erstellt von admin am 09.07.2021 Source: https://inkscape.org/de/~inklinea/%E2%98%85inklin A polygon arc generator. Creates polygons with arcs as sides instead of straight lines. See also: Lasercut Polygon Polygon Side Lasercut Polygon Living Hinge (Size Input) See also Buxtronix Living Hinges Living Hinge (Fit To Rectangle) Box Maker - Living Hinge Parabola Source: https://github.com/opensourcebear/inkscape-extension-parabola Parabola 2 Source: https://github.com/opensourcebear/inkscape-extension-parabola/pull/1/commits/d645767e18b59b8373d45736a615dbae8da913fc   Polygon Side Source: https://inkscape.org/de/~inklinea/%E2%98%85polygon-side Creates a polygon with a given side length.   See also: Lasercut Polygon Inklin Random Line Source: https://github.com/opensourcebear/inkscape-extension-random-line Sine and Lace Source → https://github.com/vishnu20001/EggBot/tree/master/inkscape_contributed SpiroGraph Requirements https://github.com/fsmMLK/inkscapeMadeEasy (included in MightyScape) https://github.com/fsmMLK/inkscapeSpirograph (included in MightyScape) Docs https://inkscape.org/zh-hans/~fsmMLK/%E2%98%85this-extension-will-assist-you-creating-spirograph-plots https://github.com/fsmMLK/inkscapeSpirograph Sundial Declining https://inkscape.org/de/~TomasUrban/%E2%98%85sundial-declining You can use mapcoordinates.net to retreive your desired location coordinates Triangle Same triangle generator than default, but with possibility to enter units: Vektorkollektor A little contribution to the ongoing Vektorkollektor project by Niklas Roy and Kati Hyyppä . See https://stadtfabrikanten.org/article/offene-werkstatt-mit-vektorkollektor This extensions grabs the live vector data from RAW js file and parses it into usable arrays creating Inkscape SVG lines Tips for post processing Making files for T Shirts select all paths and run Chain Paths additionally change miter style / cap style to straight thicken up the paths to desired width convert the contour to a path. This allows to cut those images with a vinylcutter: 3D Printing Use Paths to OpenSCAD More details: http://www.vektorkollektor.com http://www.vektorkollektor.com/vektordaten/vektorkollektor.pdf http://www.vektorkollektor.com/vektordaten/vektorkollektor.js http://www.vektorkollektor.com/vektordaten/vektorkollektor_optimized.js (same format like vektorkollektor.js but with filtered line duplicates / overlapping segments) Simple Inkscape (Interface) Source: https://inkscape.org/~Mr.Raven/%E2%98%85simpleinkscapev01+2 Original description: This extension changes the Inkscape interface into a simpler one. It hides quite some elements from the menus and toolbars so that a more basic version of the interface remains. This can be useful for educational purposes. It is very easy to use and you can always go back to the default Inkscape user interface. After installing the extension, you restart Inkscape, open the menu 'Extensions', submenu 'Interface' and then 'Simple Inkscape'. It explains itself. This extension was made in collaboration with @Kirstie, one of the users of the Inkscape forum and writer of a very good Dutch book about Inkscape. She made the changes to the ui, I made the extension that installs or removes them. There are two forum topics about this extension. https://inkscape.org/forums/extensions/simple-inkscape-what-items-do-we-want/ https://inkscape.org/forums/extensions/simple-inkscape-extension-children-education-learning-simplified-user-interface/ It works in Windows and Linux for Inkscape 1.0 and above. Lower versions of Inkscape will not work. Mac is currently not supported since I have no Mac to test it on. It will simply give an error message on Mac. If anyone who has a Mac wants to help me test it, I believe I can make it work for Mac as well. Please contact me if you want to help me with it. If you have questions - please feel free to ask. I would also be interested to know if the extension is used and what it is used for so that I can keep that in mind for future versions. So if use it - leave a post if you like. Table Support Source: https://sourceforge.net/projects/inkscape-tables/files/ Updated to be compatible with InkScape 1.2+ The functions "Duplicate Table" and "Fit Guides" options were removed due to defectness Possible actions to perform Create Add Colums Rows Guide Lines Edit Selected cells text Selected columns width Selected rows height Selected table width and height Fit Selected table to page Selected table to page width Selected table to page height Merge cells Merge selected cells Split selected cells Remove Selected columns Selected rows   Text Convert To Localized Braille https://github.com/mondeja/inkscape-braille-l18n-ext This extension has some more options than the default one from Inkscape Glyph IDs Source: https://gitlab.com/EllenWasbo/inkscape-extension-getsetGlyphIDs These two extensions streamline the process of creating fonts using the Custom Stroke Font extension https://github.com/Shriinivas/inkscapestrokefont . With a font with many glyphs it might be quite cumbersome to set the ids of each glyph manually using the XML editor. Use the getGlyphIDs to fetch the IDs before editing a font - the path IDs are easily changed during editing. Use the setGlyphIDs to set the path IDs effectively based on a string input having all the glyphs ordered from left to right. Read more about this extension on Cutlings . Ids To Text Lets you extract the ids (or other attributes) from all selected paths and show them as text elements inside the paths. Source:  https://github.com/whiplashoo/ids_to_text_inkscape   Label Feature With Fill Color OCR (Image To Text) Reads text from Inkscape canvas. Data inside may be SVG or PNG or whatever because the canvas will be exported as PNG using Cairo library. Source: https://github.com/amal-san/inkscape-ocr Requirements (Ubuntu): sudo apt-get install tesseract-ocr pip3 install pytesseract cairosvg Remove Text Stops Remove the following portions from text elements by filtering the dx attribute of tspan children of text elements: Input: Output: This extension helps to clean up imported PDF docs and other weird files :-) Source Code Text Based on the "Lorem Ipsum" plugin, this plugin searches the base directory for code, and strings it all together by concatenating on whitespace. If a flowed text is selected, Source code is added to it; otherwise a new flowed text object, the size of the page, is created in a new layer. Source:  https://gist.github.com/om-henners/8c642c87b71daa3ea68222d40167edbc Stroke Font Creator Source: https://github.com/Shriinivas/inkscapestrokefont Replace Text Simple plugin to replace the text of all (selected) text elements. Nice for mass editing. text elements often contain multiple lines, which is represented by multiple tspan elements. We can delete all tspans except the first to "shorten" everything. It can be also used to remove trailing whitespaces and whitespaces between words. Tracing/Images/Edge Detection Centerline Trace Image Triangulation requires python modules "Pillow" "numpy" "scipy" "opencv-python" - need to be installed manually Examples Imagetracer.js This extension is an InkScape wrapper for https://github.com/jankovicsandras/imagetracerjs. It utilized a standalone node.js executable to run the JavaScript code. It will be fed with embedded or linked images within InkScape. The big difference between this tracer and all other tracers in recent InkScape is the fact that it is better capable of splitting an image into it's "isles" (cutouts). The regular tracers separate by colors or layers but not by objects. That makes it hard to work with sometimes. Imagetracer.js will vectorize your beautiful image into a more beautiful SVG trace with separated infills (break apart into single surfaces like a puzzle), that means you get a lot of single areas. However, this separation does not work flawlessly. It does not reach the quality of the software "Vector Magic". See also KVEC Tip: You can separate the colors into handy layers if you want by using Styles To Layers Notes about the code: tested to run with NodeJS v10.19.0 (and hopefully above) some options were removed because they make no sense within Inkscape, like: pal, scale, corseenabled, layercontainerid Take Mario's cat Mister Charlie Trace Charlie by running Imagertracer.js Maybe you want to run Apply Transformations after running the extension because the imported SVG group will have it's own matrix transformation (XY translation and scaling) which could be annoying for you. Play with Charlie Splitting by ungrouping Warning: Do not calculate on ultra large images. You might get errors like: FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory 1: 0x7fb77b79446c node::Abort() [/lib/x86_64-linux-gnu/libnode.so.64] 2: 0x7fb77b7944b5 [/lib/x86_64-linux-gnu/libnode.so.64] 3: 0x7fb77b9c0e6a v8::Utils::ReportOOMFailure(v8::internal::Isolate*, char const*, bool) [/lib/x86_64-linux-gnu/libnode.so.64] 4: 0x7fb77b9c10e1 v8::internal::V8::FatalProcessOutOfMemory(v8::internal::Isolate*, char const*, bool) [/lib/x86_64-linux-gnu/libnode.so.64] 5: 0x7fb77bd5bc66 [/lib/x86_64-linux-gnu/libnode.so.64] 6: 0x7fb77bd6fa37 v8::internal::Heap::AllocateRawWithRetryOrFail(int, v8::internal::AllocationSpace, v8::internal::AllocationAlignment) [/lib/x86_64-linux-gnu/libnode.so.64] 7: 0x7fb77bd3bdda v8::internal::Factory::NewFillerObject(int, bool, v8::internal::AllocationSpace) [/lib/x86_64-linux-gnu/libnode.so.64] 8: 0x7fb77bfc7424 v8::internal::Runtime_AllocateInTargetSpace(int, v8::internal::Object**, v8::internal::Isolate*) [/lib/x86_64-linux-gnu/libnode.so.64] 9: 0x2d292f85452b Aborted (core dumped) Error while processing input: <--- Last few GCs ---> [7149:0x1eff140] 13889 ms: Mark-sweep 934.7 (959.0) -> 934.7 (959.0) MB, 92.5 / 0.0 ms (average mu = 0.642, current mu = 0.001) last resort GC in old space requested [7149:0x1eff140] 13989 ms: Mark-sweep 934.7 (959.0) -> 934.7 (959.0) MB, 99.4 / 0.0 ms (average mu = 0.446, current mu = 0.000) last resort GC in old space requested <--- JS stacktrace ---> ==== JS stack trace ========================================= 0: ExitFrame [pc: 0x2d292f85452b] 1: StubFrame [pc: 0x2d292f836510] 2: StubFrame [pc: 0x2d292f837f8d] Security context: 0x1ac76ab2ee11 3: new Uint8ClampedArray(aka Uint8ClampedArray) [0x1ac76ab43189](this=0x1331c8a02609 ,0x01ad07902c99 ) 4: ConstructFrame [pc: 0x2d292f799edf] 5: StubFrame [pc: 0x2d292f874384] 6: /* anonymous */ [0x148beddd5bc9] [/home/tomate/.config/inksc... Check the image file (maybe convert and save as new file) and try again. Your parser command: node imagetracerjs-master/nodecli/nodecli.js /tmp/imagetracerjs.png ltres 1.0 qtres 1.0 pathomit 8 rightangleenhance true colorsampling 0 numberofcolors 32 mincolorratio 0 numberofcolors 32 colorquantcycles 5 layering 0 strokewidth 1.0 linefilter false scale 1.0 roundcoords 1 viewbox false desc false blurradius 1 blurdelta 20.0   KVEC KVEC is a freeware program that allows you to convert raster graphics to vector graphics. You can freely use it. Before 2010 it was distributed as shareware. Please download the freeware version from the kvec web site ( https://www.kvec.de ). It can be freely distributed and copied. KVEC is very exacting with respect to memory demands. Vectorizing is a critical process and often leads to a trade off between memory demands and performance. It is crucial for the performance that your computer has enough RAM. The selection of values for the switch parameters requires some caution. Noisy pictures (typical for scanned colour pictures) or pictures with a lot of very small details should be evaluated with larger 'grit values' and smaller 'quantize values'. This is a special inkscape frontend implementation. A lot of KVEC options are not supported, because we reduced the support for SVG format only. Please see the KVEC readme for full details. Generate bezier curves The output will consist of bezier-curves instead of straight lines. This allows you to zoom the image without getting edges. For the output formats which don't support bezier curves, the bezier algorithm will be simulated and approximated by polylines. Centerlines off Turns centerline vectorization off (Default) mixed The effect of this parameter depends on the value of the parameter -lwidth. (If used together with -centerline, the meaning of the parameter -lwidth is modified). Before vectorizing, all detected objects were checked for its maximal thickness. All objects with a maximal thickness less than -lwidth were treated as line objects; all other objects were vectorized in the normal way. The vectorization of line objects does not result in border lines around the objects. It produces single lines which are located along the centerlines of the objects. The final linewidth of this generated single lines will be adopted so that the area of the line object is about the same as the area of the original object. (this has no effect, if the output format cannot handle variable linewidths). lines The same as 'centerline mixed' except that only line objects will be generated. All other objects will be discarded Colorspace conversion parameters Selects the internal color space which is used by kvec. The effect of changing the internal color space will be noticed when used together with the "colorsep" option or when bitmap processing is performed ("process" option). Note: If a color space other than RGB or CMYK is selected, the colors will be changed such that the optical impression will be quite near to the original image. RGB is default. Color separation parameters   Selects the type of color separation. The output file will only contain the specified color components. Please note, that for cmyk separation the color space is also set to the right value. Note: It is useful to produce a gray-scale output file for single component color separation. This can be achieved by using the "-black" option together with colsep. rgb: no color separation (default). cmyk: no color separation rb: extract R and B components gb: extract G and B components gr: extract R and G components cy: extract C and Y components my: extract M and Y components mc: extract C and M components rr: separate R color gg: separate G color bb: separate B color cc: separate C color mm: separate M color yy: separate Y color  Fill The fill parameters specify how the generated polylines/polygons will be interpreted: solid Polygons are always closed (i.e. the last point of a vector is identical with the first point). The Polygons are filled with individual colors (DEFAULT). The sort parameter should not be 'min' in this case because the  larger Polygons would cover and hide the smaller ones. line Output consists of polylines with individual colors. The polylines are not closed. This is the preferable fill parameter if the outputfile is generated for a pen-plotter. The plotter pen will never plot more than one color one upon another. The layout will depend on the sort order  specified with the 'sort' switch. With the switches  'reduce' and 'smooth' you can once more refine the layout of the output. contour  The same as '-fill solid', however the interiors of the  polygons remain 'hollow'. Lines with different colour can cover each other. The layout will depend on the sort order specified with the 'sort' switch. Font KVEC generates (before vectorization) an optimized set of parameters, which is suited for vectorization of dark colored text on a clear background. All objects get a unique 'dark' color. Sort order "local" is automatically turned on for generation of sub-polygons. Gap fill (jumping) This parameter controls whether the vectorizer can 'jump' over gaps while tracing an object. The value N must be specified in 10ths of a pixel. Allowed values: 0 - 30. Filter out details smaller than x pixels Polylines or polygons which belong to a bounded area with a number of pixels fewer than N will be filtered out (i.e. small details are 'erased'). The default value depends on the dimensions and the colour depth of the picture. The use of a grit value > 0 increases the computing time and increases also considerably the demand of memory. If you have to deal economically with memory you should try a grit value of 0 and decrease the quantization value. Line width Specifies the line width of the generated output vectors in 10ths of a pixel. Allowed values: 0-1000. Default value: 0. Note that this parameter has a different meaning if used together with the option -centerline. In this case the default value for the lwidth is 100. Polygons overlap (1px) If this switch is specified, Polygons will slightly overlap, actually one pixel. (DEFAULT: no overlap). If vector images show strange coloured gaps after they have been rotated (especially along border lines between adjacent Polygons) you should set this switch. Palette optimize KVEC will use internal optimized palette when color reducing has to be done (default) fixed KVEC will use a standard color palette when color reducing has to be done. This often gives better vectorization results, especially if the raster image contains less than 16 colors. user (not supported!) R1,G1,B1, .... Rn,Gn,Bn: Here you can specify a user supplied color palette which contains colors. The value must be followed by RGB triples. It is more practicable to use a parameter file than entering all RGB values on the commandline. The value for n may not exceed 256 colors. Color quantization The input file will be quantized down to N colors before vectorization, if it contains more than N colours. Default: 32 colors Type of line reducing The reduce parameters specify whether all those points of a vector laying on a straight line may be replaced (= reduced) by two points (the start and the end point of the straight line). This reduces the size of the outputfile. Because straight lines can lie horizontally, vertically, or diagonally,we have: orthogonal straight horizontal and vertical line-segments will be reduced. This is the default value. all All straight lines will be reduced (diagonal lines too). Occasionally, small gaps may appear in the layout. off lines will not be reduced. The only case in which you may want this setting is when you want the velocity of a plotter pen to slow down for long straight lines. High vectorization resolution The resolution parameters have some influence on the internal evaluation. If high, all details will be retained (needs more memory), else very small details may get lost (default) Sorting The sort parameters specify the sequence order in which the vectors appear in the outputfile: nosort  Vectors will not be sorted. Contours with different colours may cover each other but the interior areas of each vector cannot be covered by those of another vector. max This parameter depends on the filltype: For filltype 'solid' the Polygons are sorted by the size of the bounded area. For filltype line and color they are sorted by the length of the vectors (sortorder is from maximimum to minimum). This is the default value. min The same as sort 'max' but sortorder is from minimum to maximum. This makes no sense together with '-fill solid'. local The generated output order preserves the local topology, i.e. objects are drawn in the order in which they are nested. The sort order in a group of nested objects is from max to min. The sort order for groups is the same. Needs more computing time. If the sort order is local0, KVEC will try to generate subpolygons having transparency color. This may be usefull for vectorizing of text. The "-font" option will turn on the local sort order automatically. color Polygons/polylines are sorted by color. Subsampling If enabled, the output vectors are subsampled by a factor of 2. This will reduce the size of the output file and will also result in smoothing the vectors.  Sysmalloc If enabled, use the memory-allocation routines from the operating system, else KVEC uses its own memory allocation routines. Some operating systems have slow allocation routines. Try this switch if the performance of KVEC decreases. Text Generate or suppress output of text in the output file. Default is enabled Color vectorization Normal No special mode. Default Only darkest and brightest color The same as -vblack, except that only the dark areas will be processed. Thus, white areas inside of black areas might dissapear if the 'black' object is of type 'filled polygon'. All colors except brightest  The same as -vblack, except that only 'not white' areas will be processed. Thus, white areas inside of other areas might dissapear if the object is of type 'filled polygon'. Only colors with 'darkest' RGB-values Only the colors with the 'darkest' RGB-values will be vectorized (picks the 'black' lines out of the picture). All other objects were treated as having one unique 'white color'. The regions consisting of this 'white' color will also be vectorized. Thus, white areas inside of black areas will be shown correctly. Note that a lower -quantize value results in the generation of more 'black' lines. If the quantize value is too high, the program will not catch all all dark regions. Winding original (Default) Winding of polygons will be unchanged, as detected from the source or from the vectorizer. reversed Reverse the winding direction. This may be necessary for some types of input data.  optimized KVEC sets alternating winding directions for main- and subpolygons, depending on the nesting depth.  Delta This is the maximal allowed color difference between the rough and the detail layer. The detail layer contains a vector representation of these areas which have a colour difference to the first layer greater than delta. Note: delta has two different meanings: If used together with the 'progressive' option it means a color difference between two layers. If used together with the 'vcolor' option it means a maximal allowed color tolerance. Values: 0 up to 128. Default: 0 Error-Parameter for Bezier-curves Use the value N for the Bezier error-parameter. Allowed values: 1 - 20. Greater values for errbez will allow more differences between the original and the output picture and will reduce the size of the output. The default value is 3. Lossless Generates a lossless image. May need enormous memory. This is a synonym for: -resolution high -grit 0 -reduce orth. and no quantization Progressive KVEC offers you the possibility of building a 'progressive' image. The term 'progressive' means that the image is build up from two successive layers (one 'rough' picture without details and one refined picture which contains only details). The two layers follow in this order as the image is build up. This kind of image representation is very robust against all kinds of transformations and local deformations. The difference of the two layers with respect to colour quantization and resolution of details is expressed by the gritfactor and the colorfactor: -progressive gritfactor N: Generates a progressive image with 2 Layers. The first layer has a grit-value multiplied by N -progressive colorfactor N: Generates a progressive image with 2 Layers. The first layer has a quantize-value divided by N Smoothing of polylines The program will try to smoothen the polylines and Polygons. This is involving some loss of information. Default: Depends on the output format. Using the 'smooth on' with the WMF or EMF-Format will increase the resolution of the outputfile by a factor of 4. Pick out regions with color - mode none Do not apply matching This switch can be be used to pick out regions of the image which have the specified color. The color representation is RGB (Red Green Blue) with values from 0 up to 255. Only these regions that match this colour will be vectorized. Note: If a delta value > 0 is specified ('-delta' option) all colors which lie in the range (RGB +/- delta) will be vectorized. not_matching Only these regions that do not match this colour will be vectorized. Note: If a delta value > 0 is specified ('-delta' option) all colors which lie in the range (RGB +/- delta) will not be vectorized. Original KVEC software This is how official GUI looks (some settings screenshots). Line Shading See also Raster 2 Laser GCode The Endurance Line Shading extension enables to convert a raster image into waves. This extension can be used to get an art effect that goes perfectly with laser engraving. The image is divided into a certain number of lines. The pixel brightness in every line modulates the frequency and amplitude of the basic wave. Options Waveform three basic waveforms are available: sinusoidal, triangle (saw-shaped), square (meander) Number of lines Min period: of the wave (maximal frequency corresponds to the black color) Max perio: of the wave (minimal frequency corresponds to the white color) If you set the same values for the max. and min. periods only the amplitude modulation will be used. The waves period at that will correspond to the given one. If you make the minimal period bigger than the maximal one, the colors in the picture will get inverted Min amplitude: of the wave (corresponds to the white color) Max amplitude: of the wave (corresponds to the black color) If you set the same values for the max. and min. amplitudes only the frequency modulation will be used. The wave’s amplitude at that will correspond to the given one. If you make the minimal amplitude bigger than the maximal one, the colors in the picture will get inverted Gamma: gamma correction coefficient. The parameter increment makes middle tones of the picture darker; the parameter decrement makes them lighter. The brightness of the middle tones corresponds to the initial at 2,2 value of this parameter. Line width Remove image Pixel2SVG Makes a SVG colored rectangle raster from true raster image. Ideal for Icon creation. Documentation → https://florian-berger.de/en/software/pixel2svg Example Input Image: Result: Pixels To Objects Source: https://inkscape.org/~pakin/%E2%98%85pixels-to-objects Select a bitmap and one other objects, and run the extension. It will place one copy of the object at each pixel coordinate. For example, a 32×32 image will lead to objects being placed at coordinates (0, 0) through (31, 31). Options enable objects to have their stroke and/or fill color adjusted to match the corresponding image pixel; background-colored pixels to be either considered or ignored; image coordinates to be scaled up or down; and multiple objects to be assigned to coordinates either randomly or deterministically. For instance, in the banner image above, a 16×16 bitmap was selected along with four path objects of size at most 18×18. In the dialog box, "Apply color to stroke" and "Ignore background pixels" were checked. "Image coordinate scaling" was set to 18 to prevent the path objects from overlapping. And "Instantiation of multiple objects" was set to "By image coordinates" to cycle evenly through all four path objects. Take some picture We use https://openclipart.org/detail/190682/trace-tree Reduce the image to less pixels Run the extension See also Pixel2SVG Primitive (Michael Fogleman) Source code https://github.com/fogleman/primitive HowTo compiling on Windows → fogleman/primitive on Windows Say hello to Nala cat Configure her a nice primitive setting Vectorized cat madame Shape Recognition Example   SVG Embed And Crop Linked Images Sources: https://github.com/bnanes/svg-embed-and-crop/releases https://b.nanes.org/svg-embed-and-crop requires to install Java #Fedora sudo dnf install java-latest-openjdk.x86_64 About Inkscape is a powerful open-source vector graphics editor which supports the inclusion of raster images either through file references (links) or through direct embedding of the image data in the Inkscape SVG file. Referencing images as links keeps SVG files small and ensures that changes to image placement and transformations specified in the SVG file remain separate from the underlying image data. However, embedding images may be required as a final step in some production work-flows. This java-based extension for Inkscape facilitates image embedding by: Automatically identifying all linked images Cropping image data that lies outside the images’ clipping frame Optionally applying jpeg compression Optionally resampling images above a maximum resolution Writing the cropped and possibly compressed image data directly in the SVG file By cropping image data that lies outside the clipping frame, applying jpeg compression, or resampling to lower resolution, the resulting file size can be reduced significantly. If preserving image quality is a priority jpeg compression and resampling can be explicitly avoided. Known Issues Images that have already been embedded are ignored. Only clipping planes created from rectangles are currently supported. In Inkscape versions >= 1.0, non-ASCII characters in text elements may be disrupted on some systems. This is dues to an issue with the new extension system; a fix has been proposed . Workarounds include using Inkscape versions < 1.0 or editing share/inkscape/extensions/inkex/extensions.py in your Inkscape installation as detailed here . PDFs saved from Inkscape may not include jpeg compression, even if images are embedded in the SVG as jpegs. Additional information is available here . A workaround is to embed images without compression, export a PDF, then compress images in the PDF using The PDF Shrinker . On some 64bit Windows systems, Inkscape’s Python interpreter fails to recognize the JRE, even if it is correctly registered with the system. A workaround for this issue is to edit svg-embed-and-crop.py to include an absolute path to the JRE. cannot access some files from regular user "can't read file link" Transformations Another Perspective This is similar to Bezier Envelope Draw an object and convert to path Draw some envelope path Run the extension and check result Apply Transformations An Inkscape extension which recursively applies transformations to shapes. This will remove applied Matrix values from object but will keep it's transformation. It will reset the matrix to basic values like these: It will also clean Live Path Effects Barrel Distortion Draw some shape Run the extension Result Bezier Envelope This extension is similar to default Inkscape extension "Modify Path → Envelope" and is also similar to Another Perspective . Note: this extension does not work for svg:circle which were converted to svg:path. Those will contain a or A commands in their path. We need to convert those to paths with c or C commands! Draw the path you want to fit into the envelope Draw your 4-sided envelope around Please note! Paths with more than 4 sides will not correctly apply. Paths with less than 4 sides will fail. So just draw a square shape (angles don't have to be 90 degrees) Start in the upper left corner and draw clockwise. Otherwise your result may get twisted in an undesired way Run the extension First select the inner path. As second select the envelope. If you dismiss the order the extension will fail. Cutting Optimizer (Nesting) Source of documentation: https://translate.google.com/translate?hl=de&sl=fr&tl=en&u=https%3A%2F%2Fwiki.fablab-lannion.org%2Findex.php%3Ftitle%3DCutOptim CutOptim Presentation All the users of the laser cutter have probably been confronted with the problem: my drawing does not fit in the wood sheet at my disposal or even in the laser cutter! To try to remedy this problem, I started writing an optimization program for placing objects on a sheet. For interested readers, this is a variant of a problem well known in the world of optimization (bin packing problem). By doing a little research on the Web, there are also many links to programs performing this task, but the free versions are often very limited, they are content to optimize the cutting of rectangles. This can help a furniture manufacturer, but it's too limiting for a laser cutter! This program reads an input SVG file containing the objects to be placed and outputs a second SVG file containing the placed objects. It can be used as is (command line, no GUI!) Or as an extension inkscape which then provides the GUI. Environment As mentioned above, this program can be used alone or as an inkscape extension. The work to be done can take a relatively long time, it is better to run it on a modern processor, but if you are in no hurry ... The memory consumption is reasonable, no need to rush to buy new RAMs! S oftware First of all as it is a program written in C ++ for a performance issue, it must be compiled on your machine. I wrote this program under Linux / Ubuntu (compiled with gcc), but since there is no system dependency, it should work as it is under any other version of Linux. For fans of Windows (there is!), I created a Visual Studio project that allows to compile on this platform. For Mac users, sorry I do not have it, you will have to fend for yourself, but the C ++ used is really standard, it should work as soon as you have access to a compiler. For information, I did not change the code between Linux and Windows, that's saying! Linux installation The code is available here: https://github.com/thierry7100/CutOptim For the uninitiated, you clone (or download) the directory, it comes in the form of a .zip archive, which must be extracted. Then you open a terminal, go to the created directory and launch the commands: make release make install: this will copy the software to the directory ~ / .local / bin which is in the list of executable directories, which will allow you to use it directly (this may be specific Ubuntu, it's up to you put the program elsewhere on another system. make install_inkscape: this will copy the program to the inkscape extension directory (~ / .config / inkscape / extensions). If you want to make this extension available for all accounts on your machine, copy the file cutoptim.inx + the executable into / usr / share / inkscape / extensions (you must be root). If you have opted for the inkscape extension, at the next start you will have a Fablab / Laser Cutting Optimizer extension cd ~ git clone https://github.com/thierry7100/CutOptim.git cd CutOptim make release #make install #try ~/CutOptim/bin/Release/CutOptim Windows installation The code is available here: https://github.com/thierry7100/CutOptim . For the uninitiated, you clone (or download) the directory, it comes in the form of a .zip archive, which must be extracted. Then you launch Visual Studio, you can get a free version for special purposes, see Visual Studio Community Edition v17 (You also need to install Windows SDK-Version 10.0.16299.0 within Visual Studio Installer). Then, once Visual studio started, you have the CutOptim project, then: You ask to generate the release version of the project if it is not the one that appears in the menu bar. You choose the platform (x86 or x64) of your choice. By default the file is configured in x64, if you have a 32bit version of Windows, change to x86. You click Generate / Generate Solution, the compilation starts and after a few seconds, your program is available. Then, under windows, better use this program as extension inkscape, the command line is hardly used? ! To do this, copy the cutoptim.inx and CutOptm / x64 / Release / CutOptim.exe files to the inkscape extensions directory. This can be found via the Edit / Preferences / System command, but it is usually under C: \ USERS \ \ AppData \ Roaming / inkscape / extensions. Attention, to see this directory, you will have to validate the visualization of hidden files under the explorer of files, if it were not done. As in Linux, at the next start of inkscape you will have a Fablab / Laser Cutting Optimizer extension Operation The input and output format of the files is the SVG format, available on many software programs. If you use inkscape, it is the native format, the program has been tested in this context. It should also work with files from other drawing software that generates SVG. If you have a problem tell me ( thierry@fablab-lannion.org ) Description of the process: The inkscape document (at least its size) can usually be of importance, here it sets the size of the sheet used for cutting. You will need to set a document size compatible with your material (and the cutter, of course!). First of all, the program reads the inkscape document, it only considers paths or simple objects. The texts not transformed in the way, the images ... are ignored. I therefore advise to turn everything into a path before launching the program. Inkscape Ctrl + A then Objects in Path (SHIFT + Ctrl + C). Unclosed paths are also ingnorated, the software is only able to process shapes with a closed outline. Paths can be placed anywhere, in the sheet or out, it does not matter. To a certain extent, they can even be superimposed (see below). Then, from these paths, the program creates polygons approaching the paths (with an error of less than 0.1mm on average). Then the program "enlarges" these polygons to prevent paths from touching each other in the final result. The size of the enlargement is configurable. The program then takes these enlarged polygons and will try to place them in a way that is not optimal but good. Why not optimal because the problem is difficult (complete NP in mathematical terms) and requires a very long time even for simple configurations. The basic idea here is to start from the largest polygon, then to place the sorted polygons by decreasing size such that a vertex of the polygon to be placed is positioned on a vertex of an already placed polygon. This reduces the space of possibilities, even if it remains very large! The "best" configuration is obtained when the size of the convex hull is minimal. Another mathematical term! The convex hull is the smallest convex hull containing all points of all plotted polygons. Intuitively, this maximizes the free space on the plate, which is the desired result. Be careful, it is not necessarily the smallest rectangle, the convex envelope is not usually a rectangle! To place the paths, the software is allowed to turn the objects, unless you block this possibility. Depending on your needs (non-homogeneous material) you may have to limit rotations to 0 and 180 ° for example, or even to block any rotation (this will be the case for example with printed fabric). Program Options under inkscape The program has many options detailed below: Units: Always use the mm, the program is not tested for other choices. Min distance between objects: This is the size of which polygons will be enlarged. This value must be greater than 0.8mm, the approximation by polygons is not perfect. Max length of single segment: as explained above the software will try to find a good configuration by positioning vertices on other vertices. It can be interesting in some cases to "add" vertices to have more possibilities. If an edge is larger than the specified size, it will be broken into multiple segments, with additional vertices. Do not abuse this option, too low a value will slow down the treatment tremendously. Do not go below 100mm in most cases, even if the value 0 is allowed to indicate that you do NOT want to use this possibility. Optimizing level: as indicated above the program places the polygons in order of decreasing size (we place the largest pebbles first ...). This sometimes leads to clearly suboptimal situations. By increasing this parameter, the software will optimize the placement of a group of N polygons. This gives better results, but be careful, it considerably increases the treatment time. Do not exceed 2 or 3, if the default value of 1 does not give good results. If you draw has 300 vertices already placed (rather low value actually) and you allow rotations in steps of 10 °, use N = 2 will multiply operations by 36 * 300! And for N = 3 by (36 * 300) ²! Keep original layer in output. If you do not trust!, You can check this option, the original shapes will be kept as well as those placed, but placed in different layers. You will be able to check the work done. Select option for largest element placement. The first item can be placed where you want on the page. Usually at the top left, but the center also gives good results. If this option is checked, the rotation angle of each object will be chosen from 4 to make the edge coincide with one of the two of the vertex on which the object is going. to be positioned. This option is economical in processing time (at most 4 tests) but can give less good results than the fixing of the angle of rotation. The results are worse when the segments are very short, if the input form is not a polygon for example. Try rotation by (0 no rotation allowed): This option is incompatible with the previous one, it is only valid if the previous option is NOT checked. In this case, the objects are positioned on discrete rotation steps. 0 means that rotations are prohibited, this is useful when the material is not homogeneous. For MDF, no restrictions, but for wood or even plywood, if you want to respect the direction of the wood, rotations are not advisable. Choose 180 ° in this case. Attention, low values ​​greatly increase the calculation time. With 10 °, there are 36 times more calculations than with 0 °! If the input shapes are rectangular, a value of 90 ° gives good results. In practice, we often deal with situations or related objects. For example, a plate with fixing holes. If this box is checked, the software checks if the path is included in another one, and if it is, it will not process it but link it to the larger path. Once it is placed, the same transformation (rotation / translation) will be applied to the "small" included object. Attention the software is not able to recover the space released in holes, you have to leave a little work anyway. Debug file generation: If this box is checked, a debug file (Debug_CutOptim.txt) is created in the inkscape extension directory. This can be used to understand what has (badly) happened. Program options via the command line The software has pretty much the same options as via inkscape, with some additions. eridur-cutoptim.exe [OPTION...] [optional args] -f, --file SVG Input File File (default: TestPoly1.svg) -o, --output SVG Output File Output file --positional arg File to be processed -h, --help Print help -d, --distance 1.0 Min distance between paths to be cut -m, --max_length 1000.0 Max length of one segment, break than longer -l, --optimizing_level 1 Optimizing level, process list_size elements together --debug_level 0 Level of debug info in specific debug file --debug_file Generate debug info from inkscape (default: true) -k, --original Output Original layer -n, --nested Keep nested path together (default: true) -y, --layer_output 0 Output internal layers : 1 Input layer, 2 Polygon, 4 Large polygon, 8 Hull layer, 16 Placed Polygon layer, OR these values to output multiple layers -a, --angle 90.0 Rotation step -r, --free_rot allow free rotation (default: true) -p, --firstpos Position of largest object on the sheet Position of largest object Possible developments / known limitations No doubt a lot of things, to you to propose and even to realize, the code is open! the colors and layers of the objects do not play a role yet generates trashy results in a lot of situations there is no solution to remove duplicate edges there is no solution to allow zero distance between the parts known Bugs: does not work for parts which have lines it it (groups with things like living hinge flex pattern) and ignores groups of objects Example Input Output 1 2 3 as soon as you have more than one open path (e.g. a line with 2 points) CutOptim  will crash is okay (open contour will be deleted while nesting) will crash     Bibliography As indicated the subject is well known in the scientific world, I used the two following articles Waste minimization in irregular stock cutting published in 2014 by Doraid Dalalah, Samir Khrais and Khaled Bataineh. This article gives the basis of what is achieved. Jostle heuristics for the 2D-irregular shapes bin packing problems with free rotation published in 2018 by Ranga P. Abeysooriya, Julia A. Bennell and Antonio Martinez-Sykora Good reading !   Epilog Dashboard BBox Adjust This tool is a helper to adjust the document border including an offset value, which is added. Sending vector data to Epilog Dashboard often results in trimmed paths. This leads to wrong geometry where the laser misses to cut them. So we add a default (small) amount of  to expand the document's canvas. The issue in pictures Correct fit in Inkscape Import in Epilog Dashboard (ellipse lost parts of its contour)       Exponential Distort Flip This extension only operates on a single path (or a selection of paths, but all individually) by flipping it about the imaginary line that goes from the paths first node to its last node. Source: https://github.com/aconz2/inkscape-extension-flip Draw some path Run the extension and check result Inset Alignment This extension aligns elements into the first, last or largest selected item. The bounding box shape and some custom entered offset values are used to calculate the new position. Draw some objects Run the extension Isometric Projection Source of documentation: https://github.com/jdhoek/inkscape-isometric-projection http://jeroenhoek.nl/articles/svg-and-isometric-projection.html This extension has two modes (dimetric and isometric) Also have a look at Live Path Effect "Extrude" for projections: Mirror This function is a legacy one because the exact same can be done with Live Path Effects ("Mirror symmetry") Draw some objects and a path (line) to mirror Make a copy of the objects you want to mirror (otherwise the tool will just move the selection) Use Ctrl +D Run the extension If you forget to make a copy: Normalize Drawing Scale This extension will set the drawing scale to 100% and adds fitting transforms to keep the element size. You can use Apply Transformations to apply those transforms afterwards. This neat toolchain helps to handle all path command coordinates easier. Especially helpful for import/export usage for programs which might not handle viewBox of svg:svg head correctly. Parallel Translation Source: https://github.com/chris0371/parallel-translation_extension Allows parallel translations and alignment operations of selected straight lines. These lines can be simple path objects (with only start- and end-node) or line segments of larger path objects. Purpose This extension has been written to help making a strange kind of paper cube with angles different to 90 degrees. It helps to align the faces together (probably in different arrangements, as indicated in the right side of the screenshot below) and to add complex folding flaps with lines in different colors to the edges. There are options to resize the length of the flaps so that they match the length of the edges. More detailed description The functionality of the extension is spread across different tabs of the UI. The currently selected tab determines what functionality is performed by the extension. At first glance, the individual tabs seem to have completely different functionality, but if you look closer, it all comes back to the same basic concept. You have to tell the extension what object(s) of your drawing to use/modify by selecting them before hitting the apply-button. Object types to select Within all the objects selected by you, the extension always looks for a line segment , calculates its orientation angle and length, and performs some tasks based on that calculation. This line segment could be a simple path object with just the start- and end-node. In such a case, you just have to select the whole path object. Or it could be a line between two nodes of a larger path object. In that case, you have to select the two nodes of the path. For the "Group-Alignment" functionality, the extension also looks for an alignment group . This is a group of an arbitrary number of other objects, which is aligned to the line segment we've talked about earlier. 'Aligned' means that the group is rotated, moved, and it's width is modified to match the position, orientation and length of the line segment. The extension assumes two things about an alignment group: The group shall be in its horizontal default orientation. That means that if this group is to be aligned to a horizontal line segment drawn from left to right, it does not need to be rotated. The group shall contain exactly one special object which center marks the rotation center of the whole group. It is recommended to use a circle or square or simple path for this. The extension identifies this special object by its fill-color. The color to look for can be set in the UI (at the "Group-Alignment"-tab) and defaults to neon green (#0x00FF00) Information Tab This first tab contains version information and a brief explanation of extensions functionality. Hitting the 'Apply'-button in here will just show some basic information about the drawing, what objects are selected, and some basic calculations done on those objects (like length and orientation angle for the selected line segment(s). Translation Tab This tab performs parallel translation of the selected line segment. That is, the extension calculates the orientation angle of the selected line segment, and moves the object by the given distance in the direction of a right angle to the lines direction. There are options to apply the movement to just the original object, to the original object and leaving a copy at the original position, or to a copy of the object leaving the original one untouched. There are also options to revert the movement direction and to use a fixed translation angle instead of calculating it from the original line orientation. Group-Alignment Tab This tab aligns the selected group to the selected line-segment. 'Aligned' means that the group is rotated, moved, and it's width is modified to match the position, orientation and length of the line segment. There are options to apply the alignment to just the original group, to the original group and leaving a copy at the original position, or to a copy of the group leaving the original one untouched. Further, there are different options to adjust the width of the aligned group. There are also options to apply an additional rotation of 180 degrees to the group and to auto-remove the group rotation center object from the aligned group. For the strange-paper-cube example, this functionality can be used to place the folding flaps at the straight but odd-angeled edges of the faces. Object-to-Group Tab This tab is used to turn an ordinary object into an alignment group. This is done by rotating the object so that the selected line-segment is in horizontal orientation, adding a group rotation center object at the middle of the selected line-segment, and then group the objects together. For the strange-paper-cube example, this functionality can be used to align the faces of the cube together. Moving and rotating face A to align one of its edges with the corresponding edge of a fixed face B would be a 2-step-process like this: Select the line-segment to be aligned from face A and turn the object that makes up the face into an alignment group using the Object-to-Group tab. Select this group and the line-segment to be aligned with from face B. Then align just this group (no copies) using the Group-Alignment tab with no group width adjustment.   Raster Perspective Source: https://github.com/s1291/InkRasterPerspective Apply a perspective transformation to bitmap image using the selected path as envelope, without the need to use an external software to transform the image. Select the raster image and the quadrangle path (envelope). Rotations - Minimum Bounding Box Area / Minimum Width / Find All Optimal There are three extension from https://github.com/hobzcalvin/LaserPrep which allow optimal rotation according to width or bounding box. Rotate for Minimum Width Helpful when trying to nest objects, this extension rotates all selected objects to minimize their width. Rotate for Minimum Bounding Box Area Similarly, this rotates all selected objects to minimize the area of their bounding boxes. Find All Optimal Rotations This rotates the selected objects to minimize the width and area of their bounding boxes. If these are optimized at different angles, the objects are duplicated and rotated accordingly. Having some rotated object(s) Run the extension Scale To Path Length This effect makes the length of all the destination paths the same as that of the source path, while maintaining their shapes. The source is the topmost path in the selection. Please note if the size seems incorrect after running this extension, please check if you have left some transformations. They can be removed by Apply Transformations . Draw some paths Measure to check Visualize Path → Measure Path See also Scale To Size (Replaced by default transform scale) Scale To Real Scale To Real Good description for this plugin can be found at the source → https://gitlab.com/Moini/inkscape-realscale-extension See also Scale To Size (Replaced by default transform scale) Scale To Path Length Scale To Size (Replaced by default transform scale) Draw some objects / paths Get the result This extension is obsolete because we can do the same with default transformation menu: See also Scale To Path Length Scale To Real Set View Box (Replaced by CTRL + SHIFT + R) This plugins allows to adjust the view box (canvas) size according to a drawn rectangle. You can do this using CTRL +D too but it might be quicker sometimes using "Set View Box". Use the built-in default key combination to quickly resize the view to the selected object (CTRL + SHIFT + R). Various Batch Task Source: https://github.com/heyzec/Inkscape-Extensions   Delete Above Delete the selected node(s) and any other nodes that are completely within the bounding-boxes of the selected nodes that have a greater z-order. Simply put: you select a "background" rectangle, then use this plugin to delete it and everything that appears on top of it. Take some drawing and select the target object Run the extension and get the result Edit Attributes Edits an attribute on all selected elements. Available edit options: set sets new value of attribute (adds attribute if necessary) append adds new value to the end of current value of attribute prefix adds new value to the beginning of current value of attribute subtract deletes the given value string from current value of attribute remove deletes attribute of given name Import Attributes Imports attribute values from given text file. Lines in the file must be in format elementId,attributeName,value . Malformed ids will be skipped (you will get a warning). Get the items you want to modify Run the extension Select the file you want to import data from. Example:  C:\Users\test\Desktop\test.txt rect823,y,30 rect823,x,30 rect823,width,130 rect823,height,130 Check the XML tree for changed values   Random Delete This extensions does what it says. It allows to delete with a certain probability each of the selected objects. Remove Obsolete Attributes Remove attributes sodipodi:absref , sodipodi:docbase and sodipodi:docname from all elements that contain them. These attributes contain absolute paths to resources which can pose a security issue. This is a legacy extension and might not be required nowadays. Set CSS Class On Elements Set a CSS class on the selected elements. Their current inline styles will be removed vpypetools Deduplicate Plugin Source: https://github.com/LoicGoulefert/deduplicate pip3 install tqdm pip3 install git+https://github.com/LoicGoulefert/deduplicate.git#egg=deduplicate   Filter Filter paths according to specified criterion. When an option is provided (e.g. --min-length 10cm ) the corresponding criterion is applied and paths which do not respect the criterion (e.g. a 9cm-long path) are rejected. If multiple options are provided, paths will be kept only if they respect every corresponding criterion (i.e. logical AND operator). See https://vpype.readthedocs.io/en/stable/reference.html#filter . Also check out vpype Free Mode which can do the same and more. Similar extension to Filter By Length/Area Line Merging (Combine Paths) Merge lines whose endings and starts overlap or are very close. By default, linemerge considers both directions of a stroke. If there is no additional start of a stroke within the provided tolerance, it also checks for ending points of strokes and uses them in reverse. You can use the --no-flip to disable this reversing behaviour and preserve the stroke direction from the input. By default, gaps of maximum 0.05mm are considered for merging.  Also check out vpype Free Mode which can do the same and more. See https://vpype.readthedocs.io/en/stable/reference.html#linemerge Similar extension to  Chain Paths , Join Paths / Create Tabs And Dimples , Close Paths Similar to default function "Path → Combine" (CTRL + K) inverted function is  Split All Warning: Can mess your paths because it does not delete overlapping duplicate line segments! Draw some paths and attach the path node ends with each other Run the extension and get the result Line Sorting This extension is similar to Optimize Sequence: Travel Distances and Optimize Sequence: Small Holes First . Also have a look at https://github.com/inconvergent/svgsort which could be another great path planning tool for InkScape. Also check out vpype Free Mode which can do the same and more. Example Before conversion After conversion (showing the same lines sorted plus traveling lines + conversion statistics)   Multipass Add multiple passes to each line. Each line is extended with a mirrored copy of itself, optionally multiple times. This is useful for pens that need several passes to ensure a good quality. See https://vpype.readthedocs.io/en/stable/reference.html#multipass .  Also check out vpype Free Mode which can do the same and more. Occult Plugin (Hidden / Superimposed Line Removal) This plugin command removes lines hidden by polygons. It acts like a trimmer to receive a clean set of visible paths only. It does not remove common lines between opened paths, but for closed polygons. You need to install occult plugin for vpype. See vpypetools documentation. It's a great helper for optimizing cutting jobs. It is really powerful in conjunction with Line Sorting . Also check out vpype Free Mode which can do the same and more. Key phrases: remove overlapping lines, superimposed lines, remove duplicated lines, purge redundant lines, purge doubled lines, remove common edges, remove occulted lines, hidden line removal, retrace edges, chain paths, clean paths This extension is similar ( but superior ) to  Chain Paths Join Paths / Create Tabs And Dimples Purge Duplicate Path Segments Also have a look at Purge Duplicate Path Nodes if you only want to remove duplicate knot handles in a path. Troubleshooting / Upgrade extension If the extension does not generate any output and you cannot explain why, please check if you have the latest version installed. Sometimes exceptions are hidden which show up when running from console instead. Typical error like this: Traceback (most recent call last): File "c:\users\tomate\appdata\local\programs\python\python39\lib\site-packages\click_plugins\core.py", line 37, in decorator group.add_command(entry_point.load()) File "c:\users\tomate\appdata\local\programs\python\python39\lib\site-packages\pkg_resources\__init__.py", line 2450, in load return self.resolve() File "c:\users\tomate\appdata\local\programs\python\python39\lib\site-packages\pkg_resources\__init__.py", line 2456, in resolve module = __import__(self.module_name, fromlist=['__name__'], level=0) File "c:\users\tomate\appdata\local\programs\python\python39\lib\site-packages\occult\occult.py", line 7, in import pygeos File "c:\users\tomate\appdata\local\programs\python\python39\lib\site-packages\pygeos\__init__.py", line 1, in from .lib import GEOSException # NOQA ImportError: DLL load failed while importing lib: Die angegebene Prozedur wurde nicht gefunden. You can remove and reinstall the following way: #failed #pip3 install --upgrade git+https://github.com/LoicGoulefert/occult.git#egg=occult #worked pip3 uninstall git+https://github.com/LoicGoulefert/occult.git#egg=occult pip3 install git+https://github.com/LoicGoulefert/occult.git#egg=occult Simple example Draw some rectangles Layout edges above each other (simulate having common edges) Run extension to remove common edges Move the paths to some other directions to see how the edge removal was worked out Relooping Randomize the seam location of closed paths. When plotted, closed path may exhibit a visible mark at the seam, i.e. the location where the pen begins and ends the stroke. This command randomizes the seam location in order to help reduce visual effect of this in plots with regular patterns. Paths are considered closed when their beginning and end points are closer than some tolerance. See https://vpype.readthedocs.io/en/stable/reference.html#reloop . Also check out vpype Free Mode which can do the same and more. Split All Split all paths into their constituent segments. This command may be used together with linemerge for cases such as densely-connected meshes where the latter cannot optimize well enough by itself. This command will filter out segments with identical end-points. Note that since some paths (especially curved ones) can be made of a large number of segments, this command may significantly increase the processing time of the pipeline. The inverted function is Line Merging (Combine Paths) Split All extension might be really slow on large documents. Maybe you can go get some coffee while it performs. Create some paths Run the extension Get the result We can move all lines separately now, like this: Trimming Trim the geometries by some margin. This command trims the geometries by the provided X and Y margins with respect to the current bounding box. Also check out vpype Free Mode which can do the same and more. Draw some paths Run the extension and get result vpype Free Mode This extension mode for vpypetools allows to execute one up to five command sets in the given row. It works on the current selection of paths, or if nothing selected it applies to all paths in the document. You can do exactly the same like in Filter , Line Sorting and so on, but you are freely more versatile entering combinations as you like. Free Mode allows to enter different units, like "trim 1mm 3cm" vpypetools Intro About vpype and this extension vpype is a command processor working with SVG files. It can do a lot of productive steps to optimize files for different purposes like pen plotting, laser cutting or the generation of creative artwork. vpype is really powerful and helps to extend Inkscape feature capability. vpype contains a lot of functionality which is included natively within Inkscape. The extension "vpype for Inkscape" does not deal with all features but with a set of important commands like linemerge, linesort, linesimplify, occult, etc. We can use it to shorten tool path lengths, remove hidden lines and so on. vpype converts all elements into simple SVG elements like svg:line , svg:polyline and svg:polygon . They can be displayed properly in Inkscape, but they have no knot handles to edit (see https://alpha.inkscape.org/vectors/www.inkscapeforum.com/viewtopicb51d.html?f=16&t=32562 ). We need to convert those elements to svg:path using key combination CTRL + SHIFT + C ("object to path"; do not use "stroke to path" because it will duplicate your outline with inset and outset contours). Our extension allows to do this conversion automatically . Caveats of vpype requires to simplify bezier curves to polylines (reduces quality) does not honor the individual line styles (like width, color, miter, ...) - the output lines all will have the same style. We can work with vpype layerwise to distinguish between different styles output is done in svg:line, svg:polyline and svg:polygon. Converting them back in Inkscape (we need paths) is really slow. Native svg:path output would be great Source code → https://github.com/abey79/vpype Preparations (Installation of vpype) At first we need to install vpype and occult extension. It was tested successfully... with Python 3.8.5 on Ubuntu 20 LTS (Python 3.9 failed to install vpype and occult) with Python 3.9 on Windows 10 We use vpype 1.7 (2021-06-10) vpype Changelog: https://vpype.readthedocs.io/en/stable/CHANGELOG.html Linux / Windows Python modules pip install vpype #pip install git+https://github.com/abey79/vpype.git #or by using pipx pip uninstall vpype pip install pipx pipx ensurepath # restart your shell pipx install "vpype[all]" #extra module occult pip install git+https://github.com/LoicGoulefert/occult.git#egg=occult #or pip install vpype-occult #extra module deduplicate pip install git+https://github.com/LoicGoulefert/deduplicate.git#egg=deduplicate Special inclusions and similarities to existing Inkscape extensions linemerge: Join Paths / Create Tabs And Dimples , Close Paths and Chain Paths linesort: Optimize Sequence: Travel Distances and Optimize Sequence: Small Holes First linesimplify: native function "Path → Simplify" filter: Contour Scanner And Trimmer multipass: none occult: Purge Duplicate Path Nodes and Purge Duplicate Path Segments trim: Destructive Clip Overview by docs Deduplicate Plugin Filter Line Merging (Combine Paths) Line Sorting Multipass Occult Plugin (Hidden / Superimposed Line Removal) Relooping Split All Trimming vpype Free Mode Feature exclusions As mentioned vpype has a lot of features, but we do not need all of them. We decided to exclude or handle the following functions more strictly because a lot of stuff is integrated in Inkscape natively. You can try to use vpype Free Mode to use these. category comments Primitives arc, circle, ellipse, line, rect Block control begin, end Operation crop # we use trim feature instead layout #Inkscape: CTRL + SHIFT + D pagesize #Inkscape: CTRL + SHIFT + D reverse #Inkscape: Path > Reverse Generators frame #see "Bounding Box" extension random See Bounding Box Block processors grid, repeat Native functions inside Inkscape Layers lcopy, ldelete, lmove This is too generic to make use inside Inkscape Input script This is too generic to make use inside Inkscape Transforms rotate, scale, scaleto, skew, translate See  Scale To Path Length , Scale To Real , Scale To Size (Replaced by default transform scale) and native functions like path effects and transformations Filters squiggles Text text See Hershey Text Alternative Troubleshooting Problem: Traceback (most recent call last): File "C:\Users\tomate\AppData\Roaming\inkscape\extensions\mightyscape-1.2\extensions\fablabchemnitz\vpypetools\vpypetools.py", line 17, in import vpype_viewer File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\__init__.py", line 6, in from .engine import * File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\engine.py", line 13, in from ._painters import ( File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\_painters.py", line 9, in from ._utils import ColorType, load_program, load_texture_array File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\_utils.py", line 9, in from PIL import Image ModuleNotFoundError: No module named 'PIL' Solution: Traceback (most recent call last): File "C:\Users\tomate\AppData\Roaming\inkscape\extensions\mightyscape-1.2\extensions\fablabchemnitz\vpypetools\vpypetools.py", line 17, in import vpype_viewer File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\__init__.py", line 6, in from .engine import * File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\engine.py", line 13, in from ._painters import ( File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\_painters.py", line 9, in from ._utils import ColorType, load_program, load_texture_array File "C:\Users\tomate\AppData\Local\Programs\Python\Python39\lib\site-packages\vpype_viewer\_utils.py", line 9, in from PIL import Image ModuleNotFoundError: No module named 'PIL'