volview 4.0.0 → 4.0.1

package/server/helper.py

@@ -1,147 +0,0 @@
-import traceback
-import wslink
-from serialize import RpcDecoder, RpcEncoder, DEFAULT_DECODERS, DEFAULT_ENCODERS
-from wslink.websocket import LinkProtocol
-
-
-RPC_DEFERRED_TYPE = 'rpc.deferred'
-RPC_RESULT_TYPE = 'rpc.result'
-RPC_ERROR_TYPE = 'rpc.error'
-DEFERRED_RESPONSE_TYPE = 'deferred.response'
-
-
-class FutureResult(object):
-    def __init__(self, id):
-        self._id = id
-        self._done = False
-        self._result = None
-        self._exception = None
-        self._callbacks = []
-
-    def id(self):
-        return self._id
-
-    def done(self):
-        return self._done
-
-    def result(self):
-        if not self._done:
-            raise Exception('Future is not done')
-        return self._result
-
-    def exception(self):
-        if not self._done:
-            raise Exception('Future is not done')
-        return self._exception
-
-    def has_result(self):
-        return self._done and bool(self._result)
-
-    def has_exception(self):
-        return self._done and bool(self._exception)
-
-    def add_done_callback(self, cb):
-        self._callbacks.append(cb)
-
-    def remove_done_callback(self, cb):
-        self._callbacks.remove(cb)
-
-    def set_result(self, result):
-        if not self._done:
-            self._done = True
-            self._result = result
-            self._trigger_callbacks()
-
-    def set_exception(self, exception):
-        if not self._done:
-            self._done = True
-            self._exception = exception
-            self._trigger_callbacks()
-
-    def _trigger_callbacks(self):
-        for cb in self._callbacks:
-            try:
-                cb(self)
-            except:
-                pass
-
-
-def make_deferred_response(future):
-    return {
-        'type': RPC_DEFERRED_TYPE,
-        'id': future.id(),
-    }
-
-
-def make_result_response(result):
-    return {
-        'type': RPC_RESULT_TYPE,
-        'result': result,
-    }
-
-
-def make_error_response(exc):
-    return {
-        'type': RPC_ERROR_TYPE,
-        'error': str(exc),
-    }
-
-
-def deserialize(args, kwargs):
-    decoder = RpcDecoder(hooks=DEFAULT_DECODERS)
-    new_args = [decoder.decode(arg) for arg in args]
-    return new_args, kwargs
-
-
-def rpc(name):
-    def wrapper(fn):
-        def handler(self, *args, **kwargs):
-
-            try:
-                args, kwargs = deserialize(args, kwargs)
-                result = fn(self, *args, **kwargs)
-            except Exception as e:
-                traceback.print_exc()
-                return make_error_response(e)
-            else:
-                if type(result) is FutureResult:
-                    self._futures.append(result)
-                    result.set_done_callback(self._handle_future_result)
-                    return make_deferred_response(result.id())
-
-                return make_result_response(self.serialize(result))
-
-        return wslink.register(name)(handler)
-    return wrapper
-
-
-class RpcApi(LinkProtocol):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._futures = []
-
-    def _handle_future_result(self, future):
-        self._futures.remove(future)
-        self.publish('deferred.responses',
-                     self._make_deferred_result_response(future))
-
-    def _make_deferred_result_response(self, future):
-        if future.has_exception():
-            return {
-                'type': DEFERRED_RESPONSE_TYPE,
-                'id': future.id(),
-                'rpcResponse': make_error_response(future.exception())
-            }
-        return {
-            'type': DEFERRED_RESPONSE_TYPE,
-            'id': future.id(),
-            'rpcResponse': make_result_response(self.serialize(future.result()))
-        }
-
-    def serialize(self, obj):
-        try:
-            encoder = RpcEncoder(encoders=DEFAULT_ENCODERS,
-                                 extra_args=(self.addAttachment,))
-            return encoder.encode(obj)
-        except:
-            traceback.print_exc()

package/server/host.js

@@ -1,134 +0,0 @@
-/* eslint-disable-next-line max-classes-per-file */
-import WebsocketConnection from 'wslink/src/WebsocketConnection';
-import { defer } from '../src/utils/common';
-
-import { deserialize, serialize } from './serialize';
-
-/**
- * Matches a response against valid type names
- */
-function isValidResponse(response, types) {
-  const rtype = response?.type;
-  if (!types.includes(rtype)) {
-    return false;
-  }
-  switch (rtype) {
-    case 'rpc.result':
-      return 'result' in response;
-    case 'rpc.error':
-      return 'error' in response;
-    case 'rpc.deferred':
-      return 'id' in response;
-    case 'deferred.response':
-      return 'id' in response && 'rpcResponse' in response;
-    default:
-      return false;
-  }
-}
-
-export class RpcError extends Error {}
-
-export default class HostConnection {
-  constructor(wsUrl) {
-    this.ws = null;
-    this.wsUrl = wsUrl;
-    this.connected = false;
-    this.deferredResponses = new Map();
-  }
-
-  async connect() {
-    return new Promise((resolve, reject) => {
-      if (!this.connected) {
-        this.ws = WebsocketConnection.newInstance({ urls: this.wsUrl });
-
-        this.ws.onConnectionReady(() => {
-          this.connected = true;
-          this.session = this.ws.getSession();
-
-          this.session.subscribe(
-            'deferred.responses',
-            this.handleDeferredResponse
-          );
-
-          resolve();
-        });
-
-        this.ws.onConnectionClose(() => {
-          this.connected = false;
-        });
-
-        this.ws.onConnectionError(() => {
-          reject(new Error('Failed to connect to ws endpoint'));
-        });
-
-        this.ws.connect();
-      }
-    });
-  }
-
-  async disconnect() {
-    if (this.connected) {
-      this.ws.destroy();
-    }
-  }
-
-  async call(endpoint, ...args) {
-    if (!this.connected) {
-      throw new Error('Not connected');
-    }
-
-    const attach = (obj) => {
-      if (ArrayBuffer.isView(obj) && !(obj instanceof DataView)) {
-        return this.session.addAttachment(obj.buffer);
-      }
-      return obj;
-    };
-
-    const preparedArgs = args.map((arg) => serialize(arg, attach));
-
-    const response = await this.session.call(endpoint, preparedArgs);
-    return this.handleRpcResponse(response);
-  }
-
-  async handleRpcResponse(response) {
-    if (
-      !isValidResponse(response, ['rpc.result', 'rpc.error', 'rpc.deferred'])
-    ) {
-      throw new Error('Invalid response from rpc');
-    }
-
-    if (response.type === 'rpc.deferred') {
-      const deferred = defer();
-      this.deferredResponses.set(response.id, deferred);
-      return deferred.promise;
-    }
-
-    if (response.type === 'rpc.error') {
-      throw new RpcError(response.error);
-    }
-
-    const result = await deserialize(response.result);
-    return result;
-  }
-
-  async handleDeferredResponse(response) {
-    if (!isValidResponse(response, ['deferred.result'])) {
-      throw new Error('Invalid deferred response');
-    }
-
-    const { id } = response;
-    if (!this.deferredResponses.has(id)) {
-      throw new Error('Received a deferred response for a nonexistent call');
-    }
-
-    const deferred = this.deferredResponses.get(id);
-    this.deferredResponses.delete(id);
-
-    try {
-      const result = await this.handleRpcResponse(response.rpcResponse);
-      deferred.resolve(result);
-    } catch (e) {
-      deferred.reject(e);
-    }
-  }
-}

package/server/serialize.js

@@ -1,111 +0,0 @@
-import vtk from '@kitware/vtk.js/vtk';
-
-export const BREAK = Symbol('Break');
-
-export function vtkObjectReplacer(vo) {
-  if (vo?.isA?.('vtkObject')) {
-    return vo.getState();
-  }
-  return vo;
-}
-
-export function vtkDataArrayJSONReplacer(da, attach) {
-  if (da?.classHierarchy?.includes?.('vtkDataArray')) {
-    const values = new globalThis[da.dataType](da.values);
-    return {
-      ...da,
-      values: attach(values),
-    };
-  }
-  return da;
-}
-
-/**
- * Serializes typed arrays into regular arrays
- */
-export function typedArrayReplacer(ta) {
-  if (ArrayBuffer.isView(ta) && !(ta instanceof DataView)) {
-    return Array.from(ta);
-  }
-  return ta;
-}
-
-export async function vtkDataArrayValueReviver(da) {
-  if (da?.vtkClass === 'vtkDataArray' && da?.values instanceof Blob) {
-    const ab = await da.values.arrayBuffer();
-    return {
-      ...da,
-      values: new globalThis[da.dataType](ab),
-    };
-  }
-  return da;
-}
-
-export function vtkObjectReviver(obj) {
-  if ('vtkClass' in obj) {
-    return vtk(obj);
-  }
-  return obj;
-}
-
-const REPLACERS = [
-  vtkObjectReplacer,
-  vtkDataArrayJSONReplacer,
-  typedArrayReplacer,
-];
-
-const REVIVERS = [
-  vtkDataArrayValueReviver,
-  // should be after the vtkDataArrayValueReviver
-  vtkObjectReviver,
-];
-
-export function serialize(obj, attach) {
-  return JSON.parse(
-    JSON.stringify(obj, (key, value) => {
-      let transformed = value;
-      for (let i = 0; i < REPLACERS.length; i += 1) {
-        const result = REPLACERS[i](transformed, attach);
-        if (result === BREAK) {
-          break;
-        }
-        transformed = result;
-      }
-      return transformed;
-    })
-  );
-}
-
-export async function deserialize(obj) {
-  async function revive(o) {
-    let transformed = o;
-    for (let i = 0; i < REVIVERS.length; i += 1) {
-      // eslint-disable-next-line no-await-in-loop
-      const result = await REVIVERS[i](transformed);
-      if (result === BREAK) {
-        break;
-      }
-      transformed = result;
-    }
-    return transformed;
-  }
-
-  async function recurseHelper(o) {
-    if (Array.isArray(o)) {
-      const newArray = await Promise.all(o.map((item) => recurseHelper(item)));
-      return revive(newArray);
-    }
-    if (o instanceof Object && o.constructor === Object) {
-      const newO = {};
-      await Promise.all(
-        Object.keys(o).map(async (k) => {
-          newO[k] = await recurseHelper(o[k]);
-        })
-      );
-      return revive(newO);
-    }
-    return o;
-  }
-
-  return recurseHelper(obj);
-}

package/server/serialize.py

@@ -1,203 +0,0 @@
-import json
-import struct
-import itk
-import numpy as np
-
-JS_TO_NPY_TYPEMAP = {
-    'Int8Array': {
-        'struct': (1, 'b'),
-        'dtype': 'int8',
-    },
-    'Int16Array': {
-        'struct': (2, 'h'),
-        'dtype': 'int16',
-    },
-    'Int32Array': {
-        'struct': (4, 'i'),
-        'dtype': 'int32',
-    },
-    'Uint8Array': {
-        'struct': (1, 'B'),
-        'dtype': 'uint8',
-    },
-    'Uint16Array': {
-        'struct': (2, 'H'),
-        'dtype': 'uint16',
-    },
-    'Uint32Array': {
-        'struct': (4, 'I'),
-        'dtype': 'uint32',
-    },
-    'Float32Array': {
-        'struct': (4, 'f'),
-        'dtype': 'float32',
-    },
-    'Float64Array': {
-        'struct': (8, 'd'),
-        'dtype': 'float64',
-    },
-}
-
-ITK_COMP_TO_JS_TYPEMAP = {
-    'SC': 'Int8Array',
-    'UC': 'Uint8Array',
-    'SS': 'Int16Array',
-    'US': 'Uint16Array',
-    'SI': 'Int32Array',
-    'UI': 'Uint32Array',
-    'F': 'Float32Array',
-    'D': 'Float64Array',
-    'B': 'Uint8Array'
-}
-
-
-def bytebuffer_to_numpy(blob, js_type):
-    typeinfo = JS_TO_NPY_TYPEMAP[js_type]
-    size, fmt = typeinfo['struct']
-    dtype = np.dtype(typeinfo['dtype'])
-
-    if len(blob) % size != 0:
-        raise ValueError('given byte buffer is not aligned to the type')
-
-    full_fmt = '<{0}{1}'.format(len(blob) // size, fmt)
-    return np.array(struct.unpack(full_fmt, blob), dtype=dtype, copy=False)
-
-
-def itk_image_pixel_type_to_js(itk_image):
-    component_str = repr(itk_image).split(
-        'itkImagePython.')[1].split(';')[0][8:]
-    # TODO handle mangling as per https://github.com/InsightSoftwareConsortium/itk-jupyter-widgets/blob/master/itkwidgets/trait_types.py#L49
-    return ITK_COMP_TO_JS_TYPEMAP[component_str[:-1]]
-
-
-class RpcEncoder(object):
-    def __init__(self, encoders=[], extra_args=[], extra_kwargs={}):
-        self._encoders = list(encoders)
-        self._extra_args = extra_args
-        self._extra_kwargs = extra_kwargs
-
-    def add_encoder(self, encoder):
-        self._encoders.append(encoder)
-
-    def remove_encoder(self, encoder):
-        self._encoders.remove(encoder)
-
-    def run_encoders(self, obj):
-        output = obj
-        for encoder in self._encoders:
-            output = encoder(output, *self._extra_args, **self._extra_kwargs)
-        return output
-
-    def encode(self, obj):
-        # run on every possible value
-        if isinstance(obj, list):
-            return self.run_encoders([self.encode(item) for item in obj])
-        if isinstance(obj, dict):
-            return self.run_encoders({k: self.encode(v) for k, v in obj.items()})
-        else:
-            return self.run_encoders(obj)
-
-
-class RpcDecoder(object):
-    def __init__(self, hooks=[], extra_args=[], extra_kwargs={}):
-        self._hooks = list(hooks)
-        self._extra_args = extra_args
-        self._extra_kwargs = extra_kwargs
-
-    def add_hook(self, hook):
-        self._hooks.append(hook)
-
-    def remove_hook(self, hook):
-        self._hooks.remove(hook)
-
-    def run_hooks(self, val):
-        output = val
-        for hook in self._hooks:
-            output = hook(output, *self._extra_args, **self._extra_kwargs)
-        return output
-
-    def decode(self, obj):
-        # only run hooks on dictionaries
-        if isinstance(obj, list):
-            return [self.decode(item) for item in obj]
-        if isinstance(obj, dict):
-            return self.run_hooks({k: self.decode(v) for k, v in obj.items()})
-        else:
-            return obj
-
-
-def itk_image_encoder(obj, attach):
-    if type(obj).__name__.startswith('itkImage'):
-        img = obj
-        size = list(img.GetLargestPossibleRegion().GetSize())
-        values = itk.GetArrayFromImage(img).flatten(order='C')
-        return {
-            'vtkClass': 'vtkImageData',
-            'dataDescription': 8,
-            'direction': list(
-                itk.GetArrayFromVnlMatrix(
-                    img.GetDirection().GetVnlMatrix().as_matrix()
-                ).flatten()
-            ),
-            'extent': [
-                0, size[0] - 1,
-                0, size[1] - 1,
-                0, size[2] - 1,
-            ],
-            'spacing': list(img.GetSpacing()),
-            'origin': list(img.GetOrigin()),
-            'pointData': {
-                'vtkClass': 'vtkDataSetAttributes',
-                'activeScalars': 0,  # the index of the only array
-                'arrays': [
-                    {
-                        'data': {
-                            'vtkClass': 'vtkDataArray',
-                            'size': len(values),
-                            'values': attach(values.tobytes()),
-                            'dataType': itk_image_pixel_type_to_js(img),
-                            'numberOfComponents': img.GetNumberOfComponentsPerPixel(),
-                            'name': 'Scalars',
-                        }
-                    }
-                ]
-            }
-        }
-    return obj
-
-
-def itk_image_decode_hook(obj):
-    if isinstance(obj, dict) and obj.get('vtkClass', None) == 'vtkImageData':
-        data_array = obj['pointData']['arrays'][0]['data']
-        pixel_data = bytebuffer_to_numpy(
-            data_array['values'], data_array['dataType'])
-
-        extent = obj['extent']
-        # numpy indexes in ZYX order, where X varies the fastest
-        dims = [
-            extent[5] - extent[4] + 1,
-            extent[3] - extent[2] + 1,
-            extent[1] - extent[0] + 1,
-        ]
-        direction = np.zeros((3, 3))
-        for x in range(3):
-            for y in range(3):
-                direction[x][y] = obj['direction'][x*3+y]
-
-        itk_image = itk.GetImageFromArray(np.reshape(pixel_data, dims))
-        # https://discourse.itk.org/t/set-image-direction-from-numpy-array/844/10
-        vnlmat = itk.GetVnlMatrixFromArray(direction)
-        itk_image.GetDirection().GetVnlMatrix().copy_in(vnlmat.data_block())
-        itk_image.SetOrigin(obj['origin'])
-        itk_image.SetSpacing(obj['spacing'])
-        return itk_image
-    return obj
-
-
-DEFAULT_DECODERS = [
-    itk_image_decode_hook,
-]
-
-DEFAULT_ENCODERS = [
-    itk_image_encoder,
-]

package/server/server.py

@@ -1,84 +0,0 @@
-import sys
-import os
-import webbrowser
-import socket
-import argparse
-import importlib
-
-from wslink.websocket import ServerProtocol
-from wslink import server
-from twisted.internet import reactor
-
-
-def get_port():
-    # Don't care about race condition here for getting a free port
-    # if someone binds the port between get_port() and actually binding,
-    # then the server won't start
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.bind(('localhost', 0))
-    _, port = sock.getsockname()
-    sock.close()
-    return port
-
-
-def create_protocol(ApiClass):
-    class ApiProtocol(ServerProtocol):
-        authKey = 'wslink-secret'
-
-        @staticmethod
-        def configure(options):
-            ApiProtocol.authKey = options.authKey
-
-        def initialize(self):
-            self.registerLinkProtocol(ApiClass())
-            self.updateSecret(ApiProtocol.authKey)
-
-    return ApiProtocol
-
-
-if __name__ == '__main__':
-    # https://stackoverflow.com/questions/7674790/bundling-data-files-with-pyinstaller-onefile
-    try:
-        basepath = sys._MEIPASS
-    except:
-        basepath = os.path.dirname(os.path.dirname(sys.argv[0]))
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-H', '--host', default='localhost',
-                        help='Hostname for server to listen on')
-    parser.add_argument('-P', '--port', default=get_port(),
-                        help='Port for server to listen on')
-    parser.add_argument('-b', '--no-browser', action='store_true',
-                        help='Do not auto-open the browser')
-    parser.add_argument('api_script',
-                        help='Python file that exposes ServerApi')
-    args = parser.parse_args()
-
-    static_dir = os.path.join(basepath, 'www')
-    host = args.host
-    port = args.port
-    server_args = [
-        '--content', static_dir,
-        '--host', host,
-        '--port', str(port)
-    ]
-
-    wsurl = 'ws://{host}:{port}/ws'.format(host=host, port=port)
-    full_url = 'http://{host}:{port}/?wsServer={wsurl}'.format(
-        host=host, port=port, wsurl=wsurl)
-
-    def open_webapp():
-        webbrowser.open(full_url)
-
-    # if not args.no_browser:
-    #    print('If the browser doesn\'t open, navigate to:', full_url)
-    #    reactor.callLater(0.1, open_webapp)
-
-    sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-
-    spec = importlib.util.spec_from_file_location('Api', args.api_script)
-    api_module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(api_module)
-
-    server.start(server_args, create_protocol(api_module.Api))
-    server.stop_webserver()

package/server/test.py

@@ -1,17 +0,0 @@
-import itk
-import json
-from helper import RpcApi, rpc
-
-
-class Api(RpcApi):
-
-    @rpc('run')
-    def test(self, arg1, arg2):
-        print(type(arg1), type(arg2), arg2)
-        with open('spleen_10.json', 'r') as fp:
-            mm = json.load(fp)
-        return {
-            'segmentation': itk.imread('spleen_10-label.nrrd'),
-            # 'segmentation': itk.imread('/home/forrestli/data/Branch-label.nrrd'),
-            'measurements': mm,
-        }