示例#1
0
def evaluate_costs(crag_path,
                   merges,
                   ends,
                   iterations,
                   starting,
                   ending,
                   tmp=None):
    """ Evaluates the assignation of the given merges and end
    scores and returns the corresponding stats. Assumes node features have
    already been assigned
        :param crag_path: CRAG file path
        :param merges: Merge score to assign
        :param ends: End weight to assign
        :param iterations: Maximum number of iterations
        :param folder: Folder where to generate solution
        :param starting: Starting section to evaluate. Set to None for all
        :param ending: Ending section to evaluate. Set to None for all
    """
    # Manage temporary file creation
    if tmp is None:
        tmp_path = tempfile.mkdtemp()
    else:
        dataio.create_dir(tmp)
        tmp_path = tmp
    # Copy crag into temporary file
    copy_path = os.path.join(tmp_path, 'crag.h5')
    shutil.copyfile(crag_path, copy_path)
    # Generate and evaluate solution
    cg = generate_solution(copy_path, merges, ends, iterations, tmp_path)
    rand_score, voi_split, voi_merge = cg.evaluate_solution(init=starting,
                                                            end=ending)
    # Clean temporary data
    shutil.rmtree(tmp_path)
    return {'rand': rand_score, 'voi_split': voi_split, 'voi_merge': voi_merge}
示例#2
0
def generate_solution(crag_path,
                      merges,
                      ends,
                      iterations,
                      model,
                      folder,
                      logs=None,
                      edge_feat_value=1,
                      nthreads=3):
    """ Solves the inference problem of the CRAG after assigning the corresponding features and weights
    to edges (No assignment edges) and nodes (Slice and assignment nodes). Slice nodes are assigned the descriptor
    provided by the model. Given the difference between the descriptors of the slices they connect, assignment nodes
    are set by the ratio between the distance and the maximum distance considering the other assignment they 'compete'
    with (outliers are identified as well). The other values assigned here are constant values.
        :param crag_path: CRAG file path
        :param merges: Merge score to assign
        :param ends: End weight to assign
        :param iterations: Maximum number of iterations
        :param model: Folder where the trained network is
        :param folder: Folder where to generate solution
        :param logs: Path where to store the logs. Set to None to disable
        :param edge_feat_value: Feature value to assign to the no-assignment edges
        :param nthreads: Number of threads to use
    Returns
    -------
        cg: Crag class containing the solution
    """
    print('Generating solution for merge score %f and end score %f' %
          (merges, ends))

    if not os.path.isdir(model):
        raise ValueError('Model folder %s does not exist' % model)

    # Modify weights
    costs = cc.CragCostManager(crag_path)
    costs.update_node_weights(merges, weights=None)
    costs.update_edge_weights(ends)
    # Modify features
    costs.update_node_features(model)
    costs.update_edge_features(edge_feat_value)
    costs.save()

    # Evaluate resulting crag
    dataio.create_dir(folder)
    aux_crag = os.path.join(folder, 'project')
    cg = CragGenerator(aux_crag)
    cg.read_crag(crag_path)
    cg.solve(merges, ends, folder, iterations, logs=logs, threads=nthreads)
    return cg
示例#3
0
    def extract(self, outp):
        """ Extracts the merge trees in the given folder """

        # Prepare temporary folder for extracting H5 files
        self.tmp = tempfile.mkdtemp()

        print('Processing data ...')
        self.parse_data()

        print('Extracting trees ...')
        dataio.create_dir(outp)
        self.extract_trees(outp)

        # Cleaning environment
        self.clean()
示例#4
0
def merge_dataset(folder, histories, thresh, outp):
    """ Thresholds images by merging all supervoxels up to a given threshold 
    :param folder: Folder containing superpixel images
    :param histories: Folder containing the corresponding merge tree histories
    :param thresh: Merge threshold up to which merge regions
    :param outp: Folder where to store resulting images 
    """ 
    dataio.create_dir(outp)
    # Read superpixels and histories
    sps = dataio.FileReader(folder).extract_files()
    hists = dataio.FileReader(histories, exts=['.txt', '.dat', '.data']).extract_files()

    for (s, h) in zip(sps, hists):
        img = merge_superpixels(s, h, thresh)
        name, ext = os.path.splitext(s)
        mh.imsave(os.path.join(outp, os.path.basename(name) + ext), img.astype(float))
示例#5
0
    def save_data(self,
                  out_p,
                  group='data/labels',
                  min_digit=5,
                  overwrite=True,
                  int_data=False):
        """ Saves processed data. If path to HDF file provided, a dataset is created inside the
        given group. Otherwise, images are dumped into the folder specified in the path.

        Params:
        ---------
        out_p: string
            Output path. If it corresponds to a valid HDF5 it is stored as a HDF5 dataset.
            Otherwise it is stored in a file.
        group: string
            In case the output corresponds to a HDF5 file, it is the path
            inside the dataset where data needs to be stored. Subgroups must be separated by a /.
            Not used uf dumping into a folder.
        min_digit: integer
            Images are named, in order, with its position in the input volume. This number
            specifies the minimum amount of digits to use in the labeling if dumping data into a folder.
            Not used for HDF5 files.
        overwrite: boolean
            Whether to overwrite existing datasets in the destination path
        int_data: boolean
            By default data is stored as float. If this field is True, it is stored as unsigned integer
            in .png files. Only used if data path is a folder.
        """

        if os.path.exists(out_p) and not overwrite:
            return

        self._check_data()

        if dataio.valid_volume_path(out_p):
            with h5py.File(out_p, 'w') as f:
                dataio.store_hf_group(f, group, self.imgs)
        else:
            dataio.create_dir(out_p)
            if int_data is True:
                dataio.volume_to_folder(self.imgs,
                                        out_p,
                                        min_digit=min_digit,
                                        typ='uint8',
                                        ext='.png')
            else:
                dataio.volume_to_folder(self.imgs, out_p, min_digit=min_digit)
示例#6
0
    def solve(self,
              node_bias,
              edge_bias,
              outp,
              iterations,
              logs=None,
              threads=3):
        """ Solves the inference problem given the costs assigned
        Params
        ---------
        node_bias: double
            Bias to be added to each node weight
        edge_bias: double
            Bias to be added to each edge weight
        outp: string
            Folder where to extract the solution found
        iterations: integer
            Number of iterations for the solver
        logs: string
            Path where to store the process logs. Set to None to disable
        threads: int
            Number of threads to use
         """

        if not os.path.isdir(outp):
            dataio.create_dir(outp)

        if self.project_file is None:
            raise IOError('No CRAG project has been read/generated')

        args = [
            "cmc_solve", "-f",
            str(node_bias), "-b",
            str(edge_bias), "-p", self.project_file,
            "--exportSolution=" + str(outp),
            "--numIterations=" + str(iterations), "--readOnly"
        ]
        # "--numThreads=" + str(threads)
        # ]

        logs = None if logs is None else os.path.join(logs, 'solve.log')
        p = Process(args, logs)
        p.execute(verbose=True)

        self.solution = outp