Python modules for extensions - Revision history

Pulsar17: Use better language

2022-03-10T22:06:59Z

Use better language

← Older revision		Revision as of 22:06, 10 March 2022
Line 1:		Line 1:
	[[Category:Extensions]]		[[Category:Extensions]]

	~~The~~ API documentation for inkex ~~has been moved to~~ the [https://inkscape.gitlab.io/extensions/documentation/source/index.html documentation of the extensions repository.]		This page contained API documentation for various modules in inkex. A more complete API documentation is available in the [https://inkscape.gitlab.io/extensions/documentation/source/index.html documentation of the extensions repository.]

Pulsar17: Move documentation.

2022-03-10T20:58:23Z

Move documentation.

Show changes

Cabalist: update macOS path

2019-03-13T20:12:59Z

update macOS path

← Older revision		Revision as of 20:12, 13 March 2019
Line 1:		Line 1:
	[[Category:Extensions]]		[[Category:Extensions]]

	These modules are provided as part of Inkscape and can be found in /usr/share/inkscape/extensions on GNU/Linux, ... on Windows, and ... on ~~Mac OS X~~ along with the extensions bundled with Inkscape. They can be <code>import</code>ed from an extension just like any other python module.		These modules are provided as part of Inkscape and can be found in /usr/share/inkscape/extensions on GNU/Linux, ... on Windows, and /Applications/Inkscape.app/Contents/Resources/share/inkscape/extensions/ on macOS along with the extensions bundled with Inkscape. They can be <code>import</code>ed from an extension just like any other python module.

	== inkex.py ==		== inkex.py ==

Moini: ... fix missing apostrophe in correct version - sorry!

2017-11-05T00:40:05Z

... fix missing apostrophe in correct version - sorry!

← Older revision		Revision as of 00:40, 5 November 2017
Line 90:		Line 90:

	== cubicsuperpath.py ==		== cubicsuperpath.py ==
	An alternative path representation, accessing both handles of a node at once. Loses a ~~paths~~ open/closed identity.		An alternative path representation, accessing both handles of a node at once. Loses a path's open/closed identity.

	;<code>CubicSuperPath( simplepath )</code>		;<code>CubicSuperPath( simplepath )</code>

Moini: Reverted edits by Moini (talk) to last revision by Matyilona

2017-11-05T00:38:43Z

Reverted edits by Moini (talk) to last revision by Matyilona

← Older revision		Revision as of 00:38, 5 November 2017
Line 90:		Line 90:

	== cubicsuperpath.py ==		== cubicsuperpath.py ==
	An alternative path representation, accessing both handles of a node at once. Loses a ~~path's~~ open/closed identity.		An alternative path representation, accessing both handles of a node at once. Loses a paths open/closed identity.

	;<code>CubicSuperPath( simplepath )</code>		;<code>CubicSuperPath( simplepath )</code>
	: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>).		: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ], ... ], [ [ h1_m, pt_m, h2_m ], ...], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>). The list is the representation of the whole path, the first level sub-lists are representations of sub-paths, and the lists containing 3 points represent the individual control nodes.

	;<code>unCubicSuperPath( csp )</code>		;<code>unCubicSuperPath( csp )</code>
Line 106:		Line 106:
	== simpletransform.py ==		== simpletransform.py ==

	Provides code to easily transform objects.		Provides code to easily transform objects. Transformations are represented as [https://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations affine transformation matrices]. Since the last row of such matrices is always the same ([0,0,1]) it is not included, so the final matrix is a list of two lists of 3 floats containing the first two rows of the matrix. Wherever <code>E</code> is used as a default argument it means the identity matrix, a transformation that does nothing.

	*parseTransform		;<code>parseTransform( transform, mat=E )</code>
	: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~~.		: Takes a string representing a transformation (like a SVG nodes transform attribute), and returns a transformation matrix. If <code>mat</code> is supplied, the returned matrix is <code>composeTransform( mat, matrix)</code>.
	:~~Available commands:~~ <tt>~~translate~~, ~~scale~~, ~~rotate~~, ~~skewX~~, ~~skewY~~, ~~matrix~~</tt>. ~~Other examples:~~
	:~~:matrix = parseTransform(~~'~~rotate~~(10)')		;<code>formatTransform( mat )</code>
	::~~matrix~~ = ~~parseTransform('skewY(10)'~~)		: Returns string representation for transform (for use in transform attribute).
	:~~:matrix~~ = ~~parseTransform('translate(10 10)'~~)
	:~~:matrix = parseTransform~~(~~' rotate~~(10)')		;<code>invertTransform( mat )</code>
	~~::matrix = parseTransform~~(~~'translate~~(~~700~~,~~210~~) ~~rotate~~(-30)')		: Returns inverse of transformation given by <code>mat</code>.

			;<code>composeTransform( mat1, mat2 )</code>
			: Returns matrix representing a transformation equal to applying <code>mat1</code> then <code>mat2</code>.

			;<code>composeParents( node, mat )</code>
			: Returns <code>mat</code> composed with every transformation that applies to <code>node</code>. If a node has a transformation applied to it, and is part of a group that has an other transformation applied to it, both apply to the node. This function composes all the nodes ancestors' transformations.

			;<code>applyTransformToNode( mat, node )</code>
			: Apply transform to <code>node</code> by setting its transform attribute, does not change coordinates in any part of node.

			;<code>applyTransformToPath( mat, path )</code>
			: Apply transform to path, by changing the coordinates of points and handles. <code>path</code> has to be a representation used by <code>SuperCubicPath</code>.

			;<code>applyTransformToPoint( mat, point )</code>
			: Apply transform to a point given as a list <code>[ x, y ]</code>.

			;<code>fuseTransform( node )</code>
			: Removes the transform attribute from a node, and applies it to the node, changing the nodes points' coordinates.

			The following functions might be broken out into a separate module in the future (see comment in code).

			;<code>roughBBox( path )</code>
			: Returns four floats <code>xmin, xMax, ymin, yMax</code>, the coordinates for a rough bounding box. <code>path</code> has to be a representation used by <code>SuperCubicPath</code>.

			;<code>refinedBBox( path )</code>
			: Same as the above, takes longer to calculate but more precise.

			;<code>computeBBox( node_list, mat = E )</code>
			: Returns the bounding box for a list of nodes. If supplied <code>mat</code> is applied to the nodes before calculating the bounding box. Uses <code>refinedBBox</code> when applicable, text nodes are not yet supported.

			;<code>computePointInNode( pt, node, mat = E )</code>
			: Given a point and a node, returns the coordinates that when transformed by the nodes and its ancestors transformations are the same as <code>pt</code>. For example take a circle created with its centre at (0,0) and then transformed by applying a pure translation to (1,0). If the centre is now set to (0,1) the centre of the circle will actually be at (1,1) because the transformation still applies. It can be avoided by using <code>computePointInNode( [ 0, 1 ], circle )</code> which gives (-1,1), setting the centre to this the circle will appear at the desired (0,1).

	== pturtle.py ==		== pturtle.py ==

Moini at 00:20, 5 November 2017

2017-11-05T00:20:55Z

← Older revision		Revision as of 00:20, 5 November 2017
Line 90:		Line 90:

	== cubicsuperpath.py ==		== cubicsuperpath.py ==
	An alternative path representation, accessing both handles of a node at once. Loses a ~~paths~~ open/closed identity.		An alternative path representation, accessing both handles of a node at once. Loses a path's open/closed identity.

	;<code>CubicSuperPath( simplepath )</code>		;<code>CubicSuperPath( simplepath )</code>
	: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ~~], ... ], [ [ h1_m, pt_m, h2_m ], ...~~], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>)~~. The list is the representation of the whole path, the first level sub-lists are representations of sub-paths, and the lists containing 3 points represent the individual control nodes~~.		: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>).

	;<code>unCubicSuperPath( csp )</code>		;<code>unCubicSuperPath( csp )</code>
Line 106:		Line 106:
	== simpletransform.py ==		== simpletransform.py ==

	Provides code to easily transform objects. Transformations are represented as [https://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations affine transformation matrices]. Since the last row of such matrices is always the same ([0,0,1]) it is not included, so the final matrix is a list of two lists of 3 floats containing the first two rows of the matrix. Wherever <code>E</code> is used as a default argument it means the identity matrix, a transformation that does nothing.		Provides code to easily transform objects.

	~~;<code>~~parseTransform~~( transform, mat=E )</code>~~		*parseTransform
	: Takes a string ~~representing a transformation (like a SVG nodes transform attribute), and returns a transformation matrix. If~~ <~~code~~>~~mat</code> is supplied, the returned matrix is <code>composeTransform~~( ~~mat, matrix~~)</~~code~~>.		: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:
	~~;<code>formatTransform( mat )</code>~~		::matrix = parseTransform('rotate(10)')
	~~: Returns string representation for transform (for use in transform attribute).~~		::matrix = parseTransform('skewY(10)')
			::matrix = parseTransform('translate(10 10)')
	~~;<code>invertTransform( mat )</code>~~		::matrix = parseTransform(' rotate(10)')
	~~: Returns inverse of~~ transformation ~~given by <code>mat</code>.~~		::matrix = parseTransform('translate(700,210) rotate(-30)')

	~~;<code>composeTransform( mat1, mat2 )</code>~~
	~~: Returns~~ matrix ~~representing a transformation equal to applying <code>mat1</code> then <code>mat2</code>.~~

	~~;<code>composeParents( node, mat )</code>~~
	~~: Returns <code>mat</code> composed with every transformation that applies to <code>node</code>~~. If ~~a node has a transformation applied to it, and is part of a group that has~~ an ~~other transformation applied to it~~, ~~both apply to~~ the ~~node. This function composes all~~ the ~~nodes ancestors' transformations~~.

	~~;<code>applyTransformToNode( mat, node )</code>~~
	: ~~Apply transform to <code>node~~<~~/code~~> ~~by setting its transform attribute~~, ~~does not change coordinates in any part of node.~~

	~~;<code>applyTransformToPath( mat~~, ~~path )</code>~~
	~~: Apply transform to path~~, ~~by changing the coordinates of points and handles. <code>path</code> has to be a representation used by <code>SuperCubicPath</code>.~~

	~~;<code>applyTransformToPoint( mat~~, ~~point )</code>~~
	~~: Apply transform to a point given as a list <code>[ x~~, ~~y ]~~</~~code~~>.

	~~;<code>fuseTransform~~( ~~node~~ )~~</code>~~
	: ~~Removes the transform attribute from a node, and applies it to the node, changing the nodes points~~' ~~coordinates.~~

	~~The following functions might be broken out into a separate module in the future~~ (~~see comment in code~~).

	~~;<code>roughBBox( path~~ )~~</code>~~
	: ~~Returns four floats <code>xmin, xMax, ymin, yMax</code>, the coordinates for a rough bounding box. <code>path</code> has to be a representation used by <code>SuperCubicPath</code>.~~

	~~;<code>refinedBBox~~( ~~path~~ )~~</code>~~
	: ~~Same as the above, takes longer to calculate but more precise.~~

	~~;<code>computeBBox( node_list, mat = E )</code>~~
	: Returns the bounding box for a list of nodes. If supplied <code>mat</code> is applied to the nodes before calculating the bounding box. Uses <code>refinedBBox</code> when applicable, text nodes are not yet supported.

	~~;<code>computePointInNode( pt, node, mat~~ = ~~E )</code>~~
	: Given a point and a node, returns the coordinates that when transformed by the nodes and its ancestors transformations are the same as <code>pt</code>. For example take a circle created with its centre at (~~0,0) and then transformed by applying a pure translation to~~ (~~1,0~~)~~. If the centre is now set to (0,1~~) ~~the centre of the circle will actually be at~~ (~~1,1) because the transformation still applies. It can be avoided by using <code>computePointInNode~~( ~~[ 0~~, ~~1 ], circle~~ )~~</code> which gives~~ (-~~1,1~~)~~, setting the centre to this the circle will appear at the desired (0,1~~).

	== pturtle.py ==		== pturtle.py ==

Matyilona: /* simpletransform.py */ Detailed description for simpletransform

2017-11-04T21:55:35Z

simpletransform.py: Detailed description for simpletransform

← Older revision		Revision as of 21:55, 4 November 2017
Line 106:		Line 106:
	== simpletransform.py ==		== simpletransform.py ==

	Provides code to easily transform objects. Transformations are represented as [https://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations affine transformation matrices]. Since the last row of such matrices is always the same ([0,0,1]) it is not included, so the final matrix is a list of two lists of 3 floats containing the first two rows of the matrix.		Provides code to easily transform objects. Transformations are represented as [https://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations affine transformation matrices]. Since the last row of such matrices is always the same ([0,0,1]) it is not included, so the final matrix is a list of two lists of 3 floats containing the first two rows of the matrix. Wherever <code>E</code> is used as a default argument it means the identity matrix, a transformation that does nothing.

	*parseTransform		;<code>parseTransform( transform, mat=E )</code>
	: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~~.		: Takes a string representing a transformation (like a SVG nodes transform attribute), and returns a transformation matrix. If <code>mat</code> is supplied, the returned matrix is <code>composeTransform( mat, matrix)</code>.
	:~~Available commands:~~ <tt>~~translate~~, ~~scale~~, ~~rotate~~, ~~skewX~~, ~~skewY~~, ~~matrix~~</tt>. ~~Other examples:~~
	:~~:matrix = parseTransform(~~'~~rotate~~(10)')		;<code>formatTransform( mat )</code>
	::~~matrix~~ = ~~parseTransform('skewY(10)'~~)		: Returns string representation for transform (for use in transform attribute).
	:~~:matrix~~ = ~~parseTransform('translate(10 10)'~~)
	:~~:matrix = parseTransform~~(~~' rotate~~(10)')		;<code>invertTransform( mat )</code>
	~~::matrix = parseTransform~~(~~'translate~~(~~700~~,~~210~~) ~~rotate~~(-30)')		: Returns inverse of transformation given by <code>mat</code>.

			;<code>composeTransform( mat1, mat2 )</code>
			: Returns matrix representing a transformation equal to applying <code>mat1</code> then <code>mat2</code>.

			;<code>composeParents( node, mat )</code>
			: Returns <code>mat</code> composed with every transformation that applies to <code>node</code>. If a node has a transformation applied to it, and is part of a group that has an other transformation applied to it, both apply to the node. This function composes all the nodes ancestors' transformations.

			;<code>applyTransformToNode( mat, node )</code>
			: Apply transform to <code>node</code> by setting its transform attribute, does not change coordinates in any part of node.

			;<code>applyTransformToPath( mat, path )</code>
			: Apply transform to path, by changing the coordinates of points and handles. <code>path</code> has to be a representation used by <code>SuperCubicPath</code>.

			;<code>applyTransformToPoint( mat, point )</code>
			: Apply transform to a point given as a list <code>[ x, y ]</code>.

			;<code>fuseTransform( node )</code>
			: Removes the transform attribute from a node, and applies it to the node, changing the nodes points' coordinates.

			The following functions might be broken out into a separate module in the future (see comment in code).

			;<code>roughBBox( path )</code>
			: Returns four floats <code>xmin, xMax, ymin, yMax</code>, the coordinates for a rough bounding box. <code>path</code> has to be a representation used by <code>SuperCubicPath</code>.

			;<code>refinedBBox( path )</code>
			: Same as the above, takes longer to calculate but more precise.

			;<code>computeBBox( node_list, mat = E )</code>
			: Returns the bounding box for a list of nodes. If supplied <code>mat</code> is applied to the nodes before calculating the bounding box. Uses <code>refinedBBox</code> when applicable, text nodes are not yet supported.

			;<code>computePointInNode( pt, node, mat = E )</code>
			: Given a point and a node, returns the coordinates that when transformed by the nodes and its ancestors transformations are the same as <code>pt</code>. For example take a circle created with its centre at (0,0) and then transformed by applying a pure translation to (1,0). If the centre is now set to (0,1) the centre of the circle will actually be at (1,1) because the transformation still applies. It can be avoided by using <code>computePointInNode( [ 0, 1 ], circle )</code> which gives (-1,1), setting the centre to this the circle will appear at the desired (0,1).

	== pturtle.py ==		== pturtle.py ==

Matyilona: /* cubicsuperpath.py */ typo

2017-11-04T19:20:00Z

cubicsuperpath.py: typo

← Older revision		Revision as of 19:20, 4 November 2017
Line 93:		Line 93:

	;<code>CubicSuperPath( simplepath )</code>		;<code>CubicSuperPath( simplepath )</code>
	: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ], ... ], [ [ h1_m, pt_m, h2_m ], ...], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>). The list is the representation of the whole path, the first level sub-lists are representations of sub-paths, and the ~~list~~ containing 3 points represent the individual control nodes.		: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ], ... ], [ [ h1_m, pt_m, h2_m ], ...], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>). The list is the representation of the whole path, the first level sub-lists are representations of sub-paths, and the lists containing 3 points represent the individual control nodes.

	;<code>unCubicSuperPath( csp )</code>		;<code>unCubicSuperPath( csp )</code>

Matyilona: /* cubicsuperpath.py */

2017-11-04T19:18:35Z

cubicsuperpath.py

← Older revision		Revision as of 19:18, 4 November 2017
Line 93:		Line 93:

	;<code>CubicSuperPath( simplepath )</code>		;<code>CubicSuperPath( simplepath )</code>
	: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>).		: Given a path as a list returned by <code>simplepath.parsePath</code>, it returns a list of lists in <code>[ [ [ h1_0, pt_0, h2_0 ], [ h1_1, pt_1, h2_1 ], ... ], [ [ h1_m, pt_m, h2_m ], ...], ... ]</code> format, where <code>h1_n</code> and <code>h2_n</code> are handles for the node at point <code>pt_n</code>. All points/handles are lists of two floats (<code>[ x, y ]</code>). The list is the representation of the whole path, the first level sub-lists are representations of sub-paths, and the list containing 3 points represent the individual control nodes.

	;<code>unCubicSuperPath( csp )</code>		;<code>unCubicSuperPath( csp )</code>

Matyilona: /* simpletransform.py */

2017-11-04T19:13:43Z

simpletransform.py

← Older revision		Revision as of 19:13, 4 November 2017
Line 106:		Line 106:
	== simpletransform.py ==		== simpletransform.py ==

	Provides code to easily transform objects.		Provides code to easily transform objects. Transformations are represented as [https://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations affine transformation matrices]. Since the last row of such matrices is always the same ([0,0,1]) it is not included, so the final matrix is a list of two lists of 3 floats containing the first two rows of the matrix.

	*parseTransform		*parseTransform