static void test_set_backend_ids_for_disabled(session &sess)
{
server_node &node = global_data->nodes.back();
auto ids = generate_ids(16);
ELLIPTICS_REQUIRE(async_set_result, sess.set_backend_ids(node.remote(), 4, ids));
backend_status_result_entry result = async_set_result.get_one();
BOOST_REQUIRE(result.is_valid());
BOOST_REQUIRE_EQUAL(result.count(), 1);
dnet_backend_status *status = result.backend(0);
BOOST_REQUIRE_EQUAL(status->backend_id, 4);
BOOST_REQUIRE_EQUAL(status->state, DNET_BACKEND_DISABLED);
ELLIPTICS_REQUIRE(async_enable_result, sess.enable_backend(node.remote(), 4));
// Wait 0.1 secs to ensure that route list was changed
usleep(100 * 1000);
auto route_ids = backend_ids(sess, node.remote(), 4);
BOOST_REQUIRE_EQUAL(ids.size(), route_ids.size());
BOOST_REQUIRE(compare_ids(ids, route_ids));
}
void Volume::display_surface_mesher_result()
{
if(m_surface.empty() || // Either the surface is not computed.
m_view_surface) // Or it is computed and displayed, and one want
// to recompute it.
{
QTime total_time;
total_time.start();
values_list->save_values(fileinfo.absoluteFilePath());
std::size_t nx = m_image.xdim();
std::size_t ny = m_image.ydim();
std::size_t nz = m_image.zdim();
if(nx * ny * nz == 0)
{
status_message("No volume loaded.");
return;
}
m_surface.clear();
sm_timer.reset();
busy();
status_message("Surface meshing...");
sm_timer.start();
c2t3.clear();
del.clear();
Sphere bounding_sphere(m_image.center(),m_image.radius()*m_image.radius());
Classify_from_isovalue_list classify(values_list);
Generate_surface_identifiers generate_ids(values_list);
m_image.set_interpolation(mw->interpolationCheckBox->isChecked());
if(mw->labellizedRadioButton->isChecked()) {
std::cerr << "Labellized image\n";
}
m_image.set_labellized(mw->labellizedRadioButton->isChecked());
classify.set_identity(mw->labellizedRadioButton->isChecked());
generate_ids.set_labellized_image(mw->labellizedRadioButton->isChecked());
// definition of the surface
Surface_3 surface(m_image, bounding_sphere, m_relative_precision);
// Threshold threshold(m_image.isovalue());
// surface mesh traits class
typedef CGAL::Surface_mesher::Implicit_surface_oracle_3<Kernel,
// typedef CGAL::Surface_mesher::Image_surface_oracle_3<Kernel,
Surface_3,
Classify_from_isovalue_list,
Generate_surface_identifiers> Oracle;
Oracle oracle(classify, generate_ids);
if(mw->searchSeedsCheckBox->isChecked())
{
typedef std::vector<std::pair<Point, double> > Seeds;
Seeds seeds;
{
std::cerr << "Search seeds...\n";
std::set<unsigned char> domains;
search_for_connected_components(std::back_inserter(seeds),
CGAL::inserter(domains),
classify);
std::cerr << "Found " << seeds.size() << " seed(s).\n";
if(mw->labellizedRadioButton->isChecked() &&
values_list->numberOfValues() == 0)
{
Q_FOREACH(unsigned char label, domains) {
if(label != 0) {
values_list->addValue(label);
}
}
}
}
std::ofstream seeds_out("seeds.off");
std::ofstream segments_out("segments.txt");
seeds_out.precision(18);
seeds_out << "OFF\n" << seeds.size() << " 0 0\n";
segments_out.precision(18);
for(Seeds::const_iterator it = seeds.begin(), end = seeds.end();
it != end; ++it)
{
seeds_out << it->first << std::endl;
CGAL::Random_points_on_sphere_3<Point> random_points_on_sphere_3(it->second);
Oracle::Intersect_3 intersect = oracle.intersect_3_object();
for(int i = 0; i < 20; ++i)
{
const Point test = it->first + (*random_points_on_sphere_3++ - CGAL::ORIGIN);
CGAL::Object o = intersect(surface, Segment_3(it->first, test));
if (const Point* intersection = CGAL::object_cast<Point>(&o)) {
segments_out << "2 " << it->first << " " << *intersection << std::endl;
del.insert(*intersection);
}
else
{
std::cerr <<
boost::format("Error. Segment (%1%, %2%) does not intersect the surface! values=(%3%, %4%)\n")
% it->first % test
% surface(it->first) % surface(test);
}
}
}
}
std::string document_state::replace_placeholders(boost::string_ref xml) const
{
assert(!state->current_file);
std::vector<std::string> ids = generate_ids(*state, xml);
return replace_ids(*state, xml, &ids);
}
