Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

proto-1.0 80: Add vectorialness for images in abstract hierarchy

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/core/tests/image_vectorialness: New. * tests/core/tests/readwrite_image: Add vectorialness property. * oln/makefile.src: Add new files. * oln/core/abstract/image.hh: Register `vectorialness' property. * oln/core/abstract/image_vectorialness.hh: New. Add vectorialness abstraction. * oln/core/abstract/entry.hh: Add inheritance to new branch `vectorialness'. * oln/core/1d/image1d.hh: Add `vectorialness' property. * oln/core/2d/image2d.hh: Likewise. * oln/core/3d/image3d.hh: Likewise. * oln/core/properties.hh: Declare `vectorialness' property.. oln/core/1d/image1d.hh | 3 oln/core/2d/image2d.hh | 3 oln/core/3d/image3d.hh | 3 oln/core/abstract/entry.hh | 4 oln/core/abstract/image.hh | 3 oln/core/abstract/image_vectorialness.hh | 126 +++++++++++++++++++++++++++++++ oln/core/properties.hh | 1 oln/makefile.src | 1 tests/core/tests/image_vectorialness | 26 ++++++ tests/core/tests/readwrite_image | 1 10 files changed, 170 insertions(+), 1 deletion(-) Index: tests/core/tests/image_vectorialness --- tests/core/tests/image_vectorialness (revision 0) +++ tests/core/tests/image_vectorialness (revision 0) @@ -0,0 +1,26 @@ + +#include <iostream> + +#include <ntg/all.hh> +#include <oln/basics2d.hh> + +#include <oln/fancy/iota.hh> +#include <oln/fancy/print.hh> + +#include "check.hh" +#include "data.hh" + + + +template <typename I> +void foo_i(const oln::abstract::integer_image<I>& input) +{} + + +bool check() +{ + // it lacks test for decimal, vectorial, ... images. + oln::image2d<ntg::int_u8> ima_i; + foo_i(ima_i); + return false; +} Index: tests/core/tests/readwrite_image --- tests/core/tests/readwrite_image (revision 79) +++ tests/core/tests/readwrite_image (working copy) @@ -24,6 +24,7 @@ { typedef is_a<abstract::readwrite_image> image_constness; typedef is_a<abstract::image2d> image_dimension_type; + typedef vectorialness_from_valuetype_(ntg::int_u8) image_vectorialness_type; typedef size2d size_type; typedef point2d point_type; Index: oln/makefile.src --- oln/makefile.src (revision 79) +++ oln/makefile.src (working copy) @@ -37,6 +37,7 @@ core/abstract/image.hh \ core/abstract/image_constness.hh \ core/abstract/image_dimension.hh \ + core/abstract/image_vectorialness.hh \ core/abstract/image_identity.hh \ core/abstract/image_with_data.hh \ core/abstract/images.hh \ Index: oln/core/abstract/image.hh --- oln/core/abstract/image.hh (revision 79) +++ oln/core/abstract/image.hh (working copy) @@ -70,6 +70,7 @@ mlc_decl_prop_with_default(category::image, image_constness_type, is_a<abstract::readonly_image>); mlc_decl_prop(category::image, image_dimension_type); + mlc_decl_prop(category::image, image_vectorialness_type); //... @@ -87,6 +88,7 @@ << " image_constness_type = " << typeid(image_constness_type).name() << " image_dimension_type = " << typeid(image_dimension_type).name() + << " image_vectorialness_type = " << typeid(image_vectorialness_type).name() << " }" << std::endl; } @@ -103,6 +105,7 @@ mlc_register_prop(category::image, image_constness_type); mlc_register_prop(category::image, image_dimension_type); + mlc_register_prop(category::image, image_vectorialness_type); Index: oln/core/abstract/image_vectorialness.hh --- oln/core/abstract/image_vectorialness.hh (revision 0) +++ oln/core/abstract/image_vectorialness.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_ABSTRACT_IMAGE_VECTORIALNESS_HH +# define OLENA_CORE_ABSTRACT_IMAGE_VECTORIALNESS_HH + +# include <mlc/bool.hh> + +# include <ntg/basics.hh> + +# include <oln/core/abstract/image.hh> + +/*! \namespace oln +** \brief oln namespace. +*/ +namespace oln { + + /*! \namespace oln::abstract + ** \brief oln::abstract namespace. + */ + namespace abstract { + + template <typename E> + struct data_type_image : public virtual image<E> + { + protected: + data_type_image() {} + }; + + template <typename E> + struct vectorial_image : public data_type_image<E> + { + protected: + vectorial_image() {} + }; + + template <typename E> + struct non_vectorial_image : public data_type_image<E> + { + protected: + non_vectorial_image() {} + }; + + template <typename E> + struct decimal_image : public non_vectorial_image<E> + { + protected: + decimal_image() {} + }; + + template <typename E> + struct integer_image : public non_vectorial_image<E> + { + protected: + integer_image() {} + }; + + template <typename E> + struct binary_image : public non_vectorial_image<E> + { + protected: + binary_image() {} + }; + + + } // end of namespace oln::abstract + + template <typename T> + struct vectorialness_from_valuetype + { + typedef typename mlc::bool_switch_< + + mlc::bool_case_<ntg_is_a(T, ntg::binary)::ret, + is_a<abstract::binary_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::integer)::ret, + is_a<abstract::integer_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::decimal)::ret, + is_a<abstract::decimal_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::vectorial)::ret, + is_a<abstract::vectorial_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::non_vectorial)::ret, + is_a<abstract::non_vectorial_image>, + + mlc::bool_case_<true, + is_a<abstract::data_type_image> > + + > > > > > >::ret ret; + }; + + #define vectorialness_from_valuetype(T) \ + typename vectorialness_from_valuetype< T >::ret + #define vectorialness_from_valuetype_(T) \ + vectorialness_from_valuetype< T >::ret + +} // end of namespace oln + + +#endif // ! OLENA_CORE_ABSTRACT_IMAGE_VECTORIALNESS_HH Index: oln/core/abstract/entry.hh --- oln/core/abstract/entry.hh (revision 79) +++ oln/core/abstract/entry.hh (working copy) @@ -30,6 +30,7 @@ # include <oln/core/abstract/image_constness.hh> # include <oln/core/abstract/image_dimension.hh> +# include <oln/core/abstract/image_vectorialness.hh> // FIXME: this file should move to oln/core/abstract/ @@ -68,7 +69,8 @@ struct image_entry : // intrusive: public oln_type_of_(E, image_constness) ::template instantiated_with<E>::ret, - public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret + public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret, + public oln_type_of_(E, image_vectorialness) ::template instantiated_with<E>::ret // ... { protected: Index: oln/core/1d/image1d.hh --- oln/core/1d/image1d.hh (revision 79) +++ oln/core/1d/image1d.hh (working copy) @@ -31,6 +31,7 @@ # include <mlc/traits.hh> # include <oln/core/abstract/image_with_data.hh> +# include <oln/core/abstract/image_vectorialness.hh> # include <oln/core/1d/array1d.hh> # include <oln/core/1d/fwd_piter1d.hh> @@ -63,6 +64,8 @@ { // intrusive property: typedef is_a<abstract::image1d> image_dimension_type; + // FIXME: should be generalized + typedef vectorialness_from_valuetype(T) image_vectorialness_type; typedef mlc::no_type delegated_type; Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 79) +++ oln/core/2d/image2d.hh (working copy) @@ -32,6 +32,7 @@ # include <oln/core/abstract/image_identity.hh> # include <oln/core/abstract/image_with_data.hh> +# include <oln/core/abstract/image_vectorialness.hh> # include <oln/core/2d/array2d.hh> # include <oln/core/2d/fwd_piter2d.hh> # include <oln/core/2d/bkd_piter2d.hh> @@ -72,6 +73,8 @@ { // intrusive property: typedef is_a<abstract::image2d> image_dimension_type; + // FIXME: should be generalized + typedef vectorialness_from_valuetype(T) image_vectorialness_type; typedef mlc::no_type delegated_type; Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 79) +++ oln/core/3d/image3d.hh (working copy) @@ -31,6 +31,7 @@ # include <mlc/traits.hh> # include <oln/core/abstract/image_with_data.hh> +# include <oln/core/abstract/image_vectorialness.hh> # include <oln/core/3d/array3d.hh> # include <oln/core/3d/fwd_piter3d.hh> @@ -61,6 +62,8 @@ { // intrusive property: typedef is_a<abstract::image3d> image_dimension_type; + // FIXME: should be generalized + typedef vectorialness_from_valuetype(T) image_vectorialness_type; typedef mlc::no_type delegated_type; Index: oln/core/properties.hh --- oln/core/properties.hh (revision 79) +++ oln/core/properties.hh (working copy) @@ -66,6 +66,7 @@ struct image_constness_type; struct image_dimension_type; + struct image_vectorialness_type; // FIXME: ... }

19 years, 9 months

proto-1.0 79: Add backward 2D iterators

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/core/tests/piter2d: Add a test for backward 2d iterators. * oln/makefile.src: Add new file. * oln/core/2d/image2d.hh: Include bkd_piter2d.hh. * oln/core/2d/bkd_piter2d.hh: New. bkd_piter2d implementation. * oln/core/properties.hh: Add bkd_piter_type property. oln/core/2d/bkd_piter2d.hh | 117 +++++++++++++++++++++++++++++++++++++++++++++ oln/core/2d/image2d.hh | 2 oln/core/properties.hh | 3 - oln/makefile.src | 1 tests/core/tests/piter2d | 23 ++++++-- 5 files changed, 140 insertions(+), 6 deletions(-) Index: tests/core/tests/piter2d --- tests/core/tests/piter2d (revision 78) +++ tests/core/tests/piter2d (working copy) @@ -14,16 +14,29 @@ { oln::image2d<int> ima(10, 10); int cpt = 0; - - oln::fwd_piter2d it(ima.size()); - for_all (it) + + oln::fwd_piter2d fwd_it(ima.size()); + for_all (fwd_it) { - ima[it] = 0; + ima[fwd_it] = 0; cpt++; } if (cpt != 100) return true; - + + + cpt = 0; + oln::bkd_piter2d bkd_it(ima.size()); + for_all (bkd_it) + { + ima[bkd_it] = 0; + cpt++; + } + + if (cpt != 100) + return true; + + return false; } Index: oln/makefile.src --- oln/makefile.src (revision 78) +++ oln/makefile.src (working copy) @@ -18,6 +18,7 @@ core/1d/point1d.hh \ core/1d/size1d.hh \ core/2d/array2d.hh \ + core/2d/bkd_piter2d.hh \ core/2d/dpoint2d.hh \ core/2d/fwd_piter2d.hh \ core/2d/image2d.hh \ Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 78) +++ oln/core/2d/image2d.hh (working copy) @@ -34,6 +34,7 @@ # include <oln/core/abstract/image_with_data.hh> # include <oln/core/2d/array2d.hh> # include <oln/core/2d/fwd_piter2d.hh> +# include <oln/core/2d/bkd_piter2d.hh> /*! \namespace oln @@ -80,6 +81,7 @@ typedef fwd_piter2d piter_type; typedef fwd_piter2d fwd_piter_type; + typedef bkd_piter2d bkd_piter_type; // please note that value_storage_type means data_type // since image2d is an image_with_data Index: oln/core/2d/bkd_piter2d.hh --- oln/core/2d/bkd_piter2d.hh (revision 0) +++ oln/core/2d/bkd_piter2d.hh (revision 0) @@ -0,0 +1,117 @@ +// 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_2D_BKD_PITER2D_HH +# define OLENA_CORE_2D_BKD_PITER2D_HH + +# include <mlc/contract.hh> + +# include <oln/core/abstract/piter.hh> +# include <oln/core/2d/point2d.hh> +# include <oln/core/2d/size2d.hh> + + +namespace oln { + + // fwd decl + struct bkd_piter2d; + + // category + template <> + struct set_category<bkd_piter2d> { typedef category::piter ret; }; + + + // props + template <> + struct set_props < category::piter, bkd_piter2d > : public props_of<category::piter> + { + typedef point2d point_type; + typedef size2d size_type; + }; + + + + struct bkd_piter2d : public abstract::piter< bkd_piter2d > + { + + typedef abstract::piter<bkd_piter2d> super_type; + + bkd_piter2d(const size2d& size) : + super_type(size) + { + this->exact_ptr = this; + this->invalidate(); + } + +# if defined __GNUC__ && __GNUC__ >= 3 + friend class abstract::piter< bkd_piter2d >; + protected: +# endif + + void impl_start() + { + this->p_.row() = this->s_.nrows() - 1; + this->p_.col() = this->s_.ncols() - 1; + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + } + + bool impl_is_valid() const + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + return this->p_.row() >= 0; + } + + void impl_next() + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + precondition(this->p_.row() >= 0 && this->p_.row() < this->s_.nrows() && + this->p_.col() >= 0 && this->p_.col() < this->s_.ncols()); + --this->p_.col(); + if (this->p_.col() >= 0) + return; + this->p_.col() = this->s_.ncols() - 1; + --this->p_.row(); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + } + + void impl_invalidate() + { + this->p_.row() = -1; + this->p_.col() = -1; + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + } + + }; +} + + +#endif // ! OLENA_CORE_2D_BKD_PITER2D_HH Index: oln/core/properties.hh --- oln/core/properties.hh (revision 78) +++ oln/core/properties.hh (working copy) @@ -36,7 +36,7 @@ */ namespace oln { - + namespace category { struct data_storage; @@ -59,6 +59,7 @@ struct point_type; struct dpoint_type; struct fwd_piter_type; + struct bkd_piter_type; struct iter_type; struct delegated_type; struct size_type;

19 years, 9 months

proto-1.0 78: Add border_resize in array2d

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/core/tests/border2d: New. * oln/core/abstract/image_with_data.hh: Add resize_border and impl_hold_large methods. * oln/core/abstract/data_storage.hh: Add resize_border in generic data_storage class. * oln/core/2d/array2d.hh: Add resize_border implementation for array2d. * oln/core/2d/image2d.hh: Add a border argument to image2d constructor. oln/core/2d/array2d.hh | 71 ++++++++++++++++++++++++++++------- oln/core/2d/image2d.hh | 4 - oln/core/abstract/data_storage.hh | 13 ++++-- oln/core/abstract/image_with_data.hh | 13 +++++- tests/core/tests/border2d | 38 ++++++++++++++++++ 5 files changed, 119 insertions(+), 20 deletions(-) Index: tests/core/tests/border2d --- tests/core/tests/border2d (revision 0) +++ tests/core/tests/border2d (revision 0) @@ -0,0 +1,38 @@ + +#include <iostream> + +#include <ntg/all.hh> +#include <oln/basics2d.hh> +#include <oln/level/fill.hh> + +#include "check.hh" +#include "data.hh" + + + +bool check() +{ + oln::point2d p(0,0); + + typedef oln::image2d<ntg::int_u8> image_type; + image_type ima(10, 10, 2); + + int i = 0; + + for (p.col() = -0; p.col() < 10; p.col()++) + for (p.row() = -0; p.row() < 10; p.row()++) + ima[p] = i++; + + ima.resize_border(3, true); + + i = 0; + for (p.col() = -3; p.col() < 13; p.col()++) + for (p.row() = -3; p.row() < 13; p.row()++) + { + if (p.col() >= -0 && p.col() < 10 && p.row() >= -0 && p.row() < 10) + if (ima[p] != i++) + return true; + } + + return false; +} Index: oln/core/abstract/data_storage.hh --- oln/core/abstract/data_storage.hh (revision 77) +++ oln/core/abstract/data_storage.hh (working copy) @@ -49,7 +49,7 @@ struct props_of < category::data_storage, type > { typedef mlc::true_type user_defined_; - + mlc_decl_prop(category::data_storage, size_type); mlc_decl_prop(category::data_storage, point_type); mlc_decl_prop(category::data_storage, data_type); @@ -65,9 +65,9 @@ }; - mlc_register_prop(category::data_storage, size_type); - mlc_register_prop(category::data_storage, point_type); - mlc_register_prop(category::data_storage, data_type); + mlc_register_prop(category::data_storage, size_type); + mlc_register_prop(category::data_storage, point_type); + mlc_register_prop(category::data_storage, data_type); namespace abstract { @@ -106,6 +106,11 @@ this->exact().impl_resize(s); } + void resize_border(size_t new_border, bool copy_border) + { + this->exact().impl_resize_border(new_border, copy_border); + } + unsigned long npoints() const { if (! this->has_data()) Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 77) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -51,7 +51,7 @@ { typedef category::image ret; }; - + // super_type template <typename E> struct set_super_type < abstract::image_with_data<E> > @@ -139,7 +139,13 @@ return this->data_->hold(p); } + bool impl_hold_large(const point_type& p) const + { + precondition(this->has_data()); + return this->data_->hold_large(p); + } + /*! \brief Implement both abstract::readonly_image<E>::get(p) ** and abstract::readwrite_image<E>::get(p) so read-only access ** to the value stored at \a p in the current image. @@ -172,7 +178,12 @@ return data_ != 0; } + void resize_border(size_t new_border, bool copy_border = false) + { + this->data_->resize_border(new_border, copy_border); + } + protected: /*! \brief Constructor (protected) with no memory allocation for Index: oln/core/2d/array2d.hh --- oln/core/2d/array2d.hh (revision 77) +++ oln/core/2d/array2d.hh (working copy) @@ -39,13 +39,13 @@ template <typename T> struct array2d; // category - template <typename T> + template <typename T> struct set_category< array2d<T> > { typedef category::data_storage ret; }; // super_type - template <typename T> + template <typename T> struct set_super_type< array2d<T> > { typedef abstract::data_storage< array2d<T> > ret; }; - + // props template <typename T> struct set_props < category::data_storage, array2d<T> > : public props_of<category::data_storage> @@ -56,7 +56,26 @@ }; + template<class T> + void alloc_and_init(T*& buffer, T**& array, const size2d& s) + { + size_t nrows_eff = s.nrows() + 2 * s.border(); + size_t ncols_eff = s.ncols() + 2 * s.border(); + size_t nelts_eff = nrows_eff * ncols_eff; + buffer = new T[nelts_eff]; + array = new T*[nrows_eff]; + + buffer = buffer; + T* buf = buffer + s.border(); + for (size_t row = 0; row < nrows_eff; ++row) + { + array[row] = buf; + buf += ncols_eff; + } + array += s.border(); + } + template <typename T> class array2d : public abstract::data_storage< array2d<T> > { @@ -129,20 +148,44 @@ this->clear_data(); size_ = s; - size_t nrows_eff = size_.nrows() + 2 * size_.border(); - size_t ncols_eff = size_.ncols() + 2 * size_.border(); - size_t nelts_eff = nrows_eff * ncols_eff; + alloc_and_init(buffer_, array_, s); + invariant_(); + } - buffer_ = new T[nelts_eff]; - array_ = new T*[nrows_eff]; + void impl_resize_border(size_t new_border, bool copy_border) + { + invariant_(); + T* new_buffer_; + T** new_array_; + size2d new_size_(this->size_.nrows(), this->size_.ncols(), new_border); - T* buf = buffer_ + size_.border(); - for (size_t row = 0; row < nrows_eff; ++row) + alloc_and_init(new_buffer_, new_array_, new_size_); + + if (buffer_ != 0) { - array_[row] = buf; - buf += ncols_eff; + size_t border = this->size_.border(); + + if (border > new_border) + border = new_border; + + coord_t row_min = copy_border ? -border : 0; + coord_t row_max = int(this->size_.nrows()) + + (copy_border ? border : 0); + coord_t col_min = copy_border ? -border : 0; + size_t ncols = int(this->size_.ncols()) + + (copy_border ? (border * 2) : 0); + + for (coord_t row = row_min; row < row_max; ++row) + memcpy(new_array_[row] + col_min, this->array_[row] + col_min, + ncols * sizeof (T)); + + this->clear_data(); } - array_ += size_.border(); + + buffer_ = new_buffer_; + array_ = new_array_; + size_ = new_size_; + invariant_(); } @@ -213,6 +256,8 @@ size_.border().is_undefined())); } + + }; } // end of namespace oln Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 77) +++ oln/core/2d/image2d.hh (working copy) @@ -124,8 +124,8 @@ this->exact_ptr = this; } - image2d(coord_t nrows, coord_t ncols) : - super_type(size2d(nrows, ncols)) + image2d(coord_t nrows, coord_t ncols, size_t border = 2) : + super_type(size2d(nrows, ncols, border)) { this->exact_ptr = this; }

19 years, 9 months

proto-1.0 76: Add neighborhood and structuring element files to makefile.src

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/makefile.src: Add neighborhood and structuring element files to makefile.src. makefile.src | 4 ++++ 1 files changed, 4 insertions(+) Index: oln/makefile.src --- oln/makefile.src (revision 75) +++ oln/makefile.src (working copy) @@ -23,6 +23,8 @@ core/2d/image2d.hh \ core/2d/point2d.hh \ core/2d/size2d.hh \ + core/2d/neighborhood2d.hh \ + core/2d/window2d.hh \ core/3d/array3d.hh \ core/3d/fwd_piter3d.hh \ core/3d/image3d.hh \ @@ -42,6 +44,8 @@ core/abstract/piter.hh \ core/abstract/point.hh \ core/abstract/size.hh \ + core/abstract/neighborhood.hh \ + core/abstract/window.hh \ core/coord.hh \ core/properties.hh \ core/value_box.hh \

19 years, 9 months

proto-1.0 75: Add neighborhood

by Simon Odou

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;

19 years, 9 months

proto-1.0 74: Add structuring elements

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/core/tests/window2d: New. * oln/core/abstract/struct_elt.hh: New. * oln/core/2d/window2d.hh: New. * oln/core/properties.hh: Add `struct_elt' category. oln/core/2d/window2d.hh | 172 ++++++++++++++++++++++++++++++++++++ oln/core/abstract/struct_elt.hh | 189 ++++++++++++++++++++++++++++++++++++++++ oln/core/properties.hh | 1 tests/core/tests/window2d | 17 +++ 4 files changed, 379 insertions(+) Index: tests/core/tests/window2d --- tests/core/tests/window2d (revision 0) +++ tests/core/tests/window2d (revision 0) @@ -0,0 +1,17 @@ +#include <oln/core/2d/window2d.hh> + +#include <ntg/all.hh> + +#include <cassert> + +using namespace oln; +using namespace ntg; + +int main() +{ + window2d w1; + w1.add(dpoint2d(0, 5)); + w1.add(dpoint2d(0, 5)); + window2d w2 = win_c8p(); + return 0; +} Index: oln/core/abstract/struct_elt.hh --- oln/core/abstract/struct_elt.hh (revision 0) +++ oln/core/abstract/struct_elt.hh (revision 0) @@ -0,0 +1,189 @@ +// 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_STRUCT_ELT_HH +# define OLENA_CORE_STRUCT_ELT_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 struct_elt; + } + + // category + template <typename E> + struct set_category< abstract::struct_elt<E> > + { + typedef category::struct_elt ret; + }; + + /// properties of any type in category::struct_elt + + template <typename type> + struct props_of <category::struct_elt, type> + { + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::struct_elt, dpoint_type); + mlc_decl_prop(category::struct_elt, size_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::struct_elt, " + << typeid(type).name() << ") = {" + << " size_type = " << typeid(size_type).name() << "," << std::endl + << " dpoint_type = " << typeid(dpoint_type).name() << " }" << std::endl; + } + + }; + + mlc_register_prop(category::struct_elt, dpoint_type); + mlc_register_prop(category::struct_elt, 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 struct_elt : 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("struct_elt<") + 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); + 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]; + } + + struct_elt() : dp_() + {}; + + struct_elt(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::struct_elt<E>& se) +{ + unsigned c = se.card(); + o << "["; + for (unsigned i = 0; i < c; ++i) + o << se.dp(i); + o << "]"; + return o; +} + + +#endif // ! OLENA_CORE_STRUCT_ELT_HH Index: oln/core/2d/window2d.hh --- oln/core/2d/window2d.hh (revision 0) +++ oln/core/2d/window2d.hh (revision 0) @@ -0,0 +1,172 @@ +// 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_WINDOW2D_HH +# define OLENA_CORE_WINDOW2D_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 window2d; // forward declaration + + // category + template <> + struct set_category< window2d > { typedef category::struct_elt ret; }; + + // super_type + template <> + struct set_super_type< window2d > + { + typedef abstract::struct_elt< window2d > ret; + }; + + template <> + struct set_props< category::struct_elt, window2d > + : public props_of<category::struct_elt> + { + typedef dpoint2d dpoint_type; + typedef size2d size_type; + }; + + class window2d : public abstract::struct_elt<window2d> + { + + public: + + typedef abstract::struct_elt<window2d> super_type; + + /*! + ** \brief Construct a window of 2 dimensions. + */ + window2d() : super_type() + {} + + /*! + ** \brief Construct a window of 2 dimensions. + ** \arg size The number of element. + */ + window2d(unsigned size) : super_type(size) + {} + + /*! + ** \brief Construct a window of 2 dimensions from several points. + ** \arg n The number of element. + ** \arg crd The coordinates of the elements + */ + window2d(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])); + } + + window2d& + add(const dpoint_type& dp) + { + return this->exact().impl_add(dp); + } + + window2d& + 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("window2d"); + } + + protected: + + }; + + + // std win + + /*! + ** \brief Create a window (2 dimensions) of 4 elements. + ** \return The new window. + */ + inline const window2d& + win_c4_only() + { + static const coord_t crd[] = { -1,0, 0,-1, 0,1, 1,0 }; + static const window2d win(4, crd); + return win; + } + + /*! + ** \brief Create a window (2 dimensions) of 5 elements. + ** \return The new window. + ** + ** It's the same than win_c4_only() plus the 0,0 point. + */ + inline const window2d& + win_c4p() + { + static const coord_t crd[] = { -1,0, 0,-1, 0,0, 0,1, 1,0 }; + static const window2d win(5, crd); + return win; + } + + /*! + ** \brief Create a window (2 dimensions) of 8 elements. + ** \return The new window. + */ + inline const window2d& + win_c8_only() + { + static const coord_t crd[] = { -1,-1, -1,0, -1,1, 0,-1, 0,1, 1,-1, 1,0, 1,1 }; + static const window2d win(8, crd); + return win; + } + + /*! + ** \brief Create a window (2 dimensions) of 9 elements. + ** \return The new window. + ** + ** It's the same than win_c8_only more the 0,0 point. + */ + inline const window2d& + win_c8p() + { + static const coord_t crd[] = { -1,-1, -1,0, -1,1, 0,-1, 0,0, 0,1, 1,-1, 1,0, 1,1 }; + static const window2d win(9, crd); + return win; + } + +} // end of oln + +#endif // OLENA_CORE_WINDOW2D_HH Index: oln/core/properties.hh --- oln/core/properties.hh (revision 73) +++ oln/core/properties.hh (working copy) @@ -41,6 +41,7 @@ { struct data_storage; struct image; + struct struct_elt; struct point; struct size; struct piter;

19 years, 9 months

proto-1.0 73: Make it check with g++-3.3

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/io/utils.hh: Add a traits for g++-3.3. utils.hh | 16 +++++++++------- 1 files changed, 9 insertions(+), 7 deletions(-) Index: oln/io/utils.hh --- oln/io/utils.hh (revision 72) +++ oln/io/utils.hh (working copy) @@ -150,29 +150,31 @@ } template <bool b> - struct pnm_io_helper + struct pnm_io_helper_bool { - enum { size = 1}; typedef unsigned char type; }; template <> - struct pnm_io_helper<false> + struct pnm_io_helper_bool<false> { - enum { size = 2}; typedef unsigned short type; }; + template <unsigned N> + struct pnm_io_helper + { + typedef typename pnm_io_helper_bool<N <= 8>::type type; + }; - } // end of namespace internal } // end of namespace io } // end of namespace oln -# define oln_io_type(N) typename oln::io::internal::pnm_io_helper<N <= 8>::type -# define oln_io_type_(N) oln::io::internal::pnm_io_helper<N <= 8>::type +# define oln_io_type(N) typename oln::io::internal::pnm_io_helper<N>::type +# define oln_io_type_(N) oln::io::internal::pnm_io_helper<N>::type #endif // ! OLENA_IO_UTILS_HH

19 years, 9 months

proto-1.0 72: Add array directory to metalic tests suite

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * configure.ac: Add array directory to mlc tests suite. configure.ac | 1 + 1 files changed, 1 insertion(+) Index: configure.ac --- configure.ac (revision 69) +++ configure.ac (working copy) @@ -178,6 +178,7 @@ # MLC_TESTS defined in oln-local.m4 + MLC_TESTS([array]) MLC_TESTS([main]) MLC_TESTS([sanity])

19 years, 9 months

proto-1.0 71: Add tests for array and pow2sup

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/main/tests/pow2sup1: New. * tests/main/tests/pow2sup2: New. * tests/array: New. * tests/array/test_array1d.cc: New. * tests/array/test_array2d.cc: New. * tests/array/gen_test_utils: New. * tests/array/gen_test_utils/postlude: New. * tests/array/gen_test_utils/errors.cc: New. * tests/array/gen_test_utils/prelude: New. * tests/array/gen_test_utils/errors.hh: New. * tests/array/test_array3d.cc: New. * tests/array/Makefile.am: New. * tests/array/gen_test.cc: New. array/Makefile.am | 18 ++ array/gen_test.cc | 346 +++++++++++++++++++++++++++++++++++++++++ array/gen_test_utils/errors.cc | 290 ++++++++++++++++++++++++++++++++++ array/gen_test_utils/errors.hh | 22 ++ array/gen_test_utils/postlude | 8 array/gen_test_utils/prelude | 20 ++ array/test_array1d.cc | 31 +++ array/test_array2d.cc | 35 ++++ array/test_array3d.cc | 44 +++++ main/tests/pow2sup1 | 37 ++++ main/tests/pow2sup2 | 37 ++++ 11 files changed, 888 insertions(+) Index: tests/main/tests/pow2sup1 --- tests/main/tests/pow2sup1 (revision 0) +++ tests/main/tests/pow2sup1 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +#include <mlc/math.hh> + +using namespace mlc; + +int main() +{ + const int i = pow2sup<33>::value; // COMPFAIL + return i; +} Index: tests/main/tests/pow2sup2 --- tests/main/tests/pow2sup2 (revision 0) +++ tests/main/tests/pow2sup2 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +#include <mlc/math.hh> + +using namespace mlc; + +int main() +{ + const unsigned i = pow2sup<27>::value; + return i != 32; +} Index: tests/array/test_array1d.cc --- tests/array/test_array1d.cc (revision 0) +++ tests/array/test_array1d.cc (revision 0) @@ -0,0 +1,31 @@ +#include <mlc/array/all.hh> +#include <iostream> +using std::cout; +using std::endl; + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; + + array1d< array1d_info< 3 >, int > foo = (ints_1d = 1, 2, 3, end); + cout << endl << "Source:\n\n" << foo << endl; + cout << "After a central symmetry:\n\n" << -foo << endl; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/test_array2d.cc --- tests/array/test_array2d.cc (revision 0) +++ tests/array/test_array2d.cc (revision 0) @@ -0,0 +1,35 @@ +#include <mlc/array/all.hh> +#include <iostream> +using std::cout; +using std::endl; + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; + + array2d< array2d_info< 3, 4, 2>, int > foo = (ints_2d = 1, 2, x(3), 4, lbrk, + 5, 6, 7, 8, + 9, 10, 11, 12, end); + + cout << endl << "Source:\n\n" << foo << endl; + cout << "After a transposition:\n\n" << foo.transpose() << endl; + cout << "After a central symmetry:\n\n" << -foo << endl; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/gen_test_utils/postlude --- tests/array/gen_test_utils/postlude (revision 0) +++ tests/array/gen_test_utils/postlude (revision 0) @@ -0,0 +1,8 @@ + + (void) foo; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/gen_test_utils/errors.cc --- tests/array/gen_test_utils/errors.cc (revision 0) +++ tests/array/gen_test_utils/errors.cc (revision 0) @@ -0,0 +1,290 @@ +#include <iostream> +#include <fstream> +#include <sstream> + +using namespace std; + + +// Warning : +// --------- +// - dimension -> 1-indexed +// - geometry -> 0-indexed +// - position -> 0-indexed + + + +// +// Center +// + + +// If odd -> center +// else -> no center + +int if_center(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + // Checks if one of the sizes is even (-> no automatic center) + for (int i = 0; i < dimension; ++i) + if ((geometry[i] & 1) == 1) // geometry is 0-indexed ! + { + if (position == 0) + ofs << "x(1), "; + else + ofs << "1, "; + return 1; + } + // All sizes are odd + ofs << "1, "; + (void) dimension; (void) geometry; (void) position; + return 1; +} + + +// If odd -> middle +// else -> 1rst position + +int one_center(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + // Checks if one of the sizes is even (-> no automatic center) + for (int i = 0; i < dimension; ++i) + if ((geometry[i] & 1) == 1) // geometry is 0-indexed ! + { + if (position == 0) + ofs << "x(1), "; + else + ofs << "1, "; + return 1; + } + // All sizes are odd + int middle = geometry[0] + 1; + for (int i = dimension - 1; 0 < i; --i) + middle *= (geometry[i] + 1); + middle = middle >> 1; + if (position == middle) + ofs << "x(1), "; + else + ofs << "1, "; + return 1; +} + +int all_centers(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "x(1), "; + (void) position; + for (--dimension; dimension >= 0; --dimension) + if (geometry[dimension] != 0) + return 0; + return 1; +} + + + +// +// Comma +// + + +int no_comma(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == 0) + ofs << "1 "; + else + ofs << "1, "; + (void) dimension; (void) geometry; + return 0; +} + + +// +// No element +// + + +int no_element(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) dimension; (void) geometry; (void) position; + return 0; +} + + + +// +// Linebreak +// + + +int no_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) geometry; (void) position; + return (dimension != 1) ? 0 : 1; +} + +int one_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == geometry[dimension - 1]) + ofs << "lbrk, "; + return (dimension > 1) ? 1 : 0; +} + +int all_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (((position + 1) % (geometry[dimension - 1] + 1)) == 0) + ofs << "lbrk, "; + + if (dimension == 1) + return 0; + for (--(--dimension); dimension >= 0; --dimension) + if (geometry[dimension] != 0) + return 0; + return 1; +} + +int too_much_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "lbrk, "; + (void) dimension; (void) geometry; (void) position; + if (dimension == 1) + return 0; + for (--dimension; dimension >= 0; --dimension) + if (geometry[dimension] != 0) + return 0; + return 1; +} + +int twice_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == geometry[dimension - 1]) + ofs << "lbrk, lbrk, "; + return 0; +} + + +// +// Planebreak +// + + +int no_pbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) geometry; (void) position; + return (dimension > 2) ? 0 : 1; +} + +int one_pbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == (geometry[1] + 1) * (geometry[2] + 1) - 1) + ofs << "pbrk, "; + return (dimension > 2) ? 1 : 0; +} + +int all_pbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if ((position + 1) % ((geometry[1] + 1) * (geometry[2] + 1)) == 0) + ofs << "pbrk, "; + return (dimension < 3) ? 0 : ((geometry[0] == 0) ? 1 : 0); +} + + + +// +// End +// + + +int no_end(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) dimension; (void) geometry; (void) position; + return 0; +} + +int normal_end(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end);" << endl; + (void) dimension; (void) geometry; (void) position; + return 1; +} + +int end_elt(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, 1);" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} + +int end_lbrk(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, lbrk);" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} + +int end_center(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, x());" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} + +int end_starter(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, ints = 1);" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} Index: tests/array/gen_test_utils/prelude --- tests/array/gen_test_utils/prelude (revision 0) +++ tests/array/gen_test_utils/prelude (revision 0) @@ -0,0 +1,20 @@ +#include <mlc/array/all.hh> + +#include <iostream> + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; Index: tests/array/gen_test_utils/errors.hh --- tests/array/gen_test_utils/errors.hh (revision 0) +++ tests/array/gen_test_utils/errors.hh (revision 0) @@ -0,0 +1,22 @@ +#include <iostream> +#include <fstream> + +int one_center(std::ostream&, int, int*, int); +int if_center(std::ostream&, int, int*, int); +int all_centers(std::ostream&, int, int*, int); +int no_comma(std::ostream&, int, int*, int); +int no_element(std::ostream&, int, int*, int); +int no_lbreak(std::ostream&, int, int*, int); +int one_lbreak(std::ostream&, int, int*, int); +int all_lbreak(std::ostream&, int, int*, int); +int too_much_lbreak(std::ostream&, int, int*, int); +int twice_lbreak(std::ostream&, int, int*, int); +int no_pbreak(std::ostream&, int, int*, int); +int one_pbreak(std::ostream&, int, int*, int); +int all_pbreak(std::ostream&, int, int*, int); +int normal_end(std::ostream&, int, int*, int); +int no_end(std::ostream&, int, int*, int); +int end_elt(std::ostream&, int, int*, int); +int end_lbrk(std::ostream&, int, int*, int); +int end_center(std::ostream&, int, int*, int); +int end_starter(std::ostream&, int, int*, int); Index: tests/array/test_array3d.cc --- tests/array/test_array3d.cc (revision 0) +++ tests/array/test_array3d.cc (revision 0) @@ -0,0 +1,44 @@ +#include <mlc/array/all.hh> +#include <iostream> +using std::cout; +using std::endl; + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; + + array3d< array3d_info< 2, 2, 3, 1>, int > foo = (ints_3d = 1, x(2), 3, lbrk, + 4, 5, 6, pbrk, + + 7, 8, 9, + 10, 11, 12, end); + + cout << endl << "Source:\n\n" << foo << endl; + + try { + cout << "After a transposition:\n\n" << foo.transpose() << endl; + } + catch (not_implemented_yet) { + cout << endl; + } + + cout << "After a central symmetry:\n\n" << -foo << endl; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/Makefile.am --- tests/array/Makefile.am (revision 0) +++ tests/array/Makefile.am (revision 0) @@ -0,0 +1,18 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +include ../check/Makefile.check + +check_PROGRAMS = test_array1d test_array2d test_array3d gen_test + +test_array1d_SOURCES = test_array1d.cc +test_array2d_SOURCES = test_array2d.cc +test_array3d_SOURCES = test_array3d.cc + +gen_test_SOURCES = gen_test.cc +gen_test_LDADD = $(LDADD) gen_test_utils/liberrors.a + +check_LIBRARIES = gen_test_utils/liberrors.a +gen_test_utils_liberrors_a_SOURCES = gen_test_utils/errors.cc gen_test_utils/errors.hh + +EXTRA_DIST = gen_test_utils/prelude gen_test_utils/postlude +CLEANFILES = fail.log success.log a.out gentest_array.cc Index: tests/array/gen_test.cc --- tests/array/gen_test.cc (revision 0) +++ tests/array/gen_test.cc (revision 0) @@ -0,0 +1,346 @@ +#include "config.h" +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> +#include <stdlib.h> +#include <cstdio> +#include <iostream> +#include <fstream> +#include <sstream> +#include "gen_test_utils/errors.hh" +#include "srcdir.hh" +#include "compile.hh" + +using namespace std; + +#define MIN_DIMENSION 1 +#define MAX_DIMENSION 3 + + +static const struct howto +{ + typedef int (*displayer)(ostream&, int, int*, int); + + int ok; + displayer element; + displayer lbreak; + displayer pbreak; + displayer terminate; + const char* verbose; +} methods[][16] = + { + { + // 1D + + { 1, one_center, no_lbreak, no_pbreak, normal_end , + "one_center, no_lbreak, no_pbreak, normal_end" }, + { 1, if_center, no_lbreak, no_pbreak, normal_end , + "if_center, no_lbreak, no_pbreak, normal_end" }, + { 1, all_centers, no_lbreak, no_pbreak, normal_end , + "all_centers!, no_lbreak, no_pbreak, normal_end" }, + { 1, one_center, one_lbreak, no_pbreak, normal_end , + "one_center, one_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, no_lbreak, no_pbreak, no_end , + "one_center, no_lbreak, no_pbreak, no_end!" }, + { 1, one_center, no_lbreak, no_pbreak, end_elt , + "one_center, no_lbreak, no_pbreak, end_elt!" }, + { 1, one_center, no_lbreak, no_pbreak, end_center , + "one_center, no_lbreak, no_pbreak, end_center!" }, + { 1, one_center, no_lbreak, no_pbreak, end_starter , + "one_center, no_lbreak, no_pbreak, end_starter!" }, + { 1, no_comma, no_lbreak, no_pbreak, normal_end , + "no_comma!, no_lbreak, no_pbreak, normal_end" }, + { 1, no_element, no_lbreak, no_pbreak, normal_end , + "no_element!, no_lbreak, no_pbreak, normal_end" }, + { 0, 0, 0, 0, 0, 0 } + }, + { + // 2D + + { 1, one_center, one_lbreak, no_pbreak, normal_end , + "one_center, one_lbreak, no_pbreak, normal_end" }, + { 1, if_center, one_lbreak, no_pbreak, normal_end , + "if_center, one_lbreak, no_pbreak, normal_end" }, + { 1, all_centers, no_lbreak, no_pbreak, normal_end , + "all_centers!, no_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, all_lbreak, no_pbreak, normal_end , + "one_center, all_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, too_much_lbreak, no_pbreak, normal_end , + "one_center, too_much_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, twice_lbreak, no_pbreak, normal_end , + "one_center, twice_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, one_lbreak, no_pbreak, no_end , + "one_center, one_lbreak, no_pbreak, no_end!" }, + { 1, one_center, one_lbreak, no_pbreak, end_elt , + "one_center, one_lbreak, no_pbreak, end_elt!" }, + { 1, one_center, one_lbreak, no_pbreak, end_lbrk , + "one_center, one_lbreak, no_pbreak, end_lbrk!" }, + { 1, one_center, one_lbreak, no_pbreak, end_center , + "one_center, one_lbreak, no_pbreak, end_center!" }, + { 1, one_center, one_lbreak, no_pbreak, end_starter , + "one_center, one_lbreak, no_pbreak, end_starter!" }, + { 1, no_comma, one_lbreak, no_pbreak, normal_end , + "no_comma!, one_lbreak, no_pbreak, normal_end" }, + { 1, no_element, one_lbreak, no_pbreak, normal_end , + "no_element!, one_lbreak, no_pbreak, normal_end" }, + { 0, 0, 0, 0, 0, 0 } + }, + { + // 3D + + { 1, one_center, one_lbreak, one_pbreak, normal_end , + "one_center, one_lbreak, one_pbreak, normal_end" }, + { 1, if_center, one_lbreak, one_pbreak, normal_end , + "if_center, one_lbreak, one_pbreak, normal_end" }, + { 1, one_center, one_lbreak, no_pbreak, normal_end , + "one_center, one_lbreak, no_pbreak!, normal_end" }, + { 1, one_center, one_lbreak, all_pbreak, normal_end , + "one_center, one_lbreak, all_pbreak!, normal_end" }, + { 1, all_centers, no_lbreak, one_pbreak, normal_end , + "all_centers!, no_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, all_lbreak, one_pbreak, normal_end , + "one_center, all_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, too_much_lbreak, one_pbreak, normal_end , + "one_center, too_much_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, twice_lbreak, one_pbreak, normal_end , + "one_center, twice_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, one_lbreak, one_pbreak, no_end , + "one_center, one_lbreak, one_pbreak, no_end!" }, + { 1, one_center, one_lbreak, one_pbreak, end_elt , + "one_center, one_lbreak, one_pbreak, end_elt!" }, + { 1, one_center, one_lbreak, one_pbreak, end_lbrk , + "one_center, one_lbreak, one_pbreak, end_lbrk!" }, + { 1, one_center, one_lbreak, one_pbreak, end_center , + "one_center, one_lbreak, one_pbreak, end_center!" }, + { 1, one_center, one_lbreak, one_pbreak, end_starter , + "one_center, one_lbreak, one_pbreak, end_starter!" }, + { 1, no_comma, one_lbreak, one_pbreak, normal_end , + "no_comma!, one_lbreak, one_pbreak, normal_end" }, + { 1, no_element, one_lbreak, one_pbreak, normal_end , + "no_element!, one_lbreak, one_pbreak, normal_end" }, + { 0, 0, 0, 0, 0, 0 } + } + }; + + + +static void +copyfile (const string & src, ofstream & dest) +{ + ifstream ifs (src.c_str (), ios::in); + string buffer; + + while (!ifs.eof ()) + { + getline (ifs, buffer); + dest << buffer << endl; + } +} + + +static void +write_prelude (ofstream & ofs, const char *filename) +{ + ofs.open (filename, ios::out); + ofs << "// -*-C++-*-" << endl + << "// This temporary file was generated for testing purpose only." + << endl + << "// It's part of Olena, the static generic image processing library." + << endl << endl; + + copyfile (srcdir + "/gen_test_utils/prelude", ofs); +} + +// #include <fstream> + +static bool +write_postlude_and_test (ofstream & ofs, + char *filename, + int dimension, + howto h, + int ok, + ofstream & success_log, + ofstream & fail_log, const stringstream & decl) +{ + copyfile (srcdir + "/gen_test_utils/postlude", ofs); + ofs.close (); + + pid_t pid; + int fd[2]; + pipe (fd); + bool fail = false; + + if ((pid = fork ()) != -1) + if (!pid) + { + dup2 (fd[1], 2); + close (fd[0]); + close (fd[1]); + // FIXME: clean path generation + std::string cmdline = compile_cmd(filename, "", + Isrcdir ("../..") + ' ' + + Isrcdir ("../check") + ' ' + + "-I../../../olena -I../../.. " + + "-L../check -lcheck " + + cxxflags_strict_errors()); + int ret = system (cmdline.c_str ()); + exit (WEXITSTATUS (ret)); + } + else + { + close (fd[1]); + stringstream header; + header << endl << "=== Compiling : [" << dimension << "D]\t" + << h.verbose << endl + << "=== Expected : " << (ok ? "PASS" : "FAIL") << endl << endl; + + stringstream compile_mesg; + char buffer[32]; + { + int r; + while ((r = read (fd[0], buffer, 32)) != 0) + compile_mesg.write (buffer, r); + } + int status; + if (waitpid (pid, &status, 0) == -1) + abort (); + if ((WEXITSTATUS (status) || ok) && !(WEXITSTATUS (status) && ok)) + { + success_log << header.str () << decl.str () + << endl << compile_mesg. + str () << "Exit status = " << WEXITSTATUS (status) << endl << + "===========================================================================" + << endl; + cerr << (ok ? "PASS" : "XFAIL"); + } + else + { + fail_log << header.str () << decl.str () << endl << compile_mesg. + str () << "Exit status = " << WEXITSTATUS (status) << endl << + "===========================================================================" + << endl; + cerr << (ok ? "FAIL" : "XPASS"); + fail = true; + } + close (fd[0]); + cerr << ": [" << dimension << "D]\t" << h.verbose << endl; + } + return fail; +} + + + +static int +fill_array (ostream & ofs, int dimension, int *geometry, howto h) +{ + int *cur_dim = (int *) malloc (dimension * sizeof (int)); + for (int i = dimension - 1; 0 <= i; --i) + cur_dim[i] = geometry[i]; + ++cur_dim[dimension - 1]; + + bool finished = false; + int position = 0; + int ok = h.ok; + while (!finished) + { + for (int d = dimension - 1; 0 <= d; --d) + if (0 <= --cur_dim[d]) + break; + else + { + cur_dim[d] = geometry[d]; + ofs << endl << "\t\t"; + } + + ok &= h.element (ofs, dimension, geometry, position); + ok &= h.lbreak (ofs, dimension, geometry, position); + ok &= h.pbreak (ofs, dimension, geometry, position); + ++position; + finished = true; + for (int i = dimension - 1; 0 <= i; --i) + finished &= (cur_dim[i] == 0); + } + ok &= h.terminate (ofs, dimension, geometry, position); + return ok; +} + + +static bool +write_file (string filename, + int dimension, + int *geometry, + howto h, ofstream & success_log, ofstream & fail_log) +{ + ofstream ofs; + write_prelude (ofs, filename.c_str ()); + + int middle = geometry[0] + 1; + for (int i = dimension - 1; 0 < i; --i) + middle *= (geometry[i] + 1); + middle = middle >> 1; + + stringstream decl; + decl << " array" << dimension << "d< array" << dimension << "d_info< "; + for (int i = 0; i < dimension; ++i) + decl << (geometry[i] + 1) << (i == dimension - 1 ? "" : ", "); + for (int i = 0; i < dimension; ++i) + if (1 == (geometry[i] & 1)) + { + decl << ", 0"; + break; + } + decl << " >, int > foo = (ints_" << dimension << "d = " << endl << "\t\t"; + int ok; + ok = fill_array (decl, dimension, geometry, h); + + ofs << decl.str (); + return write_postlude_and_test (ofs, + const_cast < char *>(filename.c_str ()), + dimension, h, ok, success_log, fail_log, + decl); +} + + +bool +check () +{ + string filename = "gentest_array.cc"; + + ofstream success_log ("success.log", ios::out); + ofstream fail_log ("fail.log", ios::out); + + bool fail = false;; + + for (int dimension = MIN_DIMENSION; dimension <= MAX_DIMENSION; ++dimension) + { + int *current_geometry = (int *) malloc (dimension * sizeof (int)); + for (int i = dimension - 1; i >= 0; --i) + current_geometry[i] = 2; + current_geometry[dimension - 1] = 3; + + bool finished = false; + while (!finished) + { + for (int i = dimension - 1; i >= 0; --i) + if (0 <= --current_geometry[i]) + break; + else + current_geometry[i] = 2; + finished = true; + for (int i = dimension - 1; i >= 0; --i) + if (current_geometry[i] > 0) + finished = false; + + for (int i = 0; methods[dimension - 1][i].element != 0; ++i) + fail |= write_file (filename, dimension, current_geometry, + methods[dimension - 1][i], + success_log, fail_log); + } + free (current_geometry); + } + success_log.close (); + fail_log.close (); + remove (filename.c_str ()); + remove ("./a.out"); + return fail; +}

19 years, 9 months

proto-1.0 70: Add missing files in makefile.src

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/makefile.src: Add missing files. makefile.src | 8 +++++++- 1 files changed, 7 insertions(+), 1 deletion(-) Index: oln/makefile.src --- oln/makefile.src (revision 69) +++ oln/makefile.src (working copy) @@ -12,22 +12,28 @@ config/pconf.hh \ config/system.hh \ core/1d/array1d.hh \ + core/1d/dpoint1d.hh \ + core/1d/fwd_piter1d.hh \ core/1d/image1d.hh \ core/1d/point1d.hh \ core/1d/size1d.hh \ core/2d/array2d.hh \ + core/2d/dpoint2d.hh \ + core/2d/fwd_piter2d.hh \ core/2d/image2d.hh \ - core/2d/fwd_piter2d.hh \ core/2d/point2d.hh \ core/2d/size2d.hh \ core/3d/array3d.hh \ + core/3d/fwd_piter3d.hh \ core/3d/image3d.hh \ core/3d/point3d.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_constness.hh \ + core/abstract/image_dimension.hh \ core/abstract/image_identity.hh \ core/abstract/image_with_data.hh \ core/abstract/images.hh \

19 years, 9 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches