diff -urN rt_v13/cross.py rt_v14/cross.py
--- rt_v13/cross.py	2018-04-01 10:49:17.000000000 +0900
+++ rt_v14/cross.py	2018-04-01 20:44:56.000000000 +0900
@@ -10,45 +10,57 @@
 
 # return dic keys 't', 'p', 'nv'
 
-def plane_z0(l, d):
+def plane_z0(crs):
 	# z=0 (x-y)
 
+	l = crs.get('l')
+
 	vz = l.v[2]
 	if vz == 0:
-		return {}
+		return False
 
 	pz = l.p[2]
 	t = -float(pz) / vz
 	if t <= 0:
-		return {}
+		return False
+
+	crs['t'] = t
+	return True
 
-	p = l.on_line_p(t)
-	return { 't': t, 'nv': v.z1, 'p': p }
+def plane_z0_nv(crs):
+	crs['nv'] = v.z1
 
-def plane_z0_xy_cond(l, d):
-	xy_cond_f = d.get( 'xy_cond_f', lambda x, y: True )
-	r = plane_z0(l, d)
-	if not r:
-		return {}
-	(x, y, _) = r.get('p')
-	return r if xy_cond_f(x, y) else {}
+def plane_z0_xy_cond(crs):
+	if not plane_z0(crs):
+		return False
+
+	t = crs.get('t')
+	xy_cond_f = crs.get( 'xy_cond_f', lambda x, y: True )
+
+	l = crs.get('l')
+	(x, y, _) = p = l.on_line_p(t)
+	if not xy_cond_f(x, y):
+		crs.pop('t')
+		return False
+	crs['p'] = p
+	return True
 
-def square(l, d):
+def square(crs):
 	# [-1,-1,0] --- [1,1,0]
-	d['xy_cond_f'] = lambda x, y: abs(x) <= 1 and abs(y) <= 1
-	return plane_z0_xy_cond(l, d)
+	crs['xy_cond_f'] = lambda x, y: abs(x) <= 1 and abs(y) <= 1
+	return plane_z0_xy_cond(crs)
 
-def circle(l, d):
+def circle(crs):
 	# center zero, r=1, z=0
-	d['xy_cond_f'] = lambda x, y: x*x + y*y <= 1
-	return plane_z0_xy_cond(l, d)
+	crs['xy_cond_f'] = lambda x, y: x*x + y*y <= 1
+	return plane_z0_xy_cond(crs)
 
-def triangle(l, d):
+def triangle(crs):
 	# (0,1,0),(-1,0,0),(1,0,0)
-	d['xy_cond_f'] = lambda x, y: x+y<=1 and -x+y<=1 and y>=0
-	return plane_z0_xy_cond(l, d)
+	crs['xy_cond_f'] = lambda x, y: x+y<=1 and -x+y<=1 and y>=0
+	return plane_z0_xy_cond(crs)
 
-def poly_n(l, d):
+def poly_n(crs):
 	n = d.get('n', 3)
 	deg = 360.0 / n
 	rad = mt.deg_to_rad( deg * 0.5 )
@@ -56,16 +68,19 @@
 	w = math.sin(rad)
 	for i in range(n):
 		axi = ax.slide_y(-1).compo( ax.zoom([w,h,1]) ).compo( ax.rot_z(i*deg) )
-		r = triangle( axi.tr('g2l', l), d )
-		if r:
-			return r
-	return {}
+		crs_ = { 'l': axi.tr( 'g2l', crs.get('l') ), 'd': crs.get('d') }
+		if triangle(crs_):
+			crs['t'] = crs_.get('t')
+			return True
+	return False
 
-def ball(l, d):
+def ball(crs):
 	# r = 1, c = zero
 	# l = p + v t
 	# v^2 t^2 + 2 v p t + p^2 = 1^2
 
+	l = crs.get('l')
+
 	a = np.dot( l.v, l.v )
 	b = 2 * np.dot( l.v, l.p )
 	c = np.dot( l.p, l.p ) - 1
@@ -73,13 +88,16 @@
 	ts = mt.quadratic_formula(a, b, c)
 	ts = sorted( filter( lambda v: v > 0, ts ) )
 	if not ts:
-		return {}
-	t = ts[0]
-	p = l.on_line_p(t)
-	nv = v.unit(p)
-	return { 't': t, 'nv': nv, 'p': p }
+		return False
+	crs['t'] = ts[0]
+	return True
+
+def ball_nv(crs):
+	t = crs.get('t')
+	crs['p'] = p = l.on_line_p(t)
+	crs['nv'] = v.unit(p)
 
-def pipe_side(l, d):
+def pipe_side(crs):
 	# r = 1
 	# -1 < z < 1
 
@@ -98,6 +116,8 @@
 	# b = 2 * (px*vx + py*vy)
 	# c = px^2 + py^2 - 1
 
+	l = crs.get('l')
+
 	(px, py, _) = l.p
 	(vx, vy, _) = l.v
 
@@ -108,17 +128,21 @@
 	ts = mt.quadratic_formula(a, b, c)
 	ts = sorted( filter( lambda v: v > 0, ts ) )
 	if not ts:
-		return {}
+		return False
 	tpzs = map( lambda t: ( lambda (x,y,z): (t, [x,y,z], z) )( l.on_line_p(t) ), ts )
 	tpzs = filter( lambda (t,p,z): abs(z) < 1, tpzs )
 	if not tpzs:
-		return {}
+		return False
 	(t, p, _) = tpzs[0]
-	(px, py, _) = p
-	nv = v.unit( [px,py,0] )
-	return { 't': t, 'nv': nv, 'p': p }
+	crs['t'] = t
+	crs['p'] = p
+	return True
+
+def pipe_side_nv(crs):
+	(px, py, _) = crs.get('p')
+	crs['nv'] = v.unit( [px,py,0] )
 
-def cone_side(l, d):
+def cone_side(crs):
 	# 0 < z < 1
 	# r = 1 - z
 
@@ -149,6 +173,8 @@
 	# b = 2*(px*vx + py*vy + (1 - pz)*vz )
 	# c = px^2 + py^2  - pz^2 + 2*pz - 1
 
+	l = crs.get('l')
+
 	(px, py, pz) = l.p
 	(vx, vy, vz) = l.v
 
@@ -159,18 +185,28 @@
 	ts = mt.quadratic_formula(a, b, c)
 	ts = sorted( filter( lambda v: v > 0, ts ) )
 	if not ts:
-		return {}
+		return False
+
 	tpzs = map( lambda t: ( lambda (x,y,z): (t, [x,y,z], z) )( l.on_line_p(t) ), ts )
 	tpzs = filter( lambda (t,p,z): 0<z and z<1, tpzs )
 	if not tpzs:
-		return {}
+		return False
 	(t, p, _) = tpzs[0]
-	(px, py, _) = p
+	crs['t'] = t
+	crs['p'] = p
+	return True
+
+def cone_side_nv(crs):
+	(px, py, _) = crs.get('p')
 	(px, py, _) = v.unit( [px,py,0] )
-	nv = v.unit( [px,py,1] )
-	return { 't': t, 'nv': nv, 'p': p }
+	crs['nv'] = v.unit( [px,py,1] )
+
+def cross(crs):
+	l_g = crs.get('l_g')
+	d = crs.get('d')
+	l2g = d.get('l2g')
+	crs['l'] = lstx.tr( l2g, 'g2l', l_g )
 
-def cross(l, d):
 	dic = {
 		'square': square,
 		'circle': circle,
@@ -182,25 +218,34 @@
 	}
 	f = dic.get( d.get('kind') )
 	if not f:
-		return {}
-	crs = f(l, d)
-	if not crs:
-		return {}
+		return False
+	return f(crs)
+
+def nv(crs):
+	if 't' not in crs:
+		return
 	if 'p' not in crs:
-		crs['p'] = l.on_line_p( crs.get('t') )
-	if 'l' not in crs:
-		crs['l'] = line.new( crs.get('p'), crs.get('nv') )
-	return crs
+		t = crs.get('t')
+		l = crs.get('l')
+		crs['p'] = l.on_line_p(t)
+	dic = {
+		'square': plane_z0_nv,
+		'circle': plane_z0_nv,
+		'triangle': plane_z0_nv,
+		'poly_n': plane_z0_nv,
+		'ball': ball_nv,
+		'pipe_side': pipe_side_nv,
+		'cone_side': cone_side_nv,
+	}
+	d = crs.get('d')
+	f = dic.get( d.get('kind') )
+	if not f:
+		return
+	f(crs)
 
-def cross_g(l_g, d):
+	l_nv = line.new( crs.get('p'), crs.get('nv') )
 	l2g = d.get('l2g')
-	l = lstx.tr( l2g, 'g2l', l_g )
-	crs = cross(l, d)
-	if not crs:
-		return {}
-	crs['l'] = nvl_g = lstx.tr( l2g, 'l2g', crs.get('l') )
-	crs['p'] = nvl_g.p
-	crs['nv'] = nvl_g.v
-	return crs
-
+	crs['l_nv_g'] = l_nv_g = lstx.tr( l2g, 'l2g', l_nv )
+	crs['p_g'] = l_nv_g.p
+	crs['nv_g'] = l_nv_g.v
 # EOF
diff -urN rt_v13/rt.py rt_v14/rt.py
--- rt_v13/rt.py	2018-04-01 11:51:37.000000000 +0900
+++ rt_v14/rt.py	2018-04-01 20:40:13.000000000 +0900
@@ -11,7 +11,8 @@
 import cross
 import img
 
-def map_col(d, crs, rev, video):
+def map_col(crs, rev, video):
+	d = crs.get('d')
 	def_col = d.get( 'def_col', v.all(128) )
 
 	if 'maps' not in d:
@@ -19,7 +20,7 @@
 
 	def f(m):
 		xyz2g = m.get('xyz2g')
-		nv_line = lstx.tr( xyz2g, 'g2l', crs.get('l') )
+		nv_line = lstx.tr( xyz2g, 'g2l', crs.get('l_nv_g') )
 		img_nv = v.z1
 		if np.dot( nv_line.v, img_nv ) < 0:
 			return []
@@ -39,32 +40,36 @@
 	if nest_rate < 0.01:
 		return []
 
-	lst = map( lambda d: ( d, cross.cross_g(l_g, d) ), data )
-	lst = filter( lambda (d, crs): 't' in crs, lst )
+	lst = map( lambda d: { 'l_g': l_g, 'd': d }, data )
+	lst = filter( lambda crs: cross.cross(crs), lst )
 	if not lst:
 		return []
 
 	if ref_len:
 		ref_rate = 0.000001
-		lst = filter( lambda (d, crs): crs.get('t') > ref_len * ref_rate, lst )
+		lst = filter( lambda crs: crs.get('t') > ref_len * ref_rate, lst )
 		if not lst:
 			return []
 
-	(d, crs) = min( lst, key=lambda (d, crs): crs.get('t') )
+	crs = min( lst, key=lambda crs: crs.get('t') )
 
-	rtd = d.get('rtd', {})
+	cross.nv(crs)
+
+	rtd = crs.get('d').get('rtd', {})
 	base = rtd.get('base', 0.3)
 
-	crsp = crs.get('p')
 	crst = crs.get('t')
-	nv = v.unit( crs.get('nv') )
+	crsp = crs.get('p_g')
+
+	nv = v.unit( crs.get('nv_g') )
+
 	eyev = v.unit(l_g.v)
 	eyev_nega = -eyev
 	ang_nv_eyev = np.dot( nv, eyev )
 	ang_nv_eyev_nega = -ang_nv_eyev
 	rev = ang_nv_eyev_nega < 0
 
-	col = map_col( d, crs, rev, video )
+	col = map_col( crs, rev, video )
 	col = mt.arr(col)
 
 	def diffusivity():