shapes-main.cpp

Go to the documentation of this file.

#include <icedb/defs.h>
#include <boost/program_options.hpp>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <icedb/shape.hpp>
#include <icedb/Database.hpp>
#include <icedb/fs_backend.hpp>
#include "shape.hpp"
#include "shapeIOtext.hpp"

// A list of valid shapefile output formats
const std::map<std::string, std::set<sfs::path> > file_formats = {
    {"text", {".dat", ".shp", ".txt", ".shape"} },
    {"icedb", {".hdf5", ".nc", ".h5", ".cdf", ".hdf"} }
};

// These get set in main(int,char**).
float resolution_um = 0; 

icedb::Groups::Group::Group_ptr basegrp; 

int main(int argc, char** argv) {
    try {
        using namespace std;
        // Read program options

        namespace po = boost::program_options;
        po::options_description desc("Allowed options");
        desc.add_options()
            ("help,h", "produce help message")
            ("from", po::value<string>(), "The path where a shape is read from")
            ("to", po::value<string>(), "The path where the shape is written to")
            ("db-path", po::value<string>()->default_value("shape"), "The path within the database to write to")
            ("create", "Create the output database if it does not exist")
            ("resolution", po::value<float>(), "Lattice spacing for the shape, in um")
            ("truncate", "Instead of opening existing output files in read-write mode, truncate them.")
            ;
        po::variables_map vm;
        po::store(po::command_line_parser(argc, argv).options(desc).run(), vm);
        po::notify(vm);

        auto doHelp = [&](const string& s)->void
        {
            cout << s << endl;
            cout << desc << endl;
            exit(1);
        };
        if (vm.count("help")) doHelp("");
        if (!vm.count("from") || !vm.count("to")) doHelp("Need to specify to/from locations.");

        using namespace icedb;

        // namespace sfs defined for compatability. See <icedb/fs_backend.hpp>
        string sFromRaw = vm["from"].as<string>();
        string sToRaw = vm["to"].as<string>();
        sfs::path pFromRaw(sFromRaw);
        sfs::path pToRaw(sToRaw);
        string dbpath = vm["db-path"].as<string>();
        if (vm.count("resolution")) resolution_um = vm["resolution"].as<float>();

        // Create the output database if it does not exist
        auto iof = fs::IOopenFlags::READ_WRITE;
        if (vm.count("create")) iof = fs::IOopenFlags::CREATE;
        if (vm.count("truncate")) iof = fs::IOopenFlags::TRUNCATE;
        if (!sfs::exists(pToRaw)) iof = fs::IOopenFlags::CREATE;
        Databases::Database::Database_ptr db = Databases::Database::openDatabase(pToRaw.string(), iof);
        
        // Reading the shape from the text file
        auto data = icedb::Examples::Shapes::readTextFile(pFromRaw.string());
        // Set a basic particle id. This id is used when writing the shape to the output file.
        // In this example, objects in the output file are named according to their ids.
        data.required.particle_id = pFromRaw.filename().string();
        if (resolution_um)
            data.optional.particle_scattering_element_spacing = resolution_um / 1.e6f;

        // Writing the shape to the HDF5/netCDF file
        
        basegrp = db->createGroupStructure(dbpath);
        auto shp = data.toShape(data.required.particle_id, basegrp->getHDF5Group());
    }
    // Ensure that unhandled errors are displayed before the application terminates.
    catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }
    catch (...) {
        std::cerr << "Unknown exception caught." << std::endl;
        return 1;
    }
    return 0;
}