I thought I should collate them here, rather than bother with that book mark marlarkey. Wish I had these while I was going through uni. Always good to see multiple explanations of the same concept.

http://ocw.mit.edu/courses/mathematics/

http://www.euclideanspace.com/

http://www.myphysicslab.com/

http://my.hrw.com/math06_07/nsmedia/tools/Graph_Calculator/graphCalc.html

http://www.physicsforums.com/index.php

http://www.khanacademy.org/

http://www.isner.com/Transform/IsnerTransformManip_04.htm

http://www.isner.com/tutorials/quatSpells/quaternion_spells_14.htm

http://www.gizma.com/easing/

Had a muck around and created this in an hour with the help of some reference.

You can download the App at the following page:

http://www.zbrushcentral.com/showthread.php?t=090617

It is Windows only at this stage, but there does appear to be a WINE compatible build that someone has made for OSX here:

http://www.zbrushcentral.com/showthread.php?t=91628&highlight=mac

To place an object at the particle’s location was simple enough, and was a case of using

object.setPosition(particle.position)

I now needed to convert the normal vector into rotational information to orient the object to that of the surface.

My first approach was to use arcTan and SOHCAHTOA to determine the angle of theta for each axis of rotation. This was quite involved, and was not working correctly (Now that I look back, it was probably due to my vector’s not being normalised).

After a handy tip from Chad Vernon on the Maya-Python list, I discovered the super-magic matrix that allows you to map 3 orthonormal basis vectors directly to a signal matrix. This is what it looks like.

⎡  x.x      x.y     x.z     0  ⎤
⎢  n.x      n.y     n.z     0  ⎥
⎢  t.x      t.y     t.z     0  ⎥
⎣  0        0       0       1  ⎦

This uses three vectors x, n and t where each vector is defined as:

n = The normal vector from querying the surface.

t = A vector that is at tangent to vector n

x = A Vector that is orthogonal to n and t

Starting with one vector, we need to construct the other two. First we need create a temporary vector that will help decide roughly which direction the x vector will point. I defined vector temp as simply {0.0, 1.0, 0.0}, which points straight up in Y.

By now calculating the cross product of n and temp we receive vector t. The angle of ∂ is not 90°, but thats ok as the angle between n and t is.

Now by finding the cross product of n ∙ t we receive vector x

We need to normalize each vector first. Now with n, t and x we can substitute these back into the matrix, and apply it to an object at the surface position.

Voila, we now have an object that is placed at a given point on a mesh’s surface, and oriented to the surface normal.

I also found Adam Mechtley’s video tutorial aim-constraints handy to visualise the need for the temp vector:

http://adammechtley.com/tutorials/rigging/aim-constraints/

]]> http://www.jiltedreality.com/blog/?feed=rss2&p=118 0 http://www.jiltedreality.com/blog/?p=106 http://www.jiltedreality.com/blog/?p=106#comments Wed, 25 Aug 2010 12:13:46 +0000 adam http://www.jiltedreality.com/blog/?p=106 Today I needed to write a script that would use RV’s frameburn overlay script to add Frame numbers to a bunch of existing quicktimes. Initially I was going to use shell script, but on further research I found Python’s optparse module.

This handy module makes it easy to create Usage and Option documentation for a shell-like script.

More information on optparse can be found here.

I did not end up using any extra options, but utilised its ability to process the argument string.

#!/usr/bin/env python
 
import os
import optparse
import shutil
import glob
import sys
from subprocess import call
 
def findMovs():
    currentPath = os.getcwd()
    movList = glob.glob('*.mov')
    for mov in movList:
        convertMov(mov)
 
def convertMov(mov):
    print "Burning " + mov + "'s Frames..."
    destPath = arguments[0] + os.sep + mov
    print "Dest Path: " + destPath
    rvBinPath="blah"
    try:
        retcode = call([rvBinPath, str(mov) ,'-o' , destPath, '-overlay',
                               'frameburn', '0.5', '0.5', '200.0'], shell=False)
        if retcode < 0:
            print >>sys.stderr, "Child was terminated by signal", -retcode
        else:
            print >>sys.stderr, "Child returned code: ", retcode
    except OSError, e:
        print >>sys.stderr, "Execution failed:", e
 
if __name__ == "__main__":
    usage ="usage: %prog [options] destinationPath"
    parser = optparse.OptionParser(usage=usage,
                    description="Adds Frame Burn ins to .movs",
                    version="%prog 0.1")
 
    options, arguments = parser.parse_args()
    if len(arguments) == 1:
        findMovs()
    else:
        parser.print_help()

After a bit of research I thought drawing it would help visualise what is happening behind the scenes.

Page 24 of http://media-arts.rmit.edu.au/Les_Walkling/Colour_Management_Notes.pdf explains how to use photoshops “proof colours” option to preview an image in another colour space. This is a useful final step for artists, that need to apply an adjustment layer to their final image so that it appears the same as how they painted it, in another colourspace/on another monitor.

zomgski’s

What is TRON? Only the next raddest moofie evar!!

Tron Trailer

I realised this while trying to complete Hour 15 of the Iphone Development in 24 hours book.

The trigger to read in the prefs from the system bundle was supposed to fire on

-(void)viewDidLoad {
 [self setValuesFromPreferences];
 [super viewDidLoad];

However this does not fire if the app is already running (when you double tap the home key, and see it down the bottom).

To catch an already open app, being reopened, it is probably better to use:

applicationDidBecomeActive

For an excellent diagram on how app flow works in iphone land I suggest looking at this page by Dr Touch??? – that name just scares me.

http://www.drobnik.com/touch/2010/07/understanding-ios-4-backgrounding-and-delegate-messaging/

http://developer.apple.com/mac/library/featuredarticles/StaticAnalysis/index.html

This extra level of debugging will keep an eye out for wasted memory allocation and initialisation errors.

http://developer.apple.com/technologies/tools/whats-new.html

Oooh Two Panes