00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include <mln/core/image/image1d.hh>
00027 #include <mln/core/image/image2d.hh>
00028 #include <mln/core/image/image3d.hh>
00029
00030 #include <mln/value/int_u8.hh>
00031 #include <mln/value/int_u16.hh>
00032 #include <mln/value/int_s8.hh>
00033 #include <mln/value/int_s16.hh>
00034
00035 #include <mln/data/compare.hh>
00036
00037 #include <mln/debug/iota.hh>
00038 #include <mln/arith/plus.hh>
00039 #include <mln/arith/minus.hh>
00040
00041
00042 struct f_box1d_t : mln::Function_v2b< f_box1d_t >
00043 {
00044 f_box1d_t(const mln::box1d& b)
00045 : b_(b)
00046 {
00047 }
00048 mln::box1d b_;
00049 bool operator()(const mln::point1d& p) const
00050 {
00051 return b_.has(p);
00052 }
00053 };
00054
00055 struct f_box2d_t : mln::Function_v2b< f_box2d_t >
00056 {
00057 f_box2d_t(const mln::box2d& b)
00058 : b_(b)
00059 {
00060 }
00061 mln::box2d b_;
00062 bool operator()(const mln::point2d& p) const
00063 {
00064 return b_.has(p);
00065 }
00066 };
00067
00068 struct f_box3d_t : mln::Function_v2b< f_box3d_t >
00069 {
00070 f_box3d_t(const mln::box3d& b)
00071 : b_(b)
00072 {
00073 }
00074 mln::box3d b_;
00075 bool operator()(const mln::point3d& p) const
00076 {
00077 return b_.has(p);
00078 }
00079 };
00080
00081
00082 namespace mln
00083 {
00084 template<typename I, typename J>
00085 void
00086 test_less(I& lhs, J& rhs)
00087 {
00088 mln_assertion(! (lhs == rhs));
00089 mln_assertion( (lhs <= rhs));
00090 mln_assertion( (lhs < rhs));
00091 mln_assertion(! (lhs >= rhs));
00092 mln_assertion(! (lhs > rhs));
00093
00094 mln_assertion(! (rhs == lhs));
00095 mln_assertion(! (rhs <= lhs));
00096 mln_assertion(! (rhs < lhs));
00097 mln_assertion( (rhs >= lhs));
00098 mln_assertion( (rhs > lhs));
00099 }
00100
00101 template<typename I, typename J>
00102 void
00103 test_more(I& lhs, J& rhs)
00104 {
00105 mln_assertion(! (lhs == rhs));
00106 mln_assertion( (lhs <= rhs));
00107 mln_assertion( (lhs < rhs));
00108 mln_assertion(! (lhs >= rhs));
00109 mln_assertion(! (lhs > rhs));
00110
00111 mln_assertion(! (rhs == lhs));
00112 mln_assertion(! (rhs <= lhs));
00113 mln_assertion(! (rhs < lhs));
00114 mln_assertion( (rhs >= lhs));
00115 mln_assertion( (rhs > lhs));
00116 }
00117
00118 template<typename I, typename J>
00119 void
00120 test_equal(I& lhs, J& rhs)
00121 {
00122 mln_assertion( (lhs == rhs));
00123 mln_assertion( (lhs <= rhs));
00124 mln_assertion(! (lhs < rhs));
00125 mln_assertion( (lhs >= rhs));
00126 mln_assertion(! (lhs > rhs));
00127
00128 mln_assertion( (rhs == lhs));
00129 mln_assertion( (rhs <= lhs));
00130 mln_assertion(! (rhs < lhs));
00131 mln_assertion( (rhs >= lhs));
00132 mln_assertion(! (rhs > lhs));
00133 }
00134
00135 template <typename I>
00136 void
00137 chk1d(unsigned cols)
00138 {
00139 image1d<I> lhs (cols);
00140 image1d<I> rhs (cols);
00141 debug::iota (lhs);
00142 debug::iota (rhs);
00143
00144 test_equal(lhs, rhs);
00145 image1d<int> lhs2 = lhs + 0;
00146 image1d<int> rhs2 = rhs + 1;
00147 test_less(lhs2, rhs2);
00148 image1d<int> lhs3 = lhs - 1;
00149 image1d<int> rhs3 = rhs + 0;
00150 test_more(lhs3, rhs3);
00151 }
00152
00153 template <typename I>
00154 void
00155 chk2d(unsigned rows, unsigned cols)
00156 {
00157 image2d<I> lhs (rows, cols);
00158 image2d<I> rhs (rows, cols);
00159 debug::iota (lhs);
00160 debug::iota (rhs);
00161
00162 test_equal(lhs, rhs);
00163 image2d<int> lhs2 = lhs + 0;
00164 image2d<int> rhs2 = rhs + 1;
00165 test_less(lhs2, rhs2);
00166 image2d<int> lhs3 = lhs - 1;
00167 image2d<int> rhs3 = rhs + 0;
00168 test_more(lhs3, rhs3);
00169 }
00170
00171 template <typename I>
00172 void
00173 chk3d(unsigned slis, unsigned rows, unsigned cols)
00174 {
00175 image3d<I> lhs (slis, rows, cols);
00176 image3d<I> rhs (slis, rows, cols);
00177 debug::iota (lhs);
00178 debug::iota (rhs);
00179
00180 test_equal(lhs, rhs);
00181 image3d<int> lhs2 = lhs + 0;
00182 image3d<int> rhs2 = rhs + 1;
00183 test_less(lhs2, rhs2);
00184 image3d<int> lhs3 = lhs - 1;
00185 image3d<int> rhs3 = rhs + 0;
00186 test_more(lhs3, rhs3);
00187 }
00188 }
00189
00190
00191
00192
00193 int main()
00194 {
00195 using namespace mln;
00196
00197 unsigned slis_start = 1;
00198 unsigned slis_end = 3;
00199
00200 unsigned rows_start = 1;
00201 unsigned rows_end = 16;
00202
00203 unsigned cols_start = 1;
00204 unsigned cols_end = 32;
00205
00206 std::cerr << "Tests data::compare" << std::endl;
00207
00208 (std::cerr << "in 1d ... ").flush ();
00209 {
00210 for (unsigned i = cols_start; i < cols_end; ++i)
00211 {
00212 chk1d<int>(i);
00213 chk1d<unsigned>(i);
00214 chk1d<value::int_u8>(i);
00215 chk1d<value::int_u16>(i);
00216 chk1d<value::int_s8>(i);
00217 chk1d<value::int_s16>(i);
00218 }
00219 }
00220 std::cerr << "OK" << std::endl;
00221
00222 (std::cerr << "in 2d ... ").flush ();
00223 {
00224 for (unsigned j = rows_start; j < rows_end; ++j)
00225 for (unsigned i = cols_start; i < cols_end; ++i)
00226 {
00227 chk2d<int>(j, i);
00228 chk2d<unsigned>(j, i);
00229 chk2d<value::int_u8>(j, i);
00230 chk2d<value::int_u16>(j, i);
00231 chk2d<value::int_s8>(j, i);
00232 chk2d<value::int_s16>(j, i);
00233 }
00234 }
00235 std::cerr << "OK" << std::endl;
00236
00237 (std::cerr << "in 3d ... ").flush ();
00238 {
00239 for (unsigned k = slis_start; k < slis_end; ++k)
00240 for (unsigned j = rows_start; j < rows_end; ++j)
00241 for (unsigned i = cols_start; i < cols_end; ++i)
00242 {
00243 chk3d<int>(k, j, i);
00244 chk3d<unsigned>(k, j, i);
00245 chk3d<value::int_u8>(k, j, i);
00246 chk3d<value::int_u16>(k, j, i);
00247 chk3d<value::int_s8>(k, j, i);
00248 chk3d<value::int_s16>(k, j, i);
00249 }
00250 }
00251 std::cerr << "OK" << std::endl;
00252 }