nvbio-less.cpp

Go to the documentation of this file.

// nvbio-less.cpp : Defines the entry point for the console application.
//

#include <nvbio/basic/types.h>
#include <nvbio/basic/packedstream.h>
#include <nvbio/basic/dna.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace nvbio;

struct Options
{
    uint32 row_length;
    bool   line_nums;
};

template <typename WordType>
void read(FILE* file, const uint32 begin, const uint32 end, const Options opts)
{
    const uint32 bps_per_word = sizeof(WordType) * 4;
    const uint32 begin_word = begin / bps_per_word;
    const uint32 end_word   = (end+bps_per_word-1) / bps_per_word;

    const uint32 n_bps = end - begin;

    uint32 i_bps    = 0u;
    uint32 line_num = 0u;

    fseek( file, begin_word * sizeof(WordType), SEEK_CUR );
    for (uint32 w = begin_word; w < end_word; w += 1024)
    {
        const uint32 n_words = std::min( end_word - w, 1024u );

        WordType words[1024];
        fread( words, sizeof(WordType), n_words, file );

        typedef PackedStream<WordType*,uint8,2,true,uint32> stream_type;

        stream_type stream( words );

        for (uint32 i = 0; i < n_words * bps_per_word && i_bps < n_bps; ++i, ++i_bps)
        {
            if (((i_bps) % opts.row_length) == 0)
            {
                fprintf(stdout,"\n");
                if (opts.line_nums)
                    fprintf(stdout, "%03u ", line_num++ );
            }

            const char bp = dna_to_char( stream[i] );
            fprintf(stdout,"%c", bp);
        }
    }
    fflush(stdout);
}

void read_ft(FILE* file, const uint32 begin, const uint32 end)
{
    fseek( file, sizeof(uint32) * begin, SEEK_CUR );

    for (uint32 i = begin; i < end; ++i)
    {
        uint32 read_id = 0;

        fread( &read_id, sizeof(uint32), 1, file );

        fprintf(stdout, "%u\n", read_id);
    }
}

int main(int argc, char* argv[])
{
    if (argc < 3 || (argc == 2 && (strcmp(argv[1],"--help") == 0 || strcmp(argv[1],"-h") == 0)))
    {
        printf("nvbio-less is a program to read dna fragments from {.pac|.rpac|.bwt|.rbwt} files.\n");
        printf("Copyright NVIDIA Corporation 2012. All rights reserved.\n");
        printf("\nUSAGE:\n");
        printf("nvbio-less [options] begin end filename\n");
        printf("options:\n");
        printf("  -r row length     specify output row length\n");
        printf("  -ln               print line numbers\n");
        printf("e.g:\n");
        printf("  nvbio-less -r 50 0 100 mydna.pac\n");
    }
    else
    {
        uint32 begin, end;

        Options opts;
        opts.row_length = uint32(-1);
        opts.line_nums  = false;

        uint32 n_options = 0;
        for (; n_options < argc-4; ++n_options)
        {
            if (argv[n_options+1][0] != '-')
                break;

            if (strcmp( argv[n_options+1], "-r" ) == 0)
                opts.row_length = atoi( argv[++n_options + 1] );
            else if (strcmp( argv[n_options+1], "-ln" ) == 0)
                opts.line_nums = true;
        }

        sscanf( argv[1+n_options], "%u", &begin );
        sscanf( argv[2+n_options], "%u", &end );
        const std::string filename = argv[3+n_options];

        FILE* file = fopen( filename.c_str(), "rb" );
        if (file == NULL)
        {
            fprintf(stderr, "error: file \"%s\" not found\n", filename.c_str());
            exit(1);
        }

        if (filename.find(".ft") != std::string::npos)
        {
            // filter file produced by nvbio-aln-diff
            read_ft( file, begin, end );

            fclose( file );
            return 0;
        }

        if (filename.find(".pac")  != std::string::npos ||
            filename.find(".rpac") != std::string::npos)
            read<uint8>( file, begin, end, opts );
        else
        if (filename.find(".wpac") != std::string::npos ||
            filename.find(".bwt")  != std::string::npos ||
            filename.find(".rbwt") != std::string::npos)
        {
            // skip header
            if (filename.find(".wpac") != std::string::npos)
                fseek( file, 8u, SEEK_CUR );
            else if (filename.find(".bwt")  != std::string::npos ||
                     filename.find(".rbwt") != std::string::npos)
                fseek( file, 20u, SEEK_CUR );

            read<uint32>( file, begin, end, opts );
        }
        else
        {
            fclose( file );

            fprintf(stderr, "error: unsupported file type\n");
            exit(1);
        }

        fclose( file );
    }
        return 0;
}