Ejemplo n.º 1
0
 def test_bridge_has_no_manifold(self):
     edge_usage = dcHelpers.generate_edge_usage_dict(self.quads_coarse)
     for edge_identifier, used_by_quads in edge_usage.items():
         self.assertTrue(used_by_quads.__len__() == 2)
Ejemplo n.º 2
0
else:
    print "Example " + __EXAMPLE__ + " not known!"
    raise Exception("ABORTING!")

if __EXAMPLE__ == "Path":
    print "Example: Path"
    path = "cantilever"
    coarse_scale = 8
    [verts, quads, params, dimensions, quads_objs, datasets] = extraction.extract_surface_from_path_w_plot(path, coarse_scale)
else:
    [verts, quads, quads_objs, params, datasets] = extraction.extraction_algorithm(fine_data, resolutions, dimensions)

print "###Plotting###"

nonmanifold=[]
edge_usage = dcHelpers.generate_edge_usage_dict(quads['coarse'])
for edge_identifier, used_by_quads in edge_usage.items():
    if used_by_quads.__len__() != 2:
        print used_by_quads.__len__()
        nonmanifold.append(edge_identifier)

print nonmanifold
for e in nonmanifold:
    print e[0]
    print verts['coarse'][e[0]]
    print e[1]
    print verts['coarse'][e[1]]

fig = plt.figure()
ax = Axes3D(fig)
Ejemplo n.º 3
0
 def test_bridge_has_no_manifold(self):
     edge_usage = dcHelpers.generate_edge_usage_dict(self.quads_coarse)
     for edge_identifier, used_by_quads in edge_usage.items():
         self.assertTrue(used_by_quads.__len__() == 2)
Ejemplo n.º 4
0
def tworesolution_dual_contour(data, resolutions, dims):
    # fine_dataset = VoxelDataset.from_filename('GE_white_big.vtk') # use for GE bracket
    fine_dataset = VoxelDataset(dims, resolutions['fine'], data)  # use for topy files
    print "++ Aligning Dataset ++"
    fine_dataset.align()
    fine_dataset.surround()

    pre_coarsening_steps = 0
    if pre_coarsening_steps > 0:
        print "PRESMOOTHING OF DATASET APPLIED!"
        print "++ Precoarsening of dataset ++"
        print "coarsening steps: %d" % (pre_coarsening_steps)
        fine_dataset = coarsen_dataset(pre_coarsening_steps, fine_dataset)

    print "++ Fine Resolution DC ++"
    print "resolution: %d" % (fine_dataset._resolution)
    [dc_verts_fine, dc_quads_fine, dc_manifold_edges_fine, not_resolved_edges_fine] = dual_contour(fine_dataset,
                                                                                                   resolutions['fine'],
                                                                                                   is_coarse_level=False,
                                                                                                   do_manifold_treatment=False)

    # compute necessary coarsening steps from given coarse resolution.
    print "fine quads produced: %d" % (dc_quads_fine.__len__())

    coarsening_steps = int(np.log(resolutions['coarse']) / np.log(2)) - pre_coarsening_steps
    if coarsening_steps > 0:
        print "++ Coarsening Dataset ++"
        assert type(coarsening_steps) is int  # coarsening steps have to be integer!
        coarse_dataset = coarsen_dataset(coarsening_steps, fine_dataset)
    else:
        coarse_dataset = fine_dataset

    print "++ Coarse Resolution DC ++"
    print "resolution: %d" % (coarse_dataset._resolution)
    [dc_verts_coarse, dc_quads_coarse, dc_manifold_edges_coarse, not_resolved_edges_coarse] = dual_contour(
        coarse_dataset,
        resolutions['fine'],
        is_coarse_level=True,
        do_manifold_treatment=True)

    print "coarse quads produced: %d" % (dc_quads_coarse.__len__())
    dc_verts = {'fine': dc_verts_fine, 'coarse': dc_verts_coarse}
    dc_quads = {'fine': dc_quads_fine, 'coarse': dc_quads_coarse}
    dc_manifolds = {'fine': dc_manifold_edges_fine, 'coarse': dc_manifold_edges_coarse}

    print "checking for remaining non-manifold edges on coarse level:"
    nonmanifold = []
    edge_usage = generate_edge_usage_dict(dc_quads_coarse)
    for edge_identifier, used_by_quads in edge_usage.items():
        if used_by_quads.__len__() != 2:
            nonmanifold.append(np.array(edge_identifier))

    try:
        assert nonmanifold.__len__() == 0 and not_resolved_edges_coarse.__len__() == 0
    except AssertionError as e:
        import traceback, os.path
        top = traceback.extract_stack()[-1]
        print '\n'
        print ', '.join([os.path.basename(top[0]), str(top[1])])
        print "ERROR found. exporting intermediate results."
        export_results.export_as_csv(dc_verts_fine, './PYTHON/NURBSReconstruction/DualContouring/plotting/dc_verts_fine')
        export_results.export_as_csv(dc_quads_fine, './PYTHON/NURBSReconstruction/DualContouring/plotting/dc_quads_fine')
        export_results.export_as_csv(dc_verts_coarse, './PYTHON/NURBSReconstruction/DualContouring/plotting/dc_verts_coarse')
        export_results.export_as_csv(dc_quads_coarse, './PYTHON/NURBSReconstruction/DualContouring/plotting/dc_quads_coarse')
        export_results.export_as_csv(np.array(nonmanifold), './PYTHON/NURBSReconstruction/DualContouring/plotting/dc_non_manifold_edges')
        export_results.export_as_csv([coarse_dataset._dimensions['min'], coarse_dataset._dimensions['max']],
                                     './PYTHON/NURBSReconstruction/DualContouring/plotting/dc_dimensions')
        print "dc_non_manifold_edges references all the vertices connected by a non-manifold edge."
        print PColors.FAIL + "ERROR: Not all manifold edges have been successfully resolved! Aborting." + PColors.ENDC
        quit()

    datasets = {'fine': fine_dataset, 'coarse': coarse_dataset}

    return dc_verts, dc_quads, dc_manifolds, datasets