def worker(self):
try:
signal.signal(signal.SIGHUP, signal.SIG_IGN)
signal.signal(signal.SIGINT, signal.SIG_IGN)
while self.maxreqs:
with suspended_signals(signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
# fixme - periodic hooks go here
pass
try:
conn, addr = self.sock.accept()
except (socket.timeout, socket.error):
continue
with suspended_signals(signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
log.debug('client %s:%d: connected', *addr)
self.maxreqs -= 1
try:
while True:
res = Response(conn)
try:
try:
req = Request(conn, timeout=self.timeout)
# hmm - it may not make sense to allow pipelining by default - look for magic header
if 'HTTP/1.1' == req.version and ('x-please-pipeline' not in req.headers or self.maxreqs is 0):
res.headers.set('Connection', 'close')
self.process(req, res)
except HTTPError as e:
log.info('HTTP error %s', e)
res.error(e.code, e.message, *e.headers)
except ErrorCompleted:
pass
ended = time.time()
log.debug('response/finished ms: %d/%d', res.delay_ms, int((ended - res.start) * 1000))
if 'HTTP/1.1' != req.version:
raise Disconnected('not HTTP/1.1', level='debug')
elif res.headers.contains('Connection', 'close'):
raise Disconnected('handler closed', level='debug')
except Disconnected as e:
pass
except socket.timeout:
log.warning('client %s:%d: timed out', *addr)
except Exception as e:
info = sys.exc_info()
log.error('Unhandled exception: %s', traceback.print_exception(*info))
sys.exit(1)
finally:
try:
conn.shutdown(socket.SHUT_RDWR)
except Exception:
pass
conn.close()
log.debug('client %s:%d: finished', *addr)
except Graceful:
# if e.reload:
# log.info("*master(%d): re-exec!", os.getpid())
# log.warn(repr(cmd))
#if __package__ is not None:
#sys.argv[0] = '-m%s' % __loader__.name
#os.execl(sys.executable, sys.executable, *sys.argv)
pass
def main_loop(fn, period=None):
exit = Value(ctypes.c_bool)
def sigint_handler(signal, frame):
print('Picked up interrupt, pausing at next break point')
exit.value = True
signal.signal(signal.SIGINT, sigint_handler)
def sigterm_handler(signal, frame):
print('Picked up sigterm, pausing at next break point')
exit.value = True
signal.signal(signal.SIGTERM, sigterm_handler)
sleep_until = 0
while not exit.value:
if period is not None:
if time.time() < sleep_until:
time.sleep(min(1, sleep_until - time.time()))
continue
sleep_until = time.time() + period
with suspended_signals(signal.SIGINT, signal.SIGTERM):
try:
fn()
except ExitLoop:
break
if period is not None:
total_sleep = sleep_until - time.time()
if total_sleep > 1:
logger.info('Waiting %.1f until loop period' % total_sleep)
def plot_thread(img, n_channel, width, height):
with pysigset.suspended_signals(
signal.SIGCHLD): # Disable signals here!
import matplotlib
matplotlib.use('TKAgg')
import matplotlib.pyplot as pl
fig = pl.figure()
b = fig.add_subplot(111)
if n_channel == 1:
b.imshow(img, cmap=pl.cm.Greys_r, interpolation='nearest')
elif n_channel == 3:
b.imshow(img, interpolation='nearest')
def format_coord(x, y):
col = int(x + 0.5)
row = int(y + 0.5)
if col >= 0 and col < width and row >= 0 and row < height:
if n_channel == 1:
z = img[row, col]
return '(%d, %d), [%1.2f]' % (col, row, z)
elif n_channel == 3:
z0 = img[row, col, 0]
z1 = img[row, col, 1]
z2 = img[row, col, 2]
return '(%d, %d), [%1.2f, %1.2f, %1.2f]' % (col, row,
z0, z1, z2)
else:
return 'x=%d, y=%d' % (col, row)
b.format_coord = format_coord
pl.show()
pass
def __init__(self):
with pysigset.suspended_signals(signal.SIGCHLD):
super(cv_imshow,
self).__init__('cv_imshow', gdb.COMMAND_SUPPORT,
gdb.COMPLETE_SYMBOL)
self.dont_repeat()
pass
def save(self, fname=None):
self.concat()
self.enumerate()
with pysigset.suspended_signals(signal.SIGCHLD):
logfile = open(fname, 'wb') if fname else sys.stdout
logfile.write('journal=' + str(self))
logfile.close()
def on_status(self, status):
with suspended_signals(SIGINT):
self.last_id = status.id
self.facet.emit(status._json)
self.progress.next(status)
if self.finished_fn(status):
progress.finish()
return False
def on_status(self, status):
with suspended_signals(SIGINT):
self.last_id = status.id
self.facet.emit(status._json)
self.progress.next(status)
if self.finished_fn(status):
progress.finish()
return False
def run_listener(name, cls, arg):
with pysigset.suspended_signals(signal.SIGCHLD):
log.debug("Starting listener for {} socket on {}".format(
name, str(arg)))
s = cls(*arg)
t = threading.Thread(target=s.serve_forever)
t.start()
self.threads.append(t)
self.listeners.append(s)
def blobget(arg):
"""Diplays the content of an opencv image"""
# Access the variable from gdb.
args = gdb.string_to_argv(arg)
val = gdb.parse_and_eval(args[0])
with pysigset.suspended_signals(signal.SIGCHLD):
blob_info = get_blob_info(val)
return get_blob_vals(*blob_info)
def run(self):
signals = {signal.SIGCHLD: self.process_cycle,
signal.SIGTERM: self.shutdown,
signal.SIGINT: self.shutdown}
with pysigset.suspended_signals(*signals.keys()):
for signo, handler in signals.items():
signal.signal(signo, handler)
self.respawn()
while self.running:
pysigset.sigsuspend(pysigset.SIGSET())
def initialize_window():
##
# Initialize imagewatch window
with pysigset.suspended_signals(signal.SIGCHLD):
# By default, my new threads will be the ones receiving the precious
# signals from the operating system. These signals should go to GDB so
# it could do its thing, and since it doesnt get them, my thread will
# make gdb hang. The solution is to configure the new thread to forward
# the signal back to the main thread, which is done by pysigset.
wnd_thread_instance=threading.Thread(target=lib.initialize_window, args=(FETCH_BUFFER_CBK_TYPE(plot_variable_cbk),))
wnd_thread_instance.daemon=True
wnd_thread_instance.start()
pass
pass
def initialize_window():
##
# Initialize imagewatch window
with pysigset.suspended_signals(signal.SIGCHLD):
# By default, my new threads will be the ones receiving the precious
# signals from the operating system. These signals should go to GDB so
# it could do its thing, and since it doesnt get them, my thread will
# make gdb hang. The solution is to configure the new thread to forward
# the signal back to the main thread, which is done by pysigset.
wnd_thread_instance=threading.Thread(target=lib.initialize_window, args=(FETCH_BUFFER_CBK_TYPE(plot_variable_cbk),))
wnd_thread_instance.daemon=True
wnd_thread_instance.start()
pass
pass
def invoke(self, arg, from_tty):
# Access the variable from gdb.
args = gdb.string_to_argv(arg)
val = gdb.parse_and_eval(args[0])
with pysigset.suspended_signals(signal.SIGCHLD):
if str(val.type.strip_typedefs()) == 'IplImage *':
img_info = self.get_iplimage_info(val)
else:
img_info = self.get_cvmat_info(val)
if img_info: self.show_image(*img_info)
self.dont_repeat()
pass
def cvget(arg):
"""Diplays the content of an opencv image"""
# Access the variable from gdb.
args = gdb.string_to_argv(arg)
val = gdb.parse_and_eval(args[0])
with pysigset.suspended_signals(signal.SIGCHLD):
if str(val.type.strip_typedefs()) == 'IplImage *':
img_info = get_iplimage_info(val)
else:
img_info = get_cvmat_info(val)
if img_info:
return get_vals(*img_info)
return None
def inner(*args, **kwargs):
try:
import gdb
PROTECT = True
except ImportError:
PROTECT = False
if sys.platform == 'darwin':
PROTECT = False
if PROTECT:
import pysigset
with pysigset.suspended_signals(signal.SIGCHLD):
return func(*args, **kwargs)
else:
return func(*args, **kwargs)
def __init__(self):
if not is_gdb_version_correct():
return
if not is_python_version_correct():
return
gdb_print('\nmcgdb version: {major}.{minor}\n'.format(
major=MCGDB_VERSION.major, minor=MCGDB_VERSION.minor))
gdb_print('python version: {major}.{minor}.{micor}\n'.format(
major=sys.version_info.major,
minor=sys.version_info.minor,
micor=sys.version_info.micro))
gdb_print('gdb version: {VERSION}\n'.format(VERSION=gdb.VERSION))
gdb_print(get_prompt())
gdb_rfd, gdb_wfd = os.pipe(
) #Through gdb_[rw]fd main pythread will be send commands to another thread
self.gdb_wfd = gdb_wfd
gdb.execute('set pagination off', False, False)
gdb.execute('source {}'.format(PATH_TO_DEFINES_MCGDB))
gethread = GEThread(gdb_rfd, main_thread_ident)
with pysigset.suspended_signals(signal.SIGCHLD):
event_thread = threading.Thread(
target=gethread,
args=()) #this thread will be communicate with editors
event_thread.start()
self.event_thread = event_thread
#unused events commented
#gdb.events.cont.connect( self.notify_gdb_cont )
gdb.events.exited.connect(self.notify_gdb_exited)
gdb.events.stop.connect(self.notify_gdb_stop)
gdb.events.new_objfile.connect(self.notify_gdb_new_objfile)
gdb.events.clear_objfiles.connect(self.notify_gdb_clear_objfiles)
#gdb.events.inferior_call_pre.connect( self.notify_gdb_inferior_call_pre )
#gdb.events.inferior_call_post.connect( self.notify_gdb_inferior_call_post )
gdb.events.memory_changed.connect(self.notify_gdb_memory_changed)
gdb.events.register_changed.connect(self.notify_gdb_register_changed)
gdb.events.breakpoint_created.connect(
self.notify_gdb_breakpoint_created)
gdb.events.breakpoint_deleted.connect(
self.notify_gdb_breakpoint_deleted)
gdb.events.breakpoint_modified.connect(
self.notify_gdb_breakpoint_modified)
for win_name in ['src', 'aux', 'asm']:
if win_name in WIN_LIST:
self.open_window(win_name)
def run(self):
config = self.config["imap"]
server = imapclient.IMAPClient(config["server"], port=config["port"], ssl=config["ssl"])
server.login(config["username"], config["password"])
server.debug=config.get("debug", False)
while True:
target_folder = "Hochgeladen {0}".format( datetime.date.today().year )
if not server.folder_exists(target_folder):
server.create_folder(target_folder)
server.subscribe_folder(target_folder)
select_info = server.select_folder('INBOX')
if select_info[b"EXISTS"]:
messages = server.search(['NOT', 'DELETED', 'NOT', 'SEEN'])
with suspended_signals(SIGINT, SIGTERM):
response = server.fetch(messages, ['RFC822'])
for msgid, data in response.items():
body = data[b'RFC822']
target = None
result = PROCESSING_RESULT.ERROR
try:
message = email.message_from_bytes(body)
result = self.handle_mail(message)
except:
self.logger.exception("Fehler beim Bearbeiten der Mail {0}".format(msgid))
finally:
if result is PROCESSING_RESULT.UPLOADED:
server.add_flags(msgid, [imapclient.SEEN])
server.copy(msgid, target_folder)
server.delete_messages(msgid)
server.expunge()
elif result in (PROCESSING_RESULT.IGNORE, PROCESSING_RESULT.OTHER):
server.remove_flags(msgid, [imapclient.SEEN])
server.idle()
server.idle_check(timeout=300) # Do a normal poll every 5 minutes, just in case
server.idle_done()
def resize(path, outpath):
with suspended_signals(SIGINT, SIGTERM):
try:
fh = os.open(outpath, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0666)
except OSError as e:
if e.errno == errno.EEXIST:
return
else:
raise
try:
with os.fdopen(fh, 'w') as out:
img = Image.open(path)
box = (299, 299)
#calculate the cropping box and get the cropped part
x1 = y1 = 0
x2, y2 = img.size
wRatio = 1.0 * x2 / box[0]
hRatio = 1.0 * y2 / box[1]
if hRatio > wRatio:
y1 = int(y2 / 2 - box[1] * wRatio / 2)
y2 = int(y2 / 2 + box[1] * wRatio / 2)
else:
x1 = int(x2 / 2 - box[0] * hRatio / 2)
x2 = int(x2 / 2 + box[0] * hRatio / 2)
img = img.crop((x1, y1, x2, y2))
img.thumbnail(box, Image.LANCZOS)
# This is necessary when saving to PNG, as it doesn't support CMYK
if img.mode == "CMYK":
img = img.convert("RGB")
img.save(out, "PNG", optimize=True)
# TensorFlow doesn't support webp yet, so we'll go with the larger png
#img.save(out, "WebP", lossless=True)
except Exception as e:
sys.stdout.write('failed:' + path + ',' +
str(e).replace('\n', '\\n') + '\n')
try:
os.remove(outpath)
except OSError:
pass
def initialize_window(self):
"""
Launch the ImageWatch window.
"""
##
# Initialize imagewatch window
with pysigset.suspended_signals(signal.SIGCHLD):
# By default, my new threads will be the ones receiving the
# precious signals from the operating system. These signals should
# go to GDB so it could do its thing, and since it doesnt get them,
# my thread will make gdb hang. The solution is to configure the
# new thread to forward the signal back to the main thread, which
# is done by pysigset.
wnd_thread_instance = threading.Thread(target=self._ui_thread,
args=(FETCH_BUFFER_CBK_TYPE(
self.plot_variable), ))
wnd_thread_instance.daemon = True
wnd_thread_instance.start()
def put(self, item):
"""
Put request from client that is passed from the server module
:param item: a dictionary with "key", "value", "serverId", "timeStamp", "messageId"
:return:
"""
id = str(uuid.uuid1())
item['messageId'] = id
# log.msg("Key {} received: {}".format(item["key"], item))
with suspended_signals(SIGKILL, SIGINT, SIGTERM):
# Signals (SIGKILL, SIGINT, SIGTERM) are blocked here
self.fileDict.put(item)
self.writeLog[id] = ["put", item, list(self.receiptVector)]
# Any pending signal is fired now ...
for i in range(config.NUM_SERVER):
if i != self.serverProxy.serverId:
self.serverProxy.sendMessage({
"ReceiverId": i,
"MessageId": id,
"Method": "Put",
"Payload": item
})
def _search(self, query_terms, query_ops, page_limit, progress, facet):
# Are we resuming after an error
if self.last_id:
print('Restarting with id={0}'.format(tg.last_id))
query_ops['max_id']=self.last_id
# max out tweets per page
if 'count' not in query_ops:
query_ops['count']=1000
q = '(' + ' OR '.join(query_terms) + ')'
for page in tweepy.Cursor(self.api.search,
q=urllib.quote_plus(q),
**query_ops).pages(page_limit):
# Block/unblock signals between pages, to allow responsive ctrl-c
# while honoring syntactic boundaries
with suspended_signals(SIGINT):
for tweet in page:
facet.emit(tweet._json)
if 'id' in tweet._json:
last_id = tweet._json['id']
last_date = tweet.created_at.date()
progress.next(tweet)
def _search(self, query_terms, query_ops, page_limit, progress, facet):
# Are we resuming after an error
if self.last_id:
print('Restarting with id={0}'.format(tg.last_id))
query_ops['max_id'] = self.last_id
# max out tweets per page
if 'count' not in query_ops:
query_ops['count'] = 1000
q = '(' + ' OR '.join(query_terms) + ')'
for page in tweepy.Cursor(self.api.search,
q=urllib.quote_plus(q),
**query_ops).pages(page_limit):
# Block/unblock signals between pages, to allow responsive ctrl-c
# while honoring syntactic boundaries
with suspended_signals(SIGINT):
for tweet in page:
facet.emit(tweet._json)
if 'id' in tweet._json:
last_id = tweet._json['id']
last_date = tweet.created_at.date()
progress.next(tweet)
def daemon(self, poll=250, maxopen=1000):
poll /= 1000.0
ticker = self.ticker()
todo = deque()
# count fds in use - just check first 100 or so
pad = 0
for fd in xrange(0, 100):
try:
os.fstat(fd)
pad += 1
except:
pass
# check limits
soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
if maxopen + pad > soft:
soft = min(maxopen + pad, hard)
resource.setrlimit(resource.RLIMIT_NOFILE, (soft, hard))
maxopen = soft - pad
map_age = 0
log.info('using %d max open graphs' % maxopen)
while True:
next(ticker)
sleep(poll)
map_age += poll
if map_age >= 60:
self.db.remap()
map_age = 0
self.db.sync(force=True)
with self.context(write=False) as ctx:
try:
if ctx.updatedDB.empty:
continue
except KeyError:
continue
# Note - we assume user is not using DB_WRITEMAP which is reasonable because:
# LemonGraph explicitly disables that
# Otherwise, we might have to mmap the whole region and msync it - maybe?
# Opening it via LemonGraph adds overhead, burns double the file descriptors, and
# currently explodes if I try to set RLIMIT_NOFILE > 2050. I know not why.
# We also assume that fdatasync() is good, which it is for Linux >= 3.6
count = 0
backlog = True
while backlog:
with suspended_signals(signal.SIGTERM, signal.SIGINT,
signal.SIGHUP):
try:
log.debug("syncing")
with self.context(write=True) as ctx:
uuids = ctx.updatedDB.pop(n=maxopen)
for uuid in uuids:
age = ctx.updatedDB_idx.pop(uuid)
try:
fd = os.open(self.graph_path(uuid),
os.O_RDONLY)
todo.append(fd)
except OSError as e:
# may have been legitimately deleted already
if e.errno != errno.ENOENT:
log.warning(
'error syncing graph %s: %s', uuid,
str(e))
count += len(uuids)
backlog = len(ctx.updatedDB)
for fd in todo:
os.fdatasync(fd)
finally:
for fd in todo:
os.close(fd)
todo.clear()
log.info("synced %d, backlog %d, age %.1fs", count, backlog,
time() - age)
def daemon(self, poll=250, maxopen=1000):
poll /= 1000.0
wrote = None
ticker = self.ticker()
todo = deque()
# count fds in use - just check first 100 or so
pad = 0
for fd in xrange(0, 100):
try:
os.fstat(fd)
pad += 1
except:
pass
# check limits
soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
if maxopen + pad > soft:
soft = min(maxopen + pad, hard)
resource.setrlimit(resource.RLIMIT_NOFILE, (soft, hard))
maxopen = soft - pad
map_age = 0
log.info('using %d max open graphs' % maxopen)
while True:
ticker.next()
sleep(poll)
map_age += poll
if map_age >= 60:
self.db.remap()
map_age = 0
self.db.sync(force=True)
with self.context(write=False) as ctx:
try:
if ctx.updatedDB.empty:
continue
except KeyError:
continue
# Note - we assume user is not using MDB_WRITEMAP which is reasonable because:
# LemonGraph does not currently expose that
# If it did, we might have to mmap the whole region and msync it - maybe?
# Opening it via LemonGraph adds overhead, burns double the file descriptors, and
# currently explodes if I try to set RLIMIT_NOFILE > 2050. I know not why.
# We also assume that fdatasync() is good, which it is for Linux >= 3.6
count = 0
backlog = True
while backlog:
with suspended_signals(signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
try:
log.debug("syncing")
with self.context(write=True) as ctx:
uuids = ctx.updatedDB.pop(n=maxopen)
for uuid in uuids:
age = ctx.updatedDB_idx.pop(uuid)
try:
fd = os.open(self.graph_path(uuid), os.O_RDONLY)
todo.append(fd)
except OSError as e:
# may have been legitimately deleted already
if e.errno != errno.ENOENT:
log.warning('error syncing graph %s: %s', uuid, str(e))
count += len(uuids)
backlog = len(ctx.updatedDB)
for fd in todo:
os.fdatasync(fd)
finally:
for fd in todo:
os.close(fd)
todo.clear()
log.info("synced %d, backlog %d, age %.1fs", count, backlog, time() - age)
def uninterruptible_section():
with pysigset.suspended_signals(signal.SIGINT):
yield
def run(self):
self.imap_client = imapclient.IMAPClient(settings.IMAP_HOSTNAME,
port=settings.IMAP_PORT,
ssl=settings.IMAP_SSL)
self.imap_client.login(settings.IMAP_USERNAME, settings.IMAP_PASSWORD)
self.imap_client.debug = settings.IMAP_DEBUG
known_mails = set()
first_run = True
while True:
mail_info = set()
select_info = self.imap_client.select_folder("INBOX")
if select_info[b"EXISTS"]:
messages = self.imap_client.search(
["NOT", "DELETED", "NOT", "SEEN"])
with suspended_signals(SIGINT, SIGTERM):
response = self.imap_client.fetch(messages, ["ENVELOPE"])
for msgid, data in response.items():
envelope = data[b"ENVELOPE"]
mail_info.add("{:%Y-%m-%d %H:%M:%S} - {}".format(
envelope.date,
envelope.subject[:30].decode("us-ascii",
errors="replace")))
new_mails = mail_info.difference(known_mails)
if new_mails and not first_run:
subject = "{0} neue Mail(s) eingegangen".format(
len(new_mails))
message = "Folgende Mails sind dazugekommen\n\n" + (
"\n * ".join(sorted(list(new_mails)))) + "\n"
if settings.SMTP_SSL:
smtpfactory = smtplib.SMTP_SSL
else:
smtpfactory = smtplib.SMTP
smtp_con = smtpfactory(host=settings.SMTP_HOSTNAME,
port=settings.SMTP_PORT)
if settings.SMTP_STARTTLS:
smtp_con.starttls()
smtp_con.login(settings.SMTP_USERNAME,
settings.SMTP_PASSWORD)
smtp_con.sendmail(
to_addrs=[settings.NOTIFICATION_TO],
from_addr=settings.NOTIFICATION_FROM,
msg=dedent("""\
From: {from_}
To: {to}
Date: {date}
Message-ID: {msgid}
Subject: {subject}
{message}
""").format(
from_=settings.NOTIFICATION_FROM,
to=settings.NOTIFICATION_TO,
date=email.utils.formatdate(),
msgid=str(uuid.uuid4()) + "." +
settings.NOTIFICATION_FROM,
subject=subject,
message=message,
),
)
smtp_con.quit()
known_mails = mail_info
first_run = False
self.imap_client.idle()
self.imap_client.idle_check(
timeout=300) # Do a normal poll every 5 minutes, just in case
self.imap_client.idle_done()
def show_image(width, height, n_channel, line_step, data_address,
data_symbol):
""" Copies the image data to a PIL image and shows it.
Args:
width: The image width, in pixels.
height: The image height, in pixels.
n_channel: The number of channels in image.
line_step: The offset to change to pixel (i+1, j) being
in pixel (i, j), in bytes.
data_address: The address of image data in memory.
data_symbol: Python struct module code to the image data type.
"""
width = int(width)
height = int(height)
n_channel = int(n_channel)
line_step = int(line_step)
data_address = int(data_address)
infe = gdb.inferiors()
memory_data = infe[0].read_memory(data_address, line_step * height)
# Calculate the memory padding to change to the next image line.
# Either due to memory alignment or a ROI.
if data_symbol in ('b', 'B'):
elem_size = 1
elif data_symbol in ('h', 'H'):
elem_size = 2
elif data_symbol in ('i', 'f'):
elem_size = 4
elif data_symbol == 'd':
elem_size = 8
padding = line_step - width * n_channel * elem_size
# Format memory data to load into the image.
image_data = []
if n_channel == 1:
mode = 'L'
fmt = '%d%s%dx' % (width, data_symbol, padding)
for line in chunker(memory_data, line_step):
image_data.extend(struct.unpack(fmt, line))
elif n_channel == 3:
mode = 'RGB'
fmt = '%d%s%dx' % (width * 3, data_symbol, padding)
for line in chunker(memory_data, line_step):
image_data.extend(struct.unpack(fmt, line))
else:
gdb.write('Only 1 or 3 channels supported\n', gdb.STDERR)
return
# Fit the opencv elemente data in the PIL element data
if data_symbol == 'b':
image_data = [i + 128 for i in image_data]
elif data_symbol == 'H':
image_data = [i >> 8 for i in image_data]
elif data_symbol == 'h':
image_data = [(i + 32768) >> 8 for i in image_data]
elif data_symbol == 'i':
image_data = [(i + 2147483648) >> 24 for i in image_data]
elif data_symbol in ('f', 'd'):
# A float image is discretized in 256 bins for display.
max_image_data = max(image_data)
min_image_data = min(image_data)
img_range = max_image_data - min_image_data
if img_range > 0:
image_data = [int(255 * (i - min_image_data) / img_range) \
for i in image_data]
else:
image_data = [0 for i in image_data]
if n_channel == 3:
# OpenCV stores the channels in BGR mode. Convert to RGB while packing.
image_data = list(zip(*[image_data[i::3] for i in [2, 1, 0]]))
img = None
if mode == 'L':
img = np.reshape(image_data, (height, width)).astype(np.uint8)
elif mode == 'RGB':
img = np.reshape(image_data,
(height, width, 3)).astype(np.uint8)
import threading
with pysigset.suspended_signals(
signal.SIGCHLD): # Disable signals here!
plot_thread_instance = threading.Thread(
target=plot_thread, args=[img, n_channel, width, height])
plot_thread_instance.daemon = True
plot_thread_instance.start()
plot_thread_instance.join()
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import pysigset, signal # Import these packages!
with pysigset.suspended_signals(signal.SIGCHLD): # Disable signals here!
from builtins import str as text
from builtins import range
import gdb
import numpy as np
import struct
def chunker(seq, size):
return (seq[pos:pos + size] for pos in range(0, len(seq), size))
def plot_thread(img, n_channel, width, height):
with pysigset.suspended_signals(
signal.SIGCHLD): # Disable signals here!
import matplotlib
matplotlib.use('TKAgg')
import matplotlib.pyplot as pl
laser = Driver(port)
def signal_handler(signal, frame):
print('You pressed Ctrl+C!')
laser.laserOff()
time.sleep(5)
sys.exit(0)
if __name__ == '__main__':
signal.signal(signal.SIGINT, signal_handler)
print(laser.getSensorState())
laser.laserOn()
plt.ion()
while True:
with suspended_signals(SIGINT, SIGTERM):
angles, distances, _ = laser.getScan()
for i in range(len(angles)):
if angles[i] < 0:
angles[i] += 360
angles[i] = angles[i] * np.pi / 180
plt.gcf().clear()
plt.polar(angles, distances, color='r')
plt.pause(0.0001)
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import pysigset, signal
with pysigset.suspended_signals(signal.SIGCHLD):
from builtins import str as text
from builtins import range
import gdb
#import matplotlib
#matplotlib.use('TKAgg')
#import matplotlib.pyplot as pl
import numpy as np
import struct
##pl.ion()
def get_cvmat_info(val):
