def __init__(self, fmt, maxsize):
self.fmt = fmt
self.itemsize = struct.calcsize(fmt)
self.maxsize = maxsize
self.values = memoryview(RawArray("b", maxsize * self.itemsize))
self.start = RawValue(ctypes.c_longlong, 0)
self.startlock = multiprocessing.Lock()
self.getsem = multiprocessing.Semaphore(0)
self.stop = RawValue(ctypes.c_longlong, 0)
self.stoplock = multiprocessing.Lock()
self.putsem = multiprocessing.Semaphore(maxsize)
def __init__(self):
params = {
'chords_amp': RawValue(ctypes.c_float),
'chords_chroma': RawArray(ctypes.c_float, 12 * [0.]),
'chords_mfcc': RawArray(ctypes.c_float, 64 * [0.]),
'chords_dissonance': RawValue(ctypes.c_float),
'bass_amp': RawValue(ctypes.c_float),
'bass_pitch': RawValue(ctypes.c_float),
'bass_has_pitch': RawValue(ctypes.c_float),
'drums_amp': RawValue(ctypes.c_float),
'drums_onset': RawValue(ctypes.c_float),
'drums_centroid': RawValue(ctypes.c_float),
}
params['chords_amp'].value = 0.
params['chords_dissonance'].value = 0.
params['bass_amp'].value = 0.
params['bass_pitch'].value = 0.
params['bass_has_pitch'].value = 0.
params['drums_amp'].value = 0.
params['drums_onset'].value = 0.
params['drums_centroid'].value = 0.
self.generator = Generator(params)
self.osc = OSCServer(params)
self.exit = Event()
def __init__(self, total: int, length: int, precision: int = 0) -> None:
self.bar_length = length
# Using synchronized Values allows us to keep the same value for all child processes. No
# need for locks, since access to __call__ should always be externally synchronized anyway.
self.first = RawValue(c_bool, True)
self.loaded = RawValue(c_size_t, 0)
self.total = total
if DEBUG:
self.total_str = f"(<DEBUG>{{}}/{self.total}) "
# Display new_percentage next to loading bar:
self.perc = RawValue(c_float, 0.)
self.precision = precision
self.format = max(0, self.precision)
# Number of "full" characters in the loading bar:
self.fill = RawValue(c_ubyte, 0)
def __init__(self, _v=None, maxsize=10240, serializing=json, szarg=None):
class ShareStructure(ctypes.Structure):
_fields_ = [("len", ctypes.c_long), ("md5", ctypes.c_char * 32),
("data", ctypes.c_char * maxsize)]
if serializing == 'json':
serializing = json
if szarg == None:
szarg = ({'encoding': 'utf-8'}, {'encoding': 'utf-8'})
elif serializing == 'pickle':
serializing = cPickle
if szarg == None:
szarg = ({}, {})
self.maxsize = maxsize
self.szarg = szarg
self.sz = serializing
self.sharestruct = ShareStructure
s = ShareStructure(0, '', '')
self.sharespace = RawValue(ShareStructure, 1)
self.lock = threading.Lock()
self.value = _v
property.__init__(self, self.value_getter, self.value_setter)
def __init__(self, capacity, data_size, data_tree = None, policy = 'random', passes_before_random = 0.):
if data_tree == None:
self.capacity = capacity # for all priority values
# calculate singular layers where it cannot be fully devided by 2:
width = 1; self.num_of_nodes = 0
while width < capacity:
self.num_of_nodes += width
width *= 2
self.tree_buffer = RawArray('d', self.num_of_nodes + capacity)
self.tree = np.frombuffer(self.tree_buffer,dtype='float64')
# [--------------Parent nodes-------------][-------leaves to recode priority-------]
# size: self.num_of_nodes size: capacity
self.data_buffer = RawArray('f', capacity*data_size)
self.data = np.frombuffer(self.data_buffer,dtype='float32').reshape((capacity,data_size)) # for all transitions
self.data_size = data_size
# [--------------data frame-------------]
# size: capacity
self.len = RawValue('i',0)
self.passes = - passes_before_random
assert self.passes <= 0
#self.childrens = []
if policy == 'sequential': self.sequential = True
elif policy == 'random': self.sequential = False
else:
self.capacity, self.len, self.passes, self.sequential, self.data_size, self.num_of_nodes = capacity, data_tree.len, data_tree.passes, data_tree.sequential, data_tree.data_size, data_tree.num_of_nodes
self.data = np.frombuffer(data_tree.data_buffer,dtype='float32').reshape((self.capacity,self.data_size))
self.tree = np.frombuffer(data_tree.tree_buffer,dtype='float64')
def __init__(self, cellular_automaton, process_count: int = 2):
multiprocessing.freeze_support()
if process_count < 1:
raise ValueError
super().__init__(cellular_automaton)
self.evolve_range = range(len(self._ca.cells))
self._ca.current_evolution_step = RawValue(
c_int, self._ca.current_evolution_step)
self.__init_processes(process_count)
def __init__(self, train, num_of_processes, others=''):
self.train = train
self.processes = []
self.actor_update_time = 10.
self.lr_step = 0
self.pending_training_updates = Value('d', 0., lock=True)
# somehow RawValue also needs us to call ".value", otherwise it says the type is c_double or c_int
self.episode = RawValue('i', 0)
self.t_done = Value('d', 0., lock=True)
self.last_achieved_time = RawValue('d', 0.)
# set the data going to subprocesses:
self.train.memory.start_proxy_process(
(self.pending_training_updates, self.episode, self.t_done,
self.last_achieved_time), self.train.transitions_storage,
(self.train.batch_size, self.train.memory.tree.data_size))
# the following will create threads, which not end and cause error (not exiting)
spawn = mp.get_context('spawn')
self.manager = spawn.Manager()
self.MemoryInputQueue = self.manager.Queue()
self.end_event = self.manager.Event()
self.pause_event = self.manager.Event()
self.learning_in_progress_event = self.manager.Event()
# actors
self.ActorReceivePipe, self.ActorUpdatePipe = spawn.Pipe(
False
) # unidirectional pipe that send message from conn2 to conn1
seed = random.randrange(0, 9999999)
self.worker_manager = spawn.Process(
target=worker_manager,
args=(copy.deepcopy(train.net).cpu(),
(self.MemoryInputQueue, self.ActorReceivePipe,
self.end_event, self.pause_event), num_of_processes,
seed, others))
# store and manage experience (including updating priority and potentially sampling out replays)
# all the arguments passed into it are used (**by fork initialization in RL module**).
# somehow RawValue also needs us to call ".value" ? Otherwise it says the type is c_double / c_int
self.train.memory.set_memory_source(
self.MemoryInputQueue, (self.pause_event, self.end_event,
self.learning_in_progress_event))
self.backup_period = self.train.backup_period
self.train.backup_period = 100
def __init__(self, cfg):
super().__init__(cfg)
self.processes = []
self.terminate = RawValue(ctypes.c_bool, False)
self.start_event = multiprocessing.Event()
self.start_event.clear()
self.report_queue = Queue()
self.report_every_sec = 1.0
self.last_report = 0
self.avg_stats_intervals = (1, 10, 60, 300, 600)
self.fps_stats = deque([], maxlen=max(self.avg_stats_intervals))
def test_futex_handshake():
print()
print(os.uname().sysname)
runner_class = threading.Thread
# runner_class = multiprocessing.Process
resource = RawValue(ctypes.c_int)
assert resource.value == 0
trace_list = RawArray(ctypes.c_float, 4)
for index in range(4):
assert trace_list[index] == 0
def reader_code():
trace_list[0] = time.time()
print("reader#1")
invoke_futex_wait(resource) # @UndefinedVariable
print("reader#2")
time.sleep(0.1)
print("reader#3")
trace_list[1] = time.time()
def writer_code():
print("writer#1")
time.sleep(0.1)
trace_list[2] = time.time()
print("writer#2")
invoke_futex_wake(resource) # @UndefinedVariable
print("writer#3")
trace_list[3] = time.time()
reader_proc = runner_class(target=reader_code, daemon=True)
writer_proc = runner_class(target=writer_code, daemon=True)
reader_proc.start()
writer_proc.start()
# reader_proc.join()
# writer_proc.join()
for index in range(3):
print(f"{index} trace_list={trace_list}")
time.sleep(1)
def __init__(self, fn, *args, **kwargs):
multiprocessing.Process.__init__(self)
self.fn = fn
self.args = args
self.kwargs = kwargs
# Create return pipe for return value
self.return_pipe = Pipe(duplex=False)
# Create 64 byte unique id based on network address, sequence number and time sample.
self.id = uuid.uuid1().hex + "." + fn.func_name[:31]
# Channel request state
self.cond = None
self.state = FAIL
self.result_ch_idx = None
self.result_msg = None
# Used to wait for acknowledgements from the RemoteLock
self.ack = False
# Used to ensure the validity of the remote answers
self.sequence_number = 1
# Protect against early termination of mother-processes leavings childs in an invalid state
self.spawned = []
# Protect against early termination of channelhomes leaving processes in an invalid state
self.registeredChanHomeList = []
self.registeredChanConnectList = []
# Protect against early termination of processes leaving channelhomes in an invalid state
self.activeChanList = []
self.closedChanList = []
# Identify this as a wrapped pycsp process, which must not be terminated by shutdown
self.maintained = True
# report execution error
self._error = RawValue('i', 0)
def get_shared_queue(size):
queue = Array(Message, size)
init_queue(queue, RawValue('i', 0), Condition(queue.get_lock()),
Condition(queue.get_lock()))
return queue
def make(cls) -> ctypes.Structure:
return RawValue(StatusStore)
from multiprocessing import Process
from multiprocessing.sharedctypes import RawValue
import ctypes
def f(n):
n.value = 'hello!!'
if __name__ == '__main__':
num = RawValue(ctypes.c_wchar_p, 'abc')
p = Process(target=f, args=(num, ))
p.start()
p.join()
print(num.value)
"""
import pigpio
from multiprocessing import Process
from multiprocessing.sharedctypes import RawValue
from collections import deque
from time import sleep
# set up
left_sensor_gpio = 27
right_sensor_gpio = 17
cache_width = 3
time_out = 135
time_width_restr = 20000
# shared value
left_speed = RawValue('f', 0)
right_speed = RawValue('f', 0)
# shared lock
#ls_lock = Lock()
#rs_lock = Lock()
def init_monitor(ls, rs):
gpio = pigpio.pi()
gpio.set_mode(left_sensor_gpio, pigpio.INPUT)
gpio.set_mode(right_sensor_gpio, pigpio.INPUT)
left_edge_time_tick = gpio.get_current_tick()
right_edge_time_tick = gpio.get_current_tick()
left_speed_queue = deque(maxlen=cache_width)
right_speed_queue = deque(maxlen=cache_width)
def __init__(self, value=0):
# RawValue because we don't need it to create a Lock:
self.val = RawValue('i', value)
self._val = value
self.lock = Lock()
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(MainWindow, self).__init__(parent)
self.setupUi(self)
# 图像大小
self.img_shape = (480, 720)
# 初始化界面
self.label_imgshow.setScaledContents(True) # 图片自适应显示
self.label_imgshow_res.setScaledContents(True) # 检测结果图片自适应显示
self.img_none = np.ones((480, 720, 3), dtype=np.uint8) * 255
self.show_img(self.img_none)
# SSD检测初始化
self.weight_path = './ssd/weights/weights_SSD300.hdf5'
self.weight_path = os.path.normpath(os.path.abspath(self.weight_path))
self.obj_names = [
'Aeroplane', 'Bicycle', 'Bird', 'Boat', 'Bottle', 'Bus', 'Car',
'Cat', 'Chair', 'Cow', 'Diningtable', 'Dog', 'Horse', 'Motorbike',
'Person', 'Pottedplant', 'Sheep', 'Sofa', 'Train', 'Tvmonitor'
]
# 需要显示的目标list， 用于过滤
self.include_class = self.obj_names
# 检测子进程
self.queue = Queue()
# 多进程之间的共享图片内存
self.img_share = RawArray('I',
self.img_shape[0] * self.img_shape[1] * 3)
# 标识当前进程的状态，非0：保持检测；0：停止检测
self.process_flg = RawValue('I', 1)
# 当前图像共享内存 img_share 的状态，非0：主进程使用中；0：子进程使用中
self.img_get_flg = RawValue('I', 1)
# 创建检测子进程
self.detector_process = Process(target=detector_process,
args=(self.img_share, self.img_shape,
self.process_flg,
self.img_get_flg, self.queue))
self.detector_process.start()
# 接收检测结果的线程
self.recv_thread = Recv_res(parent=self, queue=self.queue)
# 连接信号
self.recv_thread.res_signal.connect(self.show_res)
self.recv_thread.start()
# 视频流URL
self.camera_index = 0
self.FPS = None
# 初始化计时器
self.timer = QTimer(self) # 更新计时器
self.timer.timeout.connect(self.timer_update) # 超时信号连接对应的槽函数
# 等待加载模型
self.textEdit.setText('正在加载模型，请稍后......')
self.pushButton_start.setEnabled(False)
self.pushButton_open.setEnabled(False)
self.pushButton_pause.setEnabled(False)
self.lineEdit_cameraIndex.setEnabled(False)
# 暂停初始化为不暂停
self.pause = False
def RawValue(typecode_or_type, *args):
from multiprocessing.sharedctypes import RawValue
return RawValue(typecode_or_type, *args)
def shared_value(default, dtype="float"):
if dtype in typemap.keys():
return RawValue(typemap[dtype], default)
else:
raise ValueError
def __init__(self,
logger_manager,
filename=None,
cam_ip=None,
width=1920,
height=1200,
auto_expose=True,
auto_balance=True):
self.logger = logger_manager.get_logger("BQ_Cam")
self.sched_run = None
if filename is None:
# 设置相机模式标识。
self.mode = 0
# 相机模式分辨率自设，默认1920*1200
(self.w, self.h) = (width, height)
self.cam_ip = cam_ip
self.auto_expose = auto_expose
self.auto_balance = auto_balance
self.logger.debug("网络相机模式，IP: {}, (w, h): ({}, {}).".format(
cam_ip, self.w, self.h))
else:
# 设置文件模式标识。
self.mode = 1
# 文件模式获取分辨率
(self.w, self.h) = gige.get_resolution(filename)
self.logger.debug("文件读取模式: {}, (w, h): ({}, {}).".format(
filename, self.w, self.h))
self.width = self.w
self.height = self.h
# 准备进程锁和进程间共享空间。
self.process_lock = multiprocessing.Lock()
self.array_temp = np.ones(shape=(self.h * self.w * 3), dtype=np.ubyte)
self.shared_array = RawArray(ctypes.c_ubyte, self.array_temp)
self.shared_value = RawValue(ctypes.c_uint, 0)
self.logger.debug("进程共享内存准备完毕。")
if self.mode == 0:
self.sched_run = schedrun.SchedRun(
func=gige.get_frame_from_camera,
args=(
self.shared_array,
self.shared_value,
self.process_lock,
False,
),
init_func=gige.init_camera,
init_args=(self.cam_ip, self.w, self.h, self.auto_expose,
self.auto_balance),
clean_func=gige.close_camera,
clean_args={},
interval=0.0,
init_interval=0.0)
else:
self.sched_run = schedrun.SchedRun(func=gige.get_frame_from_file,
args=(
self.shared_array,
self.shared_value,
self.process_lock,
),
init_func=gige.init_file,
init_args=(filename, ),
clean_func=gige.close_file,
clean_args={},
interval=0.025,
init_interval=0.0)
self.logger.debug("帧读取进程启动。")
#while self.shared_value != 0:
for i in range(10):
if self.shared_value == 0:
self.logger.debug("帧读取进程没准备好，等待100ms。")
# 相机进程还没有准备好。
time.sleep(0.1)
if self.shared_value == 0:
return None
run_option = subparsers.add_parser("run", help="Run the Pyncette app")
run_option.add_argument(
"--processes", type=int, default=1, help="Number of processes to run"
)
run_option.add_argument(
"--partition-count",
type=int,
default=PARTITION_COUNT,
help="How many partitions each process should poll",
)
options = parser.parse_args()
setup(options.log_level)
if options.command == "run":
hit_count = [RawValue("l", 0) for _ in range(options.processes)]
staleness = [RawValue("f", 0) for _ in range(options.processes)]
if options.partition_count * options.processes < PARTITION_COUNT:
logger.warning(
f"partition_count * processes < {PARTITION_COUNT}. Not all partitions will be processed."
)
for i in range(options.processes):
enabled_partitions = sorted(
(i * options.partition_count + j) % PARTITION_COUNT
for j in range(options.partition_count)
)
job = Process(
target=_run,
def main1():
process_lock = multiprocessing.Lock()
array_temp = np.ones(shape=(HEIGHT * WIDTH * 3), dtype=np.ubyte)
shared_array = RawArray(ctypes.c_ubyte, array_temp)
shared_value = RawValue(ctypes.c_uint, 0)
sched_run = schedrun.SchedRun(func=get_frame_from_camera,
args=(
shared_array,
shared_value,
process_lock,
False,
),
init_func=init_camera,
init_args=(
WIDTH,
HEIGHT,
),
clean_func=close_camera,
clean_args={},
interval=0.0,
init_interval=0.0)
cv2.namedWindow("result", cv2.WINDOW_NORMAL)
#cv2.resizeWindow("result", 800, 500)
#cv2.moveWindow("result", 100, 100)
accum_time = 0
curr_fps = 0
prev_time = time.time()
show_fps = "Show FPS: ??"
gige_fps = "GigE FPS: ??"
font_scale = WIDTH // 800 + 1
while True:
process_lock.acquire()
frame = np.array(shared_array, dtype=np.uint8)
process_lock.release()
frame = frame.reshape((HEIGHT, WIDTH, 3))
curr_time = time.time()
exec_time = curr_time - prev_time
prev_time = curr_time
accum_time = accum_time + exec_time
curr_fps = curr_fps + 1
if accum_time > 1:
accum_time = accum_time - 1
show_fps = "Show FPS: " + str(curr_fps)
curr_fps = 0
if shared_value.value > 0:
gige_fps = "GigE FPS: " + str(shared_value.value)
#fps = gige_fps + " VS " + show_fps
cv2.putText(frame,
text=gige_fps,
org=(30, 80),
fontFace=cv2.FONT_HERSHEY_TRIPLEX,
fontScale=font_scale,
color=(0, 0, 255),
thickness=2)
cv2.putText(frame,
text=show_fps,
org=(30, 160),
fontFace=cv2.FONT_HERSHEY_TRIPLEX,
fontScale=font_scale,
color=(0, 0, 255),
thickness=2)
cv2.imshow('result', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
sched_run.stop()
cv2.destroyAllWindows()
return True
# Normally, should not be here.
sched_run.stop()
cv2.destroyAllWindows()
print('Oops, something wrong')
return False
def master_parallel(recording=True, to_video=False):
# init variables
wait_time = 5
#output settings
frame_gap = 1 / G.FPS #0.0002 add this line when print pace and perf_counter() are used
init_buffer = -int(G.FPS * wait_time)
#shared variables
count = RawValue('i', init_buffer)
control = RawValue(
'i', 1
) # start at 1 so that control depended process start only when count >= 0
title = RawValue(
'i', 0) # file will start to save after the first array is completed
switch = RawValue('i', 1)
lock = Lock()
sync_processes = []
arrays = []
data = []
for ID in range(G.cam_num):
array_0 = shared_array(G.Tshape, np.uint8)
array_1 = shared_array(G.Tshape, np.uint8)
img_0 = shared_array(G.Ishape, np.uint8)
img_1 = shared_array(G.Ishape, np.uint8)
data_0 = shared_array(G.kp_shape, np.int16)
data_1 = shared_array(G.kp_shape, np.int16)
process_read = Process(target=cam_read,
args=(ID, count, switch, array_0, array_1))
process_infer = Process(target=array_inference,
args=(ID, count, control, switch, array_0,
array_1, img_0, img_1, data_0, data_1))
sync_processes = sync_processes + [process_read] + [process_infer]
arrays = arrays + [array_0] + [array_1]
data = data + [img_0] + [img_1] + [data_0] + [data_1]
if recording:
central_0 = shared_array(G.Fshape, np.uint8)
central_1 = shared_array(G.Fshape, np.uint8)
process = Process(target=fill_array,
args=(count, control, title, switch, central_0,
central_1, *arrays))
sync_processes.append(process)
process = Process(target=save_array,
args=(count, title, switch, central_0, central_1))
sync_processes.append(process)
process_post = Process(target=post_process,
args=(count, control, switch, *data))
process_pace = Process(target=pace_maker,
args=(frame_gap, count, control, title, lock,
switch))
sync_processes = sync_processes + [process_post] + [process_pace]
for i in range(len(sync_processes)):
sync_processes[i].start()
for i in range(len(sync_processes)):
sync_processes[i].join()
if to_video:
read_h5()
def wsVideoPhaseMP(input, output, local_view = True, arduino = False, time_debug = False, simple_show = True):
import gxipy as gx
import schedrun
import multiprocessing
import ctypes
from multiprocessing.sharedctypes import RawArray, RawValue
from mptest import init_camera, close_camera, get_frame_from_camera
from mptest import init_file, close_file, get_frame_from_file
print("Multiprocess Mode. ")
time.sleep(0.05)
process_lock = multiprocessing.Lock()
array_temp = np.ones(shape = (1200 * 1920 * 3), dtype = np.ubyte)
shared_array = RawArray(ctypes.c_ubyte, array_temp)
shared_value = RawValue(ctypes.c_uint, 0)
if input[0] == '0':
sched_run = schedrun.SchedRun(func = get_frame_from_camera, args = (shared_array, shared_value, process_lock, False, ),
init_func = init_camera, init_args = (1920, 1200, False, False),
clean_func = close_camera, clean_args = {},
interval = 0.0,
init_interval = 0.0)
else:
sched_run = schedrun.SchedRun(func = get_frame_from_file, args = (shared_array, shared_value, process_lock, ),
init_func = init_file, init_args = (input[0], ),
clean_func = close_file, clean_args = {},
interval = 0.0,
init_interval = 0.0)
W = 1920//2
H = 720//2
RESOLUTION = (W*2, H*2)
HALF_RESOLUTION = (W, H)
center_list = []
if time_debug:
time_stamp = time.time()
print(time_stamp, ': time debug enabled.')
# Initialize the arduino serial communication.
if arduino is True:
AS_device = AS.arduino_serial('/dev/ttyUSB0')
ret = AS_device.openPort()
if ret is False:
print('Failed to open the Arduino Serial for communication. ')
return
isOutput = True if output != "" else False
if isOutput:
if simple_show:
output_res = (1920, 720)
else:
output_res = (600, 750)
video_FourCC = cv2.VideoWriter_fourcc(*'DIVX')
#video_FourCC = -1
video_FourCC = cv2.VideoWriter_fourcc("m", "p", "4", "v")
out = cv2.VideoWriter(output, video_FourCC, 50, output_res)
out_opened = out.isOpened()
if out_opened:
print('OUT Opened: isOpened(): {}. '.format(out_opened))
else:
print('OUT Closed: isOpened(): {}. '.format(out_opened))
return
print("=== Start the WS detecting ===")
print('Load C lib. ')
so_file = './libws_c.so'
lib = ctypes.cdll.LoadLibrary(so_file)
lib.testlib()
kernel = np.ones((5,5),np.uint8)
# 为normalizeCenter准备数据数组。
center_array = []
dropped_array = []
if local_view:
#cv2.namedWindow("result", cv2.WINDOW_NORMAL)
cv2.namedWindow("result")
#cv2.resizeWindow("result", 1600, 800)
#cv2.moveWindow("result", 100, 100)
if time_debug:
time_cur = time.time()
print('{:1.6f}: 初始化完成. '.format((time_cur - time_stamp) * 1000));
time_stamp = time_cur
time_frame = time_cur
time_dur_accum = 0
while True:
if time_debug:
#print('[{:3.3f} ms]: 帧间时间. '.format((time.time() - time_stamp)*1000));
print('[{:3.3f} - {:3.3f} ms]: 开始处理一帧画面. '.format((time.time() - time_frame)*1000, time_dur_accum))
time_dur_accum = 0
time_frame = time.time()
if time_debug:
time_stamp = time.time()
process_lock.acquire()
frame = np.array(shared_array, dtype = np.uint8)
process_lock.release()
if frame.max() < 5:
continue
frame = frame.reshape((1200, 1920, 3))
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 从输出源得到一帧画面. '.format(time_dur))
# 根据图像特殊处理
# ===========================
frame = imgRotate(frame, ADJUST_ANGLE)
# ===========================
if type(frame) != type(None):
# 根据摄像头摆放位置确定是否需要旋转图像。
# 目前的处理逻辑是处理凸字形的焊缝折线。
frame = np.rot90(frame, k = 0)
# 根据摄像头摆放位置切除多余的干扰画面。
# 目前这个设置是基于7块样板的图像进行设置。
# 未来这里会在GUI界面中可以设置，排除不必要的干扰区域。
(h, w) = frame.shape[:2]
# 对应12mm镜头，切除左右各1/4，切除下方1/4的画面
# ===========================
#frame = frame[0:3*h//4, w//4:3*w//4]
# ===========================
# 对应16mm镜头，暂时不切除。
# ===========================
#frame = frame[2*h//5:h, 0:w]
frame = frame[0:h, 0:w]
# ===========================
#frame = frame[4*h//9:5*h//9, 5*w//13:7*w//12]
if len(frame.shape) > 2:
color_input = True
else:
color_input = False
#frame = cv2.resize(frame, RESOLUTION, interpolation = cv2.INTER_LINEAR)
(h, w) = frame.shape[:2]
#frame = cv2.medianBlur(frame, 5)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 图像输入预处理完成. '.format(time_dur))
time_stamp = time.time()
if color_input:
# Get the blue image.
#b, r, g = cv2.split(frame)
#n = 50
#filt = (g.clip(n, n+1) - n) * 255
#filt = r//3 + g//3 + b//3
filt = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
#filt = r
else:
filt = frame
mean = filt.mean()
#black_limit = (int)(mean * 8)
black_limit = (int)(mean * 5)
if black_limit > 245:
black_limit = 245
if black_limit < 3:
black_limit = 3
#print('MEAN: ', filt.mean(), ' BLACK_LIMIT: ', black_limit)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 分色和黑场检测完成. '.format(time_dur))
coreline = getLineImage(lib, filt, black_limit = black_limit, correct_angle = False)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 基准线检测完成. '.format(time_dur))
#coreline = cutLowPixels(lib, coreline, low_level_limit = 10)
gaps = fillLineGaps(lib, coreline, start_pixel = 5)
result = gaps + coreline
#result = coreline
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 缺损检测以及填充完成. '.format(time_dur))
b_center, b_level, bound = getBottomCenter(lib, result, bottom_thick = BOTTOM_THICK, noisy_pixels = NOISY_PIXELS)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 焊缝中心识别完成. '.format(time_dur))
# 将center的输出值进行normalize处理，消除尖峰噪音干扰。
b_center, center_array, dropped_array = normalizeCenter(center_array, b_center, thres_drop = 100, thres_normal = 50, move_limit = 3, skip = False, dropped_array = dropped_array)
# 因为目前采用的分辨率是模拟屏幕的5倍，为了对应当前逻辑和减少抖动，输出值除以3取整。
real_center = int(b_center / 3)
center_list.append(real_center)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 焊缝中心尖峰降噪完成. '.format(time_dur))
# 如果我们开启了arduino serial通讯，这里拼凑坐标传送给机器人。
if arduino is True:
# 这个地方的b_center就是焊缝识别得到的中点坐标。
# 我们在这里用传统380线分辨率的做一个规一划处理。
# real_center = b_center * 380 // w
####################################
# 这个地方请修改代码，是否应该将real_center的值转化为16进制的数字，
# 通信的高地位分别怎么设置，我这里就只是用了你示例代码中的通信标志。
####################################
AS_device.writePort('E7E701450124005A0008004EFE')
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 坐标写入串口完成. '.format(time_dur))
if not color_input:
frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
if simple_show:
mix_image = fill2ColorImage(lib, frame, result, fill_color = (255, 0, 0))
if not DRAW_BOUND:
bound = None
if not DRAW_BOTTOM:
bottom_thick = None
else:
bottom_thick = BOTTOM_THICK
drawTag(frame, b_center, b_level, bottom_thick = bottom_thick, bound = bound)
#drawTag(frame, b_center, b_level)
images = frame
#images = cv2.resize(frame, HALF_RESOLUTION, interpolation = cv2.INTER_LINEAR)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 图像输出标记完成. '.format(time_dur))
else: #simple_show
mix_image = fill2ColorImage(lib, frame//2, result, fill_color = (255, 0, 0))
mix_image = fill2ColorImage(lib, mix_image, gaps, fill_color = (0, 255, 0))
drawTag(mix_image, b_center, b_level)
result = cv2.cvtColor(result, cv2.COLOR_GRAY2RGB)
drawTag(result, b_center, b_level)
drawTag(frame, b_center, b_level)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 图像输出标记完成. '.format(time_dur))
fill_black = np.zeros(shape = (RESOLUTION[1], RESOLUTION[0], 3))
#frame = cv2.resize(frame, HALF_RESOLUTION, interpolation = cv2.INTER_LINEAR)
result = cv2.resize(result, HALF_RESOLUTION, interpolation = cv2.INTER_LINEAR)
mix_image = cv2.resize(mix_image, HALF_RESOLUTION, interpolation = cv2.INTER_LINEAR)
image2 = np.hstack([mix_image, result])
images = np.vstack([frame, image2])
images = cv2.resize(images, (600, 750), interpolation = cv2.INTER_LINEAR_EXACT)
center_string = "Center: " + str(real_center)
center_string += " -- TOF: {:3.3f}ms".format((time.time() - time_frame) * 1000)
cv2.putText(images, text=center_string, org=(30, 30), fontFace=cv2.FONT_HERSHEY_TRIPLEX,
fontScale=0.5, color=(255, 255, 255), thickness=1)
#print(images.shape)
if local_view:
#images = coreline
cv2.imshow("result", images)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 图像屏幕输出完成. '.format(time_dur))
if isOutput:
out.write(images)
if time_debug:
time_dur = time.time() - time_stamp
time_stamp = time.time()
time_dur *= 1000
time_dur_accum += time_dur
print('\t[{:3.3f} ms]: 图像文件输出完成. '.format(time_dur))
else:
break
sched_run.stop()
plt.figure()
x = range(len(center_list))
plt.plot(x, center_list)
plt.ylim(0, max(center_list) + 10)
plt.show()
if local_view:
cv2.destroyAllWindows()
def RawValue(typecode_or_type, *args):
"""
Returns a shared object
"""
from multiprocessing.sharedctypes import RawValue
return RawValue(typecode_or_type, *args)
def __init__(self, start_loc, length, width):
self._pos = RawArray('d', start_loc)
self._vel = RawArray('d', 2)
self._acc = RawArray('d', 2)
self._rot = RawValue('d')
self._sz = RawArray('d', (length, width))
def main(filename):
process_lock = multiprocessing.Lock()
array_temp = np.ones(shape=(HEIGHT * WIDTH * 3), dtype=np.ubyte)
shared_array = RawArray(ctypes.c_ubyte, array_temp)
shared_value = RawValue(ctypes.c_uint, 0)
sched_run = schedrun.SchedRun(func=get_frame_from_file,
args=(
shared_array,
shared_value,
process_lock,
),
init_func=init_file,
init_args=(filename, ),
clean_func=close_file,
clean_args={},
interval=0.0,
init_interval=0.0)
cv2.namedWindow("result", cv2.WINDOW_NORMAL)
#cv2.resizeWindow("result", 800, 500)
#cv2.moveWindow("result", 100, 100)
accum_time = 0
curr_fps = 0
prev_time = time.time()
show_fps = "Show FPS: ??"
gige_fps = "GigE FPS: ??"
font_scale = WIDTH // 800 + 1
while True:
if shared_value.value > 10000:
# Something wrong in the frame aquirement.
break
elif shared_value.value == 0:
# Fram aquirement process is not ready.
# sleep for 50ms.
sleep(0.05)
continue
gige_fps = "GigE FPS: " + str(shared_value.value)
process_lock.acquire()
frame = np.array(shared_array, dtype=np.uint8)
process_lock.release()
frame = frame.reshape((HEIGHT, WIDTH, 3))
curr_time = time.time()
exec_time = curr_time - prev_time
prev_time = curr_time
accum_time = accum_time + exec_time
curr_fps = curr_fps + 1
if accum_time > 1:
accum_time = accum_time - 1
show_fps = "Show FPS: " + str(curr_fps)
curr_fps = 0
#fps = gige_fps + " VS " + show_fps
cv2.putText(frame,
text=gige_fps,
org=(30, 80),
fontFace=cv2.FONT_HERSHEY_TRIPLEX,
fontScale=font_scale,
color=(0, 0, 255),
thickness=2)
cv2.putText(frame,
text=show_fps,
org=(30, 160),
fontFace=cv2.FONT_HERSHEY_TRIPLEX,
fontScale=font_scale,
color=(0, 0, 255),
thickness=2)
cv2.imshow('result', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
sched_run.stop()
cv2.destroyAllWindows()
def __init__(self, BMdict, DevConf):
'''Args: configuration dictionary
Device Class
'''
# read configuration dictionary
if "NBuffers" in BMdict:
self.NBuffers = BMdict["NBuffers"] # number of buffers
else:
self.NBuffers= 16
if "BMmodules" in BMdict:
self.BMmodules = BMdict["BMmodules"] # display modules to start
else:
self.BMmodules = []
if "LogFile" in BMdict:
self.LogFile = BMdict["LogFile"]
else:
self.LogFile = None
self.flog = None # file not yet open
if "verbose" in BMdict:
self.verbose = BMdict["verbose"]
else:
self.verbose=1 # print (detailed) info if >0
if "logTime" in BMdict:
self.logTime = BMdict["logTime"] # display modules to start
else:
self.logTime = 60 # logging information once per 60 sec
# read device congiguration and set up Buffer space
self.DevConf = DevConf
self.NChannels = DevConf.NChannels # number of channels in use
self.NSamples = DevConf.NSamples # number of samples
self.TSampling = DevConf.TSampling # sampling interval
# function collecting data from hardware device
self.rawDAQproducer = DevConf.acquireData
# data structure for BufferManager in shared c-type memory ...
self.CBMbuf = RawArray('f',
self.NBuffers * self.NChannels * self.NSamples)
self.CtimeStamp = RawArray('f', self.NBuffers )
self.CtrigStamp = RawArray('i', self.NBuffers )
# ... and map to numpy arrays
self.BMbuf = np.frombuffer(self.CBMbuf, 'f').reshape(self.NBuffers,
self.NChannels, self.NSamples)
self.timeStamp = np.frombuffer(self.CtimeStamp, 'f')
self.trigStamp = np.frombuffer(self.CtrigStamp, 'f')
self.ibufr = RawValue('i', -1) # read index, synchronization with producer
# global variables for producer statistics
self.Ntrig = RawValue('i', 0) # count number of readings
self.Ttrig = RawValue('f', 0.) # time of last event
self.Tlife = RawValue('f', 0.) # DAQ lifetime
self.readrate = RawValue('f', 0) # current rate
self.lifefrac = RawValue('f', 0) # current life-time
# set up variables for Buffer Manager status and accounting
self.BMT0 = 0.
self.tPause = 0. # time when last paused
self.dTPause = 0. # total time spent in paused state
self.ACTIVE = RawValue('b', 0)
self.RUNNING = RawValue('b', 0)
self.STOPPED = False
# queues ( multiprocessing Queues for communication with sub-processes)
self.prod_Que = Queue(self.NBuffers) # acquireData <-> manageDataBuffer
self.request_Ques=[] # consumer request to manageDataBuffer
# 0: request event pointer, obligatory consumer
# 1: request event data, random consumer
# 2: request event data, obligatoray consumer
self.consumer_Ques=[] # data from manageDataBuffer to consumer
# multiprocessing Queues for data transfer to subprocesses
self.mpQues = []
self.BMInfoQue = None
self.BMlock = threading.Lock()
self.logQ = None
# keep track of sub-processes started by BufferManager
self.procs=[] # list of sub-processes started by BufferMan
self.thrds=[] # list of sub-processes started by BufferMan
def __init__(self, bam_bits):
self.bam_bits = bam_bits
self.buf = RawArray('B', Driver.MEM_SIZE * bam_bits)
self.sp = None
self.quit = RawValue('B', 0)
def __init__(self, initial_state=(0., ), draw_first_state=True):
super().__init__(initial_state, draw_first_state)
self._state_slots = [RawArray(c_float, initial_state) for i in range(self.__class__._state_save_slot_count)]
self._active = [RawValue(c_bool, False) for i in range(self.__class__._state_save_slot_count)]
self._active[0].value = True
self._dirty = RawValue(c_bool, draw_first_state)
