Olena-patches November 2007

olena-patches@lrde.epita.fr

9 participants
147 discussions

Description de l'état d'Olena 1.0ß sur le serveur Trac

by Roland Levillain

J'ai mis à jour les tableaux et leurs légendes sur les pages : https://trac.lrde.org/olena/wiki/Olena/Release1.0beta https://trac.lrde.org/olena/wiki/Olena/Release1.0beta/DetailedView Merci de les mettre à jour !

16 years, 5 months

1555: Overhaul mln::t_image.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Overhaul mln::t_image. * mln/core/t_image.hh (mln::internal::data_t< t_image >): New. (mln::t_image): Revamp. Inherit from internal::image_morpher_< I, mln_pset(I), t_image >. (t_image::super_): Adjust typedef. (t_image::psite, t_image::value) (t_image::rvalue, t_image::vset): New properties. (t_image::lvalue): Fix properties. (t_image::t_image): Adjust for mln::internal::data_t< t_image >. Document ctor. (t_image::has_data, t_image::values): New methods. (t_image::c1_, t_image::c2_, t_image::b_): Remove. Superseded by data_::dim1_, data_::dim2_ and data_::box_. (t_image::exchange_coords_): New method. Use it to redefine... (t_image::transpose_): ...this method. Document. (t_image::owns_, t_image::operator()): Adjust. * tests/t_image.cxx: Rename as... * tests/t_image.cc: ...this. s/image2d_b/image2d/. mln/core/t_image.hh | 215 ++++++++++++++++++++++++++++++++++++++++------------ tests/t_image.cc | 8 - 2 files changed, 173 insertions(+), 50 deletions(-) Index: mln/core/t_image.hh --- mln/core/t_image.hh (revision 1555) +++ mln/core/t_image.hh (working copy) @@ -33,12 +33,45 @@ * \brief Definition of the "transposed" image class mln::t_image. */ -# include <mln/core/internal/image_adaptor.hh> +# include <mln/core/internal/image_morpher.hh> +# include <mln/core/box.hh> namespace mln { + // Fwd decl. + template <typename I> struct t_image; + + namespace internal + { + + /// Data held by a mln::t_image. + template <typename I> + struct data_< t_image > + { + /// \brief Build the data object held by a t_image. + /// + /// \param ima The underlying image. + /// \param dim1 The first dimension to be swapped. + /// \param dim2 The second dimension to be swapped. + /// \param box The bounding box (domain) of the morphed image. + data_(I& ima, unsigned dim1, unsigned dim2, + mln::box_<mln_point(I)>& box); + + /// Underlying image. + I ima_; + /// The swapped dimensions. + /// \{ + unsigned dim1_; + unsigned dim2_; + /// \} + /// The bounding box of the morphed image. + mln::box_<mln_point(I)> box_; + }; + + } // end of namespace mln::internal + /*! \brief Transposed image class. * @@ -47,11 +80,52 @@ * \warning This class only works on images whose domain is a box. */ template <typename I> - struct t_image : public internal::image_adaptor_< I, t_image > + class t_image + : public internal::image_morpher_< I, mln_pset(I), t_image > { + public: + /// Super type. + typedef + internal::image_morpher_< I, mln_pset(I), t_image > super_; + + /// Point_Site associated type. + typedef mln_psite(I) psite; + + /// Value associated type. + typedef mln_value(I) value; + + /// Type returned by the read-write pixel value operator. + typedef typename internal::morpher_lvalue_::ret lvalue; + + /// Return type of read-only access. + typedef mln_rvalue(I) rvalue; + + /// Value set associated type. + typedef mln::value::set<value> vset; + + /// Skeleton. typedef t_image< tag::image_ > skeleton; + public: + /// \brief Build the generalized transpose of an image. + /// + /// In the 2-dimension case, \a dim1 and \a dim2 must be resp. 1 and 2 + /// (or 2 and 1), and t_image is a transpose of a matrix with the + /// usual meaning. + /// + /// In dimensions greater than 2, mln::t_image represents a view + /// of the underlying image where two dimensions (i.e., two + /// components of each point) have been exchanged. + /// + /// \param ima The underlying image. + /// \param dim1 The first dimension to be swapped. + /// \param dim2 The second dimension to be swapped. + t_image(I& ima, unsigned dim1, unsigned dim2); + + /// Test if this image has been initialized. + bool has_data() const; + /// Test if a pixel value is accessible at \p p. bool owns_(const mln_point(I)& p) const; @@ -61,90 +135,108 @@ /// Read-only access of pixel value at point site \p p. mln_rvalue(I) operator()(const mln_point(I)& p) const; - /// Type returned by the read-write pixel value operator. - typedef typename internal::morpher_lvalue_::ret lvalue; - /// Read-write access of pixel value at point site \p p. lvalue operator()(const mln_point(I)& p); - /// Constructor. - t_image(I& ima, unsigned c1, unsigned c2); + /// Give the set of values of the image. + const vset& values() const; protected: - - typedef internal::image_adaptor_< I, t_image > super_; - const unsigned c1_, c2_; // coords to swap - box_<mln_point(I)> b_; - + /// Exchange components \a dim1_ and \a dim2_ of point \a p. mln_point(I) transpose_(const mln_point(I)& p) const; + /// Exchange components \a dim1 and \a dim2 of point \a p. + mln_point(I) exchange_coords_(const mln_point(I)& p, + unsigned dim1, unsigned dim2) const; }; + /* FIXME: Shouldn't we move these elsewhere? I (Roland) think mixing + data structure and routines is confusing, even if they are + closely related. What about mln/geom/swap_coords.hh? */ template <typename I> - t_image swap_coords(Image& ima, unsigned c1, unsigned c2); + t_image + swap_coords(Image& ima, unsigned dim1, unsigned dim2); template <typename I> - t_image<const I> swap_coords(const Image& ima, unsigned c1, unsigned c2); + t_image<const I> + swap_coords(const Image& ima, unsigned dim1, unsigned dim2); # ifndef MLN_INCLUDE_ONLY + namespace internal + { + + // internal::data_< t_image<I,S> > + template <typename I> - t_image swap_coords(Image& ima, unsigned c1, unsigned c2) + data_< t_image >::data_(I& ima, + unsigned dim1, unsigned dim2, + mln::box_<mln_point(I)>& box) + : ima_(ima), + dim1_(dim1), dim2_(dim2), + box_(box) { - typedef mln_point(I) P; - mln_precondition(c1 != c2); - mln_precondition(c1 <= P::dim && c2 <= P::dim); - t_image tmp(exact(ima), c1, c2); - return tmp; } + } // end of namespace mln::internal + + template <typename I> - t_image<const I> swap_coords(const Image& ima, unsigned c1, unsigned c2) + t_image::t_image(I& ima, unsigned dim1, unsigned dim2) { - typedef mln_point(I) P; - mln_precondition(c1 != c2); - mln_precondition(c1 <= P::dim && c2 <= P::dim); - t_image<const I> tmp(exact(ima), c1, c2); - return tmp; + mln_precondition(ima.has_data()); + /* FIXME: Add a precondition on the fact that the domain of ima is + a box. */ + // We don't use mln::t_image::transpose here, since one its + // prerequisite is that data_ is initialized, which is not done + // yet at this point. + box_<mln_point(I)> box(exchange_coords_(ima.bbox().pmin(), dim1, dim2), + exchange_coords_(ima.bbox().pmax(), dim1, dim2)); + this->data_ = new internal::data_< t_image >(ima, dim1, dim2, box); } template <typename I> - t_image::t_image(I& ima, unsigned c1, unsigned c2) - : super_(ima), - c1_(c1), - c2_(c2) + bool t_image::has_data() const { - mln_precondition(ima.has_data()); - b_.pmin() = transpose_(this->adaptee_.bbox().pmin()); - b_.pmax() = transpose_(this->adaptee_.bbox().pmax()); + mln_invariant(this->delegatee_()->has_data()); + return true; + } + + template <typename I> + bool + t_image::owns_(const mln_point(I)& p) const + { + mln_precondition(this->has_data()); + return this->delegatee_()->owns_(transpose_(p)); } template <typename I> mln_point(I) t_image::transpose_(const mln_point(I)& p) const { - mln_point(I) tmp(p); - tmp[c1_] = p[c2_]; - tmp[c2_] = p[c1_]; - return tmp; + mln_precondition(this->has_data()); + return exchange_coords_(p, this->data_->dim1_, this->data_->dim2_); } template <typename I> - const box_<mln_point(I)>& - t_image::domain() const + mln_point(I) + t_image::exchange_coords_(const mln_point(I)& p, + unsigned dim1, unsigned dim2) const { - mln_precondition(this->has_data()); - return b_; + mln_point(I) tmp(p); + tmp[dim1] = p[dim2]; + tmp[dim2] = p[dim1]; + return tmp; } template <typename I> - bool - t_image::owns_(const mln_point(I)& p) const + const box_<mln_point(I)>& + t_image::domain() const { mln_precondition(this->has_data()); - return this->adaptee_.owns_(transpose_(p)); + return this->data_->box_; } template <typename I> @@ -152,7 +244,7 @@ t_image::operator()(const mln_point(I)& p) const { mln_precondition(this->owns_(p)); - return this->adaptee_(transpose_(p)); + return this->data_->ima_(transpose_(p)); } template <typename I> @@ -160,7 +252,38 @@ t_image::operator()(const mln_point(I)& p) { mln_precondition(this->owns_(p)); - return this->adaptee_(transpose_(p)); + return this->data_->ima_(transpose_(p)); + } + + template <typename I> + const typename t_image::vset& + t_image::values() const + { + mln_precondition(this->delegatee_() != 0); + return this->delegatee_()->values(); + } + + + template <typename I> + t_image + swap_coords(Image& ima, unsigned dim1, unsigned dim2) + { + typedef mln_point(I) P; + mln_precondition(dim1 != dim2); + mln_precondition(dim1 <= P::dim && dim2 <= P::dim); + t_image tmp(exact(ima), dim1, dim2); + return tmp; + } + + template <typename I> + t_image<const I> + swap_coords(const Image& ima, unsigned dim1, unsigned dim2) + { + typedef mln_point(I) P; + mln_precondition(dim1 != dim2); + mln_precondition(dim1 <= P::dim && dim2 <= P::dim); + t_image<const I> tmp(exact(ima), dim1, dim2); + return tmp; } # endif // ! MLN_INCLUDE_ONLY Index: tests/t_image.cc --- tests/t_image.cc (revision 1423) +++ tests/t_image.cc (working copy) @@ -30,7 +30,7 @@ * \brief Tests on mln::t_image. */ -#include <mln/core/image2d_b.hh> +#include <mln/core/image2d.hh> #include <mln/core/t_image.hh> #include <mln/debug/iota.hh> @@ -41,12 +41,12 @@ { using namespace mln; - typedef image2d_b<int> I; + typedef image2d<int> I; I ima(2, 3); debug::iota(ima); debug::println(ima); - t_image tima(ima, 0, 1); - debug::println(tima); + t_image t_ima(ima, 0, 1); + debug::println(t_ima); }

16 years, 5 months

milena r1553: Add convertion of a tree into tree_fast

by Guillaume Duhamel

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2007-11-27 Guillaume Duhamel <guillaume.duhamel(a)lrde.epita.fr> Add convertion of a tree into tree_fast. * mln/util/tree_to_fast.hh: Add convertion of tree into tree_fast. Tests * tests/util/tree_to_fast.cc: New tests for this. * tests/util/Makefile.am: Update. --- mln/util/tree_fast_to_image.hh | 2 mln/util/tree_to_fast.hh | 110 +++++++++++++++++++++++++++++++++++++++++ tests/util/Makefile.am | 4 + tests/util/tree_to_fast.cc | 74 +++++++++++++++++++++++++++ 4 files changed, 188 insertions(+), 2 deletions(-) Index: trunk/milena/tests/util/tree_to_fast.cc =================================================================== --- trunk/milena/tests/util/tree_to_fast.cc (revision 0) +++ trunk/milena/tests/util/tree_to_fast.cc (revision 1553) @@ -0,0 +1,74 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/*! + * \file tests/util/tree_to_fast.cc + * + * \brief test of mln::util::tree_to_fast + * + */ + +#include <mln/util/tree.hh> +#include <mln/util/tree_to_fast.hh> +#include <mln/util/tree_fast.hh> + +int main () +{ + using namespace mln; + + unsigned elt1 = 1; + unsigned elt2 = 2; + unsigned elt3 = 3; + unsigned elt4 = 4; + unsigned elt5 = 5; + unsigned elt6= 42; + + util::node<unsigned> node(elt1); + util::node<unsigned>* node2 = node.add_child(elt2); + node.add_child(elt3); + mln_assertion(node2); + node2->add_child(elt4); + node2->add_child(elt5); + util::node<unsigned>* node3 = node.search(elt4); + mln_assertion(node3); + node3 = node2->search(elt1); + mln_assertion(!node3); + util::tree<unsigned>* tre = new util::tree<unsigned>(&node); + mln_assertion(tre); + tre->add_tree_up(elt6); + mln_assertion (tre->check_consistency()); + + + util::tree_fast<unsigned> tree_fast = util::tree_to_fast(*tre); + mln_assertion(tree_fast.has (elt1)); + mln_assertion(tree_fast.has (elt2)); + mln_assertion(tree_fast.has (elt3)); + mln_assertion(tree_fast.has (elt4)); + mln_assertion(tree_fast.has (elt5)); + mln_assertion(tree_fast.has (elt6)); + mln_assertion(tree_fast.search(elt6) == tree_fast.root_); +} Index: trunk/milena/tests/util/Makefile.am =================================================================== --- trunk/milena/tests/util/Makefile.am (revision 1552) +++ trunk/milena/tests/util/Makefile.am (revision 1553) @@ -13,7 +13,8 @@ tree \ tree_fast \ tree_fast_to_image \ - tree_to_image + tree_to_image \ + tree_to_fast all_headers_SOURCES = all_headers.cc branch_iter_SOURCES = branch_iter.cc @@ -25,5 +26,6 @@ tree_fast_SOURCES = tree_fast.cc tree_fast_to_image_SOURCES = tree_to_image.cc tree_to_image_SOURCES = tree_to_image.cc +tree_to_fast_SOURCES = tree_to_fast.cc TESTS = $(check_PROGRAMS) Index: trunk/milena/mln/util/tree_to_fast.hh =================================================================== --- trunk/milena/mln/util/tree_to_fast.hh (revision 0) +++ trunk/milena/mln/util/tree_to_fast.hh (revision 1553) @@ -0,0 +1,110 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_UTIL_TREE_TO_FAST_HH +# define MLN_UTIL_TREE_TO_FAST_HH + +/*! + * \file mln/util/tree_to_fast.hh + * + * \brief Definition of function which converts a tree into tree_fast. + * + */ + +# include <mln/util/tree.hh> +# include <mln/util/tree_fast.hh> +# include <mln/trace/all.hh> + + +namespace mln +{ + + namespace util + { + + + /*! Convert a tree into an tree_fast. + * + * \param[in] input The tree to convert. + * + * \return The tree_fast containing tree informations. + * + */ + template<typename T> + tree_fast<T> + tree_to_fast(tree<T>& input); + + +# ifndef MLN_INCLUDE_ONLY + + + namespace impl + { + + template<typename T> + void + tree_to_fast_(node<T>* input, tree_fast<T>& tree, unsigned p, unsigned& i) + { + typename node<T>::children_t child = input->children (); + typename node<T>::children_t::iterator it = child.begin (); + + for (; it != child.end (); ++it) + { + tree.add_child(p, (*it)->elt ()); + ++i; + impl::tree_to_fast_((*it), tree, i, i); + } + } + + } + + /// Facade. + + template<typename T> + tree_fast<T> + tree_to_fast(tree<T>& input) + { + trace::entering("util::tree_to_fast"); + + unsigned i = 0; + tree_fast<T> tree (input.root ()->elt ()); + + impl::tree_to_fast_(input.root (), tree, 0, i); + + trace::exiting("util::tree_to_fast"); + return tree; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::util + +} // end of namespace mln + + +#endif // !MLN_UTIL_TREE_TO_FAST_HH + Index: trunk/milena/mln/util/tree_fast_to_image.hh =================================================================== --- trunk/milena/mln/util/tree_fast_to_image.hh (revision 1552) +++ trunk/milena/mln/util/tree_fast_to_image.hh (revision 1553) @@ -89,7 +89,7 @@ trace::exiting("util::impl::tree_fast_to_image"); } - } // end of mln::util::impl + } // end of namespace mln::util::impl

16 years, 5 months

milena r1555: convert for graylevel

by Matthieu Garrigues

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2007-11-27 Matthieu Garrigues <garrigues(a)lrde.epita.fr> convert for graylevel. * mln/value/graylevel.hh: the graylevel type wasn't compatible with the generic convert in convert.hh because of a convertion to int. --- graylevel.hh | 36 +++++++++++++++++++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-) Index: trunk/milena/mln/value/graylevel.hh =================================================================== --- trunk/milena/mln/value/graylevel.hh (revision 1554) +++ trunk/milena/mln/value/graylevel.hh (revision 1555) @@ -170,7 +170,6 @@ typedef float sum; }; - } // end of namespace mln::trait @@ -247,6 +246,20 @@ + namespace internal + { + + // convert for graylevel + template <unsigned n> + struct convert_< graylevel<n> > + { + static graylevel<n> value_at_index(unsigned i); + static unsigned index_of_value(graylevel<n> v); + }; + + } // end of namespace mln::value::internal + + /// Op<<. template <unsigned n> std::ostream& operator<<(std::ostream& ostr, const graylevel<n>& g); @@ -430,6 +443,27 @@ } + + namespace internal + { + + template <unsigned n> + graylevel<n> + convert_< graylevel<n> >::value_at_index(unsigned i) + { + mln_assertion(i <= mln_max(mln_equiv(graylevel<n>))); + return graylevel<n>(i); + } + + template <unsigned n> + unsigned + convert_< graylevel<n> >::index_of_value(graylevel<n> v) + { + return v.value(); + } + + } // end of namespace mln::value::internal + // Operators. template <unsigned n>

16 years, 5 months

[PATCH] Fix typos in the tutorial

by Benoit Sigoure

URL: https://svn.lrde.epita.fr/svn/oln/trunk OK to apply? (Use Reply-All, I'm not subscribed to this ML, thanks) ChangeLog: 2007-11-27 Benoit Sigoure <tsuna(a)lrde.epita.fr> Fix typos in the tutorial. * milena/doc/tutorial/slides.tex: Various typos everywhere. --- slides.tex | 47 ++++++++++++++++++++++++----------------------- 1 files changed, 24 insertions(+), 23 deletions(-) Index: milena/doc/tutorial/slides.tex =================================================================== --- milena/doc/tutorial/slides.tex (revision 1543) +++ milena/doc/tutorial/slides.tex (working copy) @@ -243,7 +243,7 @@ \item Many libraries exist that can fulfill one's needs. \item If you're happy with your favorite tool, we cannot force you to change for \mln... - \item Though, you might have a look at \mln and being seduced! + \item Though, you might have a look at \mln and be seduced! \end{itemize} \end{block} @@ -253,7 +253,7 @@ \begin{block}{No!} \begin{itemize} \item \mln is rather different than available libraries. - \item A lot of convenient data structures that \emph{really} helps + \item A lot of convenient data structures that \emph{really} help you in developing IP solutions. \end{itemize} \end{block} @@ -310,7 +310,8 @@ \smallskip \begin{lstlisting}[basicstyle={\tiny\sffamily}] template <typename I, typename H> -void transform_inplace(Image& f_, const Function_v2v<H>& h_) +void transform_inplace(Image& f_, + const Function_v2v<H>& h_) { I& f = exact(f); const H& h = exact(h_); @@ -361,7 +362,7 @@ %........................................................................ \begin{frame}%[<+->] - \frametitle{What's In a Library} + \frametitle{What's In The Library} \begin{itemize} \item algorithms:\\ @@ -389,7 +390,7 @@ \begin{itemize} \item Generic... \item Efficient so that one can process large images. - \item Quite as easy to use as a C or Java library. + \item Almost as easy to use as a C or Java library. \item Many tools to help writing readable algorithms in a concise way. \end{itemize} @@ -552,7 +553,7 @@ \texttt{arith} & arithmetical operators \\ \texttt{border} & routines about virtual border & \texttt{canvas} & canvases \\ -\texttt{convert} & conversions routines & +\texttt{convert} & conversion routines & \texttt{core} & the library core \\ \texttt{debug} & debugging tools & \texttt{display} & display tools \\ @@ -605,7 +606,7 @@ not on implementation details about how to do it \smallskip % - \item you do not have found yet a library to easily process your + \item you have not yet found a library to easily process your particular types of data \end{itemize} @@ -824,9 +825,9 @@ \begin{frame}[fragile] \frametitle{Modifying the State of an Object (2/2)} - accessing and modifying through method calls allow some control: + accessing and modifying through method calls allows for some control: \begin{itemize} - \item one cannot do everything with an object + \item one cannot do anything with an object \item especially putting it in an invalid state \end{itemize} @@ -888,7 +889,7 @@ \begin{itemize} \item no need to take the address (with \&) of an object \item no pointer arithmetics - \item no $->$ in use + \item no $->$ to access members \end{itemize} \item it \emph{always} designates the same object \begin{itemize} @@ -995,7 +996,7 @@ accessible from the user \begin{itemize} \item thanks to the keyword \kw{private} - \item writing \code{p.row\_} outside this class is not allowed (do + \item writing \code{p.row\_} outside this class is not allowed (does not compile) \end{itemize} \smallskip @@ -1003,7 +1004,7 @@ \item the method \code{row()} is accessible (keyword \kw{public}) \begin{itemize} \item in the method body we have some room to add code - \item a simple access to data can performs some clever stuff that + \item a simple access to data can perform some clever stuff that you do not really have to know (neither want to)! \end{itemize} \end{itemize} @@ -1121,7 +1122,7 @@ \end{lstlisting} \begin{itemize} -\item the variable \code{r} represents an object which type is +\item the variable \code{r} represents an object the type of which is precisely \code{rabbit} \begin{center} we say that it is the \emph{exact} type behind this variable @@ -1165,7 +1166,7 @@ \item In that case \begin{itemize} \item at compile-time: there are many possible types of objects represented - \item at run-time: there is one object represented so just type. + \item at run-time: there is one object represented so just one type. \end{itemize} \end{itemize} @@ -1184,7 +1185,7 @@ About ``classical'' object-orientation: \begin{itemize} - \item abstractions (like \code{animal}) leads to poor + \item abstractions (like \code{animal}) lead to poor performance at run-time when involved in intensive scientific code. % \item it is due to the fact that the exact type is lost\\ @@ -1340,7 +1341,7 @@ \begin{frame}[fragile] \frametitle{A rationale for Genericity} -Suppose that you want a routine that computes twice the input: +Suppose that you want a routine that computes twice its input: \begin{lstlisting} int twice(int i) { return 2 * i; } \end{lstlisting} @@ -1434,7 +1435,7 @@ one of the procedure argument ``\code{(T t)}'' % \item the nature of \code{t} is \code{T}, the nature of \code{T} is - \code{typename} (so designates a type) + \code{typename} (so it designates a type) % \item the \cpp keyword introducing a generic piece of code is \kw{template} @@ -1476,7 +1477,7 @@ \item \code{int twice(int t) { return 2 * t; }} and \item \code{float twice(float t) { return 2 * t; }} \end{itemize} -\item so it is not so different than with overloading +\item so it is not so different than overloading \end{itemize} except that: @@ -1762,7 +1763,7 @@ } \end{lstlisting} -How can we ensure that the delta-point type \code{D} really correspond +How can we ensure that the delta-point type \code{D} really corresponds to \code{P}? {\scriptsize (we really do not want \code{P} and \code{D} resp. being \code{point3d} and \code{dpoint2d}!)} @@ -1803,7 +1804,7 @@ } \end{lstlisting} -What is the problem? (Hint: read both signatures in natural language) +What is the problem? (Hint: read both signatures out loud) \end{frame} @@ -1829,7 +1830,7 @@ \end{lstlisting} which is clearly not ambiguous (but slow at run-time...) -where \code{Dpoint} and \code{Image} are abstract class. +where \code{Dpoint} and \code{Image} are abstract classes. \end{frame} @@ -2140,11 +2141,11 @@ \scriptsize{it works for any delta-point type} \smallskip % -\item is fast +\item is fast, \scriptsize{you cannot get more efficient code} \smallskip % -\item is user-friendly +\item is user-friendly, \scriptsize{just write ``\code{dp1 + dp2}'' to add a couple of delta-points} \end{itemize}

16 years, 5 months

r1554: Remove all_headers.cc in util

by Guillaume Duhamel

URL: https://svn.lrde.epita.fr/svn/oln/trunk ChangeLog: 2007-11-27 Guillaume Duhamel <guillaume.duhamel(a)lrde.epita.fr> Remove all_headers.cc in util. * milena/tests/util/Makefile.am: Remove all_headers tests. --- Makefile.am | 2 -- 1 file changed, 2 deletions(-) Index: trunk/milena/tests/util/Makefile.am =================================================================== --- trunk/milena/tests/util/Makefile.am (revision 1553) +++ trunk/milena/tests/util/Makefile.am (revision 1554) @@ -4,7 +4,6 @@ check_PROGRAMS = \ - all_headers \ branch_iter \ branch_iter_ind \ eat \ @@ -16,7 +15,6 @@ tree_to_image \ tree_to_fast -all_headers_SOURCES = all_headers.cc branch_iter_SOURCES = branch_iter.cc branch_iter_ind_SOURCES = branch_iter_ind.cc eat_SOURCES = eat.cc

16 years, 5 months

1551: Add macros mln_trait_value_sum_ and mln_sum_.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * mln/trait/value_.hh (mln_trait_value_sum_, mln_sum_): New macros. value_.hh | 2 ++ 1 file changed, 2 insertions(+) Index: mln/trait/value_.hh --- mln/trait/value_.hh (revision 1551) +++ mln/trait/value_.hh (working copy) @@ -58,7 +58,9 @@ /// Give the summation type for values of type \c T. # define mln_trait_value_sum(V) typename mln::trait::value_< V >::sum +# define mln_trait_value_sum_(V) mln::trait::value_< V >::sum # define mln_sum(V) mln_trait_value_sum(V) +# define mln_sum_(V) mln_trait_value_sum_(V)

16 years, 5 months

1550: Add norm functors.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add norm functors. * mln/fun/v2v/norm.hh: New. Provide norm functors. * mln/fun/all.hh: Fix namespace description. * tests/fun/v2v/norm.cc: New. * tests/fun/v2v/Makefile.am (check_PROGRAMS): New. Add norm. (norm_SOURCES): New. (TESTS): New. * tests/fun/Makefile.am (SUBDIRS): Add v2v. mln/fun/all.hh | 2 mln/fun/v2v/norm.hh | 125 ++++++++++++++++++++++++++++++++++++++++++++++ tests/fun/Makefile.am | 2 tests/fun/v2v/Makefile.am | 6 ++ tests/fun/v2v/norm.cc | 69 +++++++++++++++++++++++++ 5 files changed, 202 insertions(+), 2 deletions(-) Index: mln/fun/v2v/norm.hh --- mln/fun/v2v/norm.hh (revision 0) +++ mln/fun/v2v/norm.hh (revision 0) @@ -0,0 +1,125 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_V2V_NORM_HH +# define MLN_FUN_V2V_NORM_HH + +/*! \file mln/fun/v2v/norm.hh + * + * \brief Norm functors. + * + * \see mln/norm/. + */ + +# include <mln/core/concept/function.hh> +# include <mln/trait/value_.hh> + +# include <mln/norm/all.hh> + + +namespace mln +{ + + namespace fun + { + + namespace v2v + { + + /*! \brief L1-norm. + * + * \c V is the type of input values; \c R is the result type. + * + * \see mln::norm::l1. + */ + template <typename V, typename R> + struct l1_norm : public Function_v2v< l1_norm<V, R> > + { + typedef R result; + R operator()(const V& v) const; + }; + + /*! \brief L2-norm. + * + * \c V is the type of input values; \c R is the result type. + * + * \see mln::norm::l2. + */ + template <typename V, typename R> + struct l2_norm : public Function_v2v< l2_norm<V, R> > + { + typedef R result; + R operator()(const V& v) const; + }; + + /*! \brief L-infty norm. + * + * \c V is the type of input values; \c R is the result type. + * + * \see mln::norm::linfty. + */ + template <typename V, typename R> + struct linfty_norm : public Function_v2v< linfty_norm<V, R> > + { + typedef R result; + R operator()(const V& v) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename V, typename R> + R + l1_norm<V, R>::operator()(const V& v) const + { + return mln::norm::l1 (v); + } + + template <typename V, typename R> + R + l2_norm<V, R>::operator()(const V& v) const + { + return mln::norm::l2 (v); + } + + template <typename V, typename R> + R + linfty_norm<V, R>::operator()(const V& v) const + { + return mln::norm::linfty (v); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::v2v + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_V2V_NORM_HH Index: mln/fun/all.hh --- mln/fun/all.hh (revision 1550) +++ mln/fun/all.hh (working copy) @@ -37,7 +37,7 @@ namespace mln { - /// Namespace of image processing routines related to pixel funs. + /// Namespace of image processing routines related to functions. namespace fun { Index: tests/fun/v2v/norm.cc --- tests/fun/v2v/norm.cc (revision 0) +++ tests/fun/v2v/norm.cc (revision 0) @@ -0,0 +1,69 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/*! \file tests/norm/l1.hh + * + * \brief Test the norm functors. + */ + +#include <mln/metal/vec.hh> +#include <mln/fun/v2v/norm.hh> + +#include <tests/norm/common.hh> + + +int main() +{ + typedef mln::metal::vec<3, int> vec_t; + + // L1-norm. + { + vec_t t, u; + t.set (1, -2, 3); + u.set (5, 1, 0); + mln::fun::v2v::l1_norm<vec_t, float> l1; + test::check_norm(l1, t, u); + } + + // L2-norm. + { + vec_t t, u; + t.set (2, -2, 3); + u.set (4, 1, 0); + mln::fun::v2v::l2_norm<vec_t, float> l2; + test::check_norm(l2, t, u); + } + + // L-infinity-norm. + { + vec_t t, u; + t.set (2, -2, 4); + u.set (4, 1, 0); + mln::fun::v2v::linfty_norm<vec_t, int> linfty; + test::check_norm(linfty, t, u); + } +} Index: tests/fun/v2v/Makefile.am --- tests/fun/v2v/Makefile.am (revision 1550) +++ tests/fun/v2v/Makefile.am (working copy) @@ -1,3 +1,9 @@ ## Process this file through Automake to create Makefile.in -*- Makefile -*- include $(top_srcdir)/milena/tests/tests.mk + +check_PROGRAMS = norm + +norm_SOURCES = norm.cc + +TESTS = $(check_PROGRAMS) Index: tests/fun/Makefile.am --- tests/fun/Makefile.am (revision 1550) +++ tests/fun/Makefile.am (working copy) @@ -2,4 +2,4 @@ include $(top_srcdir)/milena/tests/tests.mk -SUBDIRS = x2x +SUBDIRS = v2v x2x

16 years, 5 months

1549: Improve tests on norms.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Improve tests on norms. * tests/norm/l1.cc, tests/norm/l2.cc, tests/norm/linfty.cc: Revamp and factor common parts... * tests/norm/common.hh: ...here (new file). * tests/norm/Makefile.am (l1_SOURCES, l2_SOURCES, linfty_SOURCES): Add common.hh. * tests/norm_l2.cc: Remove. * tests/Makefile.am (SUBDIRS): Add fun. (check_PROGRAMS): Remove norm_l2.cc. * mln/norm/l1.hh (l1_distance), * mln/norm/l2.hh (l2_distance): Fix indentation. Makefile.am | 3 -- norm/Makefile.am | 6 ++--- norm/common.hh | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ norm/l1.cc | 49 ++++++++++++++++++++++++---------------------- norm/l2.cc | 49 +++++++++++++++++++++++++--------------------- norm/linfty.cc | 47 ++++++++++++++++++++++---------------------- 6 files changed, 139 insertions(+), 73 deletions(-) Index: mln/norm/l1.hh Index: mln/norm/l2.hh Index: tests/norm/l1.cc --- tests/norm/l1.cc (revision 1549) +++ tests/norm/l1.cc (working copy) @@ -30,44 +30,47 @@ * \brief Test the L1-norm. */ -#include <cassert> +#include <tests/norm/common.hh> #include <mln/metal/vec.hh> -#include <mln/math/abs.hh> #include <mln/norm/l1.hh> -// FIXME: We should have a almost_equal function somewhere in Milena. -static const float epsilon = 0.0001; -using mln::metal::vec; -using mln::norm::l1; - -template <typename V> -void check_l1 (const V& vec1, const V& vec2) +namespace test { - assert (mln::math::abs(mln::norm::l1(vec1) - mln::norm::l1(vec2)) - < epsilon); -} - template <typename V, typename S> -void check_l1_distance (const V& vec1, const V& vec2, const S& ref_val) + void + check_l1_norm_and_distance(const V& vec1, const V& vec2, const S& ref_val) { - assert (mln::math::abs(mln::norm::l1_distance(vec1, vec2) - ref_val) - < epsilon); + // Pointer on mln::norm::l1. + typedef mln_sum_(int) (*l1_t)(const V&); + l1_t l1 = mln::norm::l1; + + test::check_norm(l1, vec1, vec2); + + // Pointer on mln::norm::l1_distance. + typedef mln_sum_(int) (*l1_distance_t)(const V&, const V&); + l1_distance_t l1_distance = mln::norm::l1_distance; + + test::check_distance(l1_distance, vec1, vec2, ref_val); + } } int main () { - vec<3, int> t; t.set (1, -2, 3); - vec<3, int> u; u.set (5, 1, 0); + typedef mln::metal::vec<3, int> vec_t; + + // Reference value. int d = (5 - 1) + (1 + 2) + 3; - check_l1(t, u); - check_l1_distance (t, u, d); + // Tests using mln::metal::vec. + vec_t t, u; + t.set(1, -2, 3); + u.set(5, 1, 0); + test::check_l1_norm_and_distance(t, u, d); + // Tests using plain arrays. int v[] = {1, -2, 3}; int w[] = {5, 1, 0}; - - check_l1(v, w); - check_l1_distance (v, w, d); + test::check_l1_norm_and_distance(v, w, d); } Index: tests/norm/l2.cc --- tests/norm/l2.cc (revision 1549) +++ tests/norm/l2.cc (working copy) @@ -33,44 +33,49 @@ #include <cmath> #include <cassert> +#include <tests/norm/common.hh> + #include <mln/metal/vec.hh> -#include <mln/math/abs.hh> #include <mln/norm/l2.hh> -// FIXME: We should have a almost_equal function somewhere in Milena. -static const float epsilon = 0.0001; - -using mln::metal::vec; -using mln::norm::l2; -template <typename V> -void check_l2 (const V& vec1, const V& vec2) +namespace test { - assert (mln::math::abs(mln::norm::l2(vec1) - mln::norm::l2(vec2)) - < epsilon); -} - template <typename V, typename S> -void check_l2_distance (const V& vec1, const V& vec2, const S& ref_val) + void + check_l2_norm_and_distance(const V& vec1, const V& vec2, const S& ref_val) { - assert (mln::math::abs(mln::norm::l2_distance(vec1, vec2) - ref_val) - < epsilon); + // Pointer on mln::norm::l2. + typedef mln_sum_(int) (*l2_t)(const V&); + l2_t l2 = mln::norm::l2; + + test::check_norm(l2, vec1, vec2); + + // Pointer on mln::norm::l2_distance. + typedef mln_sum_(int) (*l2_distance_t)(const V&, const V&); + l2_distance_t l2_distance = mln::norm::l2_distance; + + test::check_distance(l2_distance, vec1, vec2, ref_val); + } } int main () { - vec<3, int> t; t.set (2, -2, 3); - vec<3, int> u; u.set (4, 1, 0); + typedef mln::metal::vec<3, int> vec_t; + + // Reference value. float d = std::sqrt((4 - 2) * (4 - 2) + (1 + 2) * (1 + 2) + (0 - 3) * (0 - 3)); - check_l2(t, u); - check_l2_distance (t, u, d); + // Tests using mln::metal::vec. + vec_t t, u; + t.set(2, -2, 3); + u.set(4, 1, 0); + test::check_l2_norm_and_distance(t, u, d); + // Tests using plain arrays. int v[] = {2, -2, 3}; int w[] = {4, 1, 0}; - - check_l2(v, w); - check_l2_distance (v, w, d); + test::check_l2_norm_and_distance(v, w, d); } Index: tests/norm/linfty.cc --- tests/norm/linfty.cc (revision 1549) +++ tests/norm/linfty.cc (working copy) @@ -30,47 +30,48 @@ * \brief Test the L-infinity-norm. */ -#include <cmath> -#include <cassert> +#include <tests/norm/common.hh> #include <mln/metal/vec.hh> #include <mln/math/abs.hh> #include <mln/norm/linfty.hh> -// FIXME: We should have a almost_equal function somewhere in Milena. -static const float epsilon = 0.0001; -using mln::metal::vec; -using mln::norm::linfty; - -template <typename V> -void check_linfty (const V& vec1, const V& vec2) +namespace test { - assert (mln::math::abs(mln::norm::linfty(vec1) - mln::norm::linfty(vec2)) - < epsilon); -} - template <typename V, typename S> -void check_linfty_distance (const V& vec1, const V& vec2, const S& ref_val) + void + check_linfty_norm_and_distance(const V& vec1, const V& vec2, const S& ref_val) { - assert (mln::math::abs(mln::norm::linfty_distance(vec1, vec2) - ref_val) - < epsilon); + // Pointer on mln::norm::linfty. + typedef int (*linfty_t)(const V&); + linfty_t linfty = mln::norm::linfty; + + test::check_norm(linfty, vec1, vec2); + + // Pointer on mln::norm::linfty_distance. + typedef int (*linfty_distance_t)(const V&, const V&); + linfty_distance_t linfty_distance = mln::norm::linfty_distance; + + test::check_distance(linfty_distance, vec1, vec2, ref_val); + } } int main () { - vec<3, int> t; t.set (2, -2, 4); - vec<3, int> u; u.set (4, 1, 0); + typedef mln::metal::vec<3, int> vec_t; + + // Reference value. float d = std::max(std::abs(4 - 2), std::max(std::abs(1 + 2), std::abs(0 - 4))); - check_linfty(t, u); - check_linfty_distance (t, u, d); + vec_t t, u; + t.set(2, -2, 4); + u.set(4, 1, 0); + test::check_linfty_norm_and_distance(t, u, d); int v[] = {2, -2, 4}; int w[] = {4, 1, 0}; - - check_linfty(v, w); - check_linfty_distance (v, w, d); + test::check_linfty_norm_and_distance(v, w, d); } Index: tests/norm/common.hh --- tests/norm/common.hh (revision 0) +++ tests/norm/common.hh (revision 0) @@ -0,0 +1,58 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef TESTS_NORM_COMMON_HH +# define TESTS_NORM_COMMON_HH + +#include <cassert> + +#include <mln/math/abs.hh> + +// FIXME: We should have a almost_equal function somewhere in Milena. +static const float epsilon = 0.0001; + +namespace test +{ + + template <typename Norm, typename V> + void + check_norm(const Norm norm, const V& vec1, const V& vec2) + { + assert(mln::math::abs(norm(vec1) - norm(vec2)) < epsilon); + } + + template <typename Distance, typename V, typename S> + void + check_distance (const Distance dist, const V& vec1, const V& vec2, + const S& ref_val) + { + assert (mln::math::abs(dist(vec1, vec2) - ref_val) < epsilon); + } + +} // End of namespace test. + +#endif // !TESTS_NORM_COMMON_HH Index: tests/norm/Makefile.am --- tests/norm/Makefile.am (revision 1549) +++ tests/norm/Makefile.am (working copy) @@ -7,8 +7,8 @@ l2 \ linfty -l1_SOURCES = l1.cc -l2_SOURCES = l2.cc -linfty_SOURCES = linfty.cc +l1_SOURCES = l1.cc common.hh +l2_SOURCES = l2.cc common.hh +linfty_SOURCES = linfty.cc common.hh TESTS = $(check_PROGRAMS) Index: tests/Makefile.am --- tests/Makefile.am (revision 1549) +++ tests/Makefile.am (working copy) @@ -9,6 +9,7 @@ canvas \ display \ draw \ + fun \ histo \ level \ logical \ @@ -103,8 +104,6 @@ morpho_opening_area \ morpho_thinning \ \ - norm_l2 \ - \ pixel \ pixter1d \ pixter2d \

16 years, 5 months

milena r1549: Add an error of incompatible types in pnm loading

by Matthieu Garrigues

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2007-11-27 Matthieu Garrigues <garrigues(a)lrde.epita.fr> Add an error of incompatible types in pnm loading. * mln/io/pnm/load.hh: io::ppm::load<rgb8>("image16bits.ppm") now abort because we can't store rgb 16 bits into rgb 8 bits (likewise for pgm). * tests/io/ppm/ppm16.cc: Add some tests due to this update. --- mln/io/pnm/load.hh | 13 +++++++++++++ tests/io/ppm/ppm16.cc | 17 +++++++++++++++++ 2 files changed, 30 insertions(+) Index: trunk/milena/tests/io/ppm/ppm16.cc =================================================================== --- trunk/milena/tests/io/ppm/ppm16.cc (revision 1548) +++ trunk/milena/tests/io/ppm/ppm16.cc (revision 1549) @@ -117,4 +117,21 @@ io::ppm::load(b, "../../../img/lena_16.ppm"); } + + { + // Abort +// image2d< value::rgb<8> > a = +// io::ppm::load("../../../img/lena_16.ppm"); + + // Abort +// image2d< value::rgb<16> > a = +// io::ppm::load< value::rgb<16> >("../../../img/lena.ppm"); + + image2d< value::rgb<16> > a = + io::ppm::load< value::rgb<16> >("../../../img/lena_16.ppm"); + + image2d< value::rgb<8> > b = + io::ppm::load< value::rgb<8> >("../../../img/lena.ppm"); + + } } Index: trunk/milena/mln/io/pnm/load.hh =================================================================== --- trunk/milena/mln/io/pnm/load.hh (revision 1548) +++ trunk/milena/mln/io/pnm/load.hh (revision 1549) @@ -156,6 +156,19 @@ read_header(type_ - 3, type_, file, type, nrows, ncols, maxval); + if (max_component(V()) != maxval) + { + std::cerr << "error: file '" << filename + << "' cannot be loaded into this type of image" + << std::endl; + + std::cerr << "input image have " << maxval + << " as maximum value while the destination's one is " + << max_component(V()) << " (should be the same)." + << std::endl; + abort(); + } + image2d<V> ima(nrows, ncols); if (type == type_) load_raw_2d(file, ima);

16 years, 5 months

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches November 2007