Index: ChangeLog
from Simon Odou <simon(a)lrde.epita.fr>
* tests/core/tests/neighborhood2d: New.
* oln/core/abstract/neighborhood.hh: New.
* oln/core/2d/neighborhood2d.hh: New.
* oln/core/properties.hh: Add `neighborhood' category.
oln/core/2d/neighborhood2d.hh | 133 ++++++++++++++++++++++++++
oln/core/abstract/neighborhood.hh | 192 ++++++++++++++++++++++++++++++++++++++
oln/core/properties.hh | 1
tests/core/tests/neighborhood2d | 17 +++
4 files changed, 343 insertions(+)
Index: tests/core/tests/neighborhood2d
--- tests/core/tests/neighborhood2d (revision 0)
+++ tests/core/tests/neighborhood2d (revision 0)
@@ -0,0 +1,17 @@
+#include <oln/core/2d/neighborhood2d.hh>
+
+#include <ntg/all.hh>
+
+#include <cassert>
+
+using namespace oln;
+using namespace ntg;
+
+int main()
+{
+ neighborhood2d w1;
+ w1.add(dpoint2d(0, 5));
+ w1.add(dpoint2d(0, 5));
+ neighborhood2d w2 = neighb_c8();
+ return 0;
+}
Index: oln/core/abstract/neighborhood.hh
--- oln/core/abstract/neighborhood.hh (revision 0)
+++ oln/core/abstract/neighborhood.hh (revision 0)
@@ -0,0 +1,192 @@
+// 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_NEIGHBORHOOD_HH
+# define OLENA_CORE_NEIGHBORHOOD_HH
+
+# include <mlc/types.hh>
+# include <oln/core/properties.hh>
+# include <oln/core/coord.hh>
+# include <oln/core/abstract/dpoint.hh>
+# include <vector>
+# include <utility>
+# include <iostream>
+
+namespace oln {
+
+ // fwd decl
+ namespace abstract {
+ template<class Exact>
+ struct neighborhood;
+ }
+
+ // category
+ template <typename E>
+ struct set_category< abstract::neighborhood<E> >
+ {
+ typedef category::neighborhood ret;
+ };
+
+ /// properties of any type in category::neighborhood
+
+ template <typename type>
+ struct props_of <category::neighborhood, type>
+ {
+ typedef mlc::true_type user_defined_;
+
+ mlc_decl_prop(category::neighborhood, dpoint_type);
+ mlc_decl_prop(category::neighborhood, size_type);
+
+ static void echo(std::ostream& ostr)
+ {
+ ostr << "props_of( category::neighborhood, "
+ << typeid(type).name() << ") = {"
+ << " size_type = " << typeid(size_type).name() <<
"," << std::endl
+ << " dpoint_type = " << typeid(dpoint_type).name() <<
" }" << std::endl;
+ }
+
+ };
+
+ mlc_register_prop(category::neighborhood, dpoint_type);
+ mlc_register_prop(category::neighborhood, size_type);
+
+
+ namespace abstract {
+
+ /*!
+ ** Structuring elements (set of dpoints).
+ **
+ ** This abstract class defines several virtual methods for its
+ ** subclasses. Its goal is to deal with a set of 'move' points.
+ */
+ template<class E>
+ class neighborhood : public mlc::any__best_memory<E>
+ {
+
+ public:
+
+ typedef oln_type_of(E, dpoint) dpoint_type;
+
+ typedef E exact_type;
+
+ static std::string
+ name()
+ {
+ return std::string("neighborhood<") + exact_type::name() +
">";
+ }
+
+ bool
+ has(const abstract::dpoint<dpoint_type>& dp) const
+ {
+ return this->exact().impl_has(dp.exact());
+ }
+
+ unsigned
+ card() const
+ {
+ return this->exact().impl_card();
+ }
+
+ exact_type&
+ add(const dpoint_type& dp)
+ {
+ return this->exact().impl_add(dp);
+ }
+
+ dpoint_type
+ dp(unsigned i) const
+ {
+ return this->exact().impl_at(i);
+ }
+
+ const dpoint_type
+ operator[](unsigned i) const
+ {
+ return this->exact().impl_at(i);
+ }
+
+ protected:
+
+ bool
+ impl_has(const dpoint_type& dp) const
+ {
+ return std::find(dp_.begin(), dp_.end(), dp) != dp_.end();
+ }
+
+ exact_type&
+ impl_add(const dpoint_type& dp)
+ {
+ if (!(impl_has(dp)))
+ {
+ this->dp_.push_back(dp);
+ this->dp_.push_back(-dp);
+ }
+ return this->exact();
+ }
+
+ unsigned
+ impl_card() const
+ {
+ return dp_.size();
+ }
+
+ const dpoint_type
+ impl_at(unsigned i) const
+ {
+ precondition(i < this->card());
+ return dp_[i];
+ }
+
+ neighborhood() : dp_()
+ {};
+
+ neighborhood(unsigned size) : dp_()
+ {
+ dp_.reserve(size);
+ };
+
+ std::vector<dpoint_type> dp_;
+
+ };
+ } // end of abstract
+
+} // end of oln
+
+template<class E>
+std::ostream&
+operator<<(std::ostream& o, const oln::abstract::neighborhood<E>&
se)
+{
+ unsigned c = se.card();
+ o << "[";
+ for (unsigned i = 0; i < c; ++i)
+ o << se.dp(i);
+ o << "]";
+ return o;
+}
+
+
+#endif // ! OLENA_CORE_NEIGHBORHOOD_HH
Index: oln/core/2d/neighborhood2d.hh
--- oln/core/2d/neighborhood2d.hh (revision 0)
+++ oln/core/2d/neighborhood2d.hh (revision 0)
@@ -0,0 +1,133 @@
+// 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_NEIGHBORHOOD2D_HH
+# define OLENA_CORE_NEIGHBORHOOD2D_HH
+
+# include <oln/core/2d/dpoint2d.hh>
+# include <oln/core/2d/size2d.hh>
+# include <oln/core/coord.hh>
+# include <oln/core/abstract/struct_elt.hh>
+
+namespace oln {
+
+ class neighborhood2d; // forward declaration
+
+ // category
+ template <>
+ struct set_category< neighborhood2d > { typedef category::struct_elt ret; };
+
+ // super_type
+ template <>
+ struct set_super_type< neighborhood2d >
+ {
+ typedef abstract::struct_elt< neighborhood2d > ret;
+ };
+
+ template <>
+ struct set_props< category::struct_elt, neighborhood2d >
+ : public props_of<category::struct_elt>
+ {
+ typedef dpoint2d dpoint_type;
+ typedef size2d size_type;
+ };
+
+ class neighborhood2d : public abstract::struct_elt<neighborhood2d>
+ {
+
+ public:
+
+ typedef abstract::struct_elt<neighborhood2d> super_type;
+
+ /*!
+ ** \brief Construct a neighborhood of 2 dimensions.
+ */
+ neighborhood2d() : super_type()
+ {}
+
+ /*!
+ ** \brief Construct a neighborhood of 2 dimensions.
+ ** \arg size The number of element.
+ */
+ neighborhood2d(unsigned size) : super_type(size)
+ {}
+
+ /*!
+ ** \brief Construct a neighborhood of 2 dimensions from several points.
+ ** \arg n The number of element.
+ ** \arg crd The coordinates of the elements
+ */
+ neighborhood2d(unsigned n, const coord_t crd[]) : super_type(n)
+ {
+ for (unsigned i = 0; i < 2 * n; i += 2)
+ this->add(dpoint_type(crd[i], crd[i+1]));
+ }
+
+ neighborhood2d&
+ add(const dpoint_type& dp)
+ {
+ return this->exact().impl_add(dp);
+ }
+
+ neighborhood2d&
+ add(coord_t row, coord_t col)
+ {
+ dpoint_type dp(row, col);
+ return add(dp);
+ }
+
+
+ /// Return the name of the type.
+ static std::string
+ name()
+ {
+ return std::string("neighborhood2d");
+ }
+
+ protected:
+
+ };
+
+ inline const neighborhood2d&
+ neighb_c4()
+ {
+ static const coord_t crd[] = { 0,1, 1,0 };
+ static const neighborhood2d neighb(2, crd);
+ return neighb;
+ }
+
+ inline const neighborhood2d&
+ neighb_c8()
+ {
+ static const coord_t crd[] = { 0,1, 1,1, 1,0, 1,-1 };
+ static const neighborhood2d neighb(4, crd);
+ return neighb;
+ }
+
+} // end of oln
+
+#endif // OLENA_CORE_NEIGHBORHOOD2D_HH
Index: oln/core/properties.hh
--- oln/core/properties.hh (revision 74)
+++ oln/core/properties.hh (working copy)
@@ -42,6 +42,7 @@
struct data_storage;
struct image;
struct struct_elt;
+ struct neighborhood;
struct point;
struct size;
struct piter;