00001 // Copyright (C) 2001, 2002, 2003, 2004, 2006 EPITA Research and 00002 // Development Laboratory 00003 // 00004 // This file is part of the Olena Library. This library is free 00005 // software; you can redistribute it and/or modify it under the terms 00006 // of the GNU General Public License version 2 as published by the 00007 // Free Software Foundation. 00008 // 00009 // This library is distributed in the hope that it will be useful, 00010 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00011 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00012 // General Public License for more details. 00013 // 00014 // You should have received a copy of the GNU General Public License 00015 // along with this library; see the file COPYING. If not, write to 00016 // the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 00017 // Boston, MA 02110-1301, USA. 00018 // 00019 // As a special exception, you may use this file as part of a free 00020 // software library without restriction. Specifically, if other files 00021 // instantiate templates or use macros or inline functions from this 00022 // file, or you compile this file and link it with other files to 00023 // produce an executable, this file does not by itself cause the 00024 // resulting executable to be covered by the GNU General Public 00025 // License. This exception does not however invalidate any other 00026 // reasons why the executable file might be covered by the GNU General 00027 // Public License. 00028 00029 #ifndef OLENA_IO_BASE_HH 00030 # define OLENA_IO_BASE_HH 00031 00032 # include <oln/io/image_read.hh> 00033 # include <oln/io/image_write.hh> 00035 # include <oln/io/se_fwd.hh> 00036 00037 namespace oln { 00038 00042 namespace io { 00043 00047 namespace internal { 00048 00054 template<typename T> 00055 bool 00056 read_any(T& output, const std::string& name) 00057 { 00058 return read(output, name); 00059 } 00060 00066 template<typename T> 00067 bool 00068 write_any(const T& input, const std::string& name) 00069 { 00070 return write(input, name); 00071 } 00072 00073 } // end of internal 00074 00075 // aliases 00076 00077 /* 00078 ** \brief Load object from a file. This could be an image but also 00079 ** a window or a neighborhood. 00080 ** \arg name The name of the file. 00081 ** \return The new object. 00082 ** \sa oln::abstract::iter 00083 ** 00084 ** Call abstract::image::has_impl to test that your image has been 00085 ** successfully loaded. 00086 ** See oln::io::internal::reader_id to know which file are supported. 00087 ** \sa abstract::image::has_impl 00088 ** \sa 00089 */ 00090 inline 00091 internal::anything 00092 load(const std::string& name) 00093 { 00094 return internal::anything(name); 00095 } 00096 00097 /* 00098 ** \brief Load an image or a structuring element from a file. 00099 ** \arg output The object to write to a file. 00100 ** \arg name The name of the file. 00101 ** \return True if successful. 00102 ** 00103 ** Depending of T, work is dispatched. 00104 */ 00105 template<class T> 00106 bool 00107 load(T& output, std::string name) 00108 { 00109 return internal::read_any(output, name); 00110 } 00111 00112 /* 00113 ** \brief Write an image or a structuring element to a file. 00114 ** a window or a neighborhood. 00115 ** \arg input The object to read. 00116 ** \arg name The name of the file. 00117 ** \return True if successful. 00118 ** 00119 ** Depending of T, work is dispatched. 00120 ** \sa oln::abstract::iter 00121 */ 00122 template< typename T > 00123 bool 00124 save(const T& input, const std::string& name) 00125 { 00126 return internal::write_any(input, name); 00127 } 00128 00129 } // end of namespace io 00130 00131 // Export load & save into namespace oln:: for convenience. 00132 using io::load; 00133 using io::save; 00134 00135 } // end of namespace oln 00136 00137 // Implementations. 00138 # include <oln/io/se_window.hh> 00139 # include <oln/io/se_neighborhood.hh> 00140 00141 #endif // OLENA_IO_BASE_HH