void ImageStackDirectoryDatasource::readMetaDataFile(boost::filesystem::path metaDataFileName) { boost::property_tree::ptree xmlTree; read_xml(metaDataFileName.string(), xmlTree); std::vector<ImageLocation> tempImageLocations; std::vector<MetaDataNode> tempProjectionProperties; for(auto it = xmlTree.begin(); it != xmlTree.end(); ++it) { if(it->first == "projection") { std::string filename = it->second.get_child("image").get<std::string>("<xmlattr>.filename"); tempImageLocations.push_back(ImageLocation(filename)); auto props = this->parseProjectionProperties(it->second); props.nodename = it->first; tempProjectionProperties.push_back(props); } if(it->first == "projectionstack") { auto props = this->parseProjectionProperties(it->second); props.nodename = it->first; std::string filename = it->second.get_child("image").get<std::string>("<xmlattr>.filename"); unsigned int numberOfImages = ImageDeserializer::getNumberOfImagesInStack((directory / filename).string()); for(unsigned int i = 0; i < numberOfImages; i++) { tempImageLocations.push_back(ImageLocation(filename, i)); tempProjectionProperties.push_back(props); } } } std::unordered_map<float, unsigned int> tiltAngleToIndex; std::unordered_map<float, unsigned int> tiltAngleProjectionCount; for(unsigned int i = 0; i < tempProjectionProperties.size(); ++i) { float tiltAngle = tempProjectionProperties[i].tiltAngle; auto findIt = tiltAngleToIndex.find(tiltAngle); if(findIt == tiltAngleToIndex.end()) { // Without the temporary variable, there seems to be a memory corruption on linux, // but I did not find the real cause unsigned int currentIndex = (unsigned int)tiltAngleToIndex.size(); tiltAngleToIndex[tiltAngle] = currentIndex; tiltAngleProjectionCount[tiltAngle] = 0; } HyperStackIndex index(tiltAngleToIndex[tiltAngle], tiltAngleProjectionCount[tiltAngle]++); imageLocations[index] = tempImageLocations[i]; metaDataNodes[index] = tempProjectionProperties[i]; } if(this->isEveryTiltAngleUnique()) { this->convertToOneDimension(); this->resolution = this->getProjectionImage(HyperStackIndex(0))->getResolution(); } else { this->resolution = this->getProjectionImage(HyperStackIndex(0, 0))->getResolution(); } auto baseScannerGeometry = createScannerGeometry( xmlTree.get_child("geometry") ); this->satRotator.setBaseScannerGeometry(baseScannerGeometry); }
void SceneImporter::load(const std::string& filename) { read_xml(filename, pt); }
//parse the RSS feed which is xml, get each items, generate element for new item and insert into elementList void RssStreamInput::generateElementByRss(std::string& rssXmlContent) { boost::property_tree::ptree pt; stringstream ss; ss << rssXmlContent; read_xml(ss, pt); boost::property_tree::ptree channelPt; channelPt = pt.get_child("rss.channel"); std::string linkurl = channelPt.get_child("link").data(); std::vector<std::string> titleVector; // save the titles in the RSS feed page std::vector<std::string> linkVector; // save the links in the RSS feed page //mark if the newest title we processed is still in this RSS feed page bool isProcessedNewestTitleStillInThisPage = false; std::string processedNewestTitle; std::map<std::string, std::string >::iterator it = this->urlTitleMap.find(linkurl); if(it != this->urlTitleMap.end()) { processedNewestTitle = it->second; } else { processedNewestTitle = ""; } BOOST_FOREACH(boost::property_tree::ptree::value_type &v1, channelPt) { if(v1.first=="item") { boost::property_tree::ptree itemPt = v1.second; //get the title and link for each item std::string title; std::string link; title = itemPt.get_child("title").data(); link = itemPt.get_child("link").data(); //save title and link titleVector.push_back(title); linkVector.push_back(link); //see if any exists if(processedNewestTitle == title) { isProcessedNewestTitleStillInThisPage = true; } } } //if new titles exist, generate corresponding elements if(isProcessedNewestTitleStillInThisPage == false) {//no title has been processed, generate element for each one int number = titleVector.size(); for( int i = number-1; i >=0 ; i--)//reverse scan, we scan from the oldest to the newest { std::string title = titleVector[i]; std::string link = linkVector[i]; DocumentBuilder builder; builder.append("title",title); builder.append("link",link); Document document = builder.obj(); Element element; element.document = document; element.id = DocumentIdentifierGenerator::generateNewDocumentIdentifier(); element.timestamp = TimestampGenerator::getCurrentTime(); this->rssElementList.push_back(element); } } else {//we have processed some titles in this page, generate element for the new titles int number = titleVector.size(); bool isProccesdNewsetTitleMeet = false; for( int i = number-1; i >=0 ; i--)//reverse scan, we scan from the oldest to the newest { std::string title = titleVector[i]; std::string link = linkVector[i]; if(isProccesdNewsetTitleMeet == true) {// during the scan of the titles from the oldest to the newest, the one which we have processed before is passed // then the titles after are all new titles, we should generate element for them each. DocumentBuilder builder; builder.append("title",title); builder.append("link",link); Document document = builder.obj(); Element element; element.document = document; element.id = DocumentIdentifierGenerator::generateNewDocumentIdentifier(); element.timestamp = TimestampGenerator::getCurrentTime(); element.masterTag = false; this->rssElementList.push_back(element); } if(title == processedNewestTitle) { isProccesdNewsetTitleMeet = true; } } } //update processedNewestTitle if(this->urlTitleMap[linkurl] != titleVector.front()) { this->urlTitleMap[linkurl] = titleVector.front(); isUrlTitleMapValueChanged = true; } }
void pcl::gpu::people::PersonAttribs::readPersonXMLConfig (std::istream& is) { boost::property_tree::ptree pt; read_xml(is,pt); }
} return result; } header_buffer_type read_xml(const char* test_id) { std::string input = read_file(test_id); return parse_xml(input); } // ============================================= TEST_CASE("Reading OSM XML 100") { SECTION("Direct") { header_buffer_type r = read_xml("100-correct_but_no_data"); REQUIRE(r.header.get("generator") == "testdata"); REQUIRE(0 == r.buffer.committed()); REQUIRE(! r.buffer); } SECTION("Using Reader") { osmium::io::Reader reader{filename("100-correct_but_no_data")}; const osmium::io::Header header{reader.header()}; REQUIRE(header.get("generator") == "testdata"); osmium::memory::Buffer buffer = reader.read(); REQUIRE(0 == buffer.committed()); REQUIRE(! buffer);
void PluginManager::init() { static const std::string plugin_config_file("./plugins.xml"); std::string current_path = directory_conf(); std::string full_path = current_path + "/" + plugin_config_file; BOOST_LOG_TRIVIAL(trace) << "Loading plugin configuration file from " << full_path; try { read_xml(full_path, _pt); } catch (...) { BOOST_LOG_TRIVIAL(error) << "Can not load configuration file from " << full_path; return; } // iterate configuration for configured plugins BOOST_LOG_TRIVIAL(trace) << "Target load plugins..."; for (pt::ptree::value_type &node : _pt.get_child("plugins")) { if (node.first == "plugin") { std::string name(node.second.get<std::string>("name")); std::string path(current_path + "/" + node.second.get<std::string>("path")); BOOST_LOG_TRIVIAL(trace) << "Module Name: " << name << " Module Path: " << path; SharedLibrary libHandle(path, name); BOOST_LOG_TRIVIAL(trace) << "Loading library " << libHandle.GetFilePath(); try { libHandle.Load(); } catch (...) { BOOST_LOG_TRIVIAL(error) << "Error when loading plugin library " << path << name; } } } // iterate to every module and get service references std::vector<Module *> modules = ModuleRegistry::GetModules(); BOOST_LOG_TRIVIAL(trace) << "Print existing plugins... "; for (Module *module : modules) { BOOST_LOG_TRIVIAL(trace) << "Module Name: " << module->GetName() << " Module ID: " << module->GetModuleId() << " Status: " << (module->IsLoaded() ? "LOADED" : "UNLOADED"); if (module->IsLoaded()) { ModuleContext *context = module->GetModuleContext(); std::vector<ServiceReference<IoTInfoProvider>> services = context->GetServiceReferences<IoTInfoProvider>( "(type=IoTInfoProvider)"); BOOST_LOG_TRIVIAL(trace) << "Find " << services.size() << " provider references"; for (ServiceReference<IoTInfoProvider> &value : services) { IoTInfoProvider *provider = context->GetService<IoTInfoProvider>(value); if (std::find(this->begin(), this->end(), provider) == this->end()) { this->push_back(provider); } } } } BOOST_LOG_TRIVIAL(trace) << "Total " << this->size() << " providers loaded"; }
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable ) { int error = 0; /* Obtain properties of frame */ mlt_properties properties = MLT_FRAME_PROPERTIES( frame ); /* Obtain the producer for this frame */ producer_ktitle self = mlt_properties_get_data( properties, "producer_kdenlivetitle", NULL ); /* Obtain properties of producer */ mlt_producer producer = &self->parent; mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer ); if ( mlt_properties_get_int( properties, "rescale_width" ) > 0 ) *width = mlt_properties_get_int( properties, "rescale_width" ); if ( mlt_properties_get_int( properties, "rescale_height" ) > 0 ) *height = mlt_properties_get_int( properties, "rescale_height" ); mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) ); /* Allocate the image */ if ( mlt_properties_get_int( producer_props, "force_reload" ) ) { if ( mlt_properties_get_int( producer_props, "force_reload" ) > 1 ) read_xml( producer_props ); mlt_properties_set_int( producer_props, "force_reload", 0 ); drawKdenliveTitle( self, frame, *format, *width, *height, mlt_frame_original_position( frame ), 1 ); } else { drawKdenliveTitle( self, frame, *format, *width, *height, mlt_frame_original_position( frame ), 0 ); } // Get width and height (may have changed during the refresh) *width = mlt_properties_get_int( properties, "width" ); *height = mlt_properties_get_int( properties, "height" ); *format = self->format; if ( self->current_image ) { // Clone the image and the alpha int image_size = mlt_image_format_size( self->format, self->current_width, self->current_height, NULL ); uint8_t *image_copy = mlt_pool_alloc( image_size ); // We use height-1 because mlt_image_format_size() uses height + 1. // XXX Remove -1 when mlt_image_format_size() is changed. memcpy( image_copy, self->current_image, mlt_image_format_size( self->format, self->current_width, self->current_height - 1, NULL ) ); // Now update properties so we free the copy after mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release ); // We're going to pass the copy on *buffer = image_copy; // Clone the alpha channel if ( self->current_alpha ) { image_copy = mlt_pool_alloc( self->current_width * self->current_height ); memcpy( image_copy, self->current_alpha, self->current_width * self->current_height ); mlt_frame_set_alpha( frame, image_copy, self->current_width * self->current_height, mlt_pool_release ); } } else { error = 1; } mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) ); return error; }
int CConfig::loadConfig(const char* filename) { read_xml(filename, pt); // load tree path if (boost::optional<std::string> str = pt.get_optional<std::string>("root.treepath")) { std::cout << str.get() << std::endl; treepath = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load number of tree if (boost::optional<int> integer = pt.get_optional<int>("root.ntree")) { std::cout << integer << std::endl; ntrees = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load patch width if (boost::optional<int> integer = pt.get_optional<int>("root.pwidth")) { std::cout << integer << std::endl; p_width = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load patch height if (boost::optional<int> integer = pt.get_optional<int>("root.pheight")) { std::cout << integer << std::endl; p_height = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load test image path if (boost::optional<std::string> str = pt.get_optional<std::string>("root.imgpath")) { std::cout << str.get() << std::endl; impath = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load image name list if (boost::optional<std::string> str = pt.get_optional<std::string>("root.imgnamelist")) { std::cout << str.get() << std::endl; imfiles = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load extruct feature flag if (boost::optional<bool> boolean = pt.get_optional<bool>("root.efeatures")) { std::cout << boolean << std::endl; xtrFeature = *boolean; } else { std::cout << "root.str is nothing" << std::endl; } // load image scales std::cout << "kokomade" << std::endl; scales.resize(0); BOOST_FOREACH (const boost::property_tree::ptree::value_type& child, pt.get_child("root.scales")) { const float value = boost::lexical_cast<float>(child.second.data()); scales.push_back(value); std::cout << value << std::endl; } for (int i;i < scales.size(); ++i) std::cout << i << ": " << scales.at(i) << std::endl; float value_temp = 1; scales.clear(); scales.push_back(value_temp); ratios.clear(); ratios.push_back(value_temp); ratios.push_back(value_temp); // // load image ratios ratios.resize(0); BOOST_FOREACH (const boost::property_tree::ptree::value_type& child, pt.get_child("root.ratio")) { const float value = boost::lexical_cast<float>(child.second.data()); ratios.push_back(value); std::cout << value << std::endl; } for (int i;i < ratios.size(); ++i) std::cout << i << ": " << ratios.at(i) << std::endl; // load output path if (boost::optional<std::string> str = pt.get_optional<std::string>("root.outpath")) { std::cout << str.get() << std::endl; outpath = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load scale factor for output imae if (boost::optional<int> integer = pt.get_optional<int>("root.sfactor")) { std::cout << integer << std::endl; out_scale = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load training image name list if (boost::optional<std::string> str = pt.get_optional<std::string>("root.traindataname")) { std::cout << str.get() << std::endl; traindatafile = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load training image folder if (boost::optional<std::string> str = pt.get_optional<std::string>("root.trainimgpath")) { std::cout << str.get() << std::endl; trainpath = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load scale factor for output imae if (boost::optional<int> integer = pt.get_optional<int>("root.trainimagepertree")) { std::cout << integer << std::endl; imagePerTree = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load scale factor for output imae if (boost::optional<int> integer = pt.get_optional<int>("root.minsample")) { std::cout << integer << std::endl; min_sample = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load scale factor for output imae if (boost::optional<int> integer = pt.get_optional<int>("root.maxdepth")) { std::cout << integer << std::endl; max_depth = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load scale factor for output imae if (boost::optional<int> integer = pt.get_optional<int>("root.featurechannel")) { std::cout << integer << std::endl; featureChannel = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load scale factor for output imae if (boost::optional<double> variableDouble = pt.get_optional<double>("root.patchratio")) { std::cout << variableDouble << std::endl; patchRatio = *variableDouble; } else { std::cout << "root.str is nothing" << std::endl; } // load scale factor for output imae if (boost::optional<int> integer = pt.get_optional<int>("root.stride")) { std::cout << integer << std::endl; stride = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load offset of tree name if (boost::optional<int> integer = pt.get_optional<int>("root.offTree")) { std::cout << integer << std::endl; off_tree = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load test data folder if (boost::optional<std::string> str = pt.get_optional<std::string>("root.testpath")) { std::cout << str.get() << std::endl; testPath = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load test data file name if (boost::optional<std::string> str = pt.get_optional<std::string>("root.testdataname")) { std::cout << str.get() << std::endl; testData = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load test data file name if (boost::optional<std::string> str = pt.get_optional<std::string>("root.classdatabasename")) { std::cout << str.get() << std::endl; classDatabaseName = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load offset of tree name if (boost::optional<int> integer = pt.get_optional<int>("root.learningmode")) { std::cout << integer << std::endl; learningMode = *integer; } else { std::cout << "root.str is nothing" << std::endl; } // load training image name list if (boost::optional<std::string> str = pt.get_optional<std::string>("root.traindatalistname")) { std::cout << str.get() << std::endl; traindatalist = *str; } else { std::cout << "root.str is nothing" << std::endl; } // load testing image name list if (boost::optional<std::string> str = pt.get_optional<std::string>("root.testdatalistname")) { std::cout << str.get() << std::endl; testdatalist = *str; } else { std::cout << "root.str is nothing" << std::endl; } return 0; }
void read_xml(std::istream & in, PTree & p) { read_xml(in, p, std::string()); }
void read_xml(const wchar_t * path, boost::property_tree::wptree & out) { read_xml(boost::filesystem::wpath(path), out); }
void read_xml(const std::wstring & path, boost::property_tree::wptree & out) { read_xml(boost::filesystem::wpath(path), out); }
void read_xml(const boost::filesystem::wpath & path, boost::property_tree::wptree & out) { boost::filesystem::ifstream inp(path, std::ios::binary); read_xml(inp, out); }
/****************************************************************************** MODULE: generate_stack PURPOSE: Generates the CSV stack file for the input list of XML files. RETURN VALUE: Type = int Value Description ----- ----------- ERROR An error occurred during processing of the files SUCCESS Processing was successful PROJECT: Land Satellites Data System Science Research and Development (LSRD) at the USGS EROS HISTORY: Date Programmer Reason ---------- --------------- ------------------------------------- 03/12/2014 Gail Schmidt Original Development NOTES: ******************************************************************************/ int main (int argc, char *argv[]) { bool verbose; /* verbose flag for printing messages */ char FUNC_NAME[] = "main"; /* function name */ char errmsg[STR_SIZE]; /* error message */ char **xml_infile = NULL; /* array to hold list of input XML filenames */ char *list_infile=NULL; /* file containing the temporal list of reflectance products to be processed */ char *stack_file=NULL; /* output CSV file for the XML stack */ int i; /* looping variable */ int retval; /* return status */ int curr_line; /* counter of the current line */ int nlines; /* number of lines in the input temporal list */ int nfiles; /* number of actual files in the input list */ int count; /* count of items read from file */ Ba_scene_meta_t scene_meta; /* structure to contain the desired metadata for the current XML file */ FILE *list_fptr=NULL; /* output file pointer for list of files */ FILE *stack_fptr=NULL; /* output file pointer for CSV stack */ printf ("Generating CSV stack file ...\n"); /* Read the command-line arguments, including the name of the input list of files and the output file to write the stack */ retval = get_args (argc, argv, &list_infile, &stack_file, &verbose); if (retval != SUCCESS) { /* get_args already printed the error message */ exit (ERROR); } /* Provide user information if verbose is turned on */ if (verbose) { printf (" Input list file: %s\n", list_infile); printf (" Output stack file: %s\n", stack_file); } /* Open the input list of reflectance files */ list_fptr = fopen (list_infile, "r"); if (list_fptr == NULL) { sprintf (errmsg, "Unable to open the input temporal list file: %s", list_infile); error_handler (true, FUNC_NAME, errmsg); exit (ERROR); } /* Determine the maximum number of reflectance files in the input file. Note the first scanf grabs lines with text. If that fails, the second scanf grabs empty lines. We'll count all of them for now and then only read the non-empty lines. */ nlines = 0; while (EOF != (fscanf (list_fptr, "%*[^\n]"), fscanf (list_fptr, "%*c"))) nlines++; /* Allocate memory for the list of filenames */ xml_infile = (char **) calloc (nlines, sizeof (char *)); if (xml_infile != NULL) { for (i = 0; i < nlines; i++) { xml_infile[i] = (char *) calloc (STR_SIZE, sizeof (char)); if (xml_infile[i] == NULL) { sprintf (errmsg, "Error allocating memory for array of %d " "strings to hold the list of XML filenames.", nlines); error_handler (true, FUNC_NAME, errmsg); fclose (list_fptr); exit (ERROR); } } } else { sprintf (errmsg, "Error allocating memory for array of %d strings " "to hold the list of reflectance filenames.", nlines); error_handler (true, FUNC_NAME, errmsg); fclose (list_fptr); exit (ERROR); } /* Read the list of XML files in the input file */ rewind (list_fptr); curr_line = 0; for (i = 0; i < nlines; i++) { count = fscanf (list_fptr, "%s[^\n]", &xml_infile[curr_line][0]); if (count == EOF) break; else if (count == 0) { /* blank line so skip and move to the next; don't count the line */ fscanf (list_fptr, "%*c"); } else curr_line++; } /* Set the nfiles counter if to the actual number of files in the input list; this might be different than the count of lines from earlier */ nfiles = curr_line; /* Close the input file */ fclose (list_fptr); /* Open the output CSV stack file */ stack_fptr = fopen (stack_file, "w"); if (stack_fptr == NULL) { sprintf (errmsg, "Unable to open the output CSV stack file: %s", stack_file); error_handler (true, FUNC_NAME, errmsg); exit (ERROR); } /* Write the header for the stack file */ fprintf (stack_fptr, "file, year, season, month, day, julian, path, row, " "satellite, west, east, north, south, nrow, ncol, dx, dy, utm_zone\n"); /* Loop through each of the input files, read the metadata, and write to the stack file */ if (verbose) printf ("Input list file contains %d filenames\n", nfiles); for (i = 0; i < nfiles; i++) { if (verbose) printf ("\nProcessing current file %d: %s\n", i, xml_infile[i]); /* Process the current file */ retval = read_xml (xml_infile[i], &scene_meta); if (retval != SUCCESS) { /* trouble processing this file so skip and go to the next one */ sprintf (errmsg, "Error processing file %s. Skipping and moving " "to the next file.", xml_infile[i]); error_handler (false, FUNC_NAME, errmsg); continue; } /* Write the stack information */ fprintf (stack_fptr, "%s, %d, %s, %d, %d, %d, %d, %d, %s, " "%lf, %lf, %lf, %lf, %d, %d, %f, %f, %d\n", scene_meta.filename, scene_meta.acq_date.year, scene_meta.season, scene_meta.acq_date.month, scene_meta.acq_date.day, scene_meta.acq_date.doy, scene_meta.wrs_path, scene_meta.wrs_row, scene_meta.satellite, scene_meta.bounding_coords[ESPA_WEST], scene_meta.bounding_coords[ESPA_EAST], scene_meta.bounding_coords[ESPA_NORTH], scene_meta.bounding_coords[ESPA_SOUTH], scene_meta.nlines, scene_meta.nsamps, scene_meta.pixel_size[0], scene_meta.pixel_size[1], scene_meta.utm_zone); } /* Close the output files */ fclose (stack_fptr); /* Free the filename pointers */ for (i = 0; i < nlines; i++) free (xml_infile[i]); free (xml_infile); free (list_infile); free (stack_file); /* Indicate successful completion of processing */ printf ("Stack file generation complete!\n"); exit (SUCCESS); }
int main (int argc, char* argv[]) { ApplicationsLib::LogogSetup logog_setup; TCLAP::CmdLine cmd("Postp-process results of the LIE approach", ' ', "0.1"); TCLAP::ValueArg<std::string> arg_out_pvd("o", "output-file", "the name of the new PVD file", true, "", "path"); cmd.add(arg_out_pvd); TCLAP::ValueArg<std::string> arg_in_pvd("i", "input-file", "the original PVD file name", true, "", "path"); cmd.add(arg_in_pvd); cmd.parse(argc, argv); auto const in_pvd_filename = arg_in_pvd.getValue(); auto const in_pvd_file_dir = BaseLib::extractPath(in_pvd_filename); auto const out_pvd_filename = arg_out_pvd.getValue(); auto const out_pvd_file_dir = BaseLib::extractPath(out_pvd_filename); INFO("start reading the PVD file %s", in_pvd_filename.c_str()); boost::property_tree::ptree pt; read_xml(arg_in_pvd.getValue(), pt, boost::property_tree::xml_parser::trim_whitespace); for (auto& dataset : pt.get_child("VTKFile.Collection")) { if (dataset.first != "DataSet") continue; // read VTU with simulation results auto const org_vtu_filename = dataset.second.get<std::string>("<xmlattr>.file"); INFO("processing %s...", (in_pvd_file_dir + org_vtu_filename).c_str()); std::unique_ptr<MeshLib::Mesh const> mesh( MeshLib::IO::readMeshFromFile(in_pvd_file_dir + org_vtu_filename)); // post-process std::vector<MeshLib::Element*> vec_matrix_elements; std::vector<int> vec_fracture_mat_IDs; std::vector<std::vector<MeshLib::Element*>> vec_fracture_elements; std::vector<std::vector<MeshLib::Element*>> vec_fracture_matrix_elements; std::vector<std::vector<MeshLib::Node*>> vec_fracture_nodes; ProcessLib::LIE::getFractureMatrixDataInMesh( *mesh, vec_matrix_elements, vec_fracture_mat_IDs, vec_fracture_elements, vec_fracture_matrix_elements, vec_fracture_nodes); ProcessLib::LIE::PostProcessTool post( *mesh, vec_fracture_nodes, vec_fracture_matrix_elements); // create a new VTU file and update XML auto const dest_vtu_filename = "post_" + org_vtu_filename; INFO("create %s", (out_pvd_file_dir + dest_vtu_filename).c_str()); MeshLib::IO::writeMeshToFile(post.getOutputMesh(), out_pvd_file_dir + dest_vtu_filename); dataset.second.put("<xmlattr>.file", dest_vtu_filename); } // save into the new PVD file INFO("save into the new PVD file %s", out_pvd_filename.c_str()); boost::property_tree::xml_writer_settings<std::string> settings('\t', 1); write_xml(arg_out_pvd.getValue(), pt, std::locale(), settings); return EXIT_SUCCESS; }