示例#1
0
def compare_image_lists(new_result, old_result, decimals):
    fns = []
    for _ in range(2):
        tmpfd, tmpname = tempfile.mkstemp(suffix=".png")
        os.close(tmpfd)
        fns.append(tmpname)
    num_images = len(old_result)
    assert num_images > 0
    for i in range(num_images):
        mpimg.imsave(fns[0], np.loads(zlib.decompress(old_result[i])))
        mpimg.imsave(fns[1], np.loads(zlib.decompress(new_result[i])))
        results = compare_images(fns[0], fns[1], 10 ** (-decimals))
        if results is not None:
            if os.environ.get("JENKINS_HOME") is not None:
                tempfiles = [
                    line.strip()
                    for line in results.split("\n")
                    if line.endswith(".png")
                ]
                for fn in tempfiles:
                    sys.stderr.write(f"\n[[ATTACHMENT|{fn}]]")
                sys.stderr.write("\n")
        assert_equal(results, None, results)
        for fn in fns:
            os.remove(fn)
示例#2
0
def load_data(hypes):
    data_directory = 'working_dir/data/%s' % hypes['data_directory']

    # read data control dictionaries
    metadata = load_metadata(hypes)
    # read numpy arrays
    idx_q = np.loads(storage.get('%s/idx_q.npy' % data_directory))
    idx_a = np.loads(storage.get('%s/idx_a.npy' % data_directory))

    (trainX, trainY), (testX, testY), (validX,
                                       validY) = split_dataset(idx_q, idx_a)
    trainX = trainX.tolist()
    trainY = trainY.tolist()
    testX = testX.tolist()
    testY = testY.tolist()
    validX = validX.tolist()
    validY = validY.tolist()

    trainX = tl.prepro.remove_pad_sequences(trainX)
    trainY = tl.prepro.remove_pad_sequences(trainY)
    validX = tl.prepro.remove_pad_sequences(validX)
    validY = tl.prepro.remove_pad_sequences(validY)
    testX = tl.prepro.remove_pad_sequences(testX)
    testY = tl.prepro.remove_pad_sequences(testY)

    return metadata, trainX, trainY, testX, testY, validX, validY
示例#3
0
文件: app.py 项目: roliveira/pyxel
    def load(self, filename):
        dirname = os.path.dirname(inspect.stack()[-1].filename)
        filename = os.path.join(dirname, filename)

        with gzip.open(filename, mode="rb") as fp:
            pickled_data = fp.read()

        data = pickle.loads(pickled_data)

        # todo: version check

        image_list = data.get("image")
        if image_list:
            for i in range(RENDERER_IMAGE_COUNT - 1):
                pyxel.image(i).data[:, :] = np.loads(image_list[i])

        tilemap_list = data.get("tilemap")
        if tilemap_list:
            for i in range(RENDERER_TILEMAP_COUNT):
                pyxel.tilemap(i).data[:, :] = np.loads(tilemap_list[i])

        sound_list = data.get("sound")
        if sound_list:
            for i in range(AUDIO_SOUND_COUNT):
                src = sound_list[i]
                dest = pyxel.sound(i)

                dest.note = src.note
                dest.tone = src.tone
                dest.volume = src.volume
                dest.effect = src.effect
                dest.speed = src.speed
示例#4
0
 def k_means_distance(self, centers, result_name=None):
     """
         Computes the distance between each row and each of the given center vectors for k-means
     """
     if centers.shape[1] != self.__cols:
         raise BaseException('Dimensions of matrix and centers do not match')
     if result_name == None:
         result_name = MatrixFactory.getRandomMatrixName()
     
     redwrap = RedisWrapper(self.context.redis_master, self.context.key_manager)
     prefix = 'dist(' + self.__name + ',' + centers.name() + ')';
     dist_job = kmeans_jobs.KMeansDistanceJob(self.context, self, centers, prefix)
     
     parts = dist_job.run()
     
     for p in range(0,len(parts)):
         part_name = parts[p]
         m = self.context.redis_master.lpop(part_name)
         sum = None
         while m != None:
             if sum == None:
                 sum = numpy.loads(m)
             else:
                 sum += numpy.loads(m)
             m = self.context.redis_master.lpop(part_name)
             
         self.context.redis_master.delete(part_name)
         redwrap.create_block(self.context.key_manager.get_block_name(result_name, p, 0), numpy.sqrt(sum))
     
     res = Matrix(self.__rows, centers.shape[0], result_name, self.context)
     return res
    def run(self):
        video_input = self.get_input("videoInput")
        video_input_resized = self.get_input("videoInputResized")
        gif_data_output = self.get_output("gifData")
        script = FrameAnalyzer()

        while self.running():
            # read frames - full scale and thumb
            frame_obj = video_input.read()
            frame_obj_resized = video_input_resized.read()
            frame = np.loads(frame_obj)
            frame_resized = np.loads(frame_obj_resized)

            with self.filters_lock:
                script.change_settings(\
                    self.get_parameter("max_gif_length"),
                    self.get_parameter("min_gif_length"),
                    self.get_parameter("min_time_between_gifs"),
                    self.get_parameter("max_acceptable_distance") )

            loop_data = script(frame, frame_resized)
            if loop_data and len(loop_data)==4:
                file_path, w, h, frames_count = loop_data
                self.__send_to_next_service(gif_data_output, file_path, w, h, frames_count)
                self.__push_notification()
示例#6
0
def process(dataframe, stage, output_file):
    # produce data for next stage
    try:
        config_gpu()
        detector = Detector()
        print("start gen: %s!!!!" % output_file)
        result = pd.DataFrame(columns=COLUMNS)
        for idx, ano in dataframe.iterrows():
            img_path = ano.file_name
            gboxes = np.loads(
                ano.boundbox,
                encoding='bytes') if version_info.major >= 3 else np.loads(
                    ano.boundbox)  # py3 encoding='bytes'
            keypoints = np.loads(
                ano.keypoints,
                encoding='bytes') if version_info.major >= 3 else np.loads(
                    ano.keypoints)

            img = cv2.imread(img_path)
            height, width = img.shape[:-1]
            candis = detector.predict(img, stage) or []
            input_size = {"pnet": 12, "rnet": 24, "onet": 48}.get(stage)
            fp_df = mining_fp_box(img_path, img, candis, gboxes, keypoints,
                                  input_size)
            fn_df = mining_fn_box(img_path, img, candis, gboxes, keypoints,
                                  input_size)
            result = pd.concat([result, fp_df, fn_df], ignore_index=True)
            if idx % 100 == 0:
                print("idx: %s" % idx)
        result.to_feather(output_file)
    except Exception as ee:
        print("!!!!!%s---%s" % (process.__name__, ee))
        print(ano.boundbox, ano.keypoints)
    print("end file %s" % output_file)
    def run(self):
        video_input = self.get_input("videoInput")
        video_input_resized = self.get_input("videoInputResized")
        gif_data_output = self.get_output("gifData")
        script = FrameAnalyzer()

        while self.running():
            # read frames - full scale and thumb
            frame_obj = video_input.read()
            frame_obj_resized = video_input_resized.read()
            frame = np.loads(frame_obj)
            frame_resized = np.loads(frame_obj_resized)

            with self.filters_lock:
                script.change_settings(\
                    self.get_parameter("max_gif_length"),
                    self.get_parameter("min_gif_length"),
                    self.get_parameter("min_time_between_gifs"),
                    self.get_parameter("max_acceptable_distance") )

            loop_data = script(frame, frame_resized)
            if loop_data and len(loop_data) == 4:
                file_path, w, h, frames_count = loop_data
                self.__send_to_next_service(gif_data_output, file_path, w, h,
                                            frames_count)
                self.__push_notification()
示例#8
0
def image_transform(idx, row, input_size=12, is_training=True):
    if row.crop_image:
        input_img = np.loads(
            row.crop_image,
            encoding='bytes') if version_info.major >= 3 else np.loads(
                row.crop_image)
    else:
        img = cv2.imread(row.file_name)
        cropped = np.loads(row.cropped, encoding='bytes')
        x1, y1, x2, y2 = [int(x) for x in cropped.tolist()]
        input_img = cv2.resize(img[y1:y2, x1:x2, :], (
            input_size,
            input_size,
        ))
    btype, normbox, norm_points = row.btype, trans_numpy(
        row.normbox), trans_numpy(row.norm_points)
    btype = np.array([btype])
    #if btype == 2:
    #cv2.imwrite("%s.jpg"%idx, img[y1:y2,x1:x2, :])
    #if img[y1:y2, x1:x2, :].size == 0:
    #print("dddddd", cropped, y1, y2, x1, x2, img.shape, row.file_name, btype)

    if is_training:
        input_img, normbox, norm_points = image_enforcing(
            input_img, normbox, norm_points)
    result = np.concatenate((
        btype,
        normbox,
        norm_points,
    ))  # 0: class, 1-4: boundbox, 5-19: keypoints
    return input_img, result
示例#9
0
文件: graph.py 项目: ahillbs/ma-ahill
 def _reconstruct(self):
     self.vertices = np.loads(self._vert_bin)
     self.edges = np.loads(self._edge_bin)
     self._dirty_edges = False
     self._dirty_matrix = True
     self._ad_matrix = None
     self.costs = None
     self.simple = self.check_simple()
def socketcomm(port, pipec, flags, uarr, dat_size=156):
    """Callback function to deal with incoming tcp communication.
	pipec,pipeu and pipesoc are pipe objects
	pipec: describes position of camera
	pipeu: describes orientation of camera.
	           sends (True, data) for good data
	           sends (False,.......) for bad data or loop not running
	pipesoc: fill socket objects and send to __main__
	"""
    # Flags
    sockets = []
    waiting_for_data = True
    # initialise socket object
    serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    serversocket.bind((_TCP_SOCKET_HOST, port))
    serversocket.listen(1)
    serversocket.setblocking(0)
    # add server socket to list of sockets
    sockets.append(serversocket)
    # create epoll object
    _epoll = select.epoll()
    # register interest in read events on the server socket
    _epoll.register(serversocket.fileno(), select.EPOLLIN)

    while waiting_for_data:
        events = _epoll.poll(1)
        for fileno, event in events:
            if fileno == serversocket.fileno():
                # initialise client socket object
                clientsocket, clientaddr = serversocket.accept()
                clientsocket.setblocking(0)
                # register client socket on epoll
                _epoll.register(clientsocket.fileno(), select.EPOLLIN)
                sockets.append(clientsocket)
            elif event & select.EPOLLIN:
                # read event  on client socket
                content = clientsocket.recv(dat_size)
                if content[0] == "u":
                    # pipeu.send((True,True,np.loads(content[1:])))
                    with uarr.get_lock():
                        uarr.get_obj()[:3] = np.loads(content[1:]).ravel()
                    flags.value = 2
                elif content[0] == "d":
                    # pipeu.send((False,True))
                    flags.value = 1
                elif content[0] == "c":
                    pipec.send(np.loads(content[1:]))
                elif content[0] == "e":
                    # pipeu.send((False,False))
                    flags.value = 0
                    waiting_for_data = False
                    for i in sockets:
                        _epoll.unregister(i.fileno())
            elif event & select.EPOLLHUP:
                for i in sockets:
                    _epoll.unregister(i.fileno())
                    i.close()
示例#11
0
 def get_correlation(self):
     pkt = self._request('') # raises NoCorrelation if none ready
     self.logger.debug('received: %r' % pkt)
     data = pkt[self._header_size:] # should be 3 arrays and 2 floats
     corr_time, left, right, current, total = self._header_struct.unpack(pkt[:self._header_size])
     lagss, visibss, fitss, m, c = self.unpacker.unpack(data)
     return (
         corr_time, left, right, current, total, # header information
         loads(lagss), loads(visibss), loads(fitss), m, c # data
         )
示例#12
0
 def _convert_mem_to_transition(mem):
     next_state = mem[
         "next_state"].data if mem["next_state"] != None else None
     return Transition(state=torch.as_tensor(np.loads(mem["state"].data)),
                       action=torch.tensor([[mem["action"]]],
                                           dtype=torch.long),
                       reward=torch.tensor([[mem["reward"]]],
                                           dtype=torch.float),
                       next_state=torch.as_tensor(np.loads(next_state))
                       if next_state != None else None)
示例#13
0
   def load_model(self, filename, delimiter = '<DELIMITER>'):
      """
      Load model parameters from the file provided
      """

      try:
         infile = open(filename, 'r')
      except IOError:
         print "Could not open filename '" + filename + "'."
         return

      # Get the number of units in each layer
      data = infile.read()
      data = data.split(delimiter)

      self.num_visible = int(data[0])
      self.num_hidden = int(data[1])
      self.num_rnn = int(data[2])

      # Read each line and convert to weight matrices
      self.Whv = np.loads(data[3])
      self.Wuh = np.loads(data[4])
      self.Wuv = np.loads(data[5])
      self.Wuu = np.loads(data[6])
      self.Wvu = np.loads(data[7])

      self.bias_visible = np.loads(data[8])
      self.bias_hidden = np.loads(data[9])
      self.bias_rnn = np.loads(data[10])

      self.initial_rnn = np.loads(data[11])

      infile.close()
示例#14
0
def solve_linear_equation(arr1, arr2, arr3):
    try:
        arr1 = np.loads(arr1.encode())
        arr2 = np.loads(arr2.encode())
        arr3 = np.loads(arr3.encode())
    except Exception as err:
        result = "参数有误"
    unknown_data = np.array([arr1, arr2])
    const_data = np.array([arr3[0], arr3[1]])
    result = np.linalg.solve(unknown_data, const_data)
    return result
示例#15
0
def imgloader(labelq, dataq, batch_sz, pc_id, sharedmem): 
 try:
  env = lmdb.open('testDB', readonly=True);
  miniidx=0;
  sendctr=0;
  random.seed(pc_id);
  np.random.seed(np.int64(pc_id));
  curmem=0;
  mylock=sharedmem[curmem].get_lock();
  while True:
    label=np.zeros([batch_sz,10,64,80],np.float32);
    data=np.zeros([batch_sz,3,im_sz[0],im_sz[1]],np.float32);
    temp = np.zeros([64,80,10],np.float32);
    j=0;
    while(j < batch_sz):
      flip = random.randint(1,10)%2;
      start = time.time();
      im = [];
      if (miniidx > 800):
	        miniidx = 0;

      with env.begin() as txn:
             	str_id = "{:08}".format(miniidx)
	        raw_datum = txn.get(str(str_id));
             	im = np.loads(raw_datum);

      with env.begin() as txn:
             	str_id = "{:08}".format((miniidx+1))
	        raw_datum = txn.get(str_id);
             	temp = np.loads(raw_datum);

      start = time.time();

      if flip:
	im = im[:,::-1,:];
	temp = temp[:,::-1,:];
        temp[:,:,0:5] *= -1.0;
      data[j,0:3:,:,:]=prep_image(im,im_sz).transpose(2,0,1);
      label[j,:,:,:] = (temp.transpose(2,0,1)).copy()*1000;
      j = j + 1
      miniidx = miniidx + 2
    buf=np.frombuffer(sharedmem[curmem].get_obj(), dtype=np.float32).reshape([batch_sz,3,im_sz[0],im_sz[1]]);
    buf[:,:,:,:]=data;
    dataq.put((curmem,label), timeout=6000);

    del mylock;
    curmem=(curmem+1) % len(sharedmem);
    mylock = sharedmem[curmem].get_lock();

 except Exception as e:
  tup2="".join(traceback.format_exception(*sys.exc_info()));
  dataq.put(tup2);
  raise
示例#16
0
 def _do_numeric(self, value, path):
     if PY_VER > 2:
         data = value['data']
         if isinstance(data, str):
             data = value['data'].encode('utf-8')
         junk = gunzip_string(base64.decodebytes(data))
         result = numpy.loads(junk, encoding='bytes')
     else:
         junk = gunzip_string(value['data'].decode('base64'))
         result = numpy.loads(junk)
     self._numeric[value['id']] = (path, result)
     self._obj_cache[value['id']] = result
     return result
def convert_numarray(s):
    #print(type(s))
    try:
        #assume data is zipped
        uz = zlib.decompress(s)
        #print(uz)
        if six.PY2:
            return np.loads(uz)
        else:
            return np.loads(uz, encoding='bytes')
    except:
        #fall back and just try unpickling
        return pickle.loads(s)
def socket_cb1(socket,val):
    global u1,c1, running1,fr1,dat1
    if val[0] == 'u':
        u1 = np.loads(val[1:])
        fr1 += 1
        dat1 = True
    elif val[0] == 'c':
        c1 = np.loads(val[1:])
    elif val[0] == 'd':
        dat1 = False
    elif val[0] == 'e':
    	dat1 = False
        running1 = False
示例#19
0
 def _do_numeric(self, value, path):
     if PY_VER > 2:
         data = value['data']
         if isinstance(data, str):
             data = value['data'].encode('utf-8')
         junk = gunzip_string(base64.decodebytes(data))
         result = numpy.loads(junk, encoding='bytes')
     else:
         junk = gunzip_string(value['data'].decode('base64'))
         result = numpy.loads(junk)
     self._numeric[value['id']] = (path, result)
     self._obj_cache[value['id']] = result
     return result
def socket_cb2(socket,val):
    global u2,c2, running2,fr2,dat2
    if val[0] == 'u':
        u2 = np.loads(val[1:])
        fr2 += 1
        dat2 = True
    elif val[0] == 'c':
        c2 = np.loads(val[1:])
    elif val[0] == 'd':
        dat2 = False
    elif val[0] == 'e':
    	dat2 = False
        running2 = False
示例#21
0
 def get_correlation(self):
     cmd = BYTE.pack(128)
     size, err, pkt = self._request(cmd)
     if err:
         raise NoCorrelations
     self.logger.debug('received: %r' % pkt)
     header_struct = BEE2CorrelationProvider._header_struct
     data = pkt[header_struct.size:] # should be 3 arrays and 2 floats
     corr_time, left, right, current, total = header_struct.unpack(pkt[:header_struct.size])
     lagss, visibss, fitss, m, c = self.unpacker.unpack(data)
     return (
         corr_time, left, right, current, total, # header information
         loads(lagss), loads(visibss), loads(fitss), m, c # data
         )
示例#22
0
文件: app.py 项目: yut148/pyxel
    def load(self, filename):
        dirname = os.path.dirname(inspect.stack()[-1].filename)
        filename = os.path.join(dirname, filename)

        with gzip.open(filename, mode="rb") as fp:
            pickled_data = fp.read()

        data = pickle.loads(pickled_data)

        # todo: version check

        image_list = data.get("image")
        if image_list:
            for i in range(RENDERER_IMAGE_COUNT - 1):
                pyxel.image(i).data[:, :] = np.loads(image_list[i])

        tilemap_list = data.get("tilemap")
        if tilemap_list:
            if type(tilemap_list[0]) is tuple:
                for i in range(RENDERER_TILEMAP_COUNT):
                    tilemap = pyxel.tilemap(i)
                    tilemap.data[:, :] = np.loads(tilemap_list[i][0])
                    tilemap.refimg = tilemap_list[i][1]
            else:  # todo: delete this block in the future
                for i in range(RENDERER_TILEMAP_COUNT):
                    pyxel.tilemap(i).data[:, :] = np.loads(tilemap_list[i])

        sound_list = data.get("sound")
        if sound_list:
            for i in range(AUDIO_SOUND_COUNT - 1):
                src = sound_list[i]
                dest = pyxel.sound(i)

                dest.note[:] = src.note
                dest.tone[:] = src.tone
                dest.volume[:] = src.volume
                dest.effect[:] = src.effect
                dest.speed = src.speed

        music_list = data.get("music")
        if music_list:
            for i in range(AUDIO_MUSIC_COUNT - 1):
                src = music_list[i]
                dest = pyxel.music(i)

                dest.ch0[:] = src.ch0
                dest.ch1[:] = src.ch1
                dest.ch2[:] = src.ch2
                dest.ch3[:] = src.ch3
示例#23
0
文件: app.py 项目: roberpot/pyxel
    def load(self, filename):
        with gzip.open(filename, mode="rb") as fp:
            pickled_data = fp.read()

        data = pickle.loads(pickled_data)

        # todo: version check

        image = data["image"]
        for i in range(RENDERER_IMAGE_COUNT - 1):
            self._module.image(i).data[:, :] = np.loads(image[i])

        tilemap = data["tilemap"]
        for i in range(RENDERER_TILEMAP_COUNT):
            self._module.tilemap(i).data[:, :] = np.loads(tilemap[i])
示例#24
0
 def show_frame(self, input_connector, video_frame_label):
     obj = input_connector.read()
     frame = np.loads(obj)  # załadownaie ramki do obiektu NumPy
     img = Image.fromarray(frame)
     imgTk = ImageTk.PhotoImage(image=img)
     video_frame_label.imgTk = imgTk
     video_frame_label.configure(image=imgTk)
示例#25
0
def identify_students_in_pic(students, picture, StudentObject):

    image = face_recognition.load_image_file(picture)
    encodings = face_recognition.face_encodings(image)

    prescent_student_ids = []
    stud_results = []

    for encoding in encodings:
        for student in students:
            student_pic_encodings = np.loads(student.face_encodings)
            results = face_recognition.compare_faces([encoding],
                                                     student_pic_encodings)
            if results[0]:
                if not student.id in prescent_student_ids:
                    prescent_student_ids.append(student.id)
                    stud_results.append(
                        StudentObject(student.id, student.name,
                                      student.batch.id, student.reg_id,
                                      student.profile, True))

    for student in students:
        if not student.id in prescent_student_ids:
            stud_results.append(
                StudentObject(student.id, student.name, student.batch.id,
                              student.reg_id, student.profile, False))

    return stud_results
示例#26
0
文件: picasso.py 项目: HAL90000/tirt
    def run(self):

        video_input = self.get_input("videoInput")
        video_output = self.get_output("videoOutput")
        objects_input = self.get_input("objectsInput")
        debug_output = self.get_output("debugOutput")
        
        with open('config.json') as data_file:
            data = json.load(data_file)

        classes = data["conf"]["classes"]
        
        frame = None

        while self.running(): #pętla główna usługi (wątku głównego obsługującego strumień wideo)
            
            frame_obj = video_input.read() #odebranie danych z interfejsu wejściowego
            frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy

            objects = objects_input.read()

            size_objects = len(objects)

            for i in range(0,size_objects):
                o = objects[i]
                object_class = "class" + str(o[3])
                color = classes[object_class]
                cv2.rectangle(frame, (o[0], o[1]), (o[0]+o[2], o[1]+o[2]), (color[0],color[1],color[2]), 3)
            #cv2.rectangle(frame, (20, 20), (100, 100), (0,255,0), 3)
            
            video_output.send(frame.dumps())
            debug_output.send([])
def clientthread(conn, L):
    #Sending message to connected client
    #conn.send('Welcome to the server. Type something and hit enter\n') #send only takes string
     
    #infinite loop so that function do not terminate and thread do not end.
    while True:
         
        #Receiving from client
        buf = b''
        while len(buf) < 4:
            buf += conn.recv(4 - len(buf))
        length = struct.unpack('>I', buf)[0]
        data = b''
        l = length
        
        while l > 0:

            d = conn.recv(l)
            l -= len(d)
            data += d

        if not data: break
       
        M = np.loads(data) # HERE IS AN ERROR
        
        if i == 1:
            L = M
        else:
            L += M
    #    t0 = time.time()
    #    data_out = pickle.dumps(L)
    #    print("done in %fs" % (time.time() - t0))
    #    conn.sendall(data_out)
        conn.close() 
    return(L)
示例#28
0
 def loadDictionary(self):
     with open('dictionary500_1.txt', 'r') as infile:
         data = np.loads(infile.read())
     self.name_dict = data[0]
     self.bov_helper.clf = data[1]
     self.bov_helper.kmeans_obj = data[2]
     self.bov_helper.scale = data[3]
示例#29
0
文件: input.py 项目: braind3d/DRUN
def network_input(current_image: np.ndarray, port: int) -> None:
    """Creates a socket for listening for received drone image frames.

    Args:
        current_image (np.ndarray): Cross-thread image data.
        port (int): TCP port a socket to be created on for listening.
    """
    print('ImageThread > network_input')
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as rsock:
        rsock.bind(('0.0.0.0', port))
        print('Socket binded')
        rsock.listen()
        print('Socket listnening')
        conn, addr = rsock.accept()
        with conn:
            print('Image Input established')
            while True:
                loading_image = True
                data = b''
                while loading_image:
                    part = conn.recv(4096)
                    if len(part) == 0:
                        break
                    data += part
                    print(part)
                    print(len(part))
                    ack = str(len(part))
                    conn.sendall(
                        ack.encode())  #send number of bytes read for part

                current_image = np.loads(data)
                print(current_image)
                conn.sendall(b'ACK')
示例#30
0
    def run(self):  #główna metoda usługi
        threading.Thread(target=self.watch_settings).start(
        )  #uruchomienie wątku obsługującego strumień sterujący

        video_input = self.get_input(
            "videoInput")  #obiekt interfejsu wejściowego
        video_output_master = self.get_output(
            "videoOutputMaster")  #obiekt interfejsu wyjściowego
        video_output_output = self.get_output(
            "videoOutputOutput")  #obiekt interfejsu wyjściowego

        while self.running():  #pętla główna usługi
            frame_obj = video_input.read(
            )  #odebranie danych z interfejsu wejściowego
            frame = np.loads(frame_obj)  # załadowanie ramki do obiektu NumPy

            frame = cv2.flip(frame, 1)  # odwrócenie ramki w poziomie
            frame = cv2.cvtColor(
                frame, cv2.COLOR_BGR2RGBA)  # przywrocenie naturalnych kolorów
            frame = frame.dumps()

            video_output_output.send(frame)  # przesłąnie obrazu na wyjście
            video_output_master.send(
                frame
            )  # przesłanie obrazu do mastera do kolejnego przetwarzania
示例#31
0
文件: Interproc.py 项目: sutt/ppd
 def getOrigFrame(self, b_cvt_color = False):
     ''' returns origFrame as numpy obj, instead of a 
         serialized string '''
     img = np.loads(self.serial_origFrame)
     if b_cvt_color:
         return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
     return img
示例#32
0
def data_from_pipeline(data, shape=None, dtype=None):
    if len(shape) == 0:
        return numpy.array(data, dtype=dtype)
    else:
        a = numpy.array([numpy.loads(x) for x in data], dtype=dtype)
        a.shape = (-1, ) + shape
        return a
示例#33
0
def save_to_mat_file(init_data, outfile_name):
    def get_list(vocab_dict):
        l = np.zeros((len(vocab_dict), ), dtype=np.object)
        for w, i in vocab_dict.iteritems():
            l[i] = w
        return l

    laff = lambda nm: np.loads(init_data[nm])
    tag_vocab = get_list(init_data["tag_vocab"])
    word_vocab = get_list(init_data["word_vocab"])
    with open(outfile_name, "wb") as f:
        savemat(f,
                dict(word_context_size=init_data["word_context_size"],
                     embedding_size=init_data["embedding_size"],
                     objective_type=init_data["objective_type"],
                     param_reg_type=init_data["param_reg_type"],
                     param_reg_weight=init_data["param_reg_weight"],
                     tag_vocab=tag_vocab,
                     word_vocab=word_vocab,
                     tagemb=laff("na_tag_emb"),
                     wordemb=laff("na_word_emb"),
                     T1=laff("nam_T1"),
                     T2=laff("nam_T2"),
                     Tt1=laff("nam_Ttld1"),
                     Tt2=laff("nam_Ttld2"),
                     W=laff("nat_W"),
                     Wt=laff("nat_Wtld"),
                     S=laff("na_S_emb")),
                oned_as='column',
                format='5',
                appendmat=False)
示例#34
0
 def init_flann_index(self):
     self.index_vectors = []
     self.index_ids = []
     for _id, v in self.known_vectors.items():
         self.index_vectors.append(np.loads(base64.b64decode(v)))
         self.index_ids.append(_id)
     self.build_index(self.index_vectors)
示例#35
0
    def _map_message_to_signal(self, channel, data):
        if type(channel) == bytes:
            channel = channel.decode('ascii')

        frame_signal_map = {
            'hics:webcam:frame': 'webcam_picture_received',
            'hics:framegrabber:frame': 'hypcam_picture_received',
        }
        changed_signal_map = {
            'hics:camera': 'camera_changed',
            'hics:scanner': 'scanner_changed',
            'hics:scanner:state': 'scanner_changed',
            'hics:focus:state': 'focus_changed',
        }
        value_signal_map = {
            'hics:plugin:announce': 'plugin_announce_received',
            'hics:plugin:notification': 'plugin_notification_received',
        }

        if channel in frame_signal_map.keys():
            if self._is_connected(frame_signal_map[channel]):
                getattr(self,
                        frame_signal_map[channel]).emit(numpy.loads(data))
            return True
        elif channel in changed_signal_map.keys():
            getattr(self, changed_signal_map[channel]).emit()
        elif channel in value_signal_map.keys():
            if type(data) == bytes:
                d = data.decode('ascii')
            else:
                d = data
            getattr(self, value_signal_map[channel]).emit(d)
        else:
            return False
示例#36
0
def k_means_recalc(cmd_ctx):
    m = _get_matrix_block(cmd_ctx, cmd_ctx.cmdArgs[0])
    d = _get_matrix_block(cmd_ctx, cmd_ctx.cmdArgs[1])
    result_prefix = cmd_ctx.cmdArgs[2]
    # Only count if prefix is given
    counter_prefix = None
    if len(cmd_ctx.cmdArgs) > 3:
        counter_prefix = cmd_ctx.cmdArgs[3]
    result = {}

    mincols = numpy.argmin(d, axis=1)

    # Find the nearest center for each record and add the record to the centers sum
    # Also count how many records are nearest to each center
    rowcount = 0
    for col in mincols:
        if counter_prefix != None:
            cmd_ctx.redis_master.incr(counter_prefix + str(col))
        if result.has_key(col):
            result[col] += m[rowcount]
        else:
            result[col] = m[rowcount]
        rowcount += 1

    for key in result.keys():
        k = result_prefix + str(key)
        tmp = cmd_ctx.redis_master.lpop(k)
        if tmp == None:
            cmd_ctx.redis_master.rpush(k, result[key].dumps())
        else:
            cmd_ctx.redis_master.rpush(k, (result[key] + numpy.loads(tmp)).dumps())
def detect():
    img = np.loads(request.data, encoding='latin1')
    landmarks,seg_mask = process_img(img)
    payload = {'landmarks':landmarks.tolist(), 'seg_mask':seg_mask.tolist()}
    if payload is None:
        return jsonify([])
    return jsonify(payload)
def get_segmask(bbox,img):
    margin = 50
    if (bbox[1]<margin) or (bbox[0]<margin) or ((bbox[1]+bbox[3]+margin) > img.shape[0]) or ((bbox[0]+bbox[2]+margin) > img.shape[1]):
        margin = 0
    
    print('Margin =',margin)
    
    img_bboxed = img[bbox[1]-margin:bbox[1]+bbox[3]+margin,bbox[0]-margin:bbox[0]+bbox[2]+margin,:]
    
    desired_size = np.max(img_bboxed.shape)
    old_size = img_bboxed.shape[:2] # old_size is in (height, width) format
    ratio = float(desired_size)/max(old_size)
    new_size = tuple([int(x*ratio) for x in old_size])
    print('bboxedshape',img_bboxed.shape)
    print('new_size',new_size)

    img_bboxed = cv2.resize(img_bboxed, (new_size[1], new_size[0]))

    delta_w = desired_size - new_size[1]
    delta_h = desired_size - new_size[0]
    top, bottom = delta_h//2, delta_h-(delta_h//2)
    left, right = delta_w//2, delta_w-(delta_w//2)

    color = [0, 0, 0]
    new_im = cv2.copyMakeBorder(img_bboxed, top, bottom, left, right, cv2.BORDER_CONSTANT,
        value=color)
    
    output = requests.get('http://127.0.0.1:9999/',data=np.array(new_im).dumps())
    seg_mask = np.loads(output.content, encoding='latin1').astype(np.uint8)
    seg_mask = seg_mask[left:seg_mask.shape[0]-right,top:seg_mask.shape[1] - bottom]
    seg_mask = cv2.resize(seg_mask,(old_size[1],old_size[0]))
    seg_mask = cv2.copyMakeBorder(seg_mask,bbox[1]-margin,img.shape[0] - (bbox[1]+bbox[3]+margin),bbox[0]-margin,
                                   img.shape[1] - (bbox[0]+bbox[2]+margin), cv2.BORDER_CONSTANT,value=color)
    return seg_mask
示例#39
0
文件: tag_rhmm.py 项目: se4u/genrich
def save_to_mat_file(init_data, outfile_name):
    def get_list(vocab_dict):
        l=np.zeros((len(vocab_dict),), dtype=np.object)
        for w, i in vocab_dict.iteritems():
            l[i]=w
        return l
    laff = lambda nm : np.loads(init_data[nm])
    tag_vocab=get_list(init_data["tag_vocab"])
    word_vocab=get_list(init_data["word_vocab"])
    with open(outfile_name, "wb") as f:
        savemat(f,
                dict(word_context_size=init_data["word_context_size"],
                     embedding_size=init_data["embedding_size"],
                     objective_type=init_data["objective_type"],
                     param_reg_type=init_data["param_reg_type"],
                     param_reg_weight=init_data["param_reg_weight"],
                     tag_vocab=tag_vocab,
                     word_vocab=word_vocab,
                     tagemb=laff("na_tag_emb"),
                     wordemb=laff("na_word_emb"),
                     T1=laff("nam_T1"),
                     T2=laff("nam_T2"),
                     Tt1=laff("nam_Ttld1"),
                     Tt2=laff("nam_Ttld2"),
                     W=laff("nat_W"),
                     Wt=laff("nat_Wtld"),
                     S=laff("na_S_emb")),
                oned_as='column',
                format='5',
                appendmat=False)
示例#40
0
    def find(self, img_path):
        target_img = face_recognition.load_image_file(img_path)
        target_encoding = face_recognition.face_encodings(target_img)

        if len(target_encoding) == 0:
            return 'Unknown', None

        target_encoding = target_encoding[0]
        min_dist = float('inf')

        for row in self.related_people:
            query = "SELECT path, encoding from images where id = %s"
            self.cur.execute(query, (row[0], ))

            for img in self.cur:
                if img[1] is None:
                    continue
                encoding = np.loads(img[1])
                distance = face_recognition.face_distance(
                    target_encoding, [encoding])
                if distance < min_dist:
                    most_similar_img_path = img[0]
                    most_similar_name = row[2]
                    min_dist = distance

        return most_similar_name, most_similar_img_path
示例#41
0
文件: hdtest5.py 项目: avzahn/hdtest
	def check(self):

		
		word_errors = 0
		file_errors = 0
		
		t0 = time.time()

		self.get_tree()
		

		files_read = 0
		
		for f in self.tree:
			
			try:
				arr = np.loads(f)
				files_read += 1
			except:
				file_errors += 1
				
			word_errors += np.sum(arr==self.chunk)
			
		t1 = time.time()
		speed = self.sweeplen / (1e6 * (t1-t0)) 



		msg = "\nread %.2f TB at %.2f MB/s"%(files_read*self.flen,speed)
		msg += "\n\t\t failed file reads = %i\n" %(file_errors)
		msg += "\n\t\t word errors = %i\n\n" %(word_errors)
		
		logging.info(msg)
示例#42
0
 def show_frame(self, input_connector, video_frame_label):
     obj = input_connector.read()
     frame = np.loads(obj) # załadownaie ramki do obiektu NumPy
     img = Image.fromarray(frame)
     imgTk = ImageTk.PhotoImage(image=img)
     video_frame_label.imgTk = imgTk
     video_frame_label.configure(image=imgTk)
    def run(self):  # główna metoda usługi
        video_input = self.get_input("videoInput")  # obiekt interfejsu wejściowego
        video_output = self.get_output("videoOutput")
        input_start = True
        out = None

        while self.running():  # pętla główna usługi
            try:
                frame_obj = video_input.read()  # odebranie danych z interfejsu wejściowego
                video_output.send(frame_obj)
            except Exception as e:
                video_input.close()
                if out != None:
                    out.release()
                break
            if input_start:
                video_format = self.get_parameter("videoFormat")
                print video_format
                fourcc = cv2.VideoWriter_fourcc(*"XVID")
                out = cv2.VideoWriter(
                    "output.avi", fourcc, video_format[0], (int(video_format[1]), int(video_format[2]))
                )
                input_start = False
            frame = np.loads(frame_obj)  # załadowanie ramki do obiektu NumPy
            out.write(frame)
示例#44
0
def data_from_pipeline(data, shape=None, dtype=None):
    if len(shape) == 0:
        return numpy.array(data, dtype=dtype)
    else:
        a = numpy.array([numpy.loads(x) for x in data], dtype=dtype)
        a.shape = (-1,)+shape
        return a
示例#45
0
    def run(self):  #główna metoda usługi
        threading.Thread(target=self.watch_settings).start(
        )  #uruchomienie wątku obsługującego strumień sterujący

        video_input = self.get_input(
            "videoInput")  #obiekt interfejsu wejściowego
        video_output = self.get_output(
            "videoOutput")  #obiekt interfejsu wyjściowego

        while self.running():  #pętla główna usługi
            frame_obj = video_input.read(
            )  #odebranie danych z interfejsu wejściowego
            frame = np.loads(frame_obj)  #załadowanie ramki do obiektu NumPy

            with self.service_lock:  # blokada wątku
                resize_coeff = self.resize_coeff

            frame = cv2.resize(frame,
                               None,
                               fx=resize_coeff,
                               fy=resize_coeff,
                               interpolation=cv2.INTER_AREA)

            #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)

            video_output.send(frame.dumps(
            ))  #przesłanie ramki za pomocą interfejsu wyjściowego
示例#46
0
 def loadDictionary(self, trainset):
     with open('dictionary{}.txt'.format(trainset), 'r') as infile:
         data = np.loads(infile.read())
     self.name_dict = data[0]
     self.bov_helper.clf = data[1]
     self.bov_helper.kmeans_obj = data[2]
     self.bov_helper.scale = data[3]
示例#47
0
def socket_cb(socket,val):
	global u2,running1,fr1
	if val[0] == 's':
		u2 = np.loads(val[1:])
		fr1 += 1
	elif val[0] == 'e':
		running1 = False
示例#48
0
def socket_cb2(socket,val):
	global u1,running2,fr2
	if val[0] == 's':
		u1 = np.loads(val[1:])
		fr2 += 1
	elif val[0] == 'e':
		running2 = False
    def run(self):    #główna metoda usługi
        video_input = self.get_input("videoInput")    #obiekt interfejsu wejściowego
        video_output = self.get_output("videoOutput") #obiekt interfejsu wyjściowego
        
        while self.running():   #pętla główna usługi
            try:
                frame_obj = video_input.read()  #odebranie danych z interfejsu wejściowego
            except Exception as e:
                video_input.close()
                video_output.close()
                break
            frame = np.loads(frame_obj)     #załadowanie ramki do obiektu NumPy
            with self.filters_lock:     #blokada wątku
                current_filters = self.get_parameter("filtersOn") #pobranie wartości parametru "filtersOn"

            if 1 in current_filters:    #sprawdzenie czy parametr "filtersOn" ma wartość 1, czyli czy ma być stosowany filtr
                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #zastosowanie filtru COLOR_BGR2GRAY z biblioteki OpenCV na ramce wideo
                frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) # by można było zapisać jako obraz kolorowy
            
            if 2 in current_filters:
                frame = cv2.blur(frame,(7,7))
                
            if 3 in current_filters:
                frame = cv2.GaussianBlur(frame,(5,5),0)
                
            if 4 in current_filters:
                frame = cv2.medianBlur(frame,9) ## nieparzysta liczba
                
            video_output.send(frame.dumps()) #przesłanie ramki za pomocą interfejsu wyjściowego
示例#50
0
def data_from_bytes(data, shape=None, dtype=None):
    if isinstance(data, redis.client.Pipeline):
        return functools.partial(data_from_pipeline, shape=shape, dtype=dtype)

    try:
        return numpy.loads(data)
    except cPickle.UnpicklingError:
        return float(data)
示例#51
0
def import_ConvergenceTest(fn):
    with open(fn) as f:
        l = f.read()
    c = eval(l)
    for mode in c.result:
        for arr in c.result[mode]:
            c.result[mode][arr] = np.loads(c.result[mode][arr])
    return c
示例#52
0
 def read_and_show_frame(self, input_connector, video_frame_label):
     while self.running():
         with self.service_lock:
             obj = input_connector.read()
             #print "odebrano ramkę:", input_connector
             frame = np.loads(obj) # załadownaie ramki do obiektu NumPy
             img = Image.fromarray(frame)
             imgTk = ImageTk.PhotoImage(image=img)
             video_frame_label.imgTk = imgTk
             video_frame_label.configure(image=imgTk)
 def read_video(self):
     video_input = self.get_input("videoInput")	#obiekt interfejsu wejściowego
     while self.running():   #pętla główna usługi
         frame_obj = video_input.read()  #odebranie danych z interfejsu wejściowego
         #print "ramka odebrana"
         frame = np.loads(frame_obj)     #załadowanie ramki do obiektu NumPy
         frame = self.process_frame(frame)
         frame = frame.dumps()
         with self.service_lock:
             self.video_frame = frame
示例#54
0
    def deserialize(self, key, value, flags):
        if flags == 1: # str
            return value
        if flags == 2: # ndarray
            #return np.loads(zlib.decompress(value))
            return np.loads(value)
        if flags == 3: # other
            return json.loads(value)

        raise TypeError("Unknown flags for value: %d" % flags)
示例#55
0
 def test_months_in_units_calculation(self):
     rd = self.test_data.get_rd('clt_month_units')
     calc = [{'func': 'mean', 'name': 'mean'}]
     calc_grouping = ['month']
     ops = ocgis.OcgOperations(dataset=rd, calc=calc, calc_grouping=calc_grouping)
     ret = ops.execute()
     # '[[datetime.datetime(1979, 1, 16, 0, 0) datetime.datetime(1988, 1, 16, 0, 0)]\n [datetime.datetime(1979, 2, 16, 0, 0) datetime.datetime(1988, 2, 16, 0, 0)]\n [datetime.datetime(1979, 3, 16, 0, 0) datetime.datetime(1988, 3, 16, 0, 0)]\n [datetime.datetime(1979, 4, 16, 0, 0) datetime.datetime(1988, 4, 16, 0, 0)]\n [datetime.datetime(1979, 5, 16, 0, 0) datetime.datetime(1988, 5, 16, 0, 0)]\n [datetime.datetime(1979, 6, 16, 0, 0) datetime.datetime(1988, 6, 16, 0, 0)]\n [datetime.datetime(1979, 7, 16, 0, 0) datetime.datetime(1988, 7, 16, 0, 0)]\n [datetime.datetime(1979, 8, 16, 0, 0) datetime.datetime(1988, 8, 16, 0, 0)]\n [datetime.datetime(1979, 9, 16, 0, 0) datetime.datetime(1988, 9, 16, 0, 0)]\n [datetime.datetime(1979, 10, 16, 0, 0)\n  datetime.datetime(1988, 10, 16, 0, 0)]\n [datetime.datetime(1979, 11, 16, 0, 0)\n  datetime.datetime(1988, 11, 16, 0, 0)]\n [datetime.datetime(1979, 12, 16, 0, 0)\n  datetime.datetime(1988, 12, 16, 0, 0)]]'
     actual = '\x80\x02cnumpy.core.multiarray\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x01K\x0cK\x02\x86cnumpy\ndtype\nq\x04U\x02O8K\x00K\x01\x87Rq\x05(K\x03U\x01|NNNJ\xff\xff\xff\xffJ\xff\xff\xff\xffK?tb\x89]q\x06(cdatetime\ndatetime\nq\x07U\n\x07\xbb\x01\x10\x00\x00\x00\x00\x00\x00\x85Rq\x08h\x07U\n\x07\xc4\x01\x10\x00\x00\x00\x00\x00\x00\x85Rq\th\x07U\n\x07\xbb\x02\x10\x00\x00\x00\x00\x00\x00\x85Rq\nh\x07U\n\x07\xc4\x02\x10\x00\x00\x00\x00\x00\x00\x85Rq\x0bh\x07U\n\x07\xbb\x03\x10\x00\x00\x00\x00\x00\x00\x85Rq\x0ch\x07U\n\x07\xc4\x03\x10\x00\x00\x00\x00\x00\x00\x85Rq\rh\x07U\n\x07\xbb\x04\x10\x00\x00\x00\x00\x00\x00\x85Rq\x0eh\x07U\n\x07\xc4\x04\x10\x00\x00\x00\x00\x00\x00\x85Rq\x0fh\x07U\n\x07\xbb\x05\x10\x00\x00\x00\x00\x00\x00\x85Rq\x10h\x07U\n\x07\xc4\x05\x10\x00\x00\x00\x00\x00\x00\x85Rq\x11h\x07U\n\x07\xbb\x06\x10\x00\x00\x00\x00\x00\x00\x85Rq\x12h\x07U\n\x07\xc4\x06\x10\x00\x00\x00\x00\x00\x00\x85Rq\x13h\x07U\n\x07\xbb\x07\x10\x00\x00\x00\x00\x00\x00\x85Rq\x14h\x07U\n\x07\xc4\x07\x10\x00\x00\x00\x00\x00\x00\x85Rq\x15h\x07U\n\x07\xbb\x08\x10\x00\x00\x00\x00\x00\x00\x85Rq\x16h\x07U\n\x07\xc4\x08\x10\x00\x00\x00\x00\x00\x00\x85Rq\x17h\x07U\n\x07\xbb\t\x10\x00\x00\x00\x00\x00\x00\x85Rq\x18h\x07U\n\x07\xc4\t\x10\x00\x00\x00\x00\x00\x00\x85Rq\x19h\x07U\n\x07\xbb\n\x10\x00\x00\x00\x00\x00\x00\x85Rq\x1ah\x07U\n\x07\xc4\n\x10\x00\x00\x00\x00\x00\x00\x85Rq\x1bh\x07U\n\x07\xbb\x0b\x10\x00\x00\x00\x00\x00\x00\x85Rq\x1ch\x07U\n\x07\xc4\x0b\x10\x00\x00\x00\x00\x00\x00\x85Rq\x1dh\x07U\n\x07\xbb\x0c\x10\x00\x00\x00\x00\x00\x00\x85Rq\x1eh\x07U\n\x07\xc4\x0c\x10\x00\x00\x00\x00\x00\x00\x85Rq\x1fetb.'
     actual = np.loads(actual)
     self.assertNumpyAll(ret[1]['clt'].temporal.bounds_datetime, actual)
示例#56
0
    def run(self):
        video_input = self.get_input("videoInput")
        out1 = self.get_output("out1")
        out2 = self.get_output("out2")

        while self.running():
            frame_obj = video_input.read()
            frame = np.loads(frame_obj)

            out1.send(frame.dumps())
            out2.send(frame.dumps())
    def run(self):
        if self.observer:
            self.socket.sendto("I can see you.", self.add)
            while not self.close:
                sData = ""
                try:
                    data = self.socket.recv(self.buffer)
                    if not data:
                        continue

                    if data[0] != "b":
                        # print("wrong type index.")
                        continue

                    i = 1
                    while i < self.buffer and data[i] != "_":
                        i += 1

                    nb_packet_string = data[1:i]
                    if nb_packet_string.isdigit():
                        nb_packet = int(nb_packet_string)
                    else:
                        # print("wrong index.")
                        continue

                    sData += data[i + 1:]
                    for packet in range(1, nb_packet):
                        data, _ = self.socket.recvfrom(self.buffer)  # 262144 # 8192
                        if data[0] != "c":
                            # print("wrong type index continue")
                            continue

                        i = 1
                        while i < self.buffer and data[i] != "_":
                            i += 1

                        no_packet_string = data[1:i]
                        if no_packet_string.isdigit():
                            no_packet = int(no_packet_string)
                            # if no_packet != packet:
                                # print("Wrong no packet : %d" % packet)
                        else:
                            # print("wrong index continue.")
                            continue

                        sData += data[i + 1:]

                    self.observer(np.loads(sData))
                except Exception as e:
                    if type(e) is not exceptions.EOFError:
                        if not self.close:
                            logger.error("udp observer : %s", e)
        else:
            logger.error("self.observer is None.")
def talker(TCP_PORT, TCP_PORT):
    s = socket.socket((TCP_IP, TCP_PORT))
    while not rospy.is_shutdown():
        data = conn.recv(BUFFER_SIZE)
        if data:
            deserialize = np.loads(data)
            rospy.loginfo(deserialize)
            pos_publisher.publish(deserialize)
            conn.send(1)
        rate.sleep()
    conn.close()
示例#59
0
文件: datavstack.py 项目: quank/cms
def SafeSimpleStack(seq):
	'''
		Vertically stack sequences numpy record arrays. 
		Avoids some of the problems of numpy.v_stack
	'''

	names =  uniqify(ListUnion([list(s.dtype.names) for s in seq if s.dtype.names != None]))
	formats =  [max([s.dtype[att] for s in seq if s.dtype.names != None and att in s.dtype.names]).str for att in names]
	D = numpy.rec.fromarrays([ListUnion([s[att].tolist() if (s.dtype.names != None and att in s.dtype.names) else [nullvalue(format)] * len(s) for s in seq]) for (att,format) in zip(names,formats)], names = names)
	D = D.dumps()
	return numpy.loads(D)