Index: ChangeLog
from Damien Thivolle <damien(a)lrde.epita.fr>
* tests/io/loadsave.hh: Adapt to integre.
* tests/core/tests/readonly_image: Likewise.
* tests/core/tests/image1d: Likewise.
* tests/core/tests/image2d: Likewise.
* tests/core/tests/readwrite_image: Likewise.
* tests/core/tests/image3d: Likewise.
* tests/core/tests/image_identity: Likewise.
* oln/fancy/print.hh: Likewise.
* oln/basics.hh: Likewise.
* oln/basics1d.hh: Likewise.
* oln/io/write_image_2d_pnm.hh: Likewise.
* oln/io/read_image_2d_pnm.hh: Likewise.
* oln/io/utils.hh: Likewise.
* oln/core/value_box.hh: Likewise.
oln/basics.hh | 7 ---
oln/basics1d.hh | 3 -
oln/core/value_box.hh | 48 +++++++++++++++++------
oln/fancy/print.hh | 2
oln/io/read_image_2d_pnm.hh | 66 +++++++++++++++++++-------------
oln/io/utils.hh | 20 +++++++++
oln/io/write_image_2d_pnm.hh | 80 +++++++++++++++++++++------------------
tests/core/tests/image1d | 2
tests/core/tests/image2d | 2
tests/core/tests/image3d | 2
tests/core/tests/image_identity | 2
tests/core/tests/readonly_image | 8 +--
tests/core/tests/readwrite_image | 8 +--
tests/io/loadsave.hh | 15 +++++--
14 files changed, 166 insertions(+), 99 deletions(-)
Index: tests/io/loadsave.hh
--- tests/io/loadsave.hh (revision 59)
+++ tests/io/loadsave.hh (working copy)
@@ -8,6 +8,7 @@
#include "check.hh"
#include "data.hh"
+
template<typename E>
bool compare(const oln::abstract::image<E>& a,
const oln::abstract::image<E>& b)
@@ -19,9 +20,11 @@
a.size().ncols() != b.size().ncols())
return false;
- for (it.start(); !it.is_valid(); it.next())
- if (a[it] != b[it])
- return false;
+ for_all(it)
+ {
+ if (a[it] != b[it])
+ return false;
+ }
return true;
}
@@ -33,12 +36,16 @@
bool fail = false;
T im1, im2;
+
im1 = oln::io::read(name);
+
+
oln::io::write(im1, savename);
+
im2 = oln::io::read(savename);
- if (compare(im1, im2))
+ if (compare(im1, im2) == true)
std::cout << "OK" << std::endl;
else
{
Index: tests/core/tests/readonly_image
--- tests/core/tests/readonly_image (revision 59)
+++ tests/core/tests/readonly_image (working copy)
@@ -1,6 +1,6 @@
#include <iostream>
-#include <ntg/real/int_u8.hh>
+#include <ntg/all.hh>
#include <oln/basics2d.hh>
#include "check.hh"
@@ -14,7 +14,7 @@
struct category_type< dummy_image > { typedef cat::image ret; };
template <>
- struct props <cat::image, dummy_image> :
+ struct props <cat::image, dummy_image> :
public default_props < cat::image >
{
typedef size2d size_type;
@@ -49,8 +49,8 @@
} // end of namespace test
-
-
+
+
bool check()
{
oln::dummy_image ima(3, 3);
Index: tests/core/tests/image1d
--- tests/core/tests/image1d (revision 59)
+++ tests/core/tests/image1d (working copy)
@@ -1,7 +1,7 @@
#include <iostream>
-#include <ntg/real/int_u8.hh>
+#include <ntg/all.hh>
#include <oln/basics1d.hh>
#include <oln/fancy/iota.hh>
Index: tests/core/tests/image2d
--- tests/core/tests/image2d (revision 59)
+++ tests/core/tests/image2d (working copy)
@@ -1,7 +1,7 @@
#include <iostream>
-#include <ntg/real/int_u8.hh>
+#include <ntg/all.hh>
#include <oln/basics2d.hh>
#include <oln/fancy/iota.hh>
Index: tests/core/tests/readwrite_image
--- tests/core/tests/readwrite_image (revision 59)
+++ tests/core/tests/readwrite_image (working copy)
@@ -1,6 +1,6 @@
#include <iostream>
-#include <ntg/real/int_u8.hh>
+#include <ntg/all.hh>
#include <oln/basics2d.hh>
#include "check.hh"
@@ -19,7 +19,7 @@
};
template <>
- struct set_props <category::image, dummy_image> :
+ struct set_props <category::image, dummy_image> :
public props_of < category::image >
{
typedef is_a<abstract::readwrite_image> image_constness;
@@ -53,8 +53,8 @@
} // end of namespace test
-
-
+
+
bool check()
{
oln::dummy_image ima(3, 3);
Index: tests/core/tests/image3d
--- tests/core/tests/image3d (revision 59)
+++ tests/core/tests/image3d (working copy)
@@ -1,7 +1,7 @@
#include <iostream>
-#include <ntg/real/int_u8.hh>
+#include <ntg/all.hh>
#include <oln/basics3d.hh>
#include <oln/fancy/iota.hh>
Index: tests/core/tests/image_identity
--- tests/core/tests/image_identity (revision 59)
+++ tests/core/tests/image_identity (working copy)
@@ -1,6 +1,6 @@
#include <oln/core/abstract/image_identity.hh>
#include <oln/core/2d/image2d.hh>
-#include <ntg/real/int_u8.hh>
+#include <ntg/all.hh>
template <typename I>
Index: oln/fancy/print.hh
--- oln/fancy/print.hh (revision 59)
+++ oln/fancy/print.hh (working copy)
@@ -33,7 +33,7 @@
# include <string>
-# include <ntg/real/int_u8.hh> // FIXME: no coupling like that!
+# include <ntg/real/int_u.hh> // FIXME: no coupling like that!
# include <oln/core/abstract/image_dimension.hh>
# include <oln/core/1d/point1d.hh>
Index: oln/basics.hh
--- oln/basics.hh (revision 59)
+++ oln/basics.hh (working copy)
@@ -25,8 +25,8 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-
+
#ifndef OLENA_BASICS_HH
# define OLENA_BASICS_HH
@@ -48,9 +48,6 @@
// ntg::
-# include <ntg/real/int_u8.hh>
-
-
// oln::
# include <oln/core/coord.hh>
@@ -61,7 +58,7 @@
# include <oln/core/abstract/point.hh>
# include <oln/core/abstract/images.hh>
-// # include <oln/core/abstract/piter.hh>
+# include <oln/core/abstract/piter.hh>
// # include <oln/core/abstract/niter.hh>
Index: oln/basics1d.hh
--- oln/basics1d.hh (revision 59)
+++ oln/basics1d.hh (working copy)
@@ -28,9 +28,6 @@
#ifndef OLENA_BASICS1D_HH
# define OLENA_BASICS1D_HH
-
-# include <oln/basics.hh>
-
# include <oln/core/1d/size1d.hh>
# include <oln/core/1d/point1d.hh>
# include <oln/core/1d/image1d.hh>
Index: oln/io/write_image_2d_pnm.hh
--- oln/io/write_image_2d_pnm.hh (revision 59)
+++ oln/io/write_image_2d_pnm.hh (working copy)
@@ -34,11 +34,7 @@
# include <mlc/box.hh>
-# include <ntg/core/macros.hh>
-# include <ntg/real/int_u8.hh>
-# include <ntg/real/integer.hh>
-# include <ntg/enum/enum.hh>
-# include <ntg/color/color.hh>
+# include <ntg/all.hh>
# include <oln/core/2d/image2d.hh>
# include <oln/core/abstract/op.hh>
@@ -56,15 +52,20 @@
: public oln::abstract::void_op<write_image_2d_raw<I> >
{
typedef oln_type_of(I, value) value_type;
- typedef ntg_io_type(value_type) io_type;
const I& to_write_;
std::ostream& ostr_;
+ int bin_offset;
+ char bin_v;
+
write_image_2d_raw(const I& to_write, std::ostream& ostr):
to_write_(to_write),
ostr_(ostr)
- {}
+ {
+ bin_offset = 7;
+ bin_v = 0;
+ }
void impl_run()
{
@@ -74,51 +75,55 @@
for (p.row() = 0; p.row() < to_write_.size().nrows(); ++p.row())
for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col())
- {
- c = to_write_[p];
- b = write_value_type(c);
- }
+ // FIXME: SHOULD NOT BE .value() !!!
+ b = write_value_type(to_write_[p].value());
while (b == false)
b = write_value_type(c);
+ bin_offset = 7;
+ bin_v = 0;
}
- bool write_value_type(const ntg::integer<value_type> &c)
+ //FIXME: Should work with builtin types.
+
+ template <typename E>
+ bool write_value_type(const ntg::real_value<E> &c)
{
- io_type v = c.exact();
- ostr_.write((char *)&v, sizeof(io_type));
+ typedef oln_io_type(ntg_nbits(E)) v_type;
+
+ v_type v;
+ v = ntg::cast::bound<E, v_type>(c.exact());
+ ostr_.write((char*)&v, sizeof (v_type));
return true;
}
- bool write_value_type(const ntg::color<value_type> &c)
+ template <typename E>
+ bool write_value_type(const ntg::vect_value<E> &c)
{
- assert ((ntg_depth(value_type) == 3));
- io_type v;
-
for (unsigned i = 0; i < 3; i++)
{
+ typedef oln_io_type(ntg_nbits(ntg_comp_type(value_type))) v_type;
+
+ v_type v;
v = c[i];
- ostr_.write((char *)(&v), sizeof(io_type));
+ ostr_.write((char*)&v, sizeof (v_type));
}
return true;
}
- bool write_value_type(const ntg::enum_value<value_type> &c)
+ bool write_value_type(const ntg::bin &c)
{
- assert ((ntg_max_val(value_type) == 1));
- static int offset = 7;
- static unsigned char v = 0;
bool ret = false;
- if (offset == -1)
+ if (bin_offset == -1)
{
- ostr_.write((char *)&v, 1);
- offset = 7;
- v = 0;
+ ostr_.write(&bin_v, 1);
+ bin_offset = 7;
+ bin_v = 0;
ret = true;
}
- if (c == 1)
- v |= 1 << offset;
- offset--;
+ if (c == value_type(1))
+ bin_v |= 1 << bin_offset;
+ bin_offset--;
return ret;
}
};
@@ -126,7 +131,7 @@
template <typename I, typename T>
void write(const abstract::image2d<I>& to_write,
- const ntg::integer<T>&,
+ const ntg::real_value<T>&,
std::ostream& ostr,
const std::string& ext)
{
@@ -134,6 +139,7 @@
point2d p;
size2d s = to_write.size();
+ precondition(ntg_nbits(T) <= 16);
if (ext == "pgm")
if (internal::write_pnm_header(ostr, "P5",
s.ncols(), s.nrows(),
@@ -151,7 +157,7 @@
template <typename I, typename T>
void write(const abstract::image2d<I>& to_write,
- const ntg::color<T>&,
+ const ntg::color_value<T>&,
std::ostream& ostr,
const std::string& ext)
{
@@ -159,10 +165,12 @@
point2d p;
size2d s = to_write.size();
+ precondition(ntg_nbits(ntg_comp_type(T)) <= 16);
+ precondition(ntg_nb_comp(T) == 3);
if (ext == "ppm")
if (internal::write_pnm_header(ostr, "P6",
s.ncols(), s.nrows(),
- ntg_max_val(T)))
+ ntg_max_val(ntg_comp_type(T))))
{
write_image_2d_raw<I> tmp(to_write.exact(), ostr);
tmp.run();
@@ -174,9 +182,9 @@
<< " file extension (`" << ext << "')"
<< std::endl;
}
- template <typename I, typename T>
+ template <typename I>
void write(const abstract::image2d<I>& to_write,
- const ntg::enum_value<T>&,
+ const ntg::bin&,
std::ostream& ostr,
const std::string& ext)
{
@@ -186,7 +194,7 @@
if (ext == "pbm")
if (internal::write_pnm_header(ostr, "P4",
s.ncols(), s.nrows(),
- ntg_max_val(T)))
+ 1))
{
write_image_2d_raw<I> tmp(to_write.exact(), ostr);
tmp.run();
Index: oln/io/read_image_2d_pnm.hh
--- oln/io/read_image_2d_pnm.hh (revision 59)
+++ oln/io/read_image_2d_pnm.hh (working copy)
@@ -32,12 +32,9 @@
# include <string>
# include <mlc/box.hh>
+# include <mlc/math.hh>
-# include <ntg/core/macros.hh>
-# include <ntg/real/int_u8.hh>
-# include <ntg/real/integer.hh>
-# include <ntg/enum/enum.hh>
-# include <ntg/color/color.hh>
+# include <ntg/all.hh>
# include <oln/core/2d/image2d.hh>
# include <oln/core/abstract/op.hh>
@@ -83,7 +80,6 @@
typedef oln::abstract::op<I, read_image_2d_raw<I> > super_type;
typedef oln_type_of(I, value) value_type;
- typedef ntg_io_type(value_type) io_type;
mlc::box<I> image_;
std::istream& istr_;
@@ -105,18 +101,33 @@
return *this;
}
+ template <typename E>
+ void precond(ntg::real_value<E>& c)
+ {
+ precondition(ntg_max_val(value_type) <= info_.max_val);
+ precondition(info_.type == "P5");
+ }
+
+ template <typename E>
+ void precond(ntg::vect_value<E>& c)
+ {
+ precondition(ntg_max_val(ntg_comp_type(value_type)) <= info_.max_val);
+ precondition(info_.type == "P6");
+ precondition(ntg_nb_comp(value_type) == 3);
+ }
+
+ void precond(ntg::bin& c)
+ {
+ precondition(info_.type == "P4");
+ }
+
void impl_run()
{
value_type c;
point2d p;
oln::image2d<value_type> tmp(info_.rows, info_.cols);
- if (info_.max_val > ntg_max_val(value_type))
- {
- std::cerr << "Can't load image, data type is not large
enough"
- << std::endl;
- return;
- }
+ precond(c);
for (p.row() = 0; p.row() < info_.rows && !istr_.eof(); ++p.row())
for (p.col() = 0; p.col() < info_.cols && !istr_.eof(); ++p.col())
@@ -127,32 +138,37 @@
*image_ = tmp;
}
- void read_value_type(ntg::integer<value_type> &c)
+ //FIXME: Should work with builtin types.
+
+ template <typename E>
+ void read_value_type(ntg::real_value<E> &c)
{
- io_type v;
- istr_.read(&v, sizeof (io_type));
- c = v;
+ typedef oln_io_type(ntg_nbits(E)) v_type;
+ v_type v;
+ istr_.read((char*)&v, sizeof (v_type));
+ c = ntg::cast::force<E, v_type>(v);
}
- void read_value_type(ntg::color<value_type> &c)
+ template <typename E>
+ void read_value_type(ntg::vect_value<E> &c)
{
- io_type v;
-
- for (unsigned i = 0; i < ntg_depth(value_type); i++)
+ for (unsigned i = 0; i < ntg_nb_comp(E); i++)
{
- istr_.read(&v, sizeof (v));
- c[i] = v;
+ typedef oln_io_type(ntg_nbits(ntg_comp_type(E))) v_type;
+ v_type v;
+ istr_.read((char*)&v, sizeof (v_type));
+ c[i] = ntg::cast::force<ntg_comp_type(E), v_type>(v);
}
}
- void read_value_type(ntg::enum_value<value_type> &c)
+ void read_value_type(ntg::bin &c)
{
- static io_type v;
+ static char v;
static int offset = -1;
if (offset == -1)
{
- istr_.read((char *)(&v), sizeof (v));
+ istr_.read(&v, 1);
offset = 7;
}
if ((int)(v & (1<<offset--)) == 0)
Index: oln/io/utils.hh
--- oln/io/utils.hh (revision 59)
+++ oln/io/utils.hh (working copy)
@@ -40,6 +40,7 @@
namespace internal {
+
/*!
** \brief Utils for io (get extension of a file).
*/
@@ -148,11 +149,30 @@
return true;
}
+ template <bool b>
+ struct pnm_io_helper
+ {
+ enum { size = 1};
+ typedef unsigned char type;
+ };
+ template <>
+ struct pnm_io_helper<false>
+ {
+ enum { size = 2};
+ typedef unsigned short type;
+ };
+
+
+
} // end of namespace internal
} // end of namespace io
} // end of namespace oln
+# define oln_io_type(N) typename oln::io::internal::pnm_io_helper<N <= 8>::type
+# define oln_io_type_(N) oln::io::internal::pnm_io_helper<N <= 8>::type
+
+
#endif // ! OLENA_IO_UTILS_HH
Index: oln/core/value_box.hh
--- oln/core/value_box.hh (revision 59)
+++ oln/core/value_box.hh (working copy)
@@ -81,24 +81,35 @@
/// op==
- bool operator==(const value_box<I>& value) const
+ bool operator==(const value_box<const I>& rhs) const
{
- return this->value() == value.value();
+ return this->value() == rhs.value();
}
template <typename V>
- bool operator==(const V& value) const
+ bool operator==(const V& rhs) const
{
- return this->value() == value;
+ return this->value() == rhs;
}
template <typename V>
- bool operator!=(const V& value) const
+ bool operator!=(const V& rhs) const
{
- return ! this->operator==(value);
+ return ! this->operator==(rhs);
}
+ template <typename V>
+ bool operator<(const V& rhs) const
+ {
+ return this->value() < rhs;
+ }
+ template <typename II>
+ bool operator<(const value_box<II>& rhs) const
+ {
+ return this->value() < value.value();
+ }
+
/*! \brief op=
** FIXME:...
** \return (*this)
@@ -123,7 +134,7 @@
template <typename II>
value_box& operator=(const value_box<II>& rhs)
{
- ima_->set(p_, rhs); // automatic conversion from rhs to value_type
+ ima_->set(p_, rhs.value()); // automatic conversion from rhs to value_type
return *this;
}
@@ -240,24 +251,35 @@
/// op==
- bool operator==(const value_box<const I>& value) const
+ bool operator==(const value_box<const I>& rhs) const
{
- return this->value() == value.value();
+ return this->value() == rhs.value();
}
template <typename V>
- bool operator==(const V& value) const
+ bool operator==(const V& rhs) const
{
- return this->value() == value;
+ return this->value() == rhs;
}
template <typename V>
- bool operator!=(const V& value) const
+ bool operator!=(const V& rhs) const
{
- return ! this->operator==(value);
+ return ! this->operator==(rhs);
}
+ template <typename V>
+ bool operator<(const V& rhs) const
+ {
+ return this->value() < rhs;
+ }
+ template <typename II>
+ bool operator<(const value_box<II>& rhs) const
+ {
+ return this->value() < rhs.value();
+ }
+
/*! \brief Assignment (op=) is declared but undefined.
*/