diff -urN rt_v28/Makefile rt_v29/Makefile --- rt_v28/Makefile 2018-04-24 01:06:42.000000000 +0900 +++ rt_v29/Makefile 2018-04-30 01:49:22.000000000 +0900 @@ -1,11 +1,17 @@ CC = gcc CFLAGS += -Wall -OBJS = rt_sock.o rt.o cross.o lstx.o ax.o cylx.o fcx.o vecs.o line.o v.o mt.o +OBJS = dat.o val.o sock.o lstx.o ax.o cylx.o fcx.o vecs.o line.o v.o mt.o ut.o -all: rt_sock +#all: cross rt +all: cross + +cross: cross.c $(OBJS) + gcc -DSRV_CROSS -o $@ cross.c $(OBJS) -lm + +rt: rt.c cross.c $(OBJS) + gcc -DSRV_RT -o $@ rt.c cross.o $(OBJS) -lm -rt_sock: $(OBJS) - gcc -o $@ $(OBJS) -lm clean: - rm -f *.o *~ rt_sock + rm -f cross rt + rm -f *.o *~ # EOF diff -urN rt_v28/ax.py rt_v29/ax.py --- rt_v28/ax.py 2018-04-07 23:52:48.000000000 +0900 +++ rt_v29/ax.py 2018-04-26 00:47:41.000000000 +0900 @@ -6,7 +6,6 @@ import v import line import vecs -import img def new(p, vs): # vs: vecs @@ -77,10 +76,6 @@ wh_map = lambda w, h: slide( [-w*0.5,-h*0.5,0] ).compo( zoom_all(1.0/w) ).compo( rot_x(180) ) -def fn_map(fn): - (w, h) = img.wh(fn) - return wh_map(w, h) - new_line = lambda l: new( l.p, vecs.by_fix_ref('y', l.v, 'z', v.z1) ) # EOF diff -urN rt_v28/bin.py rt_v29/bin.py --- rt_v28/bin.py 2018-04-23 22:02:00.000000000 +0900 +++ rt_v29/bin.py 2018-04-30 01:48:34.000000000 +0900 @@ -29,11 +29,17 @@ col = [] return (col, s) -pack_str = lambda str: pack_i4( len(str) ) + str.encode() +pack_bytes = lambda b: pack_i4( len(b) ) + b -def unpack_str(s): +def unpack_bytes(s): (n, s) = unpack_i4(s) - return ( s.decode(), s ) + return ( s[:n], s[n:] ) + +pack_str = lambda str: pack_bytes( str.encode() ) + +def unpack_str(s): + (b, s) = unpack_bytes(s) + return ( b.decode(), s ) pack_np64 = lambda np64_arr: np64_arr.tobytes() if six.PY3 else bytes( np.getbuffer(np64_arr) ) @@ -45,15 +51,15 @@ (a, s) = unpack_np64(s, 1) return (a[0], s) -pack_p = lambda p: pack_np64(p) +pack_xyz = lambda xyz: pack_np64(xyz) -unpack_p = lambda s: unpack_np64(s, 3) +unpack_xyz = lambda s: unpack_np64(s, 3) -pack_line = lambda l: pack_p(l.p) + pack_p(l.v) +pack_line = lambda l: pack_xyz(l.p) + pack_xyz(l.v) def unpack_line(s): - (p, s) = unpack_p(s) - (v, s) = unpack_p(s) + (p, s) = unpack_xyz(s) + (v, s) = unpack_xyz(s) return ( line.new(p, v), s ) pack_vs = lambda vs: pack_np64(vs.v3) @@ -62,10 +68,10 @@ (v3, s) = unpack_np64(s, 3*3) return ( vecs.new( v3.reshape(3,3) ), s ) -pack_ax = lambda ax: pack_p(ax.p) + pack_vs(ax.vs) +pack_ax = lambda ax: pack_xyz(ax.p) + pack_vs(ax.vs) def unpack_ax(s): - (p, s) = unpack_p(s) + (p, s) = unpack_xyz(s) (vs, s) = unpack_vs(s) return ( ax.new(p, vs), s ) @@ -141,9 +147,8 @@ ltd_k_nm_lst = [ ('pvi', 'i4'), - ('dmy', 'i4'), - ('p', 'p'), - ('v', 'p'), + ('p', 'xyz'), + ('v', 'xyz'), ('e', 'f8'), ] @@ -151,7 +156,6 @@ k = 'p' if 'p' in ltd else 'v' dic = { 'pvi': ltd_pvs.index(k), - 'dmy': 0, 'p': ltd.get( 'p', mt.zero ), 'v': ltd.get( 'v', mt.arr([0,0,-1]) ), 'e': ltd.get( 'e', 1.0 ), @@ -165,8 +169,10 @@ return (ltd, s) nms = [ - 'i4', 'col', 'str', 'np64', 'f8', 'p', 'line', 'vs', - 'ax', 'cx', 'fx', 'xx', 'lx', 'rtd', 'ltd', + 'i4', 'col', 'bytes', 'str', 'np64', 'f8', + 'xyz', 'line', 'vs', + 'ax', 'cx', 'fx', 'xx', 'lx', + 'rtd', 'ltd', ] packs = ut.map_lst( lambda nm: eval('pack_' + nm), nms ) diff -urN rt_v28/cg.py rt_v29/cg.py --- rt_v28/cg.py 2018-04-23 21:30:00.000000000 +0900 +++ rt_v29/cg.py 2018-04-30 01:48:52.000000000 +0900 @@ -4,271 +4,19 @@ import math import ut import mt -import v import line import ax -import cylx import fcx import lstx -import img -import img_sock import way import wf import rt import dat -import rt_sock - -def if_not_set_opt(d, k, v): - ut.if_not_set(d, k, v) - ut.dic_set( d, k, lstx.opt( d.get(k) ) ) - -def if_not_set_idx(d, k): - if k in d: - v = d.get(k) - if type(v) != int: - f = img_sock.client.get_idx if 'use_img_srv' in sys.argv else img.get_idx - d[k] = f(v) - -def m_setup(d, m): - # 'fn' in d - - if_not_set_idx( m, 'fn' ) - if_not_set_idx( m, 'fn_r' ) - - #if_not_set_opt( m, 'wh2xyz', [ ax.fn_map( m.get('fn') ) ] ) - wh_func = img_sock.client.wh if 'use_img_srv' in sys.argv else img.wh - (w, h) = wh_func( m.get('fn') ) - if_not_set_opt( m, 'wh2xyz', [ ax.wh_map(w, h) ] ) - - if 'xyz2t' not in m: - lst = [] - if 'r' in m: - lst += [ cylx.new( m.get('r') ) ] - if 'dz' in m: - lst += [ fcx.new( m.get('dz') ) ] - if_not_set_opt( m, 'xyz2t', lst ) - - if_not_set_opt( m, 't2m', [] ) - if_not_set_opt( m, 't2g', m.get('t2m') + d.get('m2g') ) - if_not_set_opt( m, 'xyz2g', m.get('xyz2t') + m.get('t2g') ) - if_not_set_opt( m, 'wh2g', m.get('wh2xyz') + m.get('xyz2g') ) - -def d_setup(d): - # return lst [d] - - kind = d.get('kind') - - if kind == 'poly_n': - n = d.get('n', 3) - deg = 360.0 / n - rad = mt.deg_to_rad(deg/2) - h = math.cos(rad) - b = math.sin(rad) - - def poly_n_f(i): - d_ = d.copy() - d_['kind'] = 'triangle' - d_['l2m'] = [ ax.slide_y(-1), ax.zoom([b,h,1]), ax.rot_z(deg*i) ] + d_.get( 'l2m', [] ) - return d_setup( d_ ) - - return sum( map( poly_n_f, range(n) ), [] ) - - if kind == 'cube': - def cube_f(l, deg): - d_ = d.copy() - d_['kind'] = 'square' - d_['l2m'] = [ ax.slide_z(1), ax.rot(l, deg) ] + d_.get( 'l2m', [] ) - return d_setup( d_ ) - rots = [ - (line.x1, 0), (line.x1, 90), (line.x1, 180), (line.x1, -90), - (line.y1, 90), (line.y1, -90) - ] - return sum( ut.map_up( cube_f, rots ), [] ) - - if kind == 'tri_prism_side': - d0 = d.copy() - d0['kind'] = 'square' - d0['l2m'] = [ ax.rot_x(90) ] + d0.get( 'l2m', [] ) - - d1 = d.copy() - d1['kind'] = 'square' - zm = math.sqrt(2) / 2 - d1['l2m'] = [ ax.rot_x(-90), ax.slide_x(-1), ax.zoom_x(zm), ax.rot_z(-45), ax.slide_x(1) ] + d1.get( 'l2m', [] ) - - d2 = d.copy() - d2['kind'] = 'square' - d2['l2m'] = [ ax.rot_x(-90), ax.slide_x(1), ax.zoom_x(zm), ax.rot_z(45), ax.slide_x(-1) ] + d2.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1,d2] ), [] ) - - if kind == 'tri_prism': - d0 = d.copy() - d0['kind'] = 'tri_prism_side' - - d1 = d.copy() - d1['kind'] = 'triangle' - d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] ) - - d2 = d.copy() - d2['kind'] = 'triangle' - d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1,d2] ), [] ) - - if kind == 'poly_n_prism_side': - n = d.get('n', 3) - deg = 360.0 / n - rad = mt.deg_to_rad(deg/2) - h = math.cos(rad) - b = math.sin(rad) - - def poly_n_prism_side_f(i): - d_ = d.copy() - d_['kind'] = 'square' - d_['l2m'] = [ ax.rot_x(90), ax.zoom_x(b), ax.slide_y(-h), ax.rot_z(deg*i) ] + d_.get( 'l2m', [] ) - return d_setup( d_ ) - - return sum( map( poly_n_prism_side_f, range(n) ), [] ) - - if kind == 'poly_n_prism': - d0 = d.copy() - d0['kind'] = 'poly_n_prism_side' - - d1 = d.copy() - d1['kind'] = 'poly_n' - d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] ) - - d2 = d.copy() - d2['kind'] = 'poly_n' - d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1,d2] ), [] ) - - if kind == 'four_pyramid_side': - n = 4 - zm = math.sqrt(2) - - def four_pyramid_side_f(i): - d_ = d.copy() - d_['kind'] = 'triangle' - d_['l2m'] = [ ax.zoom_y(zm), ax.rot_x(45), ax.slide_y(-1), ax.rot_z(90*i) ] + d_.get( 'l2m', [] ) - return d_setup( d_ ) - - return sum( map( four_pyramid_side_f, range(n) ), [] ) - - if kind == 'four_pyramid': - d0 = d.copy() - d0['kind'] = 'four_pyramid_side' - - d1 = d.copy() - d1['kind'] = 'square' - d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1] ), [] ) - - if kind == 'tri_pyramid_side': - d0 = d.copy() - d0['kind'] = 'triangle' - d0['l2m'] = [ ax.rot_x(90) ] + d0.get( 'l2m', [] ) - - h = math.sqrt( 1 + 0.5 ) - b = math.sqrt(2)/2 - deg = mt.rad_to_deg( math.atan2(1, b) ) - - d1 = d.copy() - d1['kind'] = 'triangle' - d1['l2m'] = [ ax.zoom([b,h,1]), ax.rot_x(deg), ax.rot_z(90+45), ax.slide([0.5,0.5,0]) ] + d1.get( 'l2m', [] ) - - d2 = d.copy() - d2['kind'] = 'triangle' - d2['l2m'] = [ ax.zoom([b,h,1]), ax.rot_x(deg), ax.rot_z(-90-45), ax.slide([-0.5,0.5,0]) ] + d2.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1, d2] ), [] ) - - if kind == 'tri_pyramid': - d0 = d.copy() - d0['kind'] = 'tri_pyramid_side' - - d1 = d.copy() - d1['kind'] = 'triangle' - d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1] ), [] ) - - if kind == 'poly_n_pyramid_side': - n = d.get('n', 3) - deg = 360.0 / n - rad = mt.deg_to_rad(deg/2) - h = math.cos(rad) - b = math.sin(rad) - h2 = math.sqrt(1 + h*h) - deg2 = mt.rad_to_deg( math.atan2(1, h) ) - - def poly_n_pyramid_side_f(i): - d_ = d.copy() - d_['kind'] = 'triangle' - d_['l2m'] = [ ax.zoom([b,h2,1]), ax.rot_x(deg2), ax.slide_y(-h), ax.rot_z(deg*i) ] + d_.get( 'l2m', [] ) - return d_setup( d_ ) - - return sum( map( poly_n_pyramid_side_f, range(n) ), [] ) - - if kind == 'poly_n_pyramid': - d0 = d.copy() - d0['kind'] = 'poly_n_pyramid_side' - - d1 = d.copy() - d1['kind'] = 'poly_n' - d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1] ), [] ) - - if kind == 'pipe': - d0 = d.copy() - d0['kind'] = 'pipe_side' - - d1 = d.copy() - d1['kind'] = 'circle' - d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] ) - - d2 = d.copy() - d2['kind'] = 'circle' - d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1,d2] ), [] ) - - if kind == 'cone': - d0 = d.copy() - d0['kind'] = 'cone_side' - - d1 = d.copy() - d1['kind'] = 'circle' - d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) - - return sum( map( d_setup, [d0,d1] ), [] ) - ### - - if_not_set_opt( d, 'l2m', [] ) - if_not_set_opt( d, 'm2g', [] ) - if_not_set_opt( d, 'l2g', d.get('l2m') + d.get('m2g') ) - - for m in d.get( 'maps', [] ): - m_setup(d, m) - - return [d] +import img if __name__ == "__main__": - if 'use_img_srv' in sys.argv: - img_sock.client.boot_server() - - data = sum( map( d_setup, dat.data ), [] ) - - lights = dat.lights - - if 'use_srv' in sys.argv: - rt_sock.client.boot_server( len(data) ) - rt_sock.client.add_data(data) - rt_sock.client.add_lights(lights) + dat.setup() (w, h) = ( ut.arg_i('w', 640) , ut.arg_i('h', 480) ) div = ut.arg_i('div', 1) @@ -299,18 +47,14 @@ f = rt.draw if 'wf' in sys.argv: f = wf.draw - f(data, lights, eye2g, wh2eye, sc_sz, video) + f(eye2g, wh2eye, sc_sz, video) video.add_img() fn = ( name if n == 1 else name+'0000{}'.format(i)[-5:] ) + '.jpg' video.write(fn) - - wsec = max( cnt.wait_sec(), 0 ) if n > 1 else -1 - video.show_zm('', wsec) + if 'no_show' not in sys.argv: + wsec = max( cnt.wait_sec(), 0 ) if n > 1 else -1 + video.show_zm('', wsec) video.clear() video.fin() - if 'use_srv' in sys.argv: - rt_sock.client.quit() - if 'use_img_srv' in sys.argv: - img_sock.client.quit() # EOF Binary files rt_v28/cross and rt_v29/cross differ diff -urN rt_v28/cross.c rt_v29/cross.c --- rt_v28/cross.c 2018-04-18 22:30:00.000000000 +0900 +++ rt_v29/cross.c 2018-04-30 01:29:14.000000000 +0900 @@ -218,7 +218,7 @@ } int -cross_cross(int kind_idx, struct ax *l2g, int eq_d, struct line *l_g, struct cross_ret *ret) +cross_cross_one(int kind_idx, struct ax *l2g, int eq_d, struct line *l_g, struct cross_ret *ret) { switch(kind_idx){ case KIND_SQUARE: @@ -253,7 +253,7 @@ } void -cross_nv(int kind_idx, struct ax *l2g, struct line *l_g, struct cross_ret *ret) +cross_get_nv(int kind_idx, struct ax *l2g, struct line *l_g, struct cross_ret *ret) { double nv[3]; struct line l_nv; @@ -295,4 +295,109 @@ ret->ang_nv_eyev = dot( ret->nv, ret->eyev ); } +void +cross_cross(struct line *l_g, int prev_id, struct cross_ret *ret) +{ + struct data *data; + struct cross_ret ret_; + int i, idx; + + data = data_get(); + idx = -1; + for(i=0; in; i++){ + struct data_one *d = &data->lst[i]; + + if( !cross_cross_one( d->kind, &d->l2g.lst[0].ax, prev_id == i, l_g, &ret_ ) ){ + continue; + } + if( idx < 0 || ret_.t < ret->t ){ + idx = i; + *ret = ret_; + } + } + if( idx >= 0 ){ + struct data_one *d = &data->lst[idx]; + cross_get_nv( d->kind, &d->l2g.lst[0].ax, l_g, ret ); + } + ret->idx = idx; +} + +int +pack_cross_ret(char *bp, struct cross_ret *ret) +{ + int sz; + char *buf = bp; + + sz = sizeof(ret->idx); + memcpy(bp, &ret->idx, sz); bp += sz; + + sz = sizeof(ret->l_nv_g); + memcpy(bp, &ret->l_nv_g, sz); bp += sz; + + sz = sizeof(ret->nv); + memcpy(bp, ret->nv, sz); bp += sz; + + sz = sizeof(ret->eyev); + memcpy(bp, ret->eyev, sz); bp += sz; + + sz = sizeof(ret->ang_nv_eyev); + memcpy(bp, &ret->ang_nv_eyev, sz); bp += sz; + + sz = sizeof(ret->t); + memcpy(bp, &ret->t, sz); bp += sz; + + sz = sizeof(ret->l); + memcpy(bp, &ret->l, sz); bp += sz; + + sz = sizeof(ret->p); + memcpy(bp, ret->p, sz); bp += sz; + + sz = bp - buf; + return sz; +} + +#ifdef SRV_CROSS +void +srv_cross(int fd) +{ + int sz; + struct line l_g; + int prev_id; + char buf[ sizeof(l_g) + sizeof(prev_id) ], *bp = buf; + struct cross_ret ret, send_buf; + + read(fd, &sz, sizeof(sz)); + if(sz != sizeof(buf)){ + fprintf(stderr, "? srv_cross sz=%d sizeof(buf)=%lu\n", sz, sizeof(buf)); + } + read(fd, buf, sizeof(buf)); + + sz = sizeof(l_g); + memcpy(&l_g, bp, sz); bp += sz; + + sz = sizeof(prev_id); + memcpy(&prev_id, bp, sz); bp += sz; + + cross_cross(&l_g, prev_id, &ret); + + sz = pack_cross_ret((char *)&send_buf, &ret); + write(fd, &sz, sizeof(sz)); + write(fd, &send_buf, sz); +} + +int +main(int ac, char **av) +{ + int port = SOCK_PORT + 14; + void *funcs[] = { + srv_cross, + }; + + if(ac >= 2 && strcmp(av[1], "boot") == 0){ + sock_srv_main_loop(port, sizeof(funcs)/sizeof(*funcs), funcs); + } + return 0; +} +#endif + /* EOF */ diff -urN rt_v28/cross.h rt_v29/cross.h --- rt_v28/cross.h 2018-04-19 22:02:29.000000000 +0900 +++ rt_v29/cross.h 2018-04-29 17:24:13.000000000 +0900 @@ -1,19 +1,21 @@ #ifndef __CROSS_H__ #define __CROSS_H__ 1 -#include "mt.h" -#include "ax.h" #include "dat.h" struct cross_ret{ - double t; - struct line l; - double p[3]; + int idx; struct line l_nv_g; double nv[3]; double eyev[3]; double ang_nv_eyev; + + double t; + struct line l; + double p[3]; +/* double diff; +*/ }; int plane_z0(struct cross_ret *ret); @@ -29,7 +31,9 @@ int pipe_side(int eq_d, struct cross_ret *ret); int cone_side(int eq_d, struct cross_ret *ret); -int cross_cross(int kind_idx, struct ax *l2g, int eq_d, struct line *l_g, struct cross_ret *ret); -void cross_nv(int kind_idx, struct ax *l2g, struct line *l_g, struct cross_ret *ret); +int cross_cross_one(int kind_idx, struct ax *l2g, int eq_d, struct line *l_g, struct cross_ret *ret); +void cross_get_nv(int kind_idx, struct ax *l2g, struct line *l_g, struct cross_ret *ret); + +void cross_cross(struct line *l_g, int prev_id, struct cross_ret *ret); #endif diff -urN rt_v28/cross.py rt_v29/cross.py --- rt_v28/cross.py 2018-04-18 23:30:00.000000000 +0900 +++ rt_v29/cross.py 2018-04-29 22:19:08.000000000 +0900 @@ -8,6 +8,10 @@ import line import ax import lstx +import sock +import val + +srv_dic = {} # return dic keys 't', 'p', 'nv' @@ -206,9 +210,13 @@ p[2] = 1 crs['nv'] = v.unit(p) -def cross(crs): +def get_kind_str(d): + kinds = ut.dic_cache( srv_dic, 'kinds', lambda : val.cli.get_prop('kinds') ) + return kinds[ d.get('kind') ] + +def cross_one(crs): d = crs.get('d') - kind = d.get('kind') + kind = get_kind_str(d) if crs.get('eq_d') and kind in [ 'square', 'circle', 'triangle' ]: return False @@ -231,7 +239,7 @@ return False return f(crs) -def nv(crs): +def get_nv(crs): if 't' not in crs: return if 'p' not in crs: @@ -247,19 +255,58 @@ 'cone_side': cone_side_nv, } d = crs.get('d') - f = dic.get( d.get('kind') ) + f = dic.get( get_kind_str(d) ) if not f: - return + return (0, line.z1, v.zero, v.zero, 0) f(crs) l_nv = line.new( crs.get('p'), crs.get('nv') ) l2g = d.get('l2g') - #crs['l_nv_g'] = l_nv_g = lstx.tr( l2g, 'l2g', l_nv ) - crs['l_nv_g'] = l_nv_g = lstx.tr_line( l2g, 'l2g', l_nv ) + l_nv_g = lstx.tr_line( l2g, 'l2g', l_nv ) - crs['nv'] = nv = v.unit(l_nv_g.v) + nv = v.unit(l_nv_g.v) l_g = crs.get('l_g') - crs['eyev'] = eyev = v.unit(l_g.v) - crs['ang_nv_eyev'] = np.dot( nv, eyev ) + eyev = v.unit(l_g.v) + ang_nv_eyev = np.dot( nv, eyev ) + + return (1, l_nv_g, nv, eyev, ang_nv_eyev) + +def cross_(l_g, prev_idx): + data = ut.dic_cache( srv_dic, 'data', lambda : val.cli.get_prop('data') ) + + prev_d = ut.lst_get(data, prev_idx) + lst = map( lambda d: { 'l_g': l_g, 'd': d, 'eq_d': d == prev_d }, data ) + lst = ut.filter_lst( lambda crs: cross_one(crs), lst ) + if not lst: + return (-1, line.z1, v.zero, v.zero, 0) + + crs = min( lst, key=lambda crs: crs.get('t') ) + + (ret, l_nv_g, nv, eyev, ang_nv_eyev) = get_nv(crs) + + if not ret: + return (-1, line.z1, v.zero, v.zero, 0) + + idx = data.index( crs.get('d') ) + + return (idx, l_nv_g, nv, eyev, ang_nv_eyev) + +cmd_infs = [ + { 'cmd': 'cross_', 'func': cross_, 'args': '(line,i4)', 'rets': '(i4,line,xyz,xyz,f8)' }, +] + +sock_inf = { + #'srv_cmd': './cross.py boot', + 'srv_cmd': './cross boot', + 'port': sock.port + 14, + 'pid': -1, +} + +cli = sock.new_client(sock_inf, cmd_infs) + +if __name__ == "__main__": + if ut.arg_is(1, 'boot'): + sock.server(sock_inf, cmd_infs) + sys.exit(0) # EOF diff -urN rt_v28/dat.c rt_v29/dat.c --- rt_v28/dat.c 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/dat.c 2018-04-30 00:02:01.000000000 +0900 @@ -0,0 +1,193 @@ +#include "dat.h" + +struct data data = { 0, NULL }; +struct lights lights = { 0, NULL }; + +char * +unpack_vs(char *bp, struct vecs *vs) +{ + int n; + + n = sizeof(vs->v3); + memcpy(vs->v3, bp, n); bp += n; + vecs_init(vs); /* ! */ + return bp; +} + +char * +unpack_xx(char *bp, struct x_x *xx) +{ + int n; + + n = sizeof(xx->typ); + memcpy(&xx->typ, bp, n); bp += n; + + switch(xx->typ){ + case TYP_AX: + n = sizeof(xx->ax.p); + memcpy(&xx->ax.p, bp, n); bp += n; + bp = unpack_vs(bp, &xx->ax.vs); + break; + case TYP_CX: + n = sizeof(xx->cx); + memcpy(&xx->cx, bp, n); bp += n; + break; + case TYP_FX: + n = sizeof(xx->fx); + memcpy(&xx->fx, bp, n); bp += n; + break; + default: + break; + } + return bp; +} + +char * +unpack_lx(char *bp, struct lstx *lx) +{ + int n, i; + + n = sizeof(lx->n); + memcpy(&lx->n, bp, n); bp += n; + + lx->lst = malloc( sizeof(*lx->lst) * lx->n ); + + for(i=0; in; i++){ + bp = unpack_xx(bp, &lx->lst[i]); + } + return bp; +} + +char * +unpack_map(char *bp, struct map *m) +{ + int n; + + bp = unpack_lx(bp, &m->xyz2g); + + n = sizeof(m->fn); + memcpy(&m->fn, bp, n); bp += n; + + n = sizeof(m->fn_r); + memcpy(&m->fn_r, bp, n); bp += n; + + bp = unpack_lx(bp, &m->wh2xyz); + + n = sizeof(m->rep_x); + memcpy(&m->rep_x, bp, n); bp += n; + + n = sizeof(m->rep_y); + memcpy(&m->rep_y, bp, n); bp += n; + + return bp; +} + +char * +unpack_maps(char *bp, struct maps *maps) +{ + int n, i; + + n = sizeof(maps->n); + memcpy(&maps->n, bp, n); bp += n; + + maps->lst = malloc( sizeof(*maps->lst) * maps->n ); + for(i=0; in; i++){ + bp = unpack_map(bp, &maps->lst[i]); + } + return bp; +} + +char * +unpack_data_one(char *bp, struct data_one *d) +{ + int n; + + n = sizeof(d->kind); + memcpy(&d->kind, bp, n); bp += n; + + bp = unpack_lx(bp, &d->l2g); + + n = sizeof(d->def_col); + memcpy(&d->def_col, bp, n); bp += n; + + bp = unpack_maps(bp, &d->maps); + + n = sizeof(d->rtd); + memcpy(&d->rtd, bp, n); bp += n; + + return bp; +} + +char * +unpack_data(char *bp, struct data *data) +{ + int n, i; + + n = sizeof(data->n); + memcpy(&data->n, bp, n); bp += n; + + data->lst = malloc( sizeof(*data->lst) * data->n ); + for(i=0; in; i++){ + bp = unpack_data_one(bp, &data->lst[i]); + } + return bp; +} + +char * +unpack_ltd(char *bp, struct ltd *ltd) +{ + int n; + + n = sizeof(ltd->pvi); + memcpy(<d->pvi, bp, n); bp += n; + + n = sizeof(ltd->p); + memcpy(ltd->p, bp, n); bp += n; + + n = sizeof(ltd->v); + memcpy(ltd->v, bp, n); bp += n; + + n = sizeof(ltd->e); + memcpy(<d->e, bp, n); bp += n; + + return bp; +} + +char * +unpack_lights(char *bp, struct lights *lights) +{ + int n, i; + + n = sizeof(lights->n); + memcpy(&lights->n, bp, n); bp += n; + + lights->lst = malloc( sizeof(*lights->lst) * lights->n ); + for(i=0; in; i++){ + bp = unpack_ltd(bp, &lights->lst[i]); + } + return bp; +} + +struct data * +data_get(void) +{ + if(data.lst == NULL){ + char *b = get_prop("data", NULL); + unpack_data(b, &data); + free(b); + } + return &data; +} + +struct lights * +lights_get(void) +{ + if(lights.lst == NULL){ + char *b = get_prop_bytes("lights", NULL); + unpack_lights(b, &lights); + free(b); + } + return &lights; +} + +/* EOF */ diff -urN rt_v28/dat.h rt_v29/dat.h --- rt_v28/dat.h 2018-04-20 23:52:43.000000000 +0900 +++ rt_v29/dat.h 2018-04-29 17:22:57.000000000 +0900 @@ -2,6 +2,7 @@ #define __DAT_H__ 1 #include "lstx.h" +#include "val.h" #include "rt.h" #define KIND_SQUARE 0 @@ -11,18 +12,37 @@ #define KIND_PIPE_SIDE 4 #define KIND_CONE_SIDE 5 -struct data{ - int ki; +struct map{ + struct lstx xyz2g; + int fn; + int fn_r; + struct lstx wh2xyz; + int rep_x, rep_y; +}; + +struct maps{ + int n; + struct map *lst; +}; + +struct data_one{ + int kind; struct lstx l2g; + int def_col[3]; + struct maps maps; struct rtd rtd; }; -#define LTD_TYP_P 0 -#define LTD_TYP_V 1 +struct data{ + int n; + struct data_one *lst; +}; + +#define LTD_P 0 +#define LTD_V 1 struct ltd{ - int typ; - int dmy; /* for padding */ + int pvi; double p[3]; double v[3]; double e; @@ -33,4 +53,7 @@ struct ltd *lst; }; +struct data *data_get(void); +struct lights *lights_get(void); + #endif diff -urN rt_v28/dat.py rt_v29/dat.py --- rt_v28/dat.py 2018-04-16 21:00:00.000000000 +0900 +++ rt_v29/dat.py 2018-04-27 23:40:43.000000000 +0900 @@ -1,13 +1,16 @@ #!/usr/bin/env python +import math import ut import mt -import v import line import ax import cylx import fcx import lstx +import sock +import val +import img maps_copen = [ { 'fn': 'copen-090419.jpg', 't2m': [ ax.zoom_all(2) ] } ] @@ -24,7 +27,7 @@ 'm2g': [ ax.zoom_all(50) ], } ] -maps_copen_rep = [ { 'fn': 'copen-090419.jpg', 't2m': [ ax.zoom_all(0.5) ], 'rep': (True,True) } ] +maps_copen_rep = [ { 'fn': 'copen-090419.jpg', 't2m': [ ax.zoom_all(0.5) ], 'rep': (1,1) } ] rtd = { 'base':0.1, 'diff': 0, 'reflect': 0.5, 'reflact': 0.5, 'density': 2 } @@ -191,7 +194,7 @@ ball_world2 = [ { 'kind': 'ball', 'rtd': { 'diff': 0.3 }, - 'maps': [ { 'fn': 'IMG_3999_3.mov', 'fn_r': 'IMG_3999_4.mov', 'r': 0.3, 'rep': (True,True) } ], + 'maps': [ { 'fn': 'IMG_3999_3.mov', 'fn_r': 'IMG_3999_4.mov', 'r': 0.3, 'rep': (1,1) } ], 'm2g': [ ax.zoom_all(r), ax.slide_z(-r/2) ], },{ 'kind': 'circle', @@ -207,11 +210,273 @@ 'm2g': [ ax.zoom_all(7), ax.slide_x(-10) ] } ] -data = eval( ut.arg_s('data_name', 'copen') ) - lights = [ { 'p': mt.arr( [1,-1,-1] ) * 30, 'e': 2.5 }, { 'p': mt.arr( [-1,1,1] ) * 30, 'e': 2.5 }, ] +def if_not_set_opt(d, k, v): + ut.if_not_set(d, k, v) + ut.dic_set( d, k, lstx.opt( d.get(k) ) ) + +def if_not_set_idx(d, k): + v = -1 + if k in d: + v = d.get(k) + if type(v) == int: + retrun + v = val.cli.geti(v) + d[k] = v + +def m_setup(d, m): + # 'fn' in d + + if_not_set_idx( m, 'fn' ) + if_not_set_idx( m, 'fn_r' ) + + (w, h) = img.cli.wh( m.get('fn') ) + if_not_set_opt( m, 'wh2xyz', [ ax.wh_map(w, h) ] ) + + if 'xyz2t' not in m: + lst = [] + if 'r' in m: + lst += [ cylx.new( m.get('r') ) ] + if 'dz' in m: + lst += [ fcx.new( m.get('dz') ) ] + if_not_set_opt( m, 'xyz2t', lst ) + + if_not_set_opt( m, 't2m', [] ) + if_not_set_opt( m, 't2g', m.get('t2m') + d.get('m2g') ) + if_not_set_opt( m, 'xyz2g', m.get('xyz2t') + m.get('t2g') ) + if_not_set_opt( m, 'wh2g', m.get('wh2xyz') + m.get('xyz2g') ) + + if not m.get('rep'): + m['rep'] = (0,0) + +def d_setup(d): + # return lst [d] + + kind = d.get('kind') + + if kind == 'poly_n': + n = d.get('n', 3) + deg = 360.0 / n + rad = mt.deg_to_rad(deg/2) + h = math.cos(rad) + b = math.sin(rad) + + def poly_n_f(i): + d_ = d.copy() + d_['kind'] = 'triangle' + d_['l2m'] = [ ax.slide_y(-1), ax.zoom([b,h,1]), ax.rot_z(deg*i) ] + d_.get( 'l2m', [] ) + return d_setup( d_ ) + + return sum( map( poly_n_f, range(n) ), [] ) + + if kind == 'cube': + def cube_f(l, deg): + d_ = d.copy() + d_['kind'] = 'square' + d_['l2m'] = [ ax.slide_z(1), ax.rot(l, deg) ] + d_.get( 'l2m', [] ) + return d_setup( d_ ) + rots = [ + (line.x1, 0), (line.x1, 90), (line.x1, 180), (line.x1, -90), + (line.y1, 90), (line.y1, -90) + ] + return sum( ut.map_up( cube_f, rots ), [] ) + + if kind == 'tri_prism_side': + d0 = d.copy() + d0['kind'] = 'square' + d0['l2m'] = [ ax.rot_x(90) ] + d0.get( 'l2m', [] ) + + d1 = d.copy() + d1['kind'] = 'square' + zm = math.sqrt(2) / 2 + d1['l2m'] = [ ax.rot_x(-90), ax.slide_x(-1), ax.zoom_x(zm), ax.rot_z(-45), ax.slide_x(1) ] + d1.get( 'l2m', [] ) + + d2 = d.copy() + d2['kind'] = 'square' + d2['l2m'] = [ ax.rot_x(-90), ax.slide_x(1), ax.zoom_x(zm), ax.rot_z(45), ax.slide_x(-1) ] + d2.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1,d2] ), [] ) + + if kind == 'tri_prism': + d0 = d.copy() + d0['kind'] = 'tri_prism_side' + + d1 = d.copy() + d1['kind'] = 'triangle' + d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] ) + + d2 = d.copy() + d2['kind'] = 'triangle' + d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1,d2] ), [] ) + + if kind == 'poly_n_prism_side': + n = d.get('n', 3) + deg = 360.0 / n + rad = mt.deg_to_rad(deg/2) + h = math.cos(rad) + b = math.sin(rad) + + def poly_n_prism_side_f(i): + d_ = d.copy() + d_['kind'] = 'square' + d_['l2m'] = [ ax.rot_x(90), ax.zoom_x(b), ax.slide_y(-h), ax.rot_z(deg*i) ] + d_.get( 'l2m', [] ) + return d_setup( d_ ) + + return sum( map( poly_n_prism_side_f, range(n) ), [] ) + + if kind == 'poly_n_prism': + d0 = d.copy() + d0['kind'] = 'poly_n_prism_side' + + d1 = d.copy() + d1['kind'] = 'poly_n' + d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] ) + + d2 = d.copy() + d2['kind'] = 'poly_n' + d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1,d2] ), [] ) + + if kind == 'four_pyramid_side': + n = 4 + zm = math.sqrt(2) + + def four_pyramid_side_f(i): + d_ = d.copy() + d_['kind'] = 'triangle' + d_['l2m'] = [ ax.zoom_y(zm), ax.rot_x(45), ax.slide_y(-1), ax.rot_z(90*i) ] + d_.get( 'l2m', [] ) + return d_setup( d_ ) + + return sum( map( four_pyramid_side_f, range(n) ), [] ) + + if kind == 'four_pyramid': + d0 = d.copy() + d0['kind'] = 'four_pyramid_side' + + d1 = d.copy() + d1['kind'] = 'square' + d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1] ), [] ) + + if kind == 'tri_pyramid_side': + d0 = d.copy() + d0['kind'] = 'triangle' + d0['l2m'] = [ ax.rot_x(90) ] + d0.get( 'l2m', [] ) + + h = math.sqrt( 1 + 0.5 ) + b = math.sqrt(2)/2 + deg = mt.rad_to_deg( math.atan2(1, b) ) + + d1 = d.copy() + d1['kind'] = 'triangle' + d1['l2m'] = [ ax.zoom([b,h,1]), ax.rot_x(deg), ax.rot_z(90+45), ax.slide([0.5,0.5,0]) ] + d1.get( 'l2m', [] ) + + d2 = d.copy() + d2['kind'] = 'triangle' + d2['l2m'] = [ ax.zoom([b,h,1]), ax.rot_x(deg), ax.rot_z(-90-45), ax.slide([-0.5,0.5,0]) ] + d2.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1, d2] ), [] ) + + if kind == 'tri_pyramid': + d0 = d.copy() + d0['kind'] = 'tri_pyramid_side' + + d1 = d.copy() + d1['kind'] = 'triangle' + d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1] ), [] ) + + if kind == 'poly_n_pyramid_side': + n = d.get('n', 3) + deg = 360.0 / n + rad = mt.deg_to_rad(deg/2) + h = math.cos(rad) + b = math.sin(rad) + h2 = math.sqrt(1 + h*h) + deg2 = mt.rad_to_deg( math.atan2(1, h) ) + + def poly_n_pyramid_side_f(i): + d_ = d.copy() + d_['kind'] = 'triangle' + d_['l2m'] = [ ax.zoom([b,h2,1]), ax.rot_x(deg2), ax.slide_y(-h), ax.rot_z(deg*i) ] + d_.get( 'l2m', [] ) + return d_setup( d_ ) + + return sum( map( poly_n_pyramid_side_f, range(n) ), [] ) + + if kind == 'poly_n_pyramid': + d0 = d.copy() + d0['kind'] = 'poly_n_pyramid_side' + + d1 = d.copy() + d1['kind'] = 'poly_n' + d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1] ), [] ) + + if kind == 'pipe': + d0 = d.copy() + d0['kind'] = 'pipe_side' + + d1 = d.copy() + d1['kind'] = 'circle' + d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] ) + + d2 = d.copy() + d2['kind'] = 'circle' + d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1,d2] ), [] ) + + if kind == 'cone': + d0 = d.copy() + d0['kind'] = 'cone_side' + + d1 = d.copy() + d1['kind'] = 'circle' + d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] ) + + return sum( map( d_setup, [d0,d1] ), [] ) + ### + + if_not_set_opt( d, 'l2m', [] ) + if_not_set_opt( d, 'm2g', [] ) + if_not_set_opt( d, 'l2g', d.get('l2m') + d.get('m2g') ) + + if 'def_col' not in d: + d['def_col'] = [128,128,128] + + if 'maps' not in d: + d['maps'] = [] + for m in d.get('maps'): + m_setup(d, m) + + + kinds = [ 'square', 'circle', 'triangle', 'ball', 'pipe_side', 'cone_side' ] + if not val.cli.has_prop('kinds'): + val.cli.set_prop( 'kinds', '[str]', kinds ) + kind = d.get('kind') + if type(kind) != int: + d['kind'] = kinds.index(kind) + + return [d] + +typ_map = '{xyz2g:lx,fn:i4,fn_r:i4,wh2xyz:lx,rep:(i4,i4)}' +typ_d = '{{kind:i4,l2g:lx,def_col:col,maps:[{}],rtd:rtd}}'.format(typ_map) +typ_data = '[{}]'.format(typ_d) + +def setup(): + data_name = ut.arg_s('data_name', 'copen') + data = eval( data_name ) + data = sum( map( d_setup, data ), [] ) + val.cli.set_prop('data', typ_data, data) + val.cli.set_prop('lights', '[ltd]', lights) # EOF diff -urN rt_v28/img.py rt_v29/img.py --- rt_v28/img.py 2018-04-22 21:50:00.000000000 +0900 +++ rt_v29/img.py 2018-04-27 23:50:33.000000000 +0900 @@ -4,163 +4,151 @@ import numpy as np import cv2 import ut +import sock +import val + +def fn_typ(fn): + # 'v': video, 'i': image + vs = [ 'mp4', 'avi', 'mov', 'gif' ] + vs = sum( map( lambda s: [ s, s.upper() ], vs ) , [] ) + for s in vs: + if fn.endswith('.' + s): + return 'v' + return 'i' img_wh = lambda img: ( lambda h, w, d: (w, h) )( *img.shape ) resize = lambda img, w, h: img if img_wh(img) == (w, h) else cv2.resize( img, (w, h) ) +img_col = lambda img, x, y: img[y, x] +is_fn = lambda k: type(k) != int and ut.exists(k) # ! type(k) unicode? str? def rep_xy(x, y, w, h, rep): (rx, ry) = rep; - if rx and not (0 <= x and x < w): + if rx and not ut.in_range(x, w): x = x % w if x > 0 else w - (-x % w) - if ry and not (0 <= y and y < h): + if ry and not ut.in_range(y, h): y = y % h if y > 0 else h - (-y % h) return (x, y) def new_imgs(): - d = {} e = ut.Empty() + d = {} - def get(fn): - if fn not in d: - d[fn] = cv2.imread(fn) - return d.get(fn) + e.has = lambda k: k in d + e.set = lambda k, img: ut.dic_set(d, k, img) + + def get(k): + if not e.has(k) and is_fn(k): + e.set( k, cv2.imread(k) ) + return d.get(k) e.get = get - e.wh = lambda fn: img_wh( get(fn) ) - e.in_img = lambda fn, x, y: ( lambda w, h: 0 <= x and x < w and 0 <= y and y < h )( *e.wh(fn) ) + e.pop = lambda k: d.pop(k) if k in d else None - def col(fn, x, y, def_col=[128,128,128], rep=None): - if e.in_img(fn, x, y): - return get(fn)[y, x] - if rep: - (w, h) = e.wh(fn) - (x, y) = rep_xy(x, y, w, h, rep) - if e.in_img(fn, x, y): - return get(fn)[y, x] - return def_col + e.wh = lambda k: img_wh( e.get(k) ) + e.in_img = lambda k, x, y: ( lambda w, h: ut.in_wh(x, y, w, h) )( *e.wh(k) ) + e.rep_xy = lambda k, x, y, rep: ( lambda w, h: rep_xy(x, y, w, h, rep) )( *e.wh(k) ) + + def col(k, x, y, def_col=[128,128,128], rep=(0,0)): + if e.in_img(k, x, y): + return img_col( e.get(k), x, y ) + if rep == (0,0): + return def_col + (x, y) = e.rep_xy(k, x, y, rep) + return col(k, x, y, def_col) e.col = col return e imgs = new_imgs() -def read_video(fn): - vc = cv2.VideoCapture(fn) - - kd = { 'i': 1, 'w': 3, 'h': 4, 'fps': 5, 'n': 7 } - get_prop = lambda k: vc.get( kd.get(k) ) - set_prop = lambda k, v: vc.set( kd.get(k), v ) - fix_type = lambda k, v: int(v) if k != 'fps' else v - - dic = dict( map( lambda k: ( k, fix_type( k, get_prop(k) ) ), kd.keys() ) ) - - fps = dic.get('fps') - n = dic.get('n') - - def err_recover(): - if vc.isOpened(): - vc.open(fn) - if 'img' in dic: - dic.pop('img') - if get_prop('i') != 0: - set_prop('i', 0) +vc_prop_d = { 'i': 1, 'w': 3, 'h': 4, 'fps': 5, 'frn': 7 } +vc_get_prop = lambda vc, k: vc.get( vc_prop_d.get(k) ) +vc_set_prop = lambda vc, k, v: vc.set( vc_prop_d.get(k), v ) + +def open_video(fn): + if fn_typ(fn) == 'i': + return { 'fn': fn, 'img': imgs.get(fn), 'wh': imgs.wh(fn), 'fps': 30, 'frn': 1 } - # get_prop(7) is doubt - for i in range(n): - (ret, _) = vc.read() - if not ret or len(_) == 0: - dic['n'] = n = i + vc = cv2.VideoCapture(fn) + w = int( vc_get_prop(vc, 'w') ) + h = int( vc_get_prop(vc, 'h') ) + wh = (w, h) + fps = vc_get_prop(vc, 'fps') + frn = int( vc_get_prop(vc, 'frn') ) + vdic = { 'fn': fn, 'vc': vc, 'wh': wh, 'fps': fps, 'frn': frn } + + # prop 7 is doubt + for i in range(frn): + (ret, img) = vc.read() + if not ret or len(img) == 0: + vdic['frn'] = i break - err_recover() + recover_video(vdic) + return vdic - def img_idx(i): - i %= n # loop - if 'img' in dic and dic.get('i') != i: - dic.pop('img') - if dic.get('i')+1 != i: - set_prop('i', i) - dic['i'] = i - if 'img' not in dic: - ( ret, dic['img'] ) = vc.read() - if not ret: - err_recover() - for j in range(i+1): - ( ret, dic['img'] ) = vc.read() - if not ret: - sys.stderr.write( 'err {} {}/{}\n'.format( fn, j, dic.get('n') ) ) - dic['i'] = i - return dic.get('img') - dic['img_idx'] = img_idx +def recover_video(vdic): + vc = vdic.get('vc') + if not vc.isOpened(): + vc.open( vdic.get('fn') ) + if vc_get_prop(vc, 'i') != 0: + vc_set_prop(vc, 'i', 0) + +def read_video(vdic, i): + if 'img' in vdic: + return vdic.get('img') + + vc = vdic.get('vc') + i %= vdic.get('frn') + if vc_get_prop(vc, 'i') != i: + vc_set_prop(vc, 'i', i) + (ret, img) = vc.read() + if ret and len(img) > 0: + return img + + recover_video(vdic) + for i_ in range(i): + vc.read() + (ret, img) = vc.read() + if not ret or len(img) == 0: + ut.err_msg( 'err read_video fn={} i={}'.format( vdic.get('fn'), i) ) + return img - sec_to_i = lambda sec: int(fps * sec) - dic['img_sec'] = lambda sec: img_idx( sec_to_i(sec) ) - - dic['imgs'] = lambda : ut.map_lst( img_idx, range(n) ) # func - - return dic +sec_to_i = lambda fps, sec: int(fps * sec) +i_to_sec = lambda fps, i: float(i) / fps def new_videos(): - d = {} e = ut.Empty() + d = {} + + e.has = lambda k: k in d + e.set = lambda k, vc: ut.dic_set(d, k, vc) - def get(fn): - if fn not in d: - d[fn] = read_video(fn) - return d.get(fn) + def get(k): + if not e.has(k) and is_fn(k): + e.set( k, open_video(k) ) + return d.get(k) e.get = get - e.w = lambda fn: get(fn).get('w') - e.h = lambda fn: get(fn).get('h') - e.wh = lambda fn: ( e.w(fn), e.h(fn) ) - e.n = lambda fn: get(fn).get('n') - e.fps = lambda fn: get(fn).get('fps') - - e.img_sec = img_sec = lambda fn, sec: get(fn).get('img_sec')(sec) - e.imgs = lambda fn: get(fn).get('imgs')() - - e.in_img = lambda fn, x, y: ( lambda w, h: 0 <= x and x < w and 0 <= y and y < h )( *e.wh(fn) ) - - def col(fn, sec, x, y, def_col=[128,128,128], rep=None): - if e.in_img(fn, x, y): - return img_sec(fn, sec)[y, x] - if rep: - (w, h) = e.wh(fn) - (x, y) = rep_xy(x, y, w, h, rep) - if e.in_img(fn, x, y): - return img_sec(fn, sec)[y, x] - return def_col + e.pop = lambda k: d.pop(k) if k in d else None + + e.wh = lambda k: get(k).get('wh') + e.fps = lambda k: get(k).get('fps') + e.frn = lambda k: get(k).get('frn') + + def col(k, sec, x, y, def_col=[128,128,128], rep=(0,0)): + i = sec_to_i( e.fps(k), sec ) + ki = (k, i) + if not imgs.has(ki): + img = read_video( get(k), i ) + imgs.set(ki, img) + return imgs.col(ki, x, y, def_col, rep) e.col = col return e videos = new_videos() -fns = [] - -def get_idx(fn): - if fn not in fns: - fns.append(fn) - return fns.index(fn) - -to_fn = lambda x: fns[x] if x in range( len(fns) ) else x - -def fn_typ(fn): - # 'v': video, 'i': image - vs = [ 'mp4', 'avi', 'mov', 'gif' ] - vs = sum( map( lambda s: [ s, s.upper() ], vs ) , [] ) - for s in vs: - if to_fn(fn).endswith('.' + s): - return 'v' - return 'i' - -wh_ = lambda fn: ( videos if fn_typ(fn) == 'v' else imgs ).wh(fn) -wh = lambda fn: wh_( to_fn(fn) ) - -def col(fn, sec, x, y, def_col=[128,128,128], rep=None): - fn = to_fn(fn) - if fn_typ(fn) == 'v': - return videos.col(fn, sec, x, y, def_col, rep) - return imgs.col(fn, x, y, def_col, rep) +### def new_wimg(w, h, def_col=[0,0,0]): e = ut.Empty() @@ -267,8 +255,32 @@ msec = max( 1, int(sec * 1000) ) cv2.waitKey(msec) +### + +wh = lambda id: videos.wh( val.cli.gets(id) ) +col = lambda id, sec, x, y, def_col, rep: videos.col( val.cli.gets(id), sec, x, y, def_col, rep ) + +cmd_infs = [ + { 'cmd': 'wh', 'func': wh, 'args': '(i4)', 'rets': '(i4,i4)' }, + { 'cmd': 'col', 'func': col, 'args':'(i4,f8,i4,i4,col,(i4,i4))', 'rets':'col' }, +] + +sock_inf = { + 'srv_cmd': './img.py boot', + 'port': sock.port + 12, + 'pid': -1, +} + +cli = sock.new_client(sock_inf, cmd_infs) + if __name__ == "__main__": + if ut.arg_is(1, 'boot'): + sock.server(sock_inf, cmd_infs) + sys.exit(0) + if len(sys.argv[1:]) < 2: + print( 'Usage: {} boot [port=xxxx]'.format(sys.argv[0]) ) + print( ' boot videos server mode , def_port=1236' ) print( 'Usage: {} img_name video_name fps= zm= cmd='.format(sys.argv[0]) ) print( ' fps is int value (default 30)' ) print( ' zm is float value (default 1.0)' ) diff -urN rt_v28/img_sock.py rt_v29/img_sock.py --- rt_v28/img_sock.py 2018-04-23 22:13:00.000000000 +0900 +++ rt_v29/img_sock.py 1970-01-01 09:00:00.000000000 +0900 @@ -1,50 +0,0 @@ -#!/usr/bin/env python - -import ut -import img -import sock - -PORT = ut.arg_i('port', 23456) + 1 -FIFO = 'fifo_img' - -def srv_col(fn, sec, x, y, def_col, rep_x, rep_y): - rep = ( bool(rep_x), bool(rep_y) ) - if rep == (False, False): - rep = None - return img.col(fn, sec, x, y, def_col, rep) - -cmd_infs = [ - { 'cmd': 'get_idx', 'func': img.get_idx, 'args': '(str)', 'rets': 'i4' }, - { 'cmd': 'wh', 'func': img.wh, 'args': '(i4)', 'rets': '(i4,i4)' }, - { 'cmd': 'col', 'func': srv_col, 'args': '(i4,f8,i4,i4,col,i4,i4)', 'rets': 'col' }, - { 'cmd': 'quit' }, -] - -def new_client(): - cli = sock.new_client(cmd_infs) - - e = ut.Empty() - - e.boot_server = lambda : cli.boot_server( './img_sock.py', PORT, FIFO ) - - e.get_idx = lambda fn: cli.call( 'get_idx', [fn] ) # fn : str - - e.wh = lambda fn: cli.call( 'wh', [fn] ) # fn : int - - def col(fn, sec, x, y, def_col=[128,128,128], rep=None): - if not rep: - rep = (False, False) - (rep_x, rep_y) = map(int, rep) - return cli.call( 'col', [ fn, sec, x, y, def_col, rep_x, rep_y ] ) - e.col = col - - e.quit = lambda : cli.call('quit') - - return e - -client = new_client() - -if __name__ == "__main__": - srv = sock.new_server(cmd_infs) - srv.main_loop() -# EOF diff -urN rt_v28/pks.py rt_v29/pks.py --- rt_v28/pks.py 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/pks.py 2018-04-30 00:55:59.000000000 +0900 @@ -0,0 +1,158 @@ +#!/usr/bin/env python + +import ut +import bin + +# Ex. s = '(i4,(f8,f8,f8),[i4],[(f8,(i4,i4))])' +# Ex. s = '{foo:i4,bar:f8,hoge:str}' + +def cut_word(s): + for i in range( len(s) ): + if s[i] in ',)}]': + return ( s[:i], s[i:] ) + return ( s, '' ) + +def conv(typ, s): # conv to func inf + c = s[0] + if c == '(': + s = s[1:] + lst = [] + while s[0] != ')': + (v, s) = conv(typ, s) + lst.append(v) + if s[0] == ',': + s = s[1:] + s = s[1:] # skip ')' + return ( tuple(lst), s ) + if c == '[': + s = s[1:] + (v, s) = conv(typ, s) + s = s[1:] # skip ']' + return ( [v], s ) + if c == '{': + s = s[1:] + ks = [] + vs = [] + while s[0] != '}': + i = s.index(':') + ks.append( s[0:i] ) + (v, s) = conv( typ, s[i+1:] ) + vs.append( v ) + if s[0] == ',': + s = s[1:] + s = s[1:] # skip '}' + return ( { 'ks': ks, 'vs': vs }, s ) + + (wd, s) = cut_word(s) + + v = wd # no conv str + if typ == 'pack': + v = bin.nm_dic_pack.get(wd) + elif typ == 'unpack': + v = bin.nm_dic_unpack.get(wd) + return (v, s) + +conv_pack = lambda s: conv('pack', s)[0] + +conv_unpack = lambda s: conv('unpack', s)[0] + +def pack(finf, v): + if not finf: + return b'' + typ = type(finf) + if typ == tuple: + return b''.join( ut.map_up( pack, zip( finf, v ) ) ) + if typ == list: + return bin.pack_i4( len(v) ) + b''.join( map( lambda v_: pack( finf[0], v_ ), v ) ) + if typ == dict: + kvs = zip( finf.get('ks'), finf.get('vs') ) + return b''.join( ut.map_up( lambda k, v_: pack( v_, v.get(k) ), kvs ) ) + return finf(v) # func + +def unpack(finf, s): + if not finf: + return (None, s) + typ = type(finf) + if typ == tuple: + lst = [] + for finf_ in finf: + (v, s) = unpack(finf_, s) + lst.append(v) + return ( tuple(lst), s) + if typ == list: + (n, s) = bin.unpack_i4(s) + finf_ = finf[0] + lst = [] + for i in range(n): + (v, s) = unpack(finf_, s) + lst.append(v) + return (lst, s) + if typ == dict: + kvs = zip( finf.get('ks'), finf.get('vs') ) + d = {} + for (k, v) in kvs: + ( d[k], s ) = unpack(v, s) + return (d, s) + return finf(s) # func + +def convs(s): + d = { 'org_str': s } + for typ in ['pack', 'unpack', 'str']: + ( d[typ], _ ) = conv(typ, s) + return d + +# convs(s).get('str') +# typ_str --> sinf +# '(i4,[i4],{a:f4,b:str})' --> ( 'i4', ['i4'], { 'ks': ['a','b'], 'vs': ['f4', 'str'] } ) + + +def rconv(sinf): + typ = type(sinf) + if typ == tuple: + return '(' + ','.join( map( rconv, sinf ) ) + ')' + if typ == list: + return '[' + rconv( sinf[0] ) + ']' + if type == dict: + kvs = zip( sinf.get('ks'), sinf.get('vs') ) + return '{' + ','.join( ut.map_up( lambda k, v: k + ':' + rconv(v), kvs ) ) + '}' + return sinf + +def ref(sinf, v, idxs=[]): + for idx in idxs: + typ = type(sinf) + if typ not in (tuple, list, dict): + ut.err_msg( '? ref typ={}'.format(typ) ) + return None + if type(v) != typ: + ut.err_msg( '? ref type(v)={} (!={}) v={}'.format( type(v), typ, v ) ) + return None + + if typ == tuple: + v = v[idx] + sinf = sinf[idx] + elif typ == list: + v = v[idx] + sinf = sinf[0] + elif typ == dict: + k = sinf.get('ks')[idx] + v = v.get(k) + sinf = sinf.get('vs')[idx] + return (sinf, v) + +def set_idx(out_sinf, out_v, idx, in_v): + typ = type(out_sinf) + + if typ == tuple or typ == list: + out_v[idx] = in_v + elif typ == dict: + k = out_sinf.get('ks')[idx] + out_v[k] = in_v + else: + ut.err_msg( '? set_idx type(out_sinf)={}'.format(typ) ) + +### + +pack_org_str = lambda org_str, v: pack( conv_pack(org_str), v ) +unpack_org_str = lambda org_str, s: unpack( conv_unpack(org_str), s ) + +# EOF diff -urN rt_v28/rt.c rt_v29/rt.c --- rt_v28/rt.c 2018-04-19 22:39:21.000000000 +0900 +++ rt_v29/rt.c 2018-04-29 17:24:34.000000000 +0900 @@ -1,15 +1,14 @@ -#include "rt.h" #include "dat.h" -#include "cross.h" +#include "rt.h" double -rt_calc_diff(struct data *d, struct lights *lights, struct cross_ret *ret) +rt_calc_diff(struct data_one *d, double *crsp, double *nv, double ang_nv_eyev) { struct rtd *rtd = &d->rtd; + double ang_nv_eyev_nega = - ang_nv_eyev; int i; double sum = 0; - double *crsp = ret->l_nv_g.p; - double ang_nv_eyev_nega = - ret->ang_nv_eyev; + struct lights *lights = lights_get(); if(rtd->diff == 0){ return 0; @@ -20,14 +19,14 @@ struct ltd *ltd = &lights->lst[i]; double ang_nv_lt, ang_nv_lt_nega; - if(ltd->typ == LTD_TYP_P){ + if(ltd->pvi == LTD_P){ v_sub(crsp, ltd->p, ltv); if(dot(ltv, ltv) == 0){ continue; } unit(ltv, ltv); } - ang_nv_lt = dot(ret->nv, ltv); + ang_nv_lt = dot(nv, ltv); ang_nv_lt_nega = -ang_nv_lt; if(ang_nv_eyev_nega * ang_nv_lt_nega < 0){ continue; diff -urN rt_v28/rt.h rt_v29/rt.h --- rt_v28/rt.h 2018-04-19 22:34:57.000000000 +0900 +++ rt_v29/rt.h 2018-04-29 13:00:31.000000000 +0900 @@ -5,10 +5,8 @@ double base, diff, reflect, reflact, density; }; -struct data; -struct lights; -struct cross_ret; +struct data_one; -double rt_calc_diff(struct data *d, struct lights *lights, struct cross_ret *ret); +double rt_calc_diff(struct data_one *d, double *crsp, double *nv, double ang_nv_eyev); #endif diff -urN rt_v28/rt.py rt_v29/rt.py --- rt_v28/rt.py 2018-04-20 23:52:43.000000000 +0900 +++ rt_v29/rt.py 2018-04-27 23:55:21.000000000 +0900 @@ -9,23 +9,19 @@ import line import lstx import cross +import sock +import val import img -import img_sock -import rt_sock -use_img_srv = 'use_img_srv' in sys.argv - -def map_col(crs, rev, sec): - d = crs.get('d') - def_col = d.get( 'def_col', v.all(128) ) +def map_col(d, l_nv_g, rev, sec): + def_col = mt.arr( d.get('def_col') ) if 'maps' not in d: return def_col def f(m): xyz2g = m.get('xyz2g') - #nv_line = lstx.tr( xyz2g, 'g2l', crs.get('l_nv_g') ) - nv_line = lstx.tr_line( xyz2g, 'g2l', crs.get('l_nv_g') ) + nv_line = lstx.tr_line( xyz2g, 'g2l', l_nv_g ) img_nv = v.z1 if np.dot( nv_line.v, img_nv ) < 0: return [] @@ -33,11 +29,9 @@ if k not in m: return [] fn = m.get(k) - #(x, y, _) = lstx.tr( m.get('wh2xyz'), 'g2l', nv_line.p ) (x, y, _) = lstx.tr_p( m.get('wh2xyz'), 'g2l', nv_line.p ) - col_func = img_sock.client.col if use_img_srv else img.col - return col_func( fn, sec, int(x), int(y), [], m.get('rep') ) + return img.cli.col( fn, sec, int(x), int(y), [], m.get('rep') ) cols = map( f, d.get('maps') ) cols = ut.filter_lst( lambda col: col != [], cols ) @@ -45,97 +39,109 @@ return def_col return np.fmin( np.sum(cols, axis=0), 255 ) -ref_rate = ut.arg_f('ref_rate', 0.001) +def calc_diff(d, crsp, nv, ang_nv_eyev): + rtd = d.get('rtd', {}) + diff = rtd.get('diff', 0.9) + if not diff: + return 0 -use_srv = 'use_srv' in sys.argv + ang_nv_eyev_nega = -ang_nv_eyev -def get_col(data, lights, l_g, sec, nest_rate=1.0, prev_d=None): - if nest_rate < 0.01: + def f(ltd): + ltv = ltd.get( 'v', mt.arr( [0,0,-1] ) ) + if 'p' in ltd: + ltv = crsp - ltd.get('p') + if all(ltv == 0): + return 0 + ltv = v.unit(ltv) + ang_nv_lt = np.dot( nv, ltv ) + ang_nv_lt_nega = -ang_nv_lt + if ang_nv_eyev_nega * ang_nv_lt_nega < 0: + return 0 + return abs( ang_nv_lt ) * ltd.get('e', 1.0) + + lights = ut.dic_cache( srv_dic, 'lights', lambda : val.cli.get_prop('lights') ) + + return sum( map( f, lights ) ) * diff + +def reflect_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx): + ang_nv_eyev_nega = -ang_nv_eyev + reflect = rtd.get('reflect', 0) + if not reflect: + return [] + if ang_nv_eyev_nega < 0 and not rtd.get('reflect_backside', False): return [] + ref_v = nv * ( 2 * ang_nv_eyev_nega ) + eyev + ref_l = line.new( crsp, ref_v ) + col = get_col( ref_l, sec, nest_rate * reflect, idx ) + return col * reflect if col != [] else [] + +def reflact_v(rtd, nv, eyev, ang_nv_eyev): + density = rtd.get('density', 1) + if density == 1 or abs(ang_nv_eyev) == 1 or ang_nv_eyev == 0: + return eyev + cos_v = nv * ang_nv_eyev + sin_v = eyev - cos_v + if ang_nv_eyev < 0: + density = 1.0 / density + r_sin_v = sin_v * density + sin_len2 = np.dot( r_sin_v, r_sin_v ) + sin_len2 = min( sin_len2, 1 ) + cos_len = math.sqrt( 1 - sin_len2 ) + r_cos_v = cos_v * ( cos_len / v.len1( cos_v ) ) + return v.unit( r_sin_v + r_cos_v ) + +def reflact_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx): + reflact = rtd.get('reflact', 0) + if not reflact: + return [] + ref_v = reflact_v(rtd, nv, eyev, ang_nv_eyev) + ref_l = line.new( crsp, ref_v ) + col = get_col( ref_l, sec, nest_rate * reflact, idx ) + return col * reflact if col != [] else [] - crs = {} - if use_srv: - prev_idx = data.index(prev_d) if prev_d else -1 - crs = rt_sock.client.cross(l_g, prev_idx) - idx = crs.get('idx') - if idx < 0: - return [] - crs['d'] = data[idx] - else: - lst = map( lambda d: { 'l_g': l_g, 'd': d, 'eq_d': d == prev_d }, data ) - lst = ut.filter_lst( lambda crs: cross.cross(crs), lst ) - if not lst: - return [] - crs = min( lst, key=lambda crs: crs.get('t') ) - cross.nv(crs) - d = crs.get('d') - rtd = d.get('rtd', {}) - base = rtd.get('base', 0.3) +use_srv = 'use_srv' in sys.argv - crst = crs.get('t') - crsp = crs.get('l_nv_g').p +srv_dic = {} - nv = crs.get('nv') +def get_col(l_g, sec, nest_rate=1.0, prev_idx=-1): + if nest_rate < 0.01: + return [] - eyev = crs.get('eyev') - ang_nv_eyev = crs.get('ang_nv_eyev') + f = cross.cli.cross_ if use_srv else cross.cross_ + (idx, l_nv_g, nv, eyev, ang_nv_eyev) = f(l_g, prev_idx) + if idx < 0: + return [] + + data = ut.dic_cache( srv_dic, 'data', lambda : val.cli.get_prop('data') ) + d = data[idx] + rtd = d.get('rtd', {}) + crsp = l_nv_g.p ang_nv_eyev_nega = -ang_nv_eyev rev = ang_nv_eyev_nega < 0 - col = map_col( crs, rev, sec ) + col = map_col( d, l_nv_g, rev, sec ) col = mt.arr(col) - diff = crs.get('diff') if use_srv else calc_diff(d, lights, crs) - col = col * (base + diff) + base = rtd.get('base', 0.3) - def reflect_col(): - reflect = rtd.get('reflect', 0) - if not reflect: - return [] - if ang_nv_eyev_nega < 0 and not rtd.get('reflect_backside', False): - return [] - ref_v = nv * ( 2 * ang_nv_eyev_nega ) + eyev - ref_l = line.new( crsp, ref_v ) - col = get_col( data, lights, ref_l, sec, nest_rate * reflect, d ) - return col * reflect if col != [] else [] + #diff = crs.get('diff') if use_srv else calc_diff(d, crsp, nv, ang_nv_eyev) + diff = calc_diff(d, crsp, nv, ang_nv_eyev) + col = col * (base + diff) - col_ = reflect_col() + col_ = reflect_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx) if col_ != []: col = col + col_ - def reflact_v(): - density = rtd.get('density', 1) - if density == 1 or abs(ang_nv_eyev) == 1 or ang_nv_eyev == 0: - return eyev - cos_v = nv * ang_nv_eyev - sin_v = eyev - cos_v - if ang_nv_eyev < 0: - density = 1.0 / density - r_sin_v = sin_v * density - sin_len2 = np.dot( r_sin_v, r_sin_v ) - sin_len2 = min( sin_len2, 1 ) - cos_len = math.sqrt( 1 - sin_len2 ) - r_cos_v = cos_v * ( cos_len / v.len1( cos_v ) ) - return v.unit( r_sin_v + r_cos_v ) - - def reflact_col(): - reflact = rtd.get('reflact', 0) - if not reflact: - return [] - ref_v = reflact_v() - ref_l = line.new( crsp, ref_v ) - col = get_col( data, lights, ref_l, sec, nest_rate * reflact, d ) - return col * reflact if col != [] else [] - - col_ = reflact_col() + col_ = reflact_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx) if col_ != []: col = col + col_ return col -def draw(data, lights, eye2g, wh2eye, sc_sz, video): +def draw(eye2g, wh2eye, sc_sz, video): (w, h, d_) = sc_sz wh2g = lstx.opt( wh2eye + [ eye2g ] ) cnt = ut.new_cnt_wh(w, h, 'wh') @@ -143,38 +149,31 @@ show = '-quiet' not in sys.argv while cnt.up(show): (ix, iy) = cnt.cur() - #p = lstx.tr( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) ) p = lstx.tr_p( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) ) l_g = line.new_p2(eye2g.p, p) - col = get_col(data, lights, l_g, sec) + + col = get_col(l_g, sec) + if col != []: col = np.fmin( col, 255 ) video.set(ix, iy, col) -def calc_diff(d, lights, crs): - rtd = d.get('rtd', {}) - diff = rtd.get('diff', 0.9) - if not diff: - return 0 - - crsp = crs.get('l_nv_g').p - nv = crs.get('nv') - ang_nv_eyev = crs.get('ang_nv_eyev') - ang_nv_eyev_nega = -ang_nv_eyev - - def f(ltd): - ltv = ltd.get( 'v', mt.arr( [0,0,-1] ) ) - if 'p' in ltd: - ltv = crsp - ltd.get('p') - if all(ltv == 0): - return 0 - ltv = v.unit(ltv) - ang_nv_lt = np.dot( nv, ltv ) - ang_nv_lt_nega = -ang_nv_lt - if ang_nv_eyev_nega * ang_nv_lt_nega < 0: - return 0 - return abs( ang_nv_lt ) * ltd.get('e', 1.0) - - return sum( map( f, lights ) ) * diff +### +cmd_infs = [ + { 'cmd': 'get_col', 'func': get_col, 'args': '(line,f8,f8,i4)', 'rets': 'col' }, +] + +sock_inf = { + 'srv_cmd': './rt.py boot', + 'port': sock.port + 13, + 'pid': -1, +} + +cli = sock.new_client(sock_inf, cmd_infs) + +if __name__ == "__main__": + if ut.arg_is(1, 'boot'): + sock.server(sock_inf, cmd_infs) + sys.exit(0) # EOF diff -urN rt_v28/rt_sock.c rt_v29/rt_sock.c --- rt_v28/rt_sock.c 2018-04-24 00:23:49.000000000 +0900 +++ rt_v29/rt_sock.c 1970-01-01 09:00:00.000000000 +0900 @@ -1,278 +0,0 @@ -#include -#include -#include -#include "cross.h" -#include "lstx.h" -#include "rt.h" - -/* FILE *dbg; */ - -#define CMD_CLEAR 0 -#define CMD_ADD 1 -#define CMD_ADD_LIGHTS 2 -#define CMD_CROSS 3 -#define CMD_QUIT 4 - -struct data *data = NULL; -int data_n = 0; - -struct lights lights = { 0, NULL }; - -void -ret0(void) -{ - int n = 0; - fwrite(&n, sizeof(n), 1, stdout); - fflush(stdout); -} - -void -alloc(int n) -{ - int i, sz = sizeof(*data) * n; - - if(data){ - free(data); - data = NULL; - } - data = malloc(sz); - data_n = n; - for(i=0; iv3); - memcpy(vs->v3, bp, n); bp += n; - vecs_init(vs); /* ! */ - return bp; -} - -char * -unpack_xx(char *bp, struct x_x *xx) -{ - int n; - - n = 4; - memcpy(&xx->typ, bp, n); bp += n; - - switch(xx->typ){ - case TYP_AX: - n = sizeof(xx->ax.p); - memcpy(&xx->ax.p, bp, n); bp += n; - bp = unpack_vs(bp, &xx->ax.vs); - break; - case TYP_CX: - n = sizeof(xx->cx); - memcpy(&xx->cx, bp, n); bp += n; - break; - case TYP_FX: - n = sizeof(xx->fx); - memcpy(&xx->fx, bp, n); bp += n; - break; - default: - break; - } - return bp; -} - -char * -unpack_lx(char *bp, struct lstx *lx) -{ - int n, i; - - n = 4; - memcpy(&lx->n, bp, n); bp += n; - - lx->lst = malloc( sizeof(*lx->lst) * lx->n ); - - for(i=0; in; i++){ - bp = unpack_xx(bp, &lx->lst[i]); - } - return bp; -} - -void -add(void) -{ - int n, i, ki; - char *buf, *bp; - - fread(&n, sizeof(n), 1, stdin); - bp = buf = malloc(n); - - fread(buf, 1, n, stdin); - - n = 4; - memcpy(&i, bp, n); bp += n; - memcpy(&ki, bp, n); bp += n; - - data[i].ki = ki; - bp = unpack_lx(bp, &data[i].l2g); - - n = sizeof( data[i].rtd ); - memcpy(&data[i].rtd, bp, n); bp += n; - - if(buf){ - free(buf); - } - ret0(); - /* - fprintf(dbg, "a %d %d/%f %f %f/%f %f %f,%f %f %f,%f %f %f\n", - i, data[i].ki, - data[i].l2g.p[0], - data[i].l2g.p[1], - data[i].l2g.p[2], - data[i].l2g.vs.v3[0], - data[i].l2g.vs.v3[1], - data[i].l2g.vs.v3[2], - data[i].l2g.vs.v3[3], - data[i].l2g.vs.v3[4], - data[i].l2g.vs.v3[5], - data[i].l2g.vs.v3[6], - data[i].l2g.vs.v3[7], - data[i].l2g.vs.v3[8]); - */ -} - -void -add_lights(void) -{ - int n; - char *buf, *bp; - - fread(&n, sizeof(n), 1, stdin); - bp = buf = malloc(n); - - fread(buf, 1, n, stdin); - - n = 4; - memcpy(&lights.n, bp, n); bp += n; - - n = sizeof(*lights.lst) * lights.n; - lights.lst = malloc(n); - - memcpy(lights.lst, bp, n); bp += n; - - if(buf){ - free(buf); - } - ret0(); -} - -void -cross_(void) -{ - char buf[ sizeof(struct line) + sizeof(int) ], *bp = buf; - int n, i, prev_idx, idx, sz; - double dbuf[ sizeof(struct line) / sizeof(double) ]; - struct line l_g; - struct cross_ret ret, ret_; - char sbuf[ sizeof(int) * 2 + sizeof(ret) ]; - - fread(&n, sizeof(n), 1, stdin); - /*n = sizeof(buf);*/ - fread(buf, 1, n, stdin); - - n = sizeof(dbuf); - memcpy(dbuf, bp, n); bp += n; - - n = sizeof(int); - memcpy(&prev_idx, bp, n); - - line_new( &l_g, &dbuf[0], &dbuf[3] ); - - idx = -1; - memset(&ret, 0, sizeof(ret)); - - for(i=0; i= 0 ){ - cross_nv( data[idx].ki, &data[idx].l2g.lst[0].ax, &l_g, &ret ); - ret.diff = rt_calc_diff( &data[idx], &lights, &ret ); - } - - sz = sizeof(sbuf); - bp = sbuf; - - n = sizeof(int); - memcpy(bp, &sz, n); bp += n; - - memcpy(bp, &idx, n); bp += n; - - n = sizeof(ret); - memcpy(bp, &ret, n); bp += n; - - n = sz; - fwrite(sbuf, 1, n, stdout); - fflush(stdout); -} - -int -main(int ac, char **av) -{ - char *key = "n="; - int key_n = strlen(key), cmd, i, n; - - /* dbg = fopen("dbg.txt", "w"); */ - - for(i=1; ih_addr, hp->h_length); + if((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) return -1; + if(connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0){ + close(fd); + return -1; + } + return fd; +} + +int +conn(char *s) +{ + int i, port; + char name[1024]; + + for(i=0; s[i]; i++) if(s[i] == ':') break; + if(i > 0 && s[i]){ + memcpy(name, s, i); + name[i] = '\0'; + }else strcpy(name, "localhost"); + i = s[i] ? i + 1 : 0; + port = strtol(s+i, NULL, 0); + + return conn_host_port(name, port); +} + +int +srv_port(int port) +{ + int sfd; + struct sockaddr_in saddr; + + if((sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) return -1; + memset(&saddr, 0, sizeof(saddr)); + saddr.sin_family = AF_INET; + saddr.sin_addr.s_addr = htonl(INADDR_ANY); + saddr.sin_port = htons(port); + if(bind(sfd, (struct sockaddr *)&saddr, sizeof(saddr)) == -1){ + close(sfd); + return -1; + } + if(listen(sfd, 5) == -1){ + close(sfd); + return -1; + } + return sfd; +} + +int +srv_accept(int sfd) +{ + struct sockaddr_in caddr; + socklen_t clen = sizeof(caddr); + int cfd; + + memset(&caddr, 0, clen); + if((cfd = accept(sfd, (struct sockaddr *)&caddr, &clen)) == -1) return -1; + return cfd; +} + +/**/ + +char * +alloc_add_bsz(int usz, int n, char *s, int *ret_sz) +{ + int bsz = usz * n; + int isz = sizeof(bsz); + char *buf = malloc( isz + bsz ); + char *bp = buf; + + memcpy(bp, &bsz, isz); bp += isz; + memcpy(bp, s, bsz); bp += bsz; + + if(ret_sz){ + *ret_sz = isz + bsz; + } + return buf; +} + +char * +sock_cli_call(int fd, int cmd, int args_sz, char *args, int *rets_sz, char *rets) +{ + int sz; + char *buf; + + write(fd, &cmd, sizeof(cmd)); + write(fd, &args_sz, sizeof(args_sz)); + if(args_sz > 0){ + write(fd, args, args_sz); + } + + read(fd, &sz, sizeof(sz)); + + buf = rets; + if(rets == NULL || rets_sz == NULL || *rets_sz < sz){ + buf = malloc(sz); + } + + read(fd, buf, sz); + + if(rets && rets_sz && sz <= *rets_sz){ + memcpy(rets, buf, *rets_sz); /* best effort */ + } + if(rets_sz){ + *rets_sz = sz; + } + return buf; + /* + if return buf != rets --> need free buf + */ +} + +pthread_mutex_t lock_arg = PTHREAD_MUTEX_INITIALIZER; +pthread_cond_t cond_arg = PTHREAD_COND_INITIALIZER; + +pthread_mutex_t lock_func = PTHREAD_MUTEX_INITIALIZER; + +void * +cmd_loop(void *arg) +{ + void **args = (void **)arg; + int fd, func_n, cmd, cmd_sz = sizeof(cmd); + void **funcs; + void (*func)(int fd); + + pthread_mutex_lock(&lock_arg); + + fd = *(int *)args[0]; + func_n = *(int *)args[1]; + funcs = args[2]; + + pthread_mutex_unlock(&lock_arg); + pthread_cond_signal(&cond_arg); + + while( read(fd, &cmd, cmd_sz) == cmd_sz ){ + if(!(0 <= cmd && cmd < func_n)){ + break; + } + func = funcs[cmd]; + + pthread_mutex_lock(&lock_func); + (*func)(fd); + pthread_mutex_unlock(&lock_func); + } + return NULL; +} + +void +sock_srv_main_loop(int port, int func_n, void **funcs) +{ + int sfd = srv_port(port); + int cfd; + pthread_t th; + void *arg[] = { &cfd, &func_n, funcs }; + + while(1){ + pthread_mutex_lock(&lock_arg); + + cfd = srv_accept(sfd); + if(cfd < 0){ + pthread_mutex_unlock(&lock_arg); + break; + } + pthread_create(&th, NULL, cmd_loop, &arg); + pthread_detach(th); + + pthread_cond_wait(&cond_arg, &lock_arg); + + pthread_mutex_unlock(&lock_arg); + } +} + +/* EOF */ diff -urN rt_v28/sock.h rt_v29/sock.h --- rt_v28/sock.h 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/sock.h 2018-04-29 22:55:06.000000000 +0900 @@ -0,0 +1,30 @@ +#ifndef __SOCK_H__ +#define __SOCK_H__ 1 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ut.h" + +#define SOCK_PORT 55500 + +int conn_host_port(char *host, int port); +int conn(char *s); +int srv_port(int port); +int srv_accept(int sfd); + +/**/ + +char *alloc_add_bsz(int usz, int n, char *s, int *ret_sz); + +char *sock_cli_call(int fd, int cmd, int args_sz, char *args, int *rets_sz, char *rets); +void sock_srv_main_loop(int port, int func_n, void **funcs); + +#endif diff -urN rt_v28/sock.py rt_v29/sock.py --- rt_v28/sock.py 2018-04-23 22:15:27.000000000 +0900 +++ rt_v29/sock.py 2018-04-29 17:44:25.000000000 +0900 @@ -2,87 +2,93 @@ import sys import socket -import six +import threading import ut import bin +import pks -# Ex. psk = '(i4,(f8,f8,f8),[i4],[(f8,(i4,i4))])' +port = 55500 # base -pks_lst = lambda pks: pks[1:-1].split(',') +def cmd_infs_copy(cmd_infs, typ): + args_f = pks.conv_unpack if typ == 'server' else pks.conv_pack + rets_f = pks.conv_unpack if typ == 'client' else pks.conv_pack -def pks_to_funcs_pack(pks): - if pks[0] == '(': - return tuple( map( pks_to_funcs_pack, pks_lst(pks) ) ) - if pks[0] == '[': - return [ pks_to_funcs_pack( pks[1:-1] ) ] # len == 1 - return bin.nm_dic_pack.get(pks) - -def pks_to_funcs_unpack(pks): - if pks[0] == '(': - return tuple( map( pks_to_funcs_unpack, pks_lst(pks) ) ) - if pks[0] == '[': - return [ pks_to_funcs_unpack( pks[1:-1] ) ] # len == 1 - return bin.nm_dic_unpack.get(pks) - -def pack_pks(pks, v): - if not pks: - return b'' - typ = type(pks) - if typ == tuple: - return b''.join( ut.map_up( pack_pks, zip(pks, v) ) ) - if typ == list: - return bin.pack_i4( len(v) ) + b''.join( map( lambda v_: pack_pks( pks[0], v_ ), v ) ) - return pks(v) - -def unpack_pks(pks, s): - if not pks: - return (None, s) - typ = type(pks) - if typ == tuple: - lst = [] - for pks_ in pks: - (v, s) = unpack_pks(pks_, s) - lst.append(v) - return (lst, s) - if typ == list: - (n, s) = bin.unpack_i4(s) - pks_ = pks[0] - lst = [] - for i in range(n): - (v, s) = unpack_pks(pks_, s) - lst.append(v) - return (lst, s) - return pks(s) - -def new_client(cmd_infs): - # cmd_infs == list of { 'cmd': cmd, 'args': pks, 'rets': pks } - - cmd_infs_ = cmd_infs - cmd_infs = [] - for d in cmd_infs_: + lst = [] + for d in cmd_infs: d = d.copy() if 'args' in d: - d['args'] = pks_to_funcs_pack( d.get('args') ) + d['args'] = args_f( d.get('args') ) if 'rets' in d: - d['rets'] = pks_to_funcs_unpack( d.get('rets') ) - cmd_infs.append(d) + d['rets'] = rets_f( d.get('rets') ) + lst.append(d) + return lst - e = ut.Empty() +# sock_inf dic keys [ srv_cmd, port, pid ] - e.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) +def new_client(sock_inf, cmd_infs): + e = ut.Empty() - e.proc = None - e.fifo_name = '' + cmd_infs = cmd_infs_copy(cmd_infs, 'client') + cmds = list( map( lambda d: d.get('cmd'), cmd_infs ) ) + get_cmd_idx = lambda cmd: cmds.index(cmd) if cmd in cmds else -1 - def boot_server(cmd_stdio, port, fifo_name): - cmd_nc = 'nc -l {}'.format(port) - cmd = 'rm -f @ ; mkfifo @ ; cat @ | {} | {} > @'.replace('@', fifo_name) - cmd = cmd.format(cmd_nc, cmd_stdio) - e.proc = ut.cmd_proc(cmd) - ut.sleep(3) # ! - e.sock.connect(('localhost', port)) - e.fifo_name = fifo_name - e.boot_server = boot_server + def update_pid(): + cmd = 'ps ax | grep -v grep | grep "{}"'.format( sock_inf.get('srv_cmd') ) + s = ut.cmd_exec(cmd) + if type(s) == bytes: + s = s.decode() + s = s.strip().split(' ')[0] + pid = int(s) if s else -1 + sock_inf['pid'] = pid + e.update_pid = update_pid + + def boot(): + proc = ut.cmd_proc( sock_inf.get('srv_cmd') ) + sock_inf['pid'] = proc.pid + ut.sleep(1) + print('boot ' + sock_inf.get('srv_cmd')) + e.boot = boot + + e.sock = None + def new_sock(): + e.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + e.sock.settimeout(5) + + e.conn_ok = False + def conn(): + if sock_inf.get('pid') < 0: + update_pid() + if sock_inf.get('pid') < 0: + boot() + if not e.sock: + new_sock() + if not e.conn_ok: + try: + print('conn ' + sock_inf.get('srv_cmd')) + port = sock_inf.get('port') + e.sock.connect(('localhost', port)) + e.conn_ok = True + except OSError as err: + print('err={}'.format(err)) + e.conn = conn + + def close(): + if not e.sock: + return + if e.conn_ok: + e.sock.shutdown(socket.SHUT_RDWR) + e.conn_ok == False + e.sock.close() + e.sock = None + e.close = close + + def kill(): + close() + pid = sock_inf.get('pid') + if pid >= 0: + ut.kill_pid(pid) + sock_inf['pid'] = -1 + e.kill = kill read = lambda n: e.sock.recv(n) if n > 0 else '' write = lambda s: e.sock.sendall(s) @@ -90,81 +96,83 @@ recv = lambda : read( bin.unpack_i4( read(4) )[0] ) send = lambda s: write( bin.pack_i4( len(s) ) + s ) - recv_pks = lambda pks: unpack_pks( pks, recv() ) - send_pks = lambda pks, ret: send( pack_pks( pks, ret ) ) - - cmds = list( map( lambda d: d.get('cmd'), cmd_infs ) ) - - get_cmd_idx = lambda cmd: cmds.index(cmd) if cmd in cmds else -1 + recv_pks = lambda finf: pks.unpack( finf, recv() ) + send_pks = lambda finf, v: send( pks.pack( finf, v ) ) def call(cmd, args=None): i = get_cmd_idx(cmd) if i < 0: - err_msg( '? cmd={}'.format(i) ) + ut.err_msg( '? cmd={}'.format(cmd) ) return None cmd_inf = cmd_infs[i] - write( bin.pack_i4(i) ) + + if not e.conn_ok: + e.conn() + try: + write( bin.pack_i4(i) ) + except OSError as err: + print(sock_inf) + print(err) + send_pks( cmd_inf.get('args'), args ) (rets, _) = recv_pks( cmd_inf.get('rets') ) - if cmd == 'quit': - if e.proc: - ut.kill_proc(e.proc) - if e.fifo_name: - ut.cmd_exec('rm ' + e.fifo_name) return rets - e.call = call + + mk_func = lambda cmd: ( lambda *args: call(cmd, args) ) + for d in cmd_infs: + cmd = d.get('cmd') + setattr( e, cmd, mk_func(cmd) ) return e -def new_server(cmd_infs): - # cmd_infs == list of { 'cmd': cmd, 'func': f, 'args': pks, 'rets': pks } - - cmd_infs_ = cmd_infs - cmd_infs = [] - for d in cmd_infs_: - d = d.copy() - if 'args' in d: - d['args'] = pks_to_funcs_unpack( d.get('args') ) - if 'rets' in d: - d['rets'] = pks_to_funcs_pack( d.get('rets') ) - cmd_infs.append(d) - - e = ut.Empty() - - err_msg = lambda s: sys.stderr.write(s + '\n') - - read = lambda n: ( sys.stdin.buffer.read(n) if six.PY3 else sys.stdin.read(n) ) if n > 0 else b'' - - def write(s): - if six.PY3: - sys.stdout.buffer.write(s) - else: - sys.stdout.write(s) - sys.stdout.flush() +def cmd_loop(sock, cmd_infs, lock): + read = lambda n: sock.recv(n) if n > 0 else '' + write = lambda s: sock.sendall(s) recv = lambda : read( bin.unpack_i4( read(4) )[0] ) send = lambda s: write( bin.pack_i4( len(s) ) + s ) - recv_pks = lambda pks: unpack_pks( pks, recv() ) - send_pks = lambda pks, ret: send( pack_pks( pks, ret ) ) - - get_cmd_inf = lambda i: cmd_infs[i] if i in range( len(cmd_infs) ) else {} + recv_pks = lambda finf: pks.unpack( finf, recv() ) + send_pks = lambda finf, v: send( pks.pack( finf, v ) ) - def main_loop(): - while True: - (i, _) = bin.unpack_i4( read(4) ) - cmd_inf = get_cmd_inf(i) - if not cmd_inf: - err_msg( '? cmd_idx={:02x}'.format(i) ) - break - (args, _) = recv_pks( cmd_inf.get('args') ) - func = cmd_inf.get('func') - rets = ( func(*args) if args != None else func() ) if func else None - send_pks( cmd_inf.get('rets'), rets ) - if cmd_inf.get('cmd') == 'quit': - break - e.main_loop = main_loop - - return e + while True: + s = read(4) + if not s: + break + (i, s) = bin.unpack_i4(s) + + cmd_inf = ut.lst_get(cmd_infs, i) + if not cmd_inf: + ut.err_msg( '? cmd_idx={:02x}'.format(i) ) + break + + (args, _) = recv_pks( cmd_inf.get('args') ) + + func = cmd_inf.get('func') + rets = None + if func: + lock.acquire() + rets = func(*args) if args != None else func() + lock.release() + + send_pks( cmd_inf.get('rets'), rets ) + if s: + sock.shutdown(socket.SHUT_RDWR) + sock.close() + +def server(sock_inf, cmd_infs): + lock = threading.Lock() + cmd_infs = cmd_infs_copy(cmd_infs, 'server') + + port = sock_inf.get('port') + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.bind(('localhost', port)) + sock.listen(5) + + while True: + (csock, addr) = sock.accept() + th = threading.Thread( target=cmd_loop, args=(csock, cmd_infs, lock) ) + th.daemon = True + th.start() # EOF diff -urN rt_v28/sock_test.py rt_v29/sock_test.py --- rt_v28/sock_test.py 2018-04-23 21:50:00.000000000 +0900 +++ rt_v29/sock_test.py 2018-04-24 22:59:10.000000000 +0900 @@ -7,13 +7,11 @@ add = lambda a, b: a+b add_sub = lambda a, b: (a+b, a-b) add1 = lambda v: v+1 -quit = lambda : None cmd_infs = [ { 'cmd': 'add', 'func': add, 'args': '(f8,f8)', 'rets': 'f8' }, { 'cmd': 'add_sub', 'func': add_sub, 'args': '(f8,f8)', 'rets': '(f8,f8)' }, { 'cmd': 'add1', 'func': add1, 'args': '(i4)', 'rets': 'i4' }, - { 'cmd': 'quit', 'func': quit }, ] if __name__ == "__main__": @@ -21,23 +19,31 @@ if 'srv' in sys.argv: server = sock.new_server(cmd_infs) - server.main_loop() + server.main_loop() + elif 'boot' in sys.argv: + client = sock.new_client(cmd_infs) + client.boot_server( './sock_test.py srv', port, 'sock_test_fifo' ) + client.disconn() + elif 'quit' in sys.argv: + client = sock.new_client(cmd_infs) + client.conn(port) + client.quit() else: - proc = sock.boot_server( './sock_test.py srv', port, 'sock_test_fifo' ) - ut.sleep(3) - client = sock.new_client(cmd_infs) client.conn(port) rets = client.call('add1', [123]); print('rets=', rets) + sys.stdout.flush() rets = client.call('add1', [999]); print('rets=', rets) + sys.stdout.flush() rets = client.call('add', [123.45, 111.11]) print('rets=', rets) + sys.stdout.flush() rets = client.call('add_sub', [123.45, 111.11]) print('rets=', rets) - client.call('quit'); + sys.stdout.flush() - ut.kill_proc(proc) + client.disconn() # EOF diff -urN rt_v28/sock_test2.py rt_v29/sock_test2.py --- rt_v28/sock_test2.py 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/sock_test2.py 2018-04-25 21:05:06.000000000 +0900 @@ -0,0 +1,66 @@ +#!/usr/bin/env python + +import sys +import six +import ut +import bin +import socket + +def srv(): + read = lambda n: ( sys.stdin.buffer.read(n) if six.PY3 else sys.stdin.read(n) ) if n > 0 else b'' + def write(s): + if six.PY3: + sys.stdout.buffer.write(s) + else: + sys.stdout.write(s) + sys.stdout.flush() + + sum = 0 + while True: + (i, _) = bin.unpack_i4( read(4) ) + if i < 0: + break + sum += i + write( bin.pack_i4(sum) ) + +if __name__ == "__main__": + + port = 3456 + fifo_name = 'fifo_test' + + if 'srv' in sys.argv: + srv() + sys.exit(0) + + if 'boot' in sys.argv: + + cmd_stdio = './sock_test2.py srv' + cmd_nc = 'nc -l -k {}'.format(port) + cmd = 'rm -f @ ; mkfifo @ ; cat @ | {} | {} > @'.replace('@', fifo_name) + cmd = cmd.format(cmd_nc, cmd_stdio) + proc = ut.cmd_proc(cmd) + ut.sleep(3) # ! + print( 'pid={}'.format(proc.pid) ) + sys.exit(0) + + if 'kill' in sys.argv: + pid = ut.arg_i('pid', -1) + if pid == -1: + print('pid=?') + sys.exit(1) + ut.kill_pid(pid) + ut.cmd_exec('rm -f ' + fifo_name) + sys.exit(0) + + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.connect(('localhost', port)) + + read = lambda n: sock.recv(n) if n > 0 else '' + write = lambda s: sock.sendall(s) + + for i in range(10): + write( bin.pack_i4(i) ) + sum = bin.unpack_i4( read(4) )[0] + print( 'sum={}'.format(sum) ) + sock.close() +# EOF diff -urN rt_v28/sock_test3.py rt_v29/sock_test3.py --- rt_v28/sock_test3.py 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/sock_test3.py 2018-04-25 21:20:00.000000000 +0900 @@ -0,0 +1,120 @@ +#!/usr/bin/env python + +import sys +import socket +import threading +import six +import ut +import bin + +port = 3456 + +lock = threading.Lock() + +sum = 0 + +def srv_f(sock): + global sum + + read = lambda n: sock.recv(n) if n > 0 else '' + write = lambda s: sock.sendall(s) + + while True: + s = read(4) + if not s: + break + (i, s) = bin.unpack_i4(s) + if i < 0: + break + lock.acquire() + sum += i + write( bin.pack_i4(sum) ) + lock.release() + +def srv(): + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.bind(('localhost', port)) + sock.listen(5) + + while True: + (csock, addr) = sock.accept() + th = threading.Thread( target=srv_f, args=(csock,) ) + th.daemon = True + th.start() + +def cli_test(name): + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.connect(('localhost', port)) + + read = lambda n: sock.recv(n) if n > 0 else '' + write = lambda s: sock.sendall(s) + + for i in range(10): + write( bin.pack_i4(i) ) + sum = bin.unpack_i4( read(4) )[0] + print( '{}: +{} sum={}'.format(name, i, sum) ) + + write( bin.pack_i4(-1) ) + sock.close() + +if __name__ == "__main__": + + if 'srv' in sys.argv: + srv() + sys.exit(0) + + if 'boot' in sys.argv: + cmd = '{} srv'.format( sys.argv[0] ) + proc = ut.cmd_proc(cmd) + ut.sleep(3) # ! + print( 'pid={}'.format(proc.pid) ) + sys.exit(0) + + if 'kill' in sys.argv: + pid = ut.arg_i('pid', -1) + if pid == -1: + print('pid=?') + sys.exit(1) + ut.kill_pid(pid) + sys.exit(0) + + ths = [] + for name in [ 'foo', 'bar' ]: + th = threading.Thread( target=cli_test, args=(name,) ) + th.daemon = True + th.start() + ths.append(th) + + for th in ths: + th.join() + +''' +$ ./sock_test3.py boot +pid=11287 + +$ ./sock_test3.py +bar: +0 sum=0 +bar: +1 sum=1 +foo: +0 sum=1 +bar: +2 sum=3 + foo: +1 sum=4 +foo: +2 sum=6 +bar: +3 sum=9 +foo: +3 sum=12 +foo: +4 sum=16 + bar: +4 sum=20 +bar: +5 sum=30 +foo: +5 sum=25 + bar: +6 sum=36 +bar: +7 sum=49 + foo: +6 sum=42 +foo: +7 sum=56 +foo: +8 sum=64 +foo: +9 sum=73 +bar: +8 sum=81 +bar: +9 sum=90 + +$ ./sock_test3.py kill pid=11287 +''' + +# EOF diff -urN rt_v28/sock_test4.py rt_v29/sock_test4.py --- rt_v28/sock_test4.py 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/sock_test4.py 2018-04-25 21:30:25.000000000 +0900 @@ -0,0 +1,65 @@ +#!/usr/bin/env python + +import sys +import threading +import ut +import sock + +port = 3456 + +sum = 0 + +def add(a): + global sum + sum += a + return sum + +def get_sum(): + return sum + +cmd_infs = [ + { 'cmd': 'add', 'func': add, 'args': '(i4)', 'rets': 'i4' }, + { 'cmd': 'get_sum', 'func': get_sum, 'rets': 'i4' }, +] + +def cli_test(name): + cli = sock.new_client(port, cmd_infs) + cli.conn() + n = 5 + for i in range(n): + if name == 'hoge': + print( '{}: sum={}'.format( name, cli.get_sum() ) ) + else: + print( '{}: +{} ret={}'.format(name, i, cli.add(i) ) ) + cli.close() + +if __name__ == "__main__": + + if 'srv' in sys.argv: + sock.server(port, cmd_infs) + sys.exit(0) + + if 'boot' in sys.argv: + cmd = '{} srv'.format( sys.argv[0] ) + proc = ut.cmd_proc(cmd) + print( 'pid={}'.format(proc.pid) ) + sys.exit(0) + + if 'kill' in sys.argv: + pid = ut.arg_i('pid', -1) + if pid == -1: + print('pid=?') + sys.exit(1) + ut.kill_pid(pid) + sys.exit(0) + + ths = [] + for name in [ 'foo', 'bar', 'hoge' ]: + th = threading.Thread( target=cli_test, args=(name,) ) + th.daemon = True + th.start() + ths.append(th) + + for th in ths: + th.join() +# EOF diff -urN rt_v28/ut.c rt_v29/ut.c --- rt_v28/ut.c 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/ut.c 2018-04-29 22:55:29.000000000 +0900 @@ -0,0 +1,17 @@ +#include "ut.h" + +void +hex_dump(char *b, int n) +{ + int i; + unsigned char *u = (unsigned char *)b; + + for(i=0; i +#include +#include +#include + +void hex_dump(char *b, int n); + +#endif diff -urN rt_v28/ut.py rt_v29/ut.py --- rt_v28/ut.py 2018-04-12 21:28:50.000000000 +0900 +++ rt_v29/ut.py 2018-04-27 00:43:42.000000000 +0900 @@ -7,6 +7,11 @@ import subprocess from decimal import * +def err_msg(s): + sys.stderr.write(s + '\n') + +hex = lambda s: ''.join( map( lambda c: '{:02x}'.format( ord(c) ), s ) ) + map_lst = lambda f, lst: list( map( f, lst ) ) map_up = lambda f, lst: map( lambda a: f(*a), lst ) map_up_lst = lambda f, lst: list( map_up( f, lst ) ) @@ -19,6 +24,7 @@ arg_v = lambda fs, k, def_val: ( lambda s: fs(s) if s else def_val )( arg_s(k) ) arg_i = lambda k, def_val: arg_v( int, k, def_val ) arg_f = lambda k, def_val: arg_v( float, k, def_val ) +arg_is = lambda i, s: lst_get(sys.argv, i) == s def dic_set(d, k, v): d[k] = v @@ -28,6 +34,11 @@ if_not_set = lambda d, k, v: dic_cache(d, k, lambda : v) +in_range = lambda i, n: 0<=i and i +#include "mt.h" extern double v_x1[3]; extern double v_y1[3]; diff -urN rt_v28/val.c rt_v29/val.c --- rt_v28/val.c 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/val.c 2018-04-30 00:02:57.000000000 +0900 @@ -0,0 +1,97 @@ +#include "val.h" + +int port = SOCK_PORT + 11; + +#define VAL_GETI 0 +#define VAL_GETS 1 +#define VAL_GETN 2 +#define VAL_PRELOAD 3 +#define VAL_GET_LST 4 + +#define VAL_SET_PROP_BYTES 5 +#define VAL_DEL_PROP 6 +#define VAL_HAS_PROP 7 +#define VAL_GET_HAS_PROP_LST 8 + +#define VAL_GET_PROP_BYTES 9 +#define VAL_GET_PROP_TYP_STR 10 +#define VAL_GET_PROP_N 11 + +#define VAL_GET_PROP_BYTES_IDXS 12 +#define VAL_GET_PROP_TYP_STR_IDXS 13 +#define VAL_GET_PROP_N_IDXS 14 + +int fd = -1; + +void +val_conn(void) +{ + char *host = "localhost"; + int port = SOCK_PORT + 11; + + if(fd < 0){ + fd = conn_host_port(host, port); + } + if(fd < 0){ + fprintf(stderr, "? val boot\n"); + } +} + +void +val_close(void) +{ + if(fd < 0){ + return; + } + close(fd); + fd = -1; +} + +char * +get_prop_bytes(char *s, int *ret_sz) +{ + char *str, *rets; + int str_sz, cmd; + + str = alloc_add_bsz(1, strlen(s), s, &str_sz); + + cmd = VAL_GET_PROP_BYTES; + if(ret_sz){ + *ret_sz = 0; + } + + val_conn(); + + rets = sock_cli_call(fd, cmd, str_sz, str, ret_sz, NULL); + free(str); + return rets; /* need free */ +} + +char * +get_prop(char *s, int *ret_sz) +{ + int sz, n; + char *b = get_prop_bytes(s, NULL), *bp = b; + char *ret; + + /* skip typ_str size */ + sz = sizeof(n); + memcpy(&n, bp, sz); bp += sz; + + /* skip typ_str */ + bp += n; + + /* skip pkd_bytes size */ + sz = sizeof(n); + memcpy(&n, bp, sz); bp += sz; + + ret = malloc(n); + memcpy(ret, bp, n); + free(b); + if(ret_sz){ + *ret_sz = n; + } + return ret; /* need free */ +} + +/* EOF */ diff -urN rt_v28/val.h rt_v29/val.h --- rt_v28/val.h 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/val.h 2018-04-29 23:56:23.000000000 +0900 @@ -0,0 +1,13 @@ +#ifndef __VAL_H__ +#define __VAL_H__ 1 + +#include "sock.h" + +void val_conn(void); +void val_close(void); + +char *get_prop_bytes(char *s, int *ret_sz); + +char *get_prop(char *s, int *ret_sz); + +#endif diff -urN rt_v28/val.py rt_v29/val.py --- rt_v28/val.py 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/val.py 2018-04-30 00:57:42.000000000 +0900 @@ -0,0 +1,240 @@ +#!/usr/bin/env python + +import sys +import ut +import sock +import pks + +lst = [] + +# for prop +lst_prop_has = [] +lst_prop_cvs = [] +lst_prop_v = [] + +def set_no_prop(i): + lst_prop_has[i] = 0 + lst_prop_cvs[i] = pks.convs('str') + lst_prop_v[i] = 'unset' + +def geti(s): + if s not in lst: + lst.append(s) + + lst_prop_has.append(None) + lst_prop_cvs.append(None) + lst_prop_v.append(None) + set_no_prop(-1) # tail data + + return lst.index(s) + +gets = lambda i: ut.lst_get(lst, i, -1) + +preload = lambda lst: list( map(geti, lst) ) + + +# for prop + +def set_prop_bytes(s, typ_str, pkd_bytes): + i = geti(s) + lst_prop_cvs[i] = cvs = pks.convs(typ_str) + (v, _) = pks.unpack( cvs.get('unpack'), pkd_bytes ) + lst_prop_v[i] = v + lst_prop_has[i] = 1 + +def del_prop(s): + i = geti(s) + set_no_prop(i) + +def has_prop(s): + i = geti(s) + return lst_prop_has[i] + +def get_has_prop_lst(): + return list( filter( lambda s: lst_prop_has[ lst.index(s) ], lst ) ) + +def get_prop_bytes(s): + i = geti(s) + cvs = lst_prop_cvs[i] + pkd_bytes = pks.pack( cvs.get('pack'), lst_prop_v[i] ) + return ( cvs.get('org_str'), pkd_bytes ) + +def get_prop_typ_str(s): + i = geti(s) + cvs = lst_prop_cvs[i] + return cvs.get('org_str') + +v_len = lambda v: len(v) if type(v) in (tuple, list, dict) else 1 + +def get_prop_n(s): + i = geti(s) + if not lst_prop_has[i]: + return 0 + v = lst_prop_v[i] + return v_len(v) + + +# for prop idxs + +def get_prop_idxs_sinf_v(s, idxs): + i = geti(s) + if not lst_prop_has[i]: + return ('str', 'unset') + cvs = lst_prop_cvs[i] + sinf = cvs.get('str') + v = lst_prop_v[i] + (sinf, v) = pks.ref(sinf, v, idxs) + return (sinf, v) + +def set_prop_bytes_idxs(s, idxs, pkd_byets): + org_str = get_prop_typ_str_idxs(s, idxs) + + if not idxs: + set_prop_bytes(s, org_str, pkd_bytes) + return + + (in_v, _) = pks.unpack_org_str( org_str, pkd_bytes ) + + idx = idxs[-1] + out_idxs = idxs[:-1] + + (out_sinf, out_v) = get_prop_idxs_sinf_v(s, out_idxs) + pks.set_idx(out_sinf, out_v, idx, in_v) + +def get_prop_bytes_idxs(s, idxs): + (sinf, v) = get_prop_idxs_sinf_v(s, idxs) + org_str = pks.rconv(sinf) + pkd_bytes = pks.pack_org_str( org_str, v ) + return ( org_str, pkd_bytes ) + +def get_prop_idxs_v(s, idxs): + (sinf, v) = get_prop_idxs_sinf_v(s, idxs) + return v + +def get_prop_typ_str_idxs(s, idxs): + ( org_str, _ ) = get_prop_bytes_idxs(s, idx) + return org_str + +def get_prop_n_idxs(s, idxs): + if not has_prop(s): + return 0 + v = get_prop_idxs_v(s, idxs) + return v_len(v) + +cmd_infs = [ + { 'cmd': 'geti', 'func': geti, 'args': '(str)', 'rets': 'i4' }, + { 'cmd': 'gets', 'func': gets, 'args': '(i4)', 'rets': 'str' }, + { 'cmd': 'getn', 'func': ( lambda : len(lst) ), 'rets': 'i4' }, + { 'cmd': 'preload', 'func': preload, 'args': '([str])', 'rets': '[i4]' }, + { 'cmd': 'get_lst', 'func': ( lambda : lst ), 'rets': '[str]' }, + + # prop + { 'cmd': 'set_prop_bytes', 'func': set_prop_bytes, 'args': '(str,str,bytes)' }, + { 'cmd': 'del_prop', 'func': del_prop, 'args': '(str)' }, + { 'cmd': 'has_prop', 'func': has_prop, 'args': '(str)', 'rets': 'i4' }, + { 'cmd': 'get_has_prop_lst', 'func': get_has_prop_lst, 'rets': '[str]' }, + + { 'cmd': 'get_prop_bytes', 'func': get_prop_bytes, 'args': '(str)', 'rets': '(str,bytes)' }, + { 'cmd': 'get_prop_typ_str', 'func': get_prop_typ_str, 'args': '(str)', 'rets': 'str' }, + { 'cmd': 'get_prop_n', 'func': get_prop_n, 'args': '(str)', 'rets': 'i4' }, + + # prop idxs + { 'cmd': 'set_prop_bytes_idxs', 'func': set_prop_bytes_idxs, 'args': '(str,[i4],bytes)' }, # cannot change typ_str , + { 'cmd': 'get_prop_bytes_idxs', 'func': get_prop_bytes_idxs, 'args': '(str,[i4])', 'rets': '(str,bytes)' }, + { 'cmd': 'get_prop_typ_str_idxs', 'func': get_prop_typ_str_idxs, 'args': '(str,[i4])', 'rets': 'str' }, + { 'cmd': 'get_prop_n_idxs', 'func': get_prop_n_idxs, 'args': '(str,[i4])', 'rets': 'i4' }, +] + +sock_inf = { + 'srv_cmd': './val.py boot', + 'port': sock.port + 11, + 'pid': -1, +} + +def new_client(): + cli = sock.new_client(sock_inf, cmd_infs) + + def set_prop(s, typ_str, v): + pkd_bytes = pks.pack_org_str(typ_str, v) + cli.set_prop_bytes(s, typ_str, pkd_bytes) + cli.set_prop = set_prop + + def get_prop(s): + (typ_str, pkd_bytes) = cli.get_prop_bytes(s) + (v, _) = pks.unpack_org_str(typ_str, pkd_bytes) + return v + cli.get_prop = get_prop + + def get_prop_idxs(s, idxs): + (typ_str, pkd_bytes) = cli.get_prop_bytes_idxs(s, idxs) + (v, _) = pks.unpack_org_str(typ_str, pkd_bytes) + return v + cli.get_prop_idxs = get_prop_idxs + + return cli + +cli = new_client() + +def tool(): + if '?' in sys.argv: + print( 'Usage: {} tool'.format( sys.argv[0] ) ) + print( ' set_prop s, v' ) + print( ' get_prop s' ) + print( ' get_prop all' ) + print( ' get_lst' ) + print( ' del_prop s' ) + print( ' geti s' ) + return + if 'boot' in sys.argv: + cli.boot() + return + if 'kill' in sys.argv: + cli.kill() + return + if 'set_prop' in sys.argv: + i = sys.argv.index( 'set_prop' ) + s = ut.lst_get(sys.argv, i+1, 'test_key') + v = ut.lst_get(sys.argv, i+2, 'test_val') + cli.set_prop(s, 'str', v) + return + if 'get_prop' in sys.argv: + i = sys.argv.index( 'get_prop' ) + s = ut.lst_get(sys.argv, i+1, 'all') + if s != 'all': + print( cli.get_prop(s) ) + return + ks = cli.get_has_prop_lst() + for k in ks: + v = cli.get_prop(k) + print( '{} : {}'.format(k, v) ) + return + if 'get_lst' in sys.argv: + print( cli.get_lst() ) + return + if 'del_prop' in sys.argv: + i = sys.argv.index( 'del_prop' ) + s = ut.lst_get(sys.argv, i+1, '') + if not s: + return + cli.del_prop(s) + return + if 'geti' in sys.argv: + i = sys.argv.index( 'geti' ) + s = ut.lst_get(sys.argv, i+1, '') + print( cli.geti(s) ) + return + if 'gets' in sys.argv: + i = sys.argv.index( 'gets' ) + s = ut.lst_get(sys.argv, i+1, '') + print( cli.gets(int(s)) ) + return + +if __name__ == "__main__": + if ut.arg_is(1, 'boot'): + sock.server(sock_inf, cmd_infs) + sys.exit(0) + + if ut.arg_is(1, 'tool'): + tool() + sys.exit(0) +# EOF diff -urN rt_v28/val_test.py rt_v29/val_test.py --- rt_v28/val_test.py 1970-01-01 09:00:00.000000000 +0900 +++ rt_v29/val_test.py 2018-04-28 00:10:00.000000000 +0900 @@ -0,0 +1,59 @@ +#!/usr/bin/env python + +import sys +import ut +import val + +if __name__ == "__main__": + cli = val.cli + + cli.set_prop('foo', 'i4', 123) + cli.set_prop('bar', 'f8', -999.888) + cli.set_prop('hoge', '[str]', ['hello', 'how', 'are', 'you']) + cli.set_prop('fuga', '{k1:i4,k2:f8,k3:str,k4:(i4,str)}', { 'k1': -777, 'k2': 3.141592, 'k3': 'kon', 'k4': (7, 'seven') }) + + for k in ['foo', 'bar', 'hoge', 'fuga']: + v = cli.get_prop(k) + print( 'prop {}={}'.format(k, v) ) + + v = cli.get_prop_idxs('hoge', [2]) + print( 'prop hoge[2]={}'.format(v) ) + + v = cli.get_prop_idxs('fuga', [3]) + print( 'prop fuga[3]={}'.format(v) ) + v = cli.get_prop_idxs('fuga', [3,0]) + print( 'prop fuga[3,0]={}'.format(v) ) + v = cli.get_prop_idxs('fuga', [3,1]) + print( 'prop fuga[3,1]={}'.format(v) ) + + n = cli.get_prop_n('foo') + print( 'prop foo n={}'.format(n) ) + n = cli.get_prop_n('hoge') + print( 'prop hoge n={}'.format(n) ) + n = cli.get_prop_n_idxs('hoge', [1]) + print( 'prop hoge[1] n={}'.format(n) ) + n = cli.get_prop_n('fuga') + print( 'prop fuga n={}'.format(n) ) + n = cli.get_prop_n_idxs('fuga', [3]) + print( 'prop fuga[3] n={}'.format(n) ) + n = cli.get_prop_n_idxs('fuga', [3, 0]) + print( 'prop fuga[3,0] n={}'.format(n) ) + n = cli.get_prop_n_idxs('fuga', [3, 1]) + print( 'prop fuga[3,1] n={}'.format(n) ) + + while True: + sys.stdout.write('> ') + sys.stdout.flush() + + s = sys.stdin.readline().strip() + print('s=', s) + if not s or s == 'quit': + break + + i = cli.geti(s) + print('i=', i) + + print('n=', cli.getn()) + + cli.kill() +# EOF diff -urN rt_v28/vecs.h rt_v29/vecs.h --- rt_v28/vecs.h 2018-04-13 20:24:38.000000000 +0900 +++ rt_v29/vecs.h 2018-04-29 17:18:38.000000000 +0900 @@ -2,8 +2,8 @@ #define __VECS_H__ #include +#include #include -#include "mt.h" #include "v.h" struct vecs{ diff -urN rt_v28/wf.py rt_v29/wf.py --- rt_v28/wf.py 2018-04-06 22:00:00.000000000 +0900 +++ rt_v29/wf.py 2018-04-27 22:20:00.000000000 +0900 @@ -6,6 +6,7 @@ import line import ax import lstx +import val def wf_ps_idxs(d): len_to_idxs = lambda n, add=0: ut.map_lst( lambda i: ( add+i, add+(i+1)%n ), range(n) ) @@ -105,8 +106,12 @@ (pa, pb) = r return [pa, pb] -def draw(data, lights, eye2g, wh2eye, sc_sz, video): +def draw(eye2g, wh2eye, sc_sz, video): col = [255,255,255] # white + + data = val.cli.get_prop('data') + lights = val.cli.get_prop('lights') + for d in data: ps = [] idxs = []