2005-04-04 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
* oln/core/pw/abstract/binary_function.hh: Likewise.
* oln/arith/ops.hh: Likewise.
* oln/core/pw/times.hh: Handle better point_type and size_type.
* oln/core/pw/div.hh: Likewise.
* oln/core/pw/plus.hh: Likewise.
* oln/core/pw/minus.hh: Likewise.
* oln/core/pw/image.hh: Cosmetic change.
* oln/core/pw/abstract/function.hh: Move macros to...
* oln/core/pw/macros.hh: ... this new file.
* oln/core/pw/literal.hh: Likewise.
* oln/core/any/dpoint.hh: Add fwd decls.
* oln/core/abstract/point.hh
(oln_point_type_from_2): New macro.
(nth): New method.
* oln/core/abstract/witer.hh: Add include to pass sanity check.
* oln/core/abstract/dpoint.hh: Likewise.
* oln/core/abstract/size.hh
(oln_size_type_from_2): New macro.
* oln/core/1d/dpoint1d.hh: Add inheritance.
(impl_nth): New method.
* oln/core/2d/dpoint2d.hh: Likewise.
* oln/core/3d/dpoint3d.hh: Likewise.
* oln/core/1d/point1d.hh (impl_nth): New method.
* oln/core/2d/point2d.hh: Likewise.
* oln/core/3d/point3d.hh: Likewise.
Index: oln/core/pw/times.hh
===================================================================
--- oln/core/pw/times.hh (revision 107)
+++ oln/core/pw/times.hh (working copy)
@@ -28,7 +28,7 @@
#ifndef OLENA_CORE_PW_TIMES_HH
# define OLENA_CORE_PW_TIMES_HH
-# include <oln/core/pw/abstract/function.hh>
+# include <oln/core/pw/abstract/binary_function.hh>
# include <oln/core/pw/literal.hh>
# include <ntg/all.hh>
@@ -44,13 +44,16 @@
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;
+ typedef abstract::binary_function<L, R, times<L, R> > super_type;
+ typedef typename traits<super_type>::point_type point_type;
+ typedef typename traits<super_type>::size_type size_type;
+ typedef ntg_return_type(times,
+ oln_pw_value_type(L),
+ oln_pw_value_type(R)) value_type;
};
template <typename L, typename R>
- struct times : public abstract::function < times<L, R> >
+ struct times : public abstract::binary_function < L, R, times<L, R> >
{
typedef times<L, R> self_type;
@@ -58,42 +61,28 @@
typedef oln_pw_value_type(self_type) value_type;
typedef oln_pw_size_type(self_type) size_type;
- L left;
- R right;
+ typedef abstract::binary_function<L, R, self_type> super_type;
times(const abstract::function<L>& left,
const abstract::function<R>& right) :
- left(left.exact()),
- right(right.exact())
+ super_type(left, right)
{
}
- 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>
Index: oln/core/pw/image.hh
===================================================================
--- oln/core/pw/image.hh (revision 107)
+++ oln/core/pw/image.hh (working copy)
@@ -128,7 +128,7 @@
typedef mlc::no_type delegated_type;
- // FIXME: we do not know if it is 2d...
+ // FIXME: AWFUL 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;
Index: oln/core/pw/div.hh
===================================================================
--- oln/core/pw/div.hh (revision 107)
+++ oln/core/pw/div.hh (working copy)
@@ -28,7 +28,7 @@
#ifndef OLENA_CORE_PW_DIV_HH
# define OLENA_CORE_PW_DIV_HH
-# include <oln/core/pw/abstract/function.hh>
+# include <oln/core/pw/abstract/binary_function.hh>
# include <oln/core/pw/literal.hh>
# include <ntg/all.hh>
@@ -44,13 +44,16 @@
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;
+ typedef abstract::binary_function<L, R, div<L, R> > super_type;
+ typedef typename traits<super_type>::point_type point_type;
+ typedef typename traits<super_type>::size_type size_type;
+ typedef ntg_return_type(div,
+ oln_pw_value_type(L),
+ oln_pw_value_type(R)) value_type;
};
template <typename L, typename R>
- struct div : public abstract::function < div<L, R> >
+ struct div : public abstract::binary_function < L, R, div<L, R> >
{
typedef div<L, R> self_type;
@@ -58,43 +61,29 @@
typedef oln_pw_value_type(self_type) value_type;
typedef oln_pw_size_type(self_type) size_type;
- L left;
- R right;
+ typedef abstract::binary_function<L, R, self_type> super_type;
div(const abstract::function<L>& left,
- const abstract::function<R>& right) :
- left(left.exact()),
- right(right.exact())
+ const abstract::function<R>& right) :
+ super_type(left, right)
{
}
- 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>
@@ -107,4 +96,9 @@
}
+oln_pw_operator(div, /, int)
+oln_pw_operator(div, /, float)
+oln_pw_operator(div, /, double)
+
+
#endif // ! OLENA_CORE_PW_DIV_HH
Index: oln/core/pw/plus.hh
===================================================================
--- oln/core/pw/plus.hh (revision 107)
+++ oln/core/pw/plus.hh (working copy)
@@ -28,7 +28,7 @@
#ifndef OLENA_CORE_PW_PLUS_HH
# define OLENA_CORE_PW_PLUS_HH
-# include <oln/core/pw/abstract/function.hh>
+# include <oln/core/pw/abstract/binary_function.hh>
# include <oln/core/pw/literal.hh>
# include <ntg/all.hh>
@@ -44,13 +44,16 @@
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;
+ typedef abstract::binary_function<L, R, plus<L, R> > super_type;
+ typedef typename traits<super_type>::point_type point_type;
+ typedef typename traits<super_type>::size_type size_type;
+ typedef ntg_return_type(plus,
+ oln_pw_value_type(L),
+ oln_pw_value_type(R)) value_type;
};
template <typename L, typename R>
- struct plus : public abstract::function < plus<L, R> >
+ struct plus : public abstract::binary_function < L, R, plus<L, R> >
{
typedef plus<L, R> self_type;
@@ -58,42 +61,28 @@
typedef oln_pw_value_type(self_type) value_type;
typedef oln_pw_size_type(self_type) size_type;
- L left;
- R right;
+ typedef abstract::binary_function<L, R, self_type> super_type;
plus(const abstract::function<L>& left,
const abstract::function<R>& right) :
- left(left.exact()),
- right(right.exact())
+ super_type(left, right)
{
}
- 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>
@@ -109,20 +98,5 @@
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/macros.hh
===================================================================
--- oln/core/pw/macros.hh (revision 0)
+++ oln/core/pw/macros.hh (revision 0)
@@ -0,0 +1,57 @@
+// 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_MACROS_HH
+# define OLENA_CORE_PW_MACROS_HH
+
+
+
+# define oln_pw_point_type(F) typename oln::pw::traits<F>::point_type
+# define oln_pw_value_type(F) typename oln::pw::traits<F>::value_type
+# define oln_pw_size_type(F) typename oln::pw::traits<F>::size_type
+
+
+// FIXME: rename
+# 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_MACROS_HH
Index: oln/core/pw/abstract/function.hh
===================================================================
--- oln/core/pw/abstract/function.hh (revision 107)
+++ oln/core/pw/abstract/function.hh (working copy)
@@ -30,13 +30,9 @@
# include <mlc/any.hh>
# include <oln/core/properties.hh>
+# include <oln/core/pw/macros.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 {
@@ -91,7 +87,7 @@
return this->exact().impl_hold_large(p);
}
-// minus< literal<value_type>, E> operator-() const;
+ minus< literal<value_type>, E> operator-() const;
protected:
function() {}
@@ -118,10 +114,11 @@
meth adr = &E::impl_hold_large;
adr = 0;
}
-
}
+
};
+
} // end of namespace oln::pw::abstract
} // end of namespace oln::pw
Index: oln/core/pw/abstract/binary_function.hh
===================================================================
--- oln/core/pw/abstract/binary_function.hh (revision 0)
+++ oln/core/pw/abstract/binary_function.hh (revision 0)
@@ -0,0 +1,150 @@
+// 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_BINARY_FUNCTION_HH
+# define OLENA_CORE_PW_ABSTRACT_BINARY_FUNCTION_HH
+
+# include <oln/core/pw/abstract/function.hh>
+# include <oln/core/abstract/point.hh>
+# include <oln/core/abstract/size.hh>
+
+
+
+namespace oln {
+
+
+ namespace pw { // means "point-wise"
+
+
+ // fwd decls
+ namespace abstract {
+ template <typename L, typename R, typename E> struct binary_function;
+ }
+
+
+ template <typename L, typename R, typename E>
+ struct traits < abstract::binary_function<L, R, E> >
+ {
+ typedef oln_pw_point_type(L) left_point_type;
+ typedef oln_pw_point_type(R) right_point_type;
+
+ typedef oln_point_type_from_2(left_point_type, right_point_type) point_type;
+
+ typedef oln_pw_size_type(L) left_size_type;
+ typedef oln_pw_size_type(R) right_size_type;
+
+ typedef oln_size_type_from_2(left_size_type, right_size_type) size_type;
+ };
+
+
+ namespace abstract {
+
+ namespace internal {
+
+ template <typename T1, typename T2>
+ struct binary_function_helper;
+
+ template <typename T>
+ struct binary_function_helper < T, T > {
+ template <typename L, typename R>
+ static const L& select(const L& l, R) {
+ return l;
+ }
+ };
+
+ template <typename S>
+ struct binary_function_helper < S, any_size > {
+ template <typename L, typename R>
+ static const L& select(const L& l, R) {
+ return l;
+ }
+ };
+
+ template <typename S>
+ struct binary_function_helper < any_size, S > {
+ template <typename L, typename R>
+ static const R& select(L, const R& r) {
+ return r;
+ }
+ };
+
+ } // end of namespace oln::pw::abstract::internal
+
+
+ template <typename L, typename R, typename E>
+ struct binary_function : public function<E>
+ {
+ typedef L left_type;
+ typedef R right_type;
+
+ L left;
+ R right;
+
+ binary_function(const abstract::function<L>& left,
+ const abstract::function<R>& right) :
+ left(left.exact()),
+ right(right.exact())
+ {
+ }
+
+ typedef abstract::binary_function<L, R, E> self_type;
+ typedef oln_pw_point_type(self_type) point_type;
+ typedef oln_pw_size_type(self_type) size_type;
+
+ typedef internal::binary_function_helper<oln_pw_size_type(L),
+ oln_pw_size_type(R) > _helper_type;
+
+ const size_type& impl_size() const
+ {
+ return _helper_type::select(this->left, this->right).size();
+ }
+
+ bool impl_hold(const point_type& p) const
+ {
+ return _helper_type::select(this->left, this->right).hold(p);
+ }
+
+ bool impl_hold_large(const point_type& p) const
+ {
+ return _helper_type::select(this->left, this->right).hold_large(p);
+ }
+
+ protected:
+ binary_function() {}
+
+ };
+
+
+ } // end of namespace oln::pw::abstract
+
+ } // end of namespace oln::pw
+
+} // end of namespace oln
+
+
+
+#endif // ! OLENA_CORE_PW_ABSTRACT_BINARY_FUNCTION_HH
Index: oln/core/pw/minus.hh
===================================================================
--- oln/core/pw/minus.hh (revision 107)
+++ oln/core/pw/minus.hh (working copy)
@@ -28,7 +28,7 @@
#ifndef OLENA_CORE_PW_MINUS_HH
# define OLENA_CORE_PW_MINUS_HH
-# include <oln/core/pw/abstract/function.hh>
+# include <oln/core/pw/abstract/binary_function.hh>
# include <oln/core/pw/literal.hh>
# include <ntg/all.hh>
@@ -44,13 +44,16 @@
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;
+ typedef abstract::binary_function<L, R, minus<L, R> > super_type;
+ typedef typename traits<super_type>::point_type point_type;
+ typedef typename traits<super_type>::size_type size_type;
+ typedef ntg_return_type(minus,
+ oln_pw_value_type(L),
+ oln_pw_value_type(R)) value_type;
};
template <typename L, typename R>
- struct minus : public abstract::function < minus<L, R> >
+ struct minus : public abstract::binary_function < L, R, minus<L, R> >
{
typedef minus<L, R> self_type;
@@ -58,52 +61,37 @@
typedef oln_pw_value_type(self_type) value_type;
typedef oln_pw_size_type(self_type) size_type;
- L left;
- R right;
+ typedef abstract::binary_function<L, R, self_type > super_type;
minus(const abstract::function<L>& left,
- const abstract::function<R>& right) :
- left(left.exact()),
- right(right.exact())
+ const abstract::function<R>& right) :
+ super_type(left, right)
{
}
- 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 {
+ 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;
-// }
+ template <typename E>
+ minus< literal<oln_pw_value_type(E)>, E>
+ function<E>::operator-() const
+ {
+ typedef literal<oln_pw_value_type(E)> lit_type;
+ static const lit_type lhs = 0;
+ minus< lit_type, E> tmp(lhs, this->exact());
+ return tmp;
+ }
-// }
+ }
} // end of namespace oln::pw
@@ -122,6 +110,9 @@
return tmp;
}
+oln_pw_operator(minus, -, int)
+oln_pw_operator(minus, -, float)
+oln_pw_operator(minus, -, double)
#endif // ! OLENA_CORE_PW_MINUS_HH
Index: oln/core/pw/literal.hh
===================================================================
--- oln/core/pw/literal.hh (revision 107)
+++ oln/core/pw/literal.hh (working copy)
@@ -99,22 +99,6 @@
} // 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/any/dpoint.hh
===================================================================
--- oln/core/any/dpoint.hh (revision 107)
+++ oln/core/any/dpoint.hh (working copy)
@@ -28,6 +28,7 @@
#ifndef OLENA_CORE_ANY_DPOINT_HH
# define OLENA_CORE_ANY_DPOINT_HH
+# include <iostream>
# include <oln/core/abstract/dpoint.hh>
# include <oln/core/any/point.hh>
@@ -35,6 +36,13 @@
namespace oln {
+ // fwd decls
+ struct any_point;
+ namespace abstract {
+ template <typename P> struct point;
+ }
+
+
struct any_dpoint : public abstract::dpoint < any_dpoint >
{
Index: oln/core/abstract/point.hh
===================================================================
--- oln/core/abstract/point.hh (revision 107)
+++ oln/core/abstract/point.hh (working copy)
@@ -29,21 +29,30 @@
# define OLENA_CORE_ABSTRACT_POINT_HH
# include <mlc/any.hh>
-# include <mlc/bool.hh>
-
+# include <oln/core/coord.hh>
# include <oln/core/properties.hh>
+# include <mlc/properties.hh> // FIXME: for better 'meta if' and 'meta
eq'
+// fwd decl
+namespace oln {
+ struct any_point;
+}
+
+
+
+# define oln_point_type_from_2(P1, P2) \
+mlc_internal_if( mlc_internal_eq( P2, oln::any_point ), P1, P2 )
+
+
+
/*! \namespace oln
** \brief oln namespace.
*/
namespace oln {
- // fwd decls
-
- struct any_point;
-
+ // fwd decl
namespace abstract {
template <typename E> struct point;
}
@@ -93,9 +102,7 @@
typedef E exact_type;
-
/// Conversion to any_point (implemented in oln/core/any/point.hh).
-
operator any_point() const;
@@ -139,6 +146,12 @@
return this->exact().impl_minus(rhs);
}
+ coord_t nth(unsigned i) const
+ {
+ // FIXME: add precondition
+ return this->exact().impl_nth(i);
+ }
+
protected:
point() {}
Index: oln/core/abstract/witer.hh
===================================================================
--- oln/core/abstract/witer.hh (revision 107)
+++ oln/core/abstract/witer.hh (working copy)
@@ -30,7 +30,7 @@
# include <mlc/any.hh>
# include <mlc/types.hh>
-
+# include <oln/core/coord.hh>
# include <oln/core/properties.hh>
# include <string>
Index: oln/core/abstract/dpoint.hh
===================================================================
--- oln/core/abstract/dpoint.hh (revision 107)
+++ oln/core/abstract/dpoint.hh (working copy)
@@ -28,8 +28,10 @@
#ifndef OLENA_CORE_ABSTRACT_DPOINT_HH
# define OLENA_CORE_ABSTRACT_DPOINT_HH
+# include <oln/core/coord.hh>
# include <mlc/any.hh>
+
/*! \namespace oln
** \brief oln namespace.
*/
@@ -67,6 +69,7 @@
coord_t nth(unsigned i) const
{
+ // FIXME: add precondition
return this->exact().impl_nth(i);
}
Index: oln/core/abstract/size.hh
===================================================================
--- oln/core/abstract/size.hh (revision 107)
+++ oln/core/abstract/size.hh (working copy)
@@ -29,9 +29,22 @@
# define OLENA_CORE_ABSTRACT_SIZE_HH
# include <mlc/any.hh>
+# include <mlc/properties.hh> // FIXME: for better 'meta if' and 'meta
eq'
+
+// fwd decl
namespace oln {
+ struct any_size;
+}
+
+# define oln_size_type_from_2(S1, S2) \
+mlc_internal_if( mlc_internal_eq( S2, oln::any_size ), S1, S2 )
+
+
+
+namespace oln {
+
namespace abstract {
@@ -70,8 +83,4 @@
-# include <oln/core/any/size.hh>
-
-
-
#endif // ! OLENA_CORE_ABSTRACT_SIZE_HH
Index: oln/core/1d/dpoint1d.hh
===================================================================
--- oln/core/1d/dpoint1d.hh (revision 107)
+++ oln/core/1d/dpoint1d.hh (working copy)
@@ -29,22 +29,15 @@
# define OLENA_CORE_1D_DPOINT1D_HH
# include <ostream>
-
# include <oln/core/coord.hh>
+# include <oln/core/abstract/dpoint.hh>
-// FIXME: there's an assumption here: we do not need inheritance for
-// dpoints. so abstract::dpoint does not exist...
-// FIXME: doc!
-
-// FIXME: test that coords are defined
-
-
namespace oln {
struct point1d;
- struct dpoint1d
+ struct dpoint1d : public abstract::dpoint < dpoint1d >
{
dpoint1d()
{
@@ -95,6 +88,13 @@
const coord_t index() const { return index_; }
coord_t& index() { return index_; }
+ coord_t impl_nth(unsigned i) const
+ {
+ // FIXME: remove when add in abstract::point
+ precondition(i == 0);
+ return index_;
+ }
+
protected:
coord_t index_;
};
Index: oln/core/1d/point1d.hh
===================================================================
--- oln/core/1d/point1d.hh (revision 107)
+++ oln/core/1d/point1d.hh (working copy)
@@ -103,6 +103,13 @@
return this->index_ == rhs.index_;
}
+ coord_t impl_nth(unsigned i) const
+ {
+ // FIXME: remove when add in abstract::point
+ precondition(i == 0);
+ return index_;
+ }
+
protected:
coord_t index_;
Index: oln/core/2d/dpoint2d.hh
===================================================================
--- oln/core/2d/dpoint2d.hh (revision 107)
+++ oln/core/2d/dpoint2d.hh (working copy)
@@ -29,19 +29,15 @@
# define OLENA_CORE_2D_DPOINT2D_HH
# include <iostream>
-
# include <oln/core/coord.hh>
+# include <oln/core/abstract/dpoint.hh>
-// FIXME: there's an assumption here: we do not need inheritance for
-// dpoints. so abstract::dpoint does not exist...
-// FIXME: doc!
-
namespace oln {
struct point2d;
- struct dpoint2d
+ struct dpoint2d : public abstract::dpoint < dpoint2d >
{
dpoint2d()
{
@@ -108,8 +104,8 @@
coord_t& row() { return row_; }
coord_t& col() { return col_; }
- //FIXME : name it impl_nth when dpoint2d derives from abstract::dpoint
- coord_t& nth(unsigned i)
+
+ coord_t& impl_nth(unsigned i)
{
assert(i < 2);
Index: oln/core/2d/point2d.hh
===================================================================
--- oln/core/2d/point2d.hh (revision 107)
+++ oln/core/2d/point2d.hh (working copy)
@@ -107,6 +107,14 @@
return this->row_ == rhs.row_ && this->col_ == rhs.col_;
}
+ coord_t impl_nth(unsigned i) const
+ {
+ // FIXME: remove when add in abstract::point
+ precondition(i < 2);
+ // FIXME: replace by meta-prog when a meta-vec is attribute
+ return i == 0 ? row_ : col_;
+ }
+
protected:
coord_t row_, col_;
Index: oln/core/3d/dpoint3d.hh
===================================================================
--- oln/core/3d/dpoint3d.hh (revision 107)
+++ oln/core/3d/dpoint3d.hh (working copy)
@@ -29,19 +29,15 @@
# define OLENA_CORE_3D_DPOINT3D_HH
# include <iostream>
-
# include <oln/core/coord.hh>
+# include <oln/core/abstract/dpoint.hh>
-// FIXME: there's an assumption here: we do not need inheritance for
-// dpoints. so abstract::dpoint does not exist...
-// FIXME: doc!
-
namespace oln {
struct point3d;
- struct dpoint3d
+ struct dpoint3d : public abstract::dpoint < dpoint3d >
{
dpoint3d()
{
@@ -103,6 +99,23 @@
coord_t& col() { return col_; }
coord_t& slice() { return slice_; }
+ coord_t impl_nth(unsigned i) const
+ {
+ // FIXME: remove when add in abstract::point
+ precondition(i < 3);
+ // FIXME: replace by meta-prog when a meta-vec is attribute
+ switch (i) {
+ case 0:
+ return slice_;
+ case 1:
+ return row_;
+ case 2:
+ return col_;
+ }
+ postcondition(0);
+ return 0;
+ }
+
protected:
coord_t slice_, row_, col_;
};
Index: oln/core/3d/point3d.hh
===================================================================
--- oln/core/3d/point3d.hh (revision 107)
+++ oln/core/3d/point3d.hh (working copy)
@@ -103,6 +103,23 @@
coord_t& row() { return row_; }
coord_t& col() { return col_; }
+ coord_t impl_nth(unsigned i) const
+ {
+ // FIXME: remove when add in abstract::point
+ precondition(i < 3);
+ // FIXME: replace by meta-prog when a meta-vec is attribute
+ switch (i) {
+ case 0:
+ return slice_;
+ case 1:
+ return row_;
+ case 2:
+ return col_;
+ }
+ postcondition(0);
+ return 0;
+ }
+
protected:
coord_t slice_, row_, col_;
};
Index: oln/makefile.src
===================================================================
--- oln/makefile.src (revision 107)
+++ oln/makefile.src (working copy)
@@ -7,6 +7,7 @@
all.hh \
arith/max.hh \
arith/min.hh \
+ arith/ops.hh \
basics.hh \
basics1d.hh \
basics2d.hh \
@@ -63,17 +64,20 @@
core/any/point.hh \
core/any/size.hh \
core/apply.hh \
+ core/box.hh \
core/ch_value_type.hh \
core/compose.hh \
core/coord.hh \
core/gen/identity.hh \
core/properties.hh \
+ core/pw/abstract/binary_function.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/macros.hh \
core/pw/minus.hh \
core/pw/plus.hh \
core/pw/times.hh \
@@ -88,9 +92,13 @@
io/write_image_2d_pnm.hh \
level/compare.hh \
level/fill.hh \
+ morpho/cc_tarjan.hh \
morpho/dilation.hh \
morpho/erosion.hh \
morpho/reconstruction.hh \
morpho/splitse.hh \
morpho/stat.hh \
- utils/clone.hh
+ utils/buffer.hh \
+ utils/clone.hh \
+ utils/key.hh \
+ utils/md5.hh
Index: oln/arith/ops.hh
===================================================================
--- oln/arith/ops.hh (revision 0)
+++ oln/arith/ops.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_ARITH_OPS_HH
+# define OLENA_ARITH_OPS_HH
+
+# include <oln/core/abstract/image.hh>
+# include <oln/core/pw/all.hh>
+
+
+/// Operator + between 2 images.
+
+template <typename L, typename R>
+oln::image_from_pw< oln::pw::plus< oln::pw::image<L>,
+ oln::pw::image<R> > >
+operator + (const oln::abstract::image<L>& lhs,
+ const oln::abstract::image<R>& rhs)
+{
+ return oln::for_all_p(oln::p_value(lhs) + oln::p_value(rhs));
+}
+
+
+/// Operator - between 2 images.
+
+template <typename L, typename R>
+oln::image_from_pw< oln::pw::minus< oln::pw::image<L>,
+ oln::pw::image<R> > >
+operator - (const oln::abstract::image<L>& lhs,
+ const oln::abstract::image<R>& rhs)
+{
+ return oln::for_all_p(oln::p_value(lhs) - oln::p_value(rhs));
+}
+
+
+/// Operator - (unary) on image.
+
+template <typename R>
+oln::image_from_pw< oln::pw::minus< oln::pw::literal< oln_pw_value_type(R)
>,
+ oln::pw::image<R> > >
+operator - (const oln::abstract::image<R>& rhs)
+{
+ return oln::for_all_p( - oln::p_value(rhs));
+}
+
+
+/// Operator * between 2 images.
+
+template <typename L, typename R>
+oln::image_from_pw< oln::pw::times< oln::pw::image<L>,
+ oln::pw::image<R> > >
+operator * (const oln::abstract::image<L>& lhs,
+ const oln::abstract::image<R>& rhs)
+{
+ return oln::for_all_p(oln::p_value(lhs) * oln::p_value(rhs));
+}
+
+
+/// Operator / between 2 images.
+
+template <typename L, typename R>
+oln::image_from_pw< oln::pw::div< oln::pw::image<L>,
+ oln::pw::image<R> > >
+operator / (const oln::abstract::image<L>& lhs,
+ const oln::abstract::image<R>& rhs)
+{
+ return oln::for_all_p(oln::p_value(lhs) / oln::p_value(rhs));
+}
+
+
+
+# define oln_decl_binary_operator(NAME, SYMBOL, TYPE) \
+template <typename L> \
+oln::image_from_pw< oln::pw::NAME< oln::pw::image<L>, \
+ oln::pw::literal<TYPE> > > \
+operator SYMBOL (const oln::abstract::image<L>& lhs, \
+ TYPE value) \
+{ \
+ return oln::for_all_p(oln::p_value(lhs) SYMBOL oln::p_lit(value)); \
+} \
+template <typename R> \
+oln::image_from_pw< oln::pw::NAME< oln::pw::literal<TYPE>, \
+ oln::pw::image<R> > > \
+operator SYMBOL (TYPE value, \
+ const oln::abstract::image<R>& rhs) \
+{ \
+ return oln::for_all_p(oln::p_lit(value) SYMBOL oln::p_value(rhs)); \
+}
+
+
+
+oln_decl_binary_operator(plus, +, int)
+oln_decl_binary_operator(plus, +, float)
+oln_decl_binary_operator(plus, +, double)
+
+oln_decl_binary_operator(minus, -, int)
+oln_decl_binary_operator(minus, -, float)
+oln_decl_binary_operator(minus, -, double)
+
+oln_decl_binary_operator(times, *, int)
+oln_decl_binary_operator(times, *, float)
+oln_decl_binary_operator(times, *, double)
+
+oln_decl_binary_operator(div, /, int)
+oln_decl_binary_operator(div, /, float)
+oln_decl_binary_operator(div, /, double)
+
+
+
+#endif // ! OLENA_ARITH_OPS_HH