inline static void init( comma::csv::options& csv_options, const comma::command_line_options& options, const std::string& defaultFields )
{
csv_options.full_xpath = options.exists( "--full-xpath" );
csv_options.fields = options.value( "--fields", defaultFields );
if( options.exists( "--binary" ) )
{
boost::optional< std::string > format = options.optional< std::string >( "--binary" );
if( format )
{
csv_options.format( options.value< std::string >( "--binary" ) );
}
}
csv_options.precision = options.value< unsigned int >( "--precision", 12 );
csv_options.delimiter = options.exists( "--delimiter" ) ? options.value( "--delimiter", ',' ) : options.value( "-d", ',' );
boost::optional< std::string > quote_character = options.optional< std::string >( "--quote" );
if( quote_character )
{
switch( quote_character->size() )
{
case 0: csv_options.quote.reset(); break;
case 1: csv_options.quote = ( *quote_character )[0]; break;
case 2: COMMA_THROW( comma::exception, "expected a quote character, got \"" << *quote_character << "\"" );
}
}
csv_options.flush = options.exists( "--flush" );
}
intervals( const comma::command_line_options& options ) : options( options )
, csv( options )
, ocsv( options )
, ascii_csv( options )
, empty( traits< bound_type >::cast( options.optional< std::string >( "--empty" ) ) )
, intervals_only( options.exists( "--intervals-only" ) )
, use_limits( options.exists( "--limits,-l" ) )
{
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< interval_t< From, To > >(), ',' ); }
if( ocsv.fields.empty() || intervals_only )
{
ocsv.fields = comma::join( comma::csv::names< interval_t< From, To > >(), ',' );
if( ocsv.binary() && ( intervals_only || append ) ) { ocsv.format( comma::csv::format::value< interval_t< From, To > >() ); }
}
ascii_csv.fields = ocsv.fields;
ascii_csv.quote = boost::none;
if( verbose ) { std::cerr << app_name << ": empty: "; empty ? std::cerr << *empty : std::cerr << "<none>"; std::cerr << std::endl; }
options.assert_mutually_exclusive( "overlap-count-min,overlap-count-max", "overlap-count" );
if( options.exists( "--overlap-count" ) )
{
min_overlap_count = max_overlap_count = options.value< unsigned int >( "--overlap-count" );
}
else
{
min_overlap_count = options.value( "--overlap-count-min", 0 );
max_overlap_count = options.value( "--overlap-count-max", std::numeric_limits< unsigned int >::max() );
}
}
grid( const comma::command_line_options& options )
: csv_( make_csv_options_( options ) )
, istream_( std::cin, csv_ )
, permissive_( options.exists( "--permissive" ) )
, reverse_( options.exists( "--reverse" ) )
, voxel_map_( resolution_( options.value< double >( "--resolution", 1 ) ) ) // quick and dirty: does not matter for now, but may be used in future
{
}
static void run(const comma::command_line_options& options)
{
comma::csv::options csv(options);
if(options.exists("--output-fields")) { std::cout<<comma::join(comma::csv::names<T>(), ',')<<std::endl; return;}
if(options.exists("--output-format")) { std::cout<< comma::csv::format::value<T>(csv.fields,true)<<std::endl; return;}
process(csv);
}
int traits::run( const comma::command_line_options& options )
{
comma::csv::options csv( options );
csv.full_xpath = true;
bool discard_collinear = options.exists( "--discard-collinear" );
line_t first_default = comma::csv::ascii< line_t >().get( options.value< std::string >( "--first", "0,0,0,0,0,0" ) );
line_t second_default = comma::csv::ascii< line_t >().get( options.value< std::string >( "--second", "0,0,0,0,0,0" ) );
comma::csv::input_stream< lines_t > istream( std::cin, csv, std::make_pair( first_default, second_default ) );
comma::csv::output_stream < output_t > ostream( std::cout, csv.binary(), false, csv.flush );
comma::csv::tied< lines_t, output_t > tied( istream, ostream );
while( istream.ready() || ( std::cin.good() && !std::cin.eof() ) )
{
const lines_t* r = istream.read();
if( !r ) { break; }
const Eigen::Vector3d& f = ( r->first.second - r->first.first ).normalized();
const Eigen::Vector3d& s = ( r->second.second - r->second.first ).normalized();
if( comma::math::equal( f.dot( s ), f.norm() * s.norm() ) )
{
if( discard_collinear ) { continue; }
std::cerr << "points-calc: lines-nearest: got collinear lines (" << r->first.first.transpose() << " , " << r->first.second.transpose() << ") and (" << r->second.first.transpose() << " , " << r->second.second.transpose() << "), please use --discard collinear to discard" << std::endl;
return 1;
}
const Eigen::Vector3d& m = s.cross( f ).normalized();
const Eigen::Vector3d& n = s.cross( m ).normalized();
const Eigen::Vector3d& d = r->second.first - r->first.first;
const Eigen::Vector3d& a = r->first.first + f * n.dot( d ) / n.dot( f );
const Eigen::Vector3d& b = a + m * m.dot( d );
tied.append( output_t( a, b ) );
}
return 0;
}
std::string make_style( const comma::command_line_options& options, const std::string& what, const bool parse_colour )
{
std::string style = options.value< std::string >( "--style", "" );
if( options.exists( "--stroke-width" ) )
{
if( style.size() ) { style += ";"; }
style += "stroke-width:" + options.value< std::string >( "--stroke-width" );
}
if( parse_colour && options.exists( "--colour,--color,-c" ) )
{
if( style.size() ) { style += ";"; }
std::string attribute = "fill";
if( what == "line" || what == "lines" || what == "polyline" || what == "polygon" ) { attribute = "stroke"; }
style += attribute + ":" + options.value< std::string >( "--colour,--color,-c" );
}
return style;
}
options( const comma::command_line_options& options )
: scale( comma::csv::ascii< std::pair< double, double > >().get( options.value< std::string >( "--scale", "0,255" ) ) )
, colourmap( options.value< std::string >( "--colour-map,--colourmap,--colour", "0,255,0" ) )
, dial_colour( options.value< std::string >( "--dial-colour", "white" ) )
, do_not_clean( options.exists( "--dirty,--do-not-clean" ) )
//, offset_from_center( options.value( "--offset-from-center", 0 ) )
{
}
intervals( const comma::command_line_options& options ) : options( options )
, csv( options )
, ocsv( options )
, ascii_csv( options )
, empty( traits< bound_type >::cast( options.optional< std::string >( "--empty" ) ) )
, intervals_only( options.exists( "--intervals-only" ) )
, use_limits( options.exists( "--limits,-l" ) )
{
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< interval_t< From, To > >(), ',' ); }
if( ocsv.fields.empty() || intervals_only )
{
ocsv.fields = comma::join( comma::csv::names< interval_t< From, To > >(), ',' );
if( ocsv.binary() && intervals_only ) { ocsv.format( comma::csv::format::value< interval_t< From, To > >() ); }
}
ascii_csv.fields = ocsv.fields;
ascii_csv.quote = boost::none;
if( verbose ) { std::cerr << app_name << ": empty: "; empty ? std::cerr << *empty : std::cerr << "<none>"; std::cerr << std::endl; }
}
void process( const comma::command_line_options& options, const std::string& output_id )
{
typedef snark::timestamped< T > output_t;
if( options.exists( "--list-fields,--output-fields" ) ) { std::cout << comma::join( comma::csv::names< output_t >( false ), ',' ) << std::endl; return; }
comma::csv::options csv;
csv.fields = options.value< std::string >( "--fields", "" );
csv.full_xpath = false;
if( options.exists( "--format" ) ) { std::cout << comma::csv::format::value< output_t >( csv.fields, false ) << std::endl; return; }
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< output_t >( csv.fields, false ) ); }
comma::csv::ascii_input_stream< input_t > istream( std::cin, "" );
comma::csv::output_stream< output_t > ostream( std::cout, csv );
while( !is_shutdown && std::cin.good() && !std::cin.eof() )
{
const input_t* input = istream.read();
if( !input ) { break; }
std::string input_id = reinterpret_cast< const braille::header* >( &input->data[0] )->id();
if( output_id != input_id ) { continue; }
ostream.write( output_t( input->t, *reinterpret_cast< const braille::packet< P::size >* >( &input->data[0] ) ) );
}
}
constraints( const comma::command_line_options& options ) // quick and dirty
{
equals = get_optional_< T >( options, "--equals" );
not_equal = get_optional_< T >( options, "--not-equal" );
from = get_optional_< T >( options, "--from,--greater-or-equal,--ge" );
to = get_optional_< T >( options, "--to,--less-or-equal,--le" );
less = get_optional_< T >( options, "--less" );
greater = get_optional_< T >( options, "--greater" );
const boost::optional< std::string >& s = get_optional_< std::string >( options, "--regex" );
if( s ) { regex = boost::regex( *s ); }
sorted = options.exists( "--sorted,--input-sorted" );
}
int sort( const comma::command_line_options& options )
{
input_t::map sorted_map;
input_t default_input;
std::vector< std::string > v = comma::split( stdin_csv.fields, ',' );
std::vector< std::string > order = options.exists("--order") ? comma::split( options.value< std::string >( "--order" ), ',' ) : v;
std::vector< std::string > w (v.size());
bool unique = options.exists("--unique,-u");
std::string first_line;
comma::csv::format f;
if( stdin_csv.binary() ) { f = stdin_csv.format(); }
else if( options.exists( "--format" ) ) { f = comma::csv::format( options.value< std::string >( "--format" ) ); }
else
{
while( std::cin.good() && first_line.empty() ) { std::getline( std::cin, first_line ); }
if( first_line.empty() ) { return 0; }
f = comma::csv::impl::unstructured::guess_format( first_line, stdin_csv.delimiter );
if( verbose ) { std::cerr << "csv-sort: guessed format: " << f.string() << std::endl; }
}
for( std::size_t i = 0; i < order.size(); ++i ) // quick and dirty, wasteful, but who cares
{
if (order[i].empty()) continue;
for( std::size_t k = 0; k < v.size(); ++k )
{
if( v[k].empty() || v[k] != order[i] )
{
if ( k + 1 == v.size())
{
std::cerr << "csv-sort: order field name \"" << order[i] << "\" not found in input fields \"" << stdin_csv.fields << "\"" << std::endl;
return 1;
}
continue;
}
std::string type = default_input.keys.append( f.offset( k ).type );
w[k] = "keys/" + type;
ordering_t o;
if ( type[0] == 's' ) { o.type = ordering_t::str_type; o.index = default_input.keys.strings.size() - 1; }
else if ( type[0] == 'l' ) { o.type = ordering_t::long_type; o.index = default_input.keys.longs.size() - 1; }
else if ( type[0] == 'd' ) { o.type = ordering_t::double_type; o.index = default_input.keys.doubles.size() - 1; }
else if ( type[0] == 't' ) { o.type = ordering_t::time_type; o.index = default_input.keys.time.size() - 1; }
else { std::cerr << "csv-sort: cannot sort on field " << v[k] << " of type \"" << type << "\"" << std::endl; return 1; }
ordering.push_back(o);
break;
}
}
stdin_csv.fields = comma::join( w, ',' );
if ( verbose ) { std::cerr << "csv-sort: fields: " << stdin_csv.fields << std::endl; }
comma::csv::input_stream< input_t > stdin_stream( std::cin, stdin_csv, default_input );
#ifdef WIN32
if( stdin_stream.is_binary() ) { _setmode( _fileno( stdout ), _O_BINARY ); }
#endif
if (!first_line.empty())
{
input_t::map::mapped_type& d = sorted_map[ comma::csv::ascii< input_t >(stdin_csv,default_input).get(first_line) ];
d.push_back( first_line + "\n" );
}
while( stdin_stream.ready() || ( std::cin.good() && !std::cin.eof() ) )
{
const input_t* p = stdin_stream.read();
if( !p ) { break; }
if( stdin_stream.is_binary() )
{
input_t::map::mapped_type& d = sorted_map[ *p ];
if (unique && !d.empty()) continue;
d.push_back( std::string() );
d.back().resize( stdin_csv.format().size() );
::memcpy( &d.back()[0], stdin_stream.binary().last(), stdin_csv.format().size() );
}
else
{
input_t::map::mapped_type& d = sorted_map[ *p ];
if (unique && !d.empty()) continue;
d.push_back( comma::join( stdin_stream.ascii().last(), stdin_csv.delimiter ) + "\n" );
}
}
if( options.exists( "--reverse,-r" ) ) { output_( sorted_map.rbegin(), sorted_map.rend() ); }
else { output_( sorted_map.begin(), sorted_map.end() ); }
return 0;
}
static int run( const comma::command_line_options& options )
{
if( options.exists( "--input-fields" ) ) { std::cout << comma::join( comma::csv::names< grid::input >( true ), ',' ) << std::endl; return 0; }
grid g( options );
return g.read_();
}