Olena-patches March 2005

olena-patches@lrde.epita.fr

10 participants
59 discussions

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

proto-1.0 69: Maintenance on configure.ac and oln.m4

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * configure.ac: Prevent .in files from the doc from being needed when the doc is not going to be built. * config/oln.m4: Change OLN_VERSION to 1.0. config/oln.m4 | 2 +- configure.ac | 16 +++++++++++----- 2 files changed, 12 insertions(+), 6 deletions(-) Index: configure.ac --- configure.ac (revision 59) +++ configure.ac (working copy) @@ -19,7 +19,6 @@ OLN_PATH_LOCAL([olena]) AC_WITH_OLN -echo $CPPFLAGS # Some library archives are used. Some C code used. AC_PROG_RANLIB @@ -39,10 +38,8 @@ metalic/mlc/Makefile olena/Makefile olena/oln/Makefile - olena/oln/config/pconf.hh:olena/oln/config/pconf-hh.in - doc/ref/out/exdoc.config:doc/ref/out/exdoc.config.in - doc/ref/exdoc.mk:doc/ref/exdoc.mk.in - doc/ref/doxygen.config:doc/ref/doxygen.config.in]) + olena/img/Makefile + olena/oln/config/pconf.hh:olena/oln/config/pconf-hh.in]) ### Olena components. @@ -104,6 +101,7 @@ OLN_TESTS([core]) OLN_TESTS([sanity]) OLN_TESTS([io]) + OLN_TESTS([level]) AC_SUBST([OLN_TESTS_SUBDIRS]) @@ -141,6 +139,8 @@ # NTG_TESTS defined in oln-local.m4 NTG_TESTS([sanity]) + NTG_TESTS([types]) + NTG_TESTS([utils]) AC_SUBST([NTG_TESTS_SUBDIRS]) @@ -216,6 +216,12 @@ ### The reference manual uses Doxygen ### FIXME: could be much better. + AC_CONFIG_FILES([ + doc/ref/out/exdoc.config:doc/ref/out/exdoc.config.in + doc/ref/exdoc.mk:doc/ref/exdoc.mk.in + doc/ref/doxygen.config:doc/ref/doxygen.config.in]) + + AC_ARG_WITH([doc-ref], [Doxygen is needed to build the doc], [AC_CHECK_PROG([DOXYGEN], [doxygen], [doxygen]) Index: config/oln.m4 --- config/oln.m4 (revision 59) +++ config/oln.m4 (working copy) @@ -628,7 +628,7 @@ ### # $Format: "m4_define([OLN_VERSION], [0.$ProjectMajorVersion$])"$ -m4_define([OLN_VERSION], [0.10]) +m4_define([OLN_VERSION], [1.0]) m4_define([OLN_CONTACT], [olena-bugs(a)lrde.epita.fr]) # OLN_COLLECTION([subdirs-variable-name],

19 years, 9 months

proto-1.0 68: Add olena images into the distribution

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * Makefile.am: Add `img' to the subdirectories list. * img/Makefile.am: Declare images to distribute. Makefile.am | 2 +- img/Makefile.am | 12 ++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) Index: Makefile.am --- Makefile.am (revision 67) +++ Makefile.am (working copy) @@ -1,5 +1,5 @@ ## Process this file with Automake to produce Makefile.in -*- Makefile -*- # OLN_SRC_SUBDIRS is set when "configure" is run. -SUBDIRS = oln $(OLN_SRC_SUBDIRS) +SUBDIRS = img oln $(OLN_SRC_SUBDIRS) Index: img/Makefile.am --- img/Makefile.am (revision 0) +++ img/Makefile.am (revision 0) @@ -0,0 +1,12 @@ +SOURCE_IMGS = \ + $(srcdir)/chien.pbm \ + $(srcdir)/chien.pbm.gz \ + $(srcdir)/lena.pbm \ + $(srcdir)/lena.pbm.gz \ + $(srcdir)/lena.pgm \ + $(srcdir)/lena.pgm.gz \ + $(srcdir)/lena.ppm \ + $(srcdir)/lena.ppm.gz + +dist_pkgdata_DATA = $(SOURCE_IMGS) +

19 years, 9 months

proto-1.0 67: Add level operators in olena

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/level: New. * tests/level/tests: New. * tests/level/tests/compare: New. * tests/level/tests/fill: New. * tests/level/runs: New. * tests/level/Makefile.am: New. * oln/makefile.src: Add new files. * oln/level: New. * oln/level/compare.hh: Add comparison operators for images. * oln/level/fill.hh: Add fill function for images. oln/level/compare.hh | 132 ++++++++++++++++++++++++++++++++++++++++++++++ oln/level/fill.hh | 53 ++++++++++++++++++ oln/makefile.src | 4 + tests/level/Makefile.am | 4 + tests/level/tests/compare | 76 ++++++++++++++++++++++++++ tests/level/tests/fill | 50 +++++++++++++++++ 6 files changed, 318 insertions(+), 1 deletion(-) Index: tests/level/tests/compare --- tests/level/tests/compare (revision 0) +++ tests/level/tests/compare (revision 0) @@ -0,0 +1,76 @@ +// -*- c++ -*- +// Copyright (C) 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. + +#include <ntg/all.hh> +#include <oln/basics2d.hh> +#include <oln/level/fill.hh> +#include <oln/level/compare.hh> +#include <iostream> +#include "check.hh" +#include "data.hh" + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +#define ASSERT_CHECK(Val) { assert_check(Val, #Val, fail); } + +void assert_check(bool res, const std::string& desc, bool &fail) +{ + std::cout << "---- " << desc << " ----" << std::endl; + if (res) + OK_OR_FAIL; +} + + +bool +check(void) +{ + bool fail = false; + + oln::image2d<ntg::int_u8> + im_0(16, 16), + im_20(16, 16); + oln::level::fill(im_0, 0); + oln::level::fill(im_20, 20); + + ASSERT_CHECK(oln::level::is_greater(im_20, im_0)); + ASSERT_CHECK(!oln::level::is_greater(im_0, im_20)); + ASSERT_CHECK(oln::level::is_greater_or_equal(im_0, im_0)); + + ASSERT_CHECK(oln::level::is_lower(im_0, im_20)); + ASSERT_CHECK(!oln::level::is_lower(im_20, im_0)); + ASSERT_CHECK(oln::level::is_lower_or_equal(im_0, im_0)); + + ASSERT_CHECK(oln::level::is_equal(im_0, im_0)); + return fail; +} Index: tests/level/tests/fill --- tests/level/tests/fill (revision 0) +++ tests/level/tests/fill (revision 0) @@ -0,0 +1,50 @@ +// -*- c++ -*- +// Copyright (C) 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. + +#include <ntg/all.hh> +#include <oln/basics2d.hh> +#include <oln/level/fill.hh> +#include <iostream> +#include "check.hh" +#include "data.hh" + +bool +check(void) +{ + + oln::image2d<ntg::int_u8> im(10, 10); + + oln::level::fill(im, 51); + + oln::fwd_piter2d it(im.size()); + for_all(it) + if (im[it] != 51) + return true; + + return false; +} Index: tests/level/Makefile.am --- tests/level/Makefile.am (revision 0) +++ tests/level/Makefile.am (revision 0) @@ -0,0 +1,4 @@ +include ../check/Makefile.runtests + +CLEANFILES += cc 2nd_cc connected_out lena_inverted set_level \ + set_level2 threshold_128 Index: oln/makefile.src --- oln/makefile.src (revision 66) +++ oln/makefile.src (working copy) @@ -46,4 +46,6 @@ io/read_image_2d_pnm.hh \ io/utils.hh \ io/write_image.hh \ - io/write_image_2d_pnm.hh + io/write_image_2d_pnm.hh \ + level/compare.hh \ + level/fill.hh Index: oln/level/compare.hh --- oln/level/compare.hh (revision 0) +++ oln/level/compare.hh (revision 0) @@ -0,0 +1,132 @@ +// 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_LEVEL_COMPARE_HH +# define OLENA_LEVEL_COMPARE_HH + +# include <oln/basics.hh> + +namespace oln { + + namespace level { + + /*! \brief Tests if all pixels of input1 are greater or equal than input2. + ** + ** \pre input1.size() == input2.size() + **/ + template<class I1, class I2> inline + bool + is_greater_or_equal(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) + { + precondition(input1.size() == input2.size()); + oln_type_of(I1, fwd_piter) p(input1.size()); + + for_all (p) + if (!(input1[p] >= input2[p])) + return false; + return true; + } + + /*! \brief Tests if all pixels of input1 are greater than input2. + ** + ** \pre input1.size() == input2.size() + **/ + template<class I1, class I2> inline + bool + is_greater(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) + { + precondition(input1.size() == input2.size()); + oln_type_of(I1, fwd_piter) p(input1.size()); + + for_all (p) + if (!(input1[p] > input2[p])) + return false; + return true; + } + + /*! \brief Tests if all pixels of input1 are lower or equal than input2. + ** + ** \pre input1.size() == input2.size() + **/ + template<class I1, class I2> inline + bool + is_lower_or_equal(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) + { + precondition(input1.size() == input2.size()); + oln_type_of(I1, fwd_piter) p(input1.size()); + + for_all (p) + if (!(input1[p] <= input2[p])) + return false; + return true; + } + + /*! \brief Tests if all pixel of input1 are lower than input2. + ** + ** \pre input1.size() == input2.size() + **/ + template<class I1, class I2> inline + bool + is_lower(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) + { + precondition(input1.size() == input2.size()); + oln_type_of(I1, fwd_piter) p(input1.size()); + + for_all (p) + if (!(input1[p] < input2[p])) + return false; + return true; + } + + + /*! \brief Tests if input1 is equal to input2. + ** + ** \pre input1.size() == input2.size() + **/ + template<class I1, class I2> inline + bool + is_equal(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) + { + precondition(input1.size() == input2.size()); + oln_type_of(I1, fwd_piter) p(input1.size()); + + for_all (p) + if (!(input1[p] == input2[p])) + return false; + return true; + } + + } // end of namespace level + +} // end of namespace oln + +#endif // ! OLENA_LEVEL_COMPARE_HH Index: oln/level/fill.hh --- oln/level/fill.hh (revision 0) +++ oln/level/fill.hh (revision 0) @@ -0,0 +1,53 @@ +// 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_LEVEL_FILL_HH +# define OLENA_LEVEL_FILL_HH + +# include <oln/basics.hh> + +namespace oln { + + namespace level { + + /*! \brief Fill the image with a value. + */ + template <class I> + I + fill(abstract::image& im, const oln_type_of(I, value)& val) + { + oln_type_of(I, fwd_piter) p(im.size()); + for_all(p) + im[p] = val; + return im.exact(); + } + + } // end of namespace level + +} // end of namespace oln + +#endif // ! OLENA_LEVEL_FILL_HH

19 years, 9 months

proto-1.0 66: Add tests for forward point iterators

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/core/tests/piter1d: Add test for 1D forward point iterators. * tests/core/tests/piter2d: Add test for 2D forward point iterators. * tests/core/tests/piter3d: Add test for 3D forward point iterators. piter1d | 29 +++++++++++++++++++++++++++++ piter2d | 29 +++++++++++++++++++++++++++++ piter3d | 29 +++++++++++++++++++++++++++++ 3 files changed, 87 insertions(+) Index: tests/core/tests/piter1d --- tests/core/tests/piter1d (revision 0) +++ tests/core/tests/piter1d (revision 0) @@ -0,0 +1,29 @@ + +#include <iostream> + +#include <ntg/all.hh> +#include <oln/basics1d.hh> + +#include "check.hh" +#include "data.hh" + + + + +bool check() +{ + oln::image1d<int> ima(10); + int cpt = 0; + + oln::fwd_piter1d it(ima.size()); + for_all (it) + { + ima[it] = 0; + cpt++; + } + + if (cpt != 10) + return true; + + return false; +} Index: tests/core/tests/piter2d --- tests/core/tests/piter2d (revision 0) +++ tests/core/tests/piter2d (revision 0) @@ -0,0 +1,29 @@ + +#include <iostream> + +#include <ntg/all.hh> +#include <oln/basics2d.hh> + +#include "check.hh" +#include "data.hh" + + + + +bool check() +{ + oln::image2d<int> ima(10, 10); + int cpt = 0; + + oln::fwd_piter2d it(ima.size()); + for_all (it) + { + ima[it] = 0; + cpt++; + } + + if (cpt != 100) + return true; + + return false; +} Index: tests/core/tests/piter3d --- tests/core/tests/piter3d (revision 0) +++ tests/core/tests/piter3d (revision 0) @@ -0,0 +1,29 @@ + +#include <iostream> + +#include <ntg/all.hh> +#include <oln/basics3d.hh> + +#include "check.hh" +#include "data.hh" + + + + +bool check() +{ + oln::image3d<int> ima(10, 10, 10); + int cpt = 0; + + oln::fwd_piter3d it(ima.size()); + for_all (it) + { + ima[it] = 0; + cpt++; + } + + if (cpt != 1000) + return true; + + return false; +}

19 years, 9 months

proto-1.0 64: Adapt oln to integre

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/io/loadsave.hh: Adapt to integre. * tests/core/tests/readonly_image: Likewise. * tests/core/tests/image1d: Likewise. * tests/core/tests/image2d: Likewise. * tests/core/tests/readwrite_image: Likewise. * tests/core/tests/image3d: Likewise. * tests/core/tests/image_identity: Likewise. * oln/fancy/print.hh: Likewise. * oln/basics.hh: Likewise. * oln/basics1d.hh: Likewise. * oln/io/write_image_2d_pnm.hh: Likewise. * oln/io/read_image_2d_pnm.hh: Likewise. * oln/io/utils.hh: Likewise. * oln/core/value_box.hh: Likewise. oln/basics.hh | 7 --- oln/basics1d.hh | 3 - oln/core/value_box.hh | 48 +++++++++++++++++------ oln/fancy/print.hh | 2 oln/io/read_image_2d_pnm.hh | 66 +++++++++++++++++++------------- oln/io/utils.hh | 20 +++++++++ oln/io/write_image_2d_pnm.hh | 80 +++++++++++++++++++++------------------ tests/core/tests/image1d | 2 tests/core/tests/image2d | 2 tests/core/tests/image3d | 2 tests/core/tests/image_identity | 2 tests/core/tests/readonly_image | 8 +-- tests/core/tests/readwrite_image | 8 +-- tests/io/loadsave.hh | 15 +++++-- 14 files changed, 166 insertions(+), 99 deletions(-) Index: tests/io/loadsave.hh --- tests/io/loadsave.hh (revision 59) +++ tests/io/loadsave.hh (working copy) @@ -8,6 +8,7 @@ #include "check.hh" #include "data.hh" + template<typename E> bool compare(const oln::abstract::image<E>& a, const oln::abstract::image<E>& b) @@ -19,9 +20,11 @@ a.size().ncols() != b.size().ncols()) return false; - for (it.start(); !it.is_valid(); it.next()) - if (a[it] != b[it]) - return false; + for_all(it) + { + if (a[it] != b[it]) + return false; + } return true; } @@ -33,12 +36,16 @@ bool fail = false; T im1, im2; + im1 = oln::io::read(name); + + oln::io::write(im1, savename); + im2 = oln::io::read(savename); - if (compare(im1, im2)) + if (compare(im1, im2) == true) std::cout << "OK" << std::endl; else { Index: tests/core/tests/readonly_image --- tests/core/tests/readonly_image (revision 59) +++ tests/core/tests/readonly_image (working copy) @@ -1,6 +1,6 @@ #include <iostream> -#include <ntg/real/int_u8.hh> +#include <ntg/all.hh> #include <oln/basics2d.hh> #include "check.hh" @@ -14,7 +14,7 @@ struct category_type< dummy_image > { typedef cat::image ret; }; template <> - struct props <cat::image, dummy_image> : + struct props <cat::image, dummy_image> : public default_props < cat::image > { typedef size2d size_type; @@ -49,8 +49,8 @@ } // end of namespace test - - + + bool check() { oln::dummy_image ima(3, 3); Index: tests/core/tests/image1d --- tests/core/tests/image1d (revision 59) +++ tests/core/tests/image1d (working copy) @@ -1,7 +1,7 @@ #include <iostream> -#include <ntg/real/int_u8.hh> +#include <ntg/all.hh> #include <oln/basics1d.hh> #include <oln/fancy/iota.hh> Index: tests/core/tests/image2d --- tests/core/tests/image2d (revision 59) +++ tests/core/tests/image2d (working copy) @@ -1,7 +1,7 @@ #include <iostream> -#include <ntg/real/int_u8.hh> +#include <ntg/all.hh> #include <oln/basics2d.hh> #include <oln/fancy/iota.hh> Index: tests/core/tests/readwrite_image --- tests/core/tests/readwrite_image (revision 59) +++ tests/core/tests/readwrite_image (working copy) @@ -1,6 +1,6 @@ #include <iostream> -#include <ntg/real/int_u8.hh> +#include <ntg/all.hh> #include <oln/basics2d.hh> #include "check.hh" @@ -19,7 +19,7 @@ }; template <> - struct set_props <category::image, dummy_image> : + struct set_props <category::image, dummy_image> : public props_of < category::image > { typedef is_a<abstract::readwrite_image> image_constness; @@ -53,8 +53,8 @@ } // end of namespace test - - + + bool check() { oln::dummy_image ima(3, 3); Index: tests/core/tests/image3d --- tests/core/tests/image3d (revision 59) +++ tests/core/tests/image3d (working copy) @@ -1,7 +1,7 @@ #include <iostream> -#include <ntg/real/int_u8.hh> +#include <ntg/all.hh> #include <oln/basics3d.hh> #include <oln/fancy/iota.hh> Index: tests/core/tests/image_identity --- tests/core/tests/image_identity (revision 59) +++ tests/core/tests/image_identity (working copy) @@ -1,6 +1,6 @@ #include <oln/core/abstract/image_identity.hh> #include <oln/core/2d/image2d.hh> -#include <ntg/real/int_u8.hh> +#include <ntg/all.hh> template <typename I> Index: oln/fancy/print.hh --- oln/fancy/print.hh (revision 59) +++ oln/fancy/print.hh (working copy) @@ -33,7 +33,7 @@ # include <string> -# include <ntg/real/int_u8.hh> // FIXME: no coupling like that! +# include <ntg/real/int_u.hh> // FIXME: no coupling like that! # include <oln/core/abstract/image_dimension.hh> # include <oln/core/1d/point1d.hh> Index: oln/basics.hh --- oln/basics.hh (revision 59) +++ oln/basics.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. - + #ifndef OLENA_BASICS_HH # define OLENA_BASICS_HH @@ -48,9 +48,6 @@ // ntg:: -# include <ntg/real/int_u8.hh> - - // oln:: # include <oln/core/coord.hh> @@ -61,7 +58,7 @@ # include <oln/core/abstract/point.hh> # include <oln/core/abstract/images.hh> -// # include <oln/core/abstract/piter.hh> +# include <oln/core/abstract/piter.hh> // # include <oln/core/abstract/niter.hh> Index: oln/basics1d.hh --- oln/basics1d.hh (revision 59) +++ oln/basics1d.hh (working copy) @@ -28,9 +28,6 @@ #ifndef OLENA_BASICS1D_HH # define OLENA_BASICS1D_HH - -# include <oln/basics.hh> - # include <oln/core/1d/size1d.hh> # include <oln/core/1d/point1d.hh> # include <oln/core/1d/image1d.hh> Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 59) +++ oln/io/write_image_2d_pnm.hh (working copy) @@ -34,11 +34,7 @@ # include <mlc/box.hh> -# include <ntg/core/macros.hh> -# include <ntg/real/int_u8.hh> -# include <ntg/real/integer.hh> -# include <ntg/enum/enum.hh> -# include <ntg/color/color.hh> +# include <ntg/all.hh> # include <oln/core/2d/image2d.hh> # include <oln/core/abstract/op.hh> @@ -56,15 +52,20 @@ : public oln::abstract::void_op<write_image_2d_raw > { typedef oln_type_of(I, value) value_type; - typedef ntg_io_type(value_type) io_type; const I& to_write_; std::ostream& ostr_; + int bin_offset; + char bin_v; + write_image_2d_raw(const I& to_write, std::ostream& ostr): to_write_(to_write), ostr_(ostr) - {} + { + bin_offset = 7; + bin_v = 0; + } void impl_run() { @@ -74,51 +75,55 @@ for (p.row() = 0; p.row() < to_write_.size().nrows(); ++p.row()) for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col()) - { - c = to_write_[p]; - b = write_value_type(c); - } + // FIXME: SHOULD NOT BE .value() !!! + b = write_value_type(to_write_[p].value()); while (b == false) b = write_value_type(c); + bin_offset = 7; + bin_v = 0; } - bool write_value_type(const ntg::integer<value_type> &c) + //FIXME: Should work with builtin types. + + template <typename E> + bool write_value_type(const ntg::real_value<E> &c) { - io_type v = c.exact(); - ostr_.write((char *)&v, sizeof(io_type)); + typedef oln_io_type(ntg_nbits(E)) v_type; + + v_type v; + v = ntg::cast::bound<E, v_type>(c.exact()); + ostr_.write((char*)&v, sizeof (v_type)); return true; } - bool write_value_type(const ntg::color<value_type> &c) + template <typename E> + bool write_value_type(const ntg::vect_value<E> &c) { - assert ((ntg_depth(value_type) == 3)); - io_type v; - for (unsigned i = 0; i < 3; i++) { + typedef oln_io_type(ntg_nbits(ntg_comp_type(value_type))) v_type; + + v_type v; v = c[i]; - ostr_.write((char *)(&v), sizeof(io_type)); + ostr_.write((char*)&v, sizeof (v_type)); } return true; } - bool write_value_type(const ntg::enum_value<value_type> &c) + bool write_value_type(const ntg::bin &c) { - assert ((ntg_max_val(value_type) == 1)); - static int offset = 7; - static unsigned char v = 0; bool ret = false; - if (offset == -1) + if (bin_offset == -1) { - ostr_.write((char *)&v, 1); - offset = 7; - v = 0; + ostr_.write(&bin_v, 1); + bin_offset = 7; + bin_v = 0; ret = true; } - if (c == 1) - v |= 1 << offset; - offset--; + if (c == value_type(1)) + bin_v |= 1 << bin_offset; + bin_offset--; return ret; } }; @@ -126,7 +131,7 @@ template <typename I, typename T> void write(const abstract::image2d& to_write, - const ntg::integer<T>&, + const ntg::real_value<T>&, std::ostream& ostr, const std::string& ext) { @@ -134,6 +139,7 @@ point2d p; size2d s = to_write.size(); + precondition(ntg_nbits(T) <= 16); if (ext == "pgm") if (internal::write_pnm_header(ostr, "P5", s.ncols(), s.nrows(), @@ -151,7 +157,7 @@ template <typename I, typename T> void write(const abstract::image2d& to_write, - const ntg::color<T>&, + const ntg::color_value<T>&, std::ostream& ostr, const std::string& ext) { @@ -159,10 +165,12 @@ point2d p; size2d s = to_write.size(); + precondition(ntg_nbits(ntg_comp_type(T)) <= 16); + precondition(ntg_nb_comp(T) == 3); if (ext == "ppm") if (internal::write_pnm_header(ostr, "P6", s.ncols(), s.nrows(), - ntg_max_val(T))) + ntg_max_val(ntg_comp_type(T)))) { write_image_2d_raw tmp(to_write.exact(), ostr); tmp.run(); @@ -174,9 +182,9 @@ << " file extension (`" << ext << "')" << std::endl; } - template <typename I, typename T> + template <typename I> void write(const abstract::image2d& to_write, - const ntg::enum_value<T>&, + const ntg::bin&, std::ostream& ostr, const std::string& ext) { @@ -186,7 +194,7 @@ if (ext == "pbm") if (internal::write_pnm_header(ostr, "P4", s.ncols(), s.nrows(), - ntg_max_val(T))) + 1)) { write_image_2d_raw tmp(to_write.exact(), ostr); tmp.run(); Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 59) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -32,12 +32,9 @@ # include <string> # include <mlc/box.hh> +# include <mlc/math.hh> -# include <ntg/core/macros.hh> -# include <ntg/real/int_u8.hh> -# include <ntg/real/integer.hh> -# include <ntg/enum/enum.hh> -# include <ntg/color/color.hh> +# include <ntg/all.hh> # include <oln/core/2d/image2d.hh> # include <oln/core/abstract/op.hh> @@ -83,7 +80,6 @@ typedef oln::abstract::op<I, read_image_2d_raw > super_type; typedef oln_type_of(I, value) value_type; - typedef ntg_io_type(value_type) io_type; mlc::box image_; std::istream& istr_; @@ -105,18 +101,33 @@ return *this; } + template <typename E> + void precond(ntg::real_value<E>& c) + { + precondition(ntg_max_val(value_type) <= info_.max_val); + precondition(info_.type == "P5"); + } + + template <typename E> + void precond(ntg::vect_value<E>& c) + { + precondition(ntg_max_val(ntg_comp_type(value_type)) <= info_.max_val); + precondition(info_.type == "P6"); + precondition(ntg_nb_comp(value_type) == 3); + } + + void precond(ntg::bin& c) + { + precondition(info_.type == "P4"); + } + void impl_run() { value_type c; point2d p; oln::image2d<value_type> tmp(info_.rows, info_.cols); - if (info_.max_val > ntg_max_val(value_type)) - { - std::cerr << "Can't load image, data type is not large enough" - << std::endl; - return; - } + precond(c); for (p.row() = 0; p.row() < info_.rows && !istr_.eof(); ++p.row()) for (p.col() = 0; p.col() < info_.cols && !istr_.eof(); ++p.col()) @@ -127,32 +138,37 @@ *image_ = tmp; } - void read_value_type(ntg::integer<value_type> &c) + //FIXME: Should work with builtin types. + + template <typename E> + void read_value_type(ntg::real_value<E> &c) { - io_type v; - istr_.read(&v, sizeof (io_type)); - c = v; + typedef oln_io_type(ntg_nbits(E)) v_type; + v_type v; + istr_.read((char*)&v, sizeof (v_type)); + c = ntg::cast::force<E, v_type>(v); } - void read_value_type(ntg::color<value_type> &c) + template <typename E> + void read_value_type(ntg::vect_value<E> &c) { - io_type v; - - for (unsigned i = 0; i < ntg_depth(value_type); i++) + for (unsigned i = 0; i < ntg_nb_comp(E); i++) { - istr_.read(&v, sizeof (v)); - c[i] = v; + typedef oln_io_type(ntg_nbits(ntg_comp_type(E))) v_type; + v_type v; + istr_.read((char*)&v, sizeof (v_type)); + c[i] = ntg::cast::force<ntg_comp_type(E), v_type>(v); } } - void read_value_type(ntg::enum_value<value_type> &c) + void read_value_type(ntg::bin &c) { - static io_type v; + static char v; static int offset = -1; if (offset == -1) { - istr_.read((char *)(&v), sizeof (v)); + istr_.read(&v, 1); offset = 7; } if ((int)(v & (1<<offset--)) == 0) Index: oln/io/utils.hh --- oln/io/utils.hh (revision 59) +++ oln/io/utils.hh (working copy) @@ -40,6 +40,7 @@ namespace internal { + /*! ** \brief Utils for io (get extension of a file). */ @@ -148,11 +149,30 @@ return true; } + template <bool b> + struct pnm_io_helper + { + enum { size = 1}; + typedef unsigned char type; + }; + template <> + struct pnm_io_helper<false> + { + enum { size = 2}; + typedef unsigned short 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 + + #endif // ! OLENA_IO_UTILS_HH Index: oln/core/value_box.hh --- oln/core/value_box.hh (revision 59) +++ oln/core/value_box.hh (working copy) @@ -81,24 +81,35 @@ /// op== - bool operator==(const value_box& value) const + bool operator==(const value_box<const I>& rhs) const { - return this->value() == value.value(); + return this->value() == rhs.value(); } template <typename V> - bool operator==(const V& value) const + bool operator==(const V& rhs) const { - return this->value() == value; + return this->value() == rhs; } template <typename V> - bool operator!=(const V& value) const + bool operator!=(const V& rhs) const { - return ! this->operator==(value); + return ! this->operator==(rhs); } + template <typename V> + bool operator<(const V& rhs) const + { + return this->value() < rhs; + } + template <typename II> + bool operator<(const value_box<II>& rhs) const + { + return this->value() < value.value(); + } + /*! \brief op= ** FIXME:... ** \return (*this) @@ -123,7 +134,7 @@ template <typename II> value_box& operator=(const value_box<II>& rhs) { - ima_->set(p_, rhs); // automatic conversion from rhs to value_type + ima_->set(p_, rhs.value()); // automatic conversion from rhs to value_type return *this; } @@ -240,24 +251,35 @@ /// op== - bool operator==(const value_box<const I>& value) const + bool operator==(const value_box<const I>& rhs) const { - return this->value() == value.value(); + return this->value() == rhs.value(); } template <typename V> - bool operator==(const V& value) const + bool operator==(const V& rhs) const { - return this->value() == value; + return this->value() == rhs; } template <typename V> - bool operator!=(const V& value) const + bool operator!=(const V& rhs) const { - return ! this->operator==(value); + return ! this->operator==(rhs); } + template <typename V> + bool operator<(const V& rhs) const + { + return this->value() < rhs; + } + template <typename II> + bool operator<(const value_box<II>& rhs) const + { + return this->value() < rhs.value(); + } + /*! \brief Assignment (op=) is declared but undefined. */

19 years, 9 months

proto-1.0 63: Add power of 2 traits in metalic

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/math.hh: Add power of 2 traits. * mlc/makefile.src: Add new file. makefile.src | 1 math.hh | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+) Index: mlc/math.hh --- mlc/math.hh (revision 0) +++ mlc/math.hh (revision 0) @@ -0,0 +1,82 @@ +// Copyright (C) 2001, 2002, 2003 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 METALIC_MATH_HH +# define METALIC_MATH_HH + +# include <mlc/bool.hh> + +namespace mlc +{ + + namespace internal + { + + // Helper structs for pow2sup below. + + template<unsigned N> struct is_pow2 { typedef false_type ret; }; + template<> struct is_pow2<8> { typedef true_type ret; }; + template<> struct is_pow2<16> { typedef true_type ret; }; + template<> struct is_pow2<32> { typedef true_type ret; }; + template<> struct is_pow2<64> { typedef true_type ret; }; + + template<unsigned N, class> struct find_pow2sup; + template<unsigned N> struct find_pow2sup<N,true_type> { + enum { value = N }; + }; + template<unsigned N> struct find_pow2sup<N,false_type> { + enum { value = find_pow2sup< N+1, + typename is_pow2<N+1>::ret >::value }; + }; + + } // end of internal + + // Smaller power of 2 greater than N. + + template<unsigned N> + struct pow2sup { + enum { + value = + internal::find_pow2sup< N, + typename internal::is_pow2<N>::ret >::value + }; + private: + typedef typename is_true<N < 32>::ensure_type precondition_type; + }; + + // Various tests on N (actually, we tests only oddness.) + + template<unsigned N> + class utest { + public: + typedef typename is_true<N/2 == (N+1)/2>::ensure_type is_odd_type; + static void ensure_odd() { is_odd_type::is_true(); } + }; + +} // end of namespace mlc + +#endif // METALIC_MATH_HH Index: mlc/makefile.src --- mlc/makefile.src (revision 62) +++ mlc/makefile.src (working copy) @@ -20,6 +20,7 @@ config/system.hh \ contract.hh \ is_a.hh \ + math.hh \ properties.hh \ tracked_ptr.hh \ traits.hh \

19 years, 9 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches March 2005