After some tests with Arnold, we quickly realized we didn’t need Vue anymore for stuff like scattering trees on a landscape. An artist at Oblique asked me to create a compound in ICE to mimic the parameters in Vue to scatter particles with some rules. Here is the compound. It’s quickly done but it works.

FL_ScatterTool.1.3.xsicompound.zip

edit: It appears the Density_Map isn’t working. I’ll have to find some time to fix it.

I don’t remember how I stumbled on Eric Dubois’ page on how to create an optimized anaglyph while keeping the colors, but I do remember that I thought it was semi useless since I always do my anaglyphs in black and white, it just works so much better. Even the default anaglyph node in Nuke creates black and white images.

Since I’m working on IMAX projects at the moment, I often use the proxy mode and I quickly realized that the anaglyph node’s offset parameter isn’t constant when activating the proxy. So I thought I would do my own anaglyph node. And then I remembered Eric Dubois’ method which was just a color matrix in linear space. It couldn’t be simpler to implement in Nuke. After experimenting a bit with it, I must say this method is awesome. I am surprised to see nobody did a Nuke gizmo before me, or that they didn’t publish it.

Haven’t used it much yet, but I doubt there should be any problems with it. It complains when you don’t have ‘left’ and ‘right’ views, but why would you do that?

DuboisAnaglyph.gizmo.zip

I also uploaded the gizmo on nukepedia. http://www.nukepedia.com/gizmos/duboisanaglyph
At the time of this writing, it’s still waiting for moderation.

I needed to load some DEM file into Softimage and Polytrans didn’t like the DEM flavor I had in hands. I wrote my own script to import it and happily ended up with a very hires model of the Rocky Mountains to scale. One Softimage unit equals 1 kilometer.

When I get the camera very close to the geometry, the mountains look good. Their shape looks normal and the slopes feel right. However, when I frame all the geometry in the viewport, the mountains look flat and boring. I have to scale them up 5 times in Y to get them to look nice again.

I made a linear camera movement from far to close and keyframed the Y scaling parameter from 5 to 1 linearly as well to see if it would present any apparent change. To my surprise, it’s not very apparent.

(Video: Watch this video on the post page)

OK, I’m tired of loading up my script just to see what’s the command line to encode AVC videos for the PS3 so I’m posting it here. This way It’ll be quicker for me to come see it here.

The PS3 doesn’t play Quicktime files. It much prefers mp4, which is an open standard (not to be confused with open source). The best and fastest way I’ve found to encode mp4 files is with ffmpeg. Yes, it’s command line but it’s easy enough to remember the basic syntax rapidly.

The syntax has several blocks, depending on what you need, all blocks may not be required.

ffmpeg
-r 23.98
-i FrameSequence.%04d.jpg
-i Sound.wav
-vcodec libx264 -acodec libfaac
-b 35M -ab 224k
-mbd rd -flags 4mv,trell,aic,qprd,mv0,loop -cmp 2 -subcmp 2 -flags2 dct8x8+skiprd -level 41 -bf 3 -qmin 10
-threads 0
OutputFile.mp4

Let’s look at this in details.
It begins with the executable (duh)
ffmpeg

Then you must set the frame rate only if you’re loading a sequence of frames. BTW, it only reads jpeg and png files, and it must begin at 0 or 1.
-r 23.98

The input files, several if your audio is separated from the video.
-i FrameSequence.%04d.jpg
-i Sound.wav

The formats, determined by the codecs. AVC for Video and AAC for audio.
-vcodec libx264 -acodec libfaac

The bit rates. I use 35Mbit/s for 1080p, 15 for 720p and 5 for SD.
-b 35M -ab 224k

This line must be entered as is. It set the encoding parameters the PS3 requires.
-mbd rd -flags 4mv,trell,aic,qprd,mv0,loop -cmp 2 -subcmp 2 -flags2 dct8x8+skiprd -level 41 -bf 3 -qmin 10

This will force ffmpeg to use all the cores on your machines, potentially speeding up the conversion considerably.
-threads 0

And the output file, with the mp4 extention.
OutputFile.mp4

This command works for ffmpeg 0.5 and probably later. You can find ffmpeg for Windows here.
Thanks to this site for providing the original syntax. I added the -qmin 10 part because libx264 was acting weird without it.

It is important to know that if you’re encoding a video you have made using computer softwares, your video might look a bit too contrasted. Blacks might be too black and whites too white. This is because pixel values on your computer range from 0 to 255, and on your TV they range from 16 to 235. Any pixel that has a value below 16 in your movie will appear as black on your TV. To correct this, you must compress the colors of all the frames in your movie to make sure the darkest thing is set above 16 and the brightest thing is below 235. Then it will show up correctly on your TV when played with the PS3. There is a setting in the PS3 to avoid this, but your TV must be compatible, and not all TVs are compatible, far from it.

EDIT: with recent linux distribution (Mandriva 2010.1 in my case) comes a new version of ffmpeg. This new version requires some changes to the command line. First, you have to add the argument -vpre slow somewhere. Also, the libfaac codec has been replaced by aac. The command would then looks like this:

ffmpeg
-r 23.98
-i FrameSequence.%04d.jpg
-i Sound.wav
-vcodec libx264 -acodec aac -b 35M -ab 224k
-vpre slow -mbd rd -flags 4mv,trell,aic,qprd,mv0,loop -cmp 2 -subcmp 2 -flags2 dct8x8+skiprd -level 41 -bf 3 -qmin 10
-threads 0
OutputFile.mp4

1. To make a starfield timelapse, it must be dark, very dark. The tinyest light pollution from a nearby village will be amplified by the long exposures and be visible in the shot.
2. To make a starfield timelapse, it must be dry. On the banks of the St-Lawrence river, in August, the moisture condenses on the lens and you are lucky to get 50 frames before it happens.
3. To make a starfield timelapse, you must use a camera that has as little dead pixels as possible. Mine is getting old (Canon Rebel XT) and I discovered it has many, many dead pixels.
4. To make a starfield timelapse, 1 minutes exposure per frame is good, but not enough to see the Milky Way.
5. To make a starfield timelapse, it is preferable to see something in the shot like a mountain or a house. Otherwise, all you see is a few stars rotating. Those objects in the shot would also recieve light from the moon when it rises possibly creating a cool effect.

I used my new shiny timelapse machine for this one since it allows for longer exposure times than what the camera supports. It proved to be useful and is perhaps the only thing that worked as expected that night.

So here is the result. I made the mistake of shooting in RAW. I should have shot in jpeg and used the noise reduction function of the camera. When I saw the result, I didn’t bother to process it too much and remove the dead pixels and color-correct it. I just set the black point to clip the light pollution and the noise and trimmed the bad frames.

1 minute exposure per frame, 8 seconds between frames, ISO 200, 12mm, F4.

I consider it to be a failure. The stars you see that don’t move are dead pixels (or dust on your screen). Near the end of the movie, you see the stars dim a little. That’s where the humidity started condensing on the lens. In the hi-res version, we can see one or two shooting stars, but they’re not very apparent. I didn’t bother posting the hi-res version.

I wanted to leave the camera outside all night but when I saw the amount of condensation there was on the lens after only an hour, I stopped the whole thing. The next morning when I saw all the water condensed on my car, I was glad I didn’t leave my camera outside.

This will download and install the latest Dropbox version and start it. Once you configured it as you like, hit ctrl+c to kill it. We will configure it to start automatically when you log in.

Type ‘systemsettings’ in a shell, go to the Advanced tab and double click on Autostart. Click the Add Program button. Browse to this file ~/.dropbox-dist/dropbox and click OK. Next time you log in, Dropbox should start.

1. In the Mandriva Control Center (drakconf), go to Hardware -> Set Up The Graphical Server.
2. Click Options, check “Enable duplicate display on the second display”. Click OK.
3. Log out, and back in.
4. Open a terminal as root.
5. Type /usr/bin/nvidia-settings
6. Go to “X Server Display Configuration”
7. Select one of the monitors and set its position to “Right of” or “Left of”.
8. Click Apply. You should see something different on both screens.
9. Click “Save to X configuration file”.

Before that, I changed the permissions on the xorg.conf file to be able to write to it as a user. This is what doesn’t work anymore. Something brings back the permissions of that file to root only. So you need to run the nvidia-settings as root. Mandriva should simply ask for your root password when opening this tool, perhaps in the next version.

Oblique, my employer, has allowed me to release it publicly. So here it is… nukeprocess.py.
Save this inside your custom python library or inside your Python’s site-packages directory. Since this is a tool for controlling an application via programming, I assume you know where to save a python file to use it. You will have to modify some parts to make sure it points to the right Nuke installation and to your own Python library.

It creates a Python script that can be run inside Nuke. It then starts Nuke and pipe the script to the STDIN, executes the script and exits Nuke. At the time of this writing, it works with Nuke 5.1v4.

If you find any bugs or have any comments about this tool, don’t hesitate to tell me. I’ve been using it in production for a few weeks now and I still find a few bugs from time to time. I would like it to be as solid as possible since Oblique pipeline will rely on it. Also, feel free to modify it to your own needs. I would appreciate if you told me what you did. In the Oblique internal version, I added a method to process on the render farm, but since our render manager API is custom made, I felt it was unnecessary for a public release.

Its usage is simple. You first create an instance of the NukeProcess class by giving it the name of the sequence you want to work with as well as its first frame, last frame and step. You then add nodes with the createNode() method by setting all the knob values with arguments. And execute the whole thing with the executeVerbose() method. The knob names you pass as args must be the scripting name. You can find them by hovering the mouse over any knob in Nuke, the tooltip is the script name.

Usage examples

#
# To resize a sequence of images, color correct it, and save to jpeg:
#
from nukeprocess import NukeProcess
np = NukeProcess("/someplace/someImageSequence.%04d.exr", 1, 100, 1)
np.createNode("Reformat", type='to box', box_width=1920, box_height=1080,
              box_fixed=True, resize='fit', black_outside=True)
np.createNode('Grade', black=.00537, white=.83)
np.createNode("Write", file="/someplace/someImageSequence_HD.%04d.jpg",
              file_type='jpeg', _jpeg_quality=1)
np.executeVerbose()

#
# To resize a sequence, offset it to frame 1 and put gray bars:
#
from nukeprocess import NukeProcess

# When declaring a empty string, it creates a Constant node instead of a Read.
np = nukeprocess.NukeProcess("", 1, sequence.getEnd()-sequence.getStart()+1,
                             color="{from_byte(64)}") 

# Use the addCode() method when you need to do something special.
np.addCode("f = nuke.addFormat('512 288 PreviewMovie')")
np.addCode("n.knob('format').setValue(f)")

# We save the node in a variable to use it later in the connectInput() method
np.saveNodeInVariable('constant') 

# sequence.getStart() and sequence.getEnd() come from another API,
# in this case a custom file browser.
np.createNode("Read", file="/somePlace/sequence.%04d.exr",
              first=sequence.getStart(), last=sequence.getEnd(),
              frame="frame+%d" % (sequence.getStart()+1))
np.createNode('Shuffle', alpha=6)
np.createNode("Reformat", type="to box", box_width=512, box_height=288,
              resize='fit', black_outside=True, box_fixed=True)

# The connectInput() method works on the previously added node.
np.createNode("Merge")
np.connectInput('constant')
np.createNode("Write", file="/somePlace/sequence_fit.%04d.exr",
              file_type="exr", compression='ZIP')

# to debug the script, you can print it and paste it in an interactive Nuke.
print np.getScript()
np.executeVerbose()

#
# To monitor the process:
#
from nukeprocess import NukeProcess
np = NukeProcess("/someplace/someImageSequence.%04d.exr", 1, 100, 1)
np.createNode("Write", file="/someplace/someImageSequence_HD.%04d.jpg",
              file_type='jpeg', _jpeg_quality=1)
oProcess = np.execute(1, 100, 1)
sOutLine = "."
while sOutLine != "":
    sOutLine = oProcess.stdout.readline()
    # Update process progress
    # Writing /someplace/someImageSequence_HD.0001.jpg took 1.08 seconds
    if sOutLine.startswith('Writing'):
        # Extract frame number from sOutLine
        try:
            iFrame = int(sOutLine.split()[1].rsplit('.')[-2])
        except:
            pass
        else:
            print("Processing frame: %d" % iFrame)

oProcess.wait()
result = oProcess.returncode

Documentation:

NukeProcess methods: