Inkscape Wiki - User contributions [en]

Extension reference

2009-12-06T04:16:18Z

Inductiveload: /* Render */

''A page with info about the Effects and particularly some PNGs / screenshots. To learn more about effects and how to write new ones, check out this page : [http://www.ekips.org/comp/inkscape/ Inkscape Effects]
''
=Color=

==Brighter==
Brightens the color(s) by dividing each RGB channel by 0.9. Channels with a value of 0 remain unaffected. Although brighter and darker are inverse operations, the results of a series of invocations will cause inconstancies due to rounding errors. Use '''More Light''' if you want to brighten up black areas as well.

==Custom...==

Allows you to evaluate different functions for each channel. '''r''', '''g''' and '''b''' are the ''normalized'' values of the red, green and blue channels. The resulting RGB values are automatically clamped.

'''Note:''' This effect is half broken in 0.45! The original values are overwritten by the new ones, which means things like the last example won't work as expected.

===Examples===
Default (doesn't change anything):
:Red Function:'''r'''
:Green Function:'''g'''
:Blue Function:'''b'''

Half the red, swap green and blue:
:Red Function:'''r*0.5'''
:Green Function:'''b'''
:Blue Function:'''g'''

ITU-R Recommendation BT.709 for grayscale:
:Red Function:'''0.2125 * r + 0.7154 * g + 0.0721 * b'''
:Green Function:'''0.2125 * r + 0.7154 * g + 0.0721 * b'''
:Blue Function:'''0.2125 * r + 0.7154 * g + 0.0721 * b'''

==Darker==

Darkens the color(s) by multiplying each RGB channel with 0.9. Although brighter and darker are inverse operations, the results of a series of invocations will cause inconstancies due to rounding errors. '''Less Light''' is usually a better option, because it operates in the HSL color space.

==Desaturate==

Desaturates the color(s) by dividing the sum of the minimum and maximum channel values by two. Use '''Grayscale''' if you want something closer to the human perception of luminance.

==Grayscale==

Creates a grayscale version of the color(s) via the PAL/NTSC formula (0.299 * RED + 0.587 * GREEN + 0.114 * BLUE).

==Less Hue==

Converts to HSL color space, subtracts 0.05 from the hue, wraps if necessary, and converts it back to RGB again.

==Less Light==

Converts to HSL color space, subtracts 0.05 from the lightness, clamps if necessary, and converts it back to RGB again.

==Less Saturation==

Converts to HSL color space, subtracts 0.05 from the saturation, clamps if necessary, and converts it back to RGB again.

==More Hue==

Converts to HSL color space, adds 0.05 from to hue, wraps if necessary, and converts it back to RGB again.

==More Light==

Converts to HSL color space, adds 0.05 from to lightness, clamps if necessary, and converts it back to RGB again.

==More Saturation==

Converts to HSL color space, adds 0.05 from to saturation, clamps if necessary, and converts it back to RGB again.

==Negative==

Inverts each RGB channel (255-value).

==Randomize==

Converts to HSL, randomizes hue and/or saturation and/or lightness and converts it back to RGB.

==Remove Blue==

Sets the blue channel to 0.

==Remove Green==

Sets the green channel to 0.

==Remove Red==

Sets the red channel to 0.

==Replace Color...==

Replaces a specific color with another one.

==RGB Barrel==

Rotates the RGB channels (RGB->BRG->GBR->RGB...).

=Developer Examples=

=Export=
==Groups to PNGs==

=Generate from Path=
==Inset/Outset Halo==

[[Image:InsetOutsetExample.png]]

Parameters:
; Width: 20
; Number of steps: 5

Creates translucent copies of the path inside and outside the path.

==Extrude==
[[Image:ExtrudeExample.png]]

Parameters:
; Magnitude: 20
; Angle: 45

==Interpolate==
===Outline===
Iterpolate does a linear interpolation between 2 or more paths. It basically means that it "fills in the gaps" between the paths according to the number of steps given.

===Basic Usage===
To use the interpolation effect, select the paths that you wish to interpolate, and go to Effects > Generate From Path > Interpolate. Choose your options, and Click OK.

===Basic Example===
View figure 1 below, where there are 2 identical paths.

[[Image:Interpolate1.png]]

Here is the result when the interpolation effect is called with a "Steps" value of 6.

[[Image:Interpolate2.png]]

===Options===
One of the great features of the inkscape interpolation is "transform style", which transforms the

It appears that you need to convert an object to a path first (Path > Object to path ; Shift-Ctrl-c). You can alter the number of steps used and choose one of two methods.

[[Image:interpolate_blueSquare-redCircle.png]]
==Pattern along Path==

Star pattern and a line path:

[[Image:PatternAlongPathExample1.png]]

Pattern along path:

[[Image:PatternAlongPathExample2.png]]

Parameters:
; Copies of the pattern: repeated
; Deformation type: snake
; Space between copies: 0
; Normal offset: 0
; Tangential offset: 0
; Pattern is vertical: unchecked
; Duplicate the pattern before deformation: checked

[[Image:PatternAlongPathExample3.png]]

Modified parameter:
; Deformation type: ribbon

=Images=

=Modify Path=
==Envelope==
==Add Nodes==
==Color Markers to Match Stroke==
==Flatten Beziers==
[[Image:FlattenBeziersExample.png]]

Parameters:
; Flatness: 10

==Fractalize==
[[Image:FractalizeExample.png]]

Parameters:
; Subdivisions: 6
; Smoothness: 4.0

==Jitter nodes==
[[Image:JitterNodesExample.png]]

Parameters:
; Maximum Displacement: 50.0
; Shift Nodes: checked
; Shift Node Handles: checked
; Use Normal Distribution: checked

==Perspective==
==Straighten Segments==
[[Image:StraightenSegmentsExample.png]]

Parameters:
; Percent: 50
; Behavior: 1

=Render=

==3D polyhedron==

'''3D polyhedron''' draws polyhedra stored in OBJ files. A selection of polygons are provided with Inkscape, and others can be used by selection <tt>Load From File...</tt> in the extension dialogue.

[[image:3D_polyhedron_-_snub_dodecahedron.png|thumb|Drawing faces]]

==Alphabet soup==

'''Alphabet Soup''' generates a series of shapes that resemble a given text string.

[[file:Alphabet_soup_-_Inkscape.png‎|thumb|250px|Output for "Inkscape"]]

==Barcode==

==Calendar==

==Cartesian grid==

==Draw from triangle==

==Foldable box==

==Function plotter==

==Gear==

==Grid==

==L-system==

==Parametric curves==

==Perfect-bound cover template==

==Polar grid==

==Printing marks==

==Random tree==

==Sequential labels==

==Spirograph==

==Triangle==

==Wireframe sphere==

=Visualise Path=

==Number Nodes==
[[Image:NumberNodesExample.png]]

Parameters:
; Font Size: 20
; Dot Size: 10px

==Kochify==
To use, select one path consisting of only line segments and apply the effect. Kochify will replace the given path with a path that has a copy of the original path in between each two adjacent nodes in the original path. If the original path input has bezier curves, the effect will effectively replace them with lines and then apply the effect. For more information about Kochify from a developers perspective, look [http://www.ekips.org/comp/inkscape/koch.php here]. Requires: python.

[[Category:Extensions]]

File:Alphabet soup - Inkscape.png

2009-12-06T04:13:39Z

Inductiveload: The output of the "Alphabet Soup" effect on the string "Inkscape" with random seed = 0

The output of the "Alphabet Soup" effect on the string "Inkscape" with random seed = 0

File:3D polyhedron - snub dodecahedron.png

2009-12-06T04:07:12Z

Inductiveload: The output of the "3D polyhedron" effect when drawing a snub dodecahedron in face-mode.

The output of the "3D polyhedron" effect when drawing a snub dodecahedron in face-mode.

Script extensions

2009-11-06T18:56:43Z

Inductiveload: add link to Generating_objects_from_extensions

[Note: This page concerns using scripting languages to create new Inkscape functionality. To access Inkscape functionality from scripting languages (i.e. to script Inkscape), see the Inkscape man page (especially in the development version or v0.46 or later, which provide --select and --verb options), or see the work in the src/extension/script directory of Inkscape source.]

=== Introduction ===

Traditional unix scripts can be used to extend Inkscape's functionality.
Such programs read a stream of data on standard input, transform the data in some way, and then write the modified data to standard output. This is an easy way to expand Inkscape and provide custom functionality without learning the internals of Inkscape. Libraries for reading and writing SVG data exist for many programming languages, and most provide support for XML. This HOWTO describes the "ins and outs" of writing one of these scripts and making it work with Inkscape's core functionality.

=== Types of scripts ===

There are three kinds of functions that can be added with a script:

* Input, providing translation from a file format to SVG
* Output, providing translation from SVG to a format
* Effect, taking in SVG, changing it, and then outputing SVG

While all of these are very similar in the scripting interface, there are slight differences between them.

=== Interaction ===

It is important for a script author to understand how Inkscape and scripts communicate.

(interpreter)? your_script (--param=value)* /path/to/input[[/SVGfile]] | inkscape

Inkscape runs your script (optionally with an interpreter) passing it any number of parameters in long gnu style. The final argument is the name of the temporary svg file your script should read. After processing, the script should return the modified svg file to inkscape on STDOUT.

=== Important Tips ===

* Receive the inkscape arguments.
* Clear temp files if it creates one.
* Write full changed SVG to the default output.
* Don't break an xml:space="preserve" area.
* Send error text to the error output and help the user.

=== Description ===

In order for Inkscape to make use of an external script or program, you must describe that script to inkscape using an INX file. See the inkscape share directory for examples. The INX file allows the author to:
* label strings for translation
* define parameters
* chain extensions
Please see [[MakingAnINX]] for help creating an INX file for your script.

==== Parameters ====
The INX file describes which parameters the extension needs. Inkscape will prompt the user with a UI to fill out these parameters before the extension is called. Each parameter will be passed through the commandline as "--paramname=paramvalue". Eg. if you have described a string parameter with name 'string1' in the INX file, Inkscape will present a textbox to the user. When the user fills in "text" and presses OK, it will pass '--string1="text"' to the program specified by the <command> tag.

There are several types of parameters that can be requested by the INX description:

* Boolean
* Int
* Float
* String
* Description
* Enum
* Notebook
* Option group (radio buttons)

=== Installing ===

Installing is as simple as copying the script (unless it resides in your path) and its INX file to the inkscape/share/extensions (home/.inkscape/extensions) directory. (If you install a script in your home directory be sure to copy the dependencies.)

If you are looking to use scripts that have already been written, the most difficult part will likely be the installation. Since scripts are seperate programs they may have any number of dependencies that are not included with inkscape. Currently, the best way to find missing dependencies is by reading the error messages produced by running the script from the command line.

=== See Also ===

*[[Generating_objects_from_extensions]]. How to use a script to generate actual objects inside SVG documents.

*[http://www.ekips.org/comp/inkscape/extending.php#ignorance| Aarons website] describing his path to learning how scripting extensions work. '''VERY OUT-OF-DATE'''

*[[MakingAnINX]]

*[[PythonEffectTutorial]]

*[[Tips For Python Script Extensions]]

[[Category:Extensions]]

Generating objects from extensions

2009-11-06T18:55:03Z

Inductiveload: Created page with 'If you need an extension to generate an object in Inkscape, there are many tools that already exist to help you. <tt>inkex.py</tt> is the most notable, as this provides the routi...'

If you need an extension to generate an object in Inkscape, there are many tools that already exist to help you. <tt>inkex.py</tt> is the most notable, as this provides the routines to insert the SVG element into the XML tree of the SVG document.

There is currently no universal set of tools to allow a single function to be called, because different extension have different attibutes for thir objects. For example, the barcode extension merely needs a black rectangle with no stroke, but another may need a way to set the stroke width, dashes and opacity. Thus, it is often best to write your own subroutine for generating your objects.

==A simple example==
Let's look at a simple Python fuunction for drawing a black rectangle:
<pre>
#SVG element generation routine
def draw_SVG_square((w,h), (x,y), parent):

style = { 'stroke' : 'none',
'width' : '1',
'fill' : '#000000'
}

attribs = {
'style' : simplestyle.formatStyle(style),
'height' : str(h),
'width' : str(w),
'x' : str(x),
'y' : str(y)
}
circ = inkex.etree.SubElement(parent, inkex.addNS('rect','svg'), attribs )
</pre>

The first thing to notice is that all the attributes of the object are stored in a dictionary format, with everything being a string. This means you have to convert all your parameters to strings if appropriate (like the <tt>height</tt> and <tt>width</tt> attributes).

Next, all the style attributes (colours, widths, fonts, etc) are put together in SVG under <tt>style</tt>. To generate this string, there exists a helper function <tt>simplestyle.formatStyle()</tt>. You simply feed this function a dictionary of the styles you want, just like the attributes. You can then use this directly as the style attribute.

The next thing to see is how to add the element to the XML tree. <tt>inkex.py</tt> has the function to do this using the LXML parser. This needs to be given the "parent" of the object (we'll come back to this), the "type" of the object, and the attributes of the object.

The type of the object is in the <tt>svg</tt> namespace, which means it begins <tt>svg:</tt> (for a rectangle, it is <tt>svg:rect</tt>). LXML cannot parse colons, so we use the <tt>inkex.addNS</tt> to prepend the namespace.

The attributes of the object just needs to be passed the dictionary <tt>attribs</tt> we made earlier.

The "parent" of the object is the containing element. This is usually a group or a layer. This will be passed in by the calling function, and we will see it in action later.

When this function is run with the right parameters, the rectangle will be added to the SVG document.

==Getting the parent==

Finding the parent is easy: you can just pass in the current layer from the <tt>self</tt> object if you like:
<pre><nowiki>
parent = self.current_layer
draw_SVG_square((1,1), (0,0), parent)
</nowiki></pre>

This will just plonk the rectangle into the document, centred on the origin.

Alternatively, you can create a group much like any other object:
<pre><nowiki>
centre = self.view_center #Put in in the centre of the current view
grp_transform = 'translate' + str( centre )

grp_name = 'Group Name'
grp_attribs = {inkex.addNS('label','inkscape'):grp_name,
'transform':grp_transform }
grp = inkex.etree.SubElement(self.current_layer, 'g', grp_attribs)#the group to put everything in
</nowiki></pre>

By the way, any object can be assigned a name as we did there, which is often helpful when generating many objects:

<pre><nowiki>
inkex.addNS('label','inkscape') : name
</nowiki></pre>

By setting the transform as <tt>self.view_center</tt>, we made sure the origin of the group is in the centre of the current view of the document. We will come back to transforms later.

The <tt>grp</tt> object can now be used as a parent for the rectangle:
<pre><nowiki>
draw_SVG_square((1,1), (0,0), grp)
</nowiki></pre>
This will draw a 1×1 black square in the center of the view.

==Transforms==

It is easy to transform an object: just supply a string like the folllowing as the <tt>transform</tt> attribute of the element:
*<tt>trans = 'translate(10,10)'</tt>
*<tt>trans = 'translate(10,10) rotate(10)'</tt>
*<tt>trans = 'skewX(-1)'</tt>

Available commands: <tt>translate, scale, rotate, skewX, skewY, matrix</tt>. The transforms are composed in left-right order (i.e. the translate comes first in the second example).

==More Examples==

===Ellipses===

Ellipses are actually path elements, but Inkscape generates the nodes automatically if you feed it the correct attributes in the Sodipodi namespace. The vital ones are <tt>rx, ry, cx, cy</tt>.

Ellipses require some attributes in the <tt>sodipodi:</tt> namespace, so we also use the <tt>addNS()</tt> function in the attribute dictionary:

<pre><nowiki>
def draw_SVG_ellipse((rx, ry), (cx, cy), parent, start_end=0,2*pi),transform='' ):

style = { 'stroke' : '#000000',
'width' : '1',
'fill' : 'none' }
ell_attribs = {'style':simplestyle.formatStyle(style),
inkex.addNS('cx','sodipodi') :str(cx),
inkex.addNS('cy','sodipodi') :str(cy),
inkex.addNS('rx','sodipodi') :str(rx),
inkex.addNS('ry','sodipodi') :str(ry),
inkex.addNS('start','sodipodi') :str(start_end[0]),
inkex.addNS('end','sodipodi') :str(start_end[1]),
inkex.addNS('open','sodipodi') :'true', #all ellipse sectors we will draw are open
inkex.addNS('type','sodipodi') :'arc',
'transform' :transform

}
ell = inkex.etree.SubElement(parent, inkex.addNS('path','svg'), ell_attribs )
</nowiki></pre>

This will draw an open arc, with a black stroke of width 1 and no fill. The transform here can be passed in from outside.

If in doubt about the right attribute name and format, just check a similar object in the XML viewer in Inkscape.

===Line Segment===

Paths can be quite tricky to get the hang of if you don't know the meaning of the letters. Read the SVG specification for a full list.

Here, the style information has been passed in from outside the function.

<pre><nowiki>
#draw an SVG line segment between the given (raw) points
def draw_SVG_line( (x1, y1), (x2, y2), style, name, parent):
line_style = { 'stroke': style.l_col,
'stroke-width':str(style.l_th),
'fill': style.l_fill
}

line_attribs = {'style' : simplestyle.formatStyle(line_style),
inkex.addNS('label','inkscape') : name,
'd' : 'M '+str(x1)+','+str(y1)+' L '+str(x2)+','+str(y2)}

line = inkex.etree.SubElement(parent, inkex.addNS('path','svg'), line_attribs )
</nowiki></pre>

Python modules for extensions

2009-10-20T21:08:28Z

Inductiveload: added section on simpletransform

[[Category:Extensions]]

== inkex.py ==

This module encapsulates the basic behavior of a script extension, allowing the author to concentrate on manipulating the SVG data. The module provides an '''class Effect()'''. inkex.py was originally designed to provide the Effect (filter) extension type, but has been used for Input/Output extensions simply by overriding additional class methods.

=== Methods ===
*effect(): override with document processing code.
*affect(): actuate the script.
*xpathSingle(path): an xpath wrapper to return a single node.
*uniqueId(old_id, make_new_id = True): return an id that is unique in the document given a proposed id.

=== Properties ===

*document: DOM document
*selected: a list of nodes that were selected in inkscape
*doc_ids: all of the ids used in the document
*options: options passed to the script

== simplestyle.py ==
Provides methods for dealing with css data embeded in SVG's style="" atribute

*parseStyle(string): Create a dictionary from the value of an inline style attribute
*formatStyle(dict): Format an inline style attribute from a dictionary
*isColor(c): Determine if its a color we can use. If not, leave it unchanged.
*parseColor(c): Creates a rgb int array
*formatColoria(a): int array to #rrggbb
*formatColorfa(a): float array to #rrggbb
*formatColor3i(r,g,b): 3 ints to #rrggbb
*formatColor3f(r,g,b): 3 floats to #rrggbb

*svgcolors: a dictionary defining legal color names and corresponding color values

== simplepath.py ==
Provides functions to round trip svg path d="" attribute data and a simple path format mimicing that datastructure. additional functions for scaling translating and rotating path data.

== cubicsuperpath.py ==
An alternative path representation. access both handles of a node at once. looses a paths open/closed identity.

== simpletransform.py ==

Provides code to easily transform objects.

*parseTransform
:Takes a string such as <tt>rotate(10)</tt> and produces a transformation matrix. If you also supply an initial matrix, the new one will be composed with the old one.
:Available commands: <tt>translate, scale, rotate, skewX, skewY, matrix</tt>. Other examples:
::matrix = parseTransform('rotate(10)')
::matrix = parseTransform('skewY(10)')
::matrix = parseTransform('translate(10 10)')
::matrix = parseTransform(' rotate(10)')
::matrix = parseTransform('translate(700,210) rotate(-30)')

== pturtle.py ==

Provides turtle graphics primitives with svg path data output

== beziermisc.py ==
Utility functions for working with bezier curves

== cspsubdiv.py ==
Decompose a path into polylines

== ff*.py ==

an obscure set of tools for dealing with musical scales.

SpecCommandLineDrawing/DraftSubmodule

2009-01-21T01:45:13Z

Inductiveload: New page: *Return to SpecCommandLineDrawing This module specifies the method for drawing an SVG object from parameters entered by the "command line". It contains: #A dictionary holding possible...

*Return to [[SpecCommandLineDrawing]]

This module specifies the method for drawing an SVG object from parameters entered by the "command line". It contains:
#A dictionary holding possible parameters (except general style paramters - these are found in the [[SpecCommandLineDrawing/DraftAssDir|global association module]]), along with the type of the parameter and the default value, which will be used if the user doesn't specify. For example, if the user enters <tt>circle r:50</tt>, the circle will be centred at <tt>(0,0)</tt>.
#A function called <tt>draw_SVG()</tt>, which puts the parameters into the correct position in the SVG, and draws it using, in this case, the inkex helper module.
#A function used to perform overrides for redundant parameters. For example, in the circle case, the radius only is used in drawing the circle. However, if the user enters a diameter and not radius, the default radius (100) would be used unless this function sets the radius to the diameter/2.

==Draft Code==
<pre>
#!/usr/bin/env python
'''

######DESCRIPTION######

This script contains routines for drawing circles using command line parameters
formatted by command_line.py

import inkex, simplestyle
import command_line

command_dictionary = { 'circle':{
'r':{'t':'scalar', 'd':100}, #radius if r given, overrides diameter
'd':{'t':'scalar'}, #diameter
'c':{'t':'point' , 'd':(0,0)} #centre uses the inkscape position, if given
}}

def draw_SVG(params, parent):
style = command_line.create_SVG_style_dict(params)

attribs = {'style':simplestyle.formatStyle(style),
'cx': str(params['c'][0]),
'cy': str(params['c'][1]),
'r': str(params['r'])
}
inkex.etree.SubElement(parent, inkex.addNS('circle','svg'), attribs )

def set_defaults(params):

#r overrides d
if 'd' in params and 'r' not in params:
params['r'] = params['d']/2.0

return
</pre>

SpecCommandLineDrawing/DraftAssDir

2009-01-21T01:33:18Z

Inductiveload:

*Return to [[SpecCommandLineDrawing]]

The association directory is a module that contains global information for the command line editing module. This includes:
#A dictionary linking the command header (eg <tt>circle</tt>) with the relevant module containing the parameters and SVG drawing function (i.e. <tt>cl_circle.py</tt>)
#A dictionary containing style attributes that apply to all objects, so these don't need to be specified for each object. (For example, fill colour, stroke width, etc).

==Draft Code==
<code><pre>

#!/usr/bin/env python
'''

######DESCRIPTION######

This script contains a dictionary for matching command headers to the modules
containing the relevant command dictionaries and drawing routines.

If a module is added to the directory, it should be added here along with the
command headers it responds to. In this way, it is easy to add or remove modules
without having to modify the core script.

directory = { 'circle' :'cl_circle',
'rect' :'cl_rect',
'poly' :'cl_poly',
'line' :'cl_line',
'star' :'cl_star'
}

std_style = { #style commands that are applicable to "standard" objects
't': {'t':'scalar', 'xml':'stroke-width', 'd':1}, #line thickness
'f': {'t':'colour', 'xml':'fill', 'd':'none'}, #fill colour
'fo':{'t':'scalar', 'xml':'fill-opacity', 'd':'1'} #stroke opacity
's': {'t':'colour', 'xml':'stroke', 'd':'#000000'}, #stroke colour
'so':{'t':'scalar', 'xml':'stroke-opacity', 'd':'1'} #stroke opacity
}
</pre></code>

SpecCommandLineDrawing/DraftAssDir

2009-01-21T01:32:20Z

Inductiveload: New page: The association directory is a module that contains global information for the command line editing module. This includes: #A dictionary linking the command header (eg <tt>circle</tt>) wit...

The association directory is a module that contains global information for the command line editing module. This includes:
#A dictionary linking the command header (eg <tt>circle</tt>) with the relevant module containing the parameters and SVG drawing function (i.e. <tt>cl_circle.py</tt>)
#A dictionary containing style attributes that apply to all objects, so these don't need to be specified for each object. (For example, fill colour, stroke width, etc).

==Draft Code==
<code><pre>

#!/usr/bin/env python
'''

######DESCRIPTION######

This script contains a dictionary for matching command headers to the modules
containing the relevant command dictionaries and drawing routines.

If a module is added to the directory, it should be added here along with the
command headers it responds to. In this way, it is easy to add or remove modules
without having to modify the core script.

directory = { 'circle' :'cl_circle',
'rect' :'cl_rect',
'poly' :'cl_poly',
'line' :'cl_line',
'star' :'cl_star'
}

std_style = { #style commands that are applicable to "standard" objects
't': {'t':'scalar', 'xml':'stroke-width', 'd':1}, #line thickness
'f': {'t':'colour', 'xml':'fill', 'd':'none'}, #fill colour
'fo':{'t':'scalar', 'xml':'fill-opacity', 'd':'1'} #stroke opacity
's': {'t':'colour', 'xml':'stroke', 'd':'#000000'}, #stroke colour
'so':{'t':'scalar', 'xml':'stroke-opacity', 'd':'1'} #stroke opacity
}
</pre></code>

SpecCommandLineDrawing

2008-10-22T00:52:11Z

Inductiveload: /* Extensibility & Scriptability */

==Outline==

At the moment, Inkscape does not allow users to enter commands to Inkscape in a text-based format. This specification proposed to add that functionality, both at the command line and internally, possibly using a command-line box similar to Rhino's. In this way, a user will be able to directly enter precise instruction to Inkscape with minimal effort. For example, a command such as "circle r:50" could be entered and Inkscape will produce a circle of radius 50px, with all other attributes set to default values. In this way, technical drawing becomes easier, and the interface to Inkscape from external programs is vastly increased.

==UI Changes==

The only UI integration this proposal needs is a command line text box and an "Enter" button. Rhino has an advanced text entry system, using a long text box under the toolbars. Eagle, a piece of electrical CAD software, also has this system.

In Inkscape, I anticipate this being located under the context toolbar, but above the ruler and drawing area. Ideally, a button would be provided on the main toolbar to allow this command entry box to be toggled on or off to save space for those who don't need this feature.

==Functionality Overview==

This proposal would add following functionality:
*Creation of SVG items in Inkscape using just text input. Default options should be supplied so that properties not important to a user can be left out of the command, but still be taken care of.
*Manipulation of existing objects (scaling, duplication, deletion, etc)
*Allow the request of document information by external applications (eg. request document size or the properties of a given object etc)
*Increasing document manipulation by textual means (page size, exporting etc)
*Allow extensions and 3D party applications to have a simple way of editing Inkscape documents. All they would have to do is supply the command string, rather than as they do now, mess around with inkex helper modules, etc.

==Basic Command Structure==

This section is extremely preliminary and is mostly based on a Python mock-up rather than practical reasons. Hopefully, at some point a formal grammar will be established.

More than one command can be entered at once. These are separated by a semicolon. The last command should not need a semicolon.

cmd1; cmd2; cmd3

Each command is made up of a command header and a zero or more of parameters, separated by spaces:

cmd 1
cmd2 param2
cmd3 param31 param32

Each parameter is made up of one or more arguments, separated by colons:

cmd1 p1:arg1
cmd2 p21:arg211 p22:arg221:arg222

If an argument represents an item that needs more than one value (such as coordinates), these are separated by commas:

cmd1 p1:arg11,arg12 p2:arg2

For example, a circle with a radius of 50px and centre (500,400)px could be entered as:
circle r:50 c:500,400

It should also be possible to enter an expression. In this way:
circle r:25/2
should end up as a circle with a radius of 12.5px. This would dramatically reduce the time spend moving data between calculator apps and Inkscape in the case especially of technical drawing.

Different units should be easily used, so that one may easily use Inkscape software for engineering purposes.
circle r:10mm
should be automatically translated into px and render as a circle 10mm across.

==Error Handling==

The parser for these commands should catch errors wherever possible, and be able to give detailed reasons why it failed. This will help third parties develop an understanding of Inkscape's command structure (useful for encourage its use as a technical drawing aid) and allow easy debugging of external code.

For example the entry (say)
circle er:45
should fail with the reason that 'er' is not a known command header.

The same goes for incorrect numbers of arguments or sub-arguments, incorrect units (eg one should not be able to specify 'px' for a colour)

==Documentation==

The Inkscape command structure should have a detailed and thorough explanation on the Inkscape wiki or elsewhere. Ideally, one should be able to summon the help for a function using a command such as

help:circle

Which will link to the relevant online resource.

==Extensibility & Scriptability==

The command structure should be easily extended to new functions and commands. I see two contenders for this system:

<ol>
<li>A global XML-based list of commands and available parameters can be provided to allow quick integration of new functions, as well as providing brief help if needed.

<ul><li>A draft command list is found here: [[SpecCommandLineDrawing/DraftCmdList|Draft Command List]]</li></ul>
<li>
Commands are provided as stand-alone packages in a dedicated sub-directory. Each command file contains its own command dictionary, as well as the routines for generating the SVG elements.

This means that the commands are extremely easy to add, as all that is required is to add a single file to the correct folder. This makes a future automated system for adding new commands very easy to implement, and reduces the possibility that such a system will damage the global file though mistakes made in writing updates.

A short module containing the associations between what you write (eg. <tt>circle</tt>) and the module containing the functions for that command (eg. <tt>cl_circle.py</tt>) would seem to be the best way to allow the central script to keep track of what does and doesn't exist in the directory. I suggest that the functions are loaded dynamically so that only the needed functions are loaded. While this module could be included in the central script, breaking it out reduces the exposure of an inexperienced user to the main code, and reduces the chances of damage.
<ul>
<li>
A sample module is provided [[SpecCommandLineDrawing/DraftSubmodule|here]].
</li>
<li>
A sample association directory is provided [[SpecCommandLineDrawing/DraftAssDir|here]].
</li>
</ul>
</li>
</ol>

Here, accessibility is the name of the game, as we want new capabilities to the command line tool to be easy to produce and implement.

It should also be very easy to script for this command-line system. While I believe making the command line instuctions a scripting language in itself is entirely unnecessary, I think it would be good if Inkscape provided a way to either enter a multiline Python script (as Python is already included with Inkscape) or run one from a remote location which was made with another editor, or ideally both.

In this way, a user can quickly enter a command like:
for i in range(5):
ink(circle r:50*i)

and get 5 circles of increasing radius. If Inkscape had a small window for entering scripts like this, saving them loading them, it would save time and make the interface even more useful. It would allow people with no knowledge of Python (but some programming know-how such as <tt>for</tt>, <tt>if</tt> statements, etc.) to be able to very easily script Inkscape.

This script window should incorporate the code entered there into a standard "container" script, which would deal with loading of the relevant modules (eg. the one containing the <tt>ink()</tt> command in this case). Thus the user is freed from having to know ''why'' the script works, and only needs to know how to use it.

==External Links==

*[http://www.rhino3d.com Rhino3D modeller with command line tool]
*[http://en.wiki.mcneel.com/default.aspx/McNeel/IntroductionToTheRhinoInterface.html An Introduction to the Rhino Interface]
*[http://cadsoft.de Eagle CAD System for electrical design. Includes a command line interface]

SpecCommandLineDrawing

2008-10-20T16:42:36Z

Inductiveload:

==Outline==

At the moment, Inkscape does not allow users to enter commands to Inkscape in a text-based format. This specification proposed to add that functionality, both at the command line and internally, possibly using a command-line box similar to Rhino's. In this way, a user will be able to directly enter precise instruction to Inkscape with minimal effort. For example, a command such as "circle r:50" could be entered and Inkscape will produce a circle of radius 50px, with all other attributes set to default values. In this way, technical drawing becomes easier, and the interface to Inkscape from external programs is vastly increased.

==UI Changes==

The only UI integration this proposal needs is a command line text box and an "Enter" button. Rhino has an advanced text entry system, using a long text box under the toolbars. Eagle, a piece of electrical CAD software, also has this system.

In Inkscape, I anticipate this being located under the context toolbar, but above the ruler and drawing area. Ideally, a button would be provided on the main toolbar to allow this command entry box to be toggled on or off to save space for those who don't need this feature.

==Functionality Overview==

This proposal would add following functionality:
*Creation of SVG items in Inkscape using just text input. Default options should be supplied so that properties not important to a user can be left out of the command, but still be taken care of.
*Manipulation of existing objects (scaling, duplication, deletion, etc)
*Allow the request of document information by external applications (eg. request document size or the properties of a given object etc)
*Increasing document manipulation by textual means (page size, exporting etc)
*Allow extensions and 3D party applications to have a simple way of editing Inkscape documents. All they would have to do is supply the command string, rather than as they do now, mess around with inkex helper modules, etc.

==Basic Command Structure==

This section is extremely preliminary and is mostly based on a Python mock-up rather than practical reasons. Hopefully, at some point a formal grammar will be established.

More than one command can be entered at once. These are separated by a semicolon. The last command should not need a semicolon.

cmd1; cmd2; cmd3

Each command is made up of a command header and a zero or more of parameters, separated by spaces:

cmd 1
cmd2 param2
cmd3 param31 param32

Each parameter is made up of one or more arguments, separated by colons:

cmd1 p1:arg1
cmd2 p21:arg211 p22:arg221:arg222

If an argument represents an item that needs more than one value (such as coordinates), these are separated by commas:

cmd1 p1:arg11,arg12 p2:arg2

For example, a circle with a radius of 50px and centre (500,400)px could be entered as:
circle r:50 c:500,400

It should also be possible to enter an expression. In this way:
circle r:25/2
should end up as a circle with a radius of 12.5px. This would dramatically reduce the time spend moving data between calculator apps and Inkscape in the case especially of technical drawing.

Different units should be easily used, so that one may easily use Inkscape software for engineering purposes.
circle r:10mm
should be automatically translated into px and render as a circle 10mm across.

==Error Handling==

The parser for these commands should catch errors wherever possible, and be able to give detailed reasons why it failed. This will help third parties develop an understanding of Inkscape's command structure (useful for encourage its use as a technical drawing aid) and allow easy debugging of external code.

For example the entry (say)
circle er:45
should fail with the reason that 'er' is not a known command header.

The same goes for incorrect numbers of arguments or sub-arguments, incorrect units (eg one should not be able to specify 'px' for a colour)

==Documentation==

The Inkscape command structure should have a detailed and thorough explanation on the Inkscape wiki or elsewhere. Ideally, one should be able to summon the help for a function using a command such as

help:circle

Which will link to the relevant online resource.

==Extensibility & Scriptability==

The command structure should be easily extended to new functions and commands. I see two contenders for this system:

<ol>
<li>A global XML-based list of commands and available parameters can be provided to allow quick integration of new functions, as well as providing brief help if needed.

A draft command list is found here: [[SpecCommandLineDrawing/DraftCmdList|Draft Command List]]
</li>
<li>
Commands are provided as stand-alone packages in a dedicated sub-directory. Each command file contains its own command dictionary, as well as the routines for generating the SVG elements.

This means that the commands are extremely easy to add, as all that is required is to add a single file to the correct folder. This makes a future automated system for adding new commands very easy to implement, and reduces the possibility that such a system will damage the global file though mistakes made in writing updates.
</li>
</ol>

Here, accessibility is the name of the game, as we want new capabilities to the command line tool to be easy to produce and implement.

It should also be very easy to script for this command-line system. While I believe making the command line instuctions a scripting language in itself is entirely unnecessary, I think it would be good if Inkscape provided a way to either enter a multiline Python script (as Python is already included with Inkscape) or run one from a remote location which was made with another editor, or ideally both.

In this way, a user can quickly enter a command like:
for i in range(5):
ink(circle r:50*i)

and get 5 circles of increasing radius. If Inkscape had a small window for entering scripts like this, saving them loading them, it would save time and make the interface even more useful. It would allow people with no knowledge of Python (but some programming know-how such as <tt>for</tt>, <tt>if</tt> statements, etc.) to be able to very easily script Inkscape.

This script window should incorporate the code entered there into a standard "container" script, which would deal with loading of the relevant modules (eg. the one containing the <tt>ink()</tt> command in this case). Thus the user is freed from having to know ''why'' the script works, and only needs to know how to use it.

==External Links==

*[http://www.rhino3d.com Rhino3D modeller with command line tool]
*[http://en.wiki.mcneel.com/default.aspx/McNeel/IntroductionToTheRhinoInterface.html An Introduction to the Rhino Interface]
*[http://cadsoft.de Eagle CAD System for electrical design. Includes a command line interface]

SpecCommandLineDrawing

2008-10-11T04:07:37Z

Inductiveload: /* Extensibility & Scriptability */

==Outline==

At the moment, Inkscape does not allow users to enter commands to Inkscape in a text-based format. This specification proposed to add that functionality, both at the command line and internally, possibly using a command-line box similar to Rhino's. In this way, a user will be able to directly enter precise instruction to Inkscape with minimal effort. For example, a command such as "circle r:50" could be entered and Inkscape will produce a circle of radius 50px, with all other attributes set to default values. In this way, technical drawing becomes easier, and the interface to Inkscape from external programs is vastly increased.

==UI Changes==

The only UI integration this proposal needs is a command line text box and an "Enter" button. Rhino has an advanced text entry system, using a long text box under the toolbars. Eagle, a piece of CAD software also has this system.

In Inkscape, I anticipate this being located under the context toolbar, but above the ruler and drawing area. Ideally, a button would be provided on the main toolbar to allow this command entry box to be toggled on or off to save space for those who don't need this feature.

==Functionality Overview==

This proposal would add following functionality:
*Creation of SVG items in Inkscape using just text input. Default options should be supplied so that properties not important to a user can be left out of the command, but still be taken care of.
*Manipulation of existing objects (scaling, duplication, deletion, etc)
*Allow the request of document information by external applications (eg. request document size or the properties of a given object etc)
*Increasing document manipulation by textual means (page size, exporting etc)
*Allow extensions and 3D party applications to have a simple way of editing Inkscape documents. All they would have to do is supply the command string, rather than as they do now, mess around with inkex helper modules, etc.

==Basic Command Structure==

This section is extremely preliminary and is mostly based on a Python mock-up rather than practical reasons. Hopefully, at some point a formal grammar will be established.

More than one command can be entered at once. These are separated by a semicolon. The last command should not need a semicolon.

cmd1; cmd2; cmd3

Each command is made up of a command header and a zero or more of parameters, separated by spaces:

cmd 1
cmd2 param2
cmd3 param31 param32

Each parameter is made up of one or more arguments, separated by colons:

cmd1 p1:arg1
cmd2 p21:arg211 p22:arg221:arg222

If an argument represents an item that needs more than one value (such as coordinates), these are separated by commas:

cmd1 p1:arg11,arg12 p2:arg2

For example, a circle with a radius of 50px and centre (500,400)px could be entered as:
circle r:50 c:500,400

It should also be possible to enter an expression. In this way:
circle r:25/2
should end up as a circle with a radius of 12.5px. This would dramatically reduce the time spend moving data between calculator apps and Inkscape in the case especially of technical drawing.

Different units should be easily used, so that one may easily use Inkscape software for engineering purposes.
circle r:10mm
should be automatically translated into px and render as a circle 10mm across.

==Error Handling==

The parser for these commands should catch errors wherever possible, and be able to give detailed reasons why it failed. This will help third parties develop an understanding of Inkscape's command structure (useful for encourage its use as a technical drawing aid) and allow easy debugging of external code.

For example the entry (say)
circle er:45
should fail with the reason that 'er' is not a known command header.

The same goes for incorrect numbers of arguments or sub-arguments, incorrect units (eg one should not be able to specify 'px' for a colour)

==Documentation==

The Inkscape command structure should have a detailed and thorough explanation on the Inkscape wiki or elsewhere. Ideally, one should be able to summon the help for a function using a command such as

help:circle

Which will link to the relevant online resource.

==Extensibility & Scriptability==

The command structure should be easily extended to new functions and commands. Perhaps an XML-based list of commands and available parameters can be provided to allow quick integration of new functions, as well as providing brief help if needed.

*A draft command list is found here: [[SpecCommandLineDrawing/DraftCmdList|Draft Command List]]

Here, accessibility is the name of the game, as we want new capabilities to the command line tool to be easy to produce and implement.

It should also be very easy to script for this command-line system. While I believe making the command line instuctions a scripting language in itself is entirely unnecessary, I think it would be good if Inkscape provided a way to either enter a multiline Python script (as Python is already included with Inkscape) or run one from a remote location which was made with another editor, or ideally both.

In this way, a user can quickly enter a command like:
for i in range(5):
ink(circle r:50*i)

and get 5 circles of increasing radius. If Inkscape had a small window for entering scripts like this and loading them, it would save time and make the interface even more useful.

SpecCommandLineDrawing/DraftCmdList

2008-10-11T04:05:09Z

Inductiveload:

*Return to [[SpecCommandLineDrawing]]

This is a proposed format for an XML-based list of available commands and parameters.

<tt><pre>


<command_directory>


<type-list>
<type>
<name>number</name>
<desc>A single number</desc>
</type>
<type>
<name>point</name>
<desc>A pair of numbers specifying a point</desc>
</type>
</type-list>


<command-list>
<cmd name="circle" desc="Draws a circle.">
<parameter>
<name>r</name>
<desc>Radius of the circle.</desc>
<type>number</type>
<default>200</default>
</parameter>
<parameter>
<name>c</name>
<desc>Centre of the circle.</desc>
<type>point</type>
<default>0,0</default>
</parameter>
</cmd>
<cmd name="rect" desc="Draws a rectangle.">
<parameter>
<name>w</name>
<desc>Width of the rectangle.</desc>
<type>number</type>
<default>100</default>
</parameter>
<parameter>
<name>h</name>
<desc>Height of the rectangle.</desc>
<type>point</type>
<default>100</default>
</parameter>
</cmd>
</command-list>

</command_directory>
</pre></tt>

*Return to [[SpecCommandLineDrawing]]

SpecCommandLineDrawing/DraftCmdList

2008-10-11T04:04:26Z

Inductiveload: New page: This is a proposed format for an XML-based list of available commands and parameters. <tt><pre>  <command_directory> ...

This is a proposed format for an XML-based list of available commands and parameters.

<tt><pre>


<command_directory>


<type-list>
<type>
<name>number</name>
<desc>A single number</desc>
</type>
<type>
<name>point</name>
<desc>A pair of numbers specifying a point</desc>
</type>
</type-list>


<command-list>
<cmd name="circle" desc="Draws a circle.">
<parameter>
<name>r</name>
<desc>Radius of the circle.</desc>
<type>number</type>
<default>200</default>
</parameter>
<parameter>
<name>c</name>
<desc>Centre of the circle.</desc>
<type>point</type>
<default>0,0</default>
</parameter>
</cmd>
<cmd name="rect" desc="Draws a rectangle.">
<parameter>
<name>w</name>
<desc>Width of the rectangle.</desc>
<type>number</type>
<default>100</default>
</parameter>
<parameter>
<name>h</name>
<desc>Height of the rectangle.</desc>
<type>point</type>
<default>100</default>
</parameter>
</cmd>
</command-list>

</command_directory>
</pre></tt>

SpecCommandLineDrawing

2008-10-09T17:04:30Z

Inductiveload:

SpecCommandLineDrawing

2008-10-08T07:11:54Z

Inductiveload:

SpecCommandLineDrawing

2008-10-08T05:52:25Z

Inductiveload: New page: ==Outline== At the moment, Inkscape does not allow users to enter commands to Inkscape in a text-based format. This specification proposed to add that functionality, both at the command l...

Tips For Python Script Extensions

2008-10-07T18:07:10Z

Inductiveload: Brief summary of the gettext translation method

==Adding Translation Capability==

One can add the ability to have Python text mesages included for translation. To provide an error message, rather than using the Python <tt>sys.stderr</tt>, use the provided <tt>errormsg()</tt> function from inkex.py in conjuction with <tt>gettext</tt>.

You must include the following at the beginning of your Python script:
import inkex
import gettext
_ = gettext.gettext

Where you wish to have an error message, write the following:
inkex.errormsg(_("This will be written to Python stderr"))

Of course, you may also change "_" to something else if you wish.

[[Category:Extensions]]

SpecPathIntersectionCutter

2008-03-17T02:49:23Z

Inductiveload: New page: Launchpad Entry: https://blueprints.launchpad.net/inkscape/+spec/path-intersection-cutter == Summary == This tool will take two paths, and add nodes to the underlying path wherever it cro...

Launchpad Entry:
https://blueprints.launchpad.net/inkscape/+spec/path-intersection-cutter

== Summary ==
This tool will take two paths, and add nodes to the underlying path wherever it crosses the overlying path.

== Release Note ==

== Rationale ==
This tool would be very useful for splitting up drawings and finding centres of regular and irregular geometric objects. This would have applications in technical, mathemtical and artistic drawings.

== Design ==
=== User Interface ===
In terms of implementation, the intersection tool should be implemented alongside current path tools such as "union", but does not require that the path be closed.

With two paths selected, the intersection tool is clicked and a context toolbar appears. Temporary nodes are added to the bott.om-most path at the points of intersection with the overlying path, which can be designated by, perhaps, a circle rather than a diamond/square.

The user then selects the nodes that are wanted, and clicks "Apply" on the toolbar. There should also be a "Select All" button for selecting nodes at every intersection, and a "Select None" for deselecting all nodes.

The illustration below shows the steps involved in finding the intersections of two paths. In this example, the red path is under the blue path, and therefore nodes will be added to the red path. To use the tool, the user selects both curves, but this is not shown.

[[Image:PathIntersection.png]]

All shapes must be converted to paths before finding the intersections can occur.

=== More ideas ===
See [http://www.oberonplace.com/products/curveworks/index.htm]. This is a more refined version of the Cut Curve Tool there (as here you can select the points to cut rather than all of them).

== TODO ==

== Discussion ==

File:PathIntersection.png

2008-03-17T02:45:22Z

Inductiveload: A diagram of how the Path Intersection Cutter Tool should work. SpecPathIntersection

A diagram of how the Path Intersection Cutter Tool should work.

[[SpecPathIntersection]]