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

    if vtk_file is None:
        vtk_file = "mesh_geom.vtk"
    vtk_file = os.path.expanduser(vtk_file)

    labels = []

    segmentation = segmentation[::degrad, ::degrad, ::degrad]
    voxelsize_mm = voxelsize_mm * degrad

    _stats(segmentation)
    if resize_mm is not None:
        logger.debug("resize begin")
        print("resize")
        new_voxelsize_mm = np.asarray([resize_mm, resize_mm, resize_mm])
        import imtools

        segmentation = imtools.misc.resize_to_mm(
            segmentation,
            voxelsize_mm=voxelsize_mm,
            new_voxelsize_mm=new_voxelsize_mm)
        voxelsize_mm = new_voxelsize_mm
        logger.debug("resize begin")
    _stats(segmentation)

    # import pdb; pdb.set_trace()
    mesh_data = gen_mesh_from_voxels_mc(segmentation, voxelsize_mm)
    if smoothing:
        mesh_data.coors = smooth_mesh(mesh_data)
        # mesh_data.coors = seg2fem.smooth_mesh(mesh_data)

    else:
        mesh_data = gen_mesh_from_voxels_mc(segmentation,
                                            voxelsize_mm * 1.0e-2)
        # mesh_data.coors +=
    mesh_data.write(vtk_file)
    if qt_app is None:
        qt_app = QApplication(sys.argv)
        logger.debug("qapp constructed")
    if show:
        import viewer

        view = viewer.QVTKViewer(vtk_file)
        print('show viewer')
        view.exec_()

    return labels
Esempio n. 2
0
    def make_mesh_file(
            self,
            labels=None,
            ):
        """ Make one mesh (vtk or stl) file

        :param label: labels from prev use of set_labels are used if None

        :return: filename of output file

        Funkce vrací trojrozměrné porobné jako data['segmentation']
        v data['slab'] je popsáno, co která hodnota znamená
        """

        if labels is None:
            labels=self.labels

        strlabel = imma.get_nlabels(slab=self.slab, labels=labels, return_mode="str")
        if strlabel is list:
            # if one file with {} in pattern is created
            strlabel = "-".join(strlabel)
        logger.debug(strlabel)
        mesh_filename = self.output_file_pattern.format(strlabel)
        logger.debug(mesh_filename)

        self.select_labels(labels)
        # import sed3
        # sed3.show_slices(self.binar_segmentation)

        self._resize_if_required()
        # sed3.show_slices(self.resized_segmentation)

        # _stats(self.segmentation)
        # _stats(self.binar_segmentation)
        _stats(self.resized_segmentation)

        # import pdb; pdb.set_trace()
        logger.debug("gen_mesh_from_voxels_mc() started")
        mesh_data = gen_mesh_from_voxels_mc(self.resized_segmentation, self.resized_voxelsize_mm)
        if self.smoothing:
            mesh_data.coors = smooth_mesh(mesh_data)
            # mesh_data.coors = seg2fem.smooth_mesh(mesh_data)

        else:
            pass
            # mesh_data = gen_mesh_from_voxels_mc(segmentation, voxelsize_mm * 1.0e-2)
            # mesh_data.coors +=
        logger.debug("gen_mesh_from_voxels_mc() finished")
        pth, ext = op.splitext(mesh_filename)
        if ext == ".stl":
            vtk_filename = mesh_filename + ".vtk"
        else:
            vtk_filename = mesh_filename
        mesh_data.write(vtk_filename)

        if ext == ".stl":
            vtk2stl.vtk2stl(vtk_filename, mesh_filename)
        return mesh_filename
Esempio n. 3
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)
Esempio 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)
Esempio 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
Esempio n. 6
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