https://wiki.inkscape.org/wiki/api.php?action=feedcontributions&user=Justin.Wikinator&feedformat=atomInkscape Wiki - User contributions [en]2020-02-21T13:16:08ZUser contributionsMediaWiki 1.33.1https://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=12446ImprovingPythonEffectsAPI2007-01-11T15:21:49Z<p>Justin.Wikinator: /* Introduction */</p>
<hr />
<div>''* Although this proposal has not been accepted amongst the Summer of Code applicants, my efforts in home-brew graphics scripting continue, and may one day see the light of day *''<br />
<br />
==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon). Keep in mind that this gallery is only the tip of the iceberg when it comes to the functionality of the libraries.<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision).<br />
<br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation (only "proper" poygon stars) (see this page: http://mathworld.wolfram.com/StarPolygon.html on Stars Polygons) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
==Timeline==<br />
<br />
This timeline has been written with a estimation-time-doubling heuristic in mind: <br />
* 2 weeks - make all design decisions, working with mentor to prevent overlap and ensure proper integration. Questions to answer:<br />
** What is the full list of features to be implemented over the summer ? What is the priority of each feature ?<br />
** How will Python access a DOM ? Should the DOM be abstracted into a Document object that is passed/instantiated in each effect ?<br />
** Will the project incorporate live scripting from a command line ? If so, how can the archetecture be designed to meet those needs ? <br />
** Should external geometry functions be used, or should all geometric operations be natively implemented?<br />
** Should the .inx specification remain the same ?<br />
** How will changes to the API affect existing effects ?<br />
* 2 weeks - make existing code that will be encorporated into the API more robust by using PyUnit test cases for QA and improve documentation, possibly using Doxygen for documentation generation<br />
* 2 weeks - integrate existing libraries into the Inkscape API<br />
* 4 weeks - develop effects using the API<br />
* 2 weeks - play with the API ! Write example scripts to generate art to be posted to various web sites (i.e. openclipart.org, deviantart), w/ advertisements for the new Inkscape features attached to them.<br />
<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6517ImprovingPythonEffectsAPI2006-05-24T23:50:46Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon). Keep in mind that this gallery is only the tip of the iceberg when it comes to the functionality of the libraries.<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision).<br />
<br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation (only "proper" poygon stars) (see this page: http://mathworld.wolfram.com/StarPolygon.html on Stars Polygons) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
==Timeline==<br />
<br />
This timeline has been written with a estimation-time-doubling heuristic in mind: <br />
* 2 weeks - make all design decisions, working with mentor to prevent overlap and ensure proper integration. Questions to answer:<br />
** What is the full list of features to be implemented over the summer ? What is the priority of each feature ?<br />
** How will Python access a DOM ? Should the DOM be abstracted into a Document object that is passed/instantiated in each effect ?<br />
** Will the project incorporate live scripting from a command line ? If so, how can the archetecture be designed to meet those needs ? <br />
** Should external geometry functions be used, or should all geometric operations be natively implemented?<br />
** Should the .inx specification remain the same ?<br />
** How will changes to the API affect existing effects ?<br />
* 2 weeks - make existing code that will be encorporated into the API more robust by using PyUnit test cases for QA and improve documentation, possibly using Doxygen for documentation generation<br />
* 2 weeks - integrate existing libraries into the Inkscape API<br />
* 4 weeks - develop effects using the API<br />
* 2 weeks - play with the API ! Write example scripts to generate art to be posted to various web sites (i.e. openclipart.org, deviantart), w/ advertisements for the new Inkscape features attached to them.<br />
<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6515ImprovingPythonEffectsAPI2006-05-24T23:16:06Z<p>Justin.Wikinator: /* AutoShapes extensions */</p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision).<br />
<br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation (only "proper" poygon stars) (see this page: http://mathworld.wolfram.com/StarPolygon.html on Stars Polygons) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon). Keep in mind that this gallery is only the tip of the iceberg when it comes to the functionality of the libraries.<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
==Timeline==<br />
<br />
This timeline has been written with a estimation-time-doubling heuristic in mind: <br />
* 2 weeks - make all design decisions, working with mentor to prevent overlap and ensure proper integration. Questions to answer:<br />
** What is the full list of features to be implemented over the summer ? What is the priority of each feature ?<br />
** How will Python access a DOM ? Should the DOM be abstracted into a Document object that is passed/instantiated in each effect ?<br />
** Will the project incorporate live scripting from a command line ? If so, how can the archetecture be designed to meet those needs ? <br />
** Should external geometry functions be used, or should all geometric operations be natively implemented?<br />
** Should the .inx specification remain the same ?<br />
** How will changes to the API affect existing effects ?<br />
* 2 weeks - make existing code that will be encorporated into the API more robust by using PyUnit test cases for QA and improve documentation, possibly using Doxygen for documentation generation<br />
* 2 weeks - integrate existing libraries into the Inkscape API<br />
* 4 weeks - develop effects using the API<br />
* 2 weeks - play with the API ! Write example scripts to generate art to be posted to various web sites (i.e. openclipart.org, deviantart), w/ advertisements for the new Inkscape features attached to them.<br />
<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6482ImprovingPythonEffectsAPI2006-05-20T15:35:52Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision).<br />
<br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation (only "proper" poygon stars) (see this page: http://mathworld.wolfram.com/StarPolygon.html on Stars Polygons) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
==Timeline==<br />
<br />
This timeline has been written with a estimation-time-doubling heuristic in mind: <br />
* 2 weeks - make all design decisions, working with mentor to prevent overlap and ensure proper integration. Questions to answer:<br />
** What is the full list of features to be implemented over the summer ? What is the priority of each feature ?<br />
** How will Python access a DOM ? Should the DOM be abstracted into a Document object that is passed/instantiated in each effect ?<br />
** Will the project incorporate live scripting from a command line ? If so, how can the archetecture be designed to meet those needs ? <br />
** Should external geometry functions be used, or should all geometric operations be natively implemented?<br />
** Should the .inx specification remain the same ?<br />
** How will changes to the API affect existing effects ?<br />
* 2 weeks - make existing code that will be encorporated into the API more robust by using PyUnit test cases for QA and improve documentation, possibly using Doxygen for documentation generation<br />
* 2 weeks - integrate existing libraries into the Inkscape API<br />
* 4 weeks - develop effects using the API<br />
* 2 weeks - play with the API ! Write example scripts to generate art to be posted to various web sites (i.e. openclipart.org, deviantart), w/ advertisements for the new Inkscape features attached to them.<br />
<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=Extension_reference&diff=6452Extension reference2006-05-15T14:58:28Z<p>Justin.Wikinator: </p>
<hr />
<div>''A page with info about the Effects and particularly some png's / screenshots. To learn more about effects and how to write new ones, check out this page : [http://www.ekips.org/comp/inkscape/ Inkscape Effects]<br />
''<br />
<br />
==Interpolate==<br />
<br />
This will transform one path to another path and optionally change the style too. 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. <br />
<br />
upload:interpolate_blueSquare-redCircle.png<br />
<br />
==Kochify==<br />
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.</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=Extension_reference&diff=6451Extension reference2006-05-15T14:54:06Z<p>Justin.Wikinator: </p>
<hr />
<div>''A page with info about the Effects and particularly some png's / screenshots. To learn more about effects and how to write new ones, check out this page : [http://www.ekips.org/comp/inkscape/ Inkscape Effects]<br />
''<br />
<br />
==Interpolate==<br />
<br />
This will transform one path to another path and optionally change the style too. 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. <br />
<br />
upload:interpolate_blueSquare-redCircle.png<br />
<br />
==Kochify==<br />
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].</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=JustinsEffectGoals&diff=6410JustinsEffectGoals2006-05-11T15:28:59Z<p>Justin.Wikinator: </p>
<hr />
<div>These are the effects that I will to develop in Inkscape<br />
<br />
*Discrete Gradient Fill- given a selection of objects and two colors, the effect will fill each object in a graded fashion i.e. given 3 circles and red,white as colors, the first circle will be filled red, the second pink, and the third white<br />
*Unit Subdivision generation (circular, triangular, cartesian, ruler ticks) - given a list of pairs that represent (division, width) it will create a grid with subdivisions of different widths (see [http://www.flickr.com/photos/wikinator/130981730/ a circular subdivision example])<br />
*Metcalfle Wheel generator - see [http://www.flickr.com/photos/wikinator/144583174/ an example]<br />
*Path command input - a gui for creating/appending paths, such that users could input path data based on geometric co-ordinates rather than mouse input<br />
<br />
GUI improvements for effects:<br />
<br />
*a screen-capture for co-ordinates (similar to the way spreadsheet program dialogues allow one to capture ranges by highlighting them on the spreadsheet) <br />
*color selector<br />
*drop-down menu with predefined svg shapes in it</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=JustinsEffectGoals&diff=6409JustinsEffectGoals2006-05-11T15:28:27Z<p>Justin.Wikinator: </p>
<hr />
<div>==Justin's Effect Goals===<br />
<br />
These are the effects that I will to develop in Inkscape<br />
<br />
*Discrete Gradient Fill- given a selection of objects and two colors, the effect will fill each object in a graded fashion i.e. given 3 circles and red,white as colors, the first circle will be filled red, the second pink, and the third white<br />
*Unit Subdivision generation (circular, triangular, cartesian, ruler ticks) - given a list of pairs that represent (division, width) it will create a grid with subdivisions of different widths (see [http://www.flickr.com/photos/wikinator/130981730/ a circular subdivision example])<br />
*Metcalfle Wheel generator - see [http://www.flickr.com/photos/wikinator/144583174/ an example]<br />
*Path command input - a gui for creating/appending paths, such that users could input path data based on geometric co-ordinates rather than mouse input<br />
<br />
GUI improvements for effects:<br />
<br />
*a screen-capture for co-ordinates (similar to the way spreadsheet program dialogues allow one to capture ranges by highlighting them on the spreadsheet) <br />
*color selector<br />
*drop-down menu with predefined svg shapes in it</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6352ImprovingPythonEffectsAPI2006-05-05T14:48:56Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision).<br />
<br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation (only "proper" poygon stars) (see this page: http://mathworld.wolfram.com/StarPolygon.html on Stars Polygons) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
==Timeline==<br />
<br />
This timeline has been written with a estimation-time-doubling heuristic in mind: <br />
* 2 weeks - make all design decisions, working with mentor to prevent overlap and ensure proper integration. Questions to answer:<br />
** What is the full list of features to be implemented over the summer ? What is the priority of each feature ?<br />
** How will Python access a DOM ?<br />
** Will the project incorporate live scripting from a command line ? If so, how can the archetecture be designed to meet those needs ? <br />
** Should external geometry functions be used, or should all geometric operations be natively implemented?<br />
** Should the .inx specification remain the same ?<br />
** How will changes to the API affect existing effects ?<br />
* 2 weeks - make existing code that will be encorporated into the API more robust by using PyUnit test cases for QA and improve documentation, possibly using Doxygen for documentation generation<br />
* 2 weeks - integrate existing libraries into the Inkscape API<br />
* 4 weeks - develop effects using the API<br />
* 2 weeks - play with the API ! Write example scripts to generate art to be posted to various web sites (i.e. openclipart.org, deviantart), w/ advertisements for the new Inkscape features attached to them.<br />
<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=UbuntuInstall043&diff=6350UbuntuInstall0432006-05-04T17:46:06Z<p>Justin.Wikinator: </p>
<hr />
<div>==How to install Inkscape 0.43 on Breezy Badger==<br />
<br />
''From the Ubuntu Forums thread [http://www.ubuntuforums.org/showthread.php?t=93233 here]:''<br />
<br />
*Step 1: Open up synaptic or apt-get install:<br />
**libglibmm-2.4-dev<br />
**libgtkmm-2.4-dev<br />
**libSigc++2.0-dev<br />
*Step 2:<br />
**Get and install the following packages from Debian testing:<br />
***libgc1c2_6.5-1_i386.deb<br />
***libgc-dev_6.5-1_i386.deb<br />
***libgtkspell0_2.0.10-3_i386.deb<br />
***libgtkspell-dev_2.0.10-3_i386.deb<br />
***Download the Inkscape 0.43 source and compile and install it.<br />
*Or Alternate Step 2:<br />
**Download this package http://keithperkins.net/files/inkscape-.43+deps.tar.gz extract it, and dpkg -i all the files in the order above, and then do the same for the Inkscape_0.43-1_i386.deb (Yes I made one) Or you can, also download just the Inkscape .deb package http://keithperkins.net/files/inkscape_0.43_1.tar.gz</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=UbuntuInstall043&diff=6349UbuntuInstall0432006-05-04T17:40:04Z<p>Justin.Wikinator: </p>
<hr />
<div>==How to install Inkscape 0.43 on Breezy Badger==<br />
<br />
''From the Ubuntu Forums thread [http://www.ubuntuforums.org/showthread.php?t=93233 here]:''<br />
<br />
Step 1:<br />
Open up synaptic or apt-get install:<br />
libglibmm-2.4-dev<br />
libgtkmm-2.4-dev<br />
libSigc++2.0-dev<br />
Step 2:<br />
Get the following packages from Debian testing:<br />
libgc1c2_6.5-1_i386.deb<br />
libgc-dev_6.5-1_i386.deb<br />
libgtkspell0_2.0.10-3_i386.deb<br />
libgtkspell-dev_2.0.10-3_i386.deb<br />
and install them.<br />
Download the Inkscape 0.43 source and compile and install it.<br />
Or Alternate Step 2:<br />
Download this package http://keithperkins.net/files/inkscape-.43+deps.tar.gz<br />
extract it, and dpkg -i all the files in the order above, and then do the same for the Inkscape_0.43-1_i386.deb<br />
(Yes I made one)<br />
Or you can, also download just the Inkscape .deb package http://keithperkins.net/files/inkscape_0.43_1.tar.gz<br />
I posted this in the Customization Forum last night but it hasn't been moderated yet (or their not going to let it in--I've not word on it, and don't know how longit's supposed to take). I made a .deb for Inkscape .43 and tar/gzipped it up with the deps that aren't in Ubuntu repos, and uploaded to my site. Also just the .deb if anyone just wants that.<br />
Works fine on my computer--YMMV.<br />
If anyone of the backports people want to use it for the backports go ahead.</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6295ImprovingPythonEffectsAPI2006-04-29T21:47:48Z<p>Justin.Wikinator: /* AutoShapes extensions */</p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision).<br />
<br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation (only "proper" poygon stars) (see this page: http://mathworld.wolfram.com/StarPolygon.html on Stars Polygons) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6294ImprovingPythonEffectsAPI2006-04-29T21:44:56Z<p>Justin.Wikinator: /* AutoShapes extensions */</p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision).<br />
<br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6293ImprovingPythonEffectsAPI2006-04-29T21:43:59Z<p>Justin.Wikinator: /* AutoShapes extensions */</p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape). Unlike AutoShapes in most drawing programs, which can only be scaled, many parameters of these AutoShapes could be configured (like the Lindenmayer). To implement some of these, I might need to improve how the GUI interfaces with the effects (i.e. to collect a list of numbers of varying size as in unit subdivision). <br />
Some examples <br />
* circle unit subdivision algorithm (see an example here) *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6292ImprovingPythonEffectsAPI2006-04-29T20:26:50Z<p>Justin.Wikinator: /* Introduction */</p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. Nor was I impressed with the code on a website called "Programmer Art" (which has since gone defunct) or the very basic examples on ASPN. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I was particularly interested in creating mandala-like patterns with my code, so I needed an easy way to convert polar co-ordinates to cartesian ones. I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape)<br />
* circle unit subdivision algorithm *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6291ImprovingPythonEffectsAPI2006-04-29T20:20:46Z<p>Justin.Wikinator: /* Introduction */</p>
<hr />
<div>==Introduction==<br />
<br />
For a year now, I have been writing python scripts to generate and manipulate SVG. My motivations in doing so was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I wanted a simpler way of creating elements so that I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed in a "pythonic" way. <br />
<br />
Though these scripts can not run in server-side web browsers like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape)<br />
* circle unit subdivision algorithm *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6290ImprovingPythonEffectsAPI2006-04-29T20:11:30Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. During this time I chose to apply for one of Inkscape's suggested projects becasue I figured I would be more likely to get the position this way, but I put little effort into my proposal, doing little more than cutting and pasting the suggestion into my application. I have decided this year that instead of choosing one of the projects that Inkscape suggests, I will create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts "PySVaG" because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way of creating elements so I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape)<br />
* circle unit subdivision algorithm *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I'm a fourth year Computer Science student at Carleton University. I've yet to have a paid job as a programmer, but I've done a bunch technology-related volunteering and a lot of self-education to suppliment my university education. I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly and am familiar with all its features<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer, during which I do not have other labour commitments<br />
* enjoy writing and will provide good documentation for both developers and end users<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
* there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
* despite this, there has not been a strong community of development around effects in Inkscape<br />
* improving the ease of development and documentation around effects will encourage developers to create new effects<br />
* python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
* improving python effects libraries would expand functionality of Inkscape without introducing any bugs to the core C++ code<br />
* improving python effects may offer ideas/sketches to improve path data structures internally<br />
<br />
<br />
Any feedback on this proposal would be greatly appreciated <br />
<br />
Thanks,<br />
<br />
Justin <br />
touchmewithsynchronicpulses)aat(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6289ImprovingPythonEffectsAPI2006-04-29T18:00:00Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. During this time I chose to apply for one of Inkscape's suggested projects becasue I figured I would be more likely to get the position this way, but I put little effort into my proposal, doing little more than cutting and pasting the suggestion into my application. I have decided this year that instead of choosing one of the projects that Inkscape suggests, I will create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts "PySVaG" because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way of creating elements so I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape)<br />
* circle unit subdivision algorithm *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self and Proposal==<br />
<br />
I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons and Free Culture community (this year I started organizing [http://carleton.freeculture.org Free Culture Carleton])<br />
My proposal will be a significant improvement to Inkscape because:<br />
* effects are a strong driving force between many different media applications (i.e. raster graphics, audio, video, 3D) and extend the capabilities of them greatly<br />
** there are many unimplimented effects that could be easily developed, as there's a lot of publications about computer graphics geometry describing the theoretical process <br />
** despite this, there has not been a strong community of development around effects in Inkscape<br />
** improving the ease of development and documentation around effects will encourage developers to create new effects<br />
** python is an extremely accessible language that proves itself ideal for effects scripting (i.e. Blender scripting)<br />
** a better <br />
<br />
==Afterwords==<br />
I am not familiar with the development scene at Inkscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because I intent to participate in the development of Inkscape one way or another, I would greatly appreciate your assistance with my proposal. <br />
<br />
Thanks,<br />
<br />
Justin Barca<br />
touchmewithsynchronicpulses)(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonExtensionAPI&diff=6288ImprovingPythonExtensionAPI2006-04-29T17:37:43Z<p>Justin.Wikinator: ImprovingPythonExtensionAPI moved to ImprovingPythonEffectsAPI</p>
<hr />
<div>#redirect [[ImprovingPythonEffectsAPI]]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6287ImprovingPythonEffectsAPI2006-04-29T17:37:42Z<p>Justin.Wikinator: ImprovingPythonExtensionAPI moved to ImprovingPythonEffectsAPI</p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. During this time I chose to apply for one of Inkscape's suggested projects becasue I figured I would be more likely to get the position this way, but I put little effort into my proposal, doing little more than cutting and pasting the suggestion into my application. I have decided this year that instead of choosing one of the projects that Inkscape suggests, I will create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts "PySVaG" because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way of creating elements so I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape)<br />
* circle unit subdivision algorithm *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self==<br />
<br />
I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons community (this year I started organizing a Free Culture Group at Carleton University)<br />
<br />
==Afterwords==<br />
I am not familiar with the development scene at Inkscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because I intent to participate in the development of Inkscape one way or another, I would greatly appreciate your assistance with my proposal. <br />
<br />
Thanks,<br />
<br />
Justin Barca<br />
touchmewithsynchronicpulses)(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6286ImprovingPythonEffectsAPI2006-04-29T17:36:05Z<p>Justin.Wikinator: /* Proposal */</p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. During this time I chose to apply for one of Inkscape's suggested projects becasue I figured I would be more likely to get the position this way, but I put little effort into my proposal, doing little more than cutting and pasting the suggestion into my application. I have decided this year that instead of choosing one of the projects that Inkscape suggests, I will create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts "PySVaG" because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way of creating elements so I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
===Mathematical libraries for plotting points===<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB #*<br />
<br />
===Functions for manipulating paths===<br />
* abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
* path distance calculation *#*<br />
* convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
* each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
* return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
* create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
* develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
* functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
* functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
* obtain a point a certain distance along a path<br />
* add texture to curves<br />
** similar to Kochify but that only applies 1 copy in between nodes wheras this would apply a pattern many times along one line or bezier command<br />
** an example application: given a leaf outline, give a jagged texture of it<br />
<br />
===AutoShapes extensions===<br />
Each AutoShape would generate a different figures given particular parameters from a GUI (like the star tool, but not being objects in Inkscape)<br />
* circle unit subdivision algorithm *#*<br />
* Cartesian and Poler graph with unit subdivision<br />
* Ruler dashes with unit subdivision<br />
* "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
* hexagon grid *#*<br />
* flower-like radial shapes *#* done some, but there's many possibilities<br />
* series of circles forming a Cartoid *#*<br />
* generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but after much contemplation/experimentation I haven't figured out how to get my spiral curves smoother)<br />
* zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account (silly to rasterize SVG, but I haven't found good SVG gallery service/software, hope openclipart.org get ccHost working soon)<br />
<br />
==Selling Self==<br />
<br />
I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons community (this year I started organizing a Free Culture Group at Carleton University)<br />
<br />
==Afterwords==<br />
I am not familiar with the development scene at Inkscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because I intent to participate in the development of Inkscape one way or another, I would greatly appreciate your assistance with my proposal. <br />
<br />
Thanks,<br />
<br />
Justin Barca<br />
touchmewithsynchronicpulses)(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6222ImprovingPythonEffectsAPI2006-04-23T10:35:27Z<p>Justin.Wikinator: /* Selling Self */</p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. During this time I chose to apply for one of Inkscape's suggested projects becasue I figured I would be more likely to get the position this way, but I put little effort into my proposal, doing little more than cutting and pasting the suggestion into my application. I have decided this year that instead of choosing one of the projects that Inkscape suggests, I will create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts "PySVaG" because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way of creating elements so I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
** obtain a point a certain distance along a path<br />
** complex path intersections<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
I realize that my proposal needs a sample API to really demonstrate my intentions, so I'll be working on assembling this in the lead-up to the application opening.<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account.<br />
<br />
==Selling Self==<br />
<br />
I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly<br />
* have the (electronic) book [http://www.learnsvg.com/ Learn SVG] as a reference<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer<br />
* will continue to improve Inkscape beyond the term of my work<br />
* am aligned with the values of the Free Software movement and its offshoots like Creative Commons community (this year I started organizing a Free Culture Group at Carleton University)<br />
<br />
==Afterwords==<br />
I am not familiar with the development scene at Inkscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because I intent to participate in the development of Inkscape one way or another, I would greatly appreciate your assistance with my proposal. <br />
<br />
Thanks,<br />
<br />
Justin Barca<br />
touchmewithsynchronicpulses)(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6221ImprovingPythonEffectsAPI2006-04-23T10:26:23Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. During this time I chose to apply for one of Inkscape's suggested projects becasue I figured I would be more likely to get the position this way, but I put little effort into my proposal, doing little more than cutting and pasting the suggestion into my application. I have decided this year that instead of choosing one of the projects that Inkscape suggests, I will create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts "PySVaG" because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way of creating elements so I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor/method in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
** obtain a point a certain distance along a path<br />
** complex path intersections<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
I realize that my proposal needs a sample API to really demonstrate my intentions, so I'll be working on assembling this in the lead-up to the application opening.<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account.<br />
<br />
==Selling Self==<br />
<br />
I believe I'm an excellent candidate for this position because I: <br />
* use Inkscape regularly<br />
* advocate for Free Software (this year I started organizing a Free Culture Group at Carleton University)<br />
* have a bunch of code already written which could be applied to the project<br />
* will pour a lot of my energies into this project during the summer<br />
* will continue to improve Inkscape beyond the term of my work <br />
<br />
==Afterwords==<br />
I am not familiar with the development scene at Inkscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because I intent to participate in the development of Inkscape one way or another, I would greatly appreciate your assistance with my proposal. <br />
<br />
Thanks,<br />
<br />
Justin Barca<br />
touchmewithsynchronicpulses)(gmail.com</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=Extension_reference&diff=6197Extension reference2006-04-19T17:41:51Z<p>Justin.Wikinator: </p>
<hr />
<div>A page with info about the Effects and particularly some png's / screenshots.<br />
<br />
To learn more about effects and how to write new ones, check out this page : [http://www.ekips.org/comp/inkscape/ Inkscape Effects]<br />
<br />
Interpolate<br />
<br />
This will transform one path to another path and optionally change the style too. 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. <br />
<br />
upload:interpolate_blueSquare-redCircle.png</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6196ImprovingPythonEffectsAPI2006-04-19T17:28:20Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. During this time I chose to apply for one of Inkscape's suggested projects becasue I figured I would be more likely to get the position this way, but I put little effort into my proposal, doing little more than cutting and pasting the suggestion into my application. I have decided this year that instead of choosing one of the projects that Inkscape suggests, I will create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts "PySVaG" because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. Math plotting libraries like GNUplot were not what I was looking for. I learned about ActionScript for Flash, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way of creating elements so I didn't have to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements (allowing for default values of attributes, style libraries, etc.), using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out overlaped the work done in the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a simple 2D geometry library in python but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. <br />
<br />
Over the last year my imagination has discovered a richness of geometric/design problems to solve. In my proposal, I have listed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the Python plugin API<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
** obtain a point a certain distance along a path<br />
** complex path intersections<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** "star polygon" creation along with creation of a dictionary of all "proper" poygon stars (see this page on [ http://mathworld.wolfram.com/StarPolygon.html Stars Polygons ] ) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account.<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inkscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[mailto:touchmewithsynchronicpulses@gmail.com Justin Barca]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6195ImprovingPythonEffectsAPI2006-04-19T16:48:37Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ SVG IMAGENERATION] on my new Flickr account.<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[mailto:touchmewithsynchronicpulses@gmail.com Justin Barca]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6194ImprovingPythonEffectsAPI2006-04-19T16:47:19Z<p>Justin.Wikinator: /* Proposal */</p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ | SVG IMAGENERATION] on my new Flickr account.<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[mailto:touchmewithsynchronicpulses@gmail.com Justin Barca]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6193ImprovingPythonEffectsAPI2006-04-19T16:47:11Z<p>Justin.Wikinator: /* Proposal */</p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
I have added some screen shots of the [http://www.flickr.com/photos/wikinator/sets/72057594111379807/ | SVG IMAGENERATION] on my new Flickr account<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[mailto:touchmewithsynchronicpulses@gmail.com Justin Barca]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6192ImprovingPythonEffectsAPI2006-04-19T16:44:04Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[mailto:touchmewithsynchronicpulses@gmail.com Justin Barca]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6191ImprovingPythonEffectsAPI2006-04-19T16:36:56Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[[mailto:touchmewithsynchronicpulses@gmail.com Justin Barca]]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6190ImprovingPythonEffectsAPI2006-04-19T16:36:09Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[[mailto:touchmewithsynchronicpulses@gmail.com | Justin Barca ]]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6189ImprovingPythonEffectsAPI2006-04-19T16:35:17Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*<br />
<br />
==Afterwords==<br />
<br />
Because I have consistently applied myself to developing SVG generation scripts over the last year, I believe that I have a lot to offer to the project. However, I am not familiar with the development scene at Inscape, and thus would like to communicate with those who are. I think it would help me to refine my proposal into something that fits better with the current development of the project. Because doing Summer of Code with Inkscape would be my absolute dream job (considering that I've been pursuing this stuff as a hobby for a year now), I would greatly appreciate your assistance. <br />
<br />
Thanks,<br />
<br />
[[Justin Barca | mailto:touchmewithsynchronicpulses@gmail.com]]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=ImprovingPythonEffectsAPI&diff=6188ImprovingPythonEffectsAPI2006-04-19T16:25:42Z<p>Justin.Wikinator: </p>
<hr />
<div>==Introduction==<br />
<br />
I applied last year for the Summer of Code and was really excited about the prospects of working on Inkscape because it was a program that I had just begun to use regularly. Although at the time I was using it mostly as a viewer, I was quite interested in vector graphics and particularly SVG for the sake of its open standards and ease of manipulation. Last summer I began working on a series of scripts to generate SVG images. I chose to apply for one of the suggested projects becasue I figured I would be more likely to get the position, but I put little effort into my proposal, basically just cutting and pasting the suggestion. I have decided that instead of choosing one of the projects that Inkscape suggests, I would create my own proposal related to the work I have been doing with stand-along Python scripts to generate SVG. I will explain what I've done and how I think it can be integrated into the python extensions in Inkscape. <br />
<br />
I've dubbed my bag of scripts PySVaG because it rhymes with "spice bag" and I like to think of this stuff as "eye spice" (instead of "eye candy"). My motivations in creating scripts to generate SVG was to allow me to plot complex geometrically defined patterns in a precise way. When I searched over the internet for code that could do this, I didn't find what I needed. I learned about ActionScript, but I didn't want to get locked into a proprietary standard. I also learned a bit about Javascript and the use of it to modify the DOM in SVG, but I wasn't liking JavaScript for generating SVG. <br />
<br />
I first of all wanted a simpler way than having to write a setAttribute line for every attribute as in JavaScript; instead I wanted to be able to call a construtor in order to add elements, using the simplicity and power of Object-Oriented Programming in Python to abstract SVG images in a clearer way. One of the first things I accomplished was to make the DOM tree easily accessible though the use of Amara. This made all attributes represented as a dictionary (which I later found out was already done by the extension tutorial) and the elements of the tree were easily traversed using built-in array index overloading (term ??). <br />
<br />
Though these scripts can not run in server-side web browsing like JavaScript can, they were not designed to do so; instead they were designed to be a library of functions that generate complex SVG shapes. Some of these scripts may draw thousands of lines, and so it would be inefficient to generate the image every time it is viewed on a web page. Instead the script runs once and outputs an .svg file. <br />
<br />
I looked for a really simple 2D geometry library but found nothing which suited the task, so I created one for the purpose of representing points as objects that could be manipulated by different algorithms and formulas. C<br />
<br />
<br />
<br />
I found there was a richness of geometric/design problems that could be fueled by the desire to turn imagination into perfect symetric generation. In my proposal, I have proposed a number of features/algorithms that I have already implemented in my stand-alone SVG applications. I have marked these with a "*#*".<br />
<br />
==Proposal==<br />
<br />
My goals in working on the python extensions would be to improve the python plugin api<br />
* Mathematical libraries for plotting points<br />
* Cartesian and Polar points with conversion to and from each other. Operations such as addition, subtraction, dot product, scalar multiplication *#*<br />
* Midpoint of two points *#*<br />
* Point at a fraction of a distance from point A to point B *#*<br />
* pointsBetween - given A and B, returns n equidistant points along the line *#*<br />
* extendBend - given two points A and B, a distance and an angle, returns a point C which results from extending distance out from AB and then bending BC about B by the given angle *#*<br />
* reflection - given a line AB and point C, returns the reflection of C in AB *#*<br />
*higher level of abstraction in accessing the document<br />
*develop a rich set of functions for manipulating paths <br />
** abstractions for each path command and random access to the list of commands (so you can look backward and see what point the inspected command is starting from) *#*<br />
** path distance calculation *#*<br />
** convert a quadradic bezier into a cubic bezier *#* figured out this one purely by experimentation<br />
** each Command object (i.e. one of class CubicBezierCommand) stores control points and nodes as Point objects *#*<br />
** return an array of references to all Points in the path (which could then be operated on by some function or other operation) *#*<br />
** create a closed symetrical path out of an open path that is one side of the shape by appending it's mirror (along the start-end line) to itself <br />
** develop new ways of constructing and representing bezier curves relative to their start and end points i.e. where the control points are represented as a vector relative to the base line of the curve *#*<br />
** functions to return points a certain distance along a path, or a certain percentage of the distance of the path<br />
** functions to do complex path slicing/merging where the number of commands is increasing or decreasing<br />
*add a number of "autoShapes" extensions that would generate different shapes given particular parameters from a GUI<br />
** circle unit subdivision algorithm *#*<br />
** Cartesian and Poler graph with unit subdivision<br />
** Ruler dashes with unit subdivision<br />
** polygon star" (see wikipedia) *#*<br />
** hexagon grid *#*<br />
** flower-like radial shapes *#* some, but there's many possibilities<br />
** series of circles forming a Cartoid *#*<br />
** generation of phi spiral and phi spiral lattice (think dreamcatcher pattern) *#* (but I can't figure out hot to get my spiral curves smoother :( )<br />
** zig zag and loop-de-loop line generation *#*</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=Google_Summer_of_Code_2006&diff=6187Google Summer of Code 20062006-04-19T16:18:38Z<p>Justin.Wikinator: /* SOC 2006 */</p>
<hr />
<div>=== SOC 2006 ===<br />
<br />
Google has been kind enough to invite Inkscape to participate as a mentoring organization in the Summer of Code 2006. The students and developers had a lot of fun last year, and resulted in some _great_ additions to the software, so we are very enthused about this year.<br />
<br />
Below is a list of ideas that Inkscape developers think might make good projects. Please do not let this list constrain you; if you have a good idea beyond what is listed we'd love to see it!<br />
<br />
Also, we would strongly encourage students to contact us on the Inkscape developer's list prior to submitting your proposal. This gives us a chance to get to know you and to give you feedback that will strengthen your proposal.<br />
<br />
* http://gould.cx/ted/blog/Google_SoC_2<br />
<br />
* http://sourceforge.net/tracker/index.php?func=detail&aid=1457179&group_id=93438&atid=604309<br />
<br />
* Debug Inkscape's memory leaks and decrease memory usage<br />
<br />
* Implement http://wiki.inkscape.org/wiki/index.php/Required_PDF_Support (I know of UberConverter, but PDF is the most important interchange format so we should better support it natively)<br />
<br />
* Implement EPS import by reusing Scribus' EPS import library for Inkscape.<br />
<br />
* SVG support in OpenOffice (not exactly Inkscape development, but would allow Inkscape users to paste in art rather than having to export to png and really promote usuage of Inkscape). Not to mention eliminating all those duplicate svg/png image files!<br />
<br />
* More potrace/SIOX/etc. style features/development<br />
<br />
* Extending the online InkscapeSVG stuff - might be very cool for sharing sketches, etc<br />
<br />
* Building a public whiteboard server for Inkscape users, with a web site of its own, user galleries, interest groups, scheduled drawathons, connections to OCAL, etc.<br />
<br />
* Make Inkboard work on Windows<br />
<br />
* Develop a prototype for a cross-platform open API to allow vector graphics tools to apply bitmap effects (e.g. from GIMP or ImageMagick) transparently to vector graphics.<br />
<br />
* Add new kinds of grid functionality, like perspective grid, hex grid, iso grid, etc.<br />
<br />
* Create or enhance converters for file formats like Visio, CorelDraw, etc. etc.<br />
<br />
* Skeletal Strokes and Effect Lines - A few links: Our wiki page on Expression [[http://wiki.inkscape.org/wiki/index.php/Expression]], Technical papers on Skeletal Strokes [[http://portal.acm.org/citation.cfm?id=192186]], Examples - [[http://northlite.50megs.com/expr/effectlines.htm]], [[http://www.wa.commufa.jp/~ksg/p_pfwp5_cgf.htm]], [[http://personal-computer-tutor.com/abc4/v36/sara36.htm]].<br />
<br />
* Improve the functionality and ease of use of the python effects API (see my proposal in the [[ImprovingPythonExtensionAPI]] page )<br />
<br />
=== bbyak projects (mentored by bulia) ===<br />
<br />
* Implement SVG filters, at least Gaussian blur<br />
<br />
* Bucket fill tool: http://sourceforge.net/tracker/index.php?func=detail&aid=1123138&group_id=93438&atid=604309<br />
<br />
* Color adjust dialog (brightness/contrast, HSL, "colorize") which would work on any number of vector objects (with flat, gradient, or pattern fill) as well as bitmaps<br />
<br />
<br />
<br />
=== SOC 2005 ===<br />
* [[SOC Accepted Proposals]]<br />
* [[SOC Writing Project Proposals]]<br />
* [[SOC Selection Criteria]]<br />
* [[SOC Original Project Prompts]]</div>Justin.Wikinatorhttps://wiki.inkscape.org/wiki/index.php?title=Google_Summer_of_Code_2006&diff=6186Google Summer of Code 20062006-04-19T16:17:36Z<p>Justin.Wikinator: /* SOC 2006 */</p>
<hr />
<div>=== SOC 2006 ===<br />
<br />
Google has been kind enough to invite Inkscape to participate as a mentoring organization in the Summer of Code 2006. The students and developers had a lot of fun last year, and resulted in some _great_ additions to the software, so we are very enthused about this year.<br />
<br />
Below is a list of ideas that Inkscape developers think might make good projects. Please do not let this list constrain you; if you have a good idea beyond what is listed we'd love to see it!<br />
<br />
Also, we would strongly encourage students to contact us on the Inkscape developer's list prior to submitting your proposal. This gives us a chance to get to know you and to give you feedback that will strengthen your proposal.<br />
<br />
* http://gould.cx/ted/blog/Google_SoC_2<br />
<br />
* http://sourceforge.net/tracker/index.php?func=detail&aid=1457179&group_id=93438&atid=604309<br />
<br />
* Debug Inkscape's memory leaks and decrease memory usage<br />
<br />
* Implement http://wiki.inkscape.org/wiki/index.php/Required_PDF_Support (I know of UberConverter, but PDF is the most important interchange format so we should better support it natively)<br />
<br />
* Implement EPS import by reusing Scribus' EPS import library for Inkscape.<br />
<br />
* SVG support in OpenOffice (not exactly Inkscape development, but would allow Inkscape users to paste in art rather than having to export to png and really promote usuage of Inkscape). Not to mention eliminating all those duplicate svg/png image files!<br />
<br />
* More potrace/SIOX/etc. style features/development<br />
<br />
* Extending the online InkscapeSVG stuff - might be very cool for sharing sketches, etc<br />
<br />
* Building a public whiteboard server for Inkscape users, with a web site of its own, user galleries, interest groups, scheduled drawathons, connections to OCAL, etc.<br />
<br />
* Make Inkboard work on Windows<br />
<br />
* Develop a prototype for a cross-platform open API to allow vector graphics tools to apply bitmap effects (e.g. from GIMP or ImageMagick) transparently to vector graphics.<br />
<br />
* Add new kinds of grid functionality, like perspective grid, hex grid, iso grid, etc.<br />
<br />
* Create or enhance converters for file formats like Visio, CorelDraw, etc. etc.<br />
<br />
* Skeletal Strokes and Effect Lines - A few links: Our wiki page on Expression [[http://wiki.inkscape.org/wiki/index.php/Expression]], Technical papers on Skeletal Strokes [[http://portal.acm.org/citation.cfm?id=192186]], Examples - [[http://northlite.50megs.com/expr/effectlines.htm]], [[http://www.wa.commufa.jp/~ksg/p_pfwp5_cgf.htm]], [[http://personal-computer-tutor.com/abc4/v36/sara36.htm]].<br />
<br />
* Improve the functionality and ease of use of the python effects API (see my proposal in the [ImprovingPythonExtensionAPI] page )<br />
<br />
=== bbyak projects (mentored by bulia) ===<br />
<br />
* Implement SVG filters, at least Gaussian blur<br />
<br />
* Bucket fill tool: http://sourceforge.net/tracker/index.php?func=detail&aid=1123138&group_id=93438&atid=604309<br />
<br />
* Color adjust dialog (brightness/contrast, HSL, "colorize") which would work on any number of vector objects (with flat, gradient, or pattern fill) as well as bitmaps<br />
<br />
<br />
<br />
=== SOC 2005 ===<br />
* [[SOC Accepted Proposals]]<br />
* [[SOC Writing Project Proposals]]<br />
* [[SOC Selection Criteria]]<br />
* [[SOC Original Project Prompts]]</div>Justin.Wikinator