bool builder::resample_surfels(boost::filesystem::path const& input_file) const {
std::cout << std::endl;
std::cout << "--------------------------------" << std::endl;
std::cout << "resample" << std::endl;
std::cout << "--------------------------------" << std::endl;
LOGGER_TRACE("resample stage");
lamure::pre::bvh bvh(memory_limit_, desc_.buffer_size, desc_.rep_radius_algo);
if (!bvh.load_tree(input_file.string())) {
return false;
}
if (bvh.state() != bvh::state_type::after_downsweep) {
LOGGER_ERROR("Wrong processing state!");
return false;
}
CPU_TIMER;
// perform resample
bvh.resample();
//write resampled leaf level out
format_xyz format_out;
std::unique_ptr<format_xyz> dummy_format_in{new format_xyz()};
auto xyz_res_file = add_to_path(base_path_, "_res.xyz");
converter conv(*dummy_format_in, format_out, desc_.buffer_size);
surfel_vector resampled_ll = bvh.get_resampled_leaf_lv_surfels();
conv.write_in_core_surfels_out(resampled_ll, xyz_res_file.string());
std::remove(input_file.string().c_str());
// LOGGER_DEBUG("Used memory: " << GetProcessUsedMemory() / 1024 / 1024 << " MiB");
return true;
}
void vc_iterate(VCSession *vc)
{
if (!vc) {
return;
}
pthread_mutex_lock(vc->queue_mutex);
struct RTPMessage *p;
if (!rb_read(vc->vbuf_raw, (void **)&p)) {
LOGGER_TRACE(vc->log, "no Video frame data available");
pthread_mutex_unlock(vc->queue_mutex);
return;
}
pthread_mutex_unlock(vc->queue_mutex);
const struct RTPHeader *const header = &p->header;
uint32_t full_data_len;
if (header->flags & RTP_LARGE_FRAME) {
full_data_len = header->data_length_full;
LOGGER_DEBUG(vc->log, "vc_iterate:001:full_data_len=%d", (int)full_data_len);
} else {
full_data_len = p->len;
LOGGER_DEBUG(vc->log, "vc_iterate:002");
}
LOGGER_DEBUG(vc->log, "vc_iterate: rb_read p->len=%d p->header.xe=%d", (int)full_data_len, p->header.xe);
LOGGER_DEBUG(vc->log, "vc_iterate: rb_read rb size=%d", (int)rb_size(vc->vbuf_raw));
const vpx_codec_err_t rc = vpx_codec_decode(vc->decoder, p->data, full_data_len, nullptr, MAX_DECODE_TIME_US);
free(p);
if (rc != VPX_CODEC_OK) {
LOGGER_ERROR(vc->log, "Error decoding video: %d %s", (int)rc, vpx_codec_err_to_string(rc));
return;
}
/* Play decoded images */
vpx_codec_iter_t iter = nullptr;
for (vpx_image_t *dest = vpx_codec_get_frame(vc->decoder, &iter);
dest != nullptr;
dest = vpx_codec_get_frame(vc->decoder, &iter)) {
if (vc->vcb) {
vc->vcb(vc->av, vc->friend_number, dest->d_w, dest->d_h,
(const uint8_t *)dest->planes[0], (const uint8_t *)dest->planes[1], (const uint8_t *)dest->planes[2],
dest->stride[0], dest->stride[1], dest->stride[2], vc->vcb_user_data);
}
vpx_img_free(dest); // is this needed? none of the VPx examples show that
}
}
void InitialiseBasics (int argv, char* argc[]) {
TRIAGENS_C_INITIALISE(argv, argc);
// use the rng so the linker does not remove it from the executable
// we might need it later because .so files might refer to the symbols
Random::random_e v = Random::selectVersion(Random::RAND_MERSENNE);
Random::UniformInteger random(0, 1);
random.random();
Random::selectVersion(v);
string revision = "$Revision: BASICS " TRIAGENS_VERSION " (c) triAGENS GmbH $";
LOGGER_TRACE(revision);
#ifdef TRI_BROKEN_CXA_GUARD
pthread_cond_t cond;
pthread_cond_init(&cond, 0);
pthread_cond_broadcast(&cond);
#endif
}
void format_bin::
write(const std::string& filename, buffer_callback_function callback)
{
file file;
surfel_vector buffer;
size_t count = 0;
file.open(filename, true);
while (true) {
bool ret = callback(buffer);
if (!ret)
break;
file.append(&buffer);
count += buffer.size();
}
file.close();
LOGGER_TRACE("Output surfels: " << count);
}
boost::filesystem::path builder::upsweep(boost::filesystem::path input_file,
uint16_t start_stage,
reduction_strategy const* reduction_strategy,
normal_computation_strategy const* normal_comp_strategy,
radius_computation_strategy const* radius_comp_strategy) const {
std::cout << std::endl;
std::cout << "--------------------------------" << std::endl;
std::cout << "upsweep" << std::endl;
std::cout << "--------------------------------" << std::endl;
LOGGER_TRACE("upsweep stage");
lamure::pre::bvh bvh(memory_limit_, desc_.buffer_size, desc_.rep_radius_algo);
if (!bvh.load_tree(input_file.string())) {
return boost::filesystem::path{};
}
if (bvh.state() != bvh::state_type::after_downsweep) {
LOGGER_ERROR("Wrong processing state!");
return boost::filesystem::path{};
}
CPU_TIMER;
// perform upsweep
bvh.upsweep(*reduction_strategy,
*normal_comp_strategy,
*radius_comp_strategy,
desc_.compute_normals_and_radii,
desc_.resample);
auto bvhu_file = add_to_path(base_path_, ".bvhu");
bvh.serialize_tree_to_file(bvhu_file.string(), true);
if ((!desc_.keep_intermediate_files) && (start_stage < 2)) {
std::remove(input_file.string().c_str());
}
input_file = bvhu_file;
// LOGGER_DEBUG("Used memory: " << GetProcessUsedMemory() / 1024 / 1024 << " MiB");
return input_file;
}
boost::filesystem::path builder::convert_to_binary(std::string const& input_type) const{
std::cout << std::endl;
std::cout << "--------------------------------" << std::endl;
std::cout << "convert input file" << std::endl;
std::cout << "--------------------------------" << std::endl;
LOGGER_TRACE("convert to a binary file");
auto input_file = fs::canonical(fs::path(desc_.input_file));
std::shared_ptr<format_abstract> format_in{};
auto binary_file = base_path_;
if (input_type == ".xyz") {
binary_file += ".bin";
format_in = std::unique_ptr<format_xyz>{new format_xyz()};
}
else if (input_type == ".xyz_all") {
binary_file += ".bin_all";
format_in = std::unique_ptr<format_xyzall>{new format_xyzall()};
}
else if (input_type == ".ply") {
binary_file += ".bin";
format_in = std::unique_ptr<format_ply>{new format_ply()};
}
else {
LOGGER_ERROR("Unable to convert input file: Unknown file format");
return boost::filesystem::path{};
}
format_bin format_out;
converter conv(*format_in, format_out, desc_.buffer_size);
conv.set_surfel_callback([](surfel &s, bool& keep) { if (s.pos() == vec3r(0.0,0.0,0.0)) keep = false; });
//conv.set_scale_factor(1);
//conv.set_translation(vec3r(-605535.577, -5097551.573, -1468.071));
CPU_TIMER;
conv.convert(input_file.string(), binary_file.string());
// LOGGER_DEBUG("Used memory: " << GetProcessUsedMemory() / 1024 / 1024 << " MiB");
return binary_file;
}
void fillBuffer () {
size_t n = sizeof(buffer);
char* ptr = reinterpret_cast<char*>(&buffer);
while (0 < n) {
ssize_t r = TRI_READ(fd, ptr, n);
if (r == 0) {
LOGGER_FATAL_AND_EXIT("read on random device failed: nothing read");
}
else if (errno == EWOULDBLOCK) {
LOGGER_INFO("not enough entropy (got " << (sizeof(buffer) - n) << " bytes), switching to pseudo-random");
break;
}
else if (r < 0) {
LOGGER_FATAL_AND_EXIT("read on random device failed: " << strerror(errno));
}
ptr += r;
n -= r;
rseed = buffer[0];
LOGGER_TRACE("using seed " << rseed);
}
if (0 < n) {
unsigned long seed = RandomDevice::getSeed();
TRI_SeedMersenneTwister((uint32_t) (rseed ^ (uint32_t) seed));
while (0 < n) {
*ptr++ = TRI_Int32MersenneTwister();
--n;
}
}
pos = 0;
}
boost::filesystem::path builder::downsweep(boost::filesystem::path input_file, uint16_t start_stage) const{
bool performed_outlier_removal = false;
do {
std::string status_suffix = "";
if ( true == performed_outlier_removal ) {
status_suffix = " (after outlier removal)";
}
std::cout << std::endl;
std::cout << "--------------------------------" << std::endl;
std::cout << "bvh properties" << status_suffix << std::endl;
std::cout << "--------------------------------" << std::endl;
lamure::pre::bvh bvh(memory_limit_, desc_.buffer_size, desc_.rep_radius_algo);
bvh.init_tree(input_file.string(),
desc_.max_fan_factor,
desc_.surfels_per_node,
base_path_);
bvh.print_tree_properties();
std::cout << std::endl;
std::cout << "--------------------------------" << std::endl;
std::cout << "downsweep" << status_suffix << std::endl;
std::cout << "--------------------------------" << std::endl;
LOGGER_TRACE("downsweep stage");
CPU_TIMER;
bvh.downsweep(desc_.translate_to_origin, input_file.string());
auto bvhd_file = add_to_path(base_path_, ".bvhd");
bvh.serialize_tree_to_file(bvhd_file.string(), true);
if ((!desc_.keep_intermediate_files) && (start_stage < 1))
{
// do not remove input file
std::remove(input_file.string().c_str());
}
input_file = bvhd_file;
// LOGGER_DEBUG("Used memory: " << GetProcessUsedMemory() / 1024 / 1024 << " MiB");
if ( 3 <= start_stage ) {
break;
}
if ( performed_outlier_removal ) {
break;
}
if(start_stage <= 2 ) {
if(desc_.outlier_ratio != 0.0) {
size_t num_outliers = desc_.outlier_ratio * (bvh.nodes().size() - bvh.first_leaf()) * bvh.max_surfels_per_node();
size_t ten_percent_of_surfels = std::max( size_t(0.1 * (bvh.nodes().size() - bvh.first_leaf()) * bvh.max_surfels_per_node()), size_t(1) );
num_outliers = std::min(std::max(num_outliers, size_t(1) ), ten_percent_of_surfels); // remove at least 1 surfel, for any given ratio != 0.0
std::cout << std::endl;
std::cout << "--------------------------------" << std::endl;
std::cout << "outlier removal ( " << int(desc_.outlier_ratio * 100) << " percent = " << num_outliers << " surfels)" << std::endl;
std::cout << "--------------------------------" << std::endl;
LOGGER_TRACE("outlier removal stage");
surfel_vector kept_surfels = bvh.remove_outliers_statistically(num_outliers, desc_.number_of_outlier_neighbours);
format_bin format_out;
std::unique_ptr<format_abstract> dummy_format_in{new format_xyz()};
converter conv(*dummy_format_in, format_out, desc_.buffer_size);
conv.set_surfel_callback([](surfel &s, bool& keep) { if (s.pos() == vec3r(0.0,0.0,0.0)) keep = false; });
auto binary_outlier_removed_file = add_to_path(base_path_, ".bin_wo_outlier");
conv.write_in_core_surfels_out(kept_surfels, binary_outlier_removed_file.string());
bvh.reset_nodes();
input_file = fs::canonical(binary_outlier_removed_file);
performed_outlier_removal = true;
} else {
break;
}
}
} while( true );
return input_file;
}
void SimpleHttpClient::setRequest (rest::HttpRequest::HttpRequestType method,
const string& location,
const char* body,
size_t bodyLength,
const map<string, string>& headerFields) {
if (_state == DEAD) {
_connection->resetNumConnectRetries();
}
///////////////////// fill the write buffer //////////////////////////////
_writeBuffer.clear();
HttpRequest::appendMethod(method, &_writeBuffer);
string l = location;
if (location.length() == 0 || location[0] != '/') {
l = "/" + location;
}
_writeBuffer.appendText(l);
_writeBuffer.appendText(" HTTP/1.1\r\n");
_writeBuffer.appendText("Host: ");
_writeBuffer.appendText(_connection->getEndpoint()->getHostString());
_writeBuffer.appendText("\r\n");
_writeBuffer.appendText("Connection: Keep-Alive\r\n");
_writeBuffer.appendText("User-Agent: VOC-Client/1.0\r\n");
// do basic authorization
if (! _pathToBasicAuth.empty()) {
string foundPrefix;
string foundValue;
std::vector< std::pair<std::string, std::string> >::iterator i = _pathToBasicAuth.begin();
for (; i != _pathToBasicAuth.end(); ++i) {
string f = i->first;
if (l.find(f) == 0) {
// f is prefix of l
if (f.length() > foundPrefix.length()) {
foundPrefix = f;
foundValue = i->second;
}
}
}
if (foundValue.length() > 0) {
_writeBuffer.appendText("Authorization: Basic ");
_writeBuffer.appendText(foundValue);
_writeBuffer.appendText("\r\n");
}
}
for (map<string, string>::const_iterator i = headerFields.begin(); i != headerFields.end(); ++i) {
// TODO: check Header name and value
_writeBuffer.appendText(i->first);
_writeBuffer.appendText(": ");
_writeBuffer.appendText(i->second);
_writeBuffer.appendText("\r\n");
}
_writeBuffer.appendText("Content-Length: ");
_writeBuffer.appendInteger(bodyLength);
_writeBuffer.appendText("\r\n\r\n");
_writeBuffer.appendText(body, bodyLength);
LOGGER_TRACE("Request: " << _writeBuffer.c_str());
//////////////////////////////////////////////////////////////////////////
if (_state != FINISHED) {
// close connection to reset all read and write buffers
this->close();
}
if (_connection->isConnected()) {
// we are connected, start with writing
_state = IN_WRITE;
_written = 0;
}
else {
// connect to server
_state = IN_CONNECT;
}
}
void Provider_System::init(Handle<std::string> folder){
#if defined(OPENSSL_SYS_UNIX)
DIR *dir;
class dirent *ent;
class stat st;
BIO *bioFile;
if((dir = opendir(folder->c_str())) == NULL){
if (mkdir(folder->c_str(), 0700) != 0){
THROW_EXCEPTION(0, Provider_System, NULL, "Error create folder");
}
}
else{
closedir(dir);
}
std::string listCertStore[] = {
"MY",
"OTHERS",
"TRUST",
"CRL"
};
for (int i = 0, c = sizeof(listCertStore) / sizeof(*listCertStore); i < c; i++){
std::string dirInCertStore = (std::string)folder->c_str() + CROSSPLATFORM_SLASH + listCertStore[i].c_str();
dir = opendir(dirInCertStore.c_str());
if(dir == NULL){
if (mkdir(dirInCertStore.c_str(), 0700) != 0){
THROW_EXCEPTION(0, Provider_System, NULL, "Error create folder");
}
continue;
}
while ((ent = readdir(dir)) != NULL) {
const std::string file_name = ent->d_name;
const std::string uri = dirInCertStore + CROSSPLATFORM_SLASH + file_name;
if (file_name[0] == '.')
continue;
const bool is_directory = (stat(uri.c_str(), &st) == 0) && S_ISDIR(st.st_mode);
if (is_directory)
continue;
LOGGER_OPENSSL(BIO_new);
bioFile = BIO_new(BIO_s_file());
LOGGER_OPENSSL(BIO_read_filename);
if (BIO_read_filename(bioFile, uri.c_str()) > 0){
Handle<PkiItem> itemTemp = new PkiItem();
itemTemp = objectToPKIItem(new std::string(uri));
if (!itemTemp.isEmpty()){
providerItemCollection->push(itemTemp);
}
}
LOGGER_OPENSSL(BIO_free);
BIO_free(bioFile);
}
closedir(dir);
}
#endif
#if defined(OPENSSL_SYS_WINDOWS)
LOGGER_FN();
try{
HANDLE dir;
WIN32_FIND_DATA file_data;
TCHAR szDir[MAX_PATH];
BIO *bioFile;
if ((dir = FindFirstFile(folder->c_str(), &file_data)) == INVALID_HANDLE_VALUE){
if (_mkdir(folder->c_str()) != 0){
THROW_EXCEPTION(0, Provider_System, NULL, "Error create folder");
}
}
std::string listCertStore[] = {
"MY",
"OTHERS",
"TRUST",
"CRL"
};
for (int i = 0, c = sizeof(listCertStore) / sizeof(*listCertStore); i < c; i++){
std::string dirInCertStore = (std::string)folder->c_str() + CROSSPLATFORM_SLASH + listCertStore[i].c_str();
std::string tempdirInCertStore = "";
tempdirInCertStore = dirInCertStore + "\\*";
LOGGER_TRACE("FindFirstFile");
if ((dir = FindFirstFile(tempdirInCertStore.c_str(), &file_data)) == INVALID_HANDLE_VALUE){
if (_mkdir(dirInCertStore.c_str()) != 0){
THROW_EXCEPTION(0, Provider_System, NULL, "Error create folder");
}
continue;
}
do {
std::string str = file_data.cFileName;
std::wstring file_name(str.begin(), str.end());
std::string uri = dirInCertStore + CROSSPLATFORM_SLASH + std::string(file_name.begin(), file_name.end());
const bool is_directory = (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
if (file_name[0] == '.')
continue;
if (is_directory)
continue;
LOGGER_OPENSSL(BIO_new);
bioFile = BIO_new(BIO_s_file());
LOGGER_OPENSSL(BIO_read_filename);
if (BIO_read_filename(bioFile, uri.c_str()) > 0){
Handle<PkiItem> itemTemp = new PkiItem();
itemTemp = objectToPKIItem(new std::string(uri));
if (!itemTemp.isEmpty()){
providerItemCollection->push(itemTemp);
}
}
// LOGGER_OPENSSL(BIO_free);
// BIO_free_all(bioFile);
} while (FindNextFile(dir, &file_data));
FindClose(dir);
}
}
catch (Handle<Exception> e){
THROW_EXCEPTION(0, Provider_System, e, "Error init system store");
}
#endif
}
