aubs.cpp File Reference

#include "auryn.h"
#include <iostream>
#include <fstream>
#include <vector>
#include "auryn/AurynVersion.h"

Include dependency graph for aubs.cpp:

Functions
AurynLong	find_frame (std::ifstream *file, AurynTime target)
void	read_header (std::ifstream *input, double &dt, AurynLong num_events, double &last_time, std::string filename)
int	main (int ac, char *av[])

Detailed Description

Implements helper program to decode files written with BinaryStateMonitor

Function Documentation

find_frame()

AurynLong find_frame	(	std::ifstream *	file,
		AurynTime	target
	)

Perform binary search on ifstream to extract frame number from a target time reference that should be given in discrete time.

{
        // get number of elements
        file->seekg (0, file->end);
        AurynLong num_of_frames = file->tellg()/sizeof(StateValue_type);

        AurynLong lo = 1; // first frame is used for header
        AurynLong hi = num_of_frames;

        while ( lo+1 < hi ) {
                AurynLong pivot = lo + (hi-lo)/2;
                file->seekg (pivot*sizeof(StateValue_type), file->beg);

                StateValue_type state_data;
                file->read((char*)&state_data, sizeof(StateValue_type));

                if ( state_data.time < target ) lo = pivot;
                else hi = pivot;
        }

        return hi;
}

main()

int main	(	int	ac,
		char *	av[]
	)

{
        std::string input_filename;
        std::ifstream * input;

        std::string output_file_name = "";
        double from_time = 0.0;
        double to_time   = -1.0;
        double seconds_to_extract_from_end = -1.0; // negative means disabled
        // one more decimal than neede to show values are not rounded
        bool debug_output = false;

        try {
                po::options_description desc("Allowed options");
                desc.add_options()
                        ("help,h", "produce help message")
                        ("version,v", "show version information")
                        ("debug,d", "show verbose debug output")
                        ("input,i", po::value<std::string>(), "input file")
                        ("output,o", po::value<std::string>(), "output file (output to stout if not given)")
                        ("from,f", po::value<double>(), "'from time' in seconds")
                        ("to,t", po::value<double>(), "'to time' in seconds")
                        ("last,l", po::value<double>(), "last x seconds (overrides from/to)")
                        ;

                po::variables_map vm;        
                po::store(po::parse_command_line(ac, av, desc), vm);
                po::notify(vm);    

                if (vm.count("help")) {
                        std::cout << desc << "\n";
                        return 1;
                }

                if (vm.count("version")) {
                        AurynVersion build;
                        std::cout << "Auryn Binary Extract version " 
                                 << build.version << "." 
                                 << build.subversion << "."
                                 << build.revision_number << "\n";
                        return EXIT_SUCCESS;
                }

                if (vm.count("debug")) {
                        debug_output = true;
                }

                if (vm.count("input")) {
                        input_filename = vm["input"].as<std::string>();
                } 

                if (vm.count("output")) {
                        output_file_name = vm["output"].as<std::string>();
                } 

                if (vm.count("from")) {
                        from_time = vm["from"].as<double>();
        } 

        if (vm.count("to")) {
                        to_time = vm["to"].as<double>();
        } 

        if (vm.count("last")) {
                        seconds_to_extract_from_end = vm["last"].as<double>();
        } 

    }
    catch(std::exception& e) {
        std::cerr << "error: " << e.what() << "\n";
        return 1;
    }
    catch(...) {
        std::cerr << "Exception of unknown type!\n";
    }

        double last_time = 0.0;
        double dt = 0.0;

        if ( input_filename.empty() ) {
                std::cerr << "Missing input file." << std::endl;
                exit(EXIT_FAILURE);
        }

        input = new std::ifstream( input_filename.c_str(), std::ios::binary );
        if (!(*input)) {
                std::cerr << "Unable to open input file " 
                        << input_filename
                        << std::endl;
                exit(EXIT_FAILURE);
        }

        double tmp_last_time = 0;
        double tmp_dt = 0;
        AurynLong tmp_num_events = 0;
        read_header( input, tmp_dt, tmp_num_events, tmp_last_time, input_filename );

        if ( debug_output ) {
                std::cerr << "# Last frame in file:" << tmp_num_events << std::endl;
        }

        if ( dt == 0 ) {
                dt = tmp_dt;
        } else {
                if ( dt != tmp_dt ) { // should not happen
                        std::cerr << "Not all input file headers match." << std::endl;
                        exit(EXIT_FAILURE);
                }
        }

        if ( tmp_last_time > last_time ) {
                last_time = tmp_last_time;
        }


        if ( to_time < 0 ) {
                to_time = last_time;
        }

        if ( seconds_to_extract_from_end > 0 ) {
                from_time = to_time-seconds_to_extract_from_end;
        }

        if ( from_time < 0 ) from_time = 0.0 ;

        if ( from_time > to_time || from_time < 0 ) {
                std::cerr << "Times must be positive and start "
                        "time needs to be < to time." << std::endl;
                exit(EXIT_FAILURE);
        }

        // translate second times into auryn time
        AurynTime to_auryn_time = to_time/dt;


        if ( debug_output ) {
                std::cerr << "# Timestep: " << dt << std::endl;
                std::cerr << "# Sizeof SpikeEvent struct: " << sizeof(StateValue_type) << std::endl;
                std::cerr << "# Time of last event in files: " << last_time << std::endl;
                std::cerr << "# From time: " << from_time << std::endl;
                std::cerr << "# To time: " << to_time << std::endl;
        }


        // set stream to respetive start frame
        
        // compute start and end frames
        AurynLong start_frame = find_frame(input, from_time/dt);

        // prepare input stream
        input->seekg (start_frame*sizeof(StateValue_type), input->beg);
        input->clear();
        if ( debug_output ) {
                std::cerr << "# Start frame stream: " 
                        << start_frame << std::endl;
        }


        StateValue_type frame;
        input->read((char*)&frame, sizeof(StateValue_type));

        AurynTime time_reference = from_time/dt;
        int decimal_places = -std::log(dt)/std::log(10)+2; 

        // open output filestream if needed
        std::ofstream of;
        bool write_to_stdout = true;
        if( !output_file_name.empty() ) {
                write_to_stdout = false;
                of.open( output_file_name.c_str(), std::ofstream::out );
                of << std::fixed << std::setprecision(decimal_places);
        }
        // sets output format to right number of decimal places
        std::cout << std::fixed << std::setprecision(decimal_places);

        while ( true ) {
                time_reference = frame.time;
                if ( time_reference >= to_auryn_time || input->eof() ) break;

                if ( debug_output && false ) {
                        std::cout << "# time_reference " << time_reference << std::endl;
                }

                // output from next_stream
                while ( frame.time <= time_reference && !input->eof() ) {
                        if ( write_to_stdout ) 
                                std::cout << std::fixed << std::setprecision(decimal_places) 
                                        << frame.time*dt << " " 
                                        << std::scientific // << std::setprecision(8)
                                        << frame.value << "\n";
                        else 
                                of << std::fixed << std::setprecision(decimal_places) 
                                        << frame.time*dt << " " 
                                        << std::scientific // << std::setprecision(8) 
                                        << frame.value << "\n";
                        input->read((char*)&frame, sizeof(StateValue_type));
                }
        }

        if ( !write_to_stdout ) 
                of.close();

        // close input stream
        input->close();

        return EXIT_SUCCESS;
}

Here is the call graph for this function:

read_header()

void read_header	(	std::ifstream *	input,
		double &	dt,
		AurynLong	num_events,
		double &	last_time,
		std::string	filename
	)

{
        // get length of the file
        StateValue_type state_data;
        input->seekg (0, input->end);
        num_events = input->tellg()/sizeof(StateValue_type)-1;

        // read first entry to infer dt 
        input->seekg (0, input->beg);
        input->read((char*)&state_data, sizeof(StateValue_type));
        dt = 1.0/state_data.time;

        // do some version checking
        AurynVersion build;
        AurynState tag = state_data.value;
        if ( (int)tag/1000 != (int)(build.tag_binary_state_monitor)/1000 ) {
                std::cerr << "Header not recognized. " 
                        "Not a BinaryStateMonitor file?" 
                         << std::endl;
                exit(EXIT_FAILURE);
        }

        if ( tag != build.tag_binary_state_monitor ) {
                std::cerr << "# Warning: Either the Auryn version does not match "
                        "the version of this tool or this is not a BinaryStateMonitor "
                        "file." << std::endl; 
                // TODO tell user if it is a state file
        }

        // read out last time
        input->seekg (num_events*sizeof(StateValue_type), input->beg);
        input->read((char*)&state_data, sizeof(StateValue_type));
        last_time = (state_data.time+1)*dt; 
        // places last_time _behind_ the last time because we are the 
        // exclusive interval end
}