assets/main.cc

#include <unistd.h>

#include <atomic>
#include <fstream>
#include <iostream>
#include <sstream>
#include <unordered_set>
#include <vector>

#include <vtestbed/base/files.hh>
#include <vtestbed/config/openmp.hh>
#include <vtestbed/config/real_type.hh>
#include <vtestbed/assets/convert.hh>

namespace vtb {
namespace assets {

inline std::string
make_output_file(const std::string& input_file, const std::string& output_directory,
                 Format to, const Options& options) {
    auto path = vtb::base::parent_child(input_file);
    if (!output_directory.empty()) { path.first = output_directory; }
    std::string output_file;
    if (path.first != ".") { output_file += path.first; output_file += '/'; }
    output_file += path.second;
    output_file += '.';
    if (options.get<bool>("gnuplot", false)) { output_file += "gnuplot"; }
    else { output_file += to_extension(to); }
    return output_file;
}

class Converter {

private:
    using scalar_type = VTB_REAL_TYPE;

private:
    Format _from{}, _to{};
    std::vector<std::string> _files;
    std::string _output_file, _output_directory;
    Options _options;
    int _nthreads = 1;
    bool _verbose = false;

public:

    void
    arguments(int argc, char* argv[]) {
        auto& from = this->_from;
        auto& to = this->_to;
        auto& files = this->_files;
        auto& output_file = this->_output_file;
        int opt;
        while ((opt = ::getopt(argc, argv, "f:t:o:O:j:d:hv")) != -1) {
            switch (opt) {
                case 'f': from = string_to_format(::optarg); break;
                case 't': to = string_to_format(::optarg); break;
                case 'o': output_file = ::optarg; break;
                case 'O': read_option(::optarg); break;
                case 'h': usage(argv[0]); std::exit(EXIT_SUCCESS); break;
                case 'v': this->_verbose = true; break;
                case 'j': this->_nthreads = std::max(1, std::atoi(::optarg)); break;
                case 'd': this->_output_directory = ::optarg; break;
                default: usage(argv[0]); std::exit(EXIT_FAILURE); break;
            }
        }
        if (::optind == argc) {
            throw std::invalid_argument("no files are specified");
        }
        files.assign(argv + ::optind, argv + argc);
        if (files.size() > 1 && !output_file.empty()) {
            throw std::invalid_argument("single output for many input files");
        }
        if (output_file.empty() && to == Format::Unspecified) {
            throw std::invalid_argument("no output format is specified");
        }
        if (from == Format::Unspecified && files.size() == 1) {
            from = filename_to_format(files.front());
        }
        if (to == Format::Unspecified && !output_file.empty()) {
            to = filename_to_format(output_file);
        }
        if (to == Format::Unspecified && from != Format::Unspecified) { to = from; }
        if (!output_file.empty() && !this->_output_directory.empty()) {
            throw std::invalid_argument(
                "specify either output file or output directory, but not both");
        }
    }

    int run() {
        std::atomic<int> ret{EXIT_SUCCESS};
        const auto& to = this->_to;
        const auto& files = this->_files;
        auto& output_file = this->_output_file;
        if (files.size() == 1) {
            if (output_file.empty()) {
                output_file = make_output_file(files.front(), this->_output_directory,
                                               to, this->_options);
            }
            convert_file(files.front(), output_file);
        } else {
            const auto nfiles = files.size();
            #if defined(VTB_WITH_OPENMP)
            #pragma omp parallel for schedule(dynamic,1) num_threads(this->_nthreads)
            #endif
            for (size_t i=0; i<nfiles; ++i) {
                const auto& file = files[i];
                try {
                    convert_file(file, make_output_file(file, this->_output_directory,
                                                        to, this->_options));
                } catch (const std::exception& err) {
                    std::stringstream msg;
                    msg << err.what() << '\n';
                    std::cerr << msg.str();
                    ret = EXIT_FAILURE;
                }
            }
        }
        return ret;
    }

    void
    convert_file(const std::string& input_file, const std::string& output_file) {
        auto from = this->_from == Format::Unspecified
            ? filename_to_format(input_file) : this->_from;
        const auto& to = this->_to;
        if (this->_verbose) {
            std::stringstream msg;
            msg << input_file << " -> " << output_file << '\n';
            std::clog << msg.str();
        }
        auto options = this->_options;
        options["input-path"] = input_file;
        options["input-format"] = from;
        options["output-path"] = output_file;
        options["output-format"] = to;
        export_asset(convert(import_asset(options), options), options);
    }

    void
    usage(const char* name) {
        std::cout
            << "usage: " << name << " [-f from] [-t to] [-o file] [-O option] [-hvj] file...\n"
            <<
R"(-f from   source format
   -t to     target format
   -o file   output file
   -O option set format-specific option
   -j n      the number of parallel threads
   -v        be verbose
supported formats: vsl, obj, stl, igs, rms, bsp
Options:
format  option        default value  description
--------------------------------------------------------------------------------
vsl     close-top     true           do not remove the main deck
vsl     close-bottom  true           do not remove the bottom
vsl     step-z        auto           vertical distance between points in metres
bsp     resolution-u  2              no. of points for segment in U dimension
bsp     resolution-v  2              no. of points for segment in V dimension
*       gnuplot       false          output as gnuplot script)";
    }

private:

    template <class T>
    void
    read_scalar(const char* arg, std::any& result) {
        std::istringstream str(arg);
        str.exceptions(std::ios::failbit | std::ios::badbit);
        T value{};
        str >> value;
        result = value;
    }

    void read_option(const char* arg) {
        this->_options.read(arg);
    }

};

}
}


int main(int argc, char* argv[]) {
    int ret = EXIT_FAILURE;
    try {
        vtb::assets::Converter converter;
        converter.arguments(argc, argv);
        ret = converter.run();
    } catch (const std::ios::failure&) {
        std::cerr << "i/o error" << std::endl;
    } catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
    }
    return ret;
}