It might take me a while to do the sensible thing and locate the appropriate Jython forum to post a question on, so since you guys are so nice and friendly and know all about Processing sketches, I thought I'd mention here that it currently doesn't appear to be possible to run Processing sketches on Jython. (unless I've mis-searched again, this issue doesn't appear to have been discussed here before).

To reproduce, open up a nice simple Java-mode sketch in the Processing IDE (mine is called “star”) and (from the 'file' menu) export it as an application. Then bring up a command prompt or shell and navigate to the “lib” directory that has just been created. I'm on Windows, on other platforms the file separator might be a colon rather than a semi-colon. Start by checking that the sketch runs normally:

D:\git\sketches\star\application.windows32\lib>java -cp star.jar;core.jar star

That much should work fine, but here's what happens if I try to run this sketch in Jython:

D:\git\sketches\star\application.windows32\lib>jython -Dpython.path=star.jar;cor e.jar
Jython 2.5.3 (2.5:c56500f08d34+, Aug 13 2012, 14:48:36)
[Java HotSpot(TM) Client VM (Oracle Corporation)] on java1.7.0_25
Type "help", "copyright", "credits" or "license" for more information.
>>> import star
>>> star.main([])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
at processing.core.PApplet.runSketch(PApplet.java:10407)
at processing.core.PApplet.main(PApplet.java:10205)
at star.main(star.java:45)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)

java.lang.RuntimeException: java.lang.RuntimeException: java.lang.ClassNotFoundE xception: star

And here are two further commands that I think are quite enlightening:

>>> x = star()
>>> x.getClass().getClassLoader()
org.python.core.SyspathJavaLoader@13aa36a

Jython has replaced the regular classloader (sun.misc.Launcher$AppClassLoader) with a class loader of it's own. The exception directs us to PApplet.java line 10407 and if we look at the line of code where the exception occurred

https://github.com/processing/processing/blob/12bb38f4b56a128b6e4eabe94836898aa1bb9e5b/core/src/processing/core/PApplet.java

We see that it is indeed trying to make use of the class loader. Unfortunately I think this is about as far as I'm going to get on my own, any advice would be welcome.

    Best wishes,

        Antony

Does anyone have some Processing code for benchmarking? - i.e. a sketch that performs a series of tasks and times each of them.

I browsed the source code for x11perf and UnixBench last night (written in C), and am mulling over porting a few of the tests across.

As might be expected, I've noticed various performance differences between Processing 1.5, Processing 2.0, Processing.js (but what about different browsers?), my laptop at home, and my computer at work... mostly obvious stuff, but occasionally something more curious, and it would be good to put my impressions on a more empirical footing.

    Thanks,

        Antony

Last month I wrote a sketch called YinYang.

http://www.openprocessing.org/sketch/74982

It uses the Box2DWeb JavaScript API, but is able to run in Java mode too (not just JavaScript mode) due to the use of Rhino, which is a JavaScript interpreter written in Java.  Perhaps this is why I tripped over a couple of cross-compatibility issues which may not have been seen before, and there are a couple of other issues I encountered which I'm going to list here too.

Everything I came across I was able to workaround in my sketch, and I also have patches to the Processing source code which address each of these issues.  I discussed how to apply a patch from GitHub to an svn working directory here:

https://forum.processing.org/topic/processing-source-code-and-github#25080000001800081

Unless I get other advice, then in about a weeks time I'm going to feed these issues one at a time into the Processing issue tracking system in googlecode, but I thought it would be good to present the whole picture first and give folks the opportunity to comment if they wish to.

It's only fair to point out that my sketch isn't free of bugs either - I have issues with conservation of momentum, transfer of angular momentum, and velocity not absolute but is proportional to the speed of the platform the code is running on.  I'm keeping it this way for the sake of simpilicty.

OK, so here's my list:


1. Detecting which mode you're running in

As far as I am aware, there isn't a direct way a Processing sketch can tell which mode it is running in.  I'm greatful to Pomax for showing me this trick which exploits type coercion to figure it out...

boolean runningInJavaScript = ( ""+2.0==""+2 );

...although perhaps this is a useful hack rather than a desirable way of going about this?  API changes are a delicate matter, so this patch is probably quite reckless ;-)

https://github.com/Antony74/Processing/commit/502865afd9b0fa0585811897a894b1aeafcae2a2


2. Doing JavaScript-specific stuff without causing a compile error in Java-mode

There are better ways of doing JavaScript-specific if you have a sketch in a web-page, but if you want a sketch to run from the Processing IDE then perhaps putting the JavaScript in a string and calling eval() is the only option?  That still left me having to comment a definition of an eval() method in and out when I switched modes, so it was a relief when I was able to move this into my Processing core:

https://github.com/Antony74/Processing/commit/047772019342a879810718feda579c89634a60b8


3. Processing IDE silently fails to open "Box2dWeb-2.1.a.3.js"

This is a pity because Box 2D is a popular API (Angry Birds uses it, though obviously not the JavaScript version), and writing simple fun sketches that make use of a physics engine is exactly the sort of thing that is likely to appeal to Processing.js developers.  I assume there's a good reason why Processing doesn't open files containing hypens or extra dots, although it worked perfectly fine or me when I tried it without this restriction, and the problem is easily worked around by renaming the file, but can we have some sort of helpful logging please?

https://github.com/Antony74/Processing/commit/7a0acabaf954ce2faa0648dd4a831ad3ddc96e3e


4. Changes to certain java source code files in the Processing core can cause very strange build errors

I wont go into detail because this has already been discussed here...

https://forum.processing.org/topic/building-processing-from-source-windows

...but it doesn't look anything like a problem caused by the source code changes, because it's run immediately, before the build gets anywhere near a compiler, and it is possible to improve upon the error message given.

https://github.com/Antony74/Processing/commit/ed73b5d683b6d173d954b6a1452bd7d3803b1686

Does anyone know if it's possible to convert curveVertcies into bezierVertices?  I want to do this because I like curveVertices but bezierVertices are more commonly used (e.g. Svg, Geomertative) because they're more flexible.

Obviously one option is to convert them by eye, which is what I've done here:




And from how that looks it's not obviously there's a relationship between the two.  I've been down into the Processing source code to see how each are drawn - and since that's taught me how to calculate intermediate points I could throw the problem into a numerical solver every time I want to make such a conversion.  Is there something more elegant and mathematically I could do?

Thanks in advance for any assistance.

    Best wishes,

        Antony

1. class Point
2. {
3.   Point(int nX, int nY) {x = nX; y = nY;}
4.   int x;
5.   int y;
6. }
7. 
   
8. Point v0  = new Point(40, 160);
9. Point v1  = new Point(40,80);
10. Point c12 = new Point(39,70);
11. Point c21 = new Point(53,43);
12. Point v2  = new Point(60,60);
13. Point c23 = new Point(68,103);
14. Point c32 = new Point(65,136);
15. Point v3  = new Point(80,160);
16. Point v4  = new Point(160, 160);
17. 
    
18. void setup()
19. {
20.   size(500,400);
21.   smooth();
22.   rectMode(CENTER);
23. }
24. 
    
25. void draw()
26. {
27.   scale(2);
28. 
    
29.   pushMatrix();  
30.   translate(80,0);
31. 
    
32.   strokeWeight(1);
33.   stroke(0);
34.   noFill();
35. 
    
36.   // Draw Catmull-Rom curve  
37.   beginShape();
38.   curveVertex(v0.x, v0.y);
39.   curveVertex(v1.x, v1.y);
40.   curveVertex(v2.x, v2.y);
41.   curveVertex(v3.x, v3.y);
42.   curveVertex(v4.x, v4.y);
43.   endShape();
44. 
    
45.   noStroke();
46.   fill(255,0,0);
47.  
48.   // Draw vertices for Catmull-Rom curve  
49.   int n = 4;
50.   rect(v0.x, v0.y, n, n);
51.   rect(v1.x, v1.y, n, n);
52.   rect(v2.x, v2.y, n, n);
53.   rect(v3.x, v3.y, n, n);
54.   rect(v4.x, v4.y, n, n);
55. 
    
56.   popMatrix();
57. 
    
58.   stroke(0);
59.   noFill();
60. 
    
61.   // Draw bezier curve
62.   beginShape();
63.   vertex(v1.x, v1.y);
64.   bezierVertex(c12.x, c12.y, c21.x, c21.y, v2.x, v2.y);
65.   bezierVertex(c23.x, c23.y, c32.x, c32.y, v3.x, v3.y);
66.   endShape();
67. 
    
68.   // Join bezier vertices to bezier control points
69.   strokeWeight(0);
70.   stroke(0,0,255);
71. 
    
72.   line(v1.x, v1.y, c12.x, c12.y);
73.   line(v2.x, v2.y, c21.x, c21.y);
74.   line(v2.x, v2.y, c23.x, c23.y);
75.   line(v3.x, v3.y, c32.x, c32.y);
76. 
    
77.   noStroke();
78.   fill(255,0,0);
79. 
    
80.   // Draw bezier vertices 
    
81.   rect(v1.x, v1.y, n, n);
82.   rect(v2.x, v2.y, n, n);
83.   rect(v3.x, v3.y, n, n);
84. 
    
85.   noStroke();
86.   fill(0,255,0);
87. 
    
88.   // Draw bezier control points
89.   rect(c12.x, c12.y, n, n);
90.   rect(c21.x, c21.y, n, n);
91.   rect(c23.x, c23.y, n, n);
92.   rect(c32.x, c32.y, n, n);
93. }