int main(int ac, char **av)
{
t_all all;
if (ac >= 2)
{
all.mlx = mlx_init();
all.win_x = (ac >= 4 && check_arg(av[2])) ? ft_atoi(av[2]) : 500;
all.win_y = (ac >= 4 && check_arg(av[3])) ? ft_atoi(av[3]) : 500;
all.win = mlx_new_window(all.mlx, all.win_x, all.win_y, "FdF");
init_all(&all);
if (ac == 5)
check_color(av[4], &all);
all.fd = open(av[1], O_RDONLY);
if (all.fd == -1)
exit(EXIT_FAILURE);
parser(all.fd, &all);
mlx_hook(all.win, 2, (1L << 0), key_hook_first, &all);
draw_map_x(&all);
mlx_loop(all.mlx);
}
else
help_main();
return (0);
}
int main(int argc, char** argv) {
if(argc == 1) {
// Print the help
help_main(argv);
return 1;
}
size_t kmerSize = 0;
size_t edgeMax = 0;
// Should we only merge on kmers and skip paths?
bool kmersOnly = false;
optind = 1; // Start at first real argument
bool optionsRemaining = true;
while(optionsRemaining) {
static struct option longOptions[] = {
{"kmer-size", required_argument, 0, 'k'},
{"edge-max", required_argument, 0, 'e'},
{"kmers-only", no_argument, 0, 'o'},
{"threads", required_argument, 0, 't'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
int optionIndex = 0;
switch(getopt_long(argc, argv, "k:e:t:h", longOptions, &optionIndex)) {
// Option value is in global optarg
case -1:
optionsRemaining = false;
break;
case 'k': // Set the kmer size
kmerSize = atol(optarg);
break;
case 'e': // Set the edge max parameter for kmer enumeration
edgeMax = atol(optarg);
break;
case 'o': // Only merge on kmers
kmersOnly = true;
break;
case 't': // Set the openmp threads
omp_set_num_threads(atoi(optarg));
break;
case 'h': // When the user asks for help
case '?': // When we get options we can't parse
help_main(argv);
exit(1);
break;
default:
// TODO: keep track of the option
std::cerr << "Illegal option" << std::endl;
exit(1);
}
}
if(argc - optind < 2) {
// We don't have two positional arguments
// Print the help
help_main(argv);
return 1;
}
if(kmersOnly && kmerSize == 0) {
// We need a kmer size to use kmers
throw std::runtime_error("Can't merge only on kmers with no kmer size");
}
// Pull out the VG file names
std::string vgFile1 = argv[optind++];
std::string vgFile2 = argv[optind++];
// Guess index names (TODO: add options)
std::string indexDir1 = vgFile1 + ".index";
std::string indexDir2 = vgFile2 + ".index";
// Open the files
std::ifstream vgStream1(vgFile1);
if(!vgStream1.good()) {
std::cerr << "Could not read " << vgFile1 << std::endl;
exit(1);
}
std::ifstream vgStream2(vgFile2);
if(!vgStream2.good()) {
std::cerr << "Could not read " << vgFile2 << std::endl;
exit(1);
}
// We may have indexes. We need to use pointers because destructing an index
// that was never opened segfaults. TODO: fix vg
vg::Index* index1 = nullptr;
vg::Index* index2 = nullptr;
if(kmerSize) {
// Only go looking for indexes if we want to merge on kmers.
index1 = new vg::Index();
index1->open_read_only(indexDir1);
index2 = new vg::Index();
index2->open_read_only(indexDir2);
}
// Load up the first VG file
vg::VG vg1(vgStream1);
// And the second
vg::VG vg2(vgStream2);
// Make a way to track IDs
int64_t nextId = 1;
std::function<int64_t(void)> getId = [&]() {
return nextId++;
};
// Make a thread set
auto threadSet = stPinchThreadSet_construct();
// Make a place to keep track of the thread sequences.
// This will only contain sequences for threads that aren't staples.
// TODO: should this be by pointer instead?
std::map<int64_t, std::string> threadSequences;
// Add in each vg graph to the thread set
coregraph::EmbeddedGraph embedding1(vg1, threadSet, threadSequences, getId, vgFile1);
coregraph::EmbeddedGraph embedding2(vg2, threadSet, threadSequences, getId, vgFile2);
if(!kmersOnly) {
// We want to merge on shared paths in addition to kmers
// Complain if any of the graphs is not completely covered by paths
if(!embedding1.isCoveredByPaths()) {
std::cerr << "WARNING: " << embedding1.getName() << " contains nodes with no paths!" << std::endl;
}
if(!embedding2.isCoveredByPaths()) {
std::cerr << "WARNING: " << embedding2.getName() << " contains nodes with no paths!" << std::endl;
}
// Trace the paths and merge the embedded graphs.
std::cerr << "Pinching graphs on shared paths..." << std::endl;
embedding1.pinchWith(embedding2);
}
if(kmerSize > 0) {
// Merge on kmers that are unique in both graphs.
std::cerr << "Pinching graphs on shared " << kmerSize << "-mers..." << std::endl;
embedding1.pinchOnKmers(*index1, embedding2, *index2, kmerSize, edgeMax);
}
// Fix trivial joins so we don't produce more vg nodes than we really need to.
stPinchThreadSet_joinTrivialBoundaries(threadSet);
// Make another vg graph from the thread set
vg::VG core = pinchToVG(threadSet, threadSequences);
// Spit it out to standard output
core.serialize_to_ostream(std::cout);
// Tear everything down. TODO: can we somehow run this destruction function
// after all our other, potentially depending locals are destructed?
stPinchThreadSet_destruct(threadSet);
return 0;
}
