aut.ologo.us digital works

Objective C Perlin Noise

2011-09-02T13:25:00.000-07:00

As promised, here is the port of the Processing.org's Perlin Noise code to Objective C.

This is beta code so use at your own risk. It's what I used for the HTorsion part of the Grow Your Own app.

It works almost the same way as the Processing.org's version. You can find the reference for that over here:

http://www.processing.org/reference/noise_.html

For some horrible sample code, here's what I have for one of my functions:

noiseVal = [noise noiseX:(x1 -xCount)*noiseScale Y: (y1 -yCount)*noiseScale Z:noiseCount];

So, as you can see, it's similar to the Processing.org version.

Anyways, the source of the code can be found here:

http://aut.ologo.us/source/Noise.zip

Please don't expect any help on how to implement it. It's not because I don't want to help. It's because I have a horrible time looking at my old code and figuring out what exactly did I do to get it to work.

Grow Your Own

2011-07-10T09:41:00.000-07:00

"Grow Your Own" iPad App

This is the second in a series of art-centric applications I am developing. Released on July 1st, it actually did fairly well in the "Entertainment" category. It hovered around the top 100 in the US charts and reached top 50 in other regional charts. Not bad for something that didn't have any advertisement or press to it.

The app is actually 2 algorithms in one. The first is a variation of the Brooklyn Eels algorithm and the second is the port of the HTorsion algorithm.

This app required me to port the Perlin algorithm from Processing to Objective C. In a future post, I fully intend to release the source for that so other generative artists can use it.

Development of this app really made me focus on the memory management of the application. With the limited 20 Mb of memory an application is allowed to use, I had to learn how to manage memory better. Spent about 2 weeks trying to trace a memory leak.

Well, I feel like I'm growing as an Xcode programmer. Unfortunately, I still find the process very tedious. I might explore using Cocos2D or Corona SDK in my future developments.

In the meantime, below are sample images generated by the app:

Honey, does this dress make me look fat?

2011-02-20T08:54:00.000-08:00

  "Honey, does this dress make me look fat?" iPhone App

At one point in every male's life, they have been asked this trap of a question. I tried checking the App store for an app and was surprised to find that there was no app for that.

I figure it would be a quick program to create an app that would analyze someone and see if the dress makes them look fat so I gave it a try. This app is a gag gift. Results aren't meant to be taken seriously. In reality, the answer is determined by the user. All this app does is deflect the blame onto the app and away from the askee.

If you have %.99 to blow, give it a whirl. :-)

Click here to see the App Store page

Tempvus Version 1.0.2

2011-01-29T11:27:00.000-08:00

So I failed to mention that the Tempvus iPhone app did fairly well considering the lack of promotion for the app. It is currently free at the moment.

As promised, I ported the app to the iPad with version 1.0.2. I feel that the platform serves the art world the best.

Here is a quick screener/demo of the application and along with some screenshots:

Tempvus App

2010-12-17T07:04:00.000-08:00

Tempvus 1.0.1 iPhone App

Tempvus is an interactive art project/toy involving flowfields. It’s based on interaction-based behavior which manipulates the final output of the image.

You can interact with the app to add spinner objects, change the direction of the spin, the strength of the spin force, change the color, or move the graviton object.

You can download the app by clicking this link.

Challenges of Creating the First iPhone App

2010-12-17T06:35:00.000-08:00

Five months ago, I took the plunge and decided to take my work to the iPhone. My intention was to create apps that would be displayed on iPads. My vision was to have a gallery of apps on the iPad.

It took me a while to get this project done due to technical, transitional, financial challenges. It also took a long time because I wrote the App only during my spare time. As programming code is only a hobby and not a fulltime job(I'm a Cisco Network Engineer by day), I can only sneak in a few snippets of code every day or two. There were times when I didn't touch the code for weeks as I simply did not have time. I'd rather spend that time playing with my baby than code.

So here are a few challenges I encountered:

Financial Challenges

The ultimate goal of this work was to get these apps to the iPad. At the time when I first started writing the app, I only had an iPhone. Writing an app for the iPad would mean I would need to plonk the money for an iPad. This wasn't too much of a problem. My wife wanted an iPad so I got it for her with the intention of using her iPad for development.

What I didn't know was that for development, that means I would need to home her iPad to my Mac instead of it being homed to her PC. This provided challenges because that means I'll have to wipe her apps each time I want to develop on the iPad and it also means she'll need to wipe my code and apps whenever she wants to use her apps. It's quite a mess.

We both decided that we'll need 2 iPads. One for her and one for me. I needed one for development so eventually I had to wait until I can justify the purchase of another iPad.

Transitional Challenges

The next challenge had to do with porting my Java Processing code to Objective C code. I wrote C/C++ code 13 years ago and I barely remember how to code with C/C++ and OpenGL. I had to read a couple of books to learn how to use Objective C.

The challenge was porting my Java code to C++ code. My approach was a straight conversion of the Java classes to Objective C classes. This was a straight translation of code without any change in the way the algorithm is implemented.

Upon completion of the translation, I soon found out that I had a lot of typos in the equations and algorithms which caused a lot of problems during the translation. It was difficult tracking down where the errors in the calculation were occurring as there was a lot of code to eyeball. Eventually I found all of them and got them fixed.

One of the major differences between Java and Objective C is garbage collection. I take this for granted when coding with Java. Objective C has no automatic garbage collection so your memory management skills have to be on point. If you don't manage memory properly, your app will crash a lot. Relearning this skill wasn't too difficult but it sure made me learn how to be a better coder.

Technical Challenges

When the code was finally transitioned, I soon found out that a straight translation will not work. For one thing, the coordinate system for Java and OpenGL are different. Java's default coordinate system is the actual pixel dimension of the window. OpenGL has a scale range of -1.0 to 1.0. This means I had to re-tweak the code to accomodate the differences. Later on, I found out I can rewrite the OpenGL code to mimic the coordinate system of Java.

The next challenge is that I needed to optimize my code to the maximum. I've never coded for a system with limited resources before. I'm used to coding on powerful systems like Macbook Pros and never had to optimize my algorithms that much.

Coding for an iDevice is different. You have limited CPUs and memory to play with. I had to take my original code apart and optimize it. I had to re-write chunks of code so there are fewer loops and fewer function calls. I also had to re-write some functions in straight C to make it faster.

Objective C is a dynamically linked language. Although this is a feature of a language, it is also one of the things that slows it down. For each function call, the system has to allocate a new memory pointer. So for a huge for-loop, each call to a function takes a lot of resource and time to allocate the memory space.

Optimization was where I spent most of my time. Through function tweaks, compiler tweaks, and reconfiguring the code to have OpenGL use the GPU more, I was able to make the app faster than it's original form. I'm still not as happy as I want but it's acceptable right now.

---

The app is currently under review from Apple so it should be launched soon.

Eels of Brooklyn

2010-12-17T06:26:00.000-08:00

Been busy with working on the iPhone app. It's currently under review and it should be up on the iTunes store anytime now. In the meanwhile, I've been keeping myself busy with some more generative work.

The following are images from my Eels of Brooklyn work. It's currently unfinished and is still a work-in-progress:

I was inspired by a visit of the Brooklyn Acquarium.

Expanding the Medium

2010-10-03T08:18:00.000-07:00

My original interest in computational design was interaction. I used to program a lot of interactive toys similar to what was popular in the early 2000s when Flash was getting popular.

My interest in interaction did not hold because it started to move towards developing 'final' images as art. So interactive art was only a means to develop static art. I've always wanted to be some sort of artist and I couldn't really draw. I stunk with Photoshop and the only joy I get with generating art was in programming. After a long while with tinkering with interactive arts, I started focusing on "finished art."

My move towards art on a static medium is what prompted me with starting this blog. I still develop a lot of interactive toys. All images posted on this blog are generated with interactive algorithms. The only difference is that the interaction is solely limited to me as opposed to posting the interactive piece online for everyone to play. This gives me more ownership of the images.

After a few years of this, I am a little bit frustrated that the Algorithmic/Generative/Computational art genre has not gained a lot of acceptance in the world. It is still a growing genre and is experiencing a lot of resistance in the art world. The growth pattern is akin to the resistance to photography as an artform.

I sometimes find myself arguing with critics about the legitimacy of this particular art and I yearn to find more exposure for this genre.

Enter the iPhone.

A few innovative souls like Glenn Marshall and Scott Snibbe has started using the iPhone as a platform for their art. Why not? With the advent of the iPad, it is a viable platform to display your digital art.

I aim to take advantage of this.

So the plan for the next couple of months is to port some of the interactive toys I created to the iPhone and either give it away for free or sell it for a dollar. The intent is to generate awareness of the brand. I'm hoping people will like the little art-app enough to maybe...just maybe purchase a print or two. Of course, if the art-as-app app takes off, I'm hoping to get a little bit of return from it as well.

So...that's the plan for now. We'll see where it goes.

Below is the first iteration of the first App I am producing. It should be ready within a month and available for free.

Watch out for the new interactive wing of http://aut.ologo.us called http://www.autologousinteractive.com.

http://www.autologousinteractive.com will be the official website for the iPhone projects that I will be working on. I'm hoping to port some of my art-apps on the site. Also have a couple of games in mind as well.

Wild Things

2010-09-19T05:53:00.000-07:00

Wild Things

processing.org java application, October 2009

This work is another application of the attractor program. It actually started off as a study of vector physics but as I started learning it, I started applying it right away.

The concept is simple. Random particles are generated on the screen. Each particle is attracted to the nearest attractor. As the particle heads towards the attractor, it may encounter a spinner particle. Spinner articles exerts a vector force on the particle causing the particle to spin around the Spinner.

Each attractor and Spinner has a corresponding twin so that there is a balanced set of particles on each side of the screen. When the particle gets between a certain distance to the attractor, it regenerates at a random coordinate.

Particles are coded to leave a trail of their path.

The intended results are to create an image that resembles a mask or face of some sort. My original intention was to create masks that would be used for Halloween.

The following are more sample images:

Scholastic Publication and Facebook Fan Page

2009-10-08T06:42:00.000-07:00

Hello. Two quick updates:

Scholastic licensed a modified image of HTorsion for one of their children's books.

The other update is that I created a Facebook fan page because I'm being bugged by people to create one. :-)

http://www.facebook.com/pages/Jim-Soliven/132531397634

I'm a little shocked about how many people fanned it already. Pretty humbling.

FFields

2009-08-17T16:25:00.000-07:00

FFields

processing.org, java application, July 2009

More playing around with the Perlin Noise algorithm. The difference this time is that I am diffusing the background each iteration. That smooths the perlin trails to make it look more vapor-like.

I'm debating whether I should offer these as prints. It's currently my desktop wallpaper.

Here are a few more FField images:

Perlin Canyons

2009-08-17T16:15:00.000-07:00

I was playing around with Perlin noise again and decided to try the usual Perlin landscape generator. The following is just a Perlin implementation that uses a height-based color sampler. The results look like the Grand Canyon.

HTorsion Color Wallpaper

2009-08-17T16:01:00.000-07:00

I'm happy to offer yet another set of wallpaper prints courtesy of Maxalot. The direct link to the prints can be found at http://www.maxalot.com/xpsf/jimsoliven_wllppr_colour.shtml. Check it out!

Open Edition Store

2009-06-13T06:36:00.000-07:00

I'm still working on the "print store" aspect of my site but I do have a basic Open Editions store open at jim-soliven.imagekind.com

It's still a work in progress but I will update when I finish the Limited Editions shop and the original editions shop. I still have to work out how to integrate all this into my website.

Rules of Order

2009-06-07T08:56:00.000-07:00

Rules of Order

processing.org, java application, April 2009

Imagine a plane leaving trails in the sky at the same time it is dropping spray paint onto the ground. That is the same process that each moving pixel does in this work. Each object flies about 30 pixels above the canvas. As it moves across the plane, it leaves a trail on the canvas and it also sprays a fine mist of pixels into the air. Given time, the spray lands on the canvas and leaves a mark.

This piece was a quick job since I am sticking to my modus operandi of keeping it simple. I love discovering new techniques in creating digital art and this piece is really more of a study of a new technique. The new technique is using multiple canvases in the same process. I suspect I will use this technique more in the future.

Here are some more images developed by the algorithm:

Above is an extreme closeup of the details. Notice the grainy nature of the image. The graininess of the image is caused by the individual pixels in the pixel spray process of the algorithm.

This is the earliest form of the algorithm. The screencapture was caught in process. Most of the other images generated are screencaptured after the complete image is done.

Below are the more colored variety:

The rest of the set can be found here

Change in Focus

2009-04-07T18:59:00.000-07:00

I haven't updated in a while. There's a good reason for that. I've been working on programs and algorithms that were overly grand and got too complicated and big. As I spend more time working on the project, I somehow lost focus.

The more I lost focus of the project, the less interest I had in finishing it. The less interested I am, the crappier the work looked. The crappier it looked the more crushing the disappointment.

I decided to change my modus operandi on my creations. I decided to keep things simple and keep things short. For each work moving forward, I decided to outline a few simple rules for the program and stick with it. The Contention project is an example of the work.

One day, I'll post the complex crappy projects I was working on.

Contention

2009-04-07T18:22:00.000-07:00

Contention

processing java application, april 2009

The premise is simple. I wanted to trace particles as they race towards another particle with the intention of destroying them. Got the idea from the opening scene of Lord of the Rings:The Fellowship of the Ring.

I read somewhere that Steve Jackson had computer programmers create an algorithm to simulate the opening war scene of the movie. Instead of rendering each soldier by hand, he had the effects team create elves that would react when the orcs approach them. This saved time on rendering but it probably ate up CPU.

The concept for Contention is similar. Two teams of particles race towards another particle of the opposing team. Each particle is strengthened by their teammates around them. The more teammates around them, the stronger they are. Once they reach the opposing target, they "roll dice" to see who wins based on their strengths. If the particle wins, they choose another target. If they lose, they start over.

Some basic behaviors were programmed to each particle. Each particle draws a line to any other particle near it. The color of the line is the average of both or all particles around it. Lines are also drawn between the particle and its target particle.

The algorithm was quite simple and this only really took about a couple of hours to draw up. I had some old class files that I reused for this so this was pretty quick and gratifying.

Below are other images created by the algorithm. The original size of each creation is 4800x3600.

Radial Formation of Contention

More images found at my Flickr site

Marduk Project

2008-11-19T16:51:00.000-08:00

I still love using the generative aspects of computer programming to generate cities. Countless hours were poured in the past to create programs that generate city-like structures. A few of the endeavours has made it to this blog in the form of TFGORC.

I kinda wanted more than just an aerial-view-generating program. I wanted a more 3D looking image. The other thing was that I was a little lazy. I've tried using Blender to generate 3D images but dammit, learning it was too much of an effort for me.

I tried scouring the web for free 3D textures that could be imported as .OBJ files into Processing but the ones I found didn't work properly with Processing.

Enter OGLE. OGLE is an OpenGL call interceptor. It basically intercepts any calls to OPENGL being used by applications and logs them for the user to peruse. Plenty of amazing things on the OGLE site has been created by this lovely programs. Among applications that OGLE has successfully worked with in the past is GoogleEarth, World of Warcraft, Second Life, and City of Heroes.

Of course, once I read the documentaion I decided that this was something I can do because it's easy. The steps basically went like this:

-launch GoogleEarth
-find a city that has 3D structures.
-hit your super powered ctrl key
-get the resulting ogle.obj file
-import into processing.org
-increase the scale to something big like 450.0.
-manipulate image at will

It's that simple. The above image is generated using midtown NYC as the model. Manhattan seems to be one of the more fleshed-out areas of GoogleEarth. Some more images were generated below. You might want to click on them to see the bigger versions:

This is a rendition of Columbus Circle in New York City. That big area in the front is actually Central Park. GoogleEarth's 3D structures seems to end at around the Central Park region.

This is an area of Manhattan I'm familiar with. This is the Battery Park area near Wall Street. I see these buildings everyday on my way to work.

This is Chicago. You can see the Sears Tower in the back.

Seattle's seaport area.

There are other cities I want to try out in the future. I was a little bit disappointed that GoogleEarth doesn't have a more fleshed-out Paris, Rome, and London. I think Barcelona and Amsterdam is well done so I might try those in the future.

This project is named Marduk because Marduk is the ancient Babylonian god of the city.

Some ZEBO Craziness

2008-11-19T16:37:00.000-08:00

I've recently started using Sunflow via P5Sunflow. Naturally, I wanted to take out my old ZEBO characters and apply the 3D renderer to them:

ZEBO and his pal Rex "The Recognizer"

Just plain old ZEBO".

Eventually, I decided to scrap the old Maximillian model from The Black Hole and replace him with something else. The next member of the Zebo family is the combat tank from the old Atari 2600 game, "Combat".

In the end, I put them together and kinda placed them in the old Zaxxon battleship environment just like how I would place any other megalomaniac robot who's bent on revenge on humankind:

I use the above image as my wallpaper on my laptop. You could get the large image from here: http://www.flickr.com/photos/autologous/2953438856/sizes/o/in/set-72157605544742542/

Brooklyn Museum of Computer Art

2008-11-04T17:33:00.000-08:00

HTorsion in Brooklyn's Museum of Computer Art
Double Exposure Exhibit
Nov. 4 - Nov. 26 2008

A copy of HTorsion is part of Brooklyn's MOCA Double Exposure Exhibit. The exhibit begins on Nov. 4 and ends on Nov. 26, 2008.

Opening Reception is on Nov. 8, 4-6 PM

MOCA is located at
MOCA Museum Gallery
139 11th Street, Brooklyn NY

More information can be found here:
http://moca.virtual.museum/physical.htm

Hey Good Looking

2008-10-19T11:05:00.000-07:00

Hey Good Looking!

processing java application, october 2008, jim soliven

"Hey Good Looking!" is a revamp of an earlier sketch that I gave up on in the past. HGL! was initially another attractor algorithm where one particle is attracted to a certain point and heads towards that destination point. The early version of the algorithm didn't really generate any interesting images. Just a bunch of scriggly lines on the screen.

About 2 years after the initial sketch, I revisited the piece and made some changes. The first change I did was I increased the number of particles by a factor of 20000. The second change was I added more destination points. The third change was I made each particle go from one destination point to the other rather than randomly picking one of the destination points and heading over there.

The surprising aspect of the piece were the 3D images that it seems to generate. Not all iterations generated 3D illusions but some of them did. After the revelation, I focused the code to increase the chances of generating the 3D images. The results impressed me a bit:

More images can be found at this Flickr! Set

Art

2008-10-10T16:30:00.000-07:00

I have never considered myself an artist before. In fact, I felt some shame for thinking that I am one that qualifies as an artists. I considered myself more of a programmer who indulges in making "pweety pictures" with his computer. I consider the people I look up to as artist but I feel really weird whenever someone tells me that I can consider myself an artist since I am no longer an admirer of someone's work but a contemporary of their work.

My old friend, Chris Soprano(a phenomenal illustrator) hammered that point to me and I guess I will concede. To that end, I changed the link on the front page of my site from "About the Programmer" to "About the Artist."

Sheez, I still feel awkward seeing myself in that light.

Snap To Grid

2008-10-10T16:28:00.000-07:00

I will be participating in the Los Angeles Center for Digital Arts' Snap To Grid group exhibition from October 9th to November 1st, 2008.

TodaysArt08 Processing Light Exhibition

2008-10-10T15:46:00.000-07:00

TodaysArt 2008: Processing Light
September 26-27, 2008
The Hague, Netherlands

I was given the opportunity by Maxalot's Max Ackermann to participate in The Hague's TodaysArt08 Festival. TodaysArt08 is a 2 day long indoor and outdoor celebration that features artists and artisans from all over the world. Invited generative artists for the Processing Light exhibit had their beautiful works displayed on the side of the Hague's Central Station building.

Artists invited are Neil Banas, Dextro, Eno Henze, Tina Frank, Marius Watz, Pedro Mari(defetto), Quayola, CEB Reas, Toxi, Lia, and Mike Paul Young

Never in any of my thoughts would I have dreamt of the possiblity of seeing any of my work in such a large format as a building wall. Due to work circumstances, I was not able to see the finished product myself although I think it would have been super to see mine and other people's work projected onto the side of the station. Maxalot and Dextro were kind enough to provide us with these candilicious images for our enjoyment. The following are images of an HTorsion image generated solely for the Processing Light exhibit.

(whee! my name in lights!)

(the large projectors used to project the images).

More images of HTorsion can be found here at my Flickr page: http://flickr.com/photos/autologous/sets/72157607763844711/

Images of the other artists awesome work can be found at http://www.maxalot.com/xhbtn/ta08.shtml

The Fabled Ghettos of Rockland County

2008-09-24T18:23:00.000-07:00

The Fabled Ghettos of Rockland County

processing java application, january 2008 to september 2008

The Fabled Ghettos of Rockland County(TFGORC) series is a variation of the old Urban Terrain Generating Project that was started on January 2008.

The premise started out simple enough. Start out with a random number of lines and keep extending them. Should any of the lines hit the edges of the screen or intersect each other, randomly generate another line attached to a previous one at a right angle.

The image generated were interestingly very city-like. Iterations of the program along with variable changes such as the number of lines starting out, the angle of the lines starting out, or even the maximum number of lines generates various types of urban aerial point-of-view:

iteration: start with 1 line and max with 500 lines

iteration: start with 10 lines and end with 5000

Eventually, I was inspired by Spiderman and decided to arrange the beginning lines in a circle. The hope was to generate web-like structures:

Another variation is to arrange two circular points of origins for the beginning lines.

The images generated by this simple algorithm are all very interesting yet the rules of the generation are very simple. Eventually, after finding some time, I decided to put some effort in coloring the images. The color swatches for the following images are taken from Flickr images of Rockland County.

Coloring of the images was done in 3 phases. The first phase draws the lines. The second phase colors the lines. The third phase redraws the finished lines in the first phase. The second phase tends to color over the lines so they had to be redrawn. Since the code was geared towards saving memory and not cpu cycles, the finish product took a really long time. The images below averaged somewhere between 8 to 16 hours. This is due to each line being checked in each iteration. It's terribly inefficient but I might be too lazy to fix it.

I added a textured background tile to create the organic look of these iterations. Below are the better images generated by the algorithm so far. Most of these images and future images generated with algorithm will be found at its Flickr site:

The piece is partially inspired by an exposure to some of my friends in Rockland County, NY. When I first met them, I thought they were from this legendary place called Rockland County where the life was just as ghetto and hardcore as Compton, Harlem, or East LA. One could make the comparison that these colleagues of mine could have passed for the Bloods or Crips.

It wasn't until I decided to drive down to their "hood" and pick one of them up right before we went to college. I was expecting half-burned crack houses, drug dealers on a corner, and the threat of carjackers exist at every stoplight. Five miles into the county I saw neither of these. All I saw were huge suburban houses surrounded by lush gardens and flanked by BMW and Mercedes cars.

I really didn't get it. How did these good old suburban boys mistake themselves as gangbangers? I still blame their fascination with "Boyz N' Da Hood"( a good movie btw) and "Menace II Society". Personally, I think they probably like "Don't be a Menace To Society While Drinking Your Juice in the Hood."

Zebo. The Zaxxon Boss

2008-09-10T19:07:00.000-07:00

Zebo. The Zaxxon Boss
3600x1200 Image
Download Here

The 80s holds several sci-fi icons in my head. The Tron Recognizer, Maximillian from the Black hole, and the first video game I have ever fought-The Zaxxon Boss.

I was fascinated by comic books when I was a kid and I spent many afternoons wasting paper inventing and doodling superheroes. As time passed by, my skills in illustration got better and I started carrying around a Moleskin to keep my illustrations.

Eventually, the realities of my computer science studies took away the time for me to draw. I stopped illustrating for a long, long time and my skills has considerably waned. As of right now, I have a small fraction of skills as I used to have when I was in college.

On the other hand, I fell in love with programming and eventually I attempted to mix the two. It is a little bit sad to say that I feel more comfortable putting polygons together in a program than it is to pick up a pencil and draw. To that effect, I decided to draw together three of the coolest robots I have known in the 80s.

The Tron Recognizer was one of those vehicles/robots where the visage just strikes me. It just looks so unusual. Their role in the Tron movie was also somewhat mysterious. Maybe it is that mystery that fascinates me about them.

Maximillian was just one of those scary robots that really freaked me out when I was a kid. That scene in The Black Hole where he skewered a man was one of the first times I remember where I covered my eyes while watching a movie. Nonetheless, I liked him because he was just so menacing. Not to mention he looks like one of those Star Wars Imperial Royal Guards. Anything Star Wars is a bonus in my book.

Then there's this homage to 1950s sci-fi robots. I don't even have a name for it. I just call him the Zaxxon Boss. Zebo for short. I have many fond memories of me piloting my spaceship on this faux 3D plane and shooting this annoying boss of a monster down. Of course, you didn't really shoot him directly. You aim for that heat-seeking rocket that he is powering up to launch at you. Nevertheless, the funky design of this robot left an impression on me. He just looked weird and memorable.

So I decided to create some polygon models of these three and combine them in an image. The original backstory of the image can be found on its Flickr page:

Zebo, the Zaxxon boss, has decided to get even with that pesky rocketship that destroyed his interstellar bachelor's pad in the 1980s.

After investing in Google stock, he has decided it is time to get even. With his gang of friends from the 80's, he has arrived to wreak vengeance on those folks that played Zaxxon and blew him up to smithereens.

The imagery is supposed to portray Zebo as a gigantic general-type leaderbot with Maximillians as his field commanders and the Recognizers as the infantry.

I had a lot of fun creating this image. It took a lot of time since it is polygon-based but it was certainly worth the 30+ hours coding every polygon vertex on it. I still have the master files on this so I might revisit the models at a later time and create even more images.

In the meantime, enjoy the 3600x1200 image.

HTorsion Wallpaper

2008-08-17T07:52:00.000-07:00

HTorsion WallPaper

Max Ackerman of Maxalot's fame requested a unique series of HTorsion prints that would be transformed to wallpaper-sized prints. The process in itself presented a series of challenges since I am really new to making print quality images.

The first challenge was how I could convert the program to scale the originaly 3200x1800 image to a 30000x15000 image. The second challenge was getting the Perlin Noise function to behave similarly to the 3200x1800 version.

The first challenge was handled by attempting to re-write the code to generate images to the biggest print size my poor Mac could handle. Unfortunately, the maximum pixel size my mac could handle was 10000x6000. The limitation is imposed by the maximum heap size Java could run on a Mac. I can only allocate 2 Gigs worth of memory for Java on a Mac Powerbook. This wasn't good enough for a print that would be around 7 x 5 feet in dimension and also made me squint in frustration for the money I wasted on getting 4 gigs of RAM on this laptop.

I played with scanning the image at 10000 DPI but I wasn't even certain that this would work and could potentially cost me more money than I care to spend. A ton of Googling eventually led me to a solution that I have seen before in the Processing.org's discussion board that somehow veiled itself to my awareness.

Marius Watz's TileSaver class was a godsend for me. Using the code provided by Mr. Watz, I was able to create images that are about 27000x15000 in size. The 27000 limit was really the biggest I could get it due to the heapsize limitation issue. The rest was easy. A quick GIMP manipulation would eventually give me a 27000x15000 image at 300 DPI. The file sizes were huge as each image was about 1.3 gigs big.

The first challenge was daunting since the limitation was due to hardware. The second challenge was relatively minor but it required a lot of brain work. The problem inherent with Perlin Noise was it is a pseudorandom number generator. The original image produced for HTorsion worked out great since the arguments used for the method worked for generating Perlin numbers that works aesthetically with a 3200x1800 image. Unfortunately, the same arguments will not work for the large footprint.

It took a while for me to figure out how to generate the correct arguments for the print. The time spent on determining it was largely due to the huge amounts of time it took to render each image. For each series of arguments passed to the method, I would have to generate an image and determine if the results are good enough. Each render took about 20-30 minutes. So for each decent print, I had to go through 10 ugly ones.

The solution came to me while I was in a haze one morning. It was soooo simple that I was flabbergasted at how dumb I was. Why go through all this number guessing when all I really had to do was use the scale function to convert the 3200x1800 image to 27000x15000? Oh my goodness! It was so simple! I literally hated my one-track mind for this.

With the two solutions finally figured out, I sent 4 DVDs worth of images to Max and about 1.5 months later the project was completed. I felt a little bit odd when I was asked to write something about myself since I'm really new to the game and I consider myself a curious programmer more than a generative artist. The odd thing was talking about myself in the 3rd person while writing about my bio. Compared to everyone else on the site, I felt really small but I guess that these are the baby steps I need to take for me to reach a goal I set for myself 2 years ago.

Overall, I am extremely happy with this project and I hope someone buys a print or two from Maxalot since I have to justify the amount of time I am spending coding this rather than spending more time with the lovely wife.

Wallpapers can be bought here: http://www.maxalot.com/xpsf/jimsoliven_wllppr.shtml

Lucretius - De Rerum Natura

2008-08-17T07:39:00.000-07:00

One of the images from the Brownian Motion Set has been picked up as a cover for a University of California Press publication.

More information regarding the book can be found here.

The Brownian Motion set was created around 2005. It was coded to satisfy my curiosity of how Brownian motion would affect a particle that travels towards a specific destination. My findings tells me that the particle would ultimately fail to reach its intended destination since the effects of the Brownian motion really derails its tracks.

Derailment doesn't really produce an interesting image and for a while I was a little bit disappointed. What I added to the code was an attribute of 'intent' to reach the destination. This way, the particle would eventually be within the vicinity of the destination.

I was mildly satisfied with the result. I put to use the term "mildly" for some reason my mind blanks out like a New York City power outage whenever I choose a color scheme for this piece.

This set will eventually be re-visited once I determine a proper behavior for the particle.

The Chalfont Swirl

2007-11-11T11:27:00.000-08:00

processing java application, october 2007, jim soliven

An old and simple program written in 2005 and revamped in 2007. The Chalfont Swirl utilizes brownian motion to create the fluctuations on the path that the particle traverses. The motion of the particle is randomly increased or decreased as it traverses towards a destination.

I love simple pieces like these because the code doesn't take more than a few lines but yet the results are amazing.

Sample images below:

Eye Magazine Issue 65

2007-10-25T19:35:00.000-07:00

Two pieces of HTorsion can be found on Eye Magazine Issue No. 65. One made the backcover and the other one has a snippet of article attached to it. It's a little bit embarassing since they put my work next to more established artists.

Smoke Series

2007-06-13T17:37:00.000-07:00

processing java application, june 2007, jim soliven

Started delving into Ken Perlin's noise algorithm and applied it to the Torsion series below. The results are amazing images which resembles smoke. The beauty of coding generative algorithms is that you are always surprised(sometimes frustrated) by the results. This series turned out a lot better than I expected.

Sample images below:

Wiresquid Network Sniffer

2007-06-04T18:39:00.002-07:00

processing java application, july 2007, jim soliven

more images found on my flickr

Wiresquid is Wireshark's illegitimate kin. It is a graphic visualization of a network packet "flow" that occurs during a TCP/IP session. Each network packet that flows from the source receives a response or two from a destination. Each transaction is represented by a tentacle that forms from the construct.

A list of features for Wiresquid follows:

Each time you send a packet to the network, a destination host responds to the request. The request can be broken down into smaller packets or TCP windows. Each collection of packets is a flow.
For every flow leaving your macine, it is represented as an object that leaves from the "src".
Each response to a request from the destination host is represented by an object that flows towards the "src". Each flow is color coded depending on the IP address of the responding host.
A response from the host is represented by a tentacle from the "squid" construct in the middle. Traffic flows outside the range of your IP address subnet mask is represented by a white tentacle. Traffic that is local to the IP address range is marked by green.

I work as a Network Analyst during the day. In my day-to-day operations I find it necessary to sniff traffic on a wire to examine packets and analyze the network. I've always been fascinated by the possibility of using the network as a source of data for graphic visualization purposes. Wiresquid is my first attempt at furthering my interests.

Files and Source Code:

application.macosx.zip - Wiresquid macosx application. Requires OpenGL, Java 1.5. Before running the application, you'll need to change the permisions on certain files to allow the application to run as root. Open a terminal window and type "sudo chmod 777 /dev/bpf*". Enter your password then the application should be able to run.

application.linux.zip - Wiresquid Linux application. Requires everything that the MacOSX application needs. I didn't really test this application since the two Linux servers I play around with are Pentium 800 Mhz machines and do not support OpenGL(boo! No Beryl!)

There is no Windows version of the application. The reason being is that all three of my windows machines cannot run the application due to a bug on the CarnivorePE software.

Torsion Series

2007-06-03T14:40:00.000-07:00

processing java application, march 2007, jim soliven

This is a simple dynamic particle attractor series. The simple algorithm follows a particle as it tries to follow a target point. I was originally trying to come up with an algorithm that will replicate a twine of rope but the resulting work came out to be something totally different.

The original series was created in 2005. It was a series of 3200x2400 images that I saved on my Mac Powerbook which was subsequently erased when I had to reformat to the mac due to security issues. My Mac powerbook actually got hacked! In my haste to secure the Mac, I inadvertently erased all the original printed work and the algorithm that generated it.

I liked the result of the work so much that I decided to recreate the program in 2007. It wasn't easy. The underlying algorithm is the same as the original but I guess I'm not implementing it the same way. The subsequent work generated images that wasn't as interesting as the original. The latest images are 5400x3600 images. When I get a chance, I'm going to print the images on rice paper.

Some sample images:

more images found at flickr

Beastbox Beatbox

2007-01-29T17:48:00.000-08:00

processing java applet, march 2004, jim soliven

600 x 520 applet

I've always been fascinated with making music. I have a special love of making synthesizer music. I've loved making them eversince I bought my Yamaha RY-30 drum machine. My interest in synth music is pretty old school. I support hardware synthesizers and have never used softsynths. Due to cramp living conditions, I think I might make the move.

Beastbox beatbox is a multi-threaded java application I wrote in 2004 to explore new interfaces in creating music. The applet is a CPU hog due to 8 threads running simultaneously and you need a fairly beefy machine.

I recently found this applet while cleaning up my files and this is one of my favorite creations. The applet was part of a bigger suite of applications that I wrote to explore new ways in creating music. Those other applications were lost when my server crashed.

One day I will probably revisit this interest in creating new instruments using software. Hope you enjoy.

True Love and the Search for the Perfect Mate

2006-09-04T08:22:00.001-07:00

processing java applet, september 2006, jim soliven

900 x 700 applet

"I'm just an object in a mathematical 2D plane that is following programmed behaviors" - That's the conclusion I came up with during an trivial emotional episode. "True Love" is a visual representation of simple rules created to emulate the search for true love. This system is designed with the following behaviors in mind:

Each person is either Male or Female
People who are single are in the dating scene
People who are coupled are outside the dating scene
A male is always constantly searching for the perfect female partner
When a male encounters another female in the field, the female is analyzed. If the female is compatible with the male, the two of them gets coupled
A coupled male will break-up with their partner if he encounters a more compatible single female
Breaking up and going out are emotional stages that bursts with energy

This translates to the following rules:

Each object is either Male or Female
Each Male scrutinizes every female within a fixed N distance
Each hookup is marked by an explosion of white
Each breakup is marked by an explostion of black
Couples' movements are synched and are not random
A weak force gravitates single objects towards the center
Coupled objects gravitates away from the center
Couples are linked via a red line if they are outside the circle of dating
Couples are linked via a uniquely colored line when they are in the circle

The following are sample results:

The following are images generated when couples are made to have stronger bonds thus less prone to breaking up. The images look less chaotic:

Daily Politics

2006-08-26T09:31:00.000-07:00

processing java applet, august 2006, jim soliven

700 x 1024

Daily Politics is a visualization of daily interactions between nations. Originally written to keep track of just how much the United States assert its influence over other countries but was later expanded to track the interaction between all nations.

Nations are grouped by their regional locations(i.e. North America, Asia, Europe, Africa, South America) and each nation is assigned a random color.

Daily Politics' underlying mechanism scours various news websites and processes World News entries to determine nations interacting with each other. The data is gathered, formatted, and written to files from which the applet feeds from.

Daily Politics started gathering data on August 20, 2006.

Website Presence Tentatively Up

2006-08-22T06:04:00.000-07:00

http://aut.ologo.us is tentatively up. Still building the site as I find time. So far, only the splash page, news link(which points to this weblog) are up.