class Collision:
def __init__(self, sensors, queue_size=2):
self.history = None
self.ready = False
self.sensors = sensors # [('center', object),...]
self.stopped = False
self.Q = Queue(maxsize=queue_size)
self.t = None
def start(self):
if self.t:
return
self.t = Thread(target=self.update, args=())
self.t.daemon = True
self.t.start()
def update(self):
while True:
if self.stopped == True:
return
result = {}
for sensor in self.sensors:
result[sensor[0]] = sensor[1].check_collision()
if self.Q.full():
self.Q.get()
self.Q.put(result)
#logger.info("Collision(): Info added to queue")
self.ready = True
sleep(2) # Required by UD Sensor Hardware
def stop(self):
self.stopped = True
self.t = None
def more(self):
return not self.Q.empty()
def ready(self):
return self.ready
def get(self, latest = False):
# logger.info("Collision Queue: " + str(self.Q.qsize()))
while latest:
if not self.Q.empty():
self.history = self.Q.get()
else:
break
else:
if not self.Q.empty():
self.history = self.Q.get()
return self.history
def clear_queue(self):
self.Q.clear()
class file():
def __init__(self):
self.__queue = Queue()
def SetPath(self, path):
self.__path = path
def GetPath(self):
return self.__path
def GetSize(self):
fsize = os.path.getsize(self.__path)
fsize = fsize / float(1024)
return round(fsize, 2)
#打开文件读取数据
def Read(self):
self.__queue.clear()
file_content = None
try:
f = open(self.__path, "rb") #直接以二进制读入，传输时不用encode和decode了
file_content = f.read()
f.close()
except Exception as ret:
print("没有此文件")
def add_node_to_tree(
self,
data): #if given a list, how to add all the elements in the list
if self.root == None:
self.root = TreeNode(data)
self.no_of_nodes += 1
#print "root: ",self.root.data
else:
q = Queue()
node = self.root
q.enqueue([node])
while not q.IsQueueEmpty():
node = q.dequeue()
if node.left is None:
node.left = TreeNode(data)
self.no_of_nodes += 1
#print node.left.data
q.clear()
elif node.right is None:
node.right = TreeNode(data)
self.no_of_nodes += 1
#print node.right.data
q.clear()
else:
q.enqueue([node.left, node.right])
def main():
queue = Queue()
queue.enqueue('hello')
queue.enqueue('dog')
queue.enqueue(3)
print(queue.display())
queue.dequeue()
print(queue.display())
queue.dequeue()
print(queue.display())
queue.dequeue()
print(queue.display())
queue.dequeue()
queue.enqueue('world')
queue.enqueue('cat')
queue.enqueue(1)
print(queue.size())
print(queue.display())
queue.clear()
print(queue.display())
class GraylogConnection(object):
"""Used by GraylogHandler to keep track of connections to Graylog servers.
Stores messages in a circular buffer of limited length until connection
is established and the messages are sent to the server. Spawns a thread
in order to enable connection to multipe Graylog servers."""
#----------------------------------------------------------------------
def __init__(self, host, port, queue_len):
"""Inits the Graylog connection using the provided host and port. The
length of the message queue is set with queue_len.
"""
self.queue_len = queue_len
self.message_queue = Queue()
self.status_queue = Queue()
self.conf_queue = Queue()
self.status_str = "Not connected"
thread_kwargs = {
"host": host,
"port": port,
"msg_queue": self.message_queue,
"stat_queue": self.status_queue,
"conf_queue": self.conf_queue
}
self.thread = threading.Thread(target=thread_function,
kwargs=thread_kwargs)
self.thread.daemon = True
self.thread.start()
#----------------------------------------------------------------------
def __del__(self):
"""Destructor. Tells the thread to exit and then waits for it to do so."""
self.conf_queue.put("exit")
self.thread.join()
#----------------------------------------------------------------------
def SendMsg(self, msg):
"""Simply sends a log message. Tells the thread to exit if the message
is 'exit'."""
if (msg == "exit"):
self.message_queue.clear()
if (self.message_queue.qsize() >= self.queue_len):
return
if (type(msg) == str):
msg = bytearray(msg.encode("utf-8"))
self.message_queue.put(msg)
#----------------------------------------------------------------------
@property
def status(self):
"""Returns the connection status."""
while (not self.status_queue.empty()):
self.status_str = self.status_queue.get()
return self.status_str
#----------------------------------------------------------------------
@property
def messages_in_queue(self):
"""Returns the number of messages in the message queue."""
return self.message_queue.qsize()
def test_queue_clear(self):
'''
test the clear() method
'''
q = Queue()
q.enqueue(3)
q.enqueue(4)
q.enqueue(13)
q.clear()
self.assertIsNone(q.head)
self.assertIsNone(q.tail)
def test_queue_clear(self): ''' test the clear() method ''' q = Queue() q.enqueue(3) q.enqueue(4) q.enqueue(13) q.clear() self.assertIsNone(q.head) self.assertIsNone(q.tail)
def insert(self, k, v):
"""Inserts a node into the binary tree. A node is inserted at the bottom
most level using BFS to find the correct spot in order to keep the tree
balanced.
Time complexity: O(n)
Keyword arguments:
k - key of node
v - value of node
"""
node = BinaryNode(k, v)
if not self.root:
self.root = node
else:
# Perform BFS for the first empty spot to insert the new node
queue = Queue()
queue.enqueue(self.root)
while not queue.is_empty():
n = queue.dequeue()
if n.left_child and n.right_child:
# n is an internal node (keeps binary structure)
queue.enqueue(n.left_child)
queue.enqueue(n.right_child)
else:
# Add child
if n.left_child:
n.right_child = node
else:
n.left_child = node
# Empty queue out as to not continue processing further nodes
queue.clear()
self.size += 1
return node
class BFS:
'''Breadth Fisrt Search. Each BFS object is initialized for a source vertex. BFS methods are first applied to
the source vertex, followed by those with a path to the source in the Graph.'''
def __init__(self, vertex):
self.root = vertex
self._visited = [vertex]
self._edgeTo = {vertex.name: vertex}
self._q = Queue()
self._q.enqueue(vertex)
def _bfs(self, w):
while len(self._q) != 0:
u = self._q.dequeue()
for v in u.ajcList:
if v not in self._visited:
self._visited.append(v)
self._edgeTo[v.name] = u
self._q.enqueue(v)
if v is w:
self._q.clear()
break
self._bfs(w)
def search(self, w):
'''Starting from source, breadth first search for w.'''
if self.root is w:
return [w]
self._bfs(w)
return self._path(w)
def _path(self, w):
''' Creat path from source to w in the BFS tree.'''
s = Stack()
while self._edgeTo[w.name] is not w:
s.push(w)
w = self._edgeTo[w.name]
return [self.root] + [s.pop() for i in range(len(s))]
class BFS:
'''Breadth Fisrt Search. Each BFS object is initialized for a source vertex. BFS methods are first applied to
the source vertex, followed by those with a path to the source in the Graph.'''
def __init__(self, vertex):
self.root = vertex
self.visited = [vertex]
self.edgeTo = {vertex.room: vertex}
self._q = Queue()
self._q.enqueue(vertex)
def bfs(self, target):
while len(self._q) != 0:
u = self._q.dequeue()
for v in u.ajcList:
if v not in self.visited:
self.visited.append(v)
self.edgeTo[v.room] = u
self._q.enqueue(v)
if v.room == target:
self._q.clear()
break
self.bfs(target)
class TestStack(unittest.TestCase):
def setUp(self):
self.queue = Queue()
def test_init(self):
self.assertEqual(self.queue.get_size(), 0)
new_queue = Queue("Bob")
self.assertEqual(new_queue.get_size(), 1)
def test_enqueue(self):
self.queue.enqueue("Bob")
self.assertEqual(self.queue.get_size(), 1)
def test_dequeue(self):
self.queue.enqueue("Bob")
dequeued_item = self.queue.dequeue()
self.assertEqual(dequeued_item, "Bob")
another_dequeued_item = self.queue.dequeue()
self.assertIsNone(another_dequeued_item)
def test_peek(self):
self.queue.enqueue("Bob")
self.queue.enqueue("Bill")
self.queue.enqueue("Boris")
peeked_item = self.queue.peek()
self.assertEqual(peeked_item, "Bob")
def test_clear(self):
for i in range(0, 100):
self.queue.enqueue("Bob")
self.assertEqual(self.queue.get_size(), 100)
self.queue.clear()
self.assertEqual(self.queue.get_size(), 0)
def test_get_size(self):
self.assertEqual(self.queue.get_size(), self.queue.linked_list.size)
class FIFOQueue:
def __init__(self, multiprocess=False, is_deque=True, max_len=200):
if multiprocess:
is_deque = False
self._queue = None
self._size = 0 # qsize() might not be implemented for MP queue
self._use_deque = is_deque
self._use_mpqueue = multiprocess
if self._use_deque:
if max_len == 0:
max_len = None
self._queue = deque(maxlen=max_len)
else:
if max_len is None:
max_len = 0
if self._use_mpqueue:
self._queue = MPQueue(maxsize=max_len)
else:
self._queue = Queue(maxsize=max_len)
def clear(self):
self._size = 0
if self._use_deque:
self._queue.clear()
else:
while self._queue.get() is not None:
pass
def size(self):
if self._use_deque:
return len(self._queue)
try:
return self._queue.qsize()
except NotImplementedError:
return self._size
def put(self, x):
if self._use_deque:
self._queue.append(x)
else:
try:
self._queue.put_nowait(x)
self._size += 1
except:
return False
return True
def get(self):
if self._use_deque:
try:
return self._queue.popleft()
except:
return None
try:
x = self._queue.get_nowait()
except:
return None
self._size -= 1
return x
class Connection(object):
"""Abstracción de conexión. Maneja colas de entrada y salida de datos,
y una funcion de estado (task). Maneja tambien el avance de la maquina de
estados.
"""
def __init__(self, fd, address=''):
"""Crea una conexión asociada al descriptor fd"""
self.socket = fd
self.task = None # El estado de la maquina de estados
self.input = Queue()
self.output = Queue()
# Esto se setea a true para pedir al proxy que desconecte
self.remove = False
self.address = address
def fileno(self):
"""
Número de descriptor del socket asociado.
Este metodo tiene que existir y llamarse así
para poder pasar instancias
de esta clase a select.poll()
"""
return self.socket.fileno()
def direction(self):
"""
Modo de la conexión, devuelve uno de las constantes DIR_*;
también puede devolver None si el estado es el final
y no hay datos para enviar.
"""
# La cola de salida puede estar vacia por dos motivos:
# -1) Se enviaron todos los datos -> Remove es True
# -2) La cola de salida no esta lista AUN -> Sigue recibiendo
if self.output.data == "":
if self.remove: # (1)
return None # El estado es el final
else: # (2)
return DIR_READ # Sigue recibiendo
else: # La cola de salida esta lista para enviarse
return DIR_WRITE
def recv(self):
"""
Lee datos del socket y los pone en la cola de entrada.
También maneja lo que pasa cuando el remoto se desconecta.
Aqui va la unica llamada a recv() sobre sockets.
"""
try:
data = self.socket.recv(RECV_SIZE) # Receive
if data == "": # El remoto se ha desconectado
self.remove = True # Hay que removerlo
self.input.put(data) # Encola los datos recibidos
except socket_error:
self.send_error(INTERNAL_ERROR, "Internal Error")
self.remove = True
def send(self):
"""Manda lo que se pueda de la cola de salida"""
# Envia sended_size bytes
sended_size = self.socket.send(self.output.data)
# Elimina los datos enviados de la cola
self.output.remove(sended_size)
def close(self):
"""Cierra el socket. OJO que tambien hay que avisarle al proxy que nos
borre.
"""
self.socket.close()
self.remove = True
self.output.clear()
def send_error(self, code, message):
"""Funcion auxiliar para mandar un mensaje de error"""
logging.warning("Generating error response %s [%s]",
code, self.address)
self.output.put("HTTP/1.1 %d %s\r\n" % (code, message))
self.output.put("Content-Type: text/html\r\n")
self.output.put("\r\n")
self.output.put(
"<body><h1>%d ERROR: %s</h1></body>\r\n" % (code, message))
self.remove = True
class Connection(object):
"""Abstracción de conexión. Maneja colas de entrada y salida de datos,
y una funcion de estado (task). Maneja tambien el avance de la maquina de
estados.
"""
def __init__(self, fd, address=''):
"""Crea una conexión asociada al descriptor fd"""
self.socket = fd
self.task = None # El estado de la maquina de estados
self.input = Queue()
self.output = Queue()
# Esto se setea a true para pedir al proxy que desconecte
self.remove = False
self.address = address
def fileno(self):
"""
Número de descriptor del socket asociado.
Este metodo tiene que existir y llamarse así
para poder pasar instancias
de esta clase a select.poll()
"""
return self.socket.fileno()
def direction(self):
"""
Modo de la conexión, devuelve uno de las constantes DIR_*;
también puede devolver None si el estado es el final
y no hay datos para enviar.
"""
# La cola de salida puede estar vacia por dos motivos:
# -1) Se enviaron todos los datos -> Remove es True
# -2) La cola de salida no esta lista AUN -> Sigue recibiendo
if self.output.data == "":
if self.remove: # (1)
return None # El estado es el final
else: # (2)
return DIR_READ # Sigue recibiendo
else: # La cola de salida esta lista para enviarse
return DIR_WRITE
def recv(self):
"""
Lee datos del socket y los pone en la cola de entrada.
También maneja lo que pasa cuando el remoto se desconecta.
Aqui va la unica llamada a recv() sobre sockets.
"""
try:
data = self.socket.recv(RECV_SIZE) # Receive
if data == "": # El remoto se ha desconectado
self.remove = True # Hay que removerlo
self.input.put(data) # Encola los datos recibidos
except socket_error:
self.send_error(INTERNAL_ERROR, "Internal Error")
self.remove = True
def send(self):
"""Manda lo que se pueda de la cola de salida"""
# Envia sended_size bytes
sended_size = self.socket.send(self.output.data)
# Elimina los datos enviados de la cola
self.output.remove(sended_size)
def close(self):
"""Cierra el socket. OJO que tambien hay que avisarle al proxy que nos
borre.
"""
self.socket.close()
self.remove = True
self.output.clear()
def send_error(self, code, message):
"""Funcion auxiliar para mandar un mensaje de error"""
logging.warning("Generating error response %s [%s]", code,
self.address)
self.output.put("HTTP/1.1 %d %s\r\n" % (code, message))
self.output.put("Content-Type: text/html\r\n")
self.output.put("\r\n")
self.output.put("<body><h1>%d ERROR: %s</h1></body>\r\n" %
(code, message))
self.remove = True
class Camera():
def __init__(self,
camera_type,
camera_num=0,
resolution=(320, 240),
framerate=20,
rotation=0):
self.fps = None
self.ready = False
self.camera = None
self.camera_type = camera_type
self.stopped = False
self.Q = Queue(maxsize=2 * framerate)
self.t = None
self.history = None
self.rotation = rotation
self.resolution = resolution
self.framerate_ms = 1.0 / float(framerate)
if self.camera_type == PICAMERA:
self.camera = picamera.PiCamera()
if rotation:
self.camera.rotation = rotation
self.camera.resolution = resolution
self.camera.framerate = framerate
self.camera.sharpness = 0
self.camera.contrast = 0
self.camera.brightness = 65
self.camera.saturation = 0
self.camera.ISO = 0
self.camera.video_stabilization = True
self.camera.exposure_compensation = 0
self.camera.exposure_mode = 'auto'
self.camera.meter_mode = 'average'
self.camera.awb_mode = 'auto'
self.camera.image_effect = 'none'
self.camera.color_effects = None
#sleep(2)
#while self.camera.analog_gain < 1 or self.camera.digital_gain < 1:
# sleep(0.1)
#self.camera.exposure_mode = 'off'
#if self.camera.analog_gain < 1 or self.camera.digital_gain < 1:
# raise RuntimeError('low gains')
elif self.camera_type == USB:
w, h = resolution
self.camera = cv2.VideoCapture(camera_num)
self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, w)
self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, h)
#self.camera.set(cv2.cv.CV_CAP_PROP_FPS, framerate) # doesnt works, using sleep to maintain fps
else:
raise EnviormentError("Invalid camera type")
#logging.debug("CameraOne.__init__()")
def start(self):
if self.t:
return
f = None
if self.camera_type == PICAMERA:
f = self.update_picamera
else:
f = self.update_usb
self.t = Thread(target=f, args=())
self.t.daemon = True
self.t.start()
def update_picamera(self):
stream = PiRGBArray(self.camera)
image = self.camera.capture_continuous(stream,
format="bgr",
use_video_port=True)
start = time()
temp_fps = 0
while True:
if self.stopped:
return
frame = image.next()
# Framerate updater
if (time() - start) >= 1:
self.fps = temp_fps
temp_fps = 0
start = time()
temp_fps += 1
frame = frame.array
stream.truncate(0)
if self.Q.full():
self.Q.get()
self.Q.put(frame)
# logging.info("Camera(): Frame added to queue")
self.ready = True
def update_usb(self):
start = time()
temp_fps = 0
while True:
if self.stopped:
return
(grabbed, frame) = self.camera.read()
# Framerate updater
if (time() - start) >= 1:
self.fps = temp_fps
temp_fps = 0
start = time()
temp_fps += 1
if not grabbed:
self.stop()
return
if self.rotation != 0:
frame = cv2.flip(frame, self.rotation)
if self.Q.full():
self.Q.get()
self.Q.put(frame)
#logging.info("Camera(): Frame added to queue")
self.ready = True
#sleep(0.2)
sleep(self.framerate_ms
) # webcam doesn't go over 9 fps on Raspberry Pi
def stop(self):
self.stopped = True
if self.camera_type == USB:
self.camera.release()
else:
self.camera.close()
self.t = None
def more(self):
return not self.Q.empty()
def ready(self):
return self.ready
def get_frame(self, latest=False):
if latest and not self.Q.empty():
size = self.Q.qsize()
for i in range(size - 2): # Keep atleast x values in queue
self.Q.get()
return self.Q.get() #, size
else:
return self.Q.get(
timeout=10
) #, "Wait" # OpenCV throw select timeout after 10 sec
def clear_queue(self):
self.Q.clear()
def test_clear(self):
Q = Queue([4, 2, 1])
Q.clear()
self.assertEqual(str(Q), '[]')
self.assertEqual(Q.pop(), None)
from queue import Queue
q = Queue()
while True:
what = input("Push Pop Print Peek or Clear\n")
if what == "push":
q.push(input("Enter Value: "))
elif what == "pop":
print(q.pop())
elif what == "print":
q.printer()
elif what == "clear":
q.clear()
class Connection(object):
"""
Abstracción de conexión. Maneja colas de entrada y salida de datos,
y una función de estado (task). Maneja también el avance de la máquina de
estados.
"""
def __init__(self, fd, address=''):
"""
Crea una conexión asociada al descriptor fd.
"""
self.socket = fd
self.task = None # El estado de la maquina de estados.
self.input = Queue()
self.output = Queue()
# Se setea a true para pedir al proxy que desconecte.
self.remove = False
self.address = address
def fileno(self):
"""
Número de descriptor del socket asociado.
Este metodo tiene que existir y llamarse así para poder pasar
instancias de esta clase a select.poll().
"""
return self.socket.fileno()
def direction(self):
"""
Modo de la conexión, devuelve una de las constantes DIR_*; también
puede devolver None si el estado es el final y no hay datos
para enviar.
"""
if self.output.data:
return DIR_WRITE
elif self.task is not None:
return DIR_READ
else:
return None
def recv(self):
"""
Lee datos del socket y los pone en la cola de entrada.
También maneja lo que pasa cuando el remoto se desconecta.
Aquí va la única llamada a recv() sobre sockets.
"""
try:
data = self.socket.recv(BUFFSIZE)
self.input.put(data)
if len(data) == 0:
self.remove = True
except:
self.remove = True
def send(self):
"""
Manda lo que se pueda de la cola de salida.
"""
try:
bytes_sent = self.socket.send(self.output.data)
self.output.remove(bytes_sent)
except:
self.remove = True
self.output.clear()
def close(self):
"""
Cierra el socket. También hay que avisarle al proxy que borre.
"""
self.socket.close()
self.remove = True
self.output.clear()
def send_error(self, code, message):
"""
Función auxiliar para mandar un mensaje de error.
"""
logging.warning("Generating error response %s [%s]", code,
self.address)
self.output.put("HTTP/1.1 %d %s\r\n" % (code, message))
self.output.put("Content-Type: text/html\r\n")
self.output.put("\r\n")
self.output.put("<body><h1>%d ERROR: %s</h1></body>\r\n" %
(code, message))
self.remove = True
class Stream():
# TODO use Threads for output distribution
def __init__(self,stapModuleInstance, args = {}, interval = 0.1, withdraw=False):
self.id = id(self)
self.args = args
self.log = print if 'logStream' not in args else args['logStream']
self.name = stapModuleInstance.name
self.queue = Queue() # the input queue
self.receivers = []
self.interval = interval # check every x seconds for output in queue.
self.withdraw = withdraw # if True, drop incomming input if we have no listeners
self.thread = Thread(target=self.run)
self.thread.daemon = True
self.thread.running = True
self.thread.start()
stapModuleInstance.queue = self.queue
def __str__(self):
return "<Stream,name=%s,queue=%s,receivers=%s>" % (self.name, self.queue, self.receivers)
def register(self,stapLabModuleInstance):
if stapLabModuleInstance is not None:
if stapLabModuleInstance not in self.receivers:
self.receivers += [stapLabModuleInstance]
stapLabModuleInstance.queue = self.queue
self.log("registered %s to %s" % (str(stapLabModuleInstance), self.name))
else:
self.log("%s already in receivers of Stream %s" % (stapLabModuleInstance.name, self))
def unregister(self,module):
if module is not None:
try:
self.receivers.remove(module)
self.log("unregistered %s from %s" % (str(module), self.name))
except ValueError:
self.log("cannot unregister module %s to stream %s" %(module,self))
def emtpyQueue(self):
with self.queue.mutex:
self.queue.clear()
def run(self):
self.log("%s entering mainLoop" % self)
while self.thread.running:
if not self.queue.empty():
if len(self.receivers) > 0:
data = self.queue.get()
for receiver in self.receivers:
if receiver is not None:
receiver.enqData(data)
else:
if self.withdraw:
self.emptyQueue()
for receiver in self.receivers:
if not receiver.thread.running:
self.unregister(receiver)
sleep(self.interval)
self.log("%s leaving mainLoop" % self)
def stop(self):
self.thread.running = False
