Will-Y

Vim plus IPython

2010-04-04T01:36:00.000-07:00

Goal :
1. Via Vim to uniformize coding style for myself or a team.
2. Use IPython to construct an integrated coding envieroment in CG film production.

For uniformizing coding style(or building a rule), I use a simple Vim plug-in snippets.vim to design some useful code snippets, such as main function formats for python, mel and rfs(RealFlow script).

Take a mel snippet for example:

// -*- coding: utf-8 -*-

/*#
  # Name :
  # Author : 
  # Dep : 
  # Org : 
  # Date :
  # Version :
  #
  # Description :
  #
  #*/

global proc main () {
  
}
  
// vim: set sw=4 sts=4 et hls is si nu:

It is easy to get information of a python module in IPython, just via ? and ?? or help. It is really helpful to write docstrings for every module. But, what if we want to know something about mel, rfs or some other languages?

Once we build the rule for coding in any language, we can design a IPython magic command to read and show information of a code file(which was written in our rule), instead of print it all on screen or open it with an editor.

Now, let's edit the ~/.ipython/ipy_user_conf.py to add some custom magic commands:

import IPython.ipapi
ip = IPython.ipapi.get()

def mel(self, arg):
    ...
    show info
    ...

ip.expose_magic("mel", mel)

Here is a demo of the mel magic command:

In [1]: mel dosomething.mel

 Name : dosomething
 Author : Willy Fan
 Dep : TD
 Org : @@a
 Date : Apr 04 04:45 2010
 Version : 1.0

 Description :
     This is a mel procedure that will do something...

 global string proc dosomething (string $action)

Next, for building environment, we can edit /usr/bin/ipython or a custom wrapper, or, create a python module for the wrapper to load(for initializing). In production or some tasks, there will be directories store some python modules that are often used, as a library. If these modules can be imported when we get into IPython, or by a simple command, we can quickly get into work and use the facility of tab completion to find modules we need.

Here is an example while initializing:

import IPython.ipapi
ip = IPython.ipapi.get()

#-----------------

def importModules(paths):
    ...
    ip.ex( "import modules" )   #exec "import modules"  
    ...

#-----------------

import sys

paths = [
    "path01",
    "path02",
    "path03",
    ...
]

sys.path += paths
importModules(paths)

Note that one should use ip.ex( "import modules" ) instead of exec "import modules" , or the imported modules will remain just within the local scope of importModules.

By making these efforts, we can use Vim and IPython to construct a simple integrated coding environment for Python, Maya, RealFlow, Nuke, and other 3D applications in a CG film production.

JDBC and MySQL

2009-11-01T06:55:00.000-08:00

（１）安裝MySQL：MySQL Community Server

下載位址：http://dev.mysql.com/downloads/#community-server
安裝時設定Root密碼...

（２）下載MySQL Connector/J：for connecting to MySQL from Java

下載位址：http://dev.mysql.com/downloads/#connector-j

（３）解壓縮MySQL Connector/J，自訂存放位置，設定環境變數中的CLASSPATH

存放位置如C:\Program Files\Java\MySQL Connector Java；設定CLASSPATH時輸入mysql-connector-java*.jar 所在位置的完整位址（有關CLASSPATH的資訊可問Google）

（４）進入MySQL Command Line Client：建立資料庫及使用者帳戶

這時須使用SQL語法：
mysql>CREATE DATABASE myfirstdb;
mysql>USE myfirstdb;
mysql>CREATE USER ' willy ' @ ' localhost ' IDENTIFIED BY ' gygy9gy ' ;
mysql>GRANT all ON myfirstdb TO ' willy ' @ ' localhost ' IDENTIFIED BY ' gygy9gy ' ;
mysql>FLUSH PRIVILEGES;

（５）撰寫Java程式來連接MySQL：

（６）連連看！

Using RIB Archive

2009-05-03T10:54:00.000-07:00

Goal :
1. Understand what is called RIB archive?
2. How to import RIB archives in RenderMan for Maya?
3. How RIB archives work with RenderMan shaders?

Simply put, RIB (RenderMan Interface Bytestream) is a file format defined by the RenderMan Standard, while a RIB archive is a RIB file contains description of a scene.

Let us see what Pixar says:
One important use of the RIB protocol is to store a scene description in an archive file for rendering at a later time or in a remote location from the modeling application.*

Procedures:

1. Generating RIB archives:

We could generate RIB archives by using some 3D programs like Maya (by Renderman for Maya) , Houdini and so on.
Before exporting RIB archive, choose full path option may help us to avoid loading problem.

2. Loading RIB archives in Maya:

Create a locator (locators) or a polygon cube and then attach a RIBBox to them, where the locator or cube here represents the geometry loaded by RIB archive.
Create a RIBBox or a RIBBox connected to an Ensemble shader. After doing so, input codes as ReadArchive "RIB file name" for loading RIB archive.
Attach the shader to the locater and render, we can see...

For more flexibility, we can add more functions to the shader.

But, here comes a problem, image won't be changed as we wished after rendering.The additional functions won't be applied on the geometry for there has been a shader loaded from RIB archive and applied on the geometry.

Since the RIB archive can't be changed in the current Maya scene, we need to edit the RIB archive to reach our purpose.
By marking the line that imports RenderMan shaders, the additional functions of the shader in the current scene can be applied to the geometry.

* These descriptions are quoted from Pixar RenderMan Artist Tools 6.5 document

Rendering Secondary Outputs (AOVs in RenderMan) - Part II

2009-04-24T22:52:00.000-07:00

Goal :
1. While generating AOVs, what is the relationsip between variables in SLBoxs and secondary display settings in RenderMan Globals(RG).
2. In Slim console, using rmanctl commands to manipulate secondary display settings in RG.

For generating secondary outputs, we can declare some variables in SLBox and give them some initial values and output values.

What makes those variables be generated as so called AOVs is the setting of secondary display in RG.

How to create new AOVs by setting RG? The standard procedures would be:

1. Add a new channel: The new channels are those variables defined in the SLBox.

2. Add a new secondary display: The name of the new display would be a part of the file name when images was rendered.

3. Setup secondary display: Under the secondary display which we have created, we can deside what kind of type the output file of the AOV should be generated by, and add channels to this display.

Now I will use rmanctl commands to setup AOVs in RG:

1. In the beginning, we should get a list of their ids to prevent overwriting the existing values:

rmanctl GetChannelIDs
rmanctl GetDspyIDs

Commands above will return a string of ids, the id of new channels or displays should be greater than the last one in the list.

2. Add a new channel:
rmanctl InitChannel id
rmanctl SetValue channelDspyMode_id {color glow_matte}

where "id" here is based on the channel id list.

3. Add a new secondary display:
rmanctl InitDspy id
rmanctl SetValue dspyName_id ball_matte
rmanctl SetValue dspyMode_id glow_matte
rmanctl SetVlaue dspyType_id openexr

where "id" here is based on the display id list.

4. For adding more than one channel, use commas to separate modes:
rmanctl SetValue dspyMode_id glow_matte,body_matte,a,...

Unfortunately, rmanctl commands are not documented in the manual of Pixar RAT or RMS. But we still can get some informations by typing rmanctl in Slim console.

Rendering Secondary Outputs (AOVs in RenderMan) - Part I

2009-04-17T08:13:00.000-07:00

Goal :
1. Understand what is called Secondary Output (AOV).
2. Realize the process how to generate AOVs when rendering passes.

Pixar says:
Secondary outputs are also called Arbitrary Output Variables, or AOVs. These outputs are not rendered in multiple passes, but are created at the same time the main image is being rendered.*

Now we are about to render an image and generate its AOVs.

1. Create a Maya geometry, a cube for example:

2. Create RenderMan shaders (Ensemble with surface property connected to a Delux) and attach them to the Maya geometry:

3. Create SLBox and Edit RenderMan Globals(RG):

Instead of adding new secondary outputs in RG by hand, I would like to use my AOV creating tool to finish this step, for the reason that I want to introduce something about rmanctl command, which can help us to control secondary outputs in RG by coding. See Part II of this article.
Select Delux shaders and declare AOV title, variable types, names, initial values and output values.
After pushing "Add AOV" button, a SLBox shading component with contents shown below will be created and connected to each Delux shader . There are three Delux shaders, each represents the surface appearance of the specific faces of the cube. (How to add SLBox in Delux shader?)

faceA with output (1,0,0) as red
faceB with output (0,1,0) as green
faceC with output (0,0,1) as blue
Let us go to RG, the secondary outputs have already been created. The picture shown below will show us that in our rendered pass, there will be an openexr image with "matte" in its file name, and four channels in this image. Now we can setup and render.

4. After the render job was finished, search the images by Apple Shake, we can see that "test.0001.tif " and " test_bty.0001.exr " are our primary outputs, " test_matte.0001.exr " is our secondary output.

Open " test_matte.0001.exr ":

5. By checking out the property panel of this image, we can see the channels contained in the image. Let us select red channel of faceA, green channel of faceB and blue channel of faceC.

6. This is our secondary outputs, quite simple and easy, isn't it?

In the end, while rendering passes, it will be very valuable for compositing if we define some special AOVs. With these proper AOVs, compositing can be more flexible.

* These descriptions are quoted from Pixar RenderMan Artist Tools 6.5 document

RAT6.5 : Add SLBox in Delux - Part IV

2009-04-16T11:11:00.000-07:00

Goal :
From viewing slim.ini and .slim file to understand the details of the command structure like
::Slim::CustomUI::pixar::AddParam::AddParam arg arg.

To reach the goal, let us take a view in slim.ini first. The code shown below is the first line written in the slim.ini, where ::Slim is a global namespace.

The following picture shows that there are many .slim files defined to build custom user interface(customui).

As for the reason why wasn't it written as CustomUI, it might be defined in a file somewhere (I haven't found it yet...), but we can find some information in the Slim scripting document:
CustomUIs are defined on Collection properties. These methods access the CustomUI information for a collection.*

collh GetCustomUIVendor
collh GetCustomUIName
collh GetCustomUIModes

Let us see how to use these commands:

As we can see, when invoking coll0 by GetCustomUIVendor, we get pixar, and by GetCustomUIName we get AddParam. (I will not talk about CustomUIModes since I haven't found information about it)

Now we should have a rough picture about ::Slim::CustomUI::pixar::AddParam:: as

[global namespace] + [defined command] + [UI vendor] + [UI name]

The additional AddParam, as the final member of the command, can not be seen in the picture shown above. (where the result of coll0 GetName is not what we are looking for)

Go to Pixar installation folder and search for addparamui.slim, we can find information to prove the conclusion described above:

See pixar is upon AddParam in hierarchy, and AddParam is declared as a customui. In the bottom of the codes, we can find a procedure called AddParam and this is the last member we are looking for, thank god !!

The two parameters are collection and type (and additional prefix string) , that is why we take the two arguments as componentcontainer(collection) and shadingcomponent(type)

* These descriptions are quoted from Pixar RenderMan Artist Tools 6.5 document

RAT6.5 : Add SLBox in Delux - Part III

2009-04-14T07:45:00.000-07:00

Goal :
1. Understand how to use template.
2. Understand property object and details of the property, GetDetail and SetDetail of property commands.

Slim template:
Slim uses templates to define the functions that are combined and manipulated in order to create custom shaders.*

The default templates are defined and stored in Pixar RenderMan for Maya installation folder, search for slim.ini to get a list of templates to use. Here are a few commands that shows us how to use template, it's simple and easy:
$plt CreateInstance -template "pixar,Ensemble#0" --> create an appearance
$app GetTemplate --> get its template
slim GetAppearances -template pixar* --> get appearances build by the template
slim GetTemplates -type "color" --> list active template by "shadingcomponent" type

According to the description above, Slim template is used to create custom shaders. What are the connections between template, appearance and shader? Let's see how Pixar describes about them:
A shader is the principal procedural entity and an appearance is a description of how to invoke the procedure.*

So here comes a conclusion that we create functions from defined templates as the so called appearances, and we organize these appearances (compile them) to become a shader or shaders.

Property Object:
Property is a base class representing the Parameters, Collections and Attributes inside of an appearance.*

Each property has its own detail, the detail can be :
uniform --> cannot be connected to a function
varying --> can be connected to a function
must vary --> must be connected to a function

After a parameter or a collection was created, its detail would be uniform by default, if we set it to be mustvary, we get some changes :
set parm [$app NewParameter color "v7"]

$parm SetDetail mustvary

$parm SetDetail uniform (Its color won't be recovered)

* These descriptions are quoted from Pixar RenderMan Artist Tools 6.5 document

RAT6.5 : Add SLBox in Delux - Part II

2009-04-12T08:56:00.000-07:00

Goal :

Understand Collection object and Parameter object in Slim scripting.

Actually, there is another way to achieve the goal mentioned in Part I. There exists some critical points by using this way.

After calling a Delux shader:
set newprop [$delux NewParameter shadingcomponent "v1"]
(eval) $newprop SetDetail mustvary "pixar,C_SLBox#0 (inlline)"
$newprop SetConnection [$slbox GetID] 　

No matter how hard we try, what we've got is a shading component connected to a SLBox with no inline state. You can say that at least we've created a connection successfully. But, If we type the following commands:
set container [$delux GetProperties -name "componentcontainer"]
$container GetChildren

These commands will show us how many children are under the component container, and our shading component is not here.

Component container contains collections, and what we've created is a parameter. They are different objects in Slim scripting. Let us see how Pixar describe them:

Collection Object:
Collection objects are used to group Parameters and Attributes. Since they do not have a value.*

Parameter Object:
What sets the Parameter class apart from other subclasses is its existence inside of the shader. It is for this reason that the methods specific to Parameter are oriented toward its presencing in shading language.*

Therefore, We can use NewCollection to generate a new collection, and use NewParameter to add parameters under the collection.

* These descriptions are quoted from Pixar RenderMan Artist Tools 6.5 document

RAT6.5 : Add SLBox in Delux - Part I

2009-04-10T11:07:00.000-07:00

Goal :
1. Within a Delux shader, create a new property of shading component type.
2. Make it connect to a SLBox function with inline state, as "v1" in the picture shown below.

("inline" means we can deal with the SLBox function within Delux shader without actually going into the SLBox node)
This instruction is based on RenderMan Artists Tools 6.5 on Linux system. Let's select a Delux node and find the property called component container. There are at least ways for creating a new shading component property:

1. By using the following command:
　set newprop [$container NewCollection shadingcomponent "v1"]

2. By using the following commands:
　set command "::Slim::CustomUI::pixar::AddParam::AddParam"
　set newprop [$command $container shadingcomponent]

Using method 1, we need to assign a SLBox function to the property and make it be inline state:
　eval $newprop SetDetail mustvary "pixar,C_SLBox#0 inline"

Using method 2, we just need to change the function type diffuse to SLBox:
　$newprop SetDetail mustvary "pixar,C_SLBox#0"

In the end, we just need to set connection between the parameter and the SLBox node. The following shows TCL version and Python version of codes to do this:

TCL version, executed in Slim console

Python version, executed in Maya with Mtor Slim command

Key word : this

2009-04-09T10:33:00.000-07:00

在以下類別繼承的架構下，設計每一個子類別都有印出自己和父類別的方法，當宣告 B myB = new B() 時，呼叫 myB.showAB() 可以順利印出 "AB"！　

但當宣告 C myC = new C() 時，呼叫 myC.showABC() 卻印出 "ACC"！！

class A {

    public void show() {

        System.out.print("A");
    }
}

class B extends A {

    public void show() {

        System.out.print("B");
    }

    public void showAB() {

        super.show();－－－－－－－印出A

        this.show();－－－－－－－－印出B
    }
}

class C extends B {

    public void show() {

        System.out.print("C");
    }

    public void showABC() {

        super.showAB();－－－－－－印出AC

        this.show();－－－－－－－－印出C
    ｝
}

原因在於宣告 C myC = new C() 時，myC.showABC() 呼叫了super.showAB()，而B類別的 showAB() 中所執行的this.show() 事實上卻是呼叫C類別所override的 show() 方法，故印出C！

結論：

一般 this 所指的是所在類別的物件參考，但事實上如同 this 字面上所傳達的訊息：我並沒有參考到特定的物件，那麼 this 廣義來看應該是參考到所創建的物件，如 C myC = new C() 時，父類別的 this 是參考到 C 的物件；如果在父類別定義一個子類別沒有的方法，再用 this 呼叫：

class B extends A {

    public void show() {

        System.out.print("B");

    }

    public void showAB() {

        super.show();

      ＊this.someMethod();

        this.show();
    }

    public void someMethod() {}
}

class C extends B {

    public void show() {

        System.out.print("C");
    }

}

那麼 this.someMethod() 的呼叫應該是先在物件 C 中搜尋 someMethod 方法，找不到再搜尋父類別！

使用 "this" 呼叫該類別的方法是常見的手法，但在繼承架構中，若程式的設計如同範例一般，在編譯期不會發生問題，到了執行時才會從結果中知道出了錯！當然，解決問題的寫法有許多種...

若使用類別方法 (class methods)，那麼一切就會變得很簡單，每個類別只需要定義一個 static void show( ) { 印出所在類別名稱 }，只要在最後一個子類別定義一個方法 (類別方法或實體方法都可以)，以類別名稱來呼叫各自的"靜態(static)" show() 方法：

class D extends C {

    public static void show() {

        System.out.println("D");
    }

    public (static) void showABCD() {

        A.show() ;

        B.show();

        C.show();

        D.show();
    }
}

Literal value

2009-04-09T10:10:00.000-07:00

整數的字面值編譯器預設指定為int type，浮點數的字面值編譯器預設指定為double type，若float y=3.14不合法且必須加上 F/f 讓編譯器跳過預設而將3.14配置給float type，為何byte x=127可順利編譯？(short x=127亦可)

byte x = 127;
float y = 3.14F;

處理等號右邊記憶體空間大於等號左邊記憶體空間問題，以下為相同邏輯的(casting)處理程序！

double a = 3.14;
float b = (float)a;

int c = 127;
byte d = (byte)c;

問題解答：引述自JavaWorld@TW Duncan網友－這與數據所帶的資訊在 assignment 後是否會遺失有關：

integer value 127 (int type by default) 在 assign 給 byte storage 後資訊完全不會遺失；floating-point value 3.14 (double type by default) 在assign 給 float stoarge 會遺失部分資訊(不準確)！
127 以 2's complement 方式表示的 binary 可以存在byte型態的 8 bits 空間裡，double 3.14 是 3.14 的近似值，將此值 assign 給 float 後也是 3.14 的近似值，但由於float type 的 mantissa(or fraction) bits 比 double 來得少，所以將一個 double value assign 給 float storage 後誤差會變大！

根據以上的敘述所給出的線索，我做了以下實驗：

//Is int 127 equal to byte 127?

byte e = 127;

if((e-127)==0) System.out.println("Yes!");

else System.out.println("No!");


//Is double 3.14 equal to float 3.14?

float f = 3.14F;

if((f-3.14)==0) System.out.println("Yes!");

else {

    System.out.print("No!");

    System.out.println("Thｅ error = " + (f-3.14));
}

答案是No!

但我得到一個有趣的結果 : float 3.14 大於 double 3.14!
這是否是常態的結果呢?

//Is float type value greater than double type value?

float g;

for(double i=3.14 ; i < 3.15 ; i+=0.001) {

    g = (float)i;

    System.out.println(g-i);
}


＝＝＝＝＝＝＝＝＝＝＝＝

Results：

1.0490417468034252E-7

3.2424926743601645E-8

-4.005432119313923E-8

-1.1253356912988011E-7

5.340576203494152E-8

-1.907348590179936E-8

-9.155273383854023E-8

7.438659732628139E-8

1.9073493895405136E-9

-7.057189854720036E-8

9.536743261762126E-8

＝＝＝＝＝＝＝＝＝＝＝＝

作了以上試驗得到一些振盪的結果！

//Let's see how float type stores data from double type.
float h = (float)Math.PI;
double i = Math.PI;
System.out.println(i);
System.out.println(h);
System.out.println(3.14159261535F);

上述說明當超過float範圍的數值存入float時，數值會被截斷以放入float的記憶體空間；float數值與double數值之差異在於數值被截斷時如何進位？上面程式碼的最後一行說明若被砍掉那一端的第一個位數為0或1時，前一個位數會減1；若第一個位數大於等於2時,前一個位數均加1...

GCJ in Cygwin

2009-04-08T10:09:00.000-07:00

Java codes compiled by GNU gcj in cygwin.

很早就知道GNU的gcc有編譯java code的套件，但一直沒有嘗試著去學習，又或者當年試著要在windows下使用gcc編譯c++ code結果無法有效吸收網路上的資訊而作罷。現在捲土重來，在windows環境下裝上了cygwin要來測試用gcc內部的gcj來編譯java code，其實目的只是為了測試另一種程式的開發環境！

@GNU GCC網站　－　http://gcc.gnu.org/
@cygwin下載網址　－　http://www.cygwin.com/

Ｓｔｅｐ　１　－－－　安裝cygwin

cygwin是一套Linux like環境，專門在MS Windows下運行

@cygwin網站　－　http://www.cygwin.com/

Ｓｔｅｐ　２　－－－　選取必要的套件

在Category項目中點開Devel，右邊列出許多套件(多半都是skip)，找到gcc字眼的套件選擇c,c++和java相關的套件，點選skip就會變成版本序號，然後接續安裝。

Ｓｔｅｐ　３　－－－　編寫程式

跳過.............................

Ｓｔｅｐ　４　－－－　cygwin視窗下編譯程式

＄ gcj -C hello.java

呼叫gcj編譯器並使用適當的options指令，此時可以去參考ＧＣＪ的使用手冊。

1.6 Code Generation說明 " -C " 指令可告知gcj編譯出bytecode( .class 檔)而非object code( .o 檔)。

@GCJ的網站　－　http://gcc.gnu.org/java/
@Documentation內的GCJ Manual　－　http://gcc.gnu.org/onlinedocs/gcj/

[註]：執行gcj --help，會發現gcj所提供的指令為 " -c " 而非 " -C " ！使用 " -c " 編譯會得到 .o 檔。

Ｓｔｅｐ　５　－－－　cygwin視窗下執行bytecode

＄ gij hello
＜show result＞

在cygwin下要執行bytecode必須呼叫gij，gij是java bytecode的interpreter。