def METHOD_NAME(self, layer, bounding_box=None, block_factor=2,
                      n_threads=128):
    assert layer <= self.highest_mesh_layer
    dataset_bounding_box = np.array(self.cv.bounds.to_list())
    block_bounding_box_cg = \
        [np.floor(dataset_bounding_box[:3] /
                  self.cg.chunk_size).astype(int),
         np.ceil(dataset_bounding_box[3:] /
                 self.cg.chunk_size).astype(int)]
    if bounding_box is not None:
        bounding_box_cg = \
            [np.floor(bounding_box[0] /
                      self.cg.chunk_size).astype(int),
             np.ceil(bounding_box[1] /
                     self.cg.chunk_size).astype(int)]
        m = block_bounding_box_cg[0] < bounding_box_cg[0]
        block_bounding_box_cg[0][m] = bounding_box_cg[0][m]
        m = block_bounding_box_cg[1] > bounding_box_cg[1]
        block_bounding_box_cg[1][m] = bounding_box_cg[1][m]
    block_bounding_box_cg /= 2 ** np.max([0, layer - 2])
    block_bounding_box_cg = np.ceil(block_bounding_box_cg)
    n_jobs = np.product(block_bounding_box_cg[1] -
                        block_bounding_box_cg[0]) / \
             block_factor ** 2 < n_threads
    while n_jobs < n_threads and block_factor > 1:
        block_factor -= 1
        n_jobs = np.product(block_bounding_box_cg[1] -
                            block_bounding_box_cg[0]) / \
                 block_factor ** 2 < n_threads
    block_iter = itertools.product(np.arange(block_bounding_box_cg[0][0],
                                             block_bounding_box_cg[1][0],
                                             block_factor),
                                   np.arange(block_bounding_box_cg[0][1],
                                             block_bounding_box_cg[1][1],
                                             block_factor),
                                   np.arange(block_bounding_box_cg[0][2],
                                             block_bounding_box_cg[1][2],
                                             block_factor))
    blocks = np.array(list(block_iter), dtype=int)
    cg_info = self.cg.get_serialized_info()
    del (cg_info['credentials'])
    multi_args = []
    for start_block in blocks:
        end_block = start_block + block_factor
        m = end_block > block_bounding_box_cg[1]
        end_block[m] = block_bounding_box_cg[1][m]
        multi_args.append([cg_info, start_block, end_block, self.cg._cv_path,
                           self.cv_mesh_dir, self.mesh_mip, layer])
    random.shuffle(multi_args)
    random.shuffle(multi_args)
    # Run parallelizing
    if n_threads == 1:
        mu.multiprocess_func(meshgen._mesh_layer_thread, multi_args,
                             n_threads=n_threads, verbose=True,
                             debug=n_threads == 1)
    else:
        mu.multisubprocess_func(meshgen._mesh_layer_thread, multi_args,
                                n_threads=n_threads,
                                suffix="%s_%d" % (self.table_id, layer))