C++ ArgumentParser::addArgument方法代码示例

CVMArgumentParser::CVMArgumentParser(int argc, const char** argv, bool requireCalib, bool requireOutputPath, bool requireInputPath, bool requireSize){
     // make a new ArgumentParser
    ArgumentParser parser;
    parser.addArgument("-c", "--calib_file", 1, !requireCalib);
    parser.addArgument("-d", "--devices", 1, true);
    parser.addArgument("-h", "--height", 1, !requireSize);
    parser.addArgument("-w", "--width", 1, !requireSize);
    parser.addArgument("-o", "--output", 1, !requireOutputPath);
    parser.addArgument("-i", "--input", 1, !requireInputPath);
    parser.addArgument("-s", "--saveData", 1, true);
    parser.addArgument("-v", "--saveVideo", 1, true);
    parser.addArgument("-t", "--debugTiming", 1, true);
    parser.addArgument("-q", "--quiet", 1, true);
    parser.parse(argc, argv);

    outputpath = parser.retrieve<string>("o");
    
    inputpath = parser.retrieve<string>("i");
    
    calib_file_path = parser.retrieve<string>("c");
    cout << calib_file_path << endl;

    deviceID = "/dev/video0";
    string devicestring = parser.retrieve<string>("d");
    if (devicestring.length() != 0)
        deviceID = devicestring;
    
    height = 960;
    string heightstring = parser.retrieve<string>("h");
    if (heightstring.length() != 0)
        height =stoi(heightstring);

    width = 1280;
    string widthstring = parser.retrieve<string>("w");
    if (widthstring.length() != 0)
        width =stoi(widthstring);

    saveData = false;
    string saveDatastr = parser.retrieve<string>("s");
    if (saveDatastr.length() != 0)
        saveData =(stoi(saveDatastr) == 1);

    saveVideo = false;
    string saveVideostr = parser.retrieve<string>("v");
    if (saveVideostr.length() != 0)
        saveVideo =(stoi(saveVideostr) == 1);
    
    saveTiming = false;
    string saveTimingstr = parser.retrieve<string>("t");
    if (saveTimingstr.length() != 0)
        saveTiming =(stoi(saveTimingstr) == 1);

    quiet = false;
    string quietstr = parser.retrieve<string>("q");
    if (quietstr.length() != 0)
        quiet =(stoi(quietstr) == 1);
}

int main(int argc, char *argv[])
{
    ArgumentParser parser;
    parser.addArgument("-i", "--input", 1, false);
    parser.parse(argc, argv);
    TApplication *myapp = new TApplication("App", &argc, argv);
    fit(parser.retrieve<string>("i"));
    myapp->Run();
}

int main(int argc, char **argv)
{
    ArgumentParser parser;
    parser.addArgument("-i", "--input", 1, false);
    parser.addArgument("-t", "--tree", 1, true);
    parser.addArgument("-b", "--branch", 1, false);
    parser.addArgument("-f", "--filter", 1, true);
    parser.addArgument("--hits_name", 1, true);
    parser.addArgument("--hits_bins", 1, true);
    parser.addArgument("--hist-start", 1, true);
    parser.addArgument("--hist-end", 1, true);
    parser.addArgument("--fit-start", 1, true);
    parser.addArgument("--fit-end", 1, true);
    parser.addArgument("-o", "--output", 1, false);

    parser.parse(argc, argv);
    Fit *fit;
    if (parser.count("tree"))
        fit = new Fit(parser.retrieve<string>("input"), parser.retrieve<string>("tree"));
    else
        fit = new Fit(parser.retrieve<string>("input"));
    if (parser.count("hist-start"))
        fit->hist_start = stod(parser.retrieve<string>("hist-start"));
    if (parser.count("hist-end"))
        fit->hist_start = stod(parser.retrieve<string>("hist-end"));
    if (parser.count("fit-start"))
        fit->hist_start = stod(parser.retrieve<string>("fit-start"));
    if (parser.count("fit-end"))
        fit->hist_start = stod(parser.retrieve<string>("fit-end"));
    if (parser.count("hits_bins"))
        fit->hist_bins = stoi(parser.retrieve<string>("hits_bins"));
    if (parser.count("hits_name"))
        fit->create_hist(parser.retrieve<string>("hist_name"));
    else
        fit->create_hist();
    if (parser.count("filter"))
        fit->load(parser.retrieve<string>("branch"), parser.retrieve<string>("filter"));
    else
        fit->load(parser.retrieve<string>("branch"));
    fit->process(parser.retrieve<string>("output"));
}

int main(int argc, char** argv)
{
    sofa::simulation::tree::init();
    sofa::component::initComponentBase();
    sofa::component::initComponentCommon();

    bool showHelp = false;
    unsigned int idExample = 0;
    ArgumentParser* argParser = new ArgumentParser(argc, argv);
    argParser->addArgument(po::value<bool>(&showHelp)->default_value(false)->implicit_value(true),                  "help,h", "Display this help message");
    argParser->addArgument(po::value<unsigned int>(&idExample)->default_value(0)->notifier([](unsigned int value)
    {
        if (value < 0 || value > 9) {
            std::cerr << "Example Number to enter from (0 - 9), current value: " << value << std::endl;
            exit( EXIT_FAILURE );
        }
    }),                                                                                                             "example,e", "Example Number to enter from (0 - 9)");

    argParser->parse();

    if(showHelp)
    {
        argParser->showHelp();
        exit( EXIT_SUCCESS );
    }

    // init GUI
    sofa::gui::initMain();
    sofa::gui::GUIManager::Init(argv[0]);

    // Create simulation tree
    sofa::simulation::setSimulation(new sofa::simulation::tree::TreeSimulation());


    // Create the graph root node with collision
    sofa::simulation::Node::SPtr root = sofa::modeling::createRootWithCollisionPipeline();
    root->setGravity( sofa::defaulttype::Vec3Types::Deriv(0,-10.0,0) );


    // Create scene example (depends on user input)
    switch (idExample)
    {
    case 0:
        fallingCubeExample(root);
        break;
    case 1:
        fallingCylinderExample(root);
        break;
    case 2:
        fallingSphereExample(root);
        break;
    case 3:
        fallingDrapExample(root);
        break;
    default:
        fallingCubeExample(root);
        break;
    }


    root->setAnimate(false);

    sofa::simulation::getSimulation()->init(root.get());

    //=======================================
    // Run the main loop
    sofa::gui::GUIManager::MainLoop(root);

    sofa::simulation::tree::cleanup();

    return 0;
}

int main(int argc, const char** argv) {
	
    // Load the command line config
    
    ArgumentParser parser;
        
    parser.addArgument("-e", "--epochs", 1);
    parser.addArgument("-s", "--seed", 1);
    parser.addArgument("-l", "--layers", 1);
    parser.addArgument("-S", "--samples", 1);
    parser.addArgument("-c", "--corpus", 1);
    parser.addArgument("--nlayers", 1);
    parser.addArgument("--ifbradius", 1);
    parser.addArgument("--lw", 1);
    parser.addArgument("--lh", 1);
    parser.addArgument("--ssize", 1);
    parser.addArgument("--sseednoise", 1);
    parser.addArgument("--sprednoise", 1);
    
    parser.parse(argc, argv);
    
	// RNG
    unsigned int seed = std::atoi(parser.retrieve("seed", std::to_string(time(nullptr))).c_str());
	std::mt19937 generator(seed);

	std::uniform_real_distribution<float> dist01(0.0f, 1.0f);
    
	// ---------------------------------- Load the Corpus ----------------------------------
	std::string corpusPath = parser.retrieve("corpus", "corpus.txt");
	std::ifstream fromFile(corpusPath);

	fromFile.seekg(0, std::ios::end);
	size_t size = fromFile.tellg();
	std::string test(size, ' ');
	fromFile.seekg(0);
	fromFile.read(&test[0], size);
	
	// ---------------------------------- Find Character Set ----------------------------------
	
	VectorCodec textcodec(test);
	int numInputs = textcodec.N;
	int inputsRoot = std::ceil(std::sqrt(static_cast<float>(numInputs)));
	
	// ---------------------------------- Create Hierarchy ----------------------------------
	
	// Fill out layer descriptions
	int nLayers = std::atoi(parser.retrieve("nlayers", "3").c_str());
	int layerW = std::atoi(parser.retrieve("lw", "16").c_str());
	int layerH = std::atoi(parser.retrieve("lh", "16").c_str());
	int inFeedBackRadius = std::atoi(parser.retrieve("ifbradius", "16").c_str());
	
	std::vector<neo::PredictiveHierarchy::LayerDesc> layerDescs(nLayers);
	
	for (int i = 0; i < nLayers; i++) {
		layerDescs[i]._width = layerW;
		layerDescs[i]._height = layerH;
	}
	
	neo::PredictiveHierarchy ph;
	
	ph.createRandom(inputsRoot, inputsRoot, inFeedBackRadius, layerDescs, -0.01f, 0.01f, 0.01f, 0.05f, 0.1f, generator);
	
	// ---------------------------------- Iterate Over Corpus ----------------------------------
    int numEpochs = std::atoi(parser.retrieve("epochs", "10").c_str());
    int numSamples = std::atoi(parser.retrieve("samples", "10").c_str());
    int sampleSize = std::atoi(parser.retrieve("ssize", std::to_string(test.length())).c_str());
    float sampleSeedNoise = std::atof(parser.retrieve("sseednoise", "0.5").c_str());
    float samplePredNoise = std::atof(parser.retrieve("sprednoise", "0.05").c_str());
    
    std::cout << "NeoRL text prediction experiment" << std::endl;
    std::cout << "Corpus: " << corpusPath << " size: " << test.length() << " alphabet size: " << textcodec.nSymbols << std::endl;
    std::cout << "Model: nLayers: " << nLayers << " layerW: " << layerW << " layerH: " << layerH << " inFeedbackRadius: " << inFeedBackRadius 
			  << " input: " << inputsRoot << "x" << inputsRoot << std::endl;
	std::cout << "Training: epochs: " << numEpochs << std::endl;
	std::cout << "Sampling: samples: " << numSamples << " size: " << sampleSize << " seed noise: " << sampleSeedNoise << " pred noise " << samplePredNoise << std::endl;    
    std::cout << "--[ Start training ]--" << std::endl;
    
    train(ph, generator, test, numEpochs, textcodec);
    
    std::cout << "--[ Start sampling ]--" << std::endl;
    for (int i = 0; i < numSamples; i++) {
        sample(ph, generator, textcodec.getRandomSymbol(generator), sampleSize, textcodec, sampleSeedNoise, samplePredNoise);
    }
    
	return 0;
}