Esempio n. 1
0
inline 
void targa_read_image( const String& filename
                     , Image&        img
                     )
{
    read_image( filename
              , img
              , targa_tag()
              );
}
Esempio n. 2
0
inline 
void targa_read_view( const String& filename
                    , const View&   view
                    )
{
    read_view( filename
             , view
             , targa_tag()
             );
}
Esempio n. 3
0
inline
void targa_write_view( const String& filename
                     , const View&   view
                     )
{
    write_view( filename
              , view
              , targa_tag()
              );
}
Esempio n. 4
0
inline 
void targa_read_and_convert_image( const String filename
                                 , Image&       img
                                 )
{
    read_and_convert_image( filename
                          , img
                          , targa_tag()
                          );
}
Esempio n. 5
0
inline 
void targa_read_and_convert_view( const String& filename
                                , const View&   view
                                , CC            cc
                                )
{
    read_and_convert_view( filename
                         , view
                         , cc
                         , targa_tag()
                         );
}
Esempio n. 6
0
int main(int argc, char* argv[])
try
{
    typedef GIL::rgba8_view                 view_type;
    typedef GIL::image_factory_t<view_type> factory_type;
    typedef factory_type::image_format_type format_type;

    factory_type            factory;
    boost::filesystem::path test_src(argc > 1 ? argv[1] : "", boost::filesystem::native);
    adobe::static_name_t    targa_tag("targa");
    GIL::rgba8_image        image;
    adobe::dictionary_t     params;

    assert (boost::filesystem::exists(test_src));

    boost::filesystem::filebuf filebuf;

    filebuf.open(test_src, std::ios_base::in | std::ios_base::binary);

    factory.register_format(format_type(targa_tag, GIL::targa_t<view_type>()));

    assert (factory.is_registered(targa_tag));

    assert (factory.read(image, filebuf, params) == targa_tag);

#if 0 // no file format writing at this time
    GIL::any_view view(GIL::view(image));

    factory.write(view, filebuf);
#endif

    factory.unregister_format(targa_tag);

    assert (!factory.is_registered(targa_tag));

    return 0;
}
catch (const std::exception& error)
{
    std::cerr << "Exception: " << error.what() << std::endl;

    return 1;
}
catch (...)
{
    std::cerr << "Exception: Unknown" << std::endl;

    return 1;
}
Esempio n. 7
0
inline
point2< std::ptrdiff_t > targa_read_dimensions( const String& filename )
{
    typedef typename get_reader_backend< String
                                       , targa_tag
                                       >::type backend_t;

    backend_t backend = read_image_info( filename
                                       , targa_tag()
                                       );

    return point2< std::ptrdiff_t >( backend._info._width
                                   , backend._info._height
                                   );
}