def saveLandmarkModel(ls, dirsave, ptcode, ctcode, cropname, what):
    """ Save graph with landmarks; do not store volumes again
    Use within or outside class LandmarkSelector
    """
    import os

    s = ls.s
    s2 = ls.s_landmarks
    s2.sampling = s.sampling
    s2.origin = s.origin
    s2.stenttype = s.stenttype
    s2.croprange = s.croprange  # keep for reference
    for key in dir(s):
        if key.startswith('meta'):
            suffix = key[4:]
            s2['meta' + suffix] = s['meta' + suffix]
    s2.what = what
    s2.params = 'LandmarkSelector'
    s2.stentType = s.stenttype

    # Save
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname,
                                     'landmarks' + what)
    ssdf.save(os.path.join(dirsave, filename), s2)
    print('')
    print('saved to disk to {}.'.format(os.path.join(dirsave, filename)))
Exemple #2
0
    def set(self, key, object, save_now=True):
        """ set(key, object, save_now=True)
        
        Add an object to the database, using the given key.
        If save_now is True, will save the database to disk now.
        
        """

        # Correct key
        key = self._key2key(key)
        #print 'set', key

        # Test object
        if ssdf.isstruct(object):
            pass
        if isinstance(object, (int, float, str, np.ndarray, tuple, list)):
            pass  # Default ssdf compatible
        elif ssdf.is_compatible_class(object):
            pass  # Compatible
        else:
            raise ValueError('The given object is not ssdf compatible.')

        # Store last key
        self._lastkey = key

        # Store object in db
        self._db[key] = object

        # Save?
        if save_now and self._fname:
            ssdf.save(self._fname, self._db)
Exemple #3
0
def save_segmentation(basedir, ptcode, ctcode, cropname, seeds, model, s, 
                      stentType=None, what='avgreg', params=None):
    """ store segmentation in new ssdf or load and add
    s = ssdf of volume from which we segment
    s2 = ssdf of segmentation model
    """
    # Build struct
    s2 = vv.ssdf.new()
    # We do not need croprange, but keep for reference
    s2.sampling = s.sampling
    s2.origin = s.origin
    s2.stenttype = s.stenttype
    s2.croprange = s.croprange
    for key in dir(s):
            if key.startswith('meta'):
                suffix = key[4:]
                s2['meta'+suffix] = s['meta'+suffix]
    s2.what = what
    s2.params = params
    s2.stentType = stentType
    # Store model
    s2.model = model.pack()
    s2.seeds = seeds.pack()
    
    # Save
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'model'+what)
    ssdf.save(os.path.join(basedir, ptcode, filename), s2)
    print('saved to disk in {} as {}.'.format(basedir, filename) )
Exemple #4
0
def add_segmentation_ssdf(basedir, ptcode, ctcode, cropname, seeds, model,  
                        graphname, s2=None, modelname='modelavgreg', 
                        stentType=None, params=None):
    """ Add a model to an existing ssdf but separate from the existing graph
    s2 = ssdf of existing model to add new segmentation graph in ssdf
    graphname = name of new graph to save in ssdf
    """
    if s2 is None:
        s2 = loadmodel(basedir, ptcode, ctcode, cropname, modelname) # unpacks to graph
    s2['params'+graphname] = params
    s2['stentType'+graphname] = stentType
    # Store model
    if model is not None: # step 2 and 3 were performed otherwise NoneType
        s2['model'+graphname] = model
        s2['seeds'+graphname] = seeds
    else: # store seeds as model
        s2['model'+graphname] = seeds.copy()
        s2['seeds'+graphname] = seeds
    
    # pack all graphs to ssdf for save
    for key in dir(s2):
        if key.startswith('model'):
            s2[key] = s2[key].pack()
        if key.startswith('seeds'):
            s2[key] = s2[key].pack()
    
    # Save
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, modelname)
    ssdf.save(os.path.join(basedir, ptcode, filename), s2)
    print('saved to disk in {} as {}.'.format(basedir, filename) )
Exemple #5
0
def make_model_dynamic(basedir, ptcode, ctcode, cropname, what='avgreg'):
    """ Read deforms and model to make model dynamic, ie, add deforms to edges
    and nodes in the graph
    """
    # Load deforms
    s = loadvol(basedir, ptcode, ctcode, cropname, 'deforms')
    deformkeys = []
    for key in dir(s):
        if key.startswith('deform'):
            deformkeys.append(key)
    deforms = [s[key] for key in deformkeys]
    deforms = [pirt.DeformationFieldBackward(*fields) for fields in deforms]
    paramsreg = s.params
    
    # Load model
    s = loadmodel(basedir, ptcode, ctcode, cropname, 'model'+what)
    for key in dir(s):
        if key.startswith('model'):
            model = s[key]
        
            # Combine ...
            incorporate_motion_nodes(model, deforms, s.origin) # adds deforms PointSets
            incorporate_motion_edges(model, deforms, s.origin) # adds deforms PointSets
        
            s[key] = model.pack()
        
        # also pack seeds before save
        if key.startswith('seeds'):
            s[key] = s[key].pack()
            
    # Save back
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'model'+what)
    s.paramsreg = paramsreg
    ssdf.save(os.path.join(basedir, ptcode, filename), s)
    print('saved dynamic to disk in {} as {}.'.format(basedir, filename) )
Exemple #6
0
def cropaveraged(basedir,
                 ptcode,
                 ctcode,
                 crop_in='stent',
                 what='avg5090',
                 crop_out='body'):
    """ Crop averaged volume of stent
    With loadvol, load ssdf containing an averaged volume and save new cropped ssdf
    """
    s = loadvol(basedir, ptcode, ctcode, crop_in, what)
    vol = s.vol

    # Open cropper tool
    print('Set the appropriate cropping range for "%s" '
          'and click finish to continue' % crop_out)
    print('Loading... be patient')
    fig = vv.figure()
    fig.title = 'Cropping for "%s"' % crop_out
    vol_crop = cropper.crop3d(vol, fig)
    fig.Destroy()

    if vol_crop.shape == vol.shape:
        raise RuntimeError('User cancelled (no crop)')

    # Calculate crop range from origin
    rz = int(vol_crop.origin[0] / vol_crop.sampling[0] + 0.5)
    rz = rz, rz + vol_crop.shape[0]
    ry = int(vol_crop.origin[1] / vol_crop.sampling[1] + 0.5)
    ry = ry, ry + vol_crop.shape[1]
    rx = int(vol_crop.origin[2] / vol_crop.sampling[2] + 0.5)
    rx = rx, rx + vol_crop.shape[2]

    # Initialize struct
    s2 = ssdf.new()
    s2.sampling = vol_crop.sampling  # z, y, x voxel size in mm
    s2.stenttype = s.stenttype
    for key in dir(s):
        if key.startswith('meta'):
            suffix = key[4:]
            s2['meta' + suffix] = s['meta' + suffix]

    # Set new croprange, origin and vol
    offset = [i[0] for i in s.croprange]  # origin of crop_in
    s2.croprange = ([rz[0] + offset[0], rz[1] + offset[0]
                     ], [ry[0] + offset[1], ry[1] + offset[1]],
                    [rx[0] + offset[2], rx[1] + offset[2]])
    s2.origin = vol_crop.origin
    s2.vol = vol_crop

    # Export and save
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, crop_out, what)
    file_out = os.path.join(basedir, ptcode, filename)
    ssdf.save(file_out, s2)
Exemple #7
0
    def test_pack1(self):
        # Custom stent
        g = StentGraph(summary='dit is een stent!', lala=3)
        g.add_node((10, 20), foo=3)
        g.add_node((30, 40), foo=5)
        g.add_edge((1, 1), (2, 2), bar=10)
        g.add_edge((10, 20), (1, 1), bar=20)

        fname = '/home/almar/test.ssdf'
        ssdf.save(fname, g.pack())

        g2 = StentGraph()
        g2.unpack(ssdf.load(fname))

        #print(nx.is_isomorphic(g, g2))
        assert nx.is_isomorphic(g, g2)
def makeLandmarkModelDynamic(basedir,
                             ptcode,
                             ctcode,
                             cropname,
                             what='landmarksavgreg',
                             savedir=None):
    """ Make model dynamic with deforms from registration 
        (and store/overwrite to disk)
    """
    #todo: change in default and merge with branch landmarks?
    import pirt
    from stentseg.motion.dynamic import (incorporate_motion_nodes,
                                         incorporate_motion_edges)
    from visvis import ssdf
    import os

    if savedir is None:
        savedir = basedir
    # Load deforms
    s = loadvol(basedir, ptcode, ctcode, cropname, 'deforms')
    deformkeys = []
    for key in dir(s):
        if key.startswith('deform'):
            deformkeys.append(key)
    deforms = [s[key] for key in deformkeys]
    deforms = [pirt.DeformationFieldBackward(*fields) for fields in deforms]
    paramsreg = s.params

    # Load model where landmarks were stored
    # s2 = loadmodel(savedir, ptcode, ctcode, cropname, what)
    fname = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, what)
    s2 = ssdf.load(os.path.join(savedir, fname))
    # Turn into graph model
    model = stentgraph.StentGraph()
    model.unpack(s2[what])

    # Combine ...
    incorporate_motion_nodes(model, deforms, s2.origin)
    incorporate_motion_edges(model, deforms, s2.origin)

    # Save back
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, what)
    s2.model = model.pack()
    s2.paramsreg = paramsreg
    ssdf.save(os.path.join(savedir, filename), s2)
    print('saved to disk to {}.'.format(os.path.join(savedir, filename)))
Exemple #9
0
    def test_pack2(self):
        # Auto generate
        import random
        n = 500
        p = dict(
            (i, (random.gauss(0, 2), random.gauss(0, 2))) for i in range(n))
        g_ = nx.random_geometric_graph(n, 0.1, dim=3, pos=p)

        g = StentGraph(summary='dit is een stent!', lala=3)
        g.add_nodes_from(g_.nodes_iter())
        g.add_edges_from(g_.edges_iter())

        fname = '/home/almar/test.ssdf'
        ssdf.save(fname, g.pack())

        g2 = StentGraph()
        g2.unpack(ssdf.load(fname))

        #print(nx.is_isomorphic(g, g2))
        assert nx.is_isomorphic(g, g2)
Exemple #10
0
    def save(self, fname=None):
        """ save(fname=None)
        
        Save the results to disk now. If fname is not given, the last used
        fname is used. If there is no fname available, will raise a runtime
        error.
        
        """

        # Use given or stored fname?
        if fname is None:
            fname = self._fname
        else:
            self._fname = fname

        # Check if there is an fname available
        if fname is None:
            raise RuntimeError('No known filename to write to.')

        # Save
        ssdf.save(fname, self._db)
Exemple #11
0
def saveaveraged(basedir, ptcode, ctcode, cropname, phases):
    """ Step C: Save average of a number of volumes (phases in cardiac cycle)
    Load ssdf containing all phases and save averaged volume as new ssdf
    """

    filename = '%s_%s_%s_phases.ssdf' % (ptcode, ctcode, cropname)
    file_in = os.path.join(basedir, ptcode, filename)
    if not os.path.exists(file_in):
        raise RuntimeError('Could not find ssdf for given input %s' % ptcode,
                           ctcode, cropname)
    s = ssdf.load(file_in)
    s_avg = ssdf.new()
    averaged = np.zeros(s.vol0.shape, np.float64)
    if phases[1] < phases[0]:
        phaserange = list(range(0, 100, 10))
        for i in range(phases[1] + 10, phases[0], 10):
            phaserange.remove(i)
    else:
        phaserange = range(phases[0], phases[1] + 10, 10)
    for phase in phaserange:
        averaged += s['vol%i' % phase]
        s_avg['meta%i' % phase] = s['meta%i' % phase]
    averaged *= 1.0 / len(phaserange)
    averaged = averaged.astype('float32')

    s_avg.vol = averaged
    s_avg.sampling = s.sampling  # z, y, x voxel size in mm
    s_avg.origin = s.origin
    s_avg.stenttype = s.stenttype
    s_avg.croprange = s.croprange
    s_avg.ctcode = s.ctcode
    s_avg.ptcode = s.ptcode

    avg = 'avg' + str(phases[0]) + str(phases[1])
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, avg)
    file_out = os.path.join(basedir, ptcode, filename)
    ssdf.save(file_out, s_avg)
Exemple #12
0
def add_segmentation_graph(basedir, ptcode, ctcode, cropname, seeds, model, 
                        s2=None, graphname='', modelname='modelavgreg'):
    """ add segmentation to an existing graph
    s2 = ssdf of existing segmentation model to add graph to this model
    graphname = model is default storename for model but can also be
                modelbranch for example if this was used in add_segmentation_ssdf
    """
    if s2 is None:
        s2 = loadmodel(basedir, ptcode, ctcode, cropname, modelname) # unpacks
        
    graphold = s2['model'+graphname]
    seedsold = s2['seeds'+graphname]
    
    # add seeds graph
    seedsold.add_nodes_from(seeds.nodes(data=True)) # including attributes if any
    # add nodes and edges to graph model
    if model is not None: # step 2 and 3 were performed otherwise NoneType
        graphold.add_nodes_from(model.nodes(data=True))
        graphold.add_edges_from(model.edges(data=True))
    else: # store seeds with model
        graphold.add_nodes_from(seeds.nodes(data=True))
    
    # Store model
    s2['model'+graphname] = graphold
    s2['seeds'+graphname] = seedsold
    
    # pack all graphs to ssdf for save
    for key in dir(s2):
        if key.startswith('model'):
            s2[key] = s2[key].pack()
        if key.startswith('seeds'):
            s2[key] = s2[key].pack()
    
    # Save
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, modelname)
    ssdf.save(os.path.join(basedir, ptcode, filename), s2)
    print('saved to disk in {} as {}.'.format(basedir, filename) )
        # s2.stenttype = s.stenttype
        # s2.croprange = s.croprange

        # Obtain deform fields
        for i in range(N):
            fields = [field for field in reg.get_deform(i).as_backward()
                      ]  # fields of z,y,x
            s2['deform%i' % i] = fields
        s2.sampling = s2.deform0[
            0].sampling  # Sampling of deform is different!
        s2.originDeforms = s2.deform0[0].origin  # But origin is zero
        s2.params = reg.params

        # Save
        filename = '%s_%s.ssdf' % (fileTr, 'deforms')
        ssdf.save(os.path.join(dirsaveinsilico, ptcode, filename), s2)
        print("deforms saved to disk.")

        # Store averaged volume, where the volumes are registered
        # create average volume from *all* volumes deformed to the "center"
        N = len(reg._ims)
        mean_vol = np.zeros(reg._ims[0].shape, 'float64')
        for i in range(N):
            vol, deform = reg._ims[i], reg.get_deform(i)  # reg._ims[0]==volOr
            mean_vol += deform.as_backward().apply_deformation(vol)
        mean_vol *= 1.0 / N

        # Create struct
        s_avg = ssdf.new()
        #s_avg.meta = s['meta'+oriPhase]
        s_avg.sampling = sampling2  # z, y, x
Exemple #14
0
        s = processFont(fontname)
        ss.append(s)

    # process to pack together
    sr, sb, si = ss[0], ss[1], ss[2]
    for fonttype in ['b', 'i']:
        s = ss[{'b': 1, 'i': 2}[fonttype]]
        # cut interesting part of image in i or b
        [Iy, Ix] = np.where(s.data > 0)
        y1 = Iy.max()
        data = s.data[0:y1 + 1, :]
        # paste that part in image of regular
        [Iy, Ix] = np.where(sr.data > 0)
        y1 = Iy.max()
        y2 = y1 + data.shape[0]
        sr.data[y1:y2] = data
        # correct origin of chars
        for i in range(s.origin.shape[0]):
            s.origin[i, 1] += y1
        # copy information to struct of sr
        sr['charcodes_' + fonttype] = s.charcodes
        sr['origin_' + fonttype] = s.origin
        sr['size_' + fonttype] = s.size
        sr['width_' + fonttype] = s.width

    # store
    base[font] = sr

ssdf.save(path + 'fonts.ssdf', base)
ssdf.save(path + '../visvisResources/fonts.ssdf', base)
Exemple #15
0
def on_key(event):
    """KEY commands for user interaction
        'DELETE   = remove seed in nodes1 closest to [picked point]'
        'PageDown = remove graph posterior (y-axis) to [picked point] (use for spine seeds)'
        'n = add [picked point] (SHIFT+R-click) as seed'
    """
    global label
    global sd
    if event.key == vv.KEY_DELETE:
        if len(selected_nodes) == 0:
            # remove node closest to picked point
            node = _utils_GUI.snap_picked_point_to_graph(sd._nodes1,
                                                         vol,
                                                         label,
                                                         nodesOnly=True)
            sd._nodes1.remove_node(node)
            view = a1.GetView()
            a1.Clear()
            label = DrawModelAxes(vol,
                                  sd._nodes1,
                                  a1,
                                  clim=clim,
                                  showVol=showVol,
                                  removeStent=False)
            a1.SetView(view)
    if event.text == 'n':
        # add picked seed to nodes_1
        coord2 = get_picked_seed(vol, label)
        sd._nodes1.add_node(tuple(coord2))
        view = a1.GetView()
        point = vv.plot(coord2[0],
                        coord2[1],
                        coord2[2],
                        mc='b',
                        ms='o',
                        mw=8,
                        alpha=0.5,
                        axes=a1)
        a1.SetView(view)
    if event.key == vv.KEY_PAGEDOWN:
        # remove false seeds posterior to picked point, e.g. for spine
        label = _utils_GUI.remove_nodes_by_selected_point(sd._nodes1,
                                                          vol,
                                                          a1,
                                                          label,
                                                          clim,
                                                          showVol=showVol)
    if event.text == 't':
        # redo step1
        view = a1.GetView()
        a1.Clear()
        sd._params = p
        sd.Step1()
        label = DrawModelAxes(vol,
                              sd._nodes1,
                              a1,
                              clim=clim,
                              showVol=showVol,
                              removeStent=False)  # lc, mc
        a1.SetView(view)
    if event.key == vv.KEY_ESCAPE:
        model = sd._nodes1
        # Build struct
        s2 = vv.ssdf.new()
        # We do not need croprange, but keep for reference
        s2.sampling = s.sampling
        s2.origin = s.origin
        s2.stenttype = s.stenttype
        s2.croprange = s.croprange
        for key in dir(s):
            if key.startswith('meta'):
                suffix = key[4:]
                s2['meta' + suffix] = s['meta' + suffix]
        s2.what = what
        s2.params = p
        s2.stentType = stentType
        # Store model
        s2.model = model.pack()
        # get filename
        filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname,
                                         'stentseeds' + what)
        # check if file already exists to not overwrite automatically
        if os.path.exists(os.path.join(dirsave, ptcode, filename)):
            #todo: shell jams after providing answer?
            print('File already exists')
            answer = str(
                input("\nWould you like to"
                      " overwrite (y), save different (u) or cancel (c)? "))
            if answer == 'u':
                filename = '%s_%s_%s_%s_2.ssdf' % (ptcode, ctcode, cropname,
                                                   'stentseeds' + what)
                ssdf.save(os.path.join(dirsave, ptcode, filename), s2)
                print("Ssdf saved to:")
                print(os.path.join(dirsave, ptcode))
            elif answer == 'y':
                ssdf.save(os.path.join(dirsave, ptcode, filename), s2)
                print("Ssdf saved to:")
                print(os.path.join(dirsave, ptcode))
        else:
            try:  # check folder existance
                ssdf.save(os.path.join(dirsave, ptcode, filename), s2)
            except FileNotFoundError:  # if dirsave does not exist, create
                os.makedirs(os.path.join(dirsave, ptcode))
                ssdf.save(os.path.join(dirsave, ptcode, filename), s2)
            print("Ssdf saved to:")
            print(os.path.join(dirsave, ptcode))
Exemple #16
0
def on_key(event):
    """KEY commands for user interaction
        'UP/DOWN  = show/hide nodes'
        'DELETE   = remove edge [select 2 nodes] or pop node [select 1 node] '
                   'or remove seed in nodes1 closest to [picked point]'
        'PageDown = remove graph posterior (y-axis) to [picked point] (use for spine seeds)'
        'ALT      = clean graph: remove residual clusters, pop, corner'
        'CTRL+SHIFT = add [picked point] (SHIFT+R-click) as seed'
    """
    global label
    global node_points
    global sd
    if event.key == vv.KEY_DOWN:
        # hide nodes
        t1.visible = False
        t2.visible = False
        t3.visible = False
        for node_point in node_points:
            node_point.visible = False
    if event.key == vv.KEY_UP:
        # show nodes
        for node_point in node_points:
            node_point.visible = True
    if event.key == vv.KEY_DELETE:
        if len(selected_nodes) == 0:
            # remove node closest to picked point
            node = _utils_GUI.snap_picked_point_to_graph(sd._nodes1,
                                                         vol,
                                                         label,
                                                         nodesOnly=True)
            sd._nodes1.remove_node(node)
            view = a1.GetView()
            a1.Clear()
            label = DrawModelAxes(vol,
                                  sd._nodes1,
                                  a1,
                                  clim=clim,
                                  showVol=showVol,
                                  removeStent=False)
            a1.SetView(view)
        if len(selected_nodes) == 2:
            # remove edge
            select1 = selected_nodes[0].node
            select2 = selected_nodes[1].node
            c = sd._nodes3.edge[select1][select2]['cost']
            ct = sd._nodes3.edge[select1][select2]['ctvalue']
            path = sd._nodes3.edge[select1][select2]['path']
            l = stentgraph._edge_length(sd._nodes3, select1, select2)
            sd._nodes3.remove_edge(select1, select2)
            stentgraph.pop_nodes(sd._nodes3)  # pop residual nodes
            # Visualize removed edge, show keys and deselect nodes
            selected_nodes[1].faceColor = 'b'
            selected_nodes[0].faceColor = 'b'
            selected_nodes.clear()
            t1.text = 'Edge ctvalue: \b{%1.2f HU}' % ct
            t2.text = 'Edge cost: \b{%1.7f }' % c
            t3.text = 'Edge length: \b{%1.2f mm}' % l
            t1.visible = True
            t2.visible = True
            t3.visible = True
            view = a3.GetView()
            pp = Pointset(path)
            line = vv.solidLine(pp, radius=0.2)
            line.faceColor = 'r'
            # a3.SetView(view)
        if len(selected_nodes) == 1:
            # pop node
            select1 = selected_nodes[0].node
            stentgraph._pop_node(sd._nodes3, select1)  # asserts degree == 2
            selected_nodes[0].faceColor = 'w'
            selected_nodes.clear()
    if event.key == vv.KEY_ALT:
        # ALT will FINISH model
        stentgraph.prune_clusters(sd._nodes3,
                                  3)  #remove residual nodes/clusters
        stentgraph.pop_nodes(sd._nodes3)
        stentgraph.add_corner_nodes(sd._nodes3,
                                    th=sd._params.graph_angleVector,
                                    angTh=sd._params.graph_angleTh)
        # Create mesh and visualize
        view = a3.GetView()
        a3.Clear()
        DrawModelAxes(vol,
                      sd._nodes3,
                      a3,
                      meshColor=meshColor,
                      clim=clim,
                      showVol=showVol,
                      lc='b',
                      mw=8,
                      lw=0.2)
        _utils_GUI.vis_spared_edges(sd._nodes3)
        a3.SetView(view)
        print(
            '----DO NOT FORGET TO SAVE THE MODEL TO DISK; RUN _SAVE_SEGMENTATION----'
        )
    if event.text == 'n':
        # add picked seed to nodes_1
        coord2 = get_picked_seed(vol, label)
        sd._nodes1.add_node(tuple(coord2))
        view = a1.GetView()
        point = vv.plot(coord2[0],
                        coord2[1],
                        coord2[2],
                        mc='b',
                        ms='o',
                        mw=8,
                        alpha=0.5,
                        axes=a1)
        a1.SetView(view)
    if event.text == 'p':
        # protect node from pop
        pickedNode = _utils_GUI.snap_picked_point_to_graph(sd._nodes1,
                                                           vol,
                                                           label,
                                                           nodesOnly=True)
        sd._nodes1.add_node(pickedNode, nopop=True)
        sd._nodes2.add_node(pickedNode, nopop=True)
        view = a1.GetView()
        point = vv.plot(pickedNode[0],
                        pickedNode[1],
                        pickedNode[2],
                        mc='y',
                        ms='o',
                        mw=8,
                        alpha=0.5,
                        axes=a1)
        a1.SetView(view)
        # now rerun step 3
    if event.key == vv.KEY_PAGEDOWN:
        # remove false seeds posterior to picked point, e.g. for spine
        try:
            _utils_GUI.remove_nodes_by_selected_point(sd._nodes3,
                                                      vol,
                                                      a3,
                                                      label,
                                                      clim,
                                                      showVol=showVol)
        except ValueError:  # false nodes already cleaned by Step3
            pass
        _utils_GUI.remove_nodes_by_selected_point(sd._nodes2,
                                                  vol,
                                                  a2,
                                                  label,
                                                  clim,
                                                  showVol=showVol)
        label = _utils_GUI.remove_nodes_by_selected_point(sd._nodes1,
                                                          vol,
                                                          a1,
                                                          label,
                                                          clim,
                                                          showVol=showVol)
    if event.text == '1':
        # redo step1
        view = a1.GetView()
        a1.Clear()
        a2.Clear()
        a3.Clear()
        sd._params = p
        sd.Step1()
        label = DrawModelAxes(vol,
                              sd._nodes1,
                              a1,
                              clim=clim,
                              showVol=showVol,
                              removeStent=False)  # lc, mc
        a1.SetView(view)
    if event.text == '2':
        # redo step2 and 3
        view = a2.GetView()
        a2.Clear()
        a3.Clear()
        sd._params = p
        sd.Step2()
        sd.Step3(cleanNodes=cleanNodes)
        DrawModelAxes(vol,
                      sd._nodes2,
                      a2,
                      clim=clim,
                      showVol=showVol,
                      removeStent=False)
        DrawModelAxes(vol,
                      sd._nodes3,
                      a3,
                      meshColor=meshColor,
                      clim=clim,
                      showVol=showVol,
                      removeStent=False)
        a2.SetView(view)
    if event.text == '3':
        view = a3.GetView()
        a3.Clear()
        sd._params = p
        sd.Step3(cleanNodes=cleanNodes)
        DrawModelAxes(vol,
                      sd._nodes3,
                      a3,
                      meshColor=meshColor,
                      clim=clim,
                      showVol=showVol,
                      removeStent=False)
        node_points = _utils_GUI.interactive_node_points(sd._nodes3, scale=0.6)
        _utils_GUI.node_points_callbacks(node_points,
                                         selected_nodes,
                                         pick=False)
        a3.SetView(view)

    if event.text == 's':
        # SAVE SEGMENTATION
        # make centerline points of segmentation
        paths_as_pp = points_from_edges_in_graph(sd._nodes3, type='order')
        ringpoints = paths_as_pp[0].T
        # Get graph model
        model = sd._nodes3
        seeds = sd._nodes1
        Draw = sd.Draw
        # Build struct
        s2 = vv.ssdf.new()
        # We do not need croprange, but keep for reference
        s2.sampling = s.sampling
        s2.origin = s.origin
        s2.stenttype = s.stenttype
        s2.croprange = s.croprange
        for key in dir(s):
            if key.startswith('meta'):
                suffix = key[4:]
                s2['meta' + suffix] = s['meta' + suffix]
        s2.what = what
        s2.params = p
        s2.stentType = stentType
        # Store model
        s2.model = model.pack()
        s2.seeds = seeds.pack()
        s2.Draw = Draw
        s2.ringpoints = ringpoints
        #s2.mesh = ssdf.new()
        # Save
        savedir = select_dir(
            r'C:\Users\Gebruiker\Google Drive\Afstuderen\Rings')
        filename = '%s_%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname,
                                            'model' + what, ring)
        ssdf.save(os.path.join(savedir, filename), s2)
        print('saved to disk in {} as {}.'.format(savedir, filename))
Exemple #17
0
    def __init__(self,ptcode,ctcode,basedir, seed_th=[600], show=True, 
                normalize=False, modelname='model'):
        
        import os
        
        import numpy as np
        import visvis as vv
        from visvis import ssdf
        
        from stentseg.utils import PointSet, _utils_GUI
        from stentseg.utils.datahandling import select_dir, loadvol, loadmodel
        from stentseg.stentdirect.stentgraph import create_mesh
        from stentseg.stentdirect import stentgraph, StentDirect, getDefaultParams
        from stentseg.stentdirect import AnacondaDirect, EndurantDirect, NellixDirect
        from stentseg.utils.visualization import show_ctvolume
        from stentseg.utils.picker import pick3d, label2worldcoordinates, label2volindices
        import scipy
        from scipy import ndimage
        import copy
        
        # Select dataset to register
        cropname = 'prox'
        # phase = 10
        #dataset = 'avgreg'
        #what = str(phase) + dataset # avgreg
        what = 'avgreg'
        
        # Load volumes
        s = loadvol(basedir, ptcode, ctcode, cropname, what)
        
        # sampling was not properly stored after registration for all cases: reset sampling
        vol_org = copy.deepcopy(s.vol)
        s.vol.sampling = [vol_org.sampling[1], vol_org.sampling[1], vol_org.sampling[2]] # z,y,x
        s.sampling = s.vol.sampling
        vol = s.vol
        
        ## Initialize segmentation parameters
        stentType = 'nellix'  # 'zenith';'nellix' runs modified pruning algorithm in Step3
        
        p = getDefaultParams(stentType)
        p.seed_threshold = seed_th     # step 1 [lower th] or [lower th, higher th]
        # p.seedSampleRate = 7                  # step 1, nellix
        p.whatphase = what                
        
        
        ## Perform segmentation
        # Instantiate stentdirect segmenter object
        if stentType == 'anacondaRing':
                sd = AnacondaDirect(vol, p) # inherit _Step3_iter from AnacondaDirect class
                #runtime warning using anacondadirect due to mesh creation, ignore
        elif stentType == 'endurant':
                sd = EndurantDirect(vol, p)
        elif stentType == 'nellix':
                sd = NellixDirect(vol, p)
        else:
                sd = StentDirect(vol, p) 

        ## show histogram and normalize
        # f = vv.figure(3)
        # a = vv.gca()
        # vv.hist(vol, drange=(300,vol.max()))
        
        # normalize vol to certain limit
        if normalize:
                sd.Step0(3071)
                vol = sd._vol
                # b= vv.hist(vol, drange=(300,3071))
                # b.color = (1,0,0)
       
        ## Perform step 1 for seeds
        sd.Step1()
        
        ## Visualize
        if show:
                fig = vv.figure(2); vv.clf()
                fig.position = 0.00, 22.00,  1920.00, 1018.00
                clim = (0,2000)
                
                # Show volume and model as graph
                a1 = vv.subplot(121)
                a1.daspect = 1,1,-1
                # t = vv.volshow(vol, clim=clim)
                t = show_ctvolume(vol, axis=a1, showVol='MIP', clim =clim, isoTh=250, 
                                removeStent=False, climEditor=True)
                label = pick3d(vv.gca(), vol)
                sd._nodes1.Draw(mc='b', mw = 2)       # draw seeded nodes
                #sd._nodes2.Draw(mc='b', lc = 'g')    # draw seeded and MCP connected nodes
                vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
                
                # Show volume and cleaned up graph
                a2 = vv.subplot(122)
                a2.daspect = 1,1,-1
                sd._nodes1.Draw(mc='b', mw = 2)       # draw seeded nodes
                # t = vv.volshow(vol, clim=clim)
                # label = pick3d(vv.gca(), vol)
                # sd._nodes2.Draw(mc='b', lc='g')
                # sd._nodes3.Draw(mc='b', lc='g')
                vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
                
                # # Show the mesh
                #===============================================================================
                # a3 = vv.subplot(133)
                # a3.daspect = 1,1,-1
                # t = vv.volshow(vol, clim=clim)
                # pick3d(vv.gca(), vol)
                # #sd._nodes3.Draw(mc='b', lc='g')
                # m = vv.mesh(bm)
                # m.faceColor = 'g'
                # # _utils_GUI.vis_spared_edges(sd._nodes3)
                # vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
                #===============================================================================
                
                # Use same camera
                a1.camera = a2.camera #= a3.camera
                
                switch = True
                a1.axis.visible = switch
                a2.axis.visible = switch
                #a3.axis.visible = switch
                

        ## Store segmentation to disk
        
        # Get graph model
        model = sd._nodes1
                
        # Build struct
        s2 = vv.ssdf.new()
        s2.sampling = s.sampling
        s2.origin = s.origin
        s2.stenttype = s.stenttype
        s2.croprange = s.croprange
        for key in dir(s):
                if key.startswith('meta'):
                    suffix = key[4:]
                    s2['meta'+suffix] = s['meta'+suffix]
        s2.what = what
        s2.params = p
        s2.stentType = stentType
        # Store model (not also volume)
        s2.model = model.pack()
        
        
        # Save
        filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, modelname+ what)
        ssdf.save(os.path.join(basedir, ptcode, filename), s2)
        print('saved to disk as {}.'.format(filename) )

        ## Make model dynamic (and store/overwrite to disk)
        #===============================================================================
        # 
        # import pirt
        # from stentsegf.motion.dynamic import incorporate_motion_nodes, incorporate_motion_edges  
        # 
        # # Load deforms
        # s = loadvol(basedir, ptcode, ctcode, cropname, '10deforms')
        # deformkeys = []
        # for key in dir(s):
        #     if key.startswith('deform'):
        #         deformkeys.append(key)
        # deforms = [s[key] for key in deformkeys]
        # deforms = [pirt.DeformationFieldBackward(*fields) for fields in deforms]
        # paramsreg = s.params
        # 
        # # Load model
        # s = loadmodel(basedir, ptcode, ctcode, cropname, 'model'+what)
        # model = s.model
        # 
        # # Combine ...
        # incorporate_motion_nodes(model, deforms, s.origin)
        # incorporate_motion_edges(model, deforms, s.origin)
        # 
        # # Save back
        # filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'model'+what)
        # s.model = model.pack()
        # s.paramsreg = paramsreg
        # ssdf.save(os.path.join(basedir, ptcode, filename), s)
        # print('saved to disk as {}.'.format(filename) )
        #===============================================================================
Exemple #18
0
def savecropvols(vols,
                 basedir,
                 ptcode,
                 ctcode,
                 cropname,
                 stenttype,
                 sampling=None,
                 meta=None):
    """ Step B: Crop and Save SSDF
    Input: vols from Step A
    Save 2 or 10 volumes (cardiac cycle phases) in one ssdf file
    Cropper tool opens to manually set the appropriate cropping range in x,y,z
    Click 'finish' to continue saving
    Meta information (dicom), origin, stenttype and cropping range are saved
    """

    try:
        vol0 = vv.Aarray(
            vols[0], vols[0].meta.sampling)  # vv.Aarray defines origin: 0,0,0
    except AttributeError:
        print('AttributeError no meta with vol, use given sampling')
        vol0 = vv.Aarray(vols[0], sampling)

    # Open cropper tool
    print('Set the appropriate cropping range for "%s" '
          'and click finish to continue' % cropname)
    print('Loading... be patient')
    fig = vv.figure()
    fig.title = 'Cropping for "%s"' % cropname
    #vol_crop = cropper.crop3d(vol0, fig)
    vol_crop = crop3d(vol0, fig)  # use local while error with cropper
    fig.Destroy()

    if vol_crop.shape == vol0.shape:
        print('User did not crop')

    # Calculate crop range from origin
    rz = int(vol_crop.origin[0] / vol_crop.sampling[0] + 0.5)
    rz = rz, rz + vol_crop.shape[0]
    ry = int(vol_crop.origin[1] / vol_crop.sampling[1] + 0.5)
    ry = ry, ry + vol_crop.shape[1]
    rx = int(vol_crop.origin[2] / vol_crop.sampling[2] + 0.5)
    rx = rx, rx + vol_crop.shape[2]

    # Initialize struct
    s = ssdf.new()
    s.sampling = vol_crop.sampling  # z, y, x voxel size in mm
    s.origin = vol_crop.origin
    s.croprange = rz, ry, rx  # in world coordinates
    s.stenttype = stenttype
    s.ctcode = ctcode
    s.ptcode = ptcode

    # Export and save
    if len(vols) == 1:  # when static ct
        s.vol = vols[0][rz[0]:rz[1], ry[0]:ry[1], rx[0]:rx[1]]
        s.meta = vols[0].meta
        vols[0].meta.PixelData = None  # avoid ssdf warning
        filename = '%s_%s_%s_phase.ssdf' % (ptcode, ctcode, cropname)
    else:  # dynamic ct
        for volnr in range(0, len(vols)):
            phase = volnr * 10
            if len(vols) == 2:  # when only diastolic/systolic volume
                try:
                    phase = vols[
                        volnr].meta.SeriesDescription[:2]  # '78%, iDose'
                    phase = int(phase)
                except AttributeError:  # has no meta
                    phase = volnr
            s['vol%i' % phase] = vols[volnr][rz[0]:rz[1], ry[0]:ry[1],
                                             rx[0]:rx[1]]
            try:
                s['meta%i' % phase] = vols[volnr].meta
                vols[volnr].meta.PixelData = None  # avoid ssdf warning
            except AttributeError:  # has no meta
                pass
                # s['meta%i'% phase] = meta # given input var
                # todo: meta type now error TypeError: unorderable types: DataElement() < DataElement()
        filename = '%s_%s_%s_phases.ssdf' % (ptcode, ctcode, cropname)
    file_out = os.path.join(basedir, ptcode, filename)
    ssdf.save(file_out, s)
    print()
    print('ssdf saved to {}.'.format(file_out))
Exemple #19
0
        # get deforms of centerline path as array
        assert model.number_of_edges() == 1  # cll should be 1 path
        centerlineEdge = model.edges()[0]  # the two nodes that define the edge
        centerlineDeforms = model.edge[centerlineEdge[0]][
            centerlineEdge[1]]['pathdeforms']

        # store in dict of centerlineMat
        if key == 'model':
            centerlineMat[
                'centerline_deforms'] = centerlineDeforms  # list with PointSet arrays
        elif key == 'model_2':
            centerlineMat[
                'centerline2_2_deforms'] = centerlineDeforms  # list with PointSet arrays
        else:
            print('No model found with known name')

        # pack model for save
        s[key] = model.pack()

# Save back ssdf
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, what + '_dynamic')
s.paramsreg = paramsreg
ssdf.save(os.path.join(basedirstl, ptcode, filename), s)
print('saved dynamic to disk in {} as {}.'.format(basedirstl, filename))

# Save back mat
newMatName = '%s_%s_%s_%s.mat' % (ptcode, ctcode, cropname, what + '_dynamic')
scipy.io.savemat(os.path.join(basedirstl, ptcode, newMatName), centerlineMat)
print('')
print('Dynamic centerline was stored as {}'.format(newMatName))
print('')
Exemple #20
0
    storevar['startpoint'] = start1
    storevar['endpoint'] = end1
    scipy.io.savemat(storemat, storevar)
    print('')
    print('centerline2 was stored as.mat to {}'.format(storemat))
    print('')
    # save ssdf
    model = centerline_nodes
    # Build struct
    s2 = vv.ssdf.new()
    s2.sampling = s.sampling
    s2.origin = s.origin
    s2.stenttype = s.stenttype
    s2.croprange = s.croprange
    for key in dir(s):
        if key.startswith('meta'):
            suffix = key[4:]
            s2['meta' + suffix] = s['meta' + suffix]
    s2.what = what
    # Store model
    s2.startpoint = start1
    s2.endpoint = end1
    s2.params = params
    s2.centerline = centerline2
    s2.model = model.pack()
    # get filename
    filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'centerline')
    ssdf.save(os.path.join(targetdir, filename), s2)
    print("Centerline saved to ssdf in :")
    print(os.path.join(targetdir, filename))
Exemple #21
0
 def _Save(self):
     try:
         ssdf.save(self._fname, self._s)
     except IOError:
         pass  # Maybe an installed frozen application (no write-rights)
            s2.croprange = s.croprange
            # Obtain deform fields
            for i in range(N):
                phase = i * 10
                fields = [field for field in reg.get_deform(i).as_backward()]
                s2['deform%i' % phase] = fields
            s2.sampling = s2.deform0[
                0].sampling  # Sampling of deform is different!
            #s2.origin = s2.deform0[0].origin  # But origin is zero
            s2.originDeforms = s2.deform0[0].origin  # But origin is zero
            s2.params = reg.params

            # Save
            filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname,
                                             'deforms')
            ssdf.save(os.path.join(basedir, ptcode, filename), s2)
            print("deforms saved to disk.")

            # Store averaged volume, where the volumes are registered

            from visvis import ssdf

            # Create average volume from *all* volumes deformed to the "center"
            N = len(reg._ims)
            mean_vol = np.zeros(reg._ims[0].shape, 'float64')
            for i in range(N):
                vol, deform = reg._ims[i], reg.get_deform(i)
                mean_vol += deform.as_backward().apply_deformation(vol)
            mean_vol *= 1.0 / N

            # Create struct
Exemple #23
0
    def __init__(self, ptcode, ctcode, basedir):
        ## Perform image registration

        import os, time

        import numpy as np
        import visvis as vv
        import pirt.reg  # Python Image Registration Toolkit
        from stentseg.utils.datahandling import select_dir, loadvol
        import scipy
        from scipy import ndimage

        # Select dataset to register
        cropname = 'prox'
        what = 'phases'

        # Load volumes
        s = loadvol(basedir, ptcode, ctcode, cropname, what)

        vols = []
        phases = []
        for key in dir(s):
            if key.startswith('vol'):
                print(key)
                # create vol with zoom in z-direction
                zscale = (s[key].sampling[0] / s[key].sampling[1])  # z / y
                # resample vol using spline interpolation, 3rd order piecewise polynomial
                vol_zoom = scipy.ndimage.interpolation.zoom(
                    s[key], [zscale, 1, 1], 'float32')
                s[key].sampling = [
                    s[key].sampling[1], s[key].sampling[1], s[key].sampling[2]
                ]

                # set scale and origin
                vol_zoom_type = vv.Aarray(vol_zoom, s[key].sampling,
                                          s[key].origin)
                vol = vol_zoom_type

                phases.append(key)
                vols.append(vol)

        t0 = time.time()

        # Initialize registration object
        reg = pirt.reg.GravityRegistration(*vols)

        reg.params.mass_transforms = 2  # 2nd order (Laplacian) triggers more at lines
        reg.params.speed_factor = 1.0
        reg.params.deform_wise = 'groupwise'  # groupwise!
        reg.params.mapping = 'backward'
        reg.params.deform_limit = 1.0
        reg.params.final_scale = 1.0  # We might set this a wee bit lower than 1 (but slower!)
        reg.params.scale_sampling = 16
        reg.params.final_grid_sampling = 20
        reg.params.grid_sampling_factor = 0.5

        # Go!
        reg.register(verbose=1)

        t1 = time.time()
        print('Registration completed, which took %1.2f min.' %
              ((t1 - t0) / 60))

        # Store registration result

        from visvis import ssdf

        # Create struct

        s2 = vv.ssdf.new()
        N = len(vols)
        for key in dir(s):
            if key.startswith('meta'):
                s2[key] = s[key]
        s2.origin = s.origin
        s2.stenttype = s.stenttype
        s2.croprange = s.croprange

        # Obtain deform fields
        for i in range(N):
            fields = [field for field in reg.get_deform(i).as_backward()]
            phase = phases[i][3:]
            s2['deform%s' % phase] = fields
        s2.sampling = s2['deform%s' %
                         phase][0].sampling  # Sampling of deform is different!
        s2.originDeforms = s2['deform%s' %
                              phase][0].origin  # But origin is zero
        s2.params = reg.params

        # Save
        filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'deforms')
        ssdf.save(os.path.join(basedir, ptcode, filename), s2)
        print("deforms saved to disk.")

        #============================================================================
        # Store averaged volume, where the volumes are registered

        #from visvis import ssdf

        # Create average volume from *all* volumes deformed to the "center"
        N = len(reg._ims)
        mean_vol = np.zeros(reg._ims[0].shape, 'float64')
        for i in range(N):
            vol, deform = reg._ims[i], reg.get_deform(i)
            mean_vol += deform.as_backward().apply_deformation(vol)
        mean_vol *= 1.0 / N

        # Create struct
        s_avg = ssdf.new()
        for key in dir(s):
            if key.startswith('meta'):
                s_avg[key] = s[key]
        s_avg.sampling = s.vol0.sampling  # z, y, x after interpolation
        s_avg.origin = s.origin
        s_avg.stenttype = s.stenttype
        s_avg.croprange = s.croprange
        s_avg.vol = mean_vol.astype('float32')
        s_avg.params = s2.params

        fig1 = vv.figure(1)
        vv.clf()
        fig1.position = 0, 22, 1366, 706
        a1 = vv.subplot(111)
        a1.daspect = 1, 1, -1
        renderstyle = 'mip'
        a1b = vv.volshow(s_avg.vol, clim=(0, 2000), renderStyle=renderstyle)
        #a1b.isoThreshold = 600
        vv.xlabel('x'), vv.ylabel('y'), vv.zlabel('z')
        vv.title('Average volume of %s phases (%s) (resized data)' %
                 (len(phases), renderstyle))

        # Save
        avg = 'avgreg'
        filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, avg)
        ssdf.save(os.path.join(basedir, ptcode, filename), s_avg)
        print("avgreg saved to disk.")

        t1 = time.time()
        print('Registration completed, which took %1.2f min.' %
              ((t1 - t0) / 60))
Exemple #24
0
 def _Save(self):
     ssdf.save(self._fname, self._s)
Exemple #25
0
        s = processFont(fontname)
        ss.append(s)
    
    # process to pack together
    sr, sb, si = ss[0], ss[1], ss[2]
    for fonttype in ['b', 'i']:
        s = ss[{'b':1,'i':2}[fonttype]]
        # cut interesting part of image in i or b
        [Iy,Ix] = np.where(s.data>0); y1 = Iy.max()
        data = s.data[0:y1+1,:]
        # paste that part in image of regular
        [Iy,Ix] = np.where(sr.data>0); y1 = Iy.max()
        y2 = y1 + data.shape[0]
        sr.data[y1:y2] = data
        # correct origin of chars
        for i in range(s.origin.shape[0]):
            s.origin[i,1] += y1
        # copy information to struct of sr
        sr['charcodes_'+fonttype] = s.charcodes
        sr['origin_'+fonttype] = s.origin
        sr['size_'+fonttype] = s.size
        sr['width_'+fonttype] = s.width
    
    # store
    base[font] = sr

ssdf.save(path+'fonts.ssdf', base)
ssdf.save(path+'../visvisResources/fonts.ssdf', base)


 def __init__(self,ptcode,ctcode,basedir, threshold=300, show=True, 
             normalize=False, modelname='modelvessel'):
     
     import os
     
     import numpy as np
     import visvis as vv
     from visvis import ssdf
     
     from stentseg.utils import PointSet, _utils_GUI
     from stentseg.utils.datahandling import select_dir, loadvol, loadmodel
     from stentseg.stentdirect.stentgraph import create_mesh
     from stentseg.stentdirect import stentgraph, StentDirect, getDefaultParams
     from stentseg.stentdirect import AnacondaDirect, EndurantDirect, NellixDirect
     from stentseg.utils.visualization import show_ctvolume
     from stentseg.utils.picker import pick3d, label2worldcoordinates, label2volindices
     import scipy
     from scipy import ndimage
     import copy
     from stentseg.utils.get_isosurface import get_isosurface3d, isosurface_to_graph, show_surface_and_vol
     
     # Select dataset to register
     cropname = 'prox'
     #phase = 10
     #what = 'phase'+str(phase)
     what = 'avgreg'
     
     # Load volumes
     s = loadvol(basedir, ptcode, ctcode, cropname, what)
     
     # sampling was not properly stored after registration for all cases: reset sampling
     vol_org = copy.deepcopy(s.vol)
     s.vol.sampling = [vol_org.sampling[1], vol_org.sampling[1], vol_org.sampling[2]] # z,y,x
     s.sampling = s.vol.sampling
     vol = s.vol
     
     # Get isosurface
     verts, faces, pp_vertices, mesh = get_isosurface3d(vol, threshold=threshold, showsurface=False)
     
     if show:
         self.label = show_surface_and_vol(vol, pp_vertices, showVol='MIP')
     
     # Convert to graph
     model = isosurface_to_graph(pp_vertices) # model with nodes
     
     # Store segmentation to disk
     p = threshold
     stentType = 'isosurface'
     
     # Build struct
     s2 = vv.ssdf.new()
     s2.sampling = s.sampling
     s2.origin = s.origin
     s2.stenttype = s.stenttype
     s2.croprange = s.croprange
     for key in dir(s):
             if key.startswith('meta'):
                 suffix = key[4:]
                 s2['meta'+suffix] = s['meta'+suffix]
     s2.what = what
     s2.params = p
     s2.stentType = stentType
     # Store model (not also volume)
     s2.model = model.pack()
     
     
     # Save
     filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, modelname+ what)
     ssdf.save(os.path.join(basedir, ptcode, filename), s2)
     print('saved to disk as {}.'.format(filename) )
Exemple #27
0
 def _Save(self):
     try:
         ssdf.save(self._fname, self._s)
     except IOError:
         pass # Maybe an installed frozen application (no write-rights)
Exemple #28
0
 def _Save(self):
     ssdf.save(self._fname, self._s)