def rotate(**kwargs): """ Rotate :param pos_pre: :param pos_cur: :param focus_view: current focused view, 'transverse' for transverse, 'saggital' for saggital, 'coronal' for coronal :return: rgb image data """ try: pos_pre = string_int_trans(kwargs['pos_pre'].split(','), 's2i') pos_cur = string_int_trans(kwargs['pos_cur'].split(','), 's2i') focus_view = get_view_index(kwargs['focus_view']) log.dev_info("=== enter rotate ===") except Exception as err: return response(success=False, message=err.message) try: views = imageentity.get_children_views() size = views[focus_view].get_scene().get_display_size() angle = cal_angle(size, pos_pre, pos_cur) imageentity.rotate(focus_view, angle) imageentity.updater().update(RefreshType.All) result = imageentity.updater().get_result() return response(json.dumps(result)) except Exception as e: return response(success=False, message='rotate failed')
def load(**kwargs): """ Load volume data and managed in memory :param volume: volume data :param seriesuid: series uid :return: """ try: volume_path = kwargs['volumepath'] if not os.path.isfile(volume_path): return response(success=False, message='volume data not exist.') except Exception as err: return response(success=False, message=err.message) try: vol = cio.read_image(volume_path) os.remove(volume_path) size = vol.size().tolist() imageentity.set_volume(vol) imageentity.remove_child_entities() imageentity.add_child_entity(CellEntity(0, False)) imageentity.add_child_entity(CellEntity(1, False)) imageentity.add_child_entity(CellEntity(2, False)) imageentity.init_default_scenes(vol) log.dev_info("load volume succeed") return response(content=json.dumps(size), success=True, message='load volume succeed') except Exception as err: return response(success=False, message=err.message)
def mask_to_contours(mask_fp): """ Convert mask to contours :param mask_fp: Mask file path :return: Array of contours """ log.dev_info('Mask file path: {}'.format(mask_fp)) if not os.path.isfile(mask_fp): log.dev_error('Path {} is not a mask file') return None mask = cio.read_image(mask_fp) mask.from_numpy(mask.to_numpy(), np.uint8) size_x, size_y, slice_count = mask.size() slices = mask.to_numpy() rst = {} for index in range(slice_count): slice = slices[index] _, thresh = cv2.threshold(slice, 0, 255, cv2.THRESH_BINARY) _, contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) if len(contours) == 0: continue graphics = [] for contour in contours: graphic = [] for cp in contour: pt = cp[0].tolist() pt.append(index + 1) graphic.append(pt) graphics.append(graphic) rst[index + 1] = graphics return rst
def release_render_srv(self, proxy_name): log.dev_info('release_render_srv {}'.format(proxy_name)) for srv in self.all_render_srv(): if srv['proxy'] == proxy_name: srv['stat'] = 0 return True return False
def get(self, request): patients_unicode = request.GET.get('patientId', None) patients_str = patients_unicode.encode('utf-8') log.dev_info('patient id {}'.format(patients_str)) if not patients_str: return Response('请传入有效的patientID') patients_list = patients_str.split(',') try: datasets_list, patient_series_dict = pacs_svc.getimage(patients_list) except Exception as e: return Response('从PACS获取数据过程出错,请重试') for dataset_list in datasets_list: try: patient_svc.upload_dcm(dataset_list) except Exception as e: return Response('DCM数据入库失败,请检查DCM数据是否符合DB字段约束') for seriespath in patient_series_dict.values(): if len(os.listdir(seriespath)) <= 1: return Response('series下的dicom文件单一,无法build volume') try: builder = VolumeBuilder() volfilepath, seriesuid = builder.build(seriespath) except Exception as e: return Response('dicom文件不符合规范,创建volume失败') try: series_svc.upload_volume(volfilepath, seriesuid) except Exception as e: return Response('Volume入库失败') return Response('Download Success')
def wrapper(*args, **kwargs): t0 = time.time() rst = func(*args, **kwargs) t = time.time() - t0 msg = "[TIME] %s used %.3f ms" % (func.__name__, t * 1000) log.dev_info(msg) print msg return rst
def command_func(p_context): current_package_data = p_context.get_serialize_object() data = RequestData(current_package_data) b = time.time() rsp = cmd.commands[data.command](**data.content) c = time.time() p_context.reply(rsp) log.dev_info('handler use {} ms'.format(str((c - b) * 1000)))
def register(self, command): log.dev_info('Register command {} succeed.'.format(command)) def wrapper(func): self.commands[command] = func log.dev_info('inner command {} succeed.'.format(command)) return func return wrapper
def __send_data_to_server(self): log.dev_info( '[Dispatcher]Send to server package size: {} bytes'.format( len(self.current_package_data))) data = RequestData(self.current_package_data) if data.session not in self.session_mgr: self.session_mgr[data.session] = self.protocols.pop(0) p = self.session_mgr[data.session] p.transport.write(self.package(self.current_package_data))
def cal_angle(size, pre_pos, cur_pos): center_pos = map(lambda x: x / 2.0, size) cent_x, cent_y = center_pos[0], center_pos[1] pre_vec = np.array([pre_pos[0] - cent_x, pre_pos[1] - cent_y]) cur_vec = np.array([cur_pos[0] - cent_x, cur_pos[1] - cent_y]) cos_angle = pre_vec.dot(cur_vec) / np.linalg.norm( pre_vec) / np.linalg.norm(cur_vec) angle = np.arccos(cos_angle) if pre_vec[0] * cur_vec[1] - pre_vec[1] * cur_vec[0] < 0: angle = -angle log.dev_info("=== angel: {}===".format(angle)) return angle
def draw_graphic(self, index, graphic_type, pos_pre, pos_cur, uid): if self._cellviews is not None and len(self._cellviews) > index: cell_operate = self._cellviews[index] scene_operate = cell_operate.get_scene() pt3d_pre = translate_from_screen_to_world(scene_operate, pos_pre) pt3d_cur = translate_from_screen_to_world(scene_operate, pos_cur) if graphic_type == GraphicType.ProLines: model_graphic = self.workflow.get_model( GET_CLASS_NAME(GraphicModel)) model_graphic.lines[uid] = (tuple(pt3d_pre), tuple(pt3d_cur)) dist = np.linalg.norm(pt3d_cur - pt3d_pre) log.dev_info('line distance: {}'.format(dist))
def port_validation(self): if isinstance(self.store_ae_port, int): test_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: test_socket.bind( (os.popen('hostname').read()[:-1], self.store_ae_port)) log.dev_info("Now listen on port {0:d}".format( self.store_ae_port)) except socket.error: log.dev_info( "Cannot listen on port {0:d}, insufficient priveleges". format(self.store_ae_port))
def register_srv_list(self, srv_info, sender): srv_list = json.loads(srv_info) for srv in srv_list: log.dev_info(srv) if srv['srv'] == 'algor': if sender in self.algor_srv_dict: self.algor_srv_dict[sender].append(srv) else: self.algor_srv_dict[sender] = [srv] else: if sender in self.render_srv_dict: self.render_srv_dict[sender].append(srv) else: self.render_srv_dict[sender] = [srv]
def get_args(argv): kwargs = {} kwargs['host'] = '0.0.0.0' kwargs['port'] = 0 try: opts, args = getopt.getopt(argv, "h:p:", ["host=", "port="]) except getopt.GetoptError: log.dev_info('server.py -h <host> -p <port>') sys.exit(2) for opt, arg in opts: if opt == '-h': kwargs['host'] = arg elif opt == '-p': kwargs['port'] = int(arg) return kwargs
def unload(**kwargs): """ UnLoad volume data and managed in memory :param seriesuid: series uid :return: """ try: seriesuid = kwargs['seriesuid'] except Exception as err: return response(success=False, message=err.message) log.dev_info(seriesuid) rst, msg = server.unload_volume(seriesuid) imageentity.remove_child_entities() log.dev_info("Unload volume succeed") return response(msg)
def get_point2d(**kwargs): try: index = get_view_index('transverse') view = imageentity.get_children_views()[index] scene = view.get_scene() vol = scene.volume contour = kwargs['contour'] cps = [] for cp in contour: cp = vol.voxel_to_world(cp) pt2d = translate_from_world_to_screen(scene, cp) cps.append(pt2d.tolist()) return response(json.dumps({'contour': cps})) except Exception as e: log.dev_info('---------------->', e.message) return response(success=False, message=e.message)
def draw_graphic(self, index, graphic_type, pos_pre, pos_cur, state): if self._scene is not None: pt3d_pre = translate_from_screen_to_world(self._scene, pos_pre) pt3d_cur = translate_from_screen_to_world(self._scene, pos_cur) overlay_graphic = self.get_overlay(RefreshType.Graphic) if state == GraphicState.Initial: line = GraphicLine(pos_pre[0], pos_pre[1], pos_cur[0], pos_cur[1]) overlay_graphic.add_graphic(line) else: overlay_graphic.get_graphics()[-1].setLine( pos_pre[0], pos_pre[1], pos_cur[0], pos_cur[1]) if state == GraphicState.Complete: model_graphic = self.workflow.get_model( GET_CLASS_NAME(GraphicModel)) model_graphic.lines.append([pt3d_pre, pt3d_cur]) dist = np.linalg.norm(pt3d_cur - pt3d_pre) log.dev_info('line distance: {}'.format(dist))
def get_point3d(**kwargs): try: index = get_view_index('transverse') contours = kwargs['contours'] view = imageentity.get_children_views()[index] scene = view.get_scene() vol = scene.volume cps_list = {'contours': []} for contour in contours: cps = [] for cp in contour: pt3d = translate_from_screen_to_world(scene, [cp['x'], cp['y']]) pt3d = vol.world_to_voxel(pt3d) cps.append([int(pt3d[0]), int(pt3d[1]), int(pt3d[2])]) cps_list['contours'].append(cps) return response(json.dumps(cps_list)) except Exception as e: log.dev_info('---------------->', e.message) return response(success=False, message=e.message)
def dataReceived(self, data): self.received_data = data self.received_size = len(data) while self.received_data != '': if self.current_package_size == 0: self.current_package_size = self.__pop(4, type='head') log.dev_info( '[Dispatcher]Need to received package size: {} bytes'. format(self.current_package_size)) if self.current_package_size <= self.received_size: self.current_package_data += self.__pop( self.current_package_size) self.__send_data_to_server() self.current_package_data = '' self.current_package_size = 0 else: self.current_package_size -= self.received_size self.current_package_data += self.__pop(self.received_size)
def render(self): log.dev_info('render start') begin = datetime.now() self._spacing = max(self._camera.fov[0] / float(self._width), self._camera.fov[1] / float(self._height)) log.dev_info('spacing: {}, fov: {}, size: {}, wwwl: {}'.format( self._spacing, self._camera.fov, [self._width, self._height], self.get_window_level())) raw_data = slice_nn(self._image3d, self._camera.look_at, self._camera.right, self._camera.up, self._camera.look_at, [self._spacing, self._spacing], [self._width, self._height], self.__default_v) if self.__color_mode is not ColorMode.Map: win_min = self._window_level - self._window_width / 2 win_max = self._window_level + self._window_width / 2 byte_data = slice_to_bytes(raw_data, win_min, win_max) color_data = bytes_to_colors(byte_data, self.__color_mode.value, None) else: color_data = bytes_to_colors(raw_data, self.__color_mode.value, self.__color_map) log.dev_info('render finish') self._image_result = color_data return color_data
def get(self, request): seriesuid = request.GET.get( 'seriesuid', '1.3.12.2.1107.5.1.4.64606.30000018051006052134700006373') scriptname = request.GET.get('scriptname', 'AnonymousUser1540275438.76') if not seriesuid or not scriptname: return ResponseDto('请输入有效的参数') series, msg = series_svc.get_series_by_uid(seriesuid) if not series: return ResponseDto(success=False, message=msg) volumepath = series.seriespixeldatafilepath try: command = 'python static/macro/{}.py {} {}'.format( scriptname, seriesuid, volumepath) r = os.popen(command) info = r.readlines() log.dev_info(info) except: return ResponseDto('script执行异常') return ResponseDto('OK')
import os import sys import threading import time from netbase.c_log import log log.create_log() log.set_source('img_srv') log.dev_info('first log of img_srv.') from command import command as cmd from message import RequestData from netbase import comproxy from netbase.cmd_event_id import CmdId def command_func(p_context): current_package_data = p_context.get_serialize_object() data = RequestData(current_package_data) b = time.time() rsp = cmd.commands[data.command](**data.content) c = time.time() p_context.reply(rsp) log.dev_info('handler use {} ms'.format(str((c - b) * 1000))) def command_load_volume(p_context): current_package_data = p_context.get_serialize_object() root = os.path.dirname(os.path.abspath(__file__)).split('portal')[0]
def set_protocol(self, p, port): p.set_protocol(self) self.protocols.append(p) log.dev_info('create a new protocol on port {}'.format(port))
def package(self, data): size = len(data) return struct.pack('i', size) + data class ClientTransfer(Protocol): def __init__(self): pass def set_protocol(self, p): self.server = p self.server.transport.resumeProducing() pass def dataReceived(self, data): self.server.transport.write(data) pass if __name__ == '__main__': kwargs = get_args(sys.argv[1:]) host = kwargs['host'] if kwargs['host'] is not None else '0.0.0.0' port = kwargs['port'] if kwargs['port'] is not None else 0 factory = Factory() factory.protocol = Transfer reactor.listenTCP(port, factory) log.dev_info( "Dispatcher started, waiting for connection on port {}".format(port)) reactor.run()
self.dic['slicethickness'] = slicethickness self.dic['slicelocation'] = slicelocation self.dic['samplesperpixel'] = samplesperpixel self.dic['rescaleintercept'] = rescaleintercept self.dic['rescaleslope'] = rescaleslope self.dic['rescaletype'] = rescaletype return self.dic if __name__ == '__main__': filename = "D:/dcm/c_get/1.3.12.2.1107.5.1.4.64606.30000018071420505204600015281/" \ "CT.1.3.12.2.1107.5.1.4.64606.30000018071420505204600015282.dcm" dataset = pydicom.dcmread(filename) a = DcmPatient() patient_dic = a.get_dicom_patient(dataset) log.dev_info(patient_dic) b = DcmStudy() study_dic = b.get_dicom_study(dataset) log.dev_info(study_dic) c = DcmSeries() series_dic = c.get_dicom_series(dataset) log.dev_info(series_dic) d = DcmImage() image_dic = d.get_dicom_image(dataset) log.dev_info(image_dic)
def unpacking(self, data): size, = struct.unpack('i', data[:4]) log.dev_info('[Dispatcher]package size {} bytes'.format(size)) data = data[4:size + 4] return size, data
from netbase.c_log import log from netbase import comproxy from netbase.cmd_event_id import CmdId from ai_server_mgr import AIServerManager from process_manager import RenderManager def get_mac_address(): mac = uuid.UUID(int=uuid.getnode()).hex[-12:] return ":".join([mac[el:el + 2] for el in range(0, 11, 2)]) if __name__ == '__main__': log.create_log() log.set_source('WorkNode') log.dev_info('first log of work node on {}'.format(get_mac_address())) proxy = comproxy.PyCommProxy('work_node_{}'.format(get_mac_address())) render_srv_manager = RenderManager(proxy) render_srv_manager.create_srv(proxy.get_name(), 4) ai_srv_mgr = AIServerManager() #ai_srv_mgr.create_algor_srv(0, 'auto_segment', proxy.get_name()) def handle_run_algor_srv(p_context): info = json.loads(p_context.get_serialize_object()) gpu_id = info['gpu'] alg_name = info['alg_name'] if p_context.get_command_id() == CmdId.cmd_id_run_algor_srv: proxy_name = ai_srv_mgr.create_algor_srv(gpu_id, alg_name, proxy.get_name()) else:
def get(self, request): log.dev_info('路由分发后:{}'.format(str(time.time()))) log.dev_info('响应经由中间件前:{}'.format(str(time.time()))) return render(request, 'main.html')
# -*- coding: utf-8 -*- """ WSGI config for mytestone project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.11/howto/deployment/wsgi/ """ import os import sys sys.path.append('..') from netbase.c_log import log from django.core.wsgi import get_wsgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "back_end.settings") log.create_log() log.dev_info('enter web_be with uwsgi, print first log...') application = get_wsgi_application()
def post(self, request): """ uploading dicom files and parsing information to database :param request: a django rest framework request object :return: boolean true for success, false for failure """ log.dev_info('uploading...') file_name_list = [] files = request.FILES.getlist('a') if len(files) == 0: return Response('请选择上传文件') log.dev_info('upload {} files!'.format(len(files))) for f in files: file_name = os.path.join(file_path_ferry.dicomPath, f.name) destination = open(file_name, 'wb+') for chunk in f.chunks(): destination.write(chunk) destination.close() file_name_list.append(file_name) dataset_list = [] series_path_list = [] log.dev_info('上传完成,正在执行数据入库...') for file_name in file_name_list: try: dataset = pydicom.dcmread(file_name, force=True) sorter = DcmSorter() seriespath = sorter.split_series(file_name, dataset) series_path_list.append(seriespath) dataset_list.append(dataset) os.remove(file_name) except Exception as ex: log.dev_error('file name: {}, ex.message: {}'.format( file_name, ex.message)) patient_svc.upload_dcm(dataset_list, file_path_ferry.splitDicomPath) for seriespath in set(series_path_list): series_dir = str(seriespath).encode('GB2312') log.dev_info('begin data checking:' + series_dir) reply = data_checker.DataChecker().data_checking(series_dir) if 0 != reply: log.dev_error('data checking failed!' + series_dir) # return Response('dicom文件不符合规范,创建volume失败') continue log.dev_info('end data checking:' + series_dir) try: log.dev_info('begin build volume') builder = VolumeBuilder() volfilepath, seriesuid = builder.build(seriespath) except Exception as ex: log.dev_error('build volume failed!' + ex.message) # return Response(ex.message) continue log.dev_info('end build volume') try: series_svc.upload_volume(volfilepath, seriesuid) except Exception as e: # return Response(e.message) log.dev_error('upload volume failed!' + e.message) continue log.dev_info('end upload volume:' + seriesuid) return Response('success')