Ejemplo n.º 1
0
def showSegmentation(
        segmentation,
        voxelsize_mm=np.ones([3, 1]),
        degrad=4,
        label=1,
        smoothing=True
        ):
    """
    Funkce vrací trojrozměrné porobné jako data['segmentation']
    v data['slab'] je popsáno, co která hodnota znamená
    """
    labels = []

    segmentation = segmentation[::degrad, ::degrad, ::degrad]

    # import pdb; pdb.set_trace()
    mesh_data = seg2fem.gen_mesh_from_voxels_mc(segmentation, voxelsize_mm*degrad)
    if smoothing:
        mesh_data.coors = seg2fem.smooth_mesh(mesh_data)
    else:
        mesh_data = seg2fem.gen_mesh_from_voxels_mc(segmentation, voxelsize_mm * 1.0e-2)
        # mesh_data.coors +=
    vtk_file = "mesh_geom.vtk"
    mesh_data.write(vtk_file)
    QApplication(sys.argv)
    view = viewer.QVTKViewer(vtk_file)
    view.exec_()

    return labels
Ejemplo n.º 2
0
def showSegmentation(segmentation,
                     voxelsize_mm=np.ones([3, 1]),
                     degrad=4,
                     label=1,
                     smoothing=True):
    """
    Funkce vrací trojrozměrné porobné jako data['segmentation']
    v data['slab'] je popsáno, co která hodnota znamená
    """
    labels = []

    segmentation = segmentation[::degrad, ::degrad, ::degrad]

    # import pdb; pdb.set_trace()
    mesh_data = seg2fem.gen_mesh_from_voxels_mc(segmentation,
                                                voxelsize_mm * degrad)
    if smoothing:
        mesh_data.coors = seg2fem.smooth_mesh(mesh_data)
    else:
        mesh_data = seg2fem.gen_mesh_from_voxels_mc(segmentation,
                                                    voxelsize_mm * 1.0e-2)
        # mesh_data.coors +=
    vtk_file = "mesh_geom.vtk"
    mesh_data.write(vtk_file)
    QApplication(sys.argv)
    view = viewer.QVTKViewer(vtk_file)
    view.exec_()

    return labels
Ejemplo n.º 3
0
    def smoothMesh(self):
        from seg2fem import gen_mesh_from_voxels_mc, smooth_mesh

        self.statusBar().showMessage('Smoothing mesh...')
        QApplication.processEvents()

        if self.mesh_smooth_method == 'marching cubes':
            self.mesh_data = gen_mesh_from_voxels_mc(self.segmentation_data,
                                                     self.voxel_sizemm * 1.0e-3)
            self.mesh_data.coors += self.dcm_offsetmm.reshape((1,3)) * 1.0e-3

        elif self.mesh_smooth_method == 'taubin':
            mid = self.rbtng_mesh_mesh.checkedId()
            if mid == 'v':
                 volume_corr=True

            else:
                volume_corr=False

            self.mesh_data.coors = smooth_mesh(self.mesh_data,
                                               n_iter=10, lam=0.6307, mu=-0.6347,
                                               volume_corr=volume_corr)
            
        self.setLabelText(self.text_mesh_data, '%d %s, smooth method - %s'\
                          % (self.mesh_data.n_el,
                             elem_tab[self.mesh_data.descs[0]],
                              self.mesh_smooth_method))

        self.statusBar().showMessage('Ready')
Ejemplo n.º 4
0
 def liver_cut(self):
     '''
     Pokud není zvolené kriterium pro provádění resekční linie, program zahlásí chybu
     '''
     if (self.planew == None) & (self.cut_point == None):
         self.info_text.appendPlainText (_fromUtf8("Neexistuje rovina řezu"))
         self.info_text.appendPlainText (_fromUtf8('Nejdříve vytvořte rovinu(Plane), nebo bod(Point)'))
     '''
     Pokud je zvoleno jako resekční kritérium rovina spustí se metoda Rez_podle_roviny ze skriptu virtual_resection
     '''
     if self.planew != None:
         self.info_text.appendPlainText (_fromUtf8("Provádění řezu. Prosím čekejte"))
         data_z_resekce,odstraneni_procenta = virtual_resection.Rez_podle_roviny(self.planew,self.segment,self.new_vox)
         '''
         Zde se provádí výpis velikosti (v procentech) odříznuté části jater do editoru pro uživatele
         Pokud je z jater odříznuto příliš mnoho, algoritmus někdy přepočítá jejich hodnotu nad hranici sta procent, proto
         je to zde ošetřeno podmínkou
         '''
         if (odstraneni_procenta > 100):
             self.liver_text.appendPlainText(_fromUtf8("Odstraněno příliš mnoho. Nelze spočítat"))
         else:
             self.liver_text.appendPlainText(_fromUtf8("Bylo ostraněno cca "+str(odstraneni_procenta)+" % jater"))
         '''
         Zde je vypnuta vytvořená rovina, což je provedeno z toho důvodu, aby mohlo být prováděno více řezů za sebou
         '''
         self.planew.Off()
     '''
     Pokud je zvoleno jako resekční kritérium bod spustí metoda. Tato metoda nejdříve vytvoří metici nul o stejné velikosti jako je matice
     původních dat. V této matici je na pozici bodu, který zvolí uživatel nula naahrazena jedničkou. Celá tato matice je společně s maticí
     původních dat předána resekčnímu algoritmu podle bodu ze skriptu virtual_resection
     '''
     if self.cut_point != None:
         self.info_text.appendPlainText (_fromUtf8("Provádění řezu. Prosím čekejte"))
         pozice = self.cut_point.GetPosition()
         self.data['data3d'] = self.data['data3d'][::self.degrad,::self.degrad,::self.degrad]
         seeds = np.zeros((self.data['segmentation'].shape[0],(self.data['segmentation'].shape[1]),(self.data['segmentation'].shape[2])))
         seeds[pozice[0]/self.new_vox[0]][pozice[1]/self.new_vox[1]][pozice[2]/self.new_vox[2]] = 1
         self.data = virtual_resection.Resekce_podle_bodu(self.data,seeds)
         data_z_resekce = self.data['segmentation'] == self.data['slab']['liver']
         self.cut_point.Off()
     '''
     Následně je vytvořen soubor VTK obsahující část jater, bez uříznuté části.
     '''
     mesh_data = seg2fem.gen_mesh_from_voxels_mc(data_z_resekce, self.new_vox)
     if True:
         for x in xrange (15):
             mesh_data.coors = seg2fem.smooth_mesh(mesh_data)
     print("Done")
     self.planew = None
     self.cut_point = None
     vtk_file = "mesh_new.vtk"
     mesh_data.write(vtk_file)
     self.View(vtk_file)
Ejemplo n.º 5
0
    def generate_mesh(self,segmentation,voxelsize_mm):
        self.segment = segmentation
        print("Generuji data...")
        self.voxelsize_mm = voxelsize_mm
        '''
        Nahrazuje původní velikost voxelu, velikostí vexoelů zvětšenou o hodnotu degradace
        '''
        self.new_vox = voxelsize_mm * self.degrad
        '''
        Zde je použita metoda ze skriptu seg2fem, která ze zadaných dat a velikosti voxelu vytvoří vtk soubor
        Data se před vytvořením vtk souboru ještě vyhlazují,aby měla hladší povrch
        Výsledný soubor je uložen pod názvem mesh_new.vtk
        '''
        mesh_data = seg2fem.gen_mesh_from_voxels_mc(self.segment, self.new_vox)
        if True:
            for x in xrange (50):
                mesh_data.coors = seg2fem.smooth_mesh(mesh_data)

        print("Done")
        vtk_file = "mesh_new.vtk"
        mesh_data.write(vtk_file)
        return vtk_file