My CG was selected as an excellent work on ASIAGRAPH 2009

Hi, I'm NISHIO Hirokazu. Today I announce a good news (for me!)

My CG artwork was selected as an excellent work by ASIAGRAPH 2009 committee. It will be displayed on 10/22-25 at Odaiba, Tokyo. See below, "Virtual Star" is mine. It shows recursive birth of 5 children of rings.


For more informations: http://www.asiagraph.jp/public/index.html

printed with EPSON's PX-5002

Hi, it is NISHIO Hirokazu. I was present at a blogger event yesterday. It is about EPSON's brandnew printer for professionals PX-5002. It was nice experience to print own graphics out and make a displayable object.





Cool! The printer has 3 grayish inks so it is good to print gray-scale image.

Professional photographer NAKAI Seiya said it is not strange if the display is sold in IKEA.



Here is a movie, but unfortunately compression made it dirty. I'm looking for a chance to display my works.

iPhone Camera and its motion blur

Hi, it is NISHIO Hirokazu. I bought iPhone 3GS yesterday! I found the response of camera is very slow. It is nice! You can make interesting pattern of motion bulr very easily.

---

Ivanhoe said... "A former colleague of mine used to play a lot with his CRT TV and video camera, making a lot of interesting patterns : http://chabin.laurent.free.fr/camera/ccd.htm" Oh! That's nice! I'm very interested in turing patterns.

How to calculate Bezier curves' bounding box

Hi, it is NISHIO Hirokazu. Today I wanted to make a lot of Bezier curves same size. And I got it.

Here is what I want to draw:


To calculate bounding box of cubic Bezier seems easy, especially you know its parametric form. See Bézier curve - Wikipedia, the free encyclopedia

However, there are some pitfall. The derivative of Bezier equation is usually quadratic equation but not always. Solutions of the derivative may out of range, etc.

I publish following source code under MIT License. Feel free to use it.

def calc_box(start, curves):
    P0 = start
    bounds = [[P0[0]], [P0[1]]]

    for c in curves:
        P1, P2, P3 = (
            (c[0], c[1]), 
            (c[2], c[3]), 
            (c[4], c[5]))

        bounds[0].append(P3[0])
        bounds[1].append(P3[1])

        for i in [0, 1]:
            f = lambda t: (
                (1-t)**3 * P0[i] 
                + 3 * (1-t)**2 * t * P1[i] 
                + 3 * (1-t) * t**2 * P2[i]
                + t**3 * P3[i])

            b = 6 * P0[i] - 12 * P1[i] + 6 * P2[i]
            a = -3 * P0[i] + 9 * P1[i] - 9 * P2[i] + 3 * P3[i]
            c = 3 * P1[i] - 3 * P0[i]

            if a == 0:
                if b == 0:
                    continue
                t = -c / b
                if 0 < t < 1: 
                    bounds[i].append(f(t))
                continue

            b2ac = b ** 2 - 4 * c * a
            if b2ac < 0: 
                continue
            t1 = (-b + sqrt(b2ac))/(2 * a)
            if 0 < t1 < 1: bounds[i].append(f(t1))
            t2 = (-b - sqrt(b2ac))/(2 * a)
            if 0 < t2 < 1: bounds[i].append(f(t2))

        P0 = P3

    x = min(bounds[0])
    w = max(bounds[0]) - x
    y = min(bounds[1])
    h = max(bounds[1]) - y
    return (x, y, w, h)

---

Blaze Boy asked me about the structure, thank you. for each c in curves is 6-tuples: P1, P2, P3 = ((c[0], c[1]), (c[2], c[3]), (c[4], c[5])) P0 and P3 are terminal points of each bezier curves.

Fractal aurora(Koch curve)

Hi, it is NISHIO Hirokazu. I wondered how we see if there is aurora in Koch curve. So I wrote a python script run on Blender. Let see it(click to enlarge):



The script is as follow. It is not beautifil because I'm just a beginner of Blender. A lot of lines are copy of sample.

from Blender.Mathutils import Vector
from Blender import *
from math import sin, cos, pi

class Turtle(object):
    def __init__(self):
        self.x = 0.0
        self.y = 0.0
        self.dirx = 1.0
        self.diry = 0.0
        self.vert2d_list = [(0.0, 0.0)]
        self.faces = []

    def forward(self, mag):
        self.x += self.dirx * mag 
        self.y += self.diry * mag 
        self.vert2d_list.append((self.x, self.y))

    def rot(self, rad):
        self.dirx, self.diry = (
            self.dirx * cos(rad) - self.diry * sin(rad),
            self.dirx * sin(rad) + self.diry * cos(rad))
    
    def build_mesh(self, z=0.0, name="Mesh"):
        verts3d = [Vector(x, y, z) for (x, y) in self.vert2d_list]
        me = Mesh.New(name + str(z))          # create a new mesh
        me.verts.extend(verts3d)          # add vertices to mesh
        me.faces.extend(self.faces)           # add faces to the mesh (also adds edges)
        return me

def deg(x):
    return 2 * pi / 360 * x

def makeHalo(x):
    mat = Material.New('Halo')          # create a new Material called 'newMat'
    mat.rgbCol = [0.7 * x, 0.7, 0.1]          # change its color
    mat.setAlpha(0.3 * (1 - x))                     # mat.alpha = 0.2 -- almost transparent
    #mat.emit = 0.7                        # equivalent to mat.setEmit(0.8)
    #mat.mode |= Material.Modes.ZTRANSP    # turn on Z-Buffer transparency
    #mat.setAdd(0.8)                       # make it glow
    mat.setMode('Halo')                   # turn 'Halo' "on" and all others "off"
    return mat

def koch(level=1, unit=1):
    if level == 0:
        turtle.forward(unit)
    else:
        koch(level - 1, unit)
        turtle.rot(deg(60))
        koch(level - 1, unit)
        turtle.rot(deg(-120))
        koch(level - 1, unit)
        turtle.rot(deg(60))
        koch(level - 1, unit)
        

turtle = Turtle()
koch(4, 0.6)

for i in range(100):
    ob = Object.New('Mesh', 'myObj')  # link mesh to an object
    m = turtle.build_mesh(i / 5.0)
    m.materials += [makeHalo(i / 100.0)]
    ob.link(m)

    sc = Scene.GetCurrent()          # link object to current scene
    sc.link(ob)