int main( int ac, char** av )
{
try
{
comma::command_line_options options( ac, av, usage );
const std::vector< std::string >& unnamed = options.unnamed( "--verbose,-v,--have-css,--loop" , "-.*" );
if( unnamed.size() != 1 ) { std::cerr << "csv-to-svg: expected one operation name" << ( unnamed.size() ? "; got " + comma::join( unnamed, ' ' ) : "" ) << std::endl; return 1; }
std::string what = unnamed[0];
comma::csv::options csv( options );
snark::render::colour_map colour_map;
bool parse_colour = true;
if( ( what == "point" || what == "circle" || what == "line" || what == "lines" ) && csv.has_field( "scalar" ) )
{
colour_map = parse_colour_map( options.value< std::string >( "--colour,--color,-c", "" ) );
parse_colour = false;
}
if( options.exists( "--class" ) ) { snark::render::svg::element::DEFAULT_ATTRIBUTES += " class=\"" + options.value< std::string >( "--class" ) + "\""; }
if( options.exists( "--id" ) ) { snark::render::svg::element::DEFAULT_ATTRIBUTES += " id=\"" + options.value< std::string >( "--id" ) + "\""; }
if( options.exists( "--transform" ) ) { snark::render::svg::element::DEFAULT_ATTRIBUTES += " transform=\"" + options.value< std::string >( "--transform" ) + "\""; }
if( options.exists( "--attributes" ) ) { snark::render::svg::element::DEFAULT_ATTRIBUTES += " " + options.value< std::string >( "--attributes" ); }
snark::render::svg::element::DEFAULT_STYLE = make_style( options, what, parse_colour );
if( what == "header" )
{
std::cout << snark::render::svg::header(
options.value< std::string >( "--width" )
, options.value< std::string >( "--height" )
, options.value< std::string >( "--viewbox" )
, options.optional< std::string >( "--css" )
) << std::endl;
}
else if( what == "footer" ) { std::cout << snark::render::svg::footer() << std::endl; }
else if( what == "script" ) { std::cout << snark::render::svg::script( options.value< std::string >( "--file" ) ) << std::endl; }
else if( what == "script_begin" ) { std::cout << snark::render::svg::script::begin() << std::endl; }
else if( what == "script_end" ) { std::cout << snark::render::svg::script::end() << std::endl; }
else if( what == "style_begin" ) { std::cout << snark::render::svg::style::begin() << std::endl; }
else if( what == "style_end" ) { std::cout << snark::render::svg::style::end() << std::endl; }
else if( what == "group_begin" ) { std::cout << snark::render::svg::g() << std::endl; }
else if( what == "group_end" ) { std::cout << snark::render::svg::g::end() << std::endl; }
else if( what == "point" || what == "circle" )
{
boost::optional< double > r = options.optional< double >( "--point-size,--weight,--radius,-r" );
if( r ) { snark::render::svg::circle::DEFAULT_RADIUS = *r; }
if( csv.has_field( "scalar" ) )
{
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< coloured< snark::render::svg::circle > >( csv.fields, true ) ); }
comma::csv::input_stream< coloured< snark::render::svg::circle > > istream( std::cin, csv );
while( std::cin.good() )
{
const coloured< snark::render::svg::circle >* c = istream.read();
if( !c ) { break; }
std::cout << snark::render::svg::circle( *c, colour_map( c->scalar ).hex() ) << std::endl;
}
}
else
{
if( csv.fields.empty() ) { csv.fields = what == "point" ? "x,y" : comma::join( comma::csv::names< snark::render::svg::circle >(), ',' ); }
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< snark::render::svg::circle >( csv.fields, true ) ); }
comma::csv::input_stream< snark::render::svg::circle > istream( std::cin, csv );
while( std::cin.good() )
{
const snark::render::svg::circle* c = istream.read();
if( !c ) { break; }
std::cout << *c << std::endl;
}
}
}
else if( what == "line" )
{
if( csv.has_field( "scalar" ) )
{
if( options.exists( "--binary,-b" ) ) { csv.format( options.value< std::string >( "--binary,-b", comma::csv::format::value< coloured< snark::render::svg::line > >( csv.fields, true ) ) ); }
comma::csv::input_stream< coloured< snark::render::svg::line > > istream( std::cin, csv );
while( std::cin.good() )
{
const coloured< snark::render::svg::line >* l = istream.read();
if( !l ) { break; }
std::cout << snark::render::svg::line( *l, colour_map( l->scalar ).hex() ) << std::endl;
}
}
else
{
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< snark::render::svg::line >(), ',' ); }
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< snark::render::svg::line >( csv.fields, true ) ); }
comma::csv::input_stream< snark::render::svg::line > istream( std::cin, csv );
while( std::cin.good() )
{
const snark::render::svg::line* l = istream.read();
if( !l ) { break; }
std::cout << *l << std::endl;
}
}
}
else if( what == "lines" )
{
if( csv.has_field( "scalar" ) )
{
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< coloured< snark::render::svg::point > >( csv.fields, true ) ); }
comma::csv::input_stream< coloured< snark::render::svg::point > > istream( std::cin, csv );
boost::optional< coloured< snark::render::svg::point > > prev;
while( std::cin.good() )
{
const coloured< snark::render::svg::point >* p = istream.read();
if( !p ) { break; }
if( prev ) { std::cout << snark::render::svg::line( prev->x, prev->y, p->x, p->y, colour_map( prev->scalar ).hex() ) << std::endl; }
prev = *p;
}
}
else
{
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< snark::render::svg::point >(), ',' ); }
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< snark::render::svg::point >( csv.fields, true ) ); }
comma::csv::input_stream< snark::render::svg::point > istream( std::cin, csv );
boost::optional< snark::render::svg::point > prev;
while( std::cin.good() )
{
const snark::render::svg::point* p = istream.read();
if( !p ) { break; }
if( prev ) { std::cout << snark::render::svg::line( prev->x, prev->y, p->x, p->y ) << std::endl; }
prev = *p;
}
}
}
else if( what == "polyline" )
{
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< snark::render::svg::point >(), ',' ); }
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< snark::render::svg::point >( csv.fields, true ) ); }
comma::csv::input_stream< snark::render::svg::point > istream( std::cin, csv );
snark::render::svg::polyline polyline;
while( std::cin.good() )
{
const snark::render::svg::point* p = istream.read();
if( !p ) { break; }
polyline.points.push_back( *p );
}
if( polyline.points.size() )
{
if( options.exists( "--loop" ) ) { polyline.points.push_back( polyline.points[0] ); }
std::cout << polyline << std::endl;
}
}
else if( what == "polygon" )
{
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< snark::render::svg::point >(), ',' ); }
if( options.exists( "--binary,-b" ) ) { csv.format( comma::csv::format::value< snark::render::svg::point >( csv.fields, true ) ); }
comma::csv::input_stream< snark::render::svg::point > istream( std::cin, csv );
snark::render::svg::polygon polygon;
boost::optional< snark::render::svg::point > first;
boost::optional< snark::render::svg::point > prev;
while( std::cin.good() )
{
const snark::render::svg::point* p = istream.read();
if( !p ) { break; }
if( !first ) { first = *p; }
polygon.points.push_back( *p );
prev = *p;
}
if( polygon.points.size() ) { std::cout << polygon << std::endl; }
}
else if( what == "text" )
{
if( csv.has_field( "scalar" ) )
{
comma::csv::input_stream< coloured< snark::render::svg::text > > istream( std::cin, csv );
while( std::cin.good() )
{
const coloured< snark::render::svg::text >* t = istream.read();
if( !t ) { break; }
std::cout << snark::render::svg::text( *t, colour_map( t->scalar ).hex() ) << std::endl;
}
}
else
{
if( csv.fields.empty() ) { csv.fields = comma::join( comma::csv::names< snark::render::svg::text >(), ',' ); }
comma::csv::input_stream< snark::render::svg::text > istream( std::cin, csv );
while( std::cin.good() )
{
const snark::render::svg::text* t = istream.read();
if( !t ) { break; }
std::cout << *t << std::endl;
}
}
}
else
{
std::cerr << "csv-to-svg: unrecognized operation: \"" << what << "\"" << std::endl;
return 1;
}
return 0;
}
catch( std::exception& ex )
{
std::cerr << "csv-to-svg: " << ex.what() << std::endl;
}
catch( ... )
{
std::cerr << "csv-to-svg: unknown exception" << std::endl;
}
return 1;
}
// ---------------------------------------------------------------------------
// Constructeur::crŽation
// ------------
bMacMapType::bMacMapType( const char* hname,
const char* hpath,
const char* data,
int hkind,
int ttype,
int* status)
:_bse(this){
_bTrace_("bMacMapType::bMacMapType(char*,char*,char*,int,int*)",true);
_iter=NULL;
_styles=NULL;
_idx=_MMAPP_->typesMgr()->count()+1;
_kind=hkind;
_rmv=0;
read_load_area();
int xtype=get_sign(ttype);
_tm_("creating type with "+(UInt32*)&xtype+" storage");
_tm_("creating type hname="+hname);
_tm_("creating type hpath="+hpath);
//_tm_("creating type data="+data);
_tm_("creating type hkind="+hkind);
_tm_("creating type ttype="+ttype);
_id=time(NULL);
_state=0;
_kind=hkind;
_bounds.top=-__BOUNDS_MAX__;
_bounds.left=-__BOUNDS_MAX__;
_bounds.bottom=__BOUNDS_MAX__;
_bounds.right=__BOUNDS_MAX__;
// snprintf(_name,256,hname);
//_tm_("avant strncpy");
strncpy(_name,hname,sizeof(_name)-1);
bGenericUnit* u=map_doc->dist_resolution_unit();
_precs=map_doc->dist_resolution();
_unit2m=u->coef();
_srid=map_doc->srid();
_nbalive=0;
_nbkilled=0;
_nsel=0;
_ncnt=0;
//_tm_("avant _bse.create");
*status=_bse.create(hpath,xtype,_srid,_precs,_unit2m,_name,data,_kind);
if(*status){
_te_("status = "+(*status)+" at _bse.create");
return;
}
//_tm_("avant make_style");
if(!make_style()){
(*status)=-1;
_te_("make_style == false");
return;
}
if(((*status)=_bse.h_read(1,kHDR_id_,&_id))){
_te_("status = "+(*status)+" at _bse.h_read kHDR_id_");
return;
}
if(((*status)=_bse.h_read(1,kHDR_state_,&_state))){
_te_("status = "+(*status)+" at _bse.h_read kHDR_state_");
return;
}
if(((*status)=_bse.h_read(1,kHDR_kind_,&_kind))){
_te_("status = "+(*status)+" at _bse.h_read kHDR_kind_");
return;
}
if(((*status)=_bse.h_read(1,kHDR_bounds_,&_bounds))){
_te_("status = "+(*status)+" at _bse.h_read kHDR_bounds_");
return;
}
if(((*status)=_bse.h_read(1,kHDR_name_,_name))){
_te_("status = % atd _bse.h_read kHDR_name_");
return;
}
if(((*status)=_bse.h_read(1,kHDR_precs_,&_precs))){
_te_("status = "+(*status)+" at _bse.h_read kHDR_precs_");
return;
}
if(((*status)=_bse.h_read(1,kHDR_unit2m_,&_unit2m))){
_te_("status = "+(*status)+" at _bse.h_read kHDR_unit2m_");
return;
}
if(((*status)=_bse.h_read(1,kHDR_srid_,&_srid))){
_te_("status = "+(*status)+" at _bse.h_read kHDR_srid_");
return;
}
_tm_("bounds are ("+_trrect_(_bounds));
gi_init_p gp={&_bounds,status,SetFlag,GetFlag,GetBounds,ObjIDComp};
_iter=(bGenericGeoIterator*)(extmgr->get_component(kComponentGeoIterator)->i_allocate(xtype,_MMAPP_,&gp));
if(!_iter){
(*status)=-1;
return;
}
_styles=new bStyleMgr(this,status);
if((*status)){
_te_("status = "+(*status)+" at new bStyleMgr");
return;
}
(*status)=noErr;
}
