Talk Unafraid » Processing http://www.talkunafraid.co.uk EVE Online, Ruby on Rails and Security Wed, 01 Sep 2010 17:12:31 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 ProscDMX – A DMX Multiplexing OpenSoundControl Server http://www.talkunafraid.co.uk/2009/01/proscdmx-a-dmx-multiplexing-opensoundcontrol-server/ http://www.talkunafraid.co.uk/2009/01/proscdmx-a-dmx-multiplexing-opensoundcontrol-server/#comments Mon, 19 Jan 2009 22:39:29 +0000 James Harrison http://www.talkunafraid.co.uk/?p=190 It’s a little bit of a mouthful, isn’t it?

I’ve been working on this for the last few days. It basically takes Open Sound Control (OSC) packets- from any number of clients- which specify a DMX address, value and fadetime. The server is written in Processing, and uses the oscP5 library. Right now it uses the ENTTEC USB DMX Pro adapter to talk to DMX via serial comms, plus an excellent DMX class published on the Processing forums.

Why would you want this? Well, it means you can use anything that supports OSC to control your lighting and theatrical effects. Beat-syncing music is a piece of cake, controlling from an iPhone/iPod Touch likewise (Just write a little webapp and you’re good- or use a tool like TouchOSC). It’s stable (I threw strobe commands at all 512 channels for 12 hours and it was still running just fine afterwards), works a treat, and is perfect if you’re writing an OSC app and want a quick and easy way to hook into DMX controls.

The only documentation is this: It expects a message to /set with typetag iif, in the format address (1-<unisize>, default 128), value (0-255), and fadetime (0.0-n, where n is a large float). Other than that, run and enjoy. I’ll be throwing the odd update to this up but I expect the API to remain the same. I’m using this for a project where we want to do some interesting things with a large number of LED parcans very quickly, so performance is fairly vital- it’s designed to be quick, but I’m not Java genius, so suggestions are welcome.

Using the Ruby OSC library, you can whip up a simple client in seconds:

require 'osc'
  1. c = OSC::UDPSocket.new
  2. m = OSC::Message.new('/set', 'iif', 1,255,0.0)
  3. c.send m, 0, 'localhost', 9000

This sets channel 1 to snap on. Easy, eh? I’ve not tested this with bundles but it should work fine.

You can grab the source (Processing required to run) over here on Github.

I’m under a bit of time pressure at the moment but might end up writing this again in openFrameworks. It’s C++, so much faster, and should be more flexible in terms of sheer speed. Sub-second strobes and so on should be attainable. My next hardware project? Bodged strobe controller for Arduino…. :)

]]> http://www.talkunafraid.co.uk/2009/01/proscdmx-a-dmx-multiplexing-opensoundcontrol-server/feed/ 0 Processing, Mediawiki, and force-directed layouts http://www.talkunafraid.co.uk/2008/12/processing-mediawiki-and-force-directed-layouts/ http://www.talkunafraid.co.uk/2008/12/processing-mediawiki-and-force-directed-layouts/#comments Sun, 14 Dec 2008 13:36:47 +0000 James Harrison http://www.talkunafraid.co.uk/?p=116 Happily, the EVE Online official wiki- the Evelopedia- has now gone into public beta. You can imagine, then, that there’s a lot of activity on it. I’m something of a Mediawiki fan; I’m currently using a very hacked-upon version on my laptop for notetaking and information storage, and used to contribute quite a bit to Wikinews/Wikipedia. So when the Evelopedia went live I was at it like a shot.

The recent changes pages of Mediawiki list the most recent changes to the wiki, providing information on the page edited, the edit made, the date of the edit, and the user making the edits. It’s simple enough to read through, but behind the monotonous list there’s a much more interesting picture to be found.

The final(ish) recent changes app, having been running for a night.

The final(ish) recent changes app, having been running for a night.

This is my first real finished product done with Processing. It grabs the RSS feed of changes, imports each change by adding a change node, an author node, and a page node. If the author or page already exists, it links them again via the newly added change and adds weight to the author and page nodes. It then queries the RSS feed every minute to grab fresh data, and imports any new changes.
What was going on last night? This!
The layout of the graphs is performed automatically using a force-directed layout. I used a simple physics library for Processing (traer.physics), and added the physics framework to my existing Node framework originally designed for the EVE Tactical Map. Every particle has repulsion to every other particle, except for particles they are linked to- they have an attraction and a spring whose length is defined by the number of links of the parent particle.

Evelopedia Recent Changes - Early Version
Depending on what the simulation damping setting is, it can take from 10 seconds to 5 minutes for the simulation to become stable and settle down- it’s all done in realtime, with new changes randomly appearing and being pulled towards their appropriate author/page articles.


Evelopedia Recent Change Monitor – Trailer from James Harrison on Vimeo.

Once I get the source in shape (It’s a single 310-line .pde file right now with few comments and no error handling) I’ll probably open this up for all who want to have a play with it. I’d be interested to see what a force-directed layout method would make of the EVE map, so I might end up backporting my code to the Tactical Map to see what happens.

]]> http://www.talkunafraid.co.uk/2008/12/processing-mediawiki-and-force-directed-layouts/feed/ 7 Draggable Objects in Processing http://www.talkunafraid.co.uk/2008/11/draggable-objects-in-processing/ http://www.talkunafraid.co.uk/2008/11/draggable-objects-in-processing/#comments Fri, 28 Nov 2008 21:58:22 +0000 James Harrison http://www.talkunafraid.co.uk/?p=72 I’ve been playing around in Processing to create a synth which is controlled by linking nodes together. These nodes are basically circles, with information displayed within them.

One thing I ran into right away which, in my opinion, should be a Processing core class is a lack of a Draggable class. With the help of some googling, I eventually cooked up my own, which performs quickly no matter the framerate.

This code makes use of Vectors, so it should be a very quick bit of code. I’ve had no problems using it.

Vector nodes;
  1. boolean drag_locked;
  2. void setup()
  3. {
  4.   size(700, 500, P2D);
  5.   smooth();
  6.   nodes = new Vector();
  7.   drag_locked = false;
  8.   nodes.add(new Node(20, 20,20));
  9.   nodes.add(new Node(50, 50,20));
  10.   frameRate(30);
  11. }
  12.  
  13. void draw()
  14. {
  15.   smooth();
  16.   background(20);
  17.   for(int i=0;i<nodes .size();i++) {
  18.     Node temp = (Node)nodes.get(i);
  19.     temp.draw();
  20.   }
  21. }
  22. class Node
  23. {
  24.   float x,y,mo_x,mo_y;
  25.   int radius;
  26.   boolean locked;
  27.   Node(float x, float y, int radius){
  28.     this.x = x;
  29.     this.y = y;
  30.     this.radius = radius;
  31.   }
  32.   void draw(){
  33.     fill(0,255,0);
  34.     ellipse(x, y, radius*2, radius*2);
  35.     if(over() && keyPressed){
  36.       nodes.remove(nodes.indexOf(this));
  37.     }
  38.     if(mousePressed && over() && !drag_locked){
  39.       mo_x = x-mouseX;
  40.       mo_y = y-mouseY;
  41.       locked = true;
  42.       drag_locked = true;
  43.     }
  44.     if(!mousePressed){
  45.       locked = false;
  46.       drag_locked = false;
  47.     }
  48.     if(locked){
  49.       x = mouseX+mo_x;
  50.       y = mouseY+mo_y;
  51.     }
  52.   }
  53.   boolean over(){
  54.     if(dist(x, y, mouseX, mouseY) < radius){
  55.       return true;
  56.     }
  57.     return false;
  58.   }
  59.  
  60. }

This will set up two nodes on your screen which are draggable, complete with offsetting and so on to make them behave perfectly. Hope this helps! ]]> http://www.talkunafraid.co.uk/2008/11/draggable-objects-in-processing/feed/ 0 Processing – Obsessive Camera Direction http://www.talkunafraid.co.uk/2008/10/processing-obsessive-camera-direction/ http://www.talkunafraid.co.uk/2008/10/processing-obsessive-camera-direction/#comments Thu, 23 Oct 2008 09:12:13 +0000 James Harrison http://www.talkunafraid.co.uk/?p=26 Processing is awesome, and what better way to improve a sketch like a map viewer than to give it some juicy mouse/keyboard controls?

The Obsessive Camera Direction library for Processing lets you do just that quite easily. Simply install the library and follow the guide for easy, awesome controls.

You need to be using some form of 3D rendering on your sketch already, be it OpenGL or P3D. You can do this by using the third argument to size- I use the GlGraphics renderer (an extension of the OpenGL renderer), so my setup function looks like this (more or less):

void setup() {
  1.   size(800, 600, GLConstants.GLGRAPHICS);
  2.   // use OPENGL instead of GLConstants.GLGRAPHICS here if you're
  3.   // not using GlGraphics
  4.   background(20);
  5.   frameRate(30);
  6. }

Now we move on and get down to business. We need to set up a few global variables.

// starting camera position
  1.   int x = 0;
  2.   int y = 0;
  3.   int z = 400;
  4.   // camera
  5.   Camera camera1;

Next, we modify our setup function to initialise the camera at it’s starting point.

void setup() {
  1.   size(800, 600, GLConstants.GLGRAPHICS);
  2.   // use OPENGL instead of GLConstants.GLGRAPHICS here if you're
  3.   // not using GlGraphics
  4.   background(20);
  5.   frameRate(30);
  6.   camera1 = new Camera(this, x, y, z);
  7. }

And finally, we need to set up this camera as our active camera feed in our draw function.

void draw() {
  1.   background(20);
  2.   camera1.feed();
  3.   // draw stuff!
  4. }

And there you have it- almost! So far we’ve just added a camera. Now we need a lengthy function to map keyboard and mouse to the camera movement controls.

// Function to manage mouse movement
  1. void mouseDragged()
  2. {
  3.   if (mouseButton == CENTER)
  4.   {
  5.     // Look around
  6.     camera1.truck(mouseX – pmouseX);
  7.     camera1.boom(mouseY – pmouseY);
  8.   }
  9.   else if (mouseButton == LEFT) {
  10.     camera1.tilt(radians(mouseY – pmouseY) / 2.0);
  11.     camera1.pan(radians(mouseX – pmouseX) / 2.0);
  12.   }
  13.   else {
  14.     camera1.dolly((pmouseX-mouseX)+(pmouseY-mouseY)/2);
  15.   }
  16. }
  17. // One more to handle the keyboard
  18. void keyPressed() {
  19.   switch(key) {
  20.   case 'r':
  21.     // Reset camera position and orientation
  22.     camera1.jump(x,y,z);
  23.     camera1.aim(0,0,0);
  24.     break;
  25.   case 'w':
  26.     // dolly forwards
  27.     camera1.dolly(-10);
  28.     break;
  29.   case 's':
  30.     // dolly backwards
  31.     camera1.dolly(10);
  32.     break;
  33.   case 'a':
  34.     // truck left
  35.     camera1.truck(-10);
  36.     break;
  37.   case 'd':
  38.     // truck right
  39.     camera1.truck(10);
  40.     break;
  41.   case ' ':
  42.     // boom up
  43.     camera1.boom(-10);
  44.   case CODED:
  45.     if (keyCode == CONTROL) {
  46.       // boom down
  47.       camera1.boom(10);
  48.     }
  49.     break;
  50.   }
  51. }

Right, finally done. This will map your mouse as follows:

  • Left mouse button looks around
  • Right mouse button moves backwards/forwards
  • Centre mouse button (wheel click down on most mice) is left/right movement

Your keyboard also gets some controls:

  • r – Resets view to the default position
  • w – Moves view forwards
  • s – Moves view backwards
  • a – Moves view left
  • d – Moves view right
  • Control – Moves view down
  • Space – Moves view up

All up/down/left/right is relative to the view axis.

Hope this helps someone else trying to achieve the same thing with Processing!

]]> http://www.talkunafraid.co.uk/2008/10/processing-obsessive-camera-direction/feed/ 1