Procedural create CityEngine, one of the few useful procedural urban tools around. Does this mean that they are looking for an easier way to create models of buildings? Reconstruction from street photographs? From aerial photographs? Why not from existing meshes (from video game artists)?
Image-based Street-side City Modeling (pdf) from Sigg09 shows some of the potential of this direction.
I'll be looking forward to seeing what these guys do next.
Sorry, it's been a little quiet around here recently. One of many reasons is that I put together my first year report (updated pdf). Notes:.
[edit] Having taken criticism from blog readers and supervisors alike, I've updated this. Some of the cut bits appear below - if you've already read it, don't bother reading it again, nothing significant has changed.
Some of the more interesting results from my time at ASU have been cut for client confidentiality. This is getting quite annoying now, will try not to fall into non-disclosure hole again.
It's mainly a bunch of blog posts end on end.
It isn't really of the quality required for a thesis.
Bits that didn't make the cut:
Possible Theses
Here I present a few possible directions that I see my work progressing in. Because of the new ground that is being covered, posing these direction as theses is a little artificial at this point.
Procedural Workflow
Useful procedural systems can be constructed by non-technical users Three dimensional modelling packages such as Wavefront's 3D Studio Max or Maya present artists with very complicated interfaces for the creation of 3D content. These systems include data flows, such as 3DSM's hypergraph which allows different properties of a material to be edited, and construction histories. It should be possible to build a system of similar complexity, that can be used by 3D artists to enable them to build procedural objects. This would involve investigating subjects such as intelligent primitives (such as blobby objects or z-spheres), the generative modelling language (GML), and current 3D workflows.
Reverse proceduralization
Reverse engineering real world or artist created objects allows for effective proceduralization of geometry From a design perspective reverse proceduralization, or reverse engineering allows artists to use their current tools to create a single instance, and then perform proceduralization as an after-thought. This would give the easiest integration into the current workflows of all proposed procedural solutions. Study in this subject would involve machine learning techniques to extract form from designs, after sufficient pattern-analysis has been performed.
Floating Point Robustness
It is possible to perform robust geometrical computations in a floating point environment. One of the upshots of my work with the straight skeleton and the Voronoi tessellation is the realisation of how hard it is to work with geometry in a floating point environment. I found that the vast majority of my time was concerned with robustness issues. For example a point that is on one side of a line can appear on the other if the calculation is repeated with an indentical line travelling in the opposite direction.
There are well known limits, within which standard geometric queries fail to behave in a predictable fashion. The result is quite chaotic, and makes designing robust algorithms both time consuming and bug-prone.
There are several attempts to make computational geometry more robust, but I've found none to make it easier. The ideal goal here would be to create an library that an undergraduate could use for robust geometric manipulation, in place of CGAL or similar.
bbc) fantastic documentary, I thought I should restart my reading in this area. More to come!
Computations at the Edge of Chaos: Phase Transitions and Emergent Computation (Physica D | pdf | bib | 2002 ) Chris Langton
This paper examines the behaviour of Cellular Automata (CA) as one property of their rule-set changes. It is the first description of emergent behaviour occurring somewhere on the spectrum from a dull, homogeneous environment to a random, chaotic one.
The variable that is changed is lambda, a statistical variable saying how likely it is to end up in an "active" state. That is, what fraction of rules lead to a cell becoming active. As the above image shows, as lambda changes, so does the typical output patterns. These changing patterns are what first attracted me to the paper (useful for procedural?!), but the real significance is that really interesting patterns only occur for a limited range of lambda values. Too low and we don't get anything happening (deep space), too high and all we see is Chaos (center of the sun). Between we get "just right", where interesting CA's live.
Computationally we see that we need storage and transmission to get interesting systems. Storage leads to homogeneous environments (low entropy), and transmission to chaos (high entropy). Both are required for meaningful computation, and we only see them both in small parts of the range of possible CA's.
Reverse engineering of spatial patterns in cellular automata ( springer | pdf | 2008 ) Yuuichi Ichise & Yoshiteru Ishida
This is a short paper that describes how to reverse engineer a CA from the results. They use the algorithm that you'd imagine, taking each observed result and filling in an entry in the rule-table. They also explore reverse engineering probabilistic CA's by accumulating the observed instances of each each particular rule. In both PCA (probabilistic cellular automata) and CA's case they return a CA with unknowns in the case that there is no example data. The important observation is that if there is insufficient data, there are a set of CA's that will reproduce a given pattern.
Comparison of a procedural city and a photo of a city: which is which? How long did you have to look?
The procedural image (of a reconstructed Pompeii) was from Procedural Inc (right), the photo was by mharrsch (left). Highlight this paragraph in your browser for the answer! Filter was a quickie "photocopy" in gimp.
The lack of real scientific method in computer science is quite apparent in fast moving and new fields, like procedural modelling. Evaluating procedural content has been an ignored subject in the journals, there is very little said about the quality or the believability of the output of a procedural system. In contrast lots is said about the number of processor cycles or the lack of artist involvement. This a sketch of a project that hopes to address this issue. We can the above idea turn this into a web-game (similar to the google image labeller game) that challenges people to spot the fake photograph in a certain time, and rewards them with points for being right.
Going even further we can build a competitive game that find the realistic and unrealistic areas of an image by asking you to attempting to fool your opposition. The computer invents a goal ("prove to your opposition that this is a real photo"), and you get points for doing it. The more of the image you reveal, the less points you get. When it's your turn, you see an image slowly revealed as your opponent reveals the bits he can see. You have to decide if it's a photo or a render (in this case). It could create a "believability" map of each image by examining the areas scratched off by the subjects. The following example just asks the user to distinguish between a render and a photograph but by using a filter that obscures the geometry (such as the photocopies in the above example) it would be possible to compare procedural & artist-defined geometry.
Images for this were stolen from this guy. Video (or on youtube):
You can play a simulated ("offline") version of this game by clicking here (Java 1.6 needed, binary file - run at your own risk). Your own moves are played back when it's your turn to guess. There is an option to add image noise to make the game harder to play.
This is one of the most promising avenues of exploration I've thought of when it comes to evaluating procedural modelling systems. Of course it is very hard to count the contributions from the artist and from the procedural mechanisms. To solve this some sort of test of artist generated geometry against procedurally generated content may be called for. In both cases we would record the quantity of programmer/artist time taken to create a scene, and then evaluate it. The hope would be that the procedural models show comparable realism, while absorbing many fewer man-hours.
Future ideas:
Could do this for videos
Could render examples from a procedural model in real time, get feedback on them, and update the model automatically. This kind of technology ("which parts of these models represent the door knobs that the guy scratched out?") is a few years away yet...
Add in distractors (trees, people, lens flare, motion blur) to allow a fair test against a random selection of architecture photos (from flickr, say).
Let me know if you think this is an interesting project, and have some ideas for carrying the idea further. It should make a half decent paper when written up.
One of the biggest problems with this is that there aren't many examples of detailed procedural models. The Pompeii examples from Procedural is a couple of years old and is still one of the best/most complex examples. As the above image shows, it is only just detailed enough to make this test plausible. I had to hunt around on the web for a while to find a photo of Pompeii without too many people/clues etc... to make the above a reasonable comparison.
It's getting harder and harder to tell rendered images from photos, if you look at the top right of this image of houses in Glasgow (park circus), it's hard to tell it's just a photograph. The houses were being refurbished, so no people to leave distinguising features, and they had just been cleaned using sand-blasting.
I can't say a lot about the skeleton project*, however, we got a very rushed paper together that was rejected, but we got some nice renders (and a whole bunch of feedback) about on the work. A few sneaky pictures follow :) as ever, they were all made with the blender render template I've made, and rendered in yafaray. Basic idea is a straight-skeleton based rapid prototyping tool for architecture. At a stretch it could even be called procedural.
I was worried the paper-reviewers would complain about the artsy backgrounds to the renders, however that was the one part of the work that wasn't panned. Most of the backgrounds were my own photos, many from this flickr set.
Something that took longer than it should have, but really makes these renders special is the tiling. Each tile on the roof is a polygon, and it basically involved writing an old-school rasterizer so each roof edge could position it's tiles. Never got around to creating tiles for the roof edges tho - so it looks like they are all made out of cardboard, which is really cute and make them look like real architectural models.
*that's one thing about working with collaborators, I've got to protect their investments as well as mine. Yes that means we're going to make this project even more awesome and try again.
from Weighted skeletons and fixed-share decomposition ( Aurenhammer | 2007 | ps | doi )
Higher dimensions
The concept of weighted skeleton (or weighted medial axis) is not limited to two dimensions. Given a convex polytope P in Ęd and an assignment of positive weights to its facets, a unique convex cell complex inside P can be defined, either by the respective shrinking process, or based on weighted distances to the hyperplanes that support P. In fact, the decomposition and optimality results presented in Section 3 and Section 4, respectively, directly generalize to higher dimensions.
Thusly we may draw:
Fun thing here is to compare what happens through the dimensions and see how high you can go before your head explodes. Also what the procedural modeling ramifications of each step are.
Here's a long, uninteresting video of the Sony Vaio CW booting Ubuntu (64 bit, wifi not a problem, but the video took a little work for the nVidia drivers how to in this post), then it shows the splash-top an instant-on web browser (that takes about to long to boot as the other operating systems take to come out of standby). This works well (flash videos play fullscreen), and I wave the screen around a bit to show the not-so-great viewing angle, but great brightness compared to my old powerbook laptop. Finally we see it booting windows 7, which is very pretty and does everything it should do.
What I didn't manage to show was the rattling battery. There's half a millimeter or so of space around it, and it doesn't lock into place properly. You don't notice it when you're using the laptop, but it's annoying when you're packing the laptop up.
Still really liking this 'top. A bit to much shiny-toy plastic, but generally responsive and enjoyable to use.
Video was taken inside, without any extra light, on a canon 500d. Sorry for the shaky bits.
