def test_some_integer_type(): ffi = FFI() ffi.cdef(""" typedef int... foo_t; typedef unsigned long... bar_t; typedef struct { foo_t a, b; } mystruct_t; foo_t foobar(bar_t, mystruct_t); static const bar_t mu = -20; static const foo_t nu = 20; """) lib = verify(ffi, 'test_some_integer_type', """ typedef unsigned long long foo_t; typedef short bar_t; typedef struct { foo_t a, b; } mystruct_t; static foo_t foobar(bar_t x, mystruct_t s) { return (foo_t)x + s.a + s.b; } static const bar_t mu = -20; static const foo_t nu = 20; """) assert ffi.sizeof("foo_t") == ffi.sizeof("unsigned long long") assert ffi.sizeof("bar_t") == ffi.sizeof("short") maxulonglong = 2 ** 64 - 1 assert int(ffi.cast("foo_t", -1)) == maxulonglong assert int(ffi.cast("bar_t", -1)) == -1 assert lib.foobar(-1, [0, 0]) == maxulonglong assert lib.foobar(2 ** 15 - 1, [0, 0]) == 2 ** 15 - 1 assert lib.foobar(10, [20, 31]) == 61 assert lib.foobar(0, [0, maxulonglong]) == maxulonglong py.test.raises(OverflowError, lib.foobar, 2 ** 15, [0, 0]) py.test.raises(OverflowError, lib.foobar, -(2 ** 15) - 1, [0, 0]) py.test.raises(OverflowError, ffi.new, "mystruct_t *", [0, -1]) assert lib.mu == -20 assert lib.nu == 20
def test_redefine_common_type(): prefix = "" if sys.version_info < (3,) else "b" ffi = FFI() ffi.cdef("typedef char FILE;") assert repr(ffi.cast("FILE", 123)) == "<cdata 'char' %s'{'>" % prefix ffi.cdef("typedef char int32_t;") assert repr(ffi.cast("int32_t", 123)) == "<cdata 'char' %s'{'>" % prefix
def test_vararg(self): if not sys.platform.startswith('linux'): py.test.skip("probably no symbol 'stderr' in the lib") ffi = FFI(backend=self.Backend()) ffi.cdef(""" int fprintf(void *, const char *format, ...); void *stderr; """) ffi.C = ffi.dlopen(None) with FdWriteCapture() as fd: ffi.C.fprintf(ffi.C.stderr, b"hello with no arguments\n") ffi.C.fprintf(ffi.C.stderr, b"hello, %s!\n", ffi.new("char[]", b"world")) ffi.C.fprintf(ffi.C.stderr, ffi.new("char[]", b"hello, %s!\n"), ffi.new("char[]", b"world2")) ffi.C.fprintf(ffi.C.stderr, b"hello int %d long %ld long long %lld\n", ffi.cast("int", 42), ffi.cast("long", 84), ffi.cast("long long", 168)) ffi.C.fprintf(ffi.C.stderr, b"hello %p\n", ffi.NULL) res = fd.getvalue() assert res == (b"hello with no arguments\n" b"hello, world!\n" b"hello, world2!\n" b"hello int 42 long 84 long long 168\n" b"hello (nil)\n")
def test_from_buffer(self): import array ffi = FFI() a = array.array('H', [10000, 20000, 30000]) c = ffi.from_buffer(a) assert ffi.typeof(c) is ffi.typeof("char[]") ffi.cast("unsigned short *", c)[1] += 500 assert list(a) == [10000, 20500, 30000]
def test_redefine_common_type(): prefix = "" if sys.version_info < (3,) else "b" ffi = FFI() ffi.cdef("typedef char FILE;") assert repr(ffi.cast("FILE", 123)) == "<cdata 'char' %s'{'>" % prefix ffi.cdef("typedef char int32_t;") assert repr(ffi.cast("int32_t", 123)) == "<cdata 'char' %s'{'>" % prefix ffi = FFI() ffi.cdef("typedef int bool, *FILE;") assert repr(ffi.cast("bool", 123)) == "<cdata 'int' 123>" assert repr(ffi.cast("FILE", 123)) == "<cdata 'int *' 0x7b>" ffi = FFI() ffi.cdef("typedef bool (*fn_t)(bool, bool);") # "bool," but within "( )"
def test_function_pointer(self): ffi = FFI(backend=self.Backend()) def cb(charp): assert repr(charp).startswith("<cdata 'char *' 0x") return 42 fptr = ffi.callback("int(*)(const char *txt)", cb) assert fptr != ffi.callback("int(*)(const char *)", cb) assert repr(fptr) == "<cdata 'int(*)(char *)' calling %r>" % (cb,) res = fptr(b"Hello") assert res == 42 # if not sys.platform.startswith('linux'): py.test.skip("probably no symbol 'stderr' in the lib") ffi.cdef(""" int fputs(const char *, void *); void *stderr; """) ffi.C = ffi.dlopen(None) fptr = ffi.cast("int(*)(const char *txt, void *)", ffi.C.fputs) assert fptr == ffi.C.fputs assert repr(fptr).startswith("<cdata 'int(*)(char *, void *)' 0x") with FdWriteCapture() as fd: fptr(b"world\n", ffi.C.stderr) res = fd.getvalue() assert res == b'world\n'
def test_win_common_types(): from cffi.commontypes import COMMON_TYPES, _CACHE from cffi.commontypes import win_common_types, resolve_common_type # def clear_all(extra={}, old_dict=COMMON_TYPES.copy()): COMMON_TYPES.clear() COMMON_TYPES.update(old_dict) COMMON_TYPES.update(extra) _CACHE.clear() # for maxsize in [2 ** 32 - 1, 2 ** 64 - 1]: ct = win_common_types(maxsize) clear_all(ct) for key in sorted(ct): resolve_common_type(key) # assert did not crash # now try to use e.g. WPARAM (-> UINT_PTR -> unsigned 32/64-bit) for maxsize in [2 ** 32 - 1, 2 ** 64 - 1]: ct = win_common_types(maxsize) clear_all(ct) ffi = FFI() value = int(ffi.cast("WPARAM", -1)) assert value == maxsize # clear_all()
def test_ffi_new_allocator_2(self): ffi = FFI(backend=self.Backend()) seen = [] def myalloc(size): seen.append(size) return ffi.new("char[]", b"X" * size) def myfree(raw): seen.append(raw) alloc1 = ffi.new_allocator(myalloc, myfree) alloc2 = ffi.new_allocator(alloc=myalloc, free=myfree, should_clear_after_alloc=False) p1 = alloc1("int[10]") p2 = alloc2("int[]", 10) assert seen == [40, 40] assert ffi.typeof(p1) == ffi.typeof("int[10]") assert ffi.sizeof(p1) == 40 assert ffi.typeof(p2) == ffi.typeof("int[]") assert ffi.sizeof(p2) == 40 assert p1[5] == 0 assert p2[6] == ord('X') * 0x01010101 raw1 = ffi.cast("char *", p1) raw2 = ffi.cast("char *", p2) del p1, p2 retries = 0 while len(seen) != 4: retries += 1 assert retries <= 5 import gc; gc.collect() assert seen == [40, 40, raw1, raw2] assert repr(seen[2]) == "<cdata 'char[]' owning 41 bytes>" assert repr(seen[3]) == "<cdata 'char[]' owning 41 bytes>"
def test_new_handle(self): ffi = FFI(backend=self.Backend()) o = [2, 3, 4] p = ffi.new_handle(o) assert ffi.typeof(p) == ffi.typeof("void *") assert ffi.from_handle(p) is o assert ffi.from_handle(ffi.cast("char *", p)) is o py.test.raises(RuntimeError, ffi.from_handle, ffi.NULL)
def range_f(start, end, step): """Create a list of double values.""" end = c_double(end) ffi = FFI() start = c_double(start) while start.value <= end.value: yield ffi.cast("double", start.value) start.value = start.value + c_double(step).value
def check(self, source, expected_ofs_y, expected_align, expected_size): # NOTE: 'expected_*' is the numbers expected from GCC. # The numbers expected from MSVC are not explicitly written # in this file, and will just be taken from the compiler. ffi = FFI() ffi.cdef("struct s1 { %s };" % source) ctype = ffi.typeof("struct s1") # verify the information with gcc ffi1 = FFI() ffi1.cdef( """ static const int Gofs_y, Galign, Gsize; struct s1 *try_with_value(int fieldnum, long long value); """ ) fnames = [name for name, cfield in ctype.fields if name and cfield.bitsize > 0] setters = ["case %d: s.%s = value; break;" % iname for iname in enumerate(fnames)] lib = ffi1.verify( """ struct s1 { %s }; struct sa { char a; struct s1 b; }; #define Gofs_y offsetof(struct s1, y) #define Galign offsetof(struct sa, b) #define Gsize sizeof(struct s1) struct s1 *try_with_value(int fieldnum, long long value) { static struct s1 s; memset(&s, 0, sizeof(s)); switch (fieldnum) { %s } return &s; } """ % (source, " ".join(setters)) ) if sys.platform == "win32": expected_ofs_y = lib.Gofs_y expected_align = lib.Galign expected_size = lib.Gsize else: assert (lib.Gofs_y, lib.Galign, lib.Gsize) == (expected_ofs_y, expected_align, expected_size) # the real test follows assert ffi.offsetof("struct s1", "y") == expected_ofs_y assert ffi.alignof("struct s1") == expected_align assert ffi.sizeof("struct s1") == expected_size # compare the actual storage of the two for name, cfield in ctype.fields: if cfield.bitsize < 0 or not name: continue if int(ffi.cast(cfield.type, -1)) == -1: # signed min_value = -(1 << (cfield.bitsize - 1)) max_value = (1 << (cfield.bitsize - 1)) - 1 else: min_value = 0 max_value = (1 << cfield.bitsize) - 1 for t in [1, 2, 4, 8, 16, 128, 2813, 89728, 981729, -1, -2, -4, -8, -16, -128, -2813, -89728, -981729]: if min_value <= t <= max_value: self._fieldcheck(ffi, lib, fnames, name, t)
def test_WPARAM_on_windows(): if sys.platform != 'win32': py.test.skip("Only for Windows") ffi = FFI() ffi.cdef("void f(WPARAM);") # # WPARAM -> UINT_PTR -> unsigned 32/64-bit integer ffi = FFI() value = int(ffi.cast("WPARAM", -42)) assert value == sys.maxsize * 2 - 40
def test_cannot_instantiate_manually(self): ffi = FFI() ct = type(ffi.typeof("void *")) py.test.raises(TypeError, ct) py.test.raises(TypeError, ct, ffi.NULL) for cd in [type(ffi.cast("void *", 0)), type(ffi.new("char[]", 3)), type(ffi.gc(ffi.NULL, lambda x: None))]: py.test.raises(TypeError, cd) py.test.raises(TypeError, cd, ffi.NULL) py.test.raises(TypeError, cd, ffi.typeof("void *"))
def test_explicit_cdecl_stdcall(self): if sys.platform != 'win32': py.test.skip("Windows-only test") if self.Backend is CTypesBackend: py.test.skip("not with the ctypes backend") win64 = (sys.maxsize > 2**32) # ffi = FFI(backend=self.Backend()) ffi.cdef(""" BOOL QueryPerformanceFrequency(LONGLONG *lpFrequency); """) m = ffi.dlopen("Kernel32.dll") tp = ffi.typeof(m.QueryPerformanceFrequency) assert str(tp) == "<ctype 'int(*)(long long *)'>" # ffi = FFI(backend=self.Backend()) ffi.cdef(""" BOOL __cdecl QueryPerformanceFrequency(LONGLONG *lpFrequency); """) m = ffi.dlopen("Kernel32.dll") tpc = ffi.typeof(m.QueryPerformanceFrequency) assert tpc is tp # ffi = FFI(backend=self.Backend()) ffi.cdef(""" BOOL WINAPI QueryPerformanceFrequency(LONGLONG *lpFrequency); """) m = ffi.dlopen("Kernel32.dll") tps = ffi.typeof(m.QueryPerformanceFrequency) if win64: assert tps is tpc else: assert tps is not tpc assert str(tps) == "<ctype 'int(__stdcall *)(long long *)'>" # ffi = FFI(backend=self.Backend()) ffi.cdef("typedef int (__cdecl *fnc_t)(int);") ffi.cdef("typedef int (__stdcall *fns_t)(int);") tpc = ffi.typeof("fnc_t") tps = ffi.typeof("fns_t") assert str(tpc) == "<ctype 'int(*)(int)'>" if win64: assert tps is tpc else: assert str(tps) == "<ctype 'int(__stdcall *)(int)'>" # fnc = ffi.cast("fnc_t", 0) fns = ffi.cast("fns_t", 0) ffi.new("fnc_t[]", [fnc]) if not win64: py.test.raises(TypeError, ffi.new, "fnc_t[]", [fns]) py.test.raises(TypeError, ffi.new, "fns_t[]", [fnc]) ffi.new("fns_t[]", [fns])
def test_include_3(): ffi1 = FFI() ffi1.cdef("typedef short sshort_t;") verify(ffi1, "test_include_3_parent", "typedef short sshort_t;") ffi = FFI() ffi.include(ffi1) ffi.cdef("sshort_t ff3(sshort_t);") lib = verify(ffi, "test_include_3", "typedef short sshort_t; //usually from a #include\n" "sshort_t ff3(sshort_t x) { return x + 42; }") assert lib.ff3(10) == 52 assert ffi.typeof(ffi.cast("sshort_t", 42)) is ffi.typeof("short") assert ffi1.typeof("sshort_t") is ffi.typeof("sshort_t")
def test_verify_anonymous_enum_with_typedef(): ffi = FFI() ffi.cdef("typedef enum { AA, ... } e1;") lib = verify(ffi, 'test_verify_anonymous_enum_with_typedef1', "typedef enum { BB, CC, AA } e1;") assert lib.AA == 2 assert ffi.sizeof("e1") == ffi.sizeof("int") assert repr(ffi.cast("e1", 2)) == "<cdata 'e1' 2: AA>" # ffi = FFI() ffi.cdef("typedef enum { AA=%d } e1;" % sys.maxsize) lib = verify(ffi, 'test_verify_anonymous_enum_with_typedef2', "typedef enum { AA=%d } e1;" % sys.maxsize) assert lib.AA == sys.maxsize assert ffi.sizeof("e1") == ffi.sizeof("long")
def test_verify_enum(): ffi = FFI() ffi.cdef("""enum e1 { B1, A1, ... }; enum e2 { B2, A2, ... };""") lib = verify(ffi, 'test_verify_enum', "enum e1 { A1, B1, C1=%d };" % sys.maxsize + "enum e2 { A2, B2, C2 };") ffi.typeof("enum e1") ffi.typeof("enum e2") assert lib.A1 == 0 assert lib.B1 == 1 assert lib.A2 == 0 assert lib.B2 == 1 assert ffi.sizeof("enum e1") == ffi.sizeof("long") assert ffi.sizeof("enum e2") == ffi.sizeof("int") assert repr(ffi.cast("enum e1", 0)) == "<cdata 'enum e1' 0: A1>"
def paste(self, im, box=None): """ Paste a PIL image into the photo image. Note that this can be very slow if the photo image is displayed. :param im: A PIL image. The size must match the target region. If the mode does not match, the image is converted to the mode of the bitmap image. :param box: A 4-tuple defining the left, upper, right, and lower pixel coordinate. See :ref:`coordinate-system`. If None is given instead of a tuple, all of the image is assumed. """ # convert to blittable im.load() image = im.im if image.isblock() and im.mode == self.__mode: block = image else: block = image.new_block(self.__mode, im.size) image.convert2(block, image) # convert directly between buffers tk = self.__photo.tk try: tk.call("PyImagingPhoto", self.__photo, block.id) except tkinter.TclError: # activate Tkinter hook try: from . import _imagingtk try: if hasattr(tk, 'interp'): # Required for PyPy, which always has CFFI installed from cffi import FFI ffi = FFI() # PyPy is using an FFI CDATA element # (Pdb) self.tk.interp # <cdata 'Tcl_Interp *' 0x3061b50> _imagingtk.tkinit( int(ffi.cast("uintptr_t", tk.interp)), 1) else: _imagingtk.tkinit(tk.interpaddr(), 1) except AttributeError: _imagingtk.tkinit(id(tk), 0) tk.call("PyImagingPhoto", self.__photo, block.id) except (ImportError, AttributeError, tkinter.TclError): raise # configuration problem; cannot attach to Tkinter
def test_include_7(): ffi1 = FFI() ffi1.cdef("typedef ... mystruct_t;\n" "int ff7b(mystruct_t *);") verify(ffi1, "test_include_7_parent", "typedef struct { int x; } mystruct_t;\n" "int ff7b(mystruct_t *p) { return p->x; }") ffi = FFI() ffi.include(ffi1) ffi.cdef("mystruct_t *ff7(void);") lib = verify(ffi, "test_include_7", "typedef struct { int x; } mystruct_t; //usually from a #include\n" "static mystruct_t result_struct = { 42 };" "mystruct_t *ff7(void) { return &result_struct; }") p = lib.ff7() assert ffi.cast("int *", p)[0] == 42 assert lib.ff7b(p) == 42
def main(): """Program main.""" ffi = FFI() ffi.cdef(""" double integral_to_infinite(double a, double b, double E); double to_degrees(double radians); """) # C = ffi.dlopen(None) lib = ffi.verify(""" #include "tetaQuad.h" """, include_dirs=["."], extra_compile_args=["-O3"]) var_e = ffi.cast("double", 0.1) var_a = ffi.cast("double", 0.0) points_x = [] points_y = [] points_y_a = [] print("Calculus may take some time...") for var_b in range_f(0.0, 100, 0.5): points_x.append(var_b) rad = lib.integral_to_infinite(var_a, var_b, var_e) theta = lib.to_degrees(abs(rad)) analytic = degrees(analytic_evaluation(var_b, var_e)) print("b = {}\ttheta = {}\tanalytic = {}".format( float(var_b), theta, analytic)) points_y.append(theta) points_y_a.append(analytic) plt.ylabel('teta') plt.xlabel('b') # plt.plot(points_x, points_y, 'r--') plt.plot(points_x, points_y, 'ro') plt.plot(points_x, points_y_a, 'b--') # plt.plot(points_x, points_y_a, 'bo') red_line = mpatches.Patch(color='red', label='theta value') blue_line = mpatches.Patch(color='blue', label='analytic value') plt.legend(handles=[red_line, blue_line]) plt.grid(True) plt.show()
def verify_rnn_forward(net): '''Test network with given input data on both darknet and tvm''' def get_darknet_network_predict(net, data): return LIB.network_predict(net, data) from cffi import FFI ffi = FFI() np_arr = np.zeros([1, net.inputs], dtype='float32') np_arr[0, 84] = 1 cffi_arr = ffi.cast('float*', np_arr.ctypes.data) tvm_out = _get_tvm_output(net, np_arr)[0] darknet_output = get_darknet_network_predict(net, cffi_arr) darknet_out = np.zeros(net.outputs, dtype='float32') for i in range(net.outputs): darknet_out[i] = darknet_output[i] last_layer = net.layers[net.n-1] darknet_outshape = (last_layer.batch, last_layer.outputs) darknet_out = darknet_out.reshape(darknet_outshape) tvm.testing.assert_allclose(darknet_out, tvm_out, rtol=1e-4, atol=1e-4)
def c_charptrptr_as_string_list(ffi: FFI, ptr: CffiData, size: int) -> List[str]: """Convert if possible a cffi pointer to a C data array char** , into a list of python strings. Args: ffi (FFI): FFI instance wrapping the native compilation module owning the native memory ptr (CffiData): cffi pointer (FFI.CData) size (int): number of character strings in the char** pointer Raises: RuntimeError: conversion is not supported Returns: List[str]: converted data """ # TODO check type strings = ffi.cast('char*[%d]' % (size, ), ptr) res = [as_string(ffi.string(strings[i])) for i in range(size)] return res
def test_struct_array_no_length(self): ffi = FFI() ffi.cdef("struct foo_s { int x; int a[]; };") p = ffi.new("struct foo_s *", [100, [200, 300, 400]]) assert p.x == 100 assert ffi.typeof(p.a) is ffi.typeof("int[]") assert len(p.a) == 3 # length recorded assert p.a[0] == 200 assert p.a[1] == 300 assert p.a[2] == 400 assert list(p.a) == [200, 300, 400] q = ffi.cast("struct foo_s *", p) assert q.x == 100 assert ffi.typeof(q.a) is ffi.typeof("int *") # no length recorded py.test.raises(TypeError, len, q.a) assert q.a[0] == 200 assert q.a[1] == 300 assert q.a[2] == 400 py.test.raises(TypeError, list, q.a)
def test_struct_array_no_length(self): ffi = FFI() ffi.cdef("struct foo_s { int x; int a[]; };") p = ffi.new("struct foo_s *", [100, [200, 300, 400]]) assert p.x == 100 assert ffi.typeof(p.a) is ffi.typeof("int[]") assert len(p.a) == 3 # length recorded assert p.a[0] == 200 assert p.a[1] == 300 assert p.a[2] == 400 assert list(p.a) == [200, 300, 400] q = ffi.cast("struct foo_s *", p) assert q.x == 100 assert ffi.typeof(q.a) is ffi.typeof("int *") # no length recorded py.test.raises(TypeError, len, q.a) assert q.a[0] == 200 assert q.a[1] == 300 assert q.a[2] == 400 py.test.raises(TypeError, list, q.a)
def dVdg_wrapper(xp, yp, weights, q_true, t_true, hdx_p, hdy_p, hnd_raw_p, test=False): if test: from test_constants import array_length_test, const_length_test, big_array_length_test from _geometry_test.lib import dVdg_function_c array_length = array_length_test const_length = const_length_test big_array_length = big_array_length_test else: from constants import array_length_real, const_length_real, big_array_length_real from _geometry2.lib import dVdg_function_c array_length = array_length_real const_length = const_length_real big_array_length = big_array_length_real ffi = FFI() xp_c = deepcopy(xp) yp_c = deepcopy(yp) xp_p = ffi.cast("double*", xp_c.__array_interface__['data'][0]) yp_p = ffi.cast("double*", yp_c.__array_interface__['data'][0]) q_truec = q_true q_truep = ffi.new('double[4]', q_truec.tolist()) t_true_c = t_true t_true_p = ffi.new('double[3]', t_true_c.tolist()) weights_c = deepcopy(weights) weights_p = ffi.cast('double*', weights_c.__array_interface__['data'][0]) r_xc = np.zeros(const_length) r_xp = ffi.cast('double*', r_xc.__array_interface__['data'][0]) r_yc = np.zeros(const_length) r_yp = ffi.cast('double*', r_yc.__array_interface__['data'][0]) hnd_c = np.zeros(array_length) hnd_p = ffi.cast('double*', hnd_c.__array_interface__['data'][0]) dVdg_c = np.zeros(array_length) dVdg_p = ffi.cast('double*', dVdg_c.__array_interface__['data'][0]) Hnd_R_c = np.zeros(array_length) Hnd_R_p = ffi.cast('double*', Hnd_R_c.__array_interface__['data'][0]) V_c = dVdg_function_c(q_truep, t_true_p, weights_p, xp_p, yp_p, hdx_p, hdy_p, hnd_raw_p, dVdg_p, r_xp, r_yp) return np.array([V_c]), dVdg_c, r_xc, r_yc
def _test_rnn_network(net, states): """Test network with given input data on both darknet and tvm""" def get_darknet_network_predict(net, data): return LIB.network_predict(net, data) from cffi import FFI ffi = FFI() np_arr = np.zeros([1, net.inputs], dtype="float32") np_arr[0, 2] = 1 cffi_arr = ffi.cast("float*", np_arr.ctypes.data) tvm_out = _get_tvm_output(net, np_arr, states=states)[0] darknet_output = get_darknet_network_predict(net, cffi_arr) darknet_out = np.zeros(net.outputs, dtype="float32") for i in range(net.outputs): darknet_out[i] = darknet_output[i] last_layer = net.layers[net.n - 1] darknet_outshape = (last_layer.batch, last_layer.outputs) darknet_out = darknet_out.reshape(darknet_outshape) tvm.testing.assert_allclose(darknet_out, tvm_out, rtol=1e-4, atol=1e-4)
def test_variable_of_unknown_size(): ffi = FFI() ffi.cdef(""" typedef ... opaque_t; opaque_t globvar; """) lib = verify(ffi, 'test_variable_of_unknown_size', """ typedef char opaque_t[6]; opaque_t globvar = "hello"; """) # can't read or write it at all e = py.test.raises(TypeError, getattr, lib, 'globvar') assert str(e.value) in ["cdata 'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet"] #pypy e = py.test.raises(TypeError, setattr, lib, 'globvar', []) assert str(e.value) in ["'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet"] #pypy # but we can get its address p = ffi.addressof(lib, 'globvar') assert ffi.typeof(p) == ffi.typeof('opaque_t *') assert ffi.string(ffi.cast("char *", p), 8) == b"hello"
def test_variable_of_unknown_size(): ffi = FFI() ffi.cdef(""" typedef ... opaque_t; opaque_t globvar; """) lib = verify(ffi, 'test_variable_of_unknown_size', """ typedef char opaque_t[6]; opaque_t globvar = "hello"; """) # can't read or write it at all e = py.test.raises(TypeError, getattr, lib, 'globvar') assert str(e.value) in ["cdata 'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet"] #pypy e = py.test.raises(TypeError, setattr, lib, 'globvar', []) assert str(e.value) in ["'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet"] #pypy # but we can get its address p = ffi.addressof(lib, 'globvar') assert ffi.typeof(p) == ffi.typeof('opaque_t *') assert ffi.string(ffi.cast("char *", p), 8) == b"hello"
class LibHMuMu: def __init__(self, libpath=os.path.dirname(os.path.realpath(__file__)) + "/libhmm.so"): self.ffi = FFI() self.ffi.cdef(""" void* new_roccor(char* filename); void roccor_kScaleDT(void* rc, float* out, int n_elem, int* charges, float* pt, float* eta, float* phi, int s, int m); void roccor_kSpreadMC_or_kSmearMC(void* rc, float* out, int n_elem, int* charges, float* pt, float* eta, float* phi, float* genpt, int* tracklayers, float* rand, int s, int m); void* new_LeptonEfficiencyCorrector(int n, const char** file, const char** histo, float* weights); void LeptonEfficiencyCorrector_getSF(void* c, float* out, int n, int* pdgid, float* pt, float* eta); const void* new_gbr(const char* weightfile); int gbr_get_nvariables(const void* gbr); void gbr_eval(const void* gbr, float* out, int nev, int nfeatures, float* inputs_matrix); void csangles_eval(float* out_theta, float* out_phi, int nev, float* pt1, float* eta1, float* phi1, float* mass1, float* pt2, float* eta2, float* phi2, float* mass2, int* charges); void mllErr_eval(float* out_err, int nev, float* pt1, float* eta1, float* phi1, float* mass1, float* pt2, float* eta2, float* phi2, float* mass2, float* Err1, float* Err2); """) self.libhmm = self.ffi.dlopen(libpath) self.new_roccor = self.libhmm.new_roccor self.roccor_kScaleDT = self.libhmm.roccor_kScaleDT self.roccor_kSpreadMC_or_kSmearMC = self.libhmm.roccor_kSpreadMC_or_kSmearMC self.new_LeptonEfficiencyCorrector = self.libhmm.new_LeptonEfficiencyCorrector self.LeptonEfficiencyCorrector_getSF = self.libhmm.LeptonEfficiencyCorrector_getSF self.new_gbr = self.libhmm.new_gbr self.gbr_get_nvariables = self.libhmm.gbr_get_nvariables self.gbr_eval = self.libhmm.gbr_eval self.csangles_eval = self.libhmm.csangles_eval self.mllErr_eval = self.libhmm.mllErr_eval def cast_as(self, dtype_string, arr): return self.ffi.cast(dtype_string, arr.ctypes.data)
def search_neighbors(context, ref_indices=None, coordinates=None, view_vectors=None, angles_deg=None, naive=False): ffi = FFI() if ref_indices is None: num_indices = len(coordinates) x, y = zip(*coordinates) x_np = np.array(x) x_p = ffi.cast("double *", x_np.ctypes.data) y_np = np.array(y) y_p = ffi.cast("double *", y_np.ctypes.data) else: num_indices = len(ref_indices) indices_np = np.zeros(num_indices, dtype=np.int32) indices_p = ffi.cast("int *", indices_np.ctypes.data) if (view_vectors is None and angles_deg is None): use_angles = False vx_p = ffi.new("double *") vy_p = ffi.new("double *") angles_deg_p = ffi.new("double *") else: use_angles = True vx, vy = zip(*view_vectors) vx_np = np.array(vx) vx_p = ffi.cast("double *", vx_np.ctypes.data) vy_np = np.array(vy) vy_p = ffi.cast("double *", vy_np.ctypes.data) angles_deg_np = np.array(angles_deg) angles_deg_p = ffi.cast("double *", angles_deg_np.ctypes.data) if ref_indices is None: _lib.search_neighbors_by_coordinates(context, num_indices, indices_p, x_p, y_p, use_angles, vx_p, vy_p, angles_deg_p, naive) else: _lib.search_neighbor_by_indices(context, num_indices, indices_p, ref_indices, use_angles, vx_p, vy_p, angles_deg_p, naive) return indices_np.tolist()
def main_simple(): """ Pass a numpy array to a C function and get a numpy array back out Cleaned up version, from: http://stackoverflow.com/questions/16276268/how-to-pass-a-numpy-array-into-a-cffi-function-and-how-to-get-one-back-out """ ffi = FFI() ffi.cdef("void copy(float *in, float *out, int len);") C = ffi.dlopen("./libcopy.so") # Create float32 numpy array a = 42 * np.ones(16, dtype=np.float32) b = np.zeros_like(a) # Cast data to readable format by C pa = ffi.cast("float *", a.ctypes.data) pb = ffi.cast("float *", b.ctypes.data) C.copy(pa, pb, len(a)) # pb is C version of b, so values of b still changed print(b) return
def main_experimental(): """ Pass a numpy array to a C function and get a numpy array back out Experimental version (not guaranteed to work) """ ffi = FFI() ffi.cdef("void copy(float *in, float *out, int len);") #C = ffi.dlopen("./libcopy.so") C = ffi.verify("""#include "copy.h" """,libraries=['libcopy']) # Create float32 numpy array a = 42 * np.ones(16, dtype=np.float32) b = np.zeros_like(a) # Cast data to readable format by C pa = ffi.cast("float *", a.ctypes.data) pb = ffi.cast("float *", b.ctypes.data) C.copy(pa, pb, len(a)) # pb is C version of b, so values of b still changed print(b) return
def as_np_array_double(ffi: FFI, ptr: CffiData, size: int, shallow: bool = False) -> np.ndarray: """Convert if possible a cffi pointer to a C data array, into a numpy array of double precision floats. Args: ffi (FFI): FFI instance wrapping the native compilation module owning the native memory ptr (CffiData): cffi pointer (FFI.CData) size (int): array size shallow (bool): If true the array points directly to native data array. Defaults to False. Raises: RuntimeError: conversion is not supported Returns: np.ndarray: converted data """ res = np.frombuffer(ffi.buffer(ffi.cast('double[%d]' % (size, ), ptr))) if shallow: return res else: return res.copy()
def test_ffi_new_allocator_2(self): ffi = FFI(backend=self.Backend()) seen = [] def myalloc(size): seen.append(size) return ffi.new("char[]", b"X" * size) def myfree(raw): seen.append(raw) alloc1 = ffi.new_allocator(myalloc, myfree) alloc2 = ffi.new_allocator(alloc=myalloc, free=myfree, should_clear_after_alloc=False) p1 = alloc1("int[10]") p2 = alloc2("int[]", 10) assert seen == [40, 40] assert ffi.typeof(p1) == ffi.typeof("int[10]") assert ffi.sizeof(p1) == 40 assert ffi.typeof(p2) == ffi.typeof("int[]") assert ffi.sizeof(p2) == 40 assert p1[5] == 0 assert p2[6] == ord('X') * 0x01010101 raw1 = ffi.cast("char *", p1) raw2 = ffi.cast("char *", p2) del p1, p2 retries = 0 while len(seen) != 4: retries += 1 assert retries <= 5 import gc gc.collect() assert seen == [40, 40, raw1, raw2] assert repr(seen[2]) == "<cdata 'char[]' owning 41 bytes>" assert repr(seen[3]) == "<cdata 'char[]' owning 41 bytes>"
def as_c_double_array(ffi: FFI, data: np.ndarray, shallow: bool = False) -> OwningCffiNativeHandle: if isinstance(data, list): data = np.asfarray(data) shallow = False elif isinstance(data, xr.DataArray): data = data.values # shallow = False # really needed?? elif not isinstance(data, np.ndarray): raise TypeError( "Conversion to a c array of double requires list or np array as input" ) if len(data.shape) > 1: data = data.squeeze() shallow = False if len(data.shape) > 1: raise TypeError( "Conversion to a double* array: input data must be of dimension one, and the python array cannot be squeezed to dimension one" ) if not (data.dtype == np.float or data.dtype == np.float64 or data.dtype == float or data.dtype == np.double or data.dtype == np.float_): # https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations # TODO: is this wise to override the shallow parameter shallow = False data = data.astype(np.float64) if shallow and data.flags['C_CONTIGUOUS']: native_d = ffi.cast("double *", data.ctypes.data) else: native_d = new_double_array(ffi, data.shape[0]) if not data.flags['C_CONTIGUOUS']: data_c = np.ascontiguousarray(data) else: data_c = data ffi.buffer(native_d)[:] = data_c return OwningCffiNativeHandle(native_d)
def create_coordinate_map(o): """Return a compiled UFC coordinate_mapping object""" try: # Create a compiled coordinate map from an object with the # ufl_mesh attribute cmap_ptr = jit.ffc_jit(o.ufl_domain()) except AttributeError: # FIXME: It would be good to avoid the type check, but ffc_jit # supports other objects so we could get, e.g., a compiled # finite element if isinstance(o, ufl.domain.Mesh): cmap_ptr = jit.ffc_jit(o) else: raise TypeError( "Cannot create coordinate map from an object of type: {}".format(type(o))) except Exception: print("Failed to create compiled coordinate map") raise # Wrap compiled coordinate map and return ffi = FFI() ufc_cmap = fem.dofmap.make_ufc_coordinate_mapping(ffi.cast("uintptr_t", cmap_ptr)) return cpp.fem.CoordinateMapping(ufc_cmap)
def check(self, source, expected_ofs_y, expected_align, expected_size): # NOTE: 'expected_*' is the numbers expected from GCC. # The numbers expected from MSVC are not explicitly written # in this file, and will just be taken from the compiler. ffi = FFI() ffi.cdef("struct s1 { %s };" % source) ctype = ffi.typeof("struct s1") # verify the information with gcc ffi1 = FFI() ffi1.cdef(""" static const int Gofs_y, Galign, Gsize; struct s1 *try_with_value(int fieldnum, long long value); """) fnames = [ name for name, cfield in ctype.fields if name and cfield.bitsize > 0 ] setters = [ 'case %d: s.%s = value; break;' % iname for iname in enumerate(fnames) ] lib = ffi1.verify(""" struct s1 { %s }; struct sa { char a; struct s1 b; }; #define Gofs_y offsetof(struct s1, y) #define Galign offsetof(struct sa, b) #define Gsize sizeof(struct s1) struct s1 *try_with_value(int fieldnum, long long value) { static struct s1 s; memset(&s, 0, sizeof(s)); switch (fieldnum) { %s } return &s; } """ % (source, ' '.join(setters))) if sys.platform == 'win32': expected_ofs_y = lib.Gofs_y expected_align = lib.Galign expected_size = lib.Gsize else: assert (lib.Gofs_y, lib.Galign, lib.Gsize) == (expected_ofs_y, expected_align, expected_size) # the real test follows assert ffi.offsetof("struct s1", "y") == expected_ofs_y assert ffi.alignof("struct s1") == expected_align assert ffi.sizeof("struct s1") == expected_size # compare the actual storage of the two for name, cfield in ctype.fields: if cfield.bitsize < 0 or not name: continue if int(ffi.cast(cfield.type, -1)) == -1: # signed min_value = -(1 << (cfield.bitsize - 1)) max_value = (1 << (cfield.bitsize - 1)) - 1 else: min_value = 0 max_value = (1 << cfield.bitsize) - 1 for t in [ 1, 2, 4, 8, 16, 128, 2813, 89728, 981729, -1, -2, -4, -8, -16, -128, -2813, -89728, -981729 ]: if min_value <= t <= max_value: self._fieldcheck(ffi, lib, fnames, name, t)
lib = ffi.dlopen('./distributions.dll') elif os.path.exists('./libdistributions.so'): lib = ffi.dlopen('./libdistributions.so') else: raise RuntimeError('Required DLL/so file was not found.') ffi.cdef(""" double random_gauss_zig(void *brng_state); """) x = Xoroshiro128() xffi = x.cffi brng = xffi.brng random_gauss_zig = lib.random_gauss_zig def normals(n, brng): out = np.empty(n) for i in range(n): out[i] = random_gauss_zig(brng) return out normalsj = nb.jit(normals, nopython=True) # Numba requires a memory address for void * # Can also get address from x.ctypes.brng.value brng_address = int(ffi.cast('uintptr_t', brng)) norm = normalsj(1000, brng_address)
elif os.path.exists('./libdistributions.so'): lib = ffi.dlopen('./libdistributions.so') else: raise RuntimeError('Required DLL/so file was not found.') ffi.cdef(""" double random_standard_normal(void *bitgen_state); """) x = PCG64() xffi = x.cffi bit_generator = xffi.bit_generator random_standard_normal = lib.random_standard_normal def normals(n, bit_generator): out = np.empty(n) for i in range(n): out[i] = random_standard_normal(bit_generator) return out normalsj = nb.jit(normals, nopython=True) # Numba requires a memory address for void * # Can also get address from x.ctypes.bit_generator.value bit_generator_address = int(ffi.cast('uintptr_t', bit_generator)) norm = normalsj(1000, bit_generator_address) print(norm[:12])
class _PcapFfi(object): """ This class represents the low-level interface to the libpcap library. It encapsulates all the cffi calls and C/Python conversions, as well as translation of errors and error codes to PcapExceptions. It is intended to be used as a singleton class through the PcapDumper and PcapLiveDevice classes, below. """ _instance = None __slots__ = ['_ffi', '_libpcap', '_interfaces', '_windows'] def __init__(self): """ Assumption: this class is instantiated once in the main thread before any other threads have a chance to try instantiating it. """ if _PcapFfi._instance: raise Exception("Can't initialize this class more than once!") _PcapFfi._instance = self self._windows = False self._ffi = FFI() self._ffi.cdef(cc, override=True) self._ffi.cdef(cc_packed, override=True, packed=1) if sys.platform == 'darwin': libname = 'libpcap.dylib' elif "win" in sys.platform[:3]: libname = 'wpcap.dll' # winpcap self._windows = True else: # if not macOS (darwin) or windows, assume we're on # some unix-based system and try for libpcap.so libname = 'libpcap.so' try: self._libpcap = self._ffi.dlopen(libname) except Exception as e: raise PcapException("Error opening libpcap: {}".format(e)) self._interfaces = [] self.discoverdevs() @staticmethod def instance(): if not _PcapFfi._instance: _PcapFfi._instance = _PcapFfi() return _PcapFfi._instance @property def version(self): return self._ffi.string(self._libpcap.pcap_lib_version()) def discoverdevs(self): """ Find all the pcap-eligible devices on the local system. """ if len(self._interfaces): raise PcapException("Device discovery should only be done once.") ppintf = self._ffi.new("pcap_if_t * *") errbuf = self._ffi.new("char []", 128) rv = self._libpcap.pcap_findalldevs(ppintf, errbuf) if rv: raise PcapException("pcap_findalldevs returned failure: {}".format( self._ffi.string(errbuf))) pintf = ppintf[0] tmp = pintf pindex = 0 while tmp != self._ffi.NULL: xname = self._ffi.string( tmp.name) # "internal name"; still stored as bytes object xname = xname.decode('ascii', 'ignore') if self._windows: ext_name = "port{}".format(pindex) else: ext_name = xname pindex += 1 if tmp.description == self._ffi.NULL: xdesc = ext_name else: xdesc = self._ffi.string(tmp.description) xdesc = xdesc.decode('ascii', 'ignore') # NB: on WinPcap, only loop flag is set isloop = (tmp.flags & 0x1) == 0x1 isup = (tmp.flags & 0x2) == 0x2 isrunning = (tmp.flags & 0x4) == 0x4 xif = PcapInterface(ext_name, xname, xdesc, isloop, isup, isrunning) self._interfaces.append(xif) tmp = tmp.next self._libpcap.pcap_freealldevs(pintf) @property def devices(self): return self._interfaces @property def lib(self): return self._libpcap @property def ffi(self): return self._ffi def _process_packet(self, xdev, header, packet, nroots): # MPLS header mpls = self._ffi.new("union mpls *") # IP header iph = self._ffi.new("struct nfstream_iphdr *") # IPv6 header iph6 = self._ffi.new("struct nfstream_ipv6hdr *") # lengths and offsets eth_offset = 0 radio_len = 0 fc = 0 type = 0 wifi_len = 0 pyld_eth_len = 0 check = 0 ip_offset = 0 ip_len = 0 frag_off = 0 vlan_id = 0 proto = 0 time = 0 time = (header.tv_sec * TICK_RESOLUTION) + (header.tv_usec / (1000000 / TICK_RESOLUTION)) datalink_type = self._libpcap.pcap_datalink(xdev) datalink_check = True while datalink_check: datalink_check = False if Dlt(datalink_type) == Dlt.DLT_NULL: tmp_dlt_null = self._ffi.cast('struct pp_32 *', packet + eth_offset) if int(ntohs(tmp_dlt_null.value)) == 2: type = 0x0800 else: type = 0x86dd ip_offset = 4 + eth_offset elif Dlt( datalink_type ) == Dlt.DLT_PPP_SERIAL: # Cisco PPP in HDLC - like framing - 50 chdlc = self._ffi.cast('struct nfstream_chdlc *', packet + eth_offset) ip_offset = self._ffi.sizeof( 'struct nfstream_chdlc') # CHDLC_OFF = 4 type = ntohs(chdlc.proto_code) elif (Dlt(datalink_type) == Dlt.DLT_C_HDLC) or ( Dlt(datalink_type) == Dlt.DLT_PPP): # Cisco PPP - 9 or 104 chdlc = self._ffi.cast('struct nfstream_chdlc *', packet + eth_offset) # CHDLC_OFF = 4 ip_offset = self._ffi.sizeof( 'struct nfstream_chdlc') # CHDLC_OFF = 4 type = ntohs(chdlc.proto_code) elif Dlt(datalink_type ) == Dlt.DLT_EN10MB: # IEEE 802.3 Ethernet - 1 */ ethernet = self._ffi.cast('struct nfstream_ethhdr *', packet + eth_offset) ip_offset = self._ffi.sizeof( 'struct nfstream_ethhdr') + eth_offset check = ntohs(ethernet.h_proto) if check <= 1500: pyld_eth_len = check elif check >= 1536: type = check if pyld_eth_len != 0: llc = self._ffi.cast('struct nfstream_llc_header_snap *', packet + ip_offset) if (llc.dsap == 0xaa) or ( llc.ssap == 0xaa): # check for LLC layer with SNAP ext type = llc.snap.proto_ID ip_offset += 8 elif (llc.dsap == 0x42) or (llc.ssap == 0x42): # No SNAP ext return None elif Dlt(datalink_type ) == Dlt.DLT_LINUX_SLL: # Linux Cooked Capture - 113 type = (packet[eth_offset + 14] << 8) + packet[eth_offset + 15] ip_offset = 16 + eth_offset elif Dlt( datalink_type ) == Dlt.DLT_IEEE802_11_RADIO: # Radiotap link - layer - 127 radiotap = self._ffi.cast('struct nfstream_radiotap_header *', packet + eth_offset) radio_len = radiotap.len if (radiotap.flags & 0x50) == 0x50: # Check Bad FCS presence return None # Calculate 802.11 header length(variable) wifi = self._ffi.cast('struct nfstream_wifi_header *', packet + (eth_offset + radio_len)) fc = wifi.fc # Check wifi data presence if fcf_type(fc) == 0x2: if (fcf_to_ds(fc) and fcf_from_ds(fc) == 0x0) or ( fcf_to_ds(fc) == 0x0 and fcf_from_ds(fc)): wifi_len = 26 # + 4 byte fcs else: pass # Check ether_type from LLC llc = self._ffi.cast( 'struct nfstream_llc_header_snap *', packet + (eth_offset + wifi_len + radio_len)) if llc.dsap == 0xaa: type = ntohs(llc.snap.proto_ID) # Set IP header offset ip_offset = wifi_len + radio_len + self._ffi.sizeof( 'struct nfstream_llc_header_snap') + eth_offset elif Dlt(datalink_type) == Dlt.DLT_RAW: ip_offset = 0 eth_offset = 0 else: return None ether_type_check = True while ether_type_check: ether_type_check = False if type == 0x8100: vlan_id = ((packet[ip_offset] << 8) + packet[ip_offset + 1]) & 0xFFF type = (packet[ip_offset + 2] << 8) + packet[ip_offset + 3] ip_offset += 4 while type == 0x8100 and ip_offset < header.caplen: # Double tagging for 802.1Q vlan_id = ((packet[ip_offset] << 8) + packet[ip_offset + 1]) & 0xFFF type = ( packet[ip_offset + 2] << 8) + packet[ip_offset + 3] ip_offset += 4 ether_type_check = True elif (type == 0x8847) or (type == 0x8848): tmp_u32 = self._ffi.cast('struct pp_32 *', packet + ip_offset) mpls.u32 = int(ntohl(tmp_u32.value)) type = 0x0800 ip_offset += 4 while not mpls.mpls.s: tmp_u32_loop = self._ffi.cast('struct pp_32 *', packet + ip_offset) mpls.u32 = int(ntohl(tmp_u32_loop.value)) ip_offset += 4 ether_type_check = True elif type == 0x8864: type = 0x0800 ip_offset += 8 ether_type_check = True else: pass ip_check = True while ip_check: ip_check = False # Check and set IP header size and total packet length iph = self._ffi.cast('struct nfstream_iphdr *', packet + ip_offset) # Just work on Ethernet packets that contain IP if (type == 0x0800) and (header.caplen >= ip_offset): frag_off = ntohs(iph.frag_off) if header.caplen < header.len: pass if iph.version == 4: ip_len = iph.ihl * 4 iph6 = self._ffi.NULL if iph.protocol == 41: # IPPROTO_IPV6 ip_offset += ip_len ip_check = True if (frag_off & 0x1FFF) != 0: return None elif iph.version == 6: iph6 = self._ffi.cast('struct nfstream_ipv6hdr *', packet + ip_offset) ip_len = self._ffi.sizeof('struct nfstream_ipv6hdr') if iph6.ip6_hdr.ip6_un1_nxt == 60: # IPv6 destination option options = self._ffi.cast('uint8_t *', packet + (ip_offset + ip_len)) ip_len += 8 * (options[1] + 1) iph = self._ffi.NULL else: return None l4_offset = 0 ipsize = 0 src_addr = 0 dst_addr = 0 l4_packet_len = 0 version = 0 nfstream_hash = 0 if iph6 == self._ffi.NULL: version = 4 l4_packet_len = ntohs(iph.tot_len) - (iph.ihl * 4) ipsize = header.caplen - ip_offset proto = iph.protocol src_addr = ntohl(iph.saddr) dst_addr = ntohl(iph.daddr) nfstream_hash += iph.saddr + iph.daddr + proto + vlan_id else: version = 6 src_addr = ntohl(iph6.ip6_src.u6_addr.u6_addr32[0]) << 96 | ntohl( iph6.ip6_src.u6_addr.u6_addr32[1]) << 64 | ntohl( iph6.ip6_src.u6_addr.u6_addr32[2]) << 32 | ntohl( iph6.ip6_src.u6_addr.u6_addr32[3]) dst_addr = ntohl(iph6.ip6_dst.u6_addr.u6_addr32[0]) << 96 | ntohl( iph6.ip6_dst.u6_addr.u6_addr32[1]) << 64 | ntohl( iph6.ip6_dst.u6_addr.u6_addr32[2]) << 32 | ntohl( iph6.ip6_dst.u6_addr.u6_addr32[3]) proto = iph6.ip6_hdr.ip6_un1_nxt if proto == 60: options = self._ffi.cast( 'uint8_t *', iph6) + self._ffi.sizeof('struct nfstream_ipv6hdr') proto = options[0] l4_packet_len = ntohs(iph6.ip6_hdr.ip6_un1_plen) nfstream_hash += ( iph6.ip6_src.u6_addr.u6_addr32[2] + iph6.ip6_src.u6_addr.u6_addr32[3]) + ( iph6.ip6_dst.u6_addr.u6_addr32[2] + iph6.ip6_dst.u6_addr.u6_addr32[3]) + proto + vlan_id if version == 4: if ipsize < 20: return None if ((iph.ihl * 4) > ipsize) or (ipsize < ntohs(iph.tot_len)): return None l4_offset = iph.ihl * 4 l3 = self._ffi.cast('uint8_t *', iph) else: l4_offset = self._ffi.sizeof('struct nfstream_ipv6hdr') l3 = self._ffi.cast('uint8_t *', iph6) l4 = self._ffi.cast('uint8_t *', l3) + l4_offset syn, cwr, ece, urg, ack, psh, rst, fin = 0, 0, 0, 0, 0, 0, 0, 0 if (proto == 6 ) and l4_packet_len >= self._ffi.sizeof('struct nfstream_tcphdr'): tcph = self._ffi.cast('struct nfstream_tcphdr *', l4) sport = int(ntohs(tcph.source)) dport = int(ntohs(tcph.dest)) syn = int(tcph.syn) cwr = int(tcph.cwr) ece = int(tcph.ece) urg = int(tcph.urg) ack = int(tcph.ack) psh = int(tcph.psh) rst = int(tcph.rst) fin = int(tcph.fin) elif (proto == 17) and l4_packet_len >= self._ffi.sizeof( 'struct nfstream_udphdr'): udph = self._ffi.cast('struct nfstream_udphdr *', l4) sport = int(ntohs(udph.source)) dport = int(ntohs(udph.dest)) else: sport = 0 dport = 0 nfstream_hash += sport + dport if version == 4: return NFPacket(time=int(time), capture_length=header.caplen, length=header.len, nfhash=nfstream_hash, ip_src=src_addr, ip_dst=dst_addr, src_port=sport, dst_port=dport, protocol=proto, vlan_id=vlan_id, version=version, tcpflags=tcpflags(syn=syn, cwr=cwr, ece=ece, urg=urg, ack=ack, psh=psh, rst=rst, fin=fin), raw=bytes(xffi.buffer(iph, ipsize)), root_idx=nfstream_hash % nroots) else: return NFPacket(time=int(time), capture_length=header.caplen, length=header.len, nfhash=nfstream_hash, ip_src=src_addr, ip_dst=dst_addr, src_port=sport, dst_port=dport, protocol=proto, vlan_id=vlan_id, version=version, tcpflags=tcpflags(syn=syn, cwr=cwr, ece=ece, urg=urg, ack=ack, psh=psh, rst=rst, fin=fin), raw=bytes(xffi.buffer(iph6, header.len - ip_offset)), root_idx=nfstream_hash % nroots) def _recv_packet(self, xdev, nroots=1): phdr = self._ffi.new("struct pcap_pkthdr **") pdata = self._ffi.new("unsigned char **") rv = self._libpcap.pcap_next_ex(xdev, phdr, pdata) if rv == 1: return self._process_packet(xdev, phdr[0], pdata[0], nroots) elif rv == 0: # timeout; nothing to return return 0 elif rv == -1: # error on receive; raise an exception s = self._ffi.string(self._libpcap.pcap_geterr(xdev)) raise PcapException("Error receiving packet: {}".format(s)) elif rv == -2: # reading from savefile, but none left return -2
#!/usr/bin/env python from cffi import FFI import numpy as np # Array data for a 4x3 RGB (black) image. dtype = [("r", np.uint8), ("g", np.uint8), ("b", np.uint8)] array = np.zeros((3,4), dtype=dtype) # declare data & function for cffi ffi = FFI() data = ffi.cast("unsigned char*", array.__array_interface__["data"][0]) length = ffi.cast("unsigned int", array.size) ffi.cdef("void greenify(unsigned char* data, unsigned int length);") # open the C lib and call a C function libgreen = ffi.dlopen("./libgreen.so") libgreen.greenify(data, length) # the array has been modified. print array
class LibWwqParseCFFI(LibWwqLyParseBase): def __init__(self): super(LibWwqParseCFFI, self).__init__() from cffi import FFI self.ffi = FFI() self.lib = self.ffi.dlopen(self.lib_path) self.ffi.cdef(""" char * get_uuid(); char * get_name(); int parse(char * c,int length,char **result,int *result_length); int free_str(char * c); void* atomic_int64_init(); int atomic_int64_destroy(void* ptr); int64_t atomic_int64_get(void* ptr); int64_t atomic_int64_set(void* ptr, int64_t val); int64_t atomic_int64_add(void* ptr, int64_t val); int64_t atomic_int64_sub(void* ptr, int64_t val); int64_t atomic_int64_and(void* ptr, int64_t val); int64_t atomic_int64_or(void* ptr, int64_t val); int64_t atomic_int64_xor(void* ptr, int64_t val); typedef union epoll_data { void* ptr; int fd; uint32_t u32; uint64_t u64; uintptr_t sock; /* Windows specific */ void* hnd; /* Windows specific */ } epoll_data_t; typedef struct { uint32_t events; /* Epoll events and flags */ epoll_data_t data; /* User data variable */ } epoll_event ; void* epoll_create(int size); void* epoll_create1(int flags); int epoll_close(void* ephnd); int epoll_ctl(void* ephnd, int op, uintptr_t sock, epoll_event* event); int epoll_wait(void* ephnd, epoll_event* events, int maxevents, int timeout); """) self.lib.__class__.__repr__ = lambda s: "<%s object at 0x%016X>" % (s.__class__.__name__, id(s)) logging.debug("successful load lib %s" % self.lib) weakref.finalize(self, lambda: logging.debug("%s released" % self.lib) if self.ffi.dlclose(self.lib) or 1 else None) def get_uuid(self) -> bytes: return self.ffi.string(self.lib.get_uuid()) def get_name(self) -> bytes: return self.ffi.string(self.lib.get_name()) def lib_parse(self, byte_str: bytes) -> bytes: length = self.ffi.cast("int", len(byte_str)) result_length = self.ffi.new("int *") result_p = self.ffi.new("char **") # p = self.ffi.new("char []", byte_str) p = self.ffi.from_buffer(byte_str) self.lib.parse(p, length, result_p, result_length) result = self.ffi.unpack(result_p[0], result_length[0]) self.lib.free_str(result_p[0]) return result
{ int id; double* xk; double h; double theta; double gamma; double g; double kappa; unsigned int f_eval; unsigned int nabla_eval; } data; ''') data_struct = ffi.new('data*') data_struct.id = -1 # to avoid freeing the data in the destructor data_struct.xk = ffi.cast('double *', xk.ctypes.data) data_struct.h = h data_struct.theta = theta data_struct.gamma = gamma data_struct.g = g data_struct.kappa = kappa D = ffi.dlopen(SN._numerics.__file__) D.set_cstruct(mcp.get_env_as_long(), ffi.cast('void*', data_struct)) mcp.set_compute_F_and_nabla_F_as_C_functions('ZhuravlevIvanov.so', 'compute_Fmcp', 'compute_nabla_Fmcp')
def test_explicitly_defined_char16_t(self): ffi = FFI() ffi.cdef("typedef uint16_t char16_t;") x = ffi.cast("char16_t", 1234) assert ffi.typeof(x) is ffi.typeof("uint16_t")
class H264Decoder: def __init_ffi(self): self.ffi = FFI() self.ffi.cdef(''' // AVCODEC enum PixelFormat { PIX_FMT_YUV420P, PIX_FMT_RGB24, ... }; void avcodec_register_all(void); struct AVPacket { ...; uint8_t *data; int size; ...; }; void av_init_packet(struct AVPacket *pkt); enum AVCodecID { AV_CODEC_ID_H264, ... }; struct AVCodec *avcodec_find_decoder(enum AVCodecID id); struct AVCodecContext *avcodec_alloc_context3(struct AVCodec *codec); int avcodec_open2(struct AVCodecContext *avctx, struct AVCodec *codec, struct AVDictionary **options); struct AVFrame { uint8_t *data[8]; int linesize[8]; ...; int key_frame; ...; }; struct AVFrame *avcodec_alloc_frame(void); int avcodec_decode_video2(struct AVCodecContext *avctx, struct AVFrame *picture, int *got_picture_ptr, struct AVPacket *avpkt); int avcodec_close(struct AVCodecContext *avctx); void av_free(void *ptr); int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height); int avpicture_fill(struct AVPicture *picture, uint8_t *ptr, int pix_fmt, int width, int height); // SWSCALE #define SWS_BILINEAR ... #define SWS_FAST_BILINEAR ... struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat, int dstW, int dstH, enum PixelFormat dstFormat, int flags, struct SwsFilter *srcFilter, struct SwsFilter *dstFilter, const double *param); int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[]); void sws_freeContext(struct SwsContext *c); ''') self.ns = self.ffi.verify(source=''' #include <libavcodec/avcodec.h> #include <libswscale/swscale.h> ''', libraries=['avcodec', 'swscale']) def __init_avcodec(self): self.ns.avcodec_register_all() self.av_packet = self.ffi.new('struct AVPacket *') self.ns.av_init_packet(self.av_packet) self.codec = self.ns.avcodec_find_decoder(self.ns.AV_CODEC_ID_H264) if not self.codec: raise Exception('avcodec_alloc_context3') self.context = self.ns.avcodec_alloc_context3(self.codec) if not self.context: raise Exception('avcodec_alloc_context3') if self.ns.avcodec_open2(self.context, self.codec, self.ffi.NULL) < 0: raise Exception('avcodec_open2') self.frame = self.ns.avcodec_alloc_frame() if not self.frame: raise Exception('avcodec_alloc_frame') self.got_frame = self.ffi.new('int *') self.out_frame = self.ns.avcodec_alloc_frame() def __init__(self): self.out_buffer, self.sws_context = None, None self.__init_ffi() self.__init_avcodec() self.update_dimensions() def close(self): self.ns.sws_freeContext(self.sws_context) self.ns.av_free(self.out_frame) self.ns.avcodec_close(self.context) self.ns.av_free(self.context) self.ns.av_free(self.frame) def update_dimensions(self): if self.sws_context is not None: self.ns.sws_freeContext(self.sws_context) self.sws_context = self.ns.sws_getContext( constants.WII_VIDEO_WIDTH, constants.WII_VIDEO_HEIGHT, self.ns.PIX_FMT_YUV420P, constants.WII_VIDEO_WIDTH, constants.WII_VIDEO_HEIGHT, self.ns.PIX_FMT_RGB24, self.ns.SWS_FAST_BILINEAR, self.ffi.NULL, self.ffi.NULL, self.ffi.NULL) bytes_req = self.ns.avpicture_get_size(self.ns.PIX_FMT_RGB24, constants.WII_VIDEO_WIDTH, constants.WII_VIDEO_HEIGHT) self.out_buffer = self.ffi.new('uint8_t [%i]' % bytes_req) self.ns.avpicture_fill( self.ffi.cast('struct AVPicture *', self.out_frame), self.out_buffer, self.ns.PIX_FMT_RGB24, constants.WII_VIDEO_WIDTH, constants.WII_VIDEO_HEIGHT) def get_image_buffer(self, encoded_nalu): in_data = self.ffi.new('uint8_t []', encoded_nalu) self.av_packet.data = in_data self.av_packet.size = len(encoded_nalu) length = self.ns.avcodec_decode_video2(self.context, self.frame, self.got_frame, self.av_packet) if length < 0: raise Exception('avcodec_decode_video2') elif length != self.av_packet.size: raise Exception('expected to decode a single complete frame') elif self.got_frame[0]: # print 'keyframe:', s.frame.key_frame # convert from YUV to RGB self.ns.sws_scale(self.sws_context, self.frame.data, self.frame.linesize, 0, constants.WII_VIDEO_HEIGHT, self.out_frame.data, self.out_frame.linesize) image_buffer = \ self.ffi.buffer(self.out_frame.data[0], self.out_frame.linesize[0] * constants.WII_VIDEO_HEIGHT) return image_buffer
import time import numpy as np from cffi import FFI from scipy.spatial.distance import cdist from _cityblock.lib import cbdm nsamples = 12000 nfeat = 50 x = np.random.random([nsamples, nfeat]) r = np.empty((nsamples, nsamples)) ffi = FFI() x_c = ffi.cast('double *', x.ctypes.data) r_c = ffi.cast('double *', r.ctypes.data) start = time.time() cbdm(x_c, x_c, r_c, nsamples, nfeat) print(f'C : {time.time() - start:.2f} seconds') start = time.time() r_cdist = cdist(x, x, 'cityblock') print(f'cdist : {time.time() - start:.2f} seconds') # check the result by comparing to cdist print(f'\ndiff : {(r - r_cdist).max():.2e}')
# reply = C.uct_notify_play(engine, board, move, null_cstr) # ret = C.board_play(board, move) # C.board_print_stderr(board) move = ffi.new("struct move*") C = None try: import os print os.path.exists(os.path.join(os.getcwd(), "libpachi.so")) C = ffi.dlopen("libpachi.so") # loads the entire C namespace except Exception as e: print e print("trying osx") if C == None: C = ffi.dlopen("libpachi.dylib") # loads the entire C namespace null_cstr = ffi.cast("char*", 0) board = C.board_init(null_cstr) size = 9 C.board_resize(board, size) C.board_clear(board) engine = C.engine_uct_init(null_cstr, board) t_black = C.time_info_init() t_white = C.time_info_init() class myHandler(BaseHTTPRequestHandler): def do_GET(self): self.do_POST() def do_POST(self): self.log_message("do_POST %s" % self.path) self.send_response(200) self.send_header('Content-type','application/json')
class cv2pynq(): MAX_WIDTH = 1920 MAX_HEIGHT = 1080 def __init__(self, load_overlay=True): self.bitstream_name = None self.bitstream_name = "cv2pynq03.bit" self.bitstream_path = os.path.join(CV2PYNQ_BIT_DIR, self.bitstream_name) self.ol = Overlay(self.bitstream_path) self.ol.download() self.ol.reset() self.xlnk = Xlnk() self.partitions = 10 #split the cma into partitions for pipelined transfer self.cmaPartitionLen = self.MAX_HEIGHT * self.MAX_WIDTH / self.partitions self.listOfcma = [ self.xlnk.cma_array(shape=(int(self.MAX_HEIGHT / self.partitions), self.MAX_WIDTH), dtype=np.uint8) for i in range(self.partitions) ] self.img_filters = self.ol.image_filters self.dmaOut = self.img_filters.axi_dma_0.sendchannel self.dmaIn = self.img_filters.axi_dma_0.recvchannel self.dmaOut.stop() self.dmaIn.stop() self.dmaIn.start() self.dmaOut.start() self.filter2DType = -1 # filter types: SobelX=0, SobelY=1, ScharrX=2, ScharrY=3, Laplacian1=4, Laplacian3=5 self.filter2D_5Type = -1 # filter types: SobelX=0, SobelY=1, Laplacian5=4 self.filter2DfType = -1 # filter types: blur=0, GaussianBlur=1 self.ffi = FFI() self.f2D = self.img_filters.filter2D_hls_0 self.f2D.reset() self.f2D_5 = self.img_filters.filter2D_hls_5_0 self.f2D_5.reset() self.f2D_f = self.img_filters.filter2D_f_0 self.f2D_f.reset() self.erodeIP = self.img_filters.erode_hls_0 self.erodeIP.reset() self.dilateIP = self.img_filters.dilate_hls_0 self.dilateIP.reset() self.cmaBuffer_0 = self.xlnk.cma_array(shape=(self.MAX_HEIGHT, self.MAX_WIDTH), dtype=np.uint8) self.cmaBuffer0 = self.cmaBuffer_0.view(self.ContiguousArrayCv2pynq) self.cmaBuffer0.init(self.cmaBuffer_0) self.cmaBuffer_1 = self.xlnk.cma_array(shape=(self.MAX_HEIGHT, self.MAX_WIDTH), dtype=np.uint8) self.cmaBuffer1 = self.cmaBuffer_1.view(self.ContiguousArrayCv2pynq) self.cmaBuffer1.init(self.cmaBuffer_1) self.cmaBuffer_2 = self.xlnk.cma_array( shape=(self.MAX_HEIGHT * 4, self.MAX_WIDTH), dtype=np.uint8) # *4 for CornerHarris return self.cmaBuffer2 = self.cmaBuffer_2.view(self.ContiguousArrayCv2pynq) self.cmaBuffer2.init(self.cmaBuffer_2) self.CannyIP = self.img_filters.canny_edge_0 self.CannyIP.reset() #self.cornerHarrisIP = self.img_filters.CornerHarris_hls_0 #self.cornerHarrisIP.reset() def close(self): #self.dmaOut.stop() #self.dmaIn.stop() self.cmaBuffer_0.close() self.cmaBuffer_1.close() self.cmaBuffer_2.close() for cma in self.listOfcma: cma.close() def Sobel(self, src, ddepth, dx, dy, dst, ksize): if (ksize == 3): self.f2D.rows = src.shape[0] self.f2D.columns = src.shape[1] self.f2D.channels = 1 if (dx == 1) and (dy == 0): if self.filter2DType != 0: self.filter2DType = 0 self.f2D.r1 = 0x000100ff #[-1 0 1] self.f2D.r2 = 0x000200fe #[-2 0 2] self.f2D.r3 = 0x000100ff #[-1 0 1] elif (dx == 0) and (dy == 1): if self.filter2DType != 1: self.filter2DType = 1 self.f2D.r1 = 0x00fffeff #[-1 -2 -1] self.f2D.r2 = 0x00000000 #[ 0 0 0] self.f2D.r3 = 0x00010201 #[ 1 2 1] else: raise RuntimeError("Incorrect dx dy configuration") self.img_filters.select_filter(1) self.f2D.start() return self.filter2D(src, dst) else: #ksize == 5 self.f2D_5.rows = src.shape[0] self.f2D_5.columns = src.shape[1] if (dx == 1) and (dy == 0): if self.filter2D_5Type != 0: self.filter2D_5Type = 0 self.f2D_5.par_V = bytes([ \ #-1, -2, 0, 2, 1, 0xff, 0xfe, 0x00, 0x02, 0x01, \ #-4, -8, 0, 8, 4, 0xfc, 0xf8, 0x00, 0x08, 0x04, \ #-6, -12, 0, 12, 6, 0xfa, 0xf4, 0x00, 0x0c, 0x06, \ #-4, -8, 0, 8, 4, 0xfc, 0xf8, 0x00, 0x08, 0x04, \ #-1, -2, 0, 2, 1, 0xff, 0xfe, 0x00, 0x02, 0x01, \ 0,0,0]) #fill up to allign with 4 elif (dx == 0) and (dy == 1): if self.filter2D_5Type != 1: self.filter2D_5Type = 1 self.f2D_5.par_V = bytes([ \ #-1, -4, -6, -4, -1, 0xff, 0xfc, 0xfa, 0xfc, 0xff, \ #-2, -8, -12, -8, -2, 0xfe, 0xf8, 0xf4, 0xf8, 0xfe, \ # 0, 0, 0, 0, 0, 0x00, 0x00, 0x00, 0x00, 0x00, \ # 2, 8, 12, 8, 2, 0x02, 0x08, 0x0c, 0x08, 0x02, \ # 1, 4, 6, 4, 1, 0x01, 0x04, 0x06, 0x04, 0x01, \ 0,0,0]) #fill up to allign with 4 else: raise RuntimeError("Incorrect dx dy configuration") self.img_filters.select_filter(5) self.f2D_5.start() return self.filter2D(src, dst) def Scharr(self, src, ddepth, dx, dy, dst): self.f2D.rows = src.shape[0] self.f2D.columns = src.shape[1] self.f2D.channels = 1 if (dx == 1) and (dy == 0): if self.filter2DType != 2: self.filter2DType = 2 self.f2D.r1 = 0x000300fd #[-3 0 3] self.f2D.r2 = 0x000a00f6 #[-10 0 10] self.f2D.r3 = 0x000300fd #[-3 0 3] elif (dx == 0) and (dy == 1): if self.filter2DType != 3: self.filter2DType = 3 self.f2D.r1 = 0x00fdf6fd #[-3 -10 -3] self.f2D.r2 = 0x00000000 #[ 0 0 0] self.f2D.r3 = 0x00030a03 #[ 3 10 3] else: raise RuntimeError("Incorrect dx dy configuration") self.img_filters.select_filter(1) self.f2D.start() return self.filter2D(src, dst) def Laplacian(self, src, ddepth, dst, ksize): if ksize == 5: self.f2D_5.rows = src.shape[0] self.f2D_5.columns = src.shape[1] if self.filter2D_5Type != 4: self.filter2D_5Type = 4 # "Laplacian_5" self.f2D_5.par_V = bytes([ \ #2, 4, 4, 4, 2, 0x02, 0x04, 0x04, 0x04, 0x02, \ #4, 0, -8, 0, 4, 0x04, 0x00, 0xf8, 0x00, 0x04, \ #4, -8, -24, -8, 4, 0x04, 0xf8, 0xe8, 0xf8, 0x04, \ #4, 0, -8, 0, 4, 0x04, 0x00, 0xf8, 0x00, 0x04, \ #2, 4, 4, 4, 2, 0x02, 0x04, 0x04, 0x04, 0x02, \ 0,0,0]) #fill up to allign with 4 self.img_filters.select_filter(5) self.f2D_5.start() return self.filter2D(src, dst) else: #ksize 1 or 3 self.f2D.rows = src.shape[0] self.f2D.columns = src.shape[1] self.f2D.channels = 1 if ksize == 1: if (self.filter2DType != 4): self.filter2DType = 4 # "Laplacian_1" self.f2D.r1 = 0x00000100 #[ 0 1 0] self.f2D.r2 = 0x0001fc01 #[ 1 -4 1] self.f2D.r3 = 0x00000100 #[ 0 1 0] elif ksize == 3: if (self.filter2DType != 5): self.filter2DType = 5 # "Laplacian_3" self.f2D.r1 = 0x00020002 #[ 2 0 2] self.f2D.r2 = 0x0000f800 #[ 0 -8 0] self.f2D.r3 = 0x00020002 #[ 2 0 2] self.img_filters.select_filter(1) self.f2D.start() return self.filter2D(src, dst) def blur(self, src, ksize, dst): self.f2D_f.rows = src.shape[0] self.f2D_f.columns = src.shape[1] if (self.filter2DfType != 0): self.filter2DfType = 0 #blur mean = self.floatToFixed(1 / 9, cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r11 = mean self.f2D_f.r12 = mean self.f2D_f.r13 = mean self.f2D_f.r21 = mean self.f2D_f.r22 = mean self.f2D_f.r23 = mean self.f2D_f.r31 = mean self.f2D_f.r32 = mean self.f2D_f.r33 = mean self.img_filters.select_filter(2) self.f2D_f.start() return self.filter2D(src, dst) def GaussianBlur(self, src, ksize, sigmaX, sigmaY, dst): self.f2D_f.rows = src.shape[0] self.f2D_f.columns = src.shape[1] if (self.filter2DfType != 1): self.filter2DfType = 1 #GaussianBlur if (sigmaX <= 0): sigmaX = 0.3 * ((ksize[0] - 1) * 0.5 - 1) + 0.8 if (sigmaY <= 0): sigmaY = sigmaX kX = cv2.getGaussianKernel(3, sigmaX, ktype=cv2.CV_32F) #kernel X kY = cv2.getGaussianKernel(3, sigmaY, ktype=cv2.CV_32F) #kernel Y self.f2D_f.r11 = self.floatToFixed(kY[0] * kX[0], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r12 = self.floatToFixed(kY[0] * kX[1], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r13 = self.floatToFixed(kY[0] * kX[2], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r21 = self.floatToFixed(kY[1] * kX[0], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r22 = self.floatToFixed(kY[1] * kX[1], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r23 = self.floatToFixed(kY[1] * kX[2], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r31 = self.floatToFixed(kY[2] * kX[0], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r32 = self.floatToFixed(kY[2] * kX[1], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.f2D_f.r33 = self.floatToFixed(kY[2] * kX[2], cv2pynqDriverFilter2D_f.K_FP_W, cv2pynqDriverFilter2D_f.K_FP_F) self.img_filters.select_filter(2) self.f2D_f.start() return self.filter2D(src, dst) def erode(self, src, kernel, dst, iterations, mode): self.img_filters.select_filter(3) return self.erodeDilateKernel(src, kernel, dst, iterations, mode, self.erodeIP) def dilate(self, src, kernel, dst, iterations, mode): self.img_filters.select_filter(4) return self.erodeDilateKernel(src, kernel, dst, iterations, mode, self.dilateIP) def Canny(self, src, threshold1, threshold2, dst): self.img_filters.select_filter(0) self.CannyIP.rows = src.shape[0] self.CannyIP.columns = src.shape[1] self.CannyIP.threshold1 = threshold1 self.CannyIP.threshold2 = threshold2 self.CannyIP.start() if hasattr(src, 'physical_address') and hasattr( dst, 'physical_address'): self.dmaIn.transfer(dst) self.dmaOut.transfer(src) self.dmaIn.wait() return dst self.cmaBuffer1.nbytes = src.nbytes self.dmaIn.transfer(self.cmaBuffer1) if hasattr(src, 'physical_address'): self.dmaOut.transfer(src) else: self.cmaBuffer0.nbytes = src.nbytes self.copyNto(self.cmaBuffer0, src, src.nbytes) self.dmaOut.transfer(self.cmaBuffer0) self.dmaIn.wait() ret = np.ndarray(src.shape, src.dtype) self.copyNto(ret, self.cmaBuffer1, ret.nbytes) return ret def filter2D(self, src, dst): if dst is None: self.cmaBuffer1.nbytes = src.nbytes elif hasattr(src, 'physical_address') and hasattr( dst, 'physical_address'): self.dmaIn.transfer(dst) self.dmaOut.transfer(src) self.dmaIn.wait() return dst if hasattr(src, 'physical_address'): self.dmaIn.transfer(self.cmaBuffer1) self.dmaOut.transfer(src) self.dmaIn.wait() else: #pipeline the copy to contiguous memory and filter calculation in hardware if src.nbytes < 184800: #440x420 self.partitions = 1 elif src.nbytes < 180000: #600x300 self.partitions = 2 elif src.nbytes < 231200: #680x340 self.partitions = 4 else: self.partitions = 8 self.cmaBuffer1.nbytes = src.nbytes self.dmaIn.transfer(self.cmaBuffer1) chunks_len = int(src.nbytes / (self.partitions)) self.cmaBuffer0.nbytes = chunks_len self.cmaBuffer2.nbytes = chunks_len #self.copyNto(src,self.cmaBuffer0,chunks_len) self.copyNto(self.cmaBuffer0, src, chunks_len) for i in range(1, self.partitions): if i % 2 == 1: while not self.dmaOut.idle and not self.dmaOut._first_transfer: pass self.dmaOut.transfer(self.cmaBuffer0) #self.copyNtoOff(src ,self.cmaBuffer2,chunks_len, i*chunks_len, 0) self.copyNtoOff(self.cmaBuffer2, src, chunks_len, 0, i * chunks_len) else: while not self.dmaOut.idle and not self.dmaOut._first_transfer: pass self.dmaOut.transfer(self.cmaBuffer2) #self.copyNtoOff(src ,self.cmaBuffer0,chunks_len, i*chunks_len, 0) self.copyNtoOff(self.cmaBuffer0, src, chunks_len, 0, i * chunks_len) while not self.dmaOut.idle and not self.dmaOut._first_transfer: pass self.dmaOut.transfer(self.cmaBuffer2) rest = src.nbytes % self.partitions if rest > 0: #cleanup any remaining data and send it to HW #self.copyNtoOff(src ,self.cmaBuffer0,chunks_len, self.partitions*chunks_len, 0) self.copyNtoOff(self.cmaBuffer0, src, chunks_len, 0, self.partitions * chunks_len) while not self.dmaOut.idle and not self.dmaOut._first_transfer: pass self.dmaOut.transfer(self.cmaBuffer0) rest -= chunks_len self.dmaIn.wait() ret = np.ndarray(src.shape, src.dtype) self.copyNto(ret, self.cmaBuffer1, ret.nbytes) return ret def floatToFixed(self, f, total_bits, fract_bits): """convert float f to a signed fixed point with #total_bits and #frac_bits after the point""" fix = int((abs(f) * (1 << fract_bits))) if (f < 0): fix += 1 << total_bits - 1 return fix def erodeDilateKernel(self, src, kernel, dst, iterations, mode, filter): filter.mode = mode filter.rows = src.shape[0] filter.columns = src.shape[1] if hasattr(src, 'physical_address') and hasattr( dst, 'physical_address'): filter.start() if iterations > 1: self.dmaIn.transfer(self.cmaBuffer1) else: self.dmaIn.transfer(dst) self.dmaOut.transfer(src) self.dmaIn.wait() self.cmaBuffer2.nbytes = src.nbytes #buffer = self.xlnk.cma_array(src.shape, dtype=np.uint8) for i in range(2, iterations + 1): filter.start() if i % 2 == 0: self.dmaIn.transfer(self.cmaBuffer2) if i != iterations: #avoid copy after last iteration self.dmaOut.transfer(self.cmaBuffer1) else: self.dmaOut.transfer(dst) else: self.dmaIn.transfer(self.cmaBuffer1) if i != iterations: self.dmaOut.transfer(self.cmaBuffer2) else: self.dmaOut.transfer(dst) self.dmaIn.wait() return dst self.cmaBuffer0.nbytes = src.nbytes self.cmaBuffer1.nbytes = src.nbytes filter.start() self.dmaIn.transfer(self.cmaBuffer1) if hasattr(src, 'physical_address'): self.dmaOut.transfer(src) else: self.copyNto(self.cmaBuffer0, src, src.nbytes) #np.copyto(srcBuffer,src) self.dmaOut.transfer(self.cmaBuffer0) self.dmaIn.wait() self.cmaBuffer2.nbytes = src.nbytes #buffer = self.xlnk.cma_array(src.shape, dtype=np.uint8) for i in range(2, iterations + 1): filter.start() if i % 2 == 0: self.dmaIn.transfer(self.cmaBuffer2) self.dmaOut.transfer(self.cmaBuffer1) else: self.dmaIn.transfer(self.cmaBuffer1) self.dmaOut.transfer(self.cmaBuffer2) self.dmaIn.wait() ret = np.ndarray(src.shape, src.dtype) if iterations % 2 == 1: self.copyNto(ret, self.cmaBuffer1, ret.nbytes) else: self.copyNto(ret, self.cmaBuffer2, ret.nbytes) return ret '''def cornerHarris(self, src, k, dst): self.img_filters.select_filter(5) self.cornerHarrisIP.rows = src.shape[0] self.cornerHarrisIP.columns = src.shape[1] self.cornerHarrisIP.start() if hasattr(src, 'physical_address') and hasattr(dst, 'physical_address') and (dst.nbytes == src.nbytes*4): self.dmaIn.transfer(dst) self.dmaOut.transfer(src) self.dmaIn.wait() return dst self.cmaBuffer2.nbytes = src.nbytes*4 self.dmaIn.transfer(self.cmaBuffer2) if hasattr(src, 'physical_address') : self.dmaOut.transfer(src) else: self.cmaBuffer0.nbytes = src.nbytes self.copyNto(self.cmaBuffer0,src,src.nbytes) self.dmaOut.transfer(self.cmaBuffer0) self.dmaIn.wait() ret = np.ndarray(src.shape,np.float32) self.copyNto(ret,self.cmaBuffer2,ret.nbytes) return ret''' def copyNto(self, dst, src, N): dstPtr = self.ffi.cast("uint8_t *", self.ffi.from_buffer(dst)) srcPtr = self.ffi.cast("uint8_t *", self.ffi.from_buffer(src)) self.ffi.memmove(dstPtr, srcPtr, N) def copyNtoOff(self, dst, src, N, dstOffset, srcOffset): dstPtr = self.ffi.cast("uint8_t *", self.ffi.from_buffer(dst)) srcPtr = self.ffi.cast("uint8_t *", self.ffi.from_buffer(src)) dstPtr += dstOffset srcPtr += srcOffset self.ffi.memmove(dstPtr, srcPtr, N) class ContiguousArrayCv2pynq(ContiguousArray): def init(self, cmaArray): self._nbytes = cmaArray.nbytes self.physical_address = cmaArray.physical_address self.cacheable = cmaArray.cacheable # overwrite access to nbytes with own function @property def nbytes(self): return self._nbytes @nbytes.setter def nbytes(self, value): self._nbytes = value
def test_vi_C_interface(): try: from cffi import FFI cffi_is_present = True except: cffi_is_present = False return if cffi_is_present: h = 1e-5 T = 1.0 t = 0.0 theta = 1.0 gamma = 1.0 g = 9.81 kappa = 0.4 xk = np.array((1., 10.)) ffi = FFI() ffi.cdef('void set_cstruct(uintptr_t p_env, void* p_struct);') ffi.cdef('''typedef struct { int id; double* xk; double h; double theta; double gamma; double g; double kappa; unsigned int f_eval; unsigned int nabla_eval; } data; ''') data_struct = ffi.new('data*') data_struct.id = -1 # to avoid freeing the data in the destructor data_struct.xk = ffi.cast('double *', xk.ctypes.data) data_struct.h = h data_struct.theta = theta data_struct.gamma = gamma data_struct.g = g data_struct.kappa = kappa vi = SN.VI(2) import siconos D = ffi.dlopen(siconos.__path__[0] + '/_numerics.so') D.set_cstruct(vi.get_env_as_long(), ffi.cast('void*', data_struct)) vi.set_compute_F_and_nabla_F_as_C_functions('ZhuravlevIvanov.so', 'compute_F', 'compute_nabla_F') lambda_ = np.zeros((2, )) xkp1 = np.zeros((2, )) SO = SN.SolverOptions(vi, SN.SICONOS_VI_BOX_QI) lb = np.array((-1.0, -1.0)) ub = np.array((1.0, 1.0)) vi.set_box_constraints(lb, ub) N = int(T / h + 10) print(N) SO.dparam[0] = 1e-24 SO.iparam[0] = 100 SO.iparam[2] = 1 SO.iparam[3] = 0 SO.iparam[4] = 5 signs = np.empty((N, 2)) sol = np.empty((N, 2)) sol[0, :] = xk k = 0 #SN.numerics_set_verbose(3) while t <= T: k += 1 info = SN.variationalInequality_box_newton_QiLSA( vi, lambda_, xkp1, SO) #print('iter {:} ; solver iter = {:} ; prec = {:}'.format(k, SO.iparam[1], SO.dparam[1])) if info > 0: print(lambda_) # vi_function(2, signs[k-1, :], xkp1) lambda_[0] = -np.sign(xkp1[0]) lambda_[1] = -np.sign(xkp1[1]) if np.abs(xk[0]) < 1e-10: lambda_[0] = 0.01 if np.abs(xk[1]) < 1e-10: lambda_[1] = 0.01 print('ok lambda') print(lambda_) info = SN.variationalInequality_box_newton_QiLSA( vi, lambda_, xkp1, SO) print('iter {:} ; solver iter = {:} ; prec = {:}'.format( k, SO.iparam[1], SO.dparam[1])) if info > 0: print('VI solver failed ! info = {:}'.format(info)) print(xk) print(lambda_) print(xkp1) kaboom() # else: # print('iter {:} ; solver iter = {:} ; prec = {:}'.format(k, SO.iparam[1], SO.dparam[1])) # vi_function(2, lambda_, xkp1) sol[k, 0:2] = xkp1 np.copyto(xk, xkp1, casting='no') signs[k, 0:2] = lambda_ t = k * h
def runKernel(opt): ffi = FFI() # create the FFI obj boHandle = xclAllocBO(opt.handle, opt.DATA_SIZE, xclBOKind.XCL_BO_DEVICE_RAM, opt.first_mem) bo1 = xclMapBO(opt.handle, boHandle, True) read_fp = ffi.cast("FILE *", bo1) if xclSyncBO(opt.handle, boHandle, xclBOSyncDirection.XCL_BO_SYNC_BO_TO_DEVICE, opt.DATA_SIZE, 0): return 1 p = xclBOProperties() bodevAddr = p.paddr if not (xclGetBOProperties(opt.handle, boHandle, p)) else -1 if bodevAddr is -1: return 1 # Allocate the exec_bo execHandle = xclAllocBO(opt.handle, opt.DATA_SIZE, xclBOKind.XCL_BO_SHARED_VIRTUAL, (1 << 31)) execData = xclMapBO(opt.handle, execHandle, True) # returns mmap() c_f = ffi.cast("FILE *", execData) if execData is ffi.NULL: print("execData is NULL") print("Construct the exe buf cmd to configure FPGA") ecmd = ert_configure_cmd() ecmd.m_uert.m_cmd_struct.state = 1 # ERT_CMD_STATE_NEW ecmd.m_uert.m_cmd_struct.opcode = 2 # ERT_CONFIGURE ecmd.slot_size = opt.DATA_SIZE ecmd.num_cus = 1 ecmd.cu_shift = 16 ecmd.cu_base_addr = opt.cu_base_addr ecmd.m_features.ert = opt.ert if opt.ert: ecmd.m_features.cu_dma = 1 ecmd.m_features.cu_isr = 1 # CU -> base address mapping ecmd.data[0] = opt.cu_base_addr ecmd.m_uert.m_cmd_struct.count = 5 + ecmd.num_cus sz = sizeof(ert_configure_cmd) ffi.memmove(c_f, ecmd, sz) print("Send the exec command and configure FPGA (ERT)") # Send the command. ret = xclExecBuf(opt.handle, execHandle) if ret: print("Unable to issue xclExecBuf") return 1 print("Wait until the command finish") while xclExecWait(opt.handle, 1000) != 0: print(".") print("Construct the exec command to run the kernel on FPGA") # construct the exec buffer cmd to start the kernel start_cmd = ert_start_kernel_cmd() rsz = (XHELLO_HELLO_CONTROL_ADDR_ACCESS1_DATA / 4 + 1) + 1 # regmap array size new_data = ((start_cmd.data._type_) * rsz)() start_cmd.m_uert.m_start_cmd_struct.state = 1 # ERT_CMD_STATE_NEW start_cmd.m_uert.m_start_cmd_struct.opcode = 0 # ERT_START_CU start_cmd.m_uert.m_start_cmd_struct.count = 1 + rsz start_cmd.cu_mask = 0x1 new_data[XHELLO_HELLO_CONTROL_ADDR_AP_CTRL] = 0x0 new_data[XHELLO_HELLO_CONTROL_ADDR_ACCESS1_DATA / 4] = bodevAddr new_data[XHELLO_HELLO_CONTROL_ADDR_ACCESS1_DATA / 4 + 1] = (bodevAddr >> 32) & 0xFFFFFFFF ffi.memmove(c_f, start_cmd, 2 * sizeof(c_uint32)) tmp_buf = ffi.buffer(c_f, 2 * sizeof(c_uint32) + (len(new_data) * sizeof(c_uint32))) data_ptr = ffi.from_buffer(tmp_buf) ffi.memmove(data_ptr + 2 * sizeof(c_uint32), new_data, len(new_data) * sizeof(c_uint32)) if xclExecBuf(opt.handle, execHandle): print("Unable to issue xclExecBuf") return 1 else: print("Kernel start command issued through xclExecBuf : start_kernel") print("Now wait until the kernel finish") print("Wait until the command finish") while xclExecWait(opt.handle, 1) != 0: print(".") # get the output xclSyncBO print("Get the output data from the device") if xclSyncBO(opt.handle, boHandle, xclBOSyncDirection.XCL_BO_SYNC_BO_FROM_DEVICE, opt.DATA_SIZE, 0): return 1 rd_buf = ffi.buffer(read_fp, len("Hello World")) print("RESULT: ") print(rd_buf[:] + "\n") return 0
elif os.path.exists("./libdistributions.so"): lib = ffi.dlopen("./libdistributions.so") else: raise RuntimeError("Required DLL/so file was not found.") ffi.cdef(""" double random_standard_normal(void *bitgen_state); """) x = PCG64() xffi = x.cffi bit_generator = xffi.bit_generator random_standard_normal = lib.random_standard_normal def normals(n, bit_generator): out = np.empty(n) for i in range(n): out[i] = random_standard_normal(bit_generator) return out normalsj = nb.jit(normals, nopython=True) # Numba requires a memory address for void * # Can also get address from x.ctypes.bit_generator.value bit_generator_address = int(ffi.cast("uintptr_t", bit_generator)) norm = normalsj(1000, bit_generator_address) print(norm[:12])
{int64:s} {int32:s} """.format_map(signatures) print(sig_text) ffi.cdef(sig_text) # # open the library file # lib = ffi.dlopen(lib_so_file) print('found these functions in module: ', dir(lib)) make_unique_double = lib.make_unique_double type_dict = dict(double=np.float64, float=np.float32, int=np.int64) in_vec = np.array([0, 5, 5, 1, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5], dtype=np.float64) invec_ptr = ffi.cast("double *", in_vec.ctypes.data) invec_len = in_vec.size type_dict = { 'double': (np.float64, lib.make_unique_double), 'float': (np.float32, lib.make_unique_float), 'int64_t': (np.int64, lib.make_unique_int64), 'int32_t': (np.int32, lib.make_unique_int32) } in_vec = np.array([0, 5, 5, 1, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5]) print(f'original vector: {in_vec}') for type_key, value in type_dict.items(): print(f'testing {type_key}') np_type, the_fun = value in_vec = np.array([0, 5, 5, 1, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5],
class QuadraticMarchingCubes: def __init__(self): self.ffi = FFI() with open("Src/exported_routines.h") as header: header_str = header.read() cstr = "" ignore = False for line in header_str.splitlines(): if (line.startswith("#if")): ignore = True if (ignore == False): cstr += line if (line.startswith("#end")): ignore = False self.ffi.cdef(cstr) correctWorkingDirectory = os.getcwd() libname_start = correctWorkingDirectory + "/build/libquadratic_iso" if (platform.system() == "Darwin"): if os.path.exists(libname_start + ".dylib"): libname = libname_start + ".dylib" else: libname = libname_start + "d.dylib" elif (platform.system() == "Windows"): libname = correctWorkingDirectory + "/build/Debug/quadratic_iso.dll" else: if os.path.exists(libname_start + ".so"): libname = libname_start + ".so" else: libname = libname_start + "d.so" self.isosurf = self.ffi.dlopen(libname) os.chdir(os.getcwd()) print(self.isosurf) def run(self, isovalue, np_sdf_data, dim, path=None): #Allocate the maximum possible amount of memory used for buffers #passed into the C++ code. np_tris = np.zeros((dim * dim * dim, 3), dtype=np.int32) np_verts = np.zeros((dim * dim * dim, 3), dtype=np.float32) ffi_vert_count = self.ffi.new("int*") ffi_tri_count = self.ffi.new("int*") #Run the C++ code. self.isosurf.run_quadratic_mc( self.ffi.cast("int", dim), self.ffi.cast("float*", np_sdf_data.ctypes.data), self.ffi.cast("float", isovalue), self.ffi.cast("float*", np_verts.ctypes.data), ffi_vert_count, self.ffi.cast("int*", np_tris.ctypes.data), ffi_tri_count) #Trim off unused memory np_verts = np_verts[:ffi_vert_count[0], :] np_tris = np_tris[:ffi_tri_count[0], :] if path is not None: with open(path, "w") as f: f.write("# OBJ file\n") for i in range(ffi_vert_count[0]): f.write( f"v {np_verts[i,0]:3.4f} {np_verts[i,1]:3.4f} {np_verts[i,2]:3.4f}\n" ) for i in range(ffi_tri_count[0]): f.write( f"f {np_tris[i,0]+1:d} {np_tris[i,1]+1:d} {np_tris[i,2]+1:d}\n" ) return np_verts, np_tris
bin_params.globalBoundary = GLOBAL_BOUNDARY bin_params.localBoundary = LOCAL_BOUNDARY bin_params.fieldReach = FIELD_REACH bin_params.fieldSize = FIELD_SIZE preTime = time.time() - preStart rustStart = time.time() rust_rtn = C.segment_buffer(c_arr,arr.shape[1],arr.shape[0],bin_params) rustTime = time.time() - rustStart postStart = time.time() pixels_arr = rust_rtn.pixels print("SIZE:",pixels_arr.size) pixels = ffi.cast("uint8_t*",pixels_arr.ptr) debug_arr = np.array([pixels[i] for i in range(pixels_arr.size)]).astype("uint8") # print("debug_arr.dtype:",debug_arr.dtype) debug_img = np.reshape(debug_arr,arr.shape,'C') # print(debug_img.shape) img = Image.fromarray(debug_img, 'RGB') img = Image.fromarray(debug_img, 'RGB') postTime = time.time() - postStart print("Time:",f"{preTime:.3f}","->",f"{rustTime:.3f}","->",f"{postTime:.3f}") img.save("test_image.png") img.show() lines_arr = rust_rtn.symbols
def setup_function(function): print("setting up %s" % function) if __name__ == "__main__": global shm import sys shmstep0() print shm.fd, shm.size, ffi.string(shm.name) c = sys.stdin.readline() print "readlins is return", c if c[:4] == "open": print "into openex test process 2" shmstep1x() print "copy 7 bytes " caddr = ffi.cast("void*", shm.addr) C.memcpy(caddr, "welcome", 7) sys.stdin.readline() print "copy %d bytes" % (4096 * 2 + 1) C.memcpy(caddr, "welcome" * 2000, 4096 * 2 + 1) sys.stdin.readline() shmstep2() elif c[:5] == "close": pass #C.shm_unlink(shm.name) else: shmstep1() print "into open test process 1" sys.stdin.readline() shmstep2()
def test_vi_C_interface(): try: from cffi import FFI cffi_is_present = True except: cffi_is_present = False return if cffi_is_present: h = 1e-5 T = 1.0 t = 0.0 theta = 1.0 gamma = 1.0 g = 9.81 kappa = 0.4 xk = np.array((1., 10.)) ffi = FFI() ffi.cdef('void set_cstruct(uintptr_t p_env, void* p_struct);') ffi.cdef('''typedef struct { int id; double* xk; double h; double theta; double gamma; double g; double kappa; } data; ''') data_struct = ffi.new('data*') data_struct.id = -1 # to avoid freeing the data in the destructor data_struct.xk = ffi.cast('double *', xk.ctypes.data) data_struct.h = h data_struct.theta = theta data_struct.gamma = gamma data_struct.g = g data_struct.kappa = kappa vi = SN.VI(2) import siconos D = ffi.dlopen(siconos.__path__[0] + '/_numerics.so') D.set_cstruct(vi.get_env_as_long(), ffi.cast('void*', data_struct)) vi.set_compute_F_and_nabla_F_as_C_functions('ZhuravlevIvanov.so', 'compute_F', 'compute_nabla_F') lambda_ = np.zeros((2,)) xkp1 = np.zeros((2,)) SO = SN.SolverOptions(vi, SN.SICONOS_VI_BOX_QI) lb = np.array((-1.0, -1.0)) ub = np.array((1.0, 1.0)) vi.set_box_constraints(lb, ub) N = int(T/h + 10) print(N) SO.dparam[0] = 1e-24 SO.iparam[0] = 100 SO.iparam[2] = 1 SO.iparam[3] = 0 SO.iparam[4] = 5 signs = np.empty((N, 2)) sol = np.empty((N, 2)) sol[0, :] = xk k = 0 #SN.setNumericsVerbose(3) while t <= T: k += 1 info = SN.variationalInequality_box_newton_QiLSA(vi, lambda_, xkp1, SO) #print('iter {:} ; solver iter = {:} ; prec = {:}'.format(k, SO.iparam[1], SO.dparam[1])) if info > 0: print(lambda_) # vi_function(2, signs[k-1, :], xkp1) lambda_[0] = -np.sign(xkp1[0]) lambda_[1] = -np.sign(xkp1[1]) if np.abs(xk[0]) < 1e-10: lambda_[0] = 0.01 if np.abs(xk[1]) < 1e-10: lambda_[1] = 0.01 print('ok lambda') print(lambda_) info = SN.variationalInequality_box_newton_QiLSA(vi, lambda_, xkp1, SO) print('iter {:} ; solver iter = {:} ; prec = {:}'.format(k, SO.iparam[1], SO.dparam[1])) if info >0: print('VI solver failed ! info = {:}'.format(info)) print(xk) print(lambda_) print(xkp1) kaboom() # else: # print('iter {:} ; solver iter = {:} ; prec = {:}'.format(k, SO.iparam[1], SO.dparam[1])) # vi_function(2, lambda_, xkp1) sol[k, 0:2] = xkp1 np.copyto(xk, xkp1, casting='no') signs[k, 0:2] = lambda_ t = k*h
from ctypes import c_double, c_int, pointer, POINTER import numpy as np ffi = FFI() chi2 = ffi.dlopen('./_chi2.so') ffi.cdef(""" int chi2(double m, double b, double *x, double *y, double *yerr, int N, double* result); """) if __name__ == '__main__': mu_y = 0. sig_y = 5. mu_x = 0.21 sig_x = 3. N = int(1000) m = float(1.) b = float(0.) x = np.random.normal(mu_x, sig_x, N).astype('float64') x_p = ffi.cast('double *', x.ctypes.data) y = np.random.normal(mu_y, sig_y, N).astype('float64') y_p = ffi.cast('double *', y.ctypes.data) yerr = np.array([sig_y] * N, 'float64') yerr_p = ffi.cast('double *', yerr.ctypes.data) result = ffi.new('double *') chi2.chi2(m, b, x_p, y_p, yerr_p, N, result) print(result[0])
class Image(object): def __init__(self, input_image, greyscale=False, matrix=None, depth=KM_UINT8): """ input_image: An image. greyscale: A boolean indicating whether to read the image on a greyscale or not matrix: An array representing the image. depth: An integer indicating each channel depth """ np_type = { KM_FLOAT32: np.float32, KM_INT32: np.int32, KM_UINT8: np.uint8 }.get(depth, None) if type(matrix) is np.ndarray: np_type == matrix.dtype elif matrix == None: pass else: raise ValueError('Only numpy arrays are allowed.') if np_type not in [np.uint8, np.int32, np.float32]: raise ValueError('Invalid type for numpy array.') self.ffi = FFI() with open('./src/includes/wrapper.h', 'r') as f: self.ffi.cdef(f.read()) self.lib = self.ffi.dlopen('./wrapper.so') self.input_image = input_image self.greyscale = greyscale self.np_type = np_type self.depth = depth self.matrix = matrix or self.read_image() (self.height, self.width) = self.matrix.shape[:2] def read_image(self): """ Read input_image using OpenCV (uses L*a*b* color space) """ image = cv2.imread(self.input_image, 0 if self.greyscale else 1) if not self.greyscale: image = cv2.cvtColor(image, cv2.COLOR_BGR2LAB) if self.np_type == np.float32: image = image.astype(self.np_type) / np.iinfo(image.dtype).max return image def posterize(self, levels): """ Posterize image using KMeans with levels number of clusters """ points = self.height * self.width dim = 1 if self.greyscale else 3 image = self.matrix.flatten() # Cast numpy array to void * c_matrix = self.ffi.cast('void *', image.ctypes.data) # Apply KMeans and get centroids c_centroids = self.lib.kmeans(c_matrix, points, dim, levels, self.depth) # Paint posterized image c_posterized = self.lib.assign_color(c_matrix, c_centroids, points, dim, levels, self.depth) # Cast posterized image to it original type pointer_type = { np.float32: 'float *', np.int32: 'int32_t *', np.uint8: 'uint8_t *' }[self.np_type] c_posterized_cast = self.ffi.cast(pointer_type, c_posterized) # Initialize buffer from which we'll read the new numpy array c_buffer = self.ffi.buffer(c_posterized_cast, points * dim * self.matrix.dtype.itemsize) posterized = np.frombuffer(c_buffer, dtype=self.np_type) if self.np_type == np.float32: posterized = (posterized * 255).astype(np.uint8) # Reshape it to the original size if self.greyscale: posterized = np.reshape(posterized, (self.height, self.width)) else: posterized = np.reshape(posterized, (self.height, self.width, 3)) posterized = cv2.cvtColor(posterized, cv2.COLOR_LAB2BGR) output = re.sub('(?P<pre>.*)(?P<format>\..*?)', '\g<pre>_output\g<format>', self.input_image) cv2.imwrite(output, posterized)