Picture to People project has been developed according to some guidelines that are desirable to most good quality software. These guidelines can be translated to a set of properties the software should have. Below you see a list of main general features that can be found in P2P libraries with some examples. Most examples came from Maccala, the newest large Picture to People library.
Generally speaking, Picture to People software is:
At language level: the low level core libraries are not object-oriented on purpose: they can be ported even to C without problems. The higher level libraries use simple, clean object-oriented techniques, so they can be ported to most object-based languages.
At environment level: there are no imports: all Computer Graphics tasks are covered by the libraries; any OS or environment dependent code must be isolated outside and just accessed by a proper interface (a well known signature). An example of this could be a clipboard interface.
At hardware level: the libraries use no video card acceleration, so the absence of this kind of hardware will not prevent its use. There are some "assembly like" code present in the low level source for otimization, but it uses just common simple instructions, so probably they exist in any current RISC or CISC architecture (porting to C solves it too).
The project suggests a smart way to deal with shapes and curves, so it can be extended, for example, to develop an interactive, desktop program for graphics manipulation.
Supersampling level (for drawing tasks) can be set dynamically from 2 to 1000 or more according to the needs. Most of data structures are really dynamic and have no fixed maximum sizes or maximum element numbers.
Many algorithms have several freedom degrees, so the results are very configurable. Many curves/shapes have a configurable smoothness.
Its exclusive rendering engine can produce top level, anti-aliased drawings with the same quality of the more expensive commercial programs.
When applicable, the software tries to be generic and smart: it's possible, for example, create new pattern styles for lines and curves with almost no programming, because the low level sub-library that tackle this is highly parameterized; it has powerful low level math sub-libraries.
Despite its internal complexity, most libraries offer very simple and easy interface (methods and functions) for common tasks. It's easy to program using the high level libraries.
It tries to get and use unified solutions when possible; to draw lines and curves, for example, the same algorithm is able to deal with a thickness of 0.3 or 30.
The libraries are largely tested and used: beyond the unit tests made, most hidden bugs are detected and corrected as part of Picture to People development (P2P source code uses most of its libraries deeply).
Worried about Performance
The implementation is heavily based on pointers (in its internals). Many times it tries to use data structures that help the algorithms to run faster. Despite the powerful supersampling available, its rasterizer is kind of 90% based on integer operations (instead of floating-point ones).
Worried about Resources
The source code is made trying to avoid too deep and too inflated call stacks when possible. It's almost totally based on dynamic data structures: usually it keeps just the memory it really needs. When in debug mode, the software can use a "memory auditor" to find blocks not deallocated by mistake (this memory spy was made by the same author, but it's not part of Picture to People).
Usually the hardest and more important low level parts are strongly documented. The high level interfaces are very easy to use.
Picture to People software implements several exclusive algorithms researched exclusively for the project.
Leonardo C. de Almeida - P2P developer