Lesson 1: Know the limit of your camera, and try to work around it.

Small cameras are known for their low dynamic range, so to get the most out of this sunset, I took two images at different exposure and merged them together with Pro HDR, right on the phone.  This increased the dynamic range dramatically, making it equal to that of a dSLR.  Then a bit of contrast and saturation boost completed the look.

Lesson 2: Post Processing

This picture came out very bland at first, but a few tweaks in Lightroom 3made it marginally passable.  There are enough apps in the Apple Appstore to edit your photo into oblivion and back.  Some of my favorite apps are Pro HDR, TiltShiftGen and Best Camera. Of course, for the most control, you’d have to use a desktop-based tool like Lightroom or Aperture.

Lesson 3: Color

What the tiny camera lacks in light-gathering ability, it makes up by upping the vibrancy and contrast.  iPhone photos are usually a lot more vibrant and contrasty than what you get out of a high-end dSLR.  Use this to your advantage to capture some eye popping pictures.

Lesson 4: Bokeh

You CAN throw the background out of focus even on a tiny sensor like the iPhone camera, but only if you are shooting in macro.  Just be patient with the focus, it can take a while to get the razor sharp image that you wanted.

That’s all for now, I am still discovering the capability of the iPhone camera.  Let me know if you have any tips regarding digital photography.

Core 2 Duo SU7300 Processor:
It has a 1.3Ghz (up to 1.7Ghz with TurboBoost technology), ultra-low-voltage processor manufactured on 45nm technology.  Which really just means the processor can do a LOT of work while barely sipping on your precious battery.  Honestly, it’s unbelievable how fast this processor is while using less than 10W of power.  [Compare with a 13 MacBook Pro: slightly slower, but uses 1/3rd the power)

Nvidia G210M 512MB and Intel 4500 Graphics:
This .93 inch thin laptop has TWO graphics cards.  The Nvidia G210 is probably the fastest graphics card available on a 13 inch laptop.  It's build on 40nm technology, and uses a max of 14W of power, which is still impressive for a graphics card of this caliber.  The Intel is slower, but uses even less power.  You can toggle between the 2 to trade off performance for battery life. [Compare with a 13" MacBook Pro:  The Asus is twice as fast, while using the same amount of juice]

4GB DDR3 RAM:
Also, the laptop can support a max of 8GB of memory, you know… in case you need that much. [Same as Macbooks.]

13inch LED-lit Screen:
LED also means it’s uses less power than regular backlights. [same as Macbooks]

12 hour battery life:
…or so Asus claims, you can probably expect 10 hours of real world usage, and maybe 4-5 hours of gaming/heavy 3D work. [much longer than the MacBook Pros]

Design:
Not quite on par with Apple’s drool inducing one-piece aluminum finish, but it’s one of the nicer laptops I’ve seen (once you get rid of all the stickers).  The design is obviously Macbook inspired.  And it’s really light and thin.

Price:
$800 USD.  I know you can get an even faster 15″ laptop for $900, but the battery life and portability also suffers as you up the screen size.  13″ with this amount of computing power is perfect.  It also comes with all the standard bells and whistles: webcam, bluetooth, 802.11n, and a half terabyte harddrive.

The bottom line:
if you are looking for a portable powerhouse, take a closer look at this laptop.  If you want raw power and don’t care about battery life, skip this.

* I do not own this laptop, nor did I got paid to write this, I was just excited that I finally found a laptop that seems to be everything I am looking for.

1. Get Blender 2.5 Alpha, also go for the 64bit version if you have 3GB or more of RAM.  2.5 is simply a lot faster and refined than Blender 2.49.  The tools and interface is also much cleaner and more intuitive.  Also, a lot of work has gone into optimizing the sculpting feature in Blender 2.5.

2. Start with a base mesh, then apply the multires modifier.  Do not use a default cube and rely on the multires modifier to do *all* the sub-division.  It’s always better to start with a base mesh with a few thousand polygons, and use multires with a sub-division level of 2-5.

3. Turn off “Double Sided” in the Object Data panel.  This will significantly speed up the redraw.

4. Delete UV texture data and Vertex Color data *might* help speed things up, but I don’t really know for sure.

5. Turn on VBO in the Preference menu.  This will further speed up drawing speed.  (Thanks Gustav!) Okay apparently it doesn’t according to another commenter, since sculpt mode already uses VBO by default.

For the inquiring minds, I got the SVN log with the following command

svn log -r 25000:0 --xml https://svn.blender.org/svnroot/bf-blender/branches >> log.xml
svn log -r 25000:0 --xml https://svn.blender.org/svnroot/bf-blender/trunk >> log.xml

These two SVN operation fetches the SVN logs for both the branches and the trunk of Blender and combine them into one 8 megabyte XML file.  Please do not do this often as I imagine querying all the commit logs must put a heavy strain on the Blender SVN server.

Parsing the XML for the author commit frequency is done with the following python script:

import xml.sax

authorList= {}

# create document handler
class SVNXMLHandler(xml.sax.handler.ContentHandler):
	def __init__(self):
		pass

	def startElement(self, name, attrs):
		self.hasAuthor = 0
		self.hasEntry = 0
		if name == "logentry":
			self.hasEntry = 1
			#print attrs.get('revision', ""),
		elif name == "author":
			self.hasAuthor = 1

	def characters(self, data):
		if self.hasAuthor:
			#print data
			try:
				authorList[data] += 1
			except:
				authorList[data] = 1

	def endElement(self, name):
		if name == "author": self.hasAuthor = 0
		if name == "logentry": self.hasEntry = 0

# load and parse log
f = open('log.xml', 'r')
xml.sax.parseString(f.read(), SVNXMLHandler())

# print to console in comma delimited format
for i in authorList:
	print i,",",authorList[i]

Run the above python script like so:

python logParser.py >> crunched.csv

After a few seconds, a CSV file should be created containing all the data you need, ready to be graphed in Microsoft Office.  Yes I used Excel for the graph…

Firstly, you will need a few piece of software: We are going to use Microsoft Visual Studio 2008 and Cmake to help us build Blender, and to fetch the source code from blender.org, we’ll also need a SVN client, I will use TortoiseSVN.

1. Get Visual Studio 2008. If you have access to a copy of Visual Studio, great!  But I heard the free Express Edition works too.  I went with a custom installation and this is all the components you’ll need to build Blender.

2. Get CMake and install it.  It’s free.

3. Install TortoiseSVN, also free.

4. Once all the software are installed, we can begin to acquire the Blender source codes!  First, navigate to an empty directory and right click to do a SVN Checkout.  Use the following URL:

https://svn.blender.org/svnroot/bf-blender/trunk/blender

Put the source under C:\Blender\blender. Next, let’s also acquire the libraries needed to build Blender.  Do another check out with the following URL:

https://svn.blender.org/svnroot/bf-blender/trunk/lib/windows

Make sure you put the files under a directory like C:\Blender\lib\Windows.  If you want to make 64bit builds, also check out the 64bit libs:

 https://svn.blender.org/svnroot/bf-blender/trunk/lib/win64

Put that under C:\Blender\lib\Win64

Use TortoiseSVN to check-out the Blender Windows Library

Once you have done the 3 check-out, your directory structure should look like this, make sure all the folders and files are in the proper place, otherwise you will have a hard time building Blender:

Folder structure

5. Now that you have all the source files, it’s time to start the building process!

We are going to use CMake to generate a “solution” file for Visual Studio.  A solution is what Visual Studio would open to build the entire Blender. It’s a collection of smaller project, each project is a collection of source files.

Now open CMake, and In the top text box, type in where you put the Blender source code. (C:\Blender\blender, in my case)

In the second text box below it, select a fresh directory where you want the output file to go. I am using C:\Blender\build

Now click on Configure, this will bring up another dialog box where it asks you which generator to pick.  We are going to use Visual Studio 9 2008, or Visual Studio 9 2008 Win64, if you want to build a 64bit Blender.

Then CMake will populate the main window with a list of options that you can disable or enable.  The default selection is good, but if you want to speed up the building process, you can deselect certain options that you are not using.

Certain options might also be unavailable or broken on 64bit.  For example, if you are building a 64bit release, make sure you uncheck FFMPEG, JACK, and QUICKTIME, since there is no 64bit library for these media features yet.

For first timers, I would suggest unchecking all of these boxes to build a minimalist Blender.  It will be faster, smaller, and there is less chance of running into an error at compile time.  You can come back and re-enable these settings once your first build is successful.  Once you have made your selection, click on Configure at the bottom of the screen.  Then followed by clicking on Generate. These will generate the corresponding Visual Studio solution files in the directory you specified above.  (C:\blender\build\) in our case.  Close CMake.

6. Navigate to C:\blender\build, you should see the solution file you just generated.  Open “Blender.sln” with Visual Studio 2008.

Once Visual Studio opens the solution, make sure you change the default build target from Debug to Release.  Otherwise you will end up with a debug build of Blender that is slower, bigger, and probably not helpful unless you are debugging.

After that, simply select Build Solution from the build menu.  After about 10 minutes of compiling and linking, a fully functional Blender installation should be ready under C:\Blender\build\Bin\Release.

Introducing… a flat, boring porins protein, this is how most scientific vistualization would show it.

What’s wrong with the image?  Well technically nothing, it’s scientifically accurate, each atom is color coded to represent an element, and it even rotates so that you can see the overall structure of protein.  But can we do better?  You bet!

Click here to see the exact same porins protein, but with a much advanced shading model, I think it’s clear why this one is superior.  With ambient occlusion, in which the model is shaded based on how likely an area is occluded because of surrounding objects, the spatial structure of the protein is much easier to understand.  And with today’s super fast GPUs, doing a screen-space ambient occlusion is virtually instant.

And if anyone is curious, the software I used to generate the graph is CuteMol, an

interactive, high quality molecular visualization system. QuteMol exploits the current GPU capabilites through OpenGL shaders to offers an array of innovative visual effects. QuteMol visualization techniques are aimed at improving clarity and an easier understanding of the 3D shape and structure of large molecules or complex proteins.

The laptop on the left is physically separated from the desktop to the right, linked only by a wireless internet connection. And as you can see, input made to the desktop computer is sent across the network to the laptop, in realtime.

And here is the script, I’ll try to explain everything as best I can:

# Simple Python UDP networking demo Created by Mike Pan
# Todo: auto-self IP detection would be nice

# the following line loads the game module used by Python
# to access the Blender Game Engine API, and assigns it the alias G
import GameLogic as G
# load the network socket python module, we'll need it later
import socket

# define own IP address, and stores it as a property under GameLogic
# essentially making it accessible as a global variable
G.ownIP = "xxx.xxx.xxx.xxx"
# define peer IP address, stores it as a property under GameLogic
# again, essentially making it accessible as a global variable
G.peerIP = "xxx.xxx.xxx.xxx"
# define the port number (arbitrary), and the socket buffer size
# (4096 is a good starting point)
G.port = 4000
G.buffer = 4096

# create an IPV4 address with the pre-defined IP and the port number
addr = (G.peerIP, G.port)

# We'll add this line to all our communication, so when debugging,
# we won't get confused as to who send the packets.
signature = "Sent from " + G.ownIP

def init():
	# create an UDP socket for **sending** datagram
	G.sender = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
	# time out is 10ms, pretty short for realworld application,
	#but enough for debugging over local network
	G.sender.settimeout(0.01)
	# this is important! by making this socket object a
	# non-blocking operation, all network stuff is run on
	# a separate thread, thus any network delay will not
	# cause the game to slow down
	G.sender.setblocking(0)

	# creates UDP socket for **receiving** datagram
	G.listener = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
	# same as above, time out is 10ms
	G.listener.settimeout(0.01)
	# same as above, we also need to make sure network operations
	# will not slow down the main application
	G.listener.setblocking(0)

	# Win32 needs the socket binded:
	try:
	 G.listener.bind((G.ownIP, G.port))
	except:
	 print "Binding Listener failed"

def comm():
	# get the object that is attached to this script
	own = G.getCurrentController().owner

 	# receive from peer
	try:
		data, port = G.listener.recvfrom(G.buffer)
		# data contains all the data that came through,
		# it's a string, and we can do whatever we want
		# like print it out
		print data.split(',')
	# if the receiving fails, print something to notify the user
	except:
		print "Receive failed"

	# send to peer
	# generate data to be sent here,
	# send the position data across the network:
	string = str(own.worldPosition)+ ',' + signature

	# going to try to send the data
	try:
		G.sender.sendto(string, addr)
		# if sending fails, notify with error message
	except:
		print "Send failed"

That’s it! To use this script, we simply need to call init() once at the start of the game, and then comm() everytime you wish to send/receive some data (perhaps every 1/30th of a second). As mentioned, here is no ‘server’ involved, the two peers connect direction to each other via a UDP socket. All the user has to do is specify the two IP addresses.

1. Acquire Blender source code and libraries

- Download and install tortoisesvn from: tortoisesvn.tigris.org
-created a folder named “blender” under c:\build, select the folder and click on SVN checkout, and use the following location:

https://svn.blender.org/svnroot/bf-blender/trunk/blender

-created a folder named “windows” under c:\build\lib, select the folder and click on SVN checkout, and use the following location:

https://svn.blender.org/svnroot/bf-blender/trunk/lib/windows

Once the above 3 steps are done, you will have the most up-to-date blender source code and library in the world.

OPTIONAL INFO: If you want to build an official release, you can grab the more stable source code (~10MB, library files are not included) from blender.org/download/source-code. Simply delete everything under C:\build\blender and then extract the tarball to the same directory. Building from the official release ensures the Blender you compiled is stable and relatively bug-free.

2. Acquire compiling softwares

- Download and install Python 2.5.1 (9MB) from www.python.org
- Download Mingw 5.1.3 (~10MB) from www.mingw.org . Run the installer, Pick any mirror, Select Current and install packages MinGW BASETOOLS and G++ COMPILER.
- Download and install SCons 0.97 Windows (300KB) from www.scons.org
- Download the experimental GCC4.x for MinGW package from tdragon.net. Extract it to the place where you installed MinGW, and this will serve as a ‘drop in’ replacement compiler. From my own testing, GCC4 is faster than the one that comes with MinGW, but can cause trouble when compiling OpenAL.

3. Environment setup

- Go to Start Menu >> Control Panel >> System >> Advanced (Tab) >> Envoronmant Variables (button) >> System Variables scroll area double click on the PATH item
- Add the following line to the end: ;C:\Python25;C:\mingw\bin

4. Python stuff…

Copy libpython25.a from C:\Python25\libs to C:\build\lib\windows\python\lib

5. Customization (Enable/disable features, add speed optimizations)

- Create a new file named user-config.py under C:\build\blender\
- Open user-config.py with notepad and copy the following text into it.

WITH_BF_GAMEENGINE=’true’
WITH_BF_BULLET = ‘true’
WITH_BF_ODE = ‘true’
WITH_BF_OPENEXR = ‘true’
WITH_BF_FTGL = ‘true’
WITH_BF_FMOD = ‘true’
WITH_BF_FFMPEG = ‘true’
WITH_BF_QUICKTIME = ‘false’
WITH_BF_OPENAL = ‘false’
WITH_BF_SDL = ‘false’
BF_PYTHON_VERSION = ’2.5′

CCFLAGS.extend( ['-march=i686', '-ftracer', '-fomit-frame-pointer', '-finline-functions', '-ffast-math'])
CXXFLAGS.extend(['-march=i686', '-ftracer', '-fomit-frame-pointer', '-finline-functions', '-ffast-math'])

REL_CFLAGS = [ '-O3' ]
REL_CCFLAGS = [ '-O3' ]

‘-march=’ is probably the most important flag in this config file. Newer Intel CPU (Pentium D, Core 2) owners are recommended to use ‘-march=nocona’, AMD (A64, X2) owners can try ‘-march=k8′.
‘-mmmx’, ‘-msse’, ‘-msse2′, ‘-msse3′ are usually implied by using a valid march flag, therefore they are not included in the config file.
‘-ffast-math’ are in general stable enough for daily use (I’ve never seen a crash), but if you are running a real production server or can not tolorate crashes, remove this flag. It will make the binary a little slower.

This is how the directory should look like:

6. Compile!

- Open a command prompt window by click on Start >> Run >> type in “cmd” and hit OK.
- Navigate to where the Blender source code is by typing this into the command prompt cd C:\build\blender
- Start the building process: scons BF_TOOLSET=mingw BF_BUILDDIR=c:\install -j4
- The above command should take about 5-10 minutes to process, and it helps if you have a dual-core processor!
- When it finishes, (Hopefully without error), you can nagivate to C:\install\win32-mingw\ and find a complete Blender installation ready to be zipped up and distributed!

Where to go from here?

You might want to rid the blender.exe of extra useless debug data by entering the following command into the command line:
strip C:\install\win32-mingw\blender.exe
This will reduce the size of the executable by 8mb or so without having any negative impact

The above ‘user-config.py’ file will result in a full-featured Blender that is optimized for speed and should run on almost all modern processors. To speed up the building process, you can chose to disable some of the features by replacing ‘true’ with ‘false’ (this will give you a blender binary without certain feaures such as gameengine, audio, etc…)
scons clean BF_TOOLSET=mingw BF_BUILDDIR=C:\install
can be used to clean the build data and getting ready for a new build

I also recommend: How to build Blender using Visual C++ Express Edition 2008 By Eugene (etr9j), MSVC produces faster binary, but takes a lot longer to setup for the first time.

1. Acquire Blender source code and libraries

- Download and install tortoisesvn from: tortoisesvn.tigris.org
-created a folder named “blender” under c:\build, select the folder and click on SVN checkout, and use the following location:

https://svn.blender.org/svnroot/bf-blender/trunk/blender

-created a folder named “windows” under c:\build\lib, select the folder and click on SVN checkout, and use the following location:

https://svn.blender.org/svnroot/bf-blender/trunk/lib/windows

2. Acquire compiling softwares

- Download and install Python 2.5.1 (9MB) from www.python.org
- Download Mingw 5.1.3 (~10MB) from www.mingw.org . Run the installer, Pick any mirror, Select Current and install packages MinGW BASETOOLS and G++ COMPILER.
- Download and install SCons 0.97 Windows (300KB) from www.scons.org

3. Environment setup

- Go to Start Menu >> Control Panel >> System >> Advanced (Tab) >> Envoronmant Variables (button) >> System Variables scroll area double click on the PATH item
- Add the following line to the end: ;C:\Python25;C:\mingw\bin
- Copy libpython25.a from C:\Python25\libs to C:\build\lib\windows\python\lib

4. Compile!

Before you start, this is how the everything should look like:

- Open a command prompt window by click on Start >> Run >> type in “cmd” and hit OK.

- Navigate to where the Blender source code is by typing this into the command prompt cd C:\build\blender

- Start the building process by:
scons BF_BUILDDIR=c:\install -j4

- The above command should take about 5-10 minutes to process, and it helps if you have a dual-core processor!

- When it finishes, (Hopefully without error), you can nagivate to C:\install\win32-mingw\ and find a complete Blender installation ready to be zipped up and distributed!

Where to go from here?

You might want to rid the blender.exe of extra useless debug data by entering the following command into the command line:
strip C:\install\win32-mingw\blender.exe
This will reduce the size of the executable by 8mb or so without having any negative impact

scons clean BF_BUILDDIR=C:\install
can be used to clean the build data and getting ready for a new build

Once you have successfully compiled Blender, you can try more customization by following the Advanced Guide.

I am using UDP, so it’s naturally faster than TCP/IP, but delivery is not guranteed.  But for realtime games latency is the main concern, so UDP is definitely the way to go.  The video shows me controlling a cube on the desktop computer (monitor to the right), it’s position data is sent across the internet* to the laptop which displays a similar cube.

Close to the end of the video, I turned off the Wi-Fi on the laptop, killing the network connection.  As expected, the cube stops updating, when I turn it back on, it takes a few second to reconnect, and then the cube starts moving again.

*I route the network traffic through another computer somewhere in town to simulate a more realistic network delay.