2005-04-02 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
* oln/core/pw/times.hh: New file.
* oln/core/pw/image.hh: New file.
* oln/core/pw/div.hh: New file.
* oln/core/pw/plus.hh: New file.
* oln/core/pw/abstract/function.hh: New file.
* oln/core/pw/all.hh: New file.
* oln/core/pw/minus.hh: New file.
* oln/core/pw/literal.hh: New file.
* oln/core/pw/cmp.hh: New file.
* oln/core/any/all.hh: New file.
* oln/core/any/point.hh: New file.
* oln/core/any/size.hh: New file.
* oln/core/any/dpoint.hh: New file.
* oln/core/abstract/point.hh (operator any_point): New.
* oln/core/abstract/size.hh: Cosmetic changes.
* oln/core/1d/size1d.hh (impl_eq(any_size)): New.
* oln/core/2d/size2d.hh (impl_eq(any_size)): New.
* oln/core/3d/size3d.hh (impl_eq(any_size)): New.
* oln/basics2d.hh: Include core/2d/fwd_piter2d and
core/2d/bkd_piter2d.
* oln/basics.hh: Include core/any/all.hh and core/pw/all.hh.
* oln/makefile.src (OLN_DEP): Add new files.
Index: oln/core/pw/times.hh
===================================================================
--- oln/core/pw/times.hh (revision 0)
+++ oln/core/pw/times.hh (revision 0)
@@ -0,0 +1,112 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_TIMES_HH
+# define OLENA_CORE_PW_TIMES_HH
+
+# include <oln/core/pw/abstract/function.hh>
+# include <ntg/all.hh>
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+ // fwd decl
+ template <typename L, typename R> struct times;
+
+ template <typename L, typename R>
+ struct traits < times<L, R> >
+ {
+ typedef oln_pw_point_type(L) point_type;
+ typedef ntg_return_type(times, oln_pw_value_type(L), oln_pw_value_type(R)) value_type;
+ typedef oln_pw_size_type(L) size_type;
+ };
+
+ template <typename L, typename R>
+ struct times : public abstract::function < times<L, R> >
+ {
+ typedef times<L, R> self_type;
+
+ typedef oln_pw_point_type(self_type) point_type;
+ typedef oln_pw_value_type(self_type) value_type;
+ typedef oln_pw_size_type(self_type) size_type;
+
+ L left;
+ R right;
+
+ times(const abstract::function<L>& left,
+ const abstract::function<R>& right) :
+ left(left.exact()),
+ right(right.exact())
+ {
+ }
+
+ const size_type& impl_size() const
+ {
+ return this->left.size();
+ }
+
+ const value_type impl_get(const point_type& p) const
+ {
+ return this->left(p) * this->right(p);
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return this->left.hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return this->left.hold_large(p);
+ }
+ };
+
+ } // end of namespace oln::pw
+
+} // end of namespace oln
+
+
+/// Operator * on pwf
+
+template <typename L, typename R>
+oln::pw::times<L, R> operator * (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::times<L, R> tmp(lhs, rhs);
+ return tmp;
+}
+
+oln_pw_operator(times, *, int)
+oln_pw_operator(times, *, float)
+oln_pw_operator(times, *, double)
+
+
+#endif // ! OLENA_CORE_PW_TIMES_HH
Index: oln/core/pw/image.hh
===================================================================
--- oln/core/pw/image.hh (revision 0)
+++ oln/core/pw/image.hh (revision 0)
@@ -0,0 +1,262 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_IMAGE_HH
+# define OLENA_CORE_PW_IMAGE_HH
+
+# include <mlc/any.hh>
+# include <mlc/cmp.hh>
+# include <oln/core/box.hh>
+# include <oln/core/abstract/entry.hh>
+# include <oln/core/pw/abstract/function.hh>
+
+// FIXME: remove
+# include <oln/core/2d/fwd_piter2d.hh>
+# include <oln/core/2d/bkd_piter2d.hh>
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+ // fwd decl
+ template <typename I> struct image;
+
+ template <typename I>
+ struct traits < image<I> >
+ {
+ typedef oln_type_of(I, point) point_type;
+ typedef oln_type_of(I, value) value_type;
+ typedef oln_type_of(I, size) size_type;
+ };
+
+ template <typename I>
+ struct image : public abstract::function < image<I> >
+ {
+ oln::box<const I> ima;
+
+ image(const oln::abstract::image<I>& ima) :
+ ima(ima)
+ {
+ }
+
+ typedef oln_type_of(I, point) point_type;
+ typedef oln_type_of(I, value) value_type;
+ typedef oln_type_of(I, size) size_type;
+
+ const size_type& impl_size() const
+ {
+ return this->ima.size();
+ }
+
+ const value_type impl_get(const point_type& p) const
+ {
+ return this->ima.get(p);
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return this->ima.hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return this->ima.hold_large(p);
+ }
+
+ };
+
+ } // end of namespace oln::pw
+
+
+ /// Routine that takes an image and outputs a "point value" object
+
+ template <typename I>
+ pw::image<I> p_value(const abstract::image<I>& ima)
+ {
+ pw::image<I> tmp(ima);
+ return tmp;
+ }
+
+
+ // fwd decl
+ template <typename F> class image_from_pw;
+
+ // category
+ template <typename F>
+ struct set_category< image_from_pw<F> > { typedef category::image ret; };
+
+ // super
+ template <typename F>
+ struct set_super_type < image_from_pw<F> >
+ {
+ typedef abstract::image_entry< image_from_pw<F> > ret;
+ };
+
+ // props
+ template <typename F>
+ struct set_props < category::image, image_from_pw<F> > : public props_of <category::image>
+ {
+ typedef oln_pw_point_type(F) point_type;
+ typedef oln_pw_value_type(F) value_type;
+ typedef oln_pw_size_type(F) size_type;
+
+ typedef mlc::no_type delegated_type;
+
+ // FIXME: we do not know if it is 2d...
+ typedef is_a<abstract::image2d> image_dimension_type;
+ typedef vectorialness_from_valuetype(value_type) image_vectorialness_type;
+
+ typedef fwd_piter2d piter_type;
+ typedef fwd_piter2d fwd_piter_type;
+ typedef bkd_piter2d bkd_piter_type;
+ };
+
+
+ /// Class image_from_pw<F>.
+
+ template <typename F>
+ struct image_from_pw : public abstract::image_entry< image_from_pw<F> >
+ {
+ typedef image_from_pw<F> self_type;
+
+ F fun;
+
+ image_from_pw(const pw::abstract::function<F>& fun) :
+ fun(fun.exact())
+ {
+ this->exact_ptr = this;
+ }
+
+ image_from_pw(const self_type& rhs) :
+ fun(rhs.fun)
+ {
+ this->exact_ptr = this;
+ }
+
+ /// typedefs
+
+ typedef image_from_pw<F> self_type;
+
+ typedef oln_type_of(self_type, size) size_type;
+ typedef oln_type_of(self_type, value) value_type;
+ typedef oln_type_of(self_type, point) point_type;
+
+ const size_type& impl_size() const
+ {
+ return this->fun.size();
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return this->fun.hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return this->fun.hold_large(p);
+ }
+
+ const value_type impl_get(const point_type& p) const
+ {
+ return this->fun(p);
+ }
+
+ // FIXME: remove below
+ unsigned long impl_npoints() const
+ {
+ return 1;
+ }
+ void impl_resize_border(size_t new_border, bool copy_border) const
+ {
+ }
+
+ };
+
+
+ /// Routine
+
+ template <typename F>
+ image_from_pw<F> for_all_p(const pw::abstract::function<F>& fun)
+ {
+ image_from_pw<F> tmp(fun);
+ return tmp;
+ }
+
+
+ /// Specialization of p_value (so that "p_value(for_all_p(fun)) == fun").
+
+ template <typename F>
+ F p_value(const image_from_pw<F>& ima)
+ {
+ return ima.fun;
+ }
+
+
+
+
+ /// Routine check.
+ // FIXME: this should be an algorithm (pred = binary_image)
+
+ template <typename I>
+ bool check(const abstract::image<I>& pred)
+ {
+ // FIXME: input should be binary
+ oln_type_of(I, fwd_piter) p(pred.size());
+ for_all (p)
+ if (! pred[p])
+ return false;
+ return true;
+ }
+
+
+
+ namespace pw {
+
+ /// Routine oln::pw::check.
+
+ template <typename F>
+ bool check(const pw::abstract::function<F>& pred)
+ {
+ // FIXME: ugly syntax
+ // FIXME: bool or bin or...
+ mlc::is_true<
+ mlc::type::eq< oln_pw_value_type(F), bool >::ret
+ >::ensure();
+
+ return oln::check(for_all_p(pred));
+ }
+
+ } // end of namespace oln::pw
+
+
+} // end of namespace oln
+
+
+
+#endif // ! OLENA_CORE_PW_IMAGE_HH
Index: oln/core/pw/div.hh
===================================================================
--- oln/core/pw/div.hh (revision 0)
+++ oln/core/pw/div.hh (revision 0)
@@ -0,0 +1,109 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_DIV_HH
+# define OLENA_CORE_PW_DIV_HH
+
+# include <oln/core/pw/abstract/function.hh>
+# include <ntg/all.hh>
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+ // fwd decl
+ template <typename L, typename R> struct div;
+
+ template <typename L, typename R>
+ struct traits < div<L, R> >
+ {
+ typedef oln_pw_point_type(L) point_type;
+ typedef ntg_return_type(div, oln_pw_value_type(L), oln_pw_value_type(R)) value_type;
+ typedef oln_pw_size_type(L) size_type;
+ };
+
+ template <typename L, typename R>
+ struct div : public abstract::function < div<L, R> >
+ {
+ typedef div<L, R> self_type;
+
+ typedef oln_pw_point_type(self_type) point_type;
+ typedef oln_pw_value_type(self_type) value_type;
+ typedef oln_pw_size_type(self_type) size_type;
+
+ L left;
+ R right;
+
+ div(const abstract::function<L>& left,
+ const abstract::function<R>& right) :
+ left(left.exact()),
+ right(right.exact())
+ {
+ }
+
+ const size_type& impl_size() const
+ {
+ return this->left.size();
+ }
+
+ const value_type impl_get(const point_type& p) const
+ {
+ precondition(this->right(p) != 0);
+ return this->left(p) / this->right(p);
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return this->left.hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return this->left.hold_large(p);
+ }
+ };
+
+ } // end of namespace oln::pw
+
+} // end of namespace oln
+
+
+/// Operator / on pwf
+
+template <typename L, typename R>
+oln::pw::div<L, R> operator / (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::div<L, R> tmp(lhs, rhs);
+ return tmp;
+}
+
+
+#endif // ! OLENA_CORE_PW_DIV_HH
Index: oln/core/pw/plus.hh
===================================================================
--- oln/core/pw/plus.hh (revision 0)
+++ oln/core/pw/plus.hh (revision 0)
@@ -0,0 +1,127 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_PLUS_HH
+# define OLENA_CORE_PW_PLUS_HH
+
+# include <oln/core/pw/abstract/function.hh>
+# include <ntg/all.hh>
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+ // fwd decl
+ template <typename L, typename R> struct plus;
+
+ template <typename L, typename R>
+ struct traits < plus<L, R> >
+ {
+ typedef oln_pw_point_type(L) point_type;
+ typedef ntg_return_type(plus, oln_pw_value_type(L), oln_pw_value_type(R)) value_type;
+ typedef oln_pw_size_type(L) size_type;
+ };
+
+ template <typename L, typename R>
+ struct plus : public abstract::function < plus<L, R> >
+ {
+ typedef plus<L, R> self_type;
+
+ typedef oln_pw_point_type(self_type) point_type;
+ typedef oln_pw_value_type(self_type) value_type;
+ typedef oln_pw_size_type(self_type) size_type;
+
+ L left;
+ R right;
+
+ plus(const abstract::function<L>& left,
+ const abstract::function<R>& right) :
+ left(left.exact()),
+ right(right.exact())
+ {
+ }
+
+ const size_type& impl_size() const
+ {
+ return this->left.size();
+ }
+
+ const value_type impl_get(const point_type& p) const
+ {
+ return this->left(p) + this->right(p);
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return this->left.hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return this->left.hold_large(p);
+ }
+ };
+
+ } // end of namespace oln::pw
+
+} // end of namespace oln
+
+
+/// Operator + on pwf
+
+template <typename L, typename R>
+oln::pw::plus<L, R> operator + (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::plus<L, R> tmp(lhs, rhs);
+ return tmp;
+}
+
+oln_pw_operator(plus, +, int)
+oln_pw_operator(plus, +, float)
+oln_pw_operator(plus, +, double)
+
+// template <typename L>
+// oln::pw::plus<L, oln::pw::literal<int> >
+// operator + (const oln::pw::abstract::function<L>& lhs,
+// int value)
+// {
+// return lhs + oln::pw::literal<int>(value);
+// }
+// template <typename R>
+// oln::pw::plus<oln::pw::literal<int>, R>
+// operator + (int value,
+// const oln::pw::abstract::function<R>& rhs)
+// {
+// return oln::pw::literal<int>(value) + rhs;
+// }
+
+
+#endif // ! OLENA_CORE_PW_PLUS_HH
Index: oln/core/pw/abstract/function.hh
===================================================================
--- oln/core/pw/abstract/function.hh (revision 0)
+++ oln/core/pw/abstract/function.hh (revision 0)
@@ -0,0 +1,133 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_ABSTRACT_FUNCTION_HH
+# define OLENA_CORE_PW_ABSTRACT_FUNCTION_HH
+
+# include <mlc/any.hh>
+# include <oln/core/properties.hh>
+
+
+# define oln_pw_point_type(T) typename oln::pw::traits<T>::point_type
+# define oln_pw_value_type(T) typename oln::pw::traits<T>::value_type
+# define oln_pw_size_type(T) typename oln::pw::traits<T>::size_type
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+ template <typename T> struct traits;
+
+
+ // fwd decls
+ namespace abstract {
+ template <typename E> struct function;
+ }
+ template <typename L, typename R> struct minus;
+ template <typename T> struct literal;
+
+
+
+ template <typename E>
+ struct traits < abstract::function<E> >
+ {
+ typedef oln_pw_point_type(E) point_type;
+ typedef oln_pw_value_type(E) value_type;
+ typedef oln_pw_size_type(E) size_type;
+ };
+
+ namespace abstract {
+
+ template <typename E>
+ struct function : public mlc::any<E>
+ {
+ typedef oln_pw_point_type(E) point_type;
+ typedef oln_pw_value_type(E) value_type;
+ typedef oln_pw_size_type(E) size_type;
+
+ const size_type& size() const
+ {
+ return this->exact().impl_size();
+ }
+
+ const value_type operator()(const point_type& p) const
+ {
+ return this->exact().impl_get(p);
+ }
+
+ bool hold(const point_type& p) const
+ {
+ return this->exact().impl_hold(p);
+ }
+
+ bool hold_large(const point_type& p) const
+ {
+ return this->exact().impl_hold_large(p);
+ }
+
+// minus< literal<value_type>, E> operator-() const;
+
+ protected:
+ function() {}
+
+ ~function()
+ {
+ { // impl_size
+ typedef const size_type& (E::*meth)() const;
+ meth adr = &E::impl_size;
+ adr = 0;
+ }
+ { // impl_get
+ typedef const value_type (E::*meth)(const point_type&) const;
+ meth adr = &E::impl_get;
+ adr = 0;
+ }
+ { // impl_hold
+ typedef bool (E::*meth)(const point_type&) const;
+ meth adr = &E::impl_hold;
+ adr = 0;
+ }
+ { // impl_hold_large
+ typedef bool (E::*meth)(const point_type&) const;
+ meth adr = &E::impl_hold_large;
+ adr = 0;
+ }
+
+ }
+ };
+
+ } // end of namespace oln::pw::abstract
+
+ } // end of namespace oln::pw
+
+} // end of namespace oln
+
+
+
+#endif // ! OLENA_CORE_PW_ABSTRACT_FUNCTION_HH
Index: oln/core/pw/all.hh
===================================================================
--- oln/core/pw/all.hh (revision 0)
+++ oln/core/pw/all.hh (revision 0)
@@ -0,0 +1,46 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_ALL_HH
+# define OLENA_CORE_PW_ALL_HH
+
+
+# include <oln/core/pw/abstract/function.hh>
+# include <oln/core/pw/image.hh>
+# include <oln/core/pw/literal.hh>
+
+# include <oln/core/pw/cmp.hh>
+
+# include <oln/core/pw/plus.hh>
+# include <oln/core/pw/minus.hh>
+# include <oln/core/pw/times.hh>
+# include <oln/core/pw/div.hh>
+
+// FIXME: not xor mod...
+
+
+#endif // ! OLENA_CORE_PW_ALL_HH
Index: oln/core/pw/minus.hh
===================================================================
--- oln/core/pw/minus.hh (revision 0)
+++ oln/core/pw/minus.hh (revision 0)
@@ -0,0 +1,126 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_MINUS_HH
+# define OLENA_CORE_PW_MINUS_HH
+
+# include <oln/core/pw/abstract/function.hh>
+# include <ntg/all.hh>
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+ // fwd decl
+ template <typename L, typename R> struct minus;
+
+ template <typename L, typename R>
+ struct traits < minus<L, R> >
+ {
+ typedef oln_pw_point_type(L) point_type;
+ typedef ntg_return_type(minus, oln_pw_value_type(L), oln_pw_value_type(R)) value_type;
+ typedef oln_pw_size_type(L) size_type;
+ };
+
+ template <typename L, typename R>
+ struct minus : public abstract::function < minus<L, R> >
+ {
+ typedef minus<L, R> self_type;
+
+ typedef oln_pw_point_type(self_type) point_type;
+ typedef oln_pw_value_type(self_type) value_type;
+ typedef oln_pw_size_type(self_type) size_type;
+
+ L left;
+ R right;
+
+ minus(const abstract::function<L>& left,
+ const abstract::function<R>& right) :
+ left(left.exact()),
+ right(right.exact())
+ {
+ }
+
+ const size_type& impl_size() const
+ {
+ return this->left.size();
+ }
+
+ const value_type impl_get(const point_type& p) const
+ {
+ return this->left(p) - this->right(p);
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return this->left.hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return this->left.hold_large(p);
+ }
+
+ };
+
+
+ // FIXME: uncomment?
+
+// namespace abstract {
+
+// template <typename E>
+// minus< literal<oln_pw_value_type(E)>, E>
+// function<E>::operator-() const
+// {
+// literal<oln_pw_value_type(E)> lhs(0);
+// return lhs - *this;
+// }
+
+// }
+
+
+ } // end of namespace oln::pw
+
+} // end of namespace oln
+
+
+/// Operator - on pwf
+
+template <typename L, typename R>
+oln::pw::minus<L, R> operator - (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::minus<L, R> tmp(lhs, rhs);
+ return tmp;
+}
+
+
+
+#endif // ! OLENA_CORE_PW_MINUS_HH
Index: oln/core/pw/literal.hh
===================================================================
--- oln/core/pw/literal.hh (revision 0)
+++ oln/core/pw/literal.hh (revision 0)
@@ -0,0 +1,120 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_LITERAL_HH
+# define OLENA_CORE_PW_LITERAL_HH
+
+# include <oln/core/pw/abstract/function.hh>
+# include <oln/core/any/all.hh>
+
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+ // fwd decl
+ template <typename T> struct literal;
+
+ template <typename T>
+ struct traits < literal<T> >
+ {
+ typedef any_point point_type;
+ typedef T value_type;
+ typedef any_size size_type;
+ };
+
+ template <typename T>
+ struct literal : public abstract::function < literal<T> >
+ {
+ typedef literal<T> self_type;
+
+ T value;
+
+ literal(T value) :
+ value(value)
+ {
+ }
+
+ const any_size& impl_size() const
+ {
+ static const any_size the;
+ return the;
+ }
+
+ const T impl_get(const any_point& p) const
+ {
+ return value;
+ }
+
+ bool impl_hold(const any_point& p) const
+ {
+ return true;
+ }
+
+ bool impl_hold_large(const any_point& p) const
+ {
+ return true;
+ }
+ };
+
+ } // end of namespace oln::pw
+
+
+ /// Routine that takes a literal and outputs a "point-wise literal" object
+
+ template <typename T>
+ pw::literal<T> p_lit(const T& value)
+ {
+ pw::literal<T> tmp(value);
+ return tmp;
+ }
+
+
+} // end of namespace oln
+
+
+# define oln_pw_operator(NAME, SYMBOL, TYPE) \
+template <typename L> \
+oln::pw::NAME<L, oln::pw::literal<TYPE> > \
+operator SYMBOL (const oln::pw::abstract::function<L>& lhs, \
+ TYPE value) \
+{ \
+ return lhs SYMBOL oln::pw::literal<TYPE>(value); \
+} \
+template <typename R> \
+oln::pw::NAME<oln::pw::literal<TYPE>, R> \
+operator SYMBOL (TYPE value, \
+ const oln::pw::abstract::function<R>& rhs) \
+{ \
+ return oln::pw::literal<TYPE>(value) SYMBOL rhs; \
+}
+
+
+
+#endif // ! OLENA_CORE_PW_LITERAL_HH
Index: oln/core/pw/cmp.hh
===================================================================
--- oln/core/pw/cmp.hh (revision 0)
+++ oln/core/pw/cmp.hh (revision 0)
@@ -0,0 +1,205 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_PW_CMP_HH
+# define OLENA_CORE_PW_CMP_HH
+
+# include <oln/core/pw/abstract/function.hh>
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+
+ // FIXME: move somewhere else
+ namespace internal
+ {
+ struct eq {
+ template <typename L, typename R>
+ bool operator()(const L& lhs, const R& rhs) const {
+ return lhs == rhs;
+ }
+ };
+ struct neq {
+ template <typename L, typename R>
+ bool operator()(const L& lhs, const R& rhs) const {
+ return lhs != rhs;
+ }
+ };
+ struct geq {
+ template <typename L, typename R>
+ bool operator()(const L& lhs, const R& rhs) const {
+ return lhs >= rhs;
+ }
+ };
+ struct leq {
+ template <typename L, typename R>
+ bool operator()(const L& lhs, const R& rhs) const {
+ return lhs <= rhs;
+ }
+ };
+ struct g {
+ template <typename L, typename R>
+ bool operator()(const L& lhs, const R& rhs) const {
+ return lhs > rhs;
+ }
+ };
+ struct l {
+ template <typename L, typename R>
+ bool operator()(const L& lhs, const R& rhs) const {
+ return lhs < rhs;
+ }
+ };
+ }
+
+
+ // fwd decl
+ template <typename L, typename R, typename C> struct cmp;
+
+ template <typename L, typename R, typename C>
+ struct traits < cmp<L, R, C> >
+ {
+ typedef oln_pw_point_type(L) point_type;
+ typedef bool value_type;
+ typedef oln_pw_size_type(L) size_type;
+ };
+
+ template <typename L, typename R, typename C>
+ struct cmp : public abstract::function < cmp<L, R, C> >
+ {
+ typedef cmp<L, R, C> self_type;
+
+ typedef oln_pw_point_type(self_type) point_type;
+ typedef oln_pw_size_type(self_type) size_type;
+
+ L left;
+ R right;
+
+ cmp(const abstract::function<L>& left,
+ const abstract::function<R>& right) :
+ left(left.exact()),
+ right(right.exact())
+ {
+ }
+
+ const size_type& impl_size() const
+ {
+ return this->left.size();
+ }
+
+ const bool impl_get(const point_type& p) const
+ {
+ static const C cmpfun = C();
+ return cmpfun(this->left(p), this->right(p));
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return this->left.hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return this->left.hold_large(p);
+ }
+
+ };
+
+ } // end of namespace oln::pw
+
+
+} // end of namespace oln
+
+
+
+/// Op+ on pwf
+
+template <typename L, typename R>
+oln::pw::cmp<L, R, oln::pw::internal::eq>
+operator == (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::cmp<L, R, oln::pw::internal::eq> tmp(lhs, rhs);
+ return tmp;
+}
+
+template <typename L, typename R>
+oln::pw::cmp<L, R, oln::pw::internal::neq>
+operator != (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::cmp<L, R, oln::pw::internal::neq> tmp(lhs, rhs);
+ return tmp;
+}
+
+template <typename L, typename R>
+oln::pw::cmp<L, R, oln::pw::internal::geq>
+operator >= (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::cmp<L, R, oln::pw::internal::geq> tmp(lhs, rhs);
+ return tmp;
+}
+
+template <typename L, typename R>
+oln::pw::cmp<L, R, oln::pw::internal::leq>
+operator <= (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::cmp<L, R, oln::pw::internal::leq> tmp(lhs, rhs);
+ return tmp;
+}
+
+template <typename L, typename R>
+oln::pw::cmp<L, R, oln::pw::internal::g>
+operator > (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::cmp<L, R, oln::pw::internal::g> tmp(lhs, rhs);
+ return tmp;
+}
+
+template <typename L, typename R>
+oln::pw::cmp<L, R, oln::pw::internal::l>
+operator < (const oln::pw::abstract::function<L>& lhs,
+ const oln::pw::abstract::function<R>& rhs)
+{
+ precondition(lhs.size() == rhs.size());
+ oln::pw::cmp<L, R, oln::pw::internal::l> tmp(lhs, rhs);
+ return tmp;
+}
+
+
+
+#endif // ! OLENA_CORE_PW_CMP_HH
Index: oln/core/any/all.hh
===================================================================
--- oln/core/any/all.hh (revision 0)
+++ oln/core/any/all.hh (revision 0)
@@ -0,0 +1,36 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_ANY_ALL_HH
+# define OLENA_CORE_ANY_ALL_HH
+
+
+# include <oln/core/any/point.hh>
+# include <oln/core/any/size.hh>
+
+
+#endif // ! OLENA_CORE_ANY_ALL_HH
Index: oln/core/any/point.hh
===================================================================
--- oln/core/any/point.hh (revision 0)
+++ oln/core/any/point.hh (revision 0)
@@ -0,0 +1,106 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_ANY_POINT_HH
+# define OLENA_CORE_ANY_POINT_HH
+
+# include <oln/core/abstract/point.hh>
+# include <oln/core/abstract/dpoint.hh>
+
+
+namespace oln {
+
+ // fwd decls
+ struct any_point;
+ struct any_dpoint;
+
+ // category
+ struct set_category< any_point > { typedef category::point ret; };
+
+ // props
+ template <>
+ struct set_props < category::point, any_point > : public props_of<category::point>
+ {
+ typedef any_dpoint dpoint_type;
+ };
+
+
+ struct any_point : public abstract::point < any_point >
+ {
+
+ bool impl_eq(const exact_type& rhs) const
+ {
+ return this->exact().impl_eq(rhs.exact());
+ }
+
+ template <typename D>
+ const any_point impl_plus(const abstract::dpoint<D>& rhs) const
+ {
+ return any_point();
+ }
+
+ template <typename P>
+ const any_dpoint impl_minus(const abstract::point<P>& rhs) const;
+
+ };
+
+
+ namespace abstract {
+
+ template <typename E>
+ point<E>::operator any_point() const
+ {
+ return any_point();
+ }
+
+ } // end of namespace oln::abstract
+
+
+} // end of namespace oln
+
+
+std::ostream& operator<<(std::ostream& ostr, const oln::any_point& p)
+{
+ return ostr << "any";
+}
+
+
+# include <oln/core/any/dpoint.hh>
+
+
+namespace oln {
+
+ template <typename P>
+ const any_dpoint any_point::impl_minus(const abstract::point<P>& rhs) const
+ {
+ return any_dpoint();
+ }
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CORE_ANY_POINT_HH
Index: oln/core/any/size.hh
===================================================================
--- oln/core/any/size.hh (revision 0)
+++ oln/core/any/size.hh (revision 0)
@@ -0,0 +1,54 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_ANY_SIZE_HH
+# define OLENA_CORE_ANY_SIZE_HH
+
+# include <oln/core/abstract/size.hh>
+
+namespace oln {
+
+ struct any_size : public abstract::size< any_size >
+ {
+
+ template <typename S>
+ bool impl_eq(const abstract::size<S>& rhs) const
+ {
+ return true;
+ }
+
+ // FIXME: remove below
+ unsigned long impl_npoints() const
+ {
+ return 1;
+ }
+ };
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CORE_ANY_SIZE_HH
Index: oln/core/any/dpoint.hh
===================================================================
--- oln/core/any/dpoint.hh (revision 0)
+++ oln/core/any/dpoint.hh (revision 0)
@@ -0,0 +1,90 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_ANY_DPOINT_HH
+# define OLENA_CORE_ANY_DPOINT_HH
+
+# include <oln/core/abstract/dpoint.hh>
+
+
+namespace oln {
+
+
+ struct any_dpoint : public abstract::dpoint < any_dpoint >
+ {
+
+ template <typename D>
+ bool operator==(const abstract::dpoint<D>& rhs) const
+ {
+ return true;
+ }
+
+ template <typename D>
+ bool operator!=(const abstract::dpoint<D>& rhs) const
+ {
+ return false;
+ }
+
+ template <typename D>
+ const any_dpoint operator+(const abstract::dpoint<D>& rhs) const
+ {
+ return any_dpoint();
+ }
+
+ template <typename P>
+ const any_point operator+(const abstract::point<P>& rhs) const;
+
+ const any_dpoint operator-() const
+ {
+ return any_dpoint();
+ }
+
+ };
+
+} // end of namespace oln
+
+
+std::ostream& operator<<(std::ostream& ostr, const oln::any_dpoint& dp)
+{
+ return ostr << "any";
+}
+
+
+# include <oln/core/any/point.hh>
+
+
+namespace oln {
+
+ template <typename P>
+ const any_point any_dpoint::operator+(const abstract::point<P>& rhs) const
+ {
+ return any_point();
+ }
+
+}
+
+#endif // ! OLENA_CORE_ANY_DPOINT_HH
Index: oln/core/abstract/point.hh
===================================================================
--- oln/core/abstract/point.hh (revision 102)
+++ oln/core/abstract/point.hh (working copy)
@@ -40,7 +40,10 @@
namespace oln {
- // fwd decl
+ // fwd decls
+
+ struct any_point;
+
namespace abstract {
template <typename E> struct point;
}
@@ -89,6 +92,13 @@
typedef E exact_type;
+
+
+ /// Conversion to any_point (implemented in oln/core/any/point.hh).
+
+ operator any_point() const;
+
+
/*! \brief Test equality of two points. Nota bene: this method
** is abstract-like.
**
@@ -99,6 +109,12 @@
return this->exact().impl_eq(rhs.exact());
}
+// // FIXME: compiler error (cannot be overloaded)
+// bool operator==(const any_point& rhs) const
+// {
+// return true;
+// }
+
/*! \brief Test difference of two points. Nota bene: this method
** is concrete (and based on abstract::point::operator==).
**
Index: oln/core/abstract/size.hh
===================================================================
--- oln/core/abstract/size.hh (revision 102)
+++ oln/core/abstract/size.hh (working copy)
@@ -34,23 +34,27 @@
namespace abstract {
+
+ /// Abstract class for size classes.
+
template <typename E>
struct size : public mlc::any__best_memory<E>
{
+ // FIXME: remove?
unsigned long npoints() const
{
return this->exact().impl_npoints();
}
- template <typename Ep>
- bool operator==(const size<Ep>& rhs) const
+ template <typename S>
+ bool operator==(const size<S>& rhs) const
{
return this->exact().impl_eq(rhs.exact());
}
- template <typename Ep>
- bool operator!=(const size<Ep>& rhs) const
+ template <typename S>
+ bool operator!=(const size<S>& rhs) const
{
return ! this->operator==(rhs);
}
@@ -59,9 +63,15 @@
size() {}
};
+
} // end of namespace abstract
} // end of namespace oln
+
+# include <oln/core/any/size.hh>
+
+
+
#endif // ! OLENA_CORE_ABSTRACT_SIZE_HH
Index: oln/core/1d/size1d.hh
===================================================================
--- oln/core/1d/size1d.hh (revision 102)
+++ oln/core/1d/size1d.hh (working copy)
@@ -69,6 +69,11 @@
return (unsigned long)nindices_;
}
+ bool impl_eq(const any_size& rhs) const
+ {
+ return true;
+ }
+
bool impl_eq(const size1d& rhs) const
{
return this->nindices_ == rhs.nindices_;
Index: oln/core/2d/size2d.hh
===================================================================
--- oln/core/2d/size2d.hh (revision 102)
+++ oln/core/2d/size2d.hh (working copy)
@@ -73,6 +73,11 @@
return (unsigned long)nrows_ * (unsigned long)ncols_;
}
+ bool impl_eq(const any_size& rhs) const
+ {
+ return true;
+ }
+
bool impl_eq(const size2d& rhs) const
{
return this->nrows_ == rhs.nrows_ &&
Index: oln/core/3d/size3d.hh
===================================================================
--- oln/core/3d/size3d.hh (revision 102)
+++ oln/core/3d/size3d.hh (working copy)
@@ -80,6 +80,11 @@
(unsigned long)ncols_;
}
+ bool impl_eq(const any_size& rhs) const
+ {
+ return true;
+ }
+
bool impl_eq(const size3d& rhs) const
{
return this->nslices_ == rhs.nslices_ &&
Index: oln/basics2d.hh
===================================================================
--- oln/basics2d.hh (revision 102)
+++ oln/basics2d.hh (working copy)
@@ -35,6 +35,8 @@
# include <oln/core/2d/size2d.hh>
# include <oln/core/2d/point2d.hh>
# include <oln/core/2d/image2d.hh>
+# include <oln/core/2d/fwd_piter2d.hh>
+# include <oln/core/2d/bkd_piter2d.hh>
# include <oln/core/2d/fwd_witer2d.hh>
# include <oln/core/2d/window2d.hh>
# include <oln/core/2d/neighborhood2d.hh>
Index: oln/basics.hh
===================================================================
--- oln/basics.hh (revision 102)
+++ oln/basics.hh (working copy)
@@ -56,10 +56,13 @@
# include <oln/core/abstract/size.hh>
# include <oln/core/abstract/point.hh>
+# include <oln/core/any/all.hh>
# include <oln/core/abstract/images.hh>
# include <oln/core/abstract/entry.hh>
# include <oln/core/abstract/image_operator.hh>
+# include <oln/core/pw/all.hh>
+
# include <oln/core/abstract/piter.hh>
# include <oln/core/abstract/witer.hh>
// # include <oln/core/abstract/niter.hh>
@@ -68,4 +71,6 @@
# include <oln/core/abstract/neighborhood.hh>
+
+
#endif // ! OLENA_BASICS_HH
Index: oln/makefile.src
===================================================================
--- oln/makefile.src (revision 102)
+++ oln/makefile.src (working copy)
@@ -57,12 +57,25 @@
core/abstract/struct_elt.hh \
core/abstract/witer.hh \
core/accum.hh \
+ core/any/all.hh \
+ core/any/dpoint.hh \
+ core/any/point.hh \
+ core/any/size.hh \
core/apply.hh \
core/ch_value_type.hh \
core/compose.hh \
core/coord.hh \
core/gen/identity.hh \
core/properties.hh \
+ core/pw/abstract/function.hh \
+ core/pw/all.hh \
+ core/pw/cmp.hh \
+ core/pw/div.hh \
+ core/pw/image.hh \
+ core/pw/literal.hh \
+ core/pw/minus.hh \
+ core/pw/plus.hh \
+ core/pw/times.hh \
core/value_box.hh \
fancy/iota.hh \
fancy/print.hh \
oln::ch_value_type a été introduit avec ce patch, mais je ne suis
absolument pas sûr de la façon dont je l'ai écrite ; apparemment,
oln/core/properties.hh ne fournit pas autant de sucre pour les
propriétés-fonctions (ch_value_type, par ex.) que pour les propriétés
« usuelles ». Je suis preneur d'aides/explications ! :)
https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0
ChangeLog | 17 +++++
oln/core/abstract/image.hh | 1
oln/core/abstract/image_dimension.hh | 12 +++-
oln/core/apply.hh | 102 +++++++++++++++++++++++++++++++++++
oln/core/ch_value_type.hh | 47 ++++++++++++++++
oln/makefile.src | 25 +++++---
tests/core/tests/apply | 22 +++++++
7 files changed, 213 insertions(+), 13 deletions(-)
Index: olena/ChangeLog
from Roland Levillain <roland(a)lrde.epita.fr>
First version of oln::apply, for Adapatble Unary Functions.
* oln/core/apply.hh: New file.
* oln/core/ch_value_type.hh: New file.
* oln/makefile.src (OLN_DEP): Add core/apply.hh and
core/ch_value_type.hh.
* tests/core/tests/apply: New test.
* oln/makefile.src (OLN_DEP): Add
core/abstract/image_by_delegation.hh, core/abstract/image_like_.hh,
core/abstract/image_operator.hh and core/gen/identity.hh.
Remove core/abstract/image_identity.hh.
* oln/core/abstract/image.hh (echo): Print concrete_type.
* oln/core/abstract/image_dimension.hh: Add missing comments.
Index: olena/tests/core/tests/apply
--- olena/tests/core/tests/apply (revision 0)
+++ olena/tests/core/tests/apply (revision 0)
@@ -0,0 +1,22 @@
+ // -*- C++ -*-
+#include <functional>
+#include <oln/basics2d.hh>
+#include <oln/core/apply.hh>
+#include <oln/level/fill.hh>
+#include <oln/level/compare.hh>
+#include <ntg/int.hh>
+
+
+bool check()
+{
+ oln::image2d<ntg::int_u8> ima1(10, 10);
+ oln::level::fill(ima1, 10);
+ oln::image2d<ntg::int_u8> ima2(10, 10);
+ oln::level::fill(ima2, 30);
+ oln::image2d<ntg::int_u8> ima;
+ ima = oln::apply (std::bind2nd(std::multiplies<ntg::int_u8>(), 3), ima1);
+
+ if (oln::level::is_equal(ima, ima2))
+ return false;
+ return true;
+}
Index: olena/oln/core/abstract/image.hh
--- olena/oln/core/abstract/image.hh (revision 100)
+++ olena/oln/core/abstract/image.hh (working copy)
@@ -79,6 +79,7 @@
{
ostr << "props_of(" // FIXME: << typeid(oln::category::image).name()
<< ", " << typeid(type).name() << ") = {"
+ << " concrete_type = " << typeid(concrete_type).name()
<< " value_type = " << typeid(value_type).name()
<< " point_type = " << typeid(point_type).name()
<< " size_type = " << typeid(size_type).name()
Index: olena/oln/core/abstract/image_dimension.hh
--- olena/oln/core/abstract/image_dimension.hh (revision 100)
+++ olena/oln/core/abstract/image_dimension.hh (working copy)
@@ -40,12 +40,10 @@
*/
namespace abstract {
- /*! \class abstract::image2d<E>
+ /*! \class abstract::image1d<E>
**
** Class of 1d images.
*/
-
-
template <typename E>
struct image1d : public virtual image<E>
{
@@ -56,6 +54,10 @@
image1d() {}
};
+ /*! \class abstract::image2d<E>
+ **
+ ** Class of 2d images.
+ */
template <typename E>
struct image2d : public virtual image<E>
{
@@ -66,6 +68,10 @@
image2d() {}
};
+ /*! \class abstract::image3d<E>
+ **
+ ** Class of 3d images.
+ */
template <typename E>
struct image3d : public virtual image<E>
{
Index: olena/oln/core/apply.hh
--- olena/oln/core/apply.hh (revision 0)
+++ olena/oln/core/apply.hh (revision 0)
@@ -0,0 +1,102 @@
+// Copyright (C) 2001, 2002, 2003, 2004, 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_APPLY_HH
+# define OLENA_CORE_APPLY_HH
+
+# include <oln/basics.hh>
+# include <oln/core/abstract/op.hh>
+# include <oln/core/ch_value_type.hh>
+
+namespace oln {
+
+ // fwd decl
+ namespace impl {
+ template <typename AdaptableUnaryFun, typename I> struct apply_type;
+ }
+
+ // category
+ template <typename AdaptableUnaryFun, typename I>
+ struct set_category< impl::apply_type<AdaptableUnaryFun, I> >
+ {
+ typedef category::image ret;
+ };
+
+ // super_type
+ template <typename AdaptableUnaryFun, typename I>
+ struct set_super_type< impl::apply_type<AdaptableUnaryFun, I> >
+ {
+ typedef typename abstract::op<I, impl::apply_type<AdaptableUnaryFun, I> >
+ ret;
+ };
+
+ namespace impl {
+
+ template <typename AdaptableUnaryFun, typename I>
+ struct apply_type :
+ public abstract::op<
+ typename ch_value_type<
+ I, typename AdaptableUnaryFun::result_type>::ret,
+ apply_type<AdaptableUnaryFun, I> >
+ {
+ typedef typename
+ ch_value_type<I, typename AdaptableUnaryFun::result_type>::ret
+ output_type;
+
+ const AdaptableUnaryFun& f_;
+ box<const I> input_;
+
+ apply_type(const AdaptableUnaryFun& f, const abstract::image<I>& input) :
+ f_ (f),
+ input_ (input.exact ())
+ {
+ }
+
+ void impl_run()
+ {
+ output_type output(input_.size());
+ oln_type_of(I, fwd_piter) p(input_.size());
+ for_all(p)
+ output[p] = f_(input_[p]);
+ this->image_ = output;
+ }
+ };
+
+ } // end of namespace impl
+
+ template <class AdaptableUnaryFun, typename I>
+ impl::apply_type<AdaptableUnaryFun, I>
+ apply (const AdaptableUnaryFun& f, const abstract::image<I>& input)
+ {
+ impl::apply_type<AdaptableUnaryFun, I> tmp (f, input);
+ tmp.run ();
+ return tmp;
+ }
+
+} // end of namespace oln
+
+#endif // ! OLENA_CORE_APPLY_HH
Index: olena/oln/core/ch_value_type.hh
--- olena/oln/core/ch_value_type.hh (revision 0)
+++ olena/oln/core/ch_value_type.hh (revision 0)
@@ -0,0 +1,47 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_CH_VALUE_TYPE_HH
+# define OLENA_CORE_CH_VALUE_TYPE_HH
+
+# include <oln/core/properties.hh>
+
+namespace oln {
+
+ template<class I, class T = oln_type_of(I, value)>
+ struct ch_value_type
+ {
+ // FIXME: Use/extend oln/core/properties.hh mechanisms, instead of
+ // using mlc/properties.hh directly.
+ typedef typename
+ internal::get_props<category::image, I>::template ch_value_type<T>::ret
+ ret;
+ };
+
+} // end of namespace oln
+
+#endif // ! OLENA_CORE_CH_VALUE_TYPE_HH
Index: olena/oln/makefile.src
--- olena/oln/makefile.src (revision 100)
+++ olena/oln/makefile.src (working copy)
@@ -1,4 +1,4 @@
-##
+## -*- Makefile -*-
## List of headers in olena
## Include this file to have access to their name.
##
@@ -14,8 +14,6 @@
config/pconf.hh \
config/system.hh \
convert/value_to_point.hh \
- morpho/stat.hh \
- morpho/erosion.hh \
core/1d/array1d.hh \
core/1d/dpoint1d.hh \
core/1d/fwd_piter1d.hh \
@@ -26,39 +24,44 @@
core/2d/bkd_piter2d.hh \
core/2d/dpoint2d.hh \
core/2d/fwd_piter2d.hh \
+ core/2d/fwd_witer2d.hh \
core/2d/image2d.hh \
+ core/2d/neighborhood2d.hh \
core/2d/point2d.hh \
core/2d/size2d.hh \
- core/2d/neighborhood2d.hh \
- core/2d/fwd_witer2d.hh \
core/2d/window2d.hh \
core/3d/array3d.hh \
+ core/3d/dpoint3d.hh \
core/3d/fwd_piter3d.hh \
core/3d/image3d.hh \
core/3d/point3d.hh \
- core/3d/dpoint3d.hh \
core/3d/size3d.hh \
core/abstract/data_storage.hh \
core/abstract/dpoint.hh \
core/abstract/entry.hh \
core/abstract/image.hh \
+ core/abstract/image_by_delegation.hh \
core/abstract/image_constness.hh \
core/abstract/image_dimension.hh \
+ core/abstract/image_like_.hh \
+ core/abstract/image_operator.hh \
core/abstract/image_vectorialness.hh \
- core/abstract/image_identity.hh \
core/abstract/image_with_data.hh \
core/abstract/images.hh \
core/abstract/internal/image_impl.hh \
+ core/abstract/neighborhood.hh \
core/abstract/op.hh \
core/abstract/piter.hh \
- core/abstract/witer.hh \
core/abstract/point.hh \
core/abstract/size.hh \
- core/abstract/neighborhood.hh \
core/abstract/struct_elt.hh \
+ core/abstract/witer.hh \
core/accum.hh \
- core/coord.hh \
+ core/apply.hh \
+ core/ch_value_type.hh \
core/compose.hh \
+ core/coord.hh \
+ core/gen/identity.hh \
core/properties.hh \
core/value_box.hh \
fancy/iota.hh \
@@ -71,4 +74,6 @@
io/write_image_2d_pnm.hh \
level/compare.hh \
level/fill.hh \
+ morpho/erosion.hh \
+ morpho/stat.hh \
utils/clone.hh
Property changes on: olena/img
___________________________________________________________________
Name: svn:ignore
+ Makefile
Makefile.in
Property changes on: metalic/tests/array
___________________________________________________________________
Name: svn:ignore
+ Makefile
Makefile.in
