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')
