MAX/MSP java externals — Part 1

So, I’ve had a lemur for a while but this week it’s getting a new friend, a grayscale 64 monome!!! I am so excited. The potential may seem like less with this device in comparison. But, A) pairing them could be amazing B) the simplicity of the monome device allows for a much easier debugging process (since you don’t have to worry about UI creation and logic) if you’re planning on experimenting outside of the beaten path. Here’s some stuff I learned this week:

After much avoidance of adding another language to the learning list, I am biting the bullet on max/msp. The reasons of knowing it completely outweigh from-scratch development if you intend to interface with Ableton Live or even use msp to create standalone anything for audio. But, for me and my specific interests, this would be a pointless avenue without a way to also interface with java somehow for the visual stuff. Unfortunately, since processing uses the Applet, I have not found a way to integrate processing and I have a feeling it cannot be done. However here is my success using Java2d. which by the way, toxiclibs is built to be independent from PApplet so we can still use that in conjunction with Java2d.

here’s my first time at toying with all this stuff.
maxbar.zip

inside you will find a max patch and another zip called java classes. unzip java classes and place them in the classes folder under your max5 runtime cycling ‘74/java/classes directory

now you can just run the patch in max5 runtime and you will see a button. click the button, not the toggle. sorry it’s not stupid proof but the toggle is for nothing. the button should start a new jframe. now change the number input and you should see the response in the jframe. that’s it! you can change the input to be whatever you want as long as it outputs floating point numbers to the external. and the 100 at the end is a maximum so java can normalize the input.

here’s the java source. it’s really easy.
maxbar_src.zip

3 classes. the max object, the jframe and the jpanel, which hosts the graphics2d stuff. you will also see a p5 class in there. ignore that unless you have an answer to something i didn’t.

good luck! i hope this helps somebody.

Dimes Visualization – Part 3

I haven’t posted for some time but I have been busy on this. Here are a few snaps. Processing libraries abandoned. I am pretty busy working on optimizations right now since this thing isn’t capable of running on a stream of infinite entries yet.

went to monterey bay aquarium last weekend. it was completely worth the trip.

Dimes Visualization – Part 2

I’ve spent a good deal of time learning how to work with openGL the last couple days. I’ve managed to improve performance pretty dramatically with just a few lines and added parameters. It seems that openGL is severely stunted in processing regarding capabilities, so we’ll see what happens. :/

details and experimentation with curves and color (distance correlative).

Dimes Visualization – Part 1

The following is inspired by the work of Chris Harrison and the beginning of a series of pieces i will demonstrate to show my progress through this exploration.

During this work more ideas have kind of surfaced so I’m just going to run with it. This was built using the processing core and restlet framework to to access and display the coordinates from the city node data gathered from the dimes REST web service. You are seeing the first 5 or 6 weeks of their db being shown in about a minute. It continues to query the hundreds of thousands of entries over time. This is also my first experience working with multi-threading. It has been an absolute joy and even somewhat epiphanic for the sake of having a truly dedicated animation thread. More to come.

weekend highlight

I saw Death Cab for Cutie this weekend. The intensity of this show was almost too much for me to handle.

random image

exploring data visualization

Lately I’ve been in a kind of exploration mode. Usually when i get like this, I find more old things that I should have known about 5 yrs ago than anything truly new. So this time has proven no different. I am sure I have practiced many concepts of data visualization in the past but haven’t known the formal nature of the term. So, I am now back-stepping so that i can learn, relearn, apply and re-apply. It may seem painful, but this is all part of my cycle of thought: figure out how to do something, do something, and figure it out better later.

It seems like this could be a useful exploration in quite a few ways. For one, having an intimate understanding of data probably isn’t a creative developer’s strength. In the past, I considered understanding data structures and sources to be not necessary for the sake of specialization. Since I’ve been at EVB, I’ve been continually exposed to the contrary aspects of this misconception. More-so, recently I’ve been bombarded with ideas that require a better understanding of data visualization concepts and in some cases, I didn’t realize it. For instance, I bought a Lemur a few months ago and sadly I’ve had not much of a chance to play with it yet for a lot of reasons. Fundamentally, my plans are to visualize the data that is being transmitted from this device within a java/processing environment. — I will be starting with a plan to research and may need to further break down the oscP5 library before I can get there. — Additionally, any consumer generated content being managed within the sites I’ve recently worked on have been some simple form of data visualization, i.e. upload your mom’s face sites… yeah it’s a stretch but still! Lastly, and more classically, there are a opportunities both discovered and undiscovered far more plentiful than I had ever previously imagined in the social media track of our industry. And this kind of stuff is actually useful. This is particularly exciting for me because of my multiple converging passions/fascinations: motion design, generative imagery, generative sound, generative… stuff, heuristics, genome project shit, this era of sociology, experimental hardware. As vague and/or vast as this term may be, I have a good feeling that this exploration will lead me to some excellent material and new ways of thinking.
Here are a couple great places that got my heart racing:
http://processing.org/exhibition/features/koblin/
http://code.google.com/apis/visualization/

sound physics simulation anyone?

I was debating with myself on whether to write about this. But if i continue to censor everything, what’s the damn point:

Yesterday morning, I had been half asleep on the train on the way to work and i don’t exactly know how i got to the point of thinking about this. it was related to the generation of music with some of the libraries I’ve toyed with in processing, but it went way crazy. First I was picturing the contrary to common notion that sound is created from silence: sound being added or multiplied to what’s already there. So, the idea started to evolve a little and I thought how cool it would be to create a piece of music or even an instrument of sorts that is initially based on a very clearly recognized constant. Not like a rhythm or even a synth chord. A more raw sound that would be intentionally manipulated by creating interference patterns. Maybe this is another way to think about the same thing, but I guess I enjoy doing shit backwards before settling on what I’m told to do.

This got me thinking about other physical aspects of sound. To my limited knowledge, there isn’t nearly as much consideration dedicated to sound physics simulation in game development compared to visual. But they surely have a lot in common, right? Consider this: any object that has been registered to some physics simulator might have properties that express its simulated mass, friction, resistance, dampening factors, shape, etc. Forces can be applied to them. There are also properties that act like constants for the environment like gravity and maybe even some friction or resistance that is applied to anything that has a non-zero velocity. But these are constants that never change to account for turbulence created by an object displacing the air. This is one limitation but maybe we aren’t too far off this kind of computing. Or maybe we’re there already. Anyway, this all might seem complicated, but the idea is really simple: an object traveling through space collides with and displaces a number of other objects which produces a unique sound per incident. all of this is multiplied together to create the cognition of one sound in one moment of time. We might have a long way to go before this kind of computing can be done at 60 fps, but it might be a fun thing to experiment with in processing on a smaller scale.