[Pkg-octave-devel] First try on autopkgtest for OF packages

Rafael Laboissière rafael at debian.org
Wed Aug 30 14:21:59 UTC 2017


* Oliver Heimlich <oheim at posteo.de> [2017-08-30 09:09]:

> On 29.08.2017 10:45, Rafael Laboissière wrote:
>> * Sébastien Villemot <sebastien at debian.org> [2017-08-29 10:28]:
>>
>>> I am also wondering if we should not make test failures fatal at build 
>>> time. This would probably cause a few FTBFS in the short term, but in 
>>> the longer run this would improve the quality of the packages.
>>
>> Yes, absolutely.  If a unit test fails, then either the functionality or 
>> the test are wrong and must be fixed.
>
> I totally agree on that one.  The interval package (where it is of 
> particular importance that it produces correct results) has an 
> extensive test suite and the build fails if one of the tests fails.

Ok, with my last commits on the octave-pkg-dev repository, check-pkg has 
now the ability to collect the results of the tests and to exit with an 
error code when any of the tests fails (after running all of them, of 
course).

With this version of octave-pkg-dev installed in the system, the 
following command run from the autopktest branch in the octave-image 
package:

autopkgtest -B . -- null

produces the log attached below.

Notice that at the end of the log file, there is the following text, 
showing that the autopkgtest fails:

 Summary: 1169 tests, 1134 passed, 21 known failures, 0 skipped
 /usr/share/cdbs/1/class/octave-pkg.mk:108: recipe for target
 'check-pkg' failed
 make: *** [check-pkg] Error 1
 autopkgtest [11:06:09]: test unit-tests: -----------------------]
 autopkgtest [11:06:09]: test unit-tests:  - - - - - - - - - - results
 - - - - - - - - - -
 unit-tests           FAIL non-zero exit status 2
 autopkgtest [11:06:09]: @@@@@@@@@@@@@@@@@@@@ summary
 unit-tests           FAIL non-zero exit status 2

The code in check-pkg is kind of convoluted.  Take this a proof of 
concept.

Comments are welcome.

Rafael
-------------- next part --------------
autopkgtest [11:04:11]: version 4.4
autopkgtest [11:04:11]: host dev; command line: /usr/bin/autopkgtest -B . -- null
autopkgtest [11:04:11]: testbed dpkg architecture: amd64
autopkgtest [11:04:11]: testbed running kernel: Linux 4.9.0-3-amd64 #1 SMP Debian 4.9.30-2 (2017-06-12)
autopkgtest [11:04:11]: @@@@@@@@@@@@@@@@@@@@ unbuilt-tree .
dpkg-source: info: using options from real-tree/debian/source/options: --extend-diff-ignore=inst/im2double.m|src/Makefile|src/config.h|src/config.log|src/config.status
autopkgtest [11:04:11]: testing package octave-image version 2.6.1-2
autopkgtest [11:04:11]: build not needed
autopkgtest [11:04:11]: test unit-tests: preparing testbed
Starting pkgProblemResolver with broken count: 0
Starting 2 pkgProblemResolver with broken count: 0
Done
autopkgtest [11:04:12]: test unit-tests: [-----------------------
/usr/share/octave-pkg-dev/check-pkg
Checking package...
echo Checking m files ...
warning: function /usr/share/octave/packages/image-2.6.1/im2double.m shadows a core library function
warning: called from
    load_packages_and_dependencies at line 48 column 5
    load_packages at line 47 column 3
    pkg at line 411 column 7
    /var/tmp/file8moa2S at line 6 column 5
[stdfilt]
>>>>> /usr/share/octave/packages/image-2.6.1/stdfilt.m
***** test
 im = stdfilt (ones (5));
 assert (im, zeros (5));
1 test, 1 passed, 0 known failure, 0 skipped
[rangefilt]
>>>>> /usr/share/octave/packages/image-2.6.1/rangefilt.m
***** test
 im = rangefilt (ones (5));
 assert (im, zeros (5));
1 test, 1 passed, 0 known failure, 0 skipped
[imtransform]
>>>>> /usr/share/octave/packages/image-2.6.1/imtransform.m
***** demo
 ## Various linear transforms
 figure (); 
 im = [checkerboard(20, 2, 4); checkerboard(40, 1, 2)];
 %input space corners
 incp = [1 1; 160 1; 160 160; 1 160];
 udata = [min(incp(:,1)) max(incp(:,1))];
 vdata = [min(incp(:,2)) max(incp(:,2))];
 subplot (2,3,1); 
 imshow (im)
 hold on
 plot (incp(:,1), incp(:,2), 'ob')
 axis on
 xlabel ('Original')
 
 % Translation and scaling
 outcp = incp * 2;
 outcp(:,1) += 200; 
 outcp(:,2) += 500;
 T = maketform ('affine', incp(1:3,:), outcp(1:3,:));
 subplot (2,3,2); 
 [im2 xdata ydata] = imtransform (im, T, 'udata', udata,
                                  'vdata', vdata, 'fillvalues', 1);
 imh = imshow (im2); set (imh, 'xdata', xdata, 'ydata', ydata) 
 set (gca, 'xlim', xdata, 'ylim', ydata)
 axis on, hold on, xlabel ('Translation / Scaling');
 plot (outcp(:,1), outcp(:,2), 'or')
 
 % Shear
 outcp = [1 1; 160 1; 140 160; -19 160]; % affine only needs 3 control points
 T = maketform ('affine', incp(1:3,:), outcp(1:3,:));
 subplot (2,3,3); 
 [im2 xdata ydata] = imtransform (im, T, 'udata', udata,
                                  'vdata', vdata, 'fillvalues', 1);
 imh = imshow (im2); set (imh, 'xdata', xdata, 'ydata', ydata) 
 set (gca, 'xlim', xdata, 'ylim', ydata)
 axis on, hold on, xlabel ('Shear');
 plot (outcp(:,1), outcp(:,2), 'or')
 
 % Rotation 
 theta = pi/4;
 T = maketform ('affine', [cos(theta) -sin(theta); ...
                           sin(theta) cos(theta); 0 0]);
 outcp = tformfwd (T, incp);
 subplot (2,3,4); 
 [im2 xdata ydata] = imtransform (im, T, 'udata', udata,
                                  'vdata', vdata, 'fillvalues', 1 );
 imh = imshow (im2); set (imh, 'xdata', xdata, 'ydata', ydata) 
 set (gca, 'xlim', xdata, 'ylim', ydata)
 axis on, hold on, xlabel ('Rotation');
 plot (outcp(:,1), outcp(:,2), 'or')

 % Reflection around x axis
 outcp = incp;
 outcp(:,2) *= -1;
 T = cp2tform (incp, outcp, 'similarity');
 subplot (2,3,5); 
 [im2 xdata ydata] = imtransform (im, T, 'udata', udata,
                                  'vdata', vdata, 'fillvalues', 1 );
 imh = imshow (im2); set (imh, 'xdata', xdata, 'ydata', ydata) 
 set (gca, 'xlim', xdata, 'ylim', ydata)
 axis on, hold on, xlabel ('Reflection');
 plot (outcp(:,1), outcp(:,2), 'or')

 % Projection
 outcp = [1 1; 160 -40; 220 220; 12 140];
 T = maketform ('projective', incp, outcp);
 subplot (2,3,6); 
 [im2 xdata ydata] = imtransform (im, T, 'udata', udata,
                                  'vdata', vdata, 'fillvalues', 1 );
 imh = imshow (im2); set (imh, 'xdata', xdata, 'ydata', ydata) 
 set (gca, 'xlim', xdata, 'ylim', ydata)
 axis on, hold on, xlabel ('Projection');
 plot (outcp(:,1), outcp(:,2), 'or')
***** demo
 ## Streched image
 rad = 2; % minimum value: 4/pi
 [uu vv] = meshgrid ((-2:2)/rad, (-2:2)/rad);
 rescfactor = sin ((uu.^2 + vv.^2).^.5);
 inpts = [(reshape (uu, numel (uu), 1)), (reshape (vv, numel (uu), 1))]; 
 xx = rescfactor .* sign(uu);
 yy = rescfactor .* sign(vv);
 outpts = [reshape(xx, numel (xx), 1) reshape(yy, numel (yy), 1)];
 
 T = cp2tform (inpts, outpts, "polynomial", 4);
 figure;
 subplot (1,2,1)
 im = zeros (800, 800, 3);
 im(:,:,1) = checkerboard (100) > 0.2;
 im(:,:,3) = checkerboard (100) < 0.2;
 [im2 xdata ydata] = imtransform (im, T, 'udata', [-2 2],
                                  'vdata', [-2 2], 'fillvalues',
                                  [0 1 0]);
 imh = imshow (im2);
 set (imh, 'xdata', xdata, 'ydata', ydata)
 set (gca, 'xlim', xdata, 'ylim', ydata)
 [im cmap] = imread ('default.img');
 subplot (1,2,2)
 [im2 xdata ydata] = imtransform (im, T, 'udata', [-1 1],
                                  'vdata', [-1 1], 'fillvalues',
                                  round (length (cmap) / 2));
 imh = imshow (im2, cmap);
***** test
 im = checkerboard ();
 incp = [0 0; 0 1; 1 1];
 scl = 10;
 outcp = scl * incp;
 T = maketform ('affine', incp, outcp);
 [im2 xdata ydata] = imtransform (im, T, 'udata', [0 1],
                                  'vdata', [0 1], 'size', [500 500]);
 assert (xdata, scl * ([0 1]))
 assert (ydata, scl * ([0 1]))
 assert (size (im2), [500 500])
***** test
 im = checkerboard ();
 incp = [0 0; 0 1; 1 1];
 scl = 10;
 outcp = scl * incp;
 xyscale = scl;
 T = maketform ('affine', incp, outcp);
 [im2 xdata ydata] = imtransform (im, T, 'xyscale', xyscale);
 assert (size (im2), size (im), 1)
***** test
 im = checkerboard (100, 10, 4);
 theta = 2 * pi;
 T = maketform ("affine", [cos(theta) -sin(theta); ...
                           sin(theta) cos(theta); 0 0]);
 im2 = imtransform (im, T, "nearest", "xdata", [1 800], "ydata", [1 2000]);
 im = im(2:end-1, 2:end-1); %avoid boundaries 
 im2 = im2(2:end-1, 2:end-1);
 assert (im, im2)
***** test
 im = checkerboard (20, 10, 4);
 theta = pi/6;
 T = maketform ('affine', [cos(theta) -sin(theta); ...
                           sin(theta) cos(theta); 0 0]);
 [im2, xdata] = imtransform (im, T);
 nu = columns(im);
 nv = rows(im);
 nx = xdata(2);
 diag = sqrt (nu^2 + nv^2);
 ang = atan (nv / nu);
 assert (nx, diag * abs (cos (theta - ang)),
         diag * 1 / size (im2, 2))
***** test
 im = rand (2);
 tmat = [eye(2); 0 0];
 T = maketform ("affine", tmat);
 im2 = imtransform (im, T, "xdata", [1 3]);
 assert (im2(:,3), zeros (2,1))
***** test
 im = rand (2);
 tmat = [eye(2); 0 0];
 T = maketform ('affine', tmat);
 im2 = imtransform (im, T, "xdata", [1 3]);
 assert (size (im2), [2 3])
***** test
 im = rand (2);
 tmat = [eye(2); 0 0];
 T = maketform ('affine', tmat);
 im2 = imtransform (im, T, "xyscale", [0.5 0.5]);
 assert (size (im2), [3 3])
7 tests, 7 passed, 0 known failure, 0 skipped
[iptcheckmap]
>>>>> /usr/share/octave/packages/image-2.6.1/iptcheckmap.m
***** test ("iptcheckmap (jet(64), 'func', 'var', 2)");                 # simple must work
***** fail ("iptcheckmap (3, 'func', 'var', 2)");                       # not a colormap
2 tests, 2 passed, 0 known failure, 0 skipped
[bwhitmiss]
>>>>> /usr/share/octave/packages/image-2.6.1/bwhitmiss.m
***** test
 bw1 = repmat ([0 1 0 1 1], [3 1]);
 bw2 = repmat ([0 1 0 0 0], [3 1]);
 assert (bwhitmiss (bw1, [1; 0; 1], [1 0 1]), logical (bw2))
 assert (bwhitmiss (bw1, [0 1 0; -1 0 -1; 0 1 0]), logical (bw2))
1 test, 1 passed, 0 known failure, 0 skipped
[padarray]
>>>>> /usr/share/octave/packages/image-2.6.1/padarray.m
***** demo
 padarray([1,2,3;4,5,6],[2,1])
 % pads [1,2,3;4,5,6] with a whole border of 2 rows and 1 columns of 0
***** demo
 padarray([1,2,3;4,5,6],[2,1],5)
 % pads [1,2,3;4,5,6] with a whole border of 2 rows and 1 columns of 5
***** demo
 padarray([1,2,3;4,5,6],[2,1],0,'pre')
 % pads [1,2,3;4,5,6] with a left and top border of 2 rows and 1 columns of 0
***** demo
 padarray([1,2,3;4,5,6],[2,1],'circular')
 % pads [1,2,3;4,5,6] with a whole 'circular' border of 2 rows and 1 columns
 % border 'repeats' data as if we tiled blocks of data
***** demo
 padarray([1,2,3;4,5,6],[2,1],'replicate')
 % pads [1,2,3;4,5,6] with a whole border of 2 rows and 1 columns which
 % 'replicates' edge data
***** demo
 padarray([1,2,3;4,5,6],[2,1],'symmetric')
 % pads [1,2,3;4,5,6] with a whole border of 2 rows and 1 columns which
 % is symmetric to the data on the edge 
***** assert (padarray ([1;2], [1]), [0;1;2;0]);
***** assert (padarray ([3 4], [0 2]), [0 0 3 4 0 0]);
***** assert (padarray ([1 2 3; 4 5 6], [1 2]),
      [zeros(1, 7); 0 0 1 2 3 0 0; 0 0 4 5 6 0 0; zeros(1, 7)]);
***** test
 assert (padarray ([1 2 3; 4 5 6], [3 2 1]),
         cat(3, zeros(8, 7),
                [ [             zeros(3, 7)               ]
                  [zeros(2, 2) [1 2 3; 4 5 6] zeros(2, 2) ]
                  [             zeros(3,7)]               ],
                zeros (8, 7)));
***** assert (padarray ([1 2], [4 5]), padarray ([1 2], [4 5], 0));
***** assert (padarray ([1 2], [4 5]), padarray ([1 2], [4 5], "both"));
***** assert (padarray ([1;2], [1], i), [i; 1; 2; i]);
***** assert (padarray ([1;2], [1], i, "pre"),  [i; 1; 2]);
***** assert (padarray ([1;2], [1], i, "post"), [1; 2; i]);
***** assert (padarray ([1;2], [1], i, "both"), [i; 1; 2; i]);
***** assert (padarray ([1 2], [0 1], i, "pre"),  [i 1 2]);
***** assert (padarray ([1 2], [0 1], i, "post"), [1 2 i]);
***** assert (padarray ([1 2], [0 1], i, "both"), [i 1 2 i]);
***** assert (padarray ([1 2], [0;1], i, "both"), [i 1 2 i]);
***** test
 A = [1 2 3; 4 5 6];
 B = repmat (A, 7, 9);
 assert (padarray (A, [1 2], "circular", "pre"),  B(2:4,2:6));
 assert (padarray (A, [1 2], "circular", "post"), B(3:5,4:8));
 assert (padarray (A, [1 2], "circular", "both"), B(2:5,2:8));
 ## This tests when padding is bigger than data
 assert (padarray (A, [5 10], "circular", "both"), B(2:13,3:25));
***** test
 A = int8 ([1 2 3; 4 5 6]);
 B = repmat (A, 7, 9);
 assert (padarray (A, [1 2], "circular", "pre"),  B(2:4,2:6));
 assert (padarray (A, [1 2], "circular", "post"), B(3:5,4:8));
 assert (padarray (A, [1 2], "circular", "both"), B(2:5,2:8));
 ## This tests when padding is bigger than data
 assert (padarray (A, [5 10], "circular", "both"), B(2:13,3:25));
***** test
 A = [1 2; 3 4];
 B = kron (A, ones (10, 5));
 assert (padarray (A, [9 4], "replicate", "pre"),  B(1:11,1:6));
 assert (padarray (A, [9 4], "replicate", "post"), B(10:20,5:10));
 assert (padarray (A, [9 4], "replicate", "both"), B);
 ## same with uint class
 assert (padarray (uint8 (A), [9 4], "replicate", "pre"),  uint8 (B(1:11,1:6)));
 assert (padarray (uint8 (A), [9 4], "replicate", "post"), uint8 (B(10:20,5:10)));
 assert (padarray (uint8 (A), [9 4], "replicate", "both"), uint8 (B));
***** test
 A    = [1:3
         4:6];
 HA   = [3:-1:1
         6:-1:4];
 VA   = [4:6
         1:3];
 VHA  = [6:-1:4
         3:-1:1];
 B    = [VHA VA VHA
         HA  A  HA
         VHA VA VHA];
 assert (padarray (A, [1 2], "symmetric", "pre"),  B(2:4,2:6));
 assert (padarray (A, [1 2], "symmetric", "post"), B(3:5,4:8));
 assert (padarray (A, [1 2], "symmetric", "both"), B(2:5,2:8));
 ## same with int class
 assert (padarray (int16 (A), [1 2], "symmetric", "pre"),  int16 (B(2:4,2:6)));
 assert (padarray (int16 (A), [1 2], "symmetric", "post"), int16 (B(3:5,4:8)));
 assert (padarray (int16 (A), [1 2], "symmetric", "both"), int16 (B(2:5,2:8)));
***** assert (padarray (int8   ([1; 2]), [1]),            int8   ([0; 1; 2; 0]));
***** assert (padarray (uint8  ([3  4]), [0 2]),          uint8  ([0 0 3 4 0 0]));
***** assert (padarray (int16  ([1; 2]), [1], 4),         int16  ([4; 1; 2; 4]));
***** assert (padarray (uint16 ([1; 2]), [1], 0),         uint16 ([0; 1; 2; 0]));
***** assert (padarray (uint32 ([1; 2]), [1], 6, "post"), uint32 ([1; 2; 6]));
***** assert (padarray (int32  ([1; 2]), [1], int32 (4), "pre"), int32 ([4; 1; 2]));
***** test
 in = [ 7  5  1  3
        5  3  3  4
        7  5  2  3
        6  1  3  8];
 padded = [
  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3
  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1
  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1
  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3
  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2
  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3
  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3
  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2
  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3
  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1
  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1
  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3
  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2
  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3
  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3
  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2
  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3
  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1
  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1  5  7  7  5  1  3  3  1
  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3  3  5  5  3  3  4  4  3
  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2
  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3
  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3  1  6  6  1  3  8  8  3
  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2  5  7  7  5  2  3  3  2];
 for ite = 1:10
  assert (padarray (in, [ite ite], "symmetric"), padded((11-ite):(14+ite),(11-ite):(14+ite)));
  assert (padarray (in, [ite ite], "symmetric", "pre"),  padded((11-ite):14,(11-ite):14));
  assert (padarray (in, [ite ite], "symmetric", "post"), padded(11:(14+ite),11:(14+ite)));
 endfor
***** test
 in = [ 7  5  4  9
        6  4  5  1
        5  3  3  3
        2  6  7  3];
 padded = [
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4
  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4
  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4
  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6  7  3  7  6  2  6
  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3  3  3  3  3  5  3
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4
  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5  4  9  4  5  7  5
  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4  5  1  5  4  6  4];
 for ite = 1:10
  assert (padarray (in, [ite ite], "reflect"), padded((11-ite):(14+ite),(11-ite):(14+ite)));
  assert (padarray (in, [ite ite], "reflect", "pre"),  padded((11-ite):14,(11-ite):14));
  assert (padarray (in, [ite ite], "reflect", "post"), padded(11:(14+ite),11:(14+ite)));
 endfor
26 tests, 26 passed, 0 known failure, 0 skipped
[lab2uint8]
>>>>> /usr/share/octave/packages/image-2.6.1/lab2uint8.m
***** test
 cm_uint8 = uint8 ([0 1 2 3 4 127 128 200 254 255]);
 cm_uint8 = repmat (cm_uint8(:), [1 3]);
 im2d_uint8 = reshape (cm_uint8, [5 2 3]);
 imnd_uint8 = permute (im2d_uint8, [1 4 3 2]);

 cm_uint16 = uint16 ([0  256  512  768  1024  32512  32768 51200  65024  65280]);
 cm_uint16 = repmat (cm_uint16(:), [1 3]);
 assert (lab2uint16 (cm_uint8), cm_uint16)
 im2d_uint16 = reshape (cm_uint16, [5 2 3]);
 assert (lab2uint16 (im2d_uint8), im2d_uint16)
 assert (lab2uint16 (imnd_uint8), permute (im2d_uint16, [1 4 3 2]))

 l1 = 100/255;
 cm = [
       0  -128  -128
      l1  -127  -127
    2*l1  -126  -126
    3*l1  -125  -125
    4*l1  -124  -124
  127*l1    -1    -1
  128*l1     0     0
  200*l1    72    72
  254*l1   126   126
     100   127   127];
 im2d = reshape (cm, [5 2 3]);
 imnd = permute (im2d, [1 4 3 2]);

 assert (lab2double (cm_uint8), cm)
 assert (lab2double (im2d_uint8), im2d)
 assert (lab2double (imnd_uint8), imnd)

 assert (lab2single (cm_uint8), single (cm))
 assert (lab2single (im2d_uint8), single (im2d))
 assert (lab2single (imnd_uint8), single (imnd))
1 test, 1 passed, 0 known failure, 0 skipped
[imabsdiff]
>>>>> /usr/share/octave/packages/image-2.6.1/imabsdiff.m
***** assert (imabsdiff (uint8   ([23 250]), uint8   ([26  50])),            uint8   ([ 3 200])); # default to first class and abs works
***** assert (imabsdiff (uint8   ([23 250]), uint8   ([24  50]), "uint16"),  uint16  ([ 1 200])); # defining output class works (not in matlab)
***** assert (imabsdiff (uint8   ([23 250]), uint8   ([24 255]), "int8"),    int8    ([ 1   5])); # signed integers kinda work (not in matlab)
***** assert (imabsdiff (logical ([ 1   0]), logical ([ 1   1])),            double  ([ 0   1])); # return double for two logical images
***** fail  ("imabsdiff (uint8   ([23 250]), 30");                                                # fails subtracting a scalar
***** fail  ("imabsdiff (uint8   ([23 250]), uint16  ([23 250]))");                               # input need to have same class
6 tests, 6 passed, 0 known failure, 0 skipped
[imcast]
>>>>> /usr/share/octave/packages/image-2.6.1/imcast.m
***** test
 im = randi ([0 255], 40, "uint8");
 assert (imcast (im, "uint8"), im2uint8 (im))
 assert (imcast (im, "uint16"), im2uint16 (im))
 assert (imcast (im, "single"), im2single (im))
 assert (imcast (im, "uint8", "indexed"), im2uint8 (im, "indexed"))
 assert (imcast (im, "uint16", "indexed"), im2uint16 (im, "indexed"))
 assert (imcast (im, "single", "indexed"), im2single (im, "indexed"))
***** test
 im = randi ([1 256], 40, "double");
 assert (imcast (im, "uint8"), im2uint8 (im))
 assert (imcast (im, "uint8", "indexed"), im2uint8 (im, "indexed"))
 assert (imcast (im, "single", "indexed"), im2single (im, "indexed"))
***** test
 im = randi ([0 65535], 40, "uint16");
 assert (imcast (im, "uint8"), im2uint8 (im))
 assert (imcast (im, "single"), im2single (im))
 assert (imcast (im, "single", "indexed"), im2single (im, "indexed"))
***** test
 im = randi ([1 255], 40, "double");
 assert (imcast (im, "uint8", "indexed"), im2uint8 (im, "indexed"))
 assert (imcast (im, "single", "indexed"), im2single (im, "indexed"))
***** test
 im = rand (40);
 assert (imcast (im, "uint8"), im2uint8 (im))
***** error <unknown image of class> imcast (randi (127, 40, "int8"), "uint8")
***** error <unsupported TYPE> imcast (randi (255, 40, "uint8"), "uint32")
***** error <unsupported TYPE> imcast (randi (255, 40, "uint8"), "not a class")
***** error <range of values> imcast (randi ([0 65535], 40, "uint16"), "uint8", "indexed")
9 tests, 9 passed, 0 known failure, 0 skipped
[label2rgb]
>>>>> /usr/share/octave/packages/image-2.6.1/label2rgb.m
***** function map = test_colormap ()
  map = [0 0 0; 0.5 0.5 0.5; 0.125 0.125 0.125];
***** endfunction
***** shared in, out, cmap
 in  = [  0    1    1    0    2    2    0    3    3
          0    1    1    0    2    2    0    3    3];

 out = [255    0    0  255  128  128  255   32   32
        255    0    0  255  128  128  255   32   32];
 out(:,:,2) = out(:,:,3) = out(:,:,1);
 out = uint8(out);

 cmap = [0 0 0; 0.5 0.5 0.5; 0.125 0.125 0.125];
***** assert (label2rgb (in, cmap),            out);
***** assert (label2rgb (uint8 (in), cmap),    out);
***** assert (label2rgb (in, "test_colormap"), out);
***** assert (label2rgb (in, @test_colormap),  out);

 out(find (in == 0)) = 0;
***** assert (label2rgb (in, cmap, "cyan"),    out);
***** assert (label2rgb (in, cmap, [0 1 1]),   out);

 in(1) = 10;
***** error label2rgb (in, cmap);
***** error label2rgb (in, cmap, 89);
***** error label2rgb (in, cmap, "g", "wrong");
9 tests, 9 passed, 0 known failure, 0 skipped
[lab2rgb]
>>>>> /usr/share/octave/packages/image-2.6.1/lab2rgb.m
***** assert (lab2rgb ([0 0 0]), [0, 0, 0], 1e-3)
***** assert (lab2rgb ([53.24, 80.09, 67.20]), [1 0 0], 1e-3)
***** assert (lab2rgb ([97.14, -21.55, 94.48]), [1 1 0], 1e-3)
***** assert (lab2rgb ([87.74, -86.18, 83.18]), [0 1 0], 1e-3)
***** assert (lab2rgb ([91.11, -48.09, -14.13]), [0 1 1], 1e-3)
***** assert (lab2rgb ([32.30, 79.19, -107.86]), [0 0 1], 1e-3)
***** assert (lab2rgb ([60.32, 98.24, -60.83]), [1 0 1], 1e-3)
***** assert (lab2rgb ([100, 0.00, 0.00]), [1 1 1], 1e-3)
***** assert (lab2rgb ([53.39, 0.00, 0.00]), [0.5 0.5 0.5], 1e-3)
***** assert (lab2rgb ([39.77, 64.51, 54.13]), [0.75 0 0], 1e-3)
***** assert (lab2rgb ([25.42, 47.91, 37.91]), [0.5 0 0], 1e-3)
***** assert (lab2rgb ([9.66, 29.68, 15.24]), [0.25 0 0], 1e-3)
***** assert (lab2rgb ([68.11, 48.39, 22.83]), [1 0.5 0.5], 1e-3)
***** assert (lab2rgb ([150 130 130]), [2.714, 1.028, 0.492], 1e-3)
***** test
 lab_map = rand (64, 3);
 lab_map(:,1) = lab_map(:,1) .* 100;
 lab_map(:,2) = lab_map(:,2) .* 254 - 127;
 lab_map(:,3) = lab_map(:,3) .* 254 - 127;
 assert (rgb2lab (lab2rgb (lab_map)), lab_map, 5e-3);
***** test
 lab_img = rand (64, 64, 3);
 lab_img(:,:,1) = lab_img(:,:,1) .* 100;
 lab_img(:,:,2) = lab_img(:,:,2) .* 254 - 127;
 lab_img(:,:,3) = lab_img(:,:,3) .* 254 - 127;
 assert (rgb2lab (lab2rgb (lab_img)), lab_img, 5e-3);
***** assert (lab2rgb (sparse ([0 0 0])), [0 0 0], 1e-3)
***** assert (lab2rgb (sparse ([100, 0.00, 0.00])), [1 1 1], 1e-3)
***** assert (class (lab2rgb (single([50 50 50]))), 'single')
***** error lab2rgb ()
***** error lab2rgb (1,2)
***** error <invalid data type 'cell'> lab2rgb ({1})
***** error <Lab must be a colormap or Lab image> lab2rgb (ones (2,2))
***** test
 lab = rand (16, 16, 3, 5);
 lab(:,:,1,:) = lab(:,:,1,:) .* 100;
 lab(:,:,2,:) = lab(:,:,2,:) .* 254 - 127;
 lab(:,:,3,:) = lab(:,:,3,:) .* 254 - 127;
 rgb = zeros (size (lab));
 for i = 1:5
   rgb(:,:,:,i) = lab2rgb (lab(:,:,:,i));
 endfor
 assert (lab2rgb (lab), rgb)
24 tests, 24 passed, 0 known failure, 0 skipped
[imnoise]
>>>>> /usr/share/octave/packages/image-2.6.1/imnoise.m
***** assert(var(imnoise(ones(10)/2,'gaussian')(:)),0.01,0.005) # probabilistic
***** assert(length(find(imnoise(ones(10)/2,'salt & pepper')~=0.5)),5,10) # probabilistic
***** assert(var(imnoise(ones(10)/2,'speckle')(:)),0.01,0.005) # probabilistic
***** test
 A = imnoise (.5 * ones (100), 'poisson');
 assert (class (A), 'double')
***** test
 A = imnoise (.5 * ones (100, 'single'), 'poisson');
 assert (class (A), 'single')
***** test
 A = imnoise (128 * ones (100, 'uint8'), 'poisson');
 assert (class (A), 'uint8')
***** test
 A = imnoise (256 * ones (100, 'uint16'), 'poisson');
 assert (class (A), 'uint16')
***** demo
  A = imnoise (2^7 * ones (100, 'uint8'), 'poisson');
  subplot (2, 2, 1)
  imshow (A)
  title ('uint8 image with poisson noise')
  A = imnoise (2^15 * ones (100, 'uint16'), 'poisson');
  subplot (2, 2, 2)
  imshow (A)
  title ('uint16 image with poisson noise')
  A = imnoise (.5 * ones (100), 'poisson');
  subplot (2, 2, 3)
  imshow (A)
  title ('double image with poisson noise')
  A = imnoise (.5 * ones (100, 'single'), 'poisson');
  subplot (2, 2, 4)
  imshow (A)
  title ('single image with poisson noise')
7 tests, 7 passed, 0 known failure, 0 skipped
[imtranslate]
>>>>> /usr/share/octave/packages/image-2.6.1/imtranslate.m
***** test
 obs = imtranslate (ones (5, 5), 2, 1, "crop");
 exp = zeros (5, 5);
 exp(1:4, 3:5) = 1;
 assert (obs, exp, eps * 10)

 obs = imtranslate (ones (5, 5), -2, -1, "crop");
 exp = zeros (5, 5);
 exp(2:5, 1:3) = 1;
 assert (obs, exp, eps * 10)
1 test, 1 passed, 0 known failure, 0 skipped
[rgb2lab]
>>>>> /usr/share/octave/packages/image-2.6.1/rgb2lab.m
***** assert (rgb2lab ([0 0 0]), [0, 0, 0], 1e-2)
***** assert (rgb2lab ([1 0 0]), [53.24, 80.09, 67.20], 1e-2)
***** assert (rgb2lab ([1 1 0]), [97.14, -21.55, 94.48], 1e-2)
***** assert (rgb2lab ([0 1 0]), [87.74, -86.18, 83.18], 1e-2)
***** assert (rgb2lab ([0 1 1]), [91.11, -48.09, -14.13], 1e-2)
***** assert (rgb2lab ([0 0 1]), [32.30, 79.19, -107.86], 1e-2)
***** assert (rgb2lab ([1 0 1]), [60.32, 98.24, -60.83], 1e-2)
***** assert (rgb2lab ([1 1 1]), [100, 0.00, 0.00], 1e-2)
***** assert (rgb2lab ([0.5 0.5 0.5]), [53.39, 0.00, 0.00], 1e-2)
***** assert (rgb2lab ([0.75 0 0]), [39.77, 64.51, 54.13], 1e-2)
***** assert (rgb2lab ([0.5 0 0]), [25.42, 47.91, 37.91], 1e-2)
***** assert (rgb2lab ([0.25 0 0]), [9.66, 29.68, 15.24], 1e-2)
***** assert (rgb2lab ([1 0.5 0.5]), [68.11, 48.39, 22.83], 1e-2)
***** assert (rgb2lab ([1.5 1 1]), [111.47, 43.42, 17.98], 1e-2)
***** test
 rgb_map = rand (64, 3);
 assert (lab2rgb (rgb2lab (rgb_map)), rgb_map, 2e-5);
***** test
 rgb_img = rand (64, 64, 3);
 assert (lab2rgb (rgb2lab (rgb_img)), rgb_img, 2e-5);
***** assert (rgb2lab (sparse ([0 0 1])), sparse ([32.30, 79.19, -107.86]), 1e-2)
***** assert (rgb2lab (sparse ([0 1 1])), sparse ([91.11, -48.09, -14.13]), 1e-2)
***** assert (rgb2lab (sparse ([1 1 1])), sparse ([100, 0.00, 0.00]), 1e-2)
***** assert (rgb2lab (uint8([255 255 255])), [100, 0.00, 0.00], 1e-2)
***** assert (class (rgb2lab (single([1 1 1]))), 'single')
***** error rgb2lab ()
***** error rgb2lab (1,2)
***** error <invalid data type 'cell'> rgb2lab ({1})
***** error <RGB must be a colormap or RGB image> rgb2lab (ones (2,2))
***** test
 rgb = rand (16, 16, 3, 5);
 lab = zeros (size (rgb));
 for i = 1:5
   lab(:,:,:,i) = rgb2lab (rgb(:,:,:,i));
 endfor
 assert (rgb2lab (rgb), lab)
26 tests, 26 passed, 0 known failure, 0 skipped
[imregionalmin]
>>>>> /usr/share/octave/packages/image-2.6.1/imregionalmin.m
***** test
 a = [
    7    3    9    3   10    3
    4    2    3   10    1    3
    1    4    6    9    4   10
    8    7    9    3    4    8
    5    9    3    3    8    9
    3    6    9    4    1   10];

 a4 = logical ([
    0    0    0    1    0    0
    0    1    0    0    1    0
    1    0    0    0    0    0
    0    0    0    1    0    0
    0    0    1    1    0    0
    1    0    0    0    1    0]);
 assert (imregionalmin (a, 4), a4)
 assert (imregionalmin (uint8 (a), 4), a4)
 assert (imregionalmin (int8 (a), 4), a4)

 a8 = logical ([
    0    0    0    0    0    0
    0    0    0    0    1    0
    1    0    0    0    0    0
    0    0    0    0    0    0
    0    0    0    0    0    0
    1    0    0    0    1    0]);
 assert (imregionalmin (a), a8)
 assert (imregionalmin (a, 8), a8)
 assert (imregionalmin (uint8 (a), 8), a8)
 assert (imregionalmin (int8 (a), 8), a8)
***** test
 a = [
   4   8   5  -1   8   7
  -1   4   0   7   1   1
   6   1   2   6   7   0
   6   1   5  -2   5   9
   1   4  -1   0   0   2
   4   6   1   0   7   1];

 a4 = logical ([
   0   0   0   1   0   0
   1   0   1   0   0   0
   0   1   0   0   0   1
   0   1   0   1   0   0
   1   0   1   0   0   0
   0   0   0   0   0   1]);
 assert (imregionalmin (a, 4), a4)
 assert (imregionalmin (int8 (a), 4), a4)

 a8 = logical ([
   0   0   0   1   0   0
   1   0   0   0   0   0
   0   0   0   0   0   1
   0   0   0   1   0   0
   0   0   0   0   0   0
   0   0   0   0   0   0]);
 assert (imregionalmin (a), a8)
 assert (imregionalmin (a, 8), a8)
 assert (imregionalmin (int8 (a), 8), a8)
2 tests, 2 passed, 0 known failure, 0 skipped
[xyz2rgb]
>>>>> /usr/share/octave/packages/image-2.6.1/xyz2rgb.m
***** assert (xyz2rgb ([0, 0, 0]), [0 0 0], 1e-3)
***** assert (xyz2rgb ([0.4125, 0.2127, 0.0193]), [1 0 0], 1e-3)
***** assert (xyz2rgb ([0.7700, 0.9278, 0.1385]), [1 1 0], 1e-3)
***** assert (xyz2rgb ([0.3576, 0.7152, 0.1192]), [0 1 0], 1e-3)
***** assert (xyz2rgb ([0.5380, 0.7873, 1.0694]), [0 1 1], 1e-3)
***** assert (xyz2rgb ([0.1804, 0.07217, 0.9502]), [0 0 1], 1e-3)
***** assert (xyz2rgb ([0.5929, 0.28484, 0.9696]), [1 0 1], 1e-3)
***** assert (xyz2rgb ([0.9505, 1.0000, 1.0888]), [1 1 1], 1e-3)
***** assert (xyz2rgb ([0.2034, 0.2140, 0.2330]), [0.5 0.5 0.5], 1e-3)
***** assert (xyz2rgb ([0.2155, 0.1111, 0.0101]), [0.75 0 0], 1e-3)
***** assert (xyz2rgb ([0.0883, 0.0455, 0.0041]), [0.5 0 0], 1e-3)
***** assert (xyz2rgb ([0.0210, 0.0108, 0.0010]), [0.25 0 0], 1e-3)
***** assert (xyz2rgb ([0.5276, 0.3812, 0.2482]), [1 0.5 0.5], 1e-3)
***** assert (xyz2rgb ([1.5 1 1]), [1.5712, 0.7109   0.9717], 1e-3)
***** test
 xyz_map = rand (64, 3);
 assert (rgb2xyz (xyz2rgb (xyz_map)), xyz_map, 3e-4);
***** test
 xyz_img = rand (64, 64, 3);
 assert (rgb2xyz (xyz2rgb (xyz_img)), xyz_img, 3e-4);
***** assert (xyz2rgb (sparse ([0 0 0])), [0 0 0], 1e-3)
***** assert (class (xyz2rgb (single([0.5 0.5 0.5]))), 'single')
***** error xyz2rgb ()
***** error xyz2rgb (1,2)
***** error <invalid data type 'cell'> xyz2rgb ({1})
***** error <XYZ must be a colormap or XYZ image> xyz2rgb (ones (2,2))
***** test
 xyz = rand (16, 16, 3, 5);
 rgb = zeros (size (xyz));
 for i = 1:5
   rgb(:,:,:,i) = xyz2rgb (xyz(:,:,:,i));
 endfor
 assert (xyz2rgb (xyz), rgb)
23 tests, 23 passed, 0 known failure, 0 skipped
[graythresh]
>>>>> /usr/share/octave/packages/image-2.6.1/graythresh.m
***** shared img, histo
 ## this is the old default.img that came with GNU Octave. While the current
 ## is very very similar, is off just enough for us to get precision errors
 img = uint8 (reshape ([138 138 138 142 142 138 142 138 138 117 105 81 69 61 53 40 49 45 40 36 40 45 53 49 65 73 121 166 210 243 247 247 247 239 235 178 154 170 150 150 162 174 190 190 194 186 178 170 154 182 198 174 117 138 138 142 138 142 142 146 142 138 138 130 109 97 81 73 69 57 53 53 57 61 61 69 73 77 105 121 158 219 243 243 247 243 243 243 206 150 158 158 158 150 158 182 186 190 194 186 174 190 206 198 162 138 142 138 142 146 138 142 142 138 146 142 134 142 130 121 101 97 85 85 81 81 81 85 93 85 73 57 61 93 150 194 215 239 243 243 243 223 166 138 158 158 154 142 162 178 190 190 198 186 182 186 174 162 182 146 142 138 142 142 146 142 146 146 146 146 142 142 142 134 125 101 85 73 65 69 73 73 57 40 53 49 57 69 85 125 166 182 178 178 174 150 130 121 146 146 150 142 166 182 190 182 174 166 162 170 194 198 138 138 146 146 138 146 146 146 146 142 150 146 146 142 130 93 65 45 45 49 45 40 49 40 49 49 49 49 61 81 113 142 150 154 154 146 142 134 125 125 138 134 125 146 162 178 178 178 166 186 202 206 186 142 142 142 134 142 146 142 150 142 146 142 146 146 130 81 53 49 49 45 49 40 36 36 32 36 36 36 53 73 89 125 150 146 134 138 146 138 146 138 142 117 117 113 117 146 166 174 178 182 178 178 170 146 142 142 138 142 146 142 142 146 150 138 146 142 130 73 49 40 49 57 65 69 73 61 61 53 57 53 61 77 77 97 113 138 134 130 138 142 150 146 150 134 138 121 121 101 121 150 158 154 142 150 162 166 178 138 138 146 142 142 142 142 146 146 142 142 130 73 57 49 36 49 65 77 85 89 85 81 81 81 85 93 93 97 105 117 125 150 158 154 162 162 166 154 134 150 130 125 113 138 182 174 154 130 178 227 239 239 134 138 142 138 142 142 146 146 138 150 125 61 49 32 32 45 49 57 65 85 101 105 101 101 109 125 117 113 109 138 134 125 166 178 170 162 150 170 162 170 150 146 150 138 125 162 186 182 142 206 247 247 243 138 138 138 138 142 142 146 146 146 130 85 45 45 36 40 53 45 57 69 97 125 130 130 134 138 146 142 134 142 158 138 117 146 174 170 174 178 170 174 170 166 154 162 158 130 134 170 178 158 190 243 247 247 142 142 142 142 142 146 146 142 138 89 53 45 40 45 45 49 57 77 93 125 138 150 154 158 158 162 154 150 166 174 142 73 125 174 178 174 182 182 178 178 174 166 174 174 162 125 154 170 174 170 227 247 251 142 138 142 142 142 142 142 138 105 61 40 40 32 40 40 49 61 89 117 146 154 158 162 170 170 174 162 166 174 182 150 65 146 166 174 186 198 198 198 190 178 178 174 174 158 134 154 198 194 174 202 251 251 146 142 142 142 146 150 138 134 69 40 40 36 32 40 45 45 65 101 134 150 158 166 174 178 174 174 174 170 170 174 142 73 150 162 178 194 202 202 194 194 178 178 154 134 125 138 154 198 194 186 190 243 251 150 146 146 146 146 150 130 109 53 45 28 40 40 36 32 49 73 101 130 154 162 170 170 170 178 182 178 178 174 158 142 121 146 158 178 174 186 190 186 186 174 146 105 109 113 130 150 178 202 190 186 243 251 146 146 146 146 150 142 109 73 49 40 32 40 40 45 40 53 69 93 130 154 162 170 174 178 182 182 186 182 178 154 146 130 138 142 150 170 182 178 174 166 150 117 97 105 113 130 150 150 174 182 190 243 251 146 146 154 146 150 134 105 53 40 45 45 40 40 36 36 40 69 105 134 162 170 174 178 182 182 182 186 190 186 178 170 158 154 150 162 182 182 174 174 174 150 113 109 113 113 130 150 162 186 186 190 239 251 154 150 146 150 146 125 77 49 36 40 36 40 36 28 40 36 77 113 138 150 170 170 174 186 190 190 190 194 190 186 194 190 170 162 174 194 174 182 170 170 158 121 113 113 113 146 158 170 210 215 215 206 243 150 146 150 150 150 113 57 49 40 45 45 49 49 40 32 45 85 113 142 170 178 174 182 194 190 194 194 198 198 198 210 210 182 162 170 190 182 186 170 170 162 130 121 113 121 146 154 150 198 215 206 210 215 150 150 150 150 150 105 49 45 40 49 49 57 40 49 49 53 85 121 158 182 178 174 182 198 194 194 194 194 202 202 194 186 174 154 162 166 178 174 170 170 170 158 117 113 130 150 154 121 182 194 206 215 206 158 150 150 150 146 97 45 36 49 49 49 40 40 49 49 65 97 130 154 174 174 174 186 194 194 194 194 198 198 186 170 158 154 158 138 158 162 170 190 182 174 170 138 138 142 154 134 142 146 170 206 219 215 150 150 158 158 150 85 36 40 40 40 40 45 45 49 49 65 97 130 146 166 166 174 182 190 194 194 194 194 190 182 162 158 150 158 182 186 178 198 206 198 190 174 154 174 174 142 142 170 170 166 202 223 219 158 150 150 150 146 85 40 45 40 40 36 45 53 45 49 53 93 117 130 154 162 174 190 186 194 194 194 190 186 178 162 162 170 174 182 198 210 206 210 198 198 182 170 178 174 158 154 194 194 174 198 210 215 150 154 158 150 150 85 49 45 40 40 32 36 53 40 45 53 81 109 142 158 158 174 178 182 190 190 194 190 190 178 170 174 178 186 190 190 206 215 202 206 194 186 178 182 174 154 170 198 210 186 186 202 215 150 154 150 154 150 97 45 40 40 40 36 36 45 40 45 73 89 113 142 158 158 174 174 182 186 186 194 186 182 178 174 170 105 166 206 186 190 202 198 194 190 182 182 174 166 154 162 198 215 202 182 202 219 154 150 154 150 146 117 61 45 45 45 36 53 53 49 53 77 93 101 125 158 162 174 174 178 174 186 190 182 182 186 182 182 77 125 198 194 186 190 190 178 178 178 162 162 162 154 186 210 227 210 190 206 223 154 150 154 150 154 138 65 45 45 45 40 49 49 40 53 65 77 89 113 150 158 166 166 170 178 182 186 182 170 170 170 162 81 117 186 190 186 182 178 186 174 166 162 150 130 154 194 227 227 219 202 202 219 154 154 150 154 146 146 89 45 40 45 40 49 49 36 40 57 65 89 109 138 146 158 158 170 170 178 182 178 162 150 158 154 113 146 186 182 178 182 178 170 170 162 146 138 138 146 202 223 231 219 210 190 215 130 130 130 130 130 130 109 45 53 40 32 36 40 45 53 61 65 81 97 117 130 138 150 158 158 178 170 162 158 138 142 150 146 166 178 174 174 170 170 170 162 158 138 117 117 142 202 223 239 223 215 186 206 61 61 65 69 69 65 57 36 40 36 32 40 40 53 57 53 57 69 93 105 109 130 138 142 154 162 150 138 142 125 121 150 162 170 170 166 170 170 170 166 162 138 121 113 130 170 202 223 227 231 202 178 182 45 49 45 40 40 40 45 45 45 45 36 40 32 49 61 61 57 65 73 81 101 109 121 130 142 146 121 89 93 117 113 134 154 174 166 162 166 170 170 162 154 150 142 150 223 186 194 215 231 227 206 182 174 49 40 45 45 49 49 45 49 49 49 49 40 36 45 57 69 65 61 65 69 85 93 109 109 117 109 89 57 57 81 97 113 154 162 166 162 170 158 158 162 154 162 174 231 239 178 186 210 231 239 210 194 178 49 36 49 45 49 49 49 45 45 49 49 36 40 40 45 36 53 53 53 57 57 69 69 73 69 61 57 45 45 65 89 105 125 142 146 150 150 154 162 170 174 223 235 247 231 178 178 206 227 227 223 198 190 40 53 36 45 40 40 40 40 45 40 40 45 45 45 45 40 53 49 49 45 53 45 32 36 36 36 36 40 49 45 61 73 89 93 97 113 125 142 186 202 239 239 243 251 239 198 166 194 215 235 227 215 202 40 45 36 32 36 40 40 45 40 40 45 49 45 49 45 49 40 40 45 49 40 45 45 45 49 49 32 40 49 40 49 57 69 81 101 134 170 206 235 243 243 239 247 251 247 210 170 186 202 231 231 227 210 49 45 49 40 40 40 49 45 40 40 45 45 45 40 45 45 45 49 40 49 40 49 45 45 36 40 40 45 45 45 45 65 121 150 210 239 243 243 247 243 243 247 251 251 239 223 178 174 194 219 239 231 219 36 45 45 40 40 49 40 45 49 49 40 40 45 49 40 40 45 49 45 40 49 45 40 40 40 49 40 45 40 49 49 121 162 215 247 247 247 247 247 243 247 251 251 251 247 239 223 194 186 202 215 210 210 36 45 45 40 40 49 40 45 32 36 49 36 45 49 40 40 45 40 36 40 45 45 40 40 40 36 45 32 40 49 57 121 142 215 243 247 243 247 243 247 251 251 251 251 247 247 247 227 186 194 190 190 182 40 32 45 32 45 40 45 45 49 45 40 45 49 36 40 45 32 40 45 45 49 45 45 45 45 53 49 53 45 45 40 69 97 186 239 243 247 247 247 251 251 251 251 251 243 243 231 202 202 206 206 186 170 53 40 40 40 40 40 36 32 32 36 45 53 49 32 36 32 36 32 40 49 40 40 45 40 40 53 45 49 49 40 32 40 49 138 219 235 247 247 251 251 251 251 251 247 243 235 198 206 210 198 190 186 186 73 69 61 57 61 49 53 40 49 45 40 49 49 49 57 57 53 49 53 53 45 40 45 40 45 49 45 49 45 40 32 53 69 101 215 231 247 247 247 247 251 251 251 243 235 219 194 202 202 186 186 190 194], [53 40]));
***** assert (graythresh (img, "percentile"),      142/255);
***** assert (graythresh (img, "percentile", 0.5), 142/255);
***** assert (graythresh (img, "moments"),         142/255);
***** assert (graythresh (img, "minimum"),          93/255);
***** assert (graythresh (img, "maxentropy"),      150/255);
***** assert (graythresh (img, "intermodes"),       99/255);
***** assert (graythresh (img, "otsu"),            115/255);
 histo = hist (img(:), 0:255);
***** assert (graythresh (histo, "otsu"),          115/255);
***** assert (graythresh (img, "mean"), 0.51445615982, 0.000000001);  # here our results differ from ImageJ
9 tests, 9 passed, 0 known failure, 0 skipped
[im2bw]
>>>>> /usr/share/octave/packages/image-2.6.1/im2bw.m
***** assert(im2bw ([0 0.4 0.5 0.6 1], 0.5), logical([0 0 0 1 1])); # basic usage
***** assert(im2bw (uint8 ([0 100 255]), 0.5), logical([0 0 1]));   # with a uint8 input
***** warning <is already binary so nothing is done> bw = im2bw (logical ([0 1 0]));
***** warning <is already binary so nothing is done> bw = im2bw (logical ([0 1 0]), 1);
***** test
 warning ("off", "all", "local");
 assert (im2bw (logical ([0 1 0])),    logical ([0 1 0]))
 assert (im2bw (logical ([0 1 0]), 0), logical ([0 1 0]))
 assert (im2bw (logical ([0 1 0]), 1), logical ([0 1 0]))
***** assert (nnz (im2bw (uint8 ([0:255]), 0.9)), 26)
***** test
 img = uint8 ([0:255]);
 s = 0;
 for i=0:.1:1
   s += nnz (im2bw (img, i));
 endfor
 assert (s, 1405)
***** assert (nnz (im2bw (int16 ([-128:127]), 0.499)), 194)
***** assert (nnz (im2bw (int16 ([-128:127]), 0.500)), 128)
***** assert (nnz (im2bw (int16 ([-128:127]), 0.501)), 62)
***** test
 img = uint16 ([0:intmax("uint16")]);
 s = 0;
 for i=0:.1:1
   s += nnz (im2bw (img, i));
 endfor
 assert (s, 360445)
***** test
 img = int16 ([intmin("int16"):intmax("int16")]);
 s = 0;
 for i=0:.1:1
   s += nnz (im2bw (img, i));
 endfor
 assert (s, 360445)
***** test
 im = [((randn(10)/10)+.3) ((randn(10)/10)+.7)];
 assert (im2bw (im, "Otsu"), im2bw (im, graythresh (im(:), "Otsu")))
 assert (im2bw (im, "moments"), im2bw (im, graythresh (im(:), "moments")))
!!!!! test failed
horizontal dimensions mismatch (1x1 vs 199x1)
***** test
 im = [((randn(10)/10)+.3) ((randn(10)/10)+.7)];
 im = reshape (im, [10 10 1 2]);
 assert (im2bw (im, "Otsu"), im2bw (im, graythresh (im(:), "Otsu")))
 assert (im2bw (im, "moments"), im2bw (im, graythresh (im(:), "moments")))
!!!!! test failed
graythresh: input must be an image or an histogram.
14 tests, 12 passed, 0 known failure, 0 skipped
[cp2tform]
>>>>> /usr/share/octave/packages/image-2.6.1/cp2tform.m
***** function [crw, cap] = coords (npt = 1000, scale = 2, dtheta = pi/3, dx = 2, dy = -6, sig2noise = 1e32)
  theta = (rand(npt, 1)*2-1)*2*pi;
  R = rand(npt,1);
  y = R.*sin(theta);
  x = R.*cos(theta);
  crw = [y x];

  thetap = theta + dtheta; 
  Rap = R * scale;

  yap = Rap.*sin(thetap);
  yap = yap + dy;
  yap = yap + rand (size (yap)) * norm (yap) / sig2noise;

  xap = Rap.*cos(thetap);
  xap = xap + dx;
  xap = xap + rand (size (xap)) * norm (xap) / sig2noise;
  cap = [yap xap];
***** endfunction
***** test
 npt = 100000;
 [crw, cap] = coords (npt);
 ttype = 'projective';
 T = cp2tform (crw, cap, ttype);
 crw2 = tforminv (T, cap);
 finalerr = norm (crw - crw2)/npt;
 assert (finalerr < eps, "norm = %3.2e ( > eps)", finalerr)
***** test
 npt = 100000;
 [crw, cap] = coords (npt);
 ttype = 'affine';
 T = cp2tform (crw, cap, ttype);
 crw2 = tforminv (T, cap);
 finalerr = norm (crw - crw2)/npt;
 assert (finalerr < eps, "norm = %3.2e ( > eps)", finalerr)
***** test
 npt = 100000;
 [crw, cap] = coords (npt);
 ttype = 'nonreflective similarity';
 T = cp2tform (crw, cap, ttype);
 crw2 = tforminv (T, cap);
 finalerr = norm (crw - crw2)/npt;
 assert (finalerr < eps, "norm = %3.2e ( > eps)", finalerr)
***** test
 npt = 100000;
 [crw, cap] = coords (npt);
 cap(:,2) *= -1; 	% reflection around y axis
 ttype = 'similarity';
 T = cp2tform (crw, cap, ttype);
 crw2 = tforminv (T, cap);
 finalerr = norm (crw - crw2)/npt;
 assert (finalerr < eps, "norm = %3.2e ( > eps)", finalerr)
***** xtest
 npt = 100000;
 [crw, cap] = coords (npt);
 ttype = 'polynomial';
 ord = 2;
 T = cp2tform (crw, cap, ttype, ord);
 crw2 = tforminv (T, cap);
 finalerr = norm (crw - crw2)/npt;
 assert (finalerr < eps, "norm = %3.2e ( > eps)", finalerr)
***** xtest
 npt = 100000;
 [crw, cap] = coords (npt);
 ttype = 'polynomial';
 ord = 3;
 T = cp2tform (crw, cap, ttype, ord);
 crw2 = tforminv (T, cap);
 finalerr = norm (crw - crw2)/npt;
 assert (finalerr < eps, "norm = %3.2e ( > eps)", finalerr)
***** xtest
 npt = 100000;
 [crw, cap] = coords (npt);
 ttype = 'polynomial';
 ord = 4;
 T = cp2tform (crw, cap, ttype, ord);
 crw2 = tforminv (T, cap);
 finalerr = norm (crw - crw2)/npt;
 assert (finalerr < eps, "norm = %3.2e ( > eps)", finalerr)
!!!!! known failure
norm = 7.52e-16 ( > eps)
7 tests, 6 passed, 1 known failure, 0 skipped
[getrangefromclass]
>>>>> /usr/share/octave/packages/image-2.6.1/getrangefromclass.m
***** shared img
 img = ones (5);
***** assert (getrangefromclass (double (img)), [0 1]);      # double returns [0 1]
***** assert (getrangefromclass (single (img)), [0 1]);      # single returns [0 1]
***** assert (getrangefromclass (logical (img)), [0 1]);     # logical returns [0 1]
***** assert (getrangefromclass (int8 (img)), [-128 127]);   # checks int
***** assert (getrangefromclass (uint8 (img)), [0 255]);     # checks unit
***** fail ("getrangefromclass ('string')");                 # fails with strings
***** fail ("getrangefromclass ({3, 4})");                   # fails with cells
7 tests, 7 passed, 0 known failure, 0 skipped
[qtgetblk]
>>>>> /usr/share/octave/packages/image-2.6.1/qtgetblk.m
***** demo
 [vals,r,c]=qtgetblk(eye(4),qtdecomp(eye(4)),2)
 % Returns 2 blocks, at [1,3] and [3,1] (2*2 zeros blocks)
***** shared A,S
 A=[ 1, 4, 2, 5,54,55,61,62;
     3, 6, 3, 1,58,53,67,65;
     3, 6, 3, 1,58,53,67,65;
     3, 6, 3, 1,58,53,67,65;
    23,42,42,42,99,99,99,99;
    27,42,42,42,99,99,99,99;
    23,22,26,25,99,99,99,99;
    22,22,24,22,99,99,99,99];
 S=qtdecomp(A,10);
***** test
 [va]=qtgetblk(A,S,8);
 [vb,r,c]=qtgetblk(A,S,8);
 [vc,i]=qtgetblk(A,S,8);
 assert(va, vb);
 assert(va, vc);
 assert(i,[]);
 assert(r,[]);
 assert(c,[]);
 R=[];
 assert(va,R);
***** test
 [va]=qtgetblk(A,S,4);
 [vb,r,c]=qtgetblk(A,S,4);
 [vc,i]=qtgetblk(A,S,4);
 assert(va, vb);
 assert(va, vc);
 assert(i, find(full(S)==4));
 assert(r,[1;5]);
 assert(c,[1;5]);
 R=zeros(4,4,2);
 R(:,:,1)=A(1:4,1:4);
 R(:,:,2)=A(5:8,5:8);
 assert(va,R);
***** test
 [va]=qtgetblk(A,S,2);
 [vb,r,c]=qtgetblk(A,S,2);
 [vc,i]=qtgetblk(A,S,2);
 assert(va, vb);
 assert(va, vc);
 assert(i, find(full(S)==2));
 assert(r,[7;5;7;1;3;1;3]);
 assert(c,[1;3;3;5;5;7;7]);
 R=zeros(2,2,7);
 R(:,:,1)=A(7:8,1:2);
 R(:,:,2)=A(5:6,3:4);
 R(:,:,3)=A(7:8,3:4);
 R(:,:,4)=A(1:2,5:6);
 R(:,:,5)=A(3:4,5:6);
 R(:,:,6)=A(1:2,7:8);
 R(:,:,7)=A(3:4,7:8);
 assert(va,R);
3 tests, 3 passed, 0 known failure, 0 skipped
[bwperim]
>>>>> /usr/share/octave/packages/image-2.6.1/bwperim.m
***** test
 in = [ 1   1   1   1   0   1   1   0   1   1
        1   1   0   1   1   1   1   1   1   0
        1   1   1   0   1   1   1   1   1   1
        1   1   1   1   0   1   1   1   0   1
        1   1   1   0   1   1   1   1   1   0
        1   1   1   1   1   1   0   1   0   1
        1   1   1   1   1   1   1   1   1   0
        1   1   1   1   1   1   1   1   1   1
        1   1   1   1   1   1   0   0   1   1
        1   1   1   1   0   1   0   1   1   0];

 out = [1   1   1   1   0   1   1   0   1   1
        1   1   0   1   1   0   0   1   1   0
        1   0   1   0   1   0   0   0   1   1
        1   0   0   1   0   1   0   1   0   1
        1   0   1   0   1   0   1   0   1   0
        1   0   0   1   0   1   0   1   0   1
        1   0   0   0   0   0   1   0   1   0
        1   0   0   0   0   0   1   1   0   1
        1   0   0   0   1   1   0   0   1   1
        1   1   1   1   0   1   0   1   1   0];
 assert (bwperim (in), logical (out))
 assert (bwperim (in, 4), logical (out))

 out = [1   1   1   1   0   1   1   0   1   1
        1   1   0   1   1   1   1   1   1   0
        1   1   1   0   1   1   0   1   1   1
        1   0   1   1   0   1   0   1   0   1
        1   0   1   0   1   1   1   1   1   0
        1   0   1   1   1   1   0   1   0   1
        1   0   0   0   0   1   1   1   1   0
        1   0   0   0   0   1   1   1   1   1
        1   0   0   1   1   1   0   0   1   1
        1   1   1   1   0   1   0   1   1   0];
 assert (bwperim (in, 8), logical (out))

 out = [1   1   1   1   0   1   1   0   1   1
        1   0   0   0   0   1   0   0   1   0
        1   0   0   0   0   0   0   1   0   1
        1   0   1   0   0   0   0   0   0   1
        1   0   0   0   0   1   0   1   0   0
        1   0   0   0   1   0   0   0   0   1
        1   0   0   0   0   0   0   1   0   0
        1   0   0   0   0   1   1   0   0   1
        1   0   0   1   0   1   0   0   1   1
        1   1   1   1   0   1   0   1   1   0];
 assert (bwperim (in, [1 0 0; 0 1 0; 0 0 1]), logical (out))
***** test
 in = [ 0   0   0   0   0   0   0
        0   0   5   0   0   1   9
        0 Inf   9   7   0   0   0
        0 1.5   5   7   1   0   0
        0 0.5  -1  89   i   0   0
        0   4  10  15   1   0   0
        0   0   0   0   0   0   0];
 out = [0   0   0   0   0   0   0
        0   0   1   0   0   1   1
        0   1   0   1   0   0   0
        0   1   0   0   1   0   0
        0   1   0   0   1   0   0
        0   1   1   1   1   0   0
        0   0   0   0   0   0   0];
 assert (bwperim (in), logical (out))
***** test
 in = reshape (magic(16), [8 8 4]) > 50;
 out(:,:,1) = [
    1   1   0   1   0   1   1   1
    0   1   1   1   1   1   0   1
    0   1   1   1   1   1   0   1
    1   1   0   1   1   1   1   1
    1   1   1   1   1   1   1   1
    1   1   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 out(:,:,2) = [
    1   1   0   1   0   1   1   1
    0   1   1   0   1   1   0   1
    0   1   0   0   0   1   0   1
    1   0   1   0   0   0   1   1
    1   0   0   1   0   1   0   1
    1   0   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 out(:,:,3) = [
    1   1   0   1   0   1   1   1
    0   1   1   0   1   1   0   1
    0   1   0   0   0   1   0   1
    1   0   0   0   0   0   1   1
    1   0   0   1   0   1   0   1
    1   0   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 out(:,:,4) = [
    1   1   0   1   0   1   1   1
    0   1   1   1   1   1   0   1
    0   1   1   1   1   1   0   1
    1   1   1   1   1   1   1   1
    1   1   1   1   1   1   1   0
    1   1   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 assert (bwperim (in), logical (out))

 out(:,:,1) = [
    1   1   0   1   0   1   1   1
    0   1   1   1   1   1   0   1
    0   1   1   1   1   1   0   1
    1   1   0   1   1   1   1   1
    1   1   1   1   1   1   1   1
    1   1   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 out(:,:,2) = [
    1   1   0   1   0   1   1   1
    0   1   1   1   1   1   0   1
    0   1   1   0   0   1   0   1
    1   1   1   1   0   1   1   1
    1   0   1   1   1   1   1   1
    1   0   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 out(:,:,3) = [
    1   1   0   1   0   1   1   1
    0   1   1   1   1   1   0   1
    0   1   0   0   0   1   0   1
    1   1   0   0   0   1   1   1
    1   0   1   1   1   1   1   1
    1   0   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 out(:,:,4) = [
    1   1   0   1   0   1   1   1
    0   1   1   1   1   1   0   1
    0   1   1   1   1   1   0   1
    1   1   1   1   1   1   1   1
    1   1   1   1   1   1   1   0
    1   1   1   0   1   0   1   1
    1   1   1   0   1   0   1   1
    1   0   1   1   1   1   1   0];
 assert (bwperim (in, 18), logical (out))
***** error bwperim ("text")
***** error bwperim (rand (10), 5)
***** error bwperim (rand (10), "text")
***** test
 a = false (5);
 a(1:4,2:4) = true;

 p = false (5);
 p(1:4,[2 4]) = true;
 assert (bwperim (a, [0 0 0; 1 1 1; 0 0 0]), p)
***** test
 a = false (8, 8, 5);
 a(4:5,4:5,2:4) = true;
 a(2:7,2:7,3) = true;
 assert (bwperim (a, 26), a)

 ## It is easy to forget that is correct
 b = a;
 b(4:5, 4:5, 3) = false;
 assert (bwperim (a), b)

 c = a;
 c(3:6,3:6,3) = false;
 assert (bwperim (a, 4), c)
8 tests, 8 passed, 0 known failure, 0 skipped
[nlfilter]
>>>>> /usr/share/octave/packages/image-2.6.1/nlfilter.m
***** demo
 ## creates a "wide" diagonal (although it can be performed more
 ## efficiently with "imdilate (A, true (3))")
 nlfilter (eye (10), [3 3], @(x) any (x(:) > 0))
***** assert (nlfilter (eye (4), [2 3], @(x) sum (x(:))),
        [2 2 1 0
         1 2 2 1
         0 1 2 2
         0 0 1 1]);
***** assert (nlfilter (eye (4), "indexed", [2 3], @(x) sum (x(:))),
        [4 2 1 2
         3 2 2 3
         2 1 2 4
         4 3 4 5]);
***** assert (nlfilter (eye (4), "indexed", [2 3], @(x, y) sum (x(:)) == y, 2),
        logical ([0 1 0 1
                  0 1 1 0
                  1 0 1 0
                  0 0 0 0]));
***** assert (nlfilter (uint8 (eye (4)), "indexed", [2 3], @(x) sum (x(:))),
        [2 2 1 0
         1 2 2 1
         0 1 2 2
         0 0 1 1]);
***** assert (nlfilter (int16 (eye (4)), "indexed", [2 3], @(x) sum (x(:))),
        [4 2 1 2
         3 2 2 3
         2 1 2 4
         4 3 4 5]);
***** assert (nlfilter (uint8 (eye (4)), "indexed", [2 3], @(x) int8 (sum (x(:)))),
        int8 ([2 2 1 0
               1 2 2 1
               0 1 2 2
               0 0 1 1]));
***** test
 a = randi (10, 20, 20, 20);
 ## extra dimensions on matrix only
 assert (nlfilter (a, [5 5], @(x) max(x(:))), imdilate (a, ones (5)))
 ## extra dimensions on both matrix and block
 assert (nlfilter (a, [5 5 5], @(x) max(x(:))), imdilate (a, ones ([5 5 5])))
 ## extra dimensions and padding
 assert (nlfilter (a, [3 7], @(x) max(x(:))), imdilate (a, ones ([3 7])))
 assert (nlfilter (a, [3 7 3], @(x) max(x(:))), imdilate (a, ones ([3 7 3])))
***** test
 a = randi (10, 15, 15, 4, 8, 3);
 assert (nlfilter (a, [3 4 7 5], @(x) max(x(:))),
         imdilate (a, ones ([3 4 7 5])))
***** test
 a = randi (10, 15, 15, 4, 3, 8);
 ord = ordfiltn (a, 3, ones ([3 7 3 1 5]));
 assert (nlfilter (a, [3 7 3 1 5], @(x) sort (x(:))(3)), ord)
 assert (nlfilter (a, [3 7 3 1 5], @(x, y) sort (x(:))(y), 3), ord)
9 tests, 9 passed, 0 known failure, 0 skipped
[imclose]
>>>>> /usr/share/octave/packages/image-2.6.1/imclose.m
***** shared in, out
 in =  [ 0   0   0   1   1   1   0   0   1   1
       0   1   0   1   1   1   0   0   0   1
       1   1   1   1   1   0   0   0   0   0
       0   1   1   1   1   0   0   0   0   0
       0   0   0   1   0   0   0   0   1   0
       0   0   0   0   0   0   0   1   1   1
       0   0   0   0   1   0   1   0   1   0
       0   0   0   1   1   1   1   1   0   0
       0   0   0   0   1   1   1   0   0   0
       0   0   0   1   1   1   0   0   0   0];

 out = [ 1   1   1   1   1   1   1   1   1   1
       1   1   1   1   1   1   0   0   0   1
       1   1   1   1   1   0   0   0   0   1
       1   1   1   1   1   0   0   0   0   1
       0   0   0   1   1   0   0   0   1   1
       0   0   0   1   1   1   1   1   1   1
       0   0   0   1   1   1   1   1   1   1
       0   0   0   1   1   1   1   1   0   0
       0   0   0   1   1   1   1   0   0   0
       0   0   0   1   1   1   1   0   0   0];
***** assert (imclose (logical (in), ones (3)), logical (out));

 out = [99   99   16   16   16   73   74   64   64   64
      98   88   16   16   16   73   71   64   64   64
      93   88   88   61   61   61   68   70   70   70
      93   88   88   61   61   61   68   71   71   71
      93   93   88   61   61   61   68   75   66   66
      79   79   82   90   90   49   49   49   49   66
      79   79   82   91   91   48   46   46   46   66
      79   79   82   95   97   48   46   46   46   72
      18   18   94   96   84   48   46   46   46   59
      18   18  100   96   84   50   50   50   50   59];
***** assert (imclose (magic (10), ones (3)), out);
***** assert (imclose (uint8 (magic (10)), strel ("square", 3)), uint8 (out));

 ## using a se that will be decomposed in 2 pieces
 out =[ 99   99   88   74   74   74   74   70   70   70
        98   93   88   74   74   74   74   70   70   70
        93   93   88   74   74   74   74   70   70   70
        93   93   88   74   74   74   74   71   71   71
        93   93   88   75   75   75   75   75   75   75
        93   93   90   90   90   72   72   72   72   72
        93   93   91   91   91   72   72   72   72   72
        93   93   93   95   97   72   72   72   72   72
        94   94   94   96   97   72   72   72   72   72
       100  100  100   97   97   72   72   72   72   72];
***** assert (imclose (magic (10), ones(5)), out);

 ## using a weird non-symmetric and even-size se
 out =[ 92   99   16   16   16   70   74   58   58   58
        98   88   60   73   16   73   69   70   64   58
        88   81   88   60   60   60   69   69   70   70
        87   87   61   68   61   60   68   69   71   69
        86   93   87   61   61   61   68   75   68   69
        23   82   89   89   90   45   68   45   68   66
        23   23   82   89   91   48   45   45   45   66
        79   23   82   95   97   46   48   46   45   72
        18   79   94   96   78   50   46   46   46   59
        18   18  100   94   94   78   50   50   46   59];
***** assert (imclose (magic (10), [1 0 0 0; 1 1 1 0; 0 1 0 1]), out);
5 tests, 5 passed, 0 known failure, 0 skipped
[imfill]
>>>>> /usr/share/octave/packages/image-2.6.1/imfill.m
***** test
 I = uint8 (5.*[1 1 1; 1 0 1; 1 1 1]);
 bw = logical ([1 1 1; 1 0 1; 1 1 1]);
 I2 = uint8 (5.*ones (3));
 bw2 = logical (ones (3));

 assert (imfill (int8 (I)), int8 (I2))
 assert (imfill (int16 (I)), int16 (I2))
 assert (imfill (int32 (I)), int32 (I2))
 assert (imfill (int64 (I)), int64 (I2))
 assert (imfill (uint8 (I)), uint8 (I2))
 assert (imfill (uint16 (I)), uint16 (I2))
 assert (imfill (uint32 (I)), uint32 (I2))
 assert (imfill (uint64 (I)), uint64 (I2))
 assert (imfill (single (I)), single (I2))
 assert (imfill (double (I)), double (I2))
 assert (imfill (bw, "holes"), bw2)
 assert (imfill (uint8 (bw)), uint8 (bw2))
***** error <must be a binary or grayscale image>
  imfill (i + ones (3, 3));                 # complex input
***** error <must be a binary or grayscale image>
  imfill (sparse (double (I)));   # sparse input
***** error
  imfill ();
***** error
 imfill (true (3), 4, "holes", 5)
***** error <LOCATIONS must be a n-by-1 or n-by-d sized index array>
 imfill (false (3), ones (2, 3))
***** error <LOCATIONS must be a n-by-1 or n-by-d sized index array>
 imfill (false (3), ones (2, 3), 4)
***** error <interactive usage is not yet supported>
 imfill (false (3))
***** error <interactive usage is not yet supported>
 imfill (false (3), 0, 4)
***** warning <ignored LOCATIONS outside of image borders>
 bw = logical ([1 1 1; 1 0 1; 1 1 1]);
 assert (imfill (bw, [5 5]), bw)
 assert (imfill (bw, 15), bw)

 bw = repmat (bw, [1 1 3]);
 assert (imfill (bw, 30), bw)
 assert (imfill (bw, [2 2 5]), bw)
***** test
 bw = logical ([1 0 0 0 0 0 0 0
                1 1 1 1 1 0 0 0
                1 0 0 0 1 0 1 0
                1 0 0 0 1 1 1 0
                1 1 1 1 0 1 1 1
                1 0 0 1 1 0 1 0
                1 0 0 0 1 0 1 0
                1 0 0 0 1 1 1 0]);
 bw2 = logical ([1 0 0 0 0 0 0 0
                 1 1 1 1 1 0 0 0
                 1 1 1 1 1 0 1 0
                 1 1 1 1 1 1 1 0
                 1 1 1 1 1 1 1 1
                 1 0 0 1 1 1 1 0
                 1 0 0 0 1 1 1 0
                 1 0 0 0 1 1 1 0]);
 bw3 = logical ([1 0 0 0 0 0 0 0
                 1 1 1 1 1 0 0 0
                 1 1 1 1 1 0 1 0
                 1 1 1 1 1 1 1 0
                 1 1 1 1 0 1 1 1
                 1 0 0 1 1 0 1 0
                 1 0 0 0 1 0 1 0
                 1 0 0 0 1 1 1 0]);
 assert (imfill (bw, "holes"), bw2)
 assert (imfill (bw, 8, "holes"), bw2)
 assert (imfill (bw, 4, "holes"), bw2)
 assert (imfill (bw, [3 3]), bw3)
 assert (imfill (bw, 19), bw3)
 assert (imfill (bw, [3 3], 4), bw3)
 assert (imfill (bw, 19, 4), bw3)
 assert (imfill (bw, [3 3], 8), bw2)
 assert (imfill (bw, 19, 8), bw2)
 assert (imfill (bw, [19; 20]), bw3)
 assert (imfill (bw, [19; 20], 4), bw3)
 assert (imfill (bw, [19; 20], 8), bw2)
***** warning <ignored LOCATIONS outside of image borders>
 bw = logical ([1 1 1 1 1 1 1
                1 0 0 0 0 0 1
                1 0 1 1 1 0 1
                1 0 1 0 1 0 1
                1 0 1 1 1 0 1
                1 0 0 0 0 0 1
                1 1 1 1 1 1 1]);
 bw44 = logical ([1 1 1 1 1 1 1
                  1 0 0 0 0 0 1
                  1 0 1 1 1 0 1
                  1 0 1 1 1 0 1
                  1 0 1 1 1 0 1
                  1 0 0 0 0 0 1
                  1 1 1 1 1 1 1]);
 bw9 = logical ([1 1 1 1 1 1 1
                 1 1 1 1 1 1 1
                 1 1 1 1 1 1 1
                 1 1 1 0 1 1 1
                 1 1 1 1 1 1 1
                 1 1 1 1 1 1 1
                 1 1 1 1 1 1 1]);
 assert (imfill (bw, "holes"), logical (ones (7)))
 assert (imfill (bw, [4 4]), bw44)
 assert (imfill (bw, 9), bw9)
 assert (imfill (bw, [4 4; 10 10]), bw44)
***** test
 bw = logical ([1 1 0 1 1]);
 assert (imfill (bw, "holes"), bw)
 bw = logical([1 1 0 1 1; 1 1 1 1 1]);
 assert (imfill (bw, "holes"), bw)
***** test
 I = zeros (5);
 I(:, [2 4]) = 1;
 I2_expected = [0   1   1   1   0
                0   1   1   1   0
                0   1   1   1   0
                0   1   1   1   0
                0   1   1   1   0];
 I2 = imfill (I, [0 0 0; 1 1 1; 0 0 0], "holes");
 assert (I2, I2_expected)
***** test
 I = zeros (5);
 I(:, [2 4]) = 1;
 I2_expected = I;
 I2 = imfill (I, [0 1 0; 0 1 0; 0 1 0], "holes");
 assert (I2, I2_expected)
***** test  # this test is Matlab compatible
 I = zeros (5);
 I(:, [2 4]) = 1;
 I2_expected = inf .* ones (5);
 I2 =  imfill (I, [0 0 0; 0 1 0; 0 0 0], "holes");
 assert (I2, I2_expected)
***** test
 I = false (5);
 I(:, [2 4]) = true;
 I2_expected = true (5);
 I2 = imfill (I, [0 0 0; 0 1 0; 0 0 0], "holes");
 assert (I2, I2_expected)
***** test
 I  = uint8 ([10 20 80 85 20
              15 90 03 25 88
              05 85 02 50 83
              90 04 03 80 80
             10 81 83 85 30]);
 I2 = uint8 ([10 20 80 85 20
              15 90 80 80 88
              05 85 80 80 83
              90 80 80 80 80
             10 81 83 85 30]);
 I3  = uint8 ([10 20 80 85 20
               15 90 05 25 88
               05 85 05 50 83
               90 05 05 80 80
               10 81 83 85 30]);
 assert (imfill (I), I2)
 assert (imfill (I, 4), I2)
 assert (imfill (I, 4, "holes"), I2)
 assert (imfill (I, 8), I3)
 assert (imfill (I, "holes"), I2)
***** test
 v_line = [0 1 0; 0 1 0; 0 1 0];
 h_line = [0 0 0; 1 1 1; 0 0 0];
 im = [0 1 0 0 1 0];

 assert (imfill (im, h_line, "holes"), [0 1 1 1 1 0])
 assert (imfill (im, v_line, "holes"), [0 1 0 0 1 0])
 assert (imfill (im', h_line, "holes"), [0 1 0 0 1 0]')
 assert (imfill (im', v_line, "holes"), [0 1 1 1 1 0]')

 im = repmat (im, [1 1 5]);
 assert (imfill (im, h_line, "holes"), repmat ([0 1 1 1 1 0], [1 1 5]))
 assert (imfill (im, v_line, "holes"), im)

 im = permute (im, [2 1 3]);
 assert (imfill (im, h_line, "holes"), im)
 assert (imfill (im, v_line, "holes"), repmat ([0 1 1 1 1 0]', [1 1 5]))
***** test
 im = logical ([0 0 0 0 0 0
                0 1 1 1 1 0
                0 1 0 0 1 0
                0 1 1 1 1 0
                0 0 0 0 0 0]);
 fi = logical ([0 0 0 0 0 0
                0 1 1 1 1 0
                0 1 1 1 1 0
                0 1 1 1 1 0
                0 0 0 0 0 0]);

 assert (imfill (cat (3, im, im, im), 8, 'holes'), cat (3, fi, fi, fi))
 assert (imfill (cat (3, im, im, im), 'holes'), cat (3, im, im, im))
 assert (imfill (cat (3, fi, im, fi), 'holes'), cat (3, fi, fi, fi))
***** test
 emp = false (5, 6);
  im = logical ([0 0 0 0 0 0
                 0 1 1 1 1 0
                 0 1 0 1 0 1
                 0 1 1 1 1 0
                 0 0 0 0 0 0]);
  fi = logical ([0 0 0 0 0 0
                 0 1 1 1 1 0
                 0 1 1 1 1 1
                 0 1 1 1 1 0
                 0 0 0 0 0 0]);
  fi1 = logical ([0 0 0 0 0 0
                  0 1 1 1 1 0
                  0 1 1 1 0 1
                  0 1 1 1 1 0
                  0 0 0 0 0 0]);
  fi2 = logical ([0 0 0 0 0 0
                  0 1 1 1 1 0
                  0 1 0 1 1 1
                  0 1 1 1 1 0
                  0 0 0 0 0 0]);

 assert (imfill (cat (3, im, im, im), [3 3 2]), cat (3, fi1, fi1, fi1))
 assert (imfill (cat (3, im, im, im), [3 5 2]), cat (3, fi2, fi2, fi2))
 assert (imfill (cat (3, im, im, im), [3 3 2; 3 5 2]), cat (3, fi, fi, fi))
 assert (imfill (cat (3, emp, im, emp), [3 3 2]), true (5, 6, 3))
21 tests, 21 passed, 0 known failure, 0 skipped
[makelut]
>>>>> /usr/share/octave/packages/image-2.6.1/makelut.m
***** demo
 makelut(inline('sum(x(:))>=3','x'), 2)
 % Returns '1' if one or more values
 % in the input matrix are 1
***** assert(prod(makelut(inline('sum(x(:))==2','x'),2)==makelut(inline('sum(x(:))==a*b*c*d','x','a','b','c','d'),2,2/(3*4*5),3,4,5))); # test multiple params
***** assert(prod(makelut(inline('x(1,1)==1','x'),2)==[zeros(2^3,1);ones(2^3,1)])==1); # test 2-by-2
***** assert(prod(makelut(inline('x(1,1)==1','x'),3)==[zeros(2^8,1);ones(2^8,1)])==1); # test 3-by-3
***** assert(prod(makelut(inline('x(1,1)==1','x'),4)==[zeros(2^15,1);ones(2^15,1)])==1); # test 4-by-4
***** assert(prod(makelut(inline('x(2,1)==1','x'),3)==[zeros(2^7,1);ones(2^7,1);zeros(2^7,1);ones(2^7,1)])==1); # another test for 3-by-3
5 tests, 5 passed, 0 known failure, 0 skipped
[checkerboard]
>>>>> /usr/share/octave/packages/image-2.6.1/checkerboard.m
***** demo
 ## Simplest case, default checkerboard size:
 ##     8 by 8 checkerboard, with squares 10 pixel wide
 board = checkerboard ();
 imshow (board)
***** demo
 ## Simplest case, default checkerboard size:
 ##     8 by 16 checkerboard, with squares 5 pixel wide
 board = checkerboard (5, 4, 8);
 imshow (board)
***** assert (checkerboard (0), zeros (0, 0))
***** assert (checkerboard (0, 3), zeros (0, 0))
***** assert (checkerboard (0, 2, 4), zeros (0, 0))
***** assert (checkerboard (0, 2, 4, 3), zeros (0, 0, 0))
***** assert (checkerboard (0, 2, 4, 3, 2), zeros (0, 0, 0, 0))
***** assert (checkerboard (1, 4, 2, 3, 0), zeros (8, 4, 6, 0))
***** assert (checkerboard (1, 4, 0, 3, 2), zeros (8, 0, 6, 4))
***** assert (checkerboard (2, 4, 0, 3, 2), zeros (16, 0, 12, 8))
***** test
 out = zeros (80);
 i1 = ((1:20:80) .+ (0:9)')(:);
 i2 = ((11:20:80) .+ (0:9)')(:);
 out(i1, i2) = 1;
 out(i2, i1) = 1;
 i1r = ((41:20:80) .+ (0:9)')(:);
 i2r = ((51:20:80) .+ (0:9)')(:);
 out(i2, i1r) = 0.7;
 out(i1, i2r) = 0.7;
 assert (checkerboard (), out)
 assert (checkerboard (10, 4, 4), out)
 assert (checkerboard (10, [4 4]), out)
 assert (checkerboard (10, [4; 4]), out)
***** test
 out = zeros (8);
 out(2:2:8, 1:2:8) = 1;
 out(1:2:8, 2:2:8) = 1;
 out(1:2:8, 6:2:8) = 0.7;
 out(2:2:8, 5:2:8) = 0.7;
 assert (checkerboard (1), out)
 assert (checkerboard (1, 4), out)
 assert (checkerboard (1, 4, 4), out)
 assert (checkerboard (1, [4 4]), out)
***** test
 out = zeros (10);
 out(2:2:10, 1:2:10) = 1;
 out(1:2:10, 2:2:10) = 1;
 out(1:2:10, 6:2:10) = 0.7;
 out(2:2:10, 7:2:10) = 0.7;
 assert (checkerboard (1, 5), out)
 assert (checkerboard (1, 5, 5), out)
 assert (checkerboard (1, [5 5]), out)
***** test
 out = zeros (20);
 out([1:4:20 2:4:20], [3:4:20 4:4:20]) = 1;
 out([3:4:20 4:4:20], [1:4:20 2:4:20]) = 1;
 out([1:4:20 2:4:20], [11:4:20 12:4:20]) = 0.7;
 out([3:4:20 4:4:20], [13:4:20 14:4:20]) = 0.7;
 assert (checkerboard (2, 5), out)
 assert (checkerboard (2, 5, 5), out)
 assert (checkerboard (2, [5 5]), out)
***** test
 out = zeros (4, 4, 4);
 out([1 3], 1, [1 3]) = 1;
 out([2 4], 2, [1 3]) = 1;
 out([1 3], 2, [2 4]) = 1;
 out([2 4], 1, [2 4]) = 1;
 out([1 3], 3, [1 3]) = 0.7;
 out([2 4], 4, [1 3]) = 0.7;
 out([1 3], 4, [2 4]) = 0.7;
 out([2 4], 3, [2 4]) = 0.7;
 assert (checkerboard (1, [2 2 2]), out)
 assert (checkerboard (1, 2, 2, 2), out)
***** test
 out = zeros (8, 8, 8);
 out([1 2 5 6], [1 2], [1 2 5 6]) = 1;
 out([3 4 7 8], [3 4], [1 2 5 6]) = 1;
 out([1 2 5 6], [3 4], [3 4 7 8]) = 1;
 out([3 4 7 8], [1 2], [3 4 7 8]) = 1;
 out([1 2 5 6], [5 6], [1 2 5 6]) = 0.7;
 out([3 4 7 8], [7 8], [1 2 5 6]) = 0.7;
 out([1 2 5 6], [7 8], [3 4 7 8]) = 0.7;
 out([3 4 7 8], [5 6], [3 4 7 8]) = 0.7;
 assert (checkerboard (2, [2 2 2]), out)
 assert (checkerboard (2, 2, 2, 2), out)
14 tests, 14 passed, 0 known failure, 0 skipped
[ordfiltn]
>>>>> /usr/share/octave/packages/image-2.6.1/ordfiltn.m
***** shared b, f, s
 b = [ 0  1  2  3
       1  8 12 12
       4 20 24 21
       7 22 25 18];

 f = [ 8 12 12 12
      20 24 24 24
      22 25 25 25
      22 25 25 25];
***** assert (ordfiltn (b, 9, true (3)), f);

 f = [ 1  8 12 12
       8 20 21 21
      20 24 24 24
      20 24 24 24];
***** assert (ordfiltn (b, 8, true (3)), f);

 f = [ 1  2  8 12
       4 12 20 21
       8 22 22 21
      20 24 24 24];
***** assert (ordfiltn (b, 7, true (3), "symmetric"), f);

 f = [ 1  8 12 12
       4 20 24 21
       7 22 25 21
       7 22 25 21];
***** assert (ordfiltn (b, 3, true (3, 1)), f);

 f = [ 1  8 12 12
       4 20 24 18
       4 20 24 18
       4 20 24 18];
***** assert (ordfiltn (b, 3, true (4, 1)), f);

 f = [ 4 20 24 21
       7 22 25 21
       7 22 25 21
       7 22 25 21];
***** assert (ordfiltn (b, 4, true (4, 1)), f);

 s = [0 0 1
      0 0 1
      0 0 1];
 f = [ 2  8 12 12
       9 20 22 21
      21 25 24 24
      21 25 24 24];
***** assert (ordfiltn (b, 8, true (3), s), f);

 b(:,:,2) = b(:,:,1) - 1;
 b(:,:,3) = b(:,:,2) - 1;
 f(:,:,1) = [ 1  8 11 11
              8 20 21 21
              20 24 24 24
              20 24 24 24];
 f(:,:,2) = [ 6 10 11 11
             18 22 22 22
             20 24 24 24
             20 24 24 24];
 f(:,:,3) = [ 0  7 10 10
              7 19 20 20
             19 23 23 23
             19 23 23 23];
***** assert (ordfiltn (b, 25, true (3, 3, 3)), f);
8 tests, 8 passed, 0 known failure, 0 skipped
[imregionalmax]
>>>>> /usr/share/octave/packages/image-2.6.1/imregionalmax.m
***** test
 a = [
    7    3    9    3   10    3
    4    2    3   10    1    3
    1    4    6    9    4   10
    8    7    9    3    4    8
    5    9    3    3    8    9
    3    6    9    4    1   10];

 a4 = [
    1    0    1    0    1    0
    0    0    0    1    0    0
    0    0    0    0    0    1
    1    0    1    0    0    0
    0    1    0    0    0    0
    0    0    1    0    0    1];
 assert (imregionalmax (a, 4), logical (a4))
 a8 = [
    1    0    0    0    1    0
    0    0    0    1    0    0
    0    0    0    0    0    1
    0    0    0    0    0    0
    0    0    0    0    0    0
    0    0    0    0    0    1];
 assert (imregionalmax (a, 8), logical (a8))
 assert (imregionalmax (a), logical (a8))
1 test, 1 passed, 0 known failure, 0 skipped
[imhist]
>>>>> /usr/share/octave/packages/image-2.6.1/imhist.m
***** shared nn, bb, enn, ebb
 [nn, bb] = imhist(logical([0 1 0 0 1]));
***** assert({nn, bb}, {[3 2]', [0 1]'})
 [nn, bb] = imhist([0 0.2 0.4 0.9 1], 5);
***** assert({nn, bb}, {[1 1 1 0 2]', [0 0.25 0.5 0.75 1]'})
 [nn, bb] = imhist([-2 0 0.2 0.4 0.9 1 5], 5);
***** assert({nn, bb}, {[2 1 1 0 3]', [0 0.25 0.5 0.75 1]'})
 [nn, bb] = imhist(uint8([0 32 255]), 256);
 enn = zeros(256, 1); enn([1, 33, 256]) = 1;
 ebb = 0:255;
***** assert({nn, bb}, {enn, ebb'})
 [nn, bb] = imhist(int8([-50 0 100]), 31);
 enn = zeros(31, 1); enn([10, 16, 28]) = 1;
 ebb = -128:8.5:127;
***** assert({nn, bb}, {enn, ebb'})
5 tests, 5 passed, 0 known failure, 0 skipped
[applylut]
>>>>> /usr/share/octave/packages/image-2.6.1/applylut.m
***** demo
 lut = makelut (inline ('sum (x (:)) >= 3', 'x'), 3);
 S = applylut (eye (5), lut);
 disp (S)
 ## Everything should be 0 despite a diagonal which doesn't reach borders.
***** assert (prod (applylut (eye (3), makelut (@(x) x(1) == 1, 2)) == eye (3)), [1 1 1]);
***** assert (prod (applylut (eye (3), makelut (@(x) x(2,2) == 1, 3)) == eye (3)), [1 1 1]);
***** assert (prod (applylut (eye (3), makelut (@(x) x(3,3) == 1, 3)) ==
              applylut (eye (3), makelut (@(x) x(2,2) == 1, 2))),
        [1 1 1]);
3 tests, 3 passed, 0 known failure, 0 skipped
[lab2xyz]
>>>>> /usr/share/octave/packages/image-2.6.1/lab2xyz.m
***** assert (lab2xyz ([0, 0, 0]), [0 0 0], 1e-3)
***** assert (lab2xyz ([53.24, 80.09, 67.20]), [0.4125, 0.2127, 0.0193], 1e-3)
***** assert (lab2xyz ([97.14, -21.55, 94.48]), [0.7700, 0.9278, 0.1385], 1e-3)
***** assert (lab2xyz ([87.74, -86.18, 83.18]), [0.3576, 0.7152, 0.1192], 1e-3)
***** assert (lab2xyz ([91.11, -48.09, -14.13]), [0.5380, 0.7873, 1.0694], 1e-3)
***** assert (lab2xyz ([32.30, 79.19, -107.86]), [0.1804, 0.07217, 0.9502], 1e-3)
***** assert (lab2xyz ([60.32, 98.24, -60.83]), [0.5929, 0.28484, 0.9696], 1e-3)
***** assert (lab2xyz ([100, 0.00, 0.00]), [0.9505, 1.0000, 1.0888], 1e-3)
***** assert (lab2xyz ([53.39, 0.00, 0.00]), [0.2034, 0.2140, 0.2330], 1e-3)
***** assert (lab2xyz ([39.77, 64.51, 54.13]), [0.2155, 0.1111, 0.0101], 1e-3)
***** assert (lab2xyz ([25.42, 47.91, 37.91]), [0.0883, 0.0455, 0.0041], 1e-3)
***** assert (lab2xyz ([9.66, 29.68, 15.24]), [0.02094, 0.0108, 0.00098], 1e-3)
***** assert (lab2xyz ([68.11, 48.39, 22.83]), [0.5276, 0.3812, 0.2482], 1e-3)
***** assert (lab2xyz ([150 130 130]), [4.596, 2.931, 0.519], 1e-3)
***** test
 lab_map = rand (64, 3);
 lab_map(:,1) = lab_map(:,1) .* 100;
 lab_map(:,2) = lab_map(:,2) .* 254 - 127;
 lab_map(:,3) = lab_map(:,3) .* 254 - 127;
 assert (xyz2lab (lab2xyz (lab_map)), lab_map, 1e-5);
***** test
 lab_img = rand (64, 64, 3);
 lab_img(:,:,1) = lab_img(:,:,1) .* 100;
 lab_img(:,:,2) = lab_img(:,:,2) .* 254 - 127;
 lab_img(:,:,3) = lab_img(:,:,3) .* 254 - 127;
 assert (xyz2lab (lab2xyz (lab_img)), lab_img, 1e-5);
***** assert (lab2xyz (sparse ([0 0 0])), [0 0 0], 1e-3)
***** assert (lab2xyz (sparse ([100, 0.00, 0.00])), [0.9505, 1.0000, 1.0888], 1e-3)
***** assert (class (lab2xyz (single([50 50 50]))), 'single')
***** error lab2xyz ()
***** error lab2xyz (1,2)
***** error <invalid data type 'cell'> lab2xyz ({1})
***** error <Lab must be a colormap or Lab image> lab2xyz (ones (2,2))
***** test
 lab = rand (16, 16, 3, 5);
 lab(:,:,1,:) = lab(:,:,1,:) .* 100;
 lab(:,:,2,:) = lab(:,:,2,:) .* 254 - 127;
 lab(:,:,3,:) = lab(:,:,3,:) .* 254 - 127;
 xyz = zeros (size (lab));
 for i = 1:5
   xyz(:,:,:,i) = lab2xyz (lab(:,:,:,i));
 endfor
 assert (lab2xyz (lab), xyz)
24 tests, 24 passed, 0 known failure, 0 skipped
[lab2double]
>>>>> /usr/share/octave/packages/image-2.6.1/lab2double.m
***** test
 l_max_f = 100 + (25500 / 65280);
 ab_max_f = 127 + (255 / 256);
 cm = [
   -Inf
   Inf
   NaN
   l_max_f
   ab_max_f
   -200
   -129
   -128
   -128+(255/65280)*(0.499999)
   -128+(255/65280)*(0.500001) # should be 0.5, but float rounding error
   -128+(255/65280)*(0.500002)
   -127
   -1
   0
   (100/65280)*(0.499999)
   (100/65280)*(0.51)
   (100/65280)*(0.500001)
   1
   99
   100
   101
   126
   127
   128
   254
   255
   256
   257];
 cm = repmat (cm, [1 3]);
 im2d = reshape (cm, [7 4 3]);
 imnd = permute (im2d, [1 4 3 2]);

 cm_uint8 = uint8 ([
     0    0    0
   255  255  255
   255  255  255
   255  228  228
   255  255  255
     0    0    0
     0    0    0
     0    0    0
     0    0    0
     0    0    0
     0    0    0
     0    1    1
     0  127  127
     0  128  128
     0  128  128
     0  128  128
     0  128  128
     3  129  129
   252  227  227
   255  228  228
   255  229  229
   255  254  254
   255  255  255
   255  255  255
   255  255  255
   255  255  255
   255  255  255
   255  255  255]);

 assert (lab2uint8 (cm), cm_uint8)
 im2d_uint8 = reshape (cm_uint8, [7 4 3]);
 assert (lab2uint8 (im2d), im2d_uint8)
 assert (lab2uint8 (imnd), permute (im2d_uint8, [1 4 3 2]))

 cm_uint16 = uint16 ([
       0      0      0
   65535  65535  65535
   65535  65535  65535
   65535  58468  58468
   65535  65535  65535
       0      0      0
       0      0      0
       0      0      0
       0      0      0
       0      1      1
       0      1      1
       0    256    256
       0  32512  32512
       0  32768  32768
       0  32768  32768
       1  32768  32768
       1  32768  32768
     653  33024  33024
   64627  58112  58112
   65280  58368  58368
   65535  58624  58624
   65535  65024  65024
   65535  65280  65280
   65535  65535  65535
   65535  65535  65535
   65535  65535  65535
   65535  65535  65535
   65535  65535  65535]);

 assert (lab2uint16 (cm), cm_uint16)
 im2d_uint16 = reshape (cm_uint16, [7 4 3]);
 assert (lab2uint16 (im2d), im2d_uint16)
 assert (lab2uint16 (imnd), permute (im2d_uint16, [1 4 3 2]))

 assert (lab2single (cm), single (cm))
 assert (lab2single (im2d), single (im2d))
 assert (lab2single (imnd), single (imnd))
1 test, 1 passed, 0 known failure, 0 skipped
[rgb2ycbcr]
>>>>> /usr/share/octave/packages/image-2.6.1/rgb2ycbcr.m
***** test
 in(:,:,1) = magic (5);
 in(:,:,2) = magic (5);
 in(:,:,3) = magic (5);
 out(:,:,1) = [31  37  17  23  29
               36  20  22  28  30
               19  21  27  33  35
               25  26  32  34  19
               25  31  37  18  24];
 out(:,:,2) = 128;
 out(:,:,3) = 128;
 assert (rgb2ycbcr (uint8 (in)), uint8 (out));
***** shared cbcr
 cbcr = 0.5019607843137255;
 out(1:10, 1)  = linspace (16/255, 235/255, 10);
 out(:, [2 3]) = cbcr;
 assert (rgb2ycbcr (gray (10)), out, 0.00001);
***** assert (rgb2ycbcr ([1 1 1]), [0.92157 cbcr cbcr], 0.0001);
2 tests, 2 passed, 0 known failure, 0 skipped
[stretchlim]
>>>>> /usr/share/octave/packages/image-2.6.1/stretchlim.m
***** error (stretchlim ());
***** error (stretchlim ("bad parameter"));
***** error (stretchlim (zeros (10, 10), "bad parameter"));
***** error (stretchlim (zeros (10, 10), 0.01, 2));
***** assert (stretchlim (0.01:.01:1), [0.02; 0.99])
***** assert (stretchlim (0.01:.01:1), stretchlim (0.01:.01:1, [0.01 0.99]))
***** assert (stretchlim (0.01:.01:1, 0.15), stretchlim (0.01:.01:1, [0.15 0.85]))
***** assert (stretchlim (0.01:.01:1, [0.01,0.95]), [0.02; 0.95], eps)
***** assert (stretchlim (0.01:.01:1, 0), [0.01; 1])
***** test
 im = rand (5);
 assert (stretchlim (im, 0), [min(im(:)); max(im(:))])
***** test
 im = rand (5, 5, 3);
 assert (stretchlim (im, 0),
         [min(im(:,:,1)(:)) min(im(:,:,2)(:)) min(im(:,:,3)(:));
          max(im(:,:,1)(:)) max(im(:,:,2)(:)) max(im(:,:,3)(:))])
***** test
 im = rand (5);
 assert (stretchlim (im, 0.03), [min(im(:)); max(im(:))])
 assert (stretchlim (im, 0.0399), [min(im(:)); max(im(:))])
***** assert (stretchlim (uint8 (1:100)), im2double (uint8 ([2; 99])))
***** assert (stretchlim (uint8 (1:100), .25), im2double (uint8 ([26; 75])))
***** assert (stretchlim (uint16  (1:1000)), im2double (uint16 ([11; 990])))
***** assert (stretchlim (int16 (-100:100)), im2double (int16 ([-98; 98])))
***** assert (stretchlim (single (0.01:.01:1)),
         double (single (0.01:.01:1)([2; 99])).')
***** assert (stretchlim (uint8 ([1 repmat(2, [1, 90]) 92:100]), 0.05),
        im2double (uint8 ([2; 95])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 4]) 6:100]), 0.05),
        im2double (uint8 ([6; 95])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 5]) 7:100]), 0.05),
        im2double (uint8 ([2; 95])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 6]) 8:100]), 0.05),
        im2double (uint8 ([2; 95])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 7]) 9:100]), 0.05),
        im2double (uint8 ([2; 95])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 8]) 10:100]), 0.05),
        im2double (uint8 ([2; 95])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 5]) repmat(3, [1 5]) 9:100]), 0.04),
        im2double (uint8 ([2; 96])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 5]) repmat(3, [1 5]) 9:100]), 0.05),
        im2double (uint8 ([2; 95])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 5]) repmat(3, [1 5]) 9:100]), 0.06),
        im2double (uint8 ([3; 94])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 5]) repmat(3, [1 5]) 9:100]), 0.07),
        im2double (uint8 ([3; 93])))
***** assert (stretchlim (uint8 ([1 repmat(2, [1 5]) repmat(3, [1 5]) 9:100]), 0.08),
        im2double (uint8 ([3; 92])))
***** test
 RGB = zeros (100, 1, 3, "uint16");
 RGB(:,:,1) = [1:1:100];
 RGB(:,:,2) = [2:2:200];
 RGB(:,:,3) = [4:4:400];
 assert (stretchlim (RGB) , im2double (uint16 ([2 4 8; 99 198 396])))
***** test
 im6c = zeros (100, 1, 6, "uint16");
 im6c(:,:,1) = [1:1:100];
 im6c(:,:,2) = [2:2:200];
 im6c(:,:,3) = [4:4:400];
 im6c(:,:,4) = [8:8:800];
 im6c(:,:,5) = [16:16:1600];
 im6c(:,:,6) = [32:32:3200];
 assert (stretchlim (im6c) ,
         im2double (uint16 ([2 4 8 16 32 64; 99 198 396 792 1584 3168])))
***** test
 im = [0 0 .1 .1 .1 .1 .2 .2 .2 .4 .4 .6 .6 .7 .7 .9 .9 .9 1 1];

 assert (stretchlim (im), [0; 1])

 ## Consider the returned lower limit in this test.  A lower limit
 ## of 0.1 will saturate two elements (10%), while 0.2 will saturate
 ## 6 elements (30%).  Both have the same distance to 20% but returning
 ## 0.1 is Matlab compatible.
 ## Now looking at the higher limit.  A limit of .9 will saturate
 ## 2 elements (10%), while a limit of 0.7 will saturate 5 elements (25%).
 ## However, for Matlab compatibility we must return .9 even though
 ## 25% would be closer to 20%.
 ## Basically, it's not just rounded.
 assert (stretchlim (im, .2),  [0.1; 0.9])

 assert (stretchlim (im, .15), [0.1; 0.9])
 assert (stretchlim (im, .1),  [0.1; 0.9])
 assert (stretchlim (im, .25), [0.1; 0.7])

 ## Reorder the vector of values (real images don't have the values
 ## already sorted), just to be sure it all works.
 im([6 3 16 11 7 17 14 8 5 19 15 1 2 4 18 13 9 20 10 12]) = im;
 assert (stretchlim (im, .2),  [0.1; 0.9])
 assert (stretchlim (im, .15), [0.1; 0.9])
 assert (stretchlim (im, .1),  [0.1; 0.9])
 assert (stretchlim (im, .25), [0.1; 0.7])
***** assert (stretchlim (0.01:.001:1), [0.019; 0.991], eps)
***** assert (stretchlim (0.01:.001:1, [0.01,0.95]), [0.019; 0.951], eps)
***** assert (stretchlim (0.01:.001:1, 0), [0.01; 1])
***** assert (stretchlim (single (0.01:.001:1)),
         double (single (0.01:.001:1)([10; 982])).')
***** test
 assert (stretchlim ([(.05:.05:1) (2:4)], 0.2), [0.25; 0.95], eps)
 assert (stretchlim ([(.05:.05:1) (2:5)], 0.2), [0.25; 1])
 assert (stretchlim ([(.05:.05:1) (2:6)], 0.2), [0.3; 1])
 assert (stretchlim ([(.05:.05:1) (2:7)], 0.2), [0.3; 1])
***** test
 assert (stretchlim ([(-6:0) (.05:.05:1)], 0.2), [0; 0.75], eps)
 assert (stretchlim ([(-5:0) (.05:.05:1)], 0.2), [0; 0.75], eps)
***** test
 im = rand (4, 4, 2, 3, 2);
 rv = zeros (2, 2, 3, 2);
 for p = 1:2
   for q = 1:3
     for r = 1:2
       rv(:,p,q,r) = stretchlim (im(:,:,p,q,r), 0.25);
     endfor
   endfor
 endfor
 assert (stretchlim (im, 0.25), rv)
***** test
 im = rand (4, 4, 2, 3, 2);
 rv = zeros (2, 2, 3, 2);
 for p = 1:2
   for q = 1:3
     for r = 1:2
       rv(:,p,q,r) = stretchlim (im(:,:,p,q,r), 0);
     endfor
   endfor
 endfor
 assert (stretchlim (im, 0), rv)
***** assert (stretchlim (zeros (5)), [0; 1])
***** assert (stretchlim (ones (5)), [0; 1])
***** assert (stretchlim (.6 * ones (5)), [0; 1])
***** assert (stretchlim (zeros (3, 3, 3, 3)), repmat ([0; 1], [1 3 3]))
***** assert (stretchlim ([0 .5 .5 .5 .5 1], .2), [0; 1])
***** test
 im = repmat ((magic (5) -1) / 24, [1 1 3 3]);
 im(:,:,1,1) = 0;
 im(:,:,2,2) = .5;
 im(:,:,3,3) = 1;
 lims = stretchlim (im, 0.2);
 assert (size (lims), [2 3 3])
 assert (lims(:, [2 3 4 6 7 8]),
         repmat ([(1/24)*round(24*.2); 1-((1/24)*round(24*.2))], [1 6]), eps)
 assert (lims(:, [1 5 9]), repmat ([0; 1], [1 3]))
45 tests, 45 passed, 0 known failure, 0 skipped
[imgetfile]
>>>>> /usr/share/octave/packages/image-2.6.1/imgetfile.m
***** assert (1)
1 test, 1 passed, 0 known failure, 0 skipped
[montage]
>>>>> /usr/share/octave/packages/image-2.6.1/montage.m
***** function cdata = montage_cdata (varargin)
  h = figure ();
  set (h, "visible", "off");
  mh = montage (varargin{:});
  cdata = get (mh, "cdata");
  close (h);
***** endfunction
***** test
 im = uint8 (ones (2, 2, 1, 5)) .* reshape ([1 2 3 4 5], [1 1 1 5]);
 cdata = montage_cdata (im);
 expected = uint8 ([
   1 1 2 2 3 3
   1 1 2 2 3 3
   4 4 5 5 0 0
   4 4 5 5 0 0
 ]);
 assert (cdata, expected)
***** test
 im = uint8 (ones (2, 4, 1, 6)) .* reshape ([1 2 3 4 5 6], [1 1 1 6]);
 cdata = montage_cdata (im);
 expected = uint8 ([
   1 1 1 1 2 2 2 2
   1 1 1 1 2 2 2 2
   3 3 3 3 4 4 4 4
   3 3 3 3 4 4 4 4
   5 5 5 5 6 6 6 6
   5 5 5 5 6 6 6 6
 ]);
 assert (cdata, expected)
2 tests, 2 passed, 0 known failure, 0 skipped
[blockproc]
>>>>> /usr/share/octave/packages/image-2.6.1/blockproc.m
***** demo
 blockproc(eye(6),[2,2],inline("any(x(:))","x"))
 # Returns a 3-by-3 diagonal
***** assert(blockproc(eye(6),[2,2],"sum"),blockproc(eye(6),[2,2], at sum));
***** assert(blockproc(eye(6),[2,2],"sum"),blockproc(eye(6),[2,2],inline("sum(x)","x")));
***** assert(blockproc(eye(6),[1,2], at sum),kron(eye(3),[1;1]));
***** assert(blockproc(eye(6),[2,2],inline("any(x(:))","x")),eye(3)!=0);
***** assert(blockproc(eye(6),[1,2],[1,1],inline("sum(x(:))","x")),[2,1,0;3,2,0;2,3,1;1,3,2;0,2,3;0,1,2]);
***** assert(blockproc(eye(6),'indexed',[1,2],[1,1],inline("sum(x(:))","x")),[8,5,6;6,2,3;5,3,4;4,3,5;3,2,6;6,5,8]);
***** assert(blockproc(eye(6),[2,3],[4,3],inline("sum(x(:))","x")),ones(3,2)*6);
***** assert(blockproc(eye(6),[2,2],inline("int8(sum(x(:)))","x")),eye(3,"int8")*2);
***** assert(blockproc(uint8(eye(6)),[1,2],[1,1],inline("sum(x(:))","x")),[2,1,0;3,2,0;2,3,1;1,3,2;0,2,3;0,1,2]);
***** assert(blockproc(uint8(eye(6)),'indexed',[1,2],[1,1],inline("sum(x(:))","x")),[2,1,0;3,2,0;2,3,1;1,3,2;0,2,3;0,1,2]);
***** assert(blockproc(uint16(eye(6)),[1,2],[1,1],inline("sum(x(:))","x")),[2,1,0;3,2,0;2,3,1;1,3,2;0,2,3;0,1,2]);
***** assert(blockproc(uint16(eye(6)),'indexed',[1,2],[1,1],inline("sum(x(:))","x")),[2,1,0;3,2,0;2,3,1;1,3,2;0,2,3;0,1,2]);
12 tests, 12 passed, 0 known failure, 0 skipped
[xyz2lab]
>>>>> /usr/share/octave/packages/image-2.6.1/xyz2lab.m
***** assert (xyz2lab ([0, 0, 0]), [0 0 0], 5e-2)
***** assert (xyz2lab ([0.4125, 0.2127, 0.0193]), [53.24, 80.09, 67.20], 5e-2)
***** assert (xyz2lab ([0.7700, 0.9278, 0.1385]), [97.14, -21.55, 94.48], 5e-2)
***** assert (xyz2lab ([0.3576, 0.7152, 0.1192]), [87.74, -86.18, 83.18], 5e-2)
***** assert (xyz2lab ([0.5380, 0.7873, 1.0694]), [91.11, -48.09, -14.13], 5e-2)
***** assert (xyz2lab ([0.1804, 0.07217, 0.9502]), [32.30, 79.19, -107.86], 5e-2)
***** assert (xyz2lab ([0.5929, 0.28484, 0.9696]), [60.32, 98.24, -60.83], 5e-2)
***** assert (xyz2lab ([0.9505, 1.0000, 1.0888]), [100, 0.00, 0.00], 5e-2)
***** assert (xyz2lab ([0.2034, 0.2140, 0.2330]), [53.39, 0.00, 0.00], 5e-2)
***** assert (xyz2lab ([0.2155, 0.1111, 0.0101]), [39.77, 64.51, 54.13], 5e-2)
***** assert (xyz2lab ([0.0883, 0.0455, 0.0041]), [25.42, 47.91, 37.91], 5e-2)
***** assert (xyz2lab ([0.02094, 0.0108, 0.00098]), [9.66, 29.68, 15.24], 5e-2)
***** assert (xyz2lab ([0.5276, 0.3812, 0.2482]), [68.11, 48.39, 22.83], 5e-2)
***** assert (xyz2lab ([1.5 1 1]), [100, 82.15, 5.60], 5e-2)
 xyz_map = rand (64, 3);
 assert (lab2xyz (xyz2lab (xyz_map)), xyz_map, 1e-5);
***** test
 xyz_img = rand (64, 64, 3);
 assert (lab2xyz (xyz2lab (xyz_img)), xyz_img, 1e-5);
***** assert (xyz2lab (sparse ([0 0 0])), [0 0 0], 5e-2)
***** assert (class (xyz2lab (single([0.5 0.5 0.5]))), 'single')
***** error xyz2lab ()
***** error xyz2lab (1,2)
***** error <invalid data type 'cell'> xyz2lab ({1})
***** error <XYZ must be a colormap or XYZ image> xyz2lab (ones (2,2))
***** test
 xyz = rand (16, 16, 3, 5);
 lab = zeros (size (xyz));
 for i = 1:5
   lab(:,:,:,i) = xyz2lab (xyz(:,:,:,i));
 endfor
 assert (xyz2lab (xyz), lab)
22 tests, 22 passed, 0 known failure, 0 skipped
[imadd]
>>>>> /usr/share/octave/packages/image-2.6.1/imadd.m
***** assert (imadd (uint8   ([23 250]), uint8   ([23 250])),            uint8   ([46 255])); # default to first class and truncate
***** assert (imadd (uint8   ([23 250]), 10),                            uint8   ([33 255])); # works adding a scalar
***** assert (imadd (uint8   ([23 250]), uint8   ([23 250]), "uint16"),  uint16  ([46 500])); # defining output class works
***** assert (imadd (logical ([ 1   0]), logical ([ 1   1])),            double  ([ 2   1])); # return double for two logical images
***** assert (imadd (logical ([ 1   0]), logical ([ 1   1]), "logical"), logical ([ 1   1])); # this is matlab incompatible on purpose
***** fail  ("imadd (uint8   ([23 250]), uint16  ([23 250]))");                               # input need to have same class
6 tests, 6 passed, 0 known failure, 0 skipped
[isrgb]
>>>>> /usr/share/octave/packages/image-2.6.1/isrgb.m
***** assert (isrgb ("this is not a RGB image"), false);
***** assert (isrgb (rand (5, 5)), false);
***** assert (isrgb (rand (5, 5, 1, 5)), false);
***** assert (isrgb (rand (5, 5, 3, 5)), true);
***** assert (isrgb (rand (5, 5, 3)), true);
***** assert (isrgb (ones (5, 5, 3)), true);
***** assert (isrgb (ones (5, 5, 3) + eps), false);
***** assert (isrgb (zeros (5, 5, 3) - eps), false);
***** assert (isrgb (rand (5, 5, 3) > 0.5), false);
***** assert (isrgb (randi ([-100 100], 5, 5, 3, "int16")), true)
10 tests, 10 passed, 0 known failure, 0 skipped
[imbothat]
>>>>> /usr/share/octave/packages/image-2.6.1/imbothat.m
***** assert (imbothat (ones (3), [1 1; 0 1]), zeros (3));
***** assert (imbothat (true (3), [1 1; 0 1]), false (3));
***** shared in, out, se
 in =  [ 0   0   0   1   1   1   0   0   1   1
         0   1   0   1   1   1   0   0   0   1
         1   1   1   1   1   0   0   0   0   0
         0   1   1   1   1   0   0   0   0   0
         0   0   0   1   0   0   0   0   1   0
         0   0   0   0   0   0   0   1   1   1
         0   0   0   0   1   0   1   0   1   0
         0   0   0   1   1   1   1   1   0   0
         0   0   0   0   1   1   1   0   0   0
         0   0   0   1   1   1   0   0   0   0];

 out = [ 1   1   1   0   0   0   1   1   0   0
         1   0   1   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   1
         1   0   0   0   0   0   0   0   0   1
         0   0   0   0   1   0   0   0   0   1
         0   0   0   1   1   1   1   0   0   0
         0   0   0   1   0   1   0   1   0   1
         0   0   0   0   0   0   0   0   0   0
         0   0   0   1   0   0   0   0   0   0
         0   0   0   0   0   0   1   0   0   0];
***** assert (imbothat (logical (in), ones (3)), logical (out));

 out = [ 7    0   15    8    1    6    0   13    6   24
         0    8    9    2    0    0   16    7    0   23
        89    7    0   41   39    7   12    7    0   23
         8    1   69   40   58    1    6    2    0   43
         7    0   63   59   52    0    0    0   14   32
        62   55    6    7    0    7    0   23   16    1
        56   74    0    2    0    0   16   14    7    0
         0   73   69    0    0   19   15    8    1    0
         8    6    0    0    6   13    9    2    0    6
         7    0    0   19    0   14    7    0   23    0];
***** assert (imbothat (magic (10), ones (3)), out);
***** assert (imbothat (uint8 (magic (10)), strel ("square", 3)), uint8 (out));

 ## using a se that will be decomposed in 2 pieces
 out =[ 7    0   87   66   59    7    0   19   12   30
        0   13   81   60   58    1   19   13    6   29
       89   12    0   54   52   20   18    7    0   23
        8    6   69   53   71   14   12    2    0   43
        7    0   63   73   66   14    7    0   23   41
       76   69   14    7    0   30   23   46   39    7
       70   88    9    2    0   24   42   40   33    6
       14   87   80    0    0   43   41   34   27    0
       84   82    0    0   19   37   35   28   26   19
       89   82    0   20   13   36   29   22   45   13];
***** assert (imbothat (magic (10), ones(5)), out);

 ## using a weird non-symmetric and even-size se
 out =[ 0    0   15    8    1    3    0    7    0   18
        0    8   53   59    0    0   14   13    0   17
       84    0    0   40   38    6   13    6    0   23
        2    0   42   47   58    0    6    0    0   41
        0    0   62   59   52    0    0    0   16   35
        6   58   13    6    0    3   19   19   35    1
        0   18    0    0    0    0   15   13    6    0
        0   17   69    0    0   17   17    8    0    0
        8   67    0    0    0   15    9    2    0    6
        7    0    0   17   10   42    7    0   19    0];
***** assert (imbothat (magic (10), [1 0 0 0; 1 1 1 0; 0 1 0 1]), out);

 ## N dimensional and weird se
 in = reshape (magic(16), [4 8 4 2]);
 se = ones (3, 3, 3);
 se(:,:,1) = [1 0 1; 0 1 1; 0 0 0];
 se(:,:,3) = [1 0 1; 0 1 1; 0 0 1];
 out = zeros (size (in));
 out(:,:,1,1) = [
     0   17   81  145  237  146   64    0
   205  128   64    0    0   37   83  147
   175  111   47    0    0   64  117  181
     0   64  128  209  173  109   45    0];
 out(:,:,2,1) = [
   235  142   78   18    0   23   69  133
     0   35  103  163  215  128   46    0
     0   64  128  195  183  123   48    0
   153   93   43    0   14   78  146  215];
 out(:,:,3,1) = [
     0   25   89  153  229  142   64    0
   201  128   64    0    0   41   91  155
   167  103   57    0    0   64  125  189
     0   64  146  217  165  101   37    0];
 out(:,:,4,1) = [
   227  142   78   14    0   31   77  141
     0   43  107  171  211  128   46    0
     0   64  128  203  179  115   48    0
   149   99   35    0   18   82  146  223];
 out(:,:,1,2) = [
     0   33   97  161  221  146   64    0
   189  125   61    0    0   53   99  163
   159   95   31    0    0   64  128  197
     0   64  128  225  157   93   29    0];
 out(:,:,2,2) = [
   219  142   78   18    0   39   85  149
     0   51  119  179  199  128   46    0
     0   64  128  211  167  107   43    0
   137   77   27    0   14   78  146  231];
 out(:,:,3,2) = [
     0   41  105  169  213  142   64    0
   185  121   64    0    0   57  107  171
   151   87   41    0    0   64  128  205
     0   64  146  233  149   85   21    0];
 out(:,:,4,2) = [
   211  142   78   14    0   47   93  157
     0   59  123  187  195  128   46    0
     0   64  128  219  163   99   35    0
   133   83   19    0   18   82  146  239];
***** assert (imbothat (in, se), out);
8 tests, 8 passed, 0 known failure, 0 skipped
[isind]
>>>>> /usr/share/octave/packages/image-2.6.1/isind.m
***** assert (isind ([]), false);
***** assert (isind (1:10), true);
***** assert (isind (0:10), false);
***** assert (isind (1), true);
***** assert (isind (0), false);
***** assert (isind ([1.3 2.4]), false);
***** assert (isind ([1 2; 3 4]), true);
***** assert (isind (randi (100, 10, 10, 1, 4)), true);
***** assert (isind (randi (100, 10, 10, 3, 4)), false);
***** assert (isind (randi (100, 10, 10, 1, 4, 2)), false);
10 tests, 10 passed, 0 known failure, 0 skipped
[imtophat]
>>>>> /usr/share/octave/packages/image-2.6.1/imtophat.m
***** assert (imtophat (ones (3), [1 1; 0 1]), zeros (3));
***** assert (imtophat (true (3), [1 1; 0 1]), false (3));
***** shared in, out, se
 in =  [ 0   0   0   1   1   1   0   0   1   1
     0   1   0   1   1   1   0   0   0   1
     1   1   1   1   1   0   0   0   0   0
     0   1   1   1   1   0   0   0   0   0
     0   0   0   1   0   0   0   0   1   0
     0   0   0   0   0   0   0   1   1   1
     0   0   0   0   1   0   1   0   1   0
     0   0   0   1   1   1   1   1   0   0
     0   0   0   0   1   1   1   0   0   0
     0   0   0   1   1   1   0   0   0   0];

 out = [ 0   0   0   0   0   0   0   0   1   1
         0   1   0   0   0   0   0   0   0   1
         1   1   1   1   1   0   0   0   0   0
         0   1   1   1   1   0   0   0   0   0
         0   0   0   1   0   0   0   0   1   0
         0   0   0   0   0   0   0   1   1   1
         0   0   0   0   1   0   1   0   1   0
         0   0   0   1   1   1   1   1   0   0
         0   0   0   0   1   1   1   0   0   0
         0   0   0   1   1   1   0   0   0   0];
***** assert (imtophat (logical (in), ones (3)), logical (out));

 out = [12  19   0   0   0  16  23   0   7   0
        18   0   0   6   1  19   0   2   9   1
         0  74  81  12   7   0   1   8  15   7
        68  70   2  14   0   6   7  14  16   0
        69  76   8   0   0   7  14  21   0   1
         0   7  59  54  61  13  20   0   0  32
        18   0  69  60  62  19   0   0   0  27
        73   0   0  66  68   0   1   6   6  33
         0   0  17  19   1   0   2   9   7  14
         1   6  23   0   7   1   8  15   0  32];
***** assert (imtophat (magic (10), ones (3)), out);
***** assert (imtophat (uint8 (magic (10)), strel ("square", 3)), uint8 (out));

 ## using a se that will be decomposed in 2 pieces
 out =[91  98   0   0   0  27  34  11  18   0
       94  76   3   6   1  33  15  17  24   1
        0  77  84  12   7  14  16  23  30   7
       80  82  14  18   0  32  34  41  43   0
       81  88  20   0   0  33  40  47  24   6
       12  19  63  57  64  16  23   0   7  39
       18   0  69  60  62  19   1   3  12  39
       73   0   0  66  68   0   2   9  18  45
        4   6  81  67  49   6   8  15  19  26
        5  12  87  48  55   7  14  21   0  32];
***** assert (imtophat (magic (10), ones(5)), out);

 ## using a weird non-symmetric and even-size se
 out =[85  92   0   0   0  12  23   0  17   0
       91  73   0   6   0  18   0   2  13   0
        0  72  81  13   6   0   1   9  15   0
       60  62  10  12   0   8   8  17  17   0
       61  69   0   0   0  28  16  41   0   0
        0   0  47  52  61  12  16   0   0  31
        6   0  53  58  60  17   0   0   0  33
       69   0   0  60  62   0   0   6   0  33
        0   0  17  60  42   0   2  13   1   8
        0   6  23   0   7   0   7  15   0  14];
***** assert (imtophat (magic (10), [1 0 0 0; 1 1 1 0; 0 1 0 1]), out);

 ## N dimensional and weird se
 in = reshape (magic(16), [4 8 4 2]);
 se = ones (3, 3, 3);
 se(:,:,1) = [1 0 1; 0 1 1; 0 0 0];
 se(:,:,3) = [1 0 1; 0 1 1; 0 0 1];
 out = zeros (size (in));
 out(:,:,1,1) = [
   239  146   82   18    0   19   83  133
     0   35   99  163  219  128   64    0
     0   46  128  195  187  123   59    0
   157   93   47    0   14   78  142  211];
 out(:,:,2,1) = [
     0   21   85  149  233  146   64    0
   205  128   64    0    0   41   87  151
   171  107   57    0    0   64  121  185
     0   64  142  213  169  105   41    0];
 out(:,:,3,1) = [
   231  146   78   14    0   27   77  137
     0   43  107  167  211  128   64    0
     0   46  128  199  179  119   51    0
   149   85   39    0   18   78  142  219];
 out(:,:,4,1) = [
     0   29   93  157  225  128   64    0
   197  128   64    0    0   31   95  159
   163   99   53    0    0   61  125  189
     0   64  146  221  161   97   33    0];
 out(:,:,1,2) = [
   223  146   82   18    0   35   99  149
     0   48  115  179  203  128   64    0
     0   46  128  211  171  107   43    0
   141   77   31    0   14   78  142  227];
 out(:,:,2,2) = [
     0   37  101  165  217  146   64    0
   189  125   64    0    0   57  103  167
   155   91   41    0    0   64  128  201
     0   64  142  229  153   89   25    0];
 out(:,:,3,2) = [
   215  146   78   14    0   43   93  153
     0   48  123  183  195  128   64    0
     0   46  128  215  163  103   35    0
   133   69   23    0   18   78  142  235];
 out(:,:,4,2) = [
     0   45  109  173  209  128   64    0
   181  117   64    0    0   47  111  175
   147   83   37    0    0   64  128  205
     0   64  146  237  145   81   17    0];
***** assert (imtophat (in, se), out);
8 tests, 8 passed, 0 known failure, 0 skipped
[fspecial]
>>>>> /usr/share/octave/packages/image-2.6.1/fspecial.m
***** test
 for i = 1:9
   n = 2^i;
   assert (sum (fspecial ("disk", n)(:)), 1, eps*n*n);
 endfor
***** test
 for r = [3 5 9 17]
   f = fspecial ("disk", r);
   [X, Y] = meshgrid (-r:r, -r:r);
   rhi = (abs (X) + 0.5).^2 + (abs (Y) + 0.5).^2;
   rlo = (abs (X) - 0.5).^2 + (abs (Y) - 0.5).^2;
   fhi = (rhi <= (r^2));
   flo = (rlo >= (r^2));
   for i = 1:(2*r+1)
     for j = 1:(2*r+1)
       if (fhi(i,j))
         assert (f(i,j), 1/(pi*r^2), eps);
       endif
       if (flo(i,j))
         assert (f(i,j), 0);
       endif
     endfor
   endfor
 endfor
***** error <LENGTHS must be greater than 0>
  fspecial ("gaussian", 0)
***** error <LENGTHS must be integer>
  fspecial ("gaussian", 3.9)
***** assert (fspecial ("gaussian"), fspecial ("gaussian", 3, 0.5))
***** assert (fspecial ("gaussian"), fspecial ("gaussian", [3 3], 0.5))
***** test
 c = ([-1:1].^2) .+ ([-1:1]'.^2);
 gauss = exp (- (c ./ (2 * (0.5 .^ 2))));
 f = gauss / sum (gauss(:));
 assert (fspecial ("gaussian"), f)

 expected = [
   0.01134373655849507   0.08381950580221061   0.01134373655849507
   0.08381950580221061   0.61934703055717721   0.08381950580221061
   0.01134373655849507   0.08381950580221061   0.01134373655849507];
 assert (f, expected, eps)
***** function f = f_gaussian_2d (hsize, sigma)
  c = ([(-hsize(1)):(hsize(1))]'.^2) .+ ([(-hsize(2)):(hsize(2))].^2);
  gauss = exp (- (c ./ (2 * (sigma .^ 2))));
  f = gauss ./ sum (gauss(:));
***** endfunction
***** test
 f = fspecial ("gaussian");
 assert (f, f_gaussian_2d ([1 1], .5))
 expected = [
   0.01134373655849507   0.08381950580221061   0.01134373655849507
   0.08381950580221061   0.61934703055717721   0.08381950580221061
   0.01134373655849507   0.08381950580221061   0.01134373655849507];
 assert (f, expected, eps)
***** test
 f = fspecial ("gaussian", 7, 2);
 assert (f, f_gaussian_2d ([3 3], 2))
 expected = [
    0.00492233115934352
    0.00919612528958620
    0.01338028334410124
    0.01516184737296414
    0.01338028334410124
    0.00919612528958620
    0.00492233115934352
    0.00919612528958620
    0.01718062389630964
    0.02499766026691484
    0.02832606006174462
    0.02499766026691484
    0.01718062389630964
    0.00919612528958620
    0.01338028334410124
    0.02499766026691484
    0.03637138107390363
    0.04121417419979795
    0.03637138107390363
    0.02499766026691484
    0.01338028334410124
    0.01516184737296414
    0.02832606006174462
    0.04121417419979795
    0.04670177773892775];
 expected = reshape ([expected; expected((end-1):-1:1)], [7 7]);
 assert (f, expected, eps)
***** test
 f = fspecial ("gaussian", [7 5], 2);
 assert (f, f_gaussian_2d ([3 2], 2))
 expected = [
    0.01069713252648568
    0.01998487459872362
    0.02907782096336423
    0.03294948784319031
    0.02907782096336423
    0.01998487459872362
    0.01069713252648568
    0.01556423598706978
    0.02907782096336423
    0.04230797985750011
    0.04794122192790870
    0.04230797985750011
    0.02907782096336423
    0.01556423598706978
    0.01763658993191515
    0.03294948784319031
    0.04794122192790870
    0.05432452146574315];
 expected = reshape ([expected; expected((end-1):-1:1)], [7 5]);
 assert (f, expected, eps)
***** test
 f = fspecial ("gaussian", [4 2], 2);
 expected = [0.10945587477855045 0.14054412522144952];
 expected = expected([1 1; 2 2; 2 2; 1 1]);
 assert (f, expected, eps)
***** test
 expected =[0.04792235409415088 0.06153352068439959 0.07901060453704994];
 expected = expected([1 2 2 1; 2 3 3 2; 2 3 3 2; 1 2 2 1]);
 assert (fspecial ("gaussian", 4, 2), expected)
***** function f = f_gaussian_3d (lengths, sigma)
  [x, y, z] = ndgrid (-lengths(1):lengths(1), -lengths(2):lengths(2),
                      -lengths(3):lengths(3));
  sig_22 = 2 * (sigma.^2);
  f = exp (-((x.^2)/sig_22 + (y.^2)/sig_22 + (z.^2)/sig_22));
  f = f / sum (f(:));
***** endfunction
***** test
 obs = fspecial ("gaussian", [5 5 5]);
 assert (obs, f_gaussian_3d ([2 2 2], .5))

 u_values = [
    0.00000000001837155
    0.00000000741161178
    0.00000005476481523
    0.00000299005759843
    0.00002209370333384
    0.00016325161336690
    0.00120627532940896
    0.00891323607975882
    0.06586040141635063
    0.48664620076350640];
 expected = zeros (5, 5, 5);
 expected([1 5 21 25 101 105 121 125]) = u_values(1);
 expected([2 4 6 10 16 20 22 24 26 30 46 50 76 80 96 100 102 104 106 110 116 120 122 124]) = u_values(2);
 expected([3 11 15 23 51 55 71 75 103 111 115 123]) = u_values(3);
 expected([7 9 17 19 27 29 31 35 41 45 47 49 77 79 81 85 91 95 97 99 107 109 117 119]) = u_values(4);
 expected([8 12 14 18 28 36 40 48 52 54 56 60 66 70 72 74 78 86 90 98 108 112 114 118]) = u_values(5);
 expected([13 53 61 65 73 113]) = u_values(6);
 expected([32 34 42 44 82 84 92 94]) = u_values(7);
 expected([33 37 39 43 57 59 67 69 83 87 89 93]) = u_values(8);
 expected([38 58 62 64 68 88]) = u_values(9);
 expected([63]) = u_values(10);
 assert (obs, expected, eps)
***** test
 obs = fspecial ("gaussian", [5 5 5], 1);
 assert (obs, f_gaussian_3d ([2 2 2], 1))

 u_values = [
    0.00016177781678373
    0.00072503787330278
    0.00119538536377748
    0.00324939431236223
    0.00535734551968363
    0.00883276951279243
    0.01456277497493249
    0.02400995686159072
    0.03958572658629712
    0.06526582943894763];
 expected = zeros (5, 5, 5);
 expected([1 5 21 25 101 105 121 125]) = u_values(1);
 expected([2 4 6 10 16 20 22 24 26 30 46 50 76 80 96 100 102 104 106 110 116 120 122 124]) = u_values(2);
 expected([3 11 15 23 51 55 71 75 103 111 115 123]) = u_values(3);
 expected([7 9 17 19 27 29 31 35 41 45 47 49 77 79 81 85 91 95 97 99 107 109 117 119]) = u_values(4);
 expected([8 12 14 18 28 36 40 48 52 54 56 60 66 70 72 74 78 86 90 98 108 112 114 118]) = u_values(5);
 expected([13 53 61 65 73 113]) = u_values(6);
 expected([32 34 42 44 82 84 92 94]) = u_values(7);
 expected([33 37 39 43 57 59 67 69 83 87 89 93]) = u_values(8);
 expected([38 58 62 64 68 88]) = u_values(9);
 expected([63]) = u_values(10);
 assert (obs, expected, eps)
***** test
 obs = fspecial ("gaussian", [3 4 1 5], 3);
 assert (find (obs == max (obs(:))), [29; 32])
 assert (size (obs), [3 4 1 5])
 assert (obs(:)(1:30), obs(:)(end:-1:31))
15 tests, 15 passed, 0 known failure, 0 skipped
[imresize]
>>>>> /usr/share/octave/packages/image-2.6.1/imresize.m
***** test
 in = [116  227  153   69  146  194   59  130  139  106
         2   47  137  249   90   75   16   24  158   44
       155   68   46   84  166  156   69  204   32  152
        71  221  137  230  210  153  192  115   30  118
       107  143  108   52   51   73  101   21  175   90
        54  158  143   77   26  168  113  229  165  225
         9   47  133  135  130  207  236   43   19   73];
 assert (imresize (uint8 (in), 1, "nearest"), uint8 (in))
 assert (imresize (uint8 (in), 1, "bicubic"), uint8 (in))

 out = [116  116  227  227  153  153   69   69  146  146  194  194   59   59  130  130  139  139  106  106
        116  116  227  227  153  153   69   69  146  146  194  194   59   59  130  130  139  139  106  106
          2    2   47   47  137  137  249  249   90   90   75   75   16   16   24   24  158  158   44   44
          2    2   47   47  137  137  249  249   90   90   75   75   16   16   24   24  158  158   44   44
        155  155   68   68   46   46   84   84  166  166  156  156   69   69  204  204   32   32  152  152
        155  155   68   68   46   46   84   84  166  166  156  156   69   69  204  204   32   32  152  152
         71   71  221  221  137  137  230  230  210  210  153  153  192  192  115  115   30   30  118  118
         71   71  221  221  137  137  230  230  210  210  153  153  192  192  115  115   30   30  118  118
        107  107  143  143  108  108   52   52   51   51   73   73  101  101   21   21  175  175   90   90
        107  107  143  143  108  108   52   52   51   51   73   73  101  101   21   21  175  175   90   90
         54   54  158  158  143  143   77   77   26   26  168  168  113  113  229  229  165  165  225  225
         54   54  158  158  143  143   77   77   26   26  168  168  113  113  229  229  165  165  225  225
          9    9   47   47  133  133  135  135  130  130  207  207  236  236   43   43   19   19   73   73
          9    9   47   47  133  133  135  135  130  130  207  207  236  236   43   43   19   19   73   73];
 assert (imresize (uint8 (in), 2, "nearest"), uint8 (out))
 assert (imresize (uint8 (in), 2, "neAreST"), uint8 (out))
 assert (imresize (uint8 (in), [14 NaN], "nearest"), uint8 (out))
 assert (imresize (uint8 (in), [NaN 20], "nearest"), uint8 (out))

 out = [116  116  227  227  153  153   69   69  146  146  194  194   59   59  130  130  139  139  106  106
          2    2   47   47  137  137  249  249   90   90   75   75   16   16   24   24  158  158   44   44
        155  155   68   68   46   46   84   84  166  166  156  156   69   69  204  204   32   32  152  152
         71   71  221  221  137  137  230  230  210  210  153  153  192  192  115  115   30   30  118  118
        107  107  143  143  108  108   52   52   51   51   73   73  101  101   21   21  175  175   90   90
         54   54  158  158  143  143   77   77   26   26  168  168  113  113  229  229  165  165  225  225
          9    9   47   47  133  133  135  135  130  130  207  207  236  236   43   43   19   19   73   73];
 assert (imresize (uint8 (in), [7 20], "nearest"), uint8 (out))

 assert (imresize (uint8 (in), 1.5, "bicubic"), imresize (uint8 (in), 1.5, "cubic"))
 assert (imresize (uint8 (in), [NaN, size(in,2)*1.5], "bicubic"), imresize (uint8 (in), 1.5, "cubic"))
 assert (imresize (uint8 (in), [size(in,1)*1.5, NaN], "bicubic"), imresize (uint8 (in), 1.5, "cubic"))
 assert (imresize (uint8 (in), 1.5, "linear"), imresize (uint8 (in), 1.5, "LIneAR"))
 assert (imresize (uint8 (in), 1.5, "linear"), imresize (uint8 (in), 1.5, "triangle"))

 out = [ 47  249   75   24   44
        221  230  153  115  118
        158   77  168  229  225
        47   135  207   43   73];
 assert (imresize (uint8 (in), 0.5, "nearest"), uint8 (out))
***** assert (imresize (repmat (5, [3 3]), 2), repmat (5, [6 6]), eps*100)
***** assert (imresize (repmat (5, [3 3 2]), 2), repmat (5, [6 6 2]), eps*100)
***** shared in, out
 in = [116  227  153   69  146  194   59  130  139  106
         2   47  137  249   90   75   16   24  158   44
       155   68   46   84  166  156   69  204   32  152
        71  221  137  230  210  153  192  115   30  118
       107  143  108   52   51   73  101   21  175   90
        54  158  143   77   26  168  113  229  165  225
         9   47  133  135  130  207  236   43   19   73];

 out = [116  185  235  171   96   64  134  189  186   74   90   141  140  124  108
         44   92  143  149  164  163  119  123  118   44   38    80  151  118   63
         14   21   47  107  195  228  115   81   70   24   19    56  137  105   49
        145   98   49   49   71  107  148  159  132   58  124   176   61   85  145
        118  139  144   92  116  168  201  188  159  140  167   158   27   69  152
         62  151  218  145  174  219  201  164  146  187  148    84   48   76  115
        102  132  151  119   90   72   72   72   83  114   60    31  144  130   81
         82  121  154  133   87   41   19   67  116   95  108   140  183  180  164
         40   96  152  149  117   74   34  108  179  131  175   215  153  177  219
         11   33   73  127  137  125  113  158  212  229  148    55   35   63   96
          4   17   53  121  141  138  133  171  220  253  141    16    7   36   67];
***** xtest assert (imresize (uint8 (in), 1.5, "bicubic"), uint8 (out))

 out = [116  172  215  165  111   82  133  170  171   81   95   132  138  123  106
         59   98  138  144  152  152  125  127  119   54   58    89  137  112   75
         27   39   62  110  172  202  123   96   78   36   40    68  123  100   62
        129   97   64   62   87  119  146  148  128   74  117   154   73   94  134
        113  129  136  101  125  162  183  172  151  135  146   139   53   83  135
         77  143  195  145  166  197  186  162  146  171  138    92   62   84  113
        101  129  149  120   98   81   78   82   91  111   77    56  132  123   95
         81  116  147  130   96   61   43   80  119  109  116   132  162  164  158
         46   93  139  141  114   80   50  109  168  141  166   189  151  171  200
         16   41   77  123  130  123  115  157  204  214  145    69   48   71   98
          9   28   61  119  134  134  131  169  212  231  140    39   23   46   73];
!!!!! known failure
ASSERT errors for:  assert (imresize (uint8 (in), 1.5, "bicubic"),uint8 (out))

  Location  |  Observed  |  Expected  |  Reason
   (2,1)          26           44        Abs err 18 exceeds tol 0
   (3,1)          21           14        Abs err 7 exceeds tol 0
   (4,1)         132          145        Abs err 13 exceeds tol 0
   (5,1)         140          118        Abs err 22 exceeds tol 0
   (6,1)          71           62        Abs err 9 exceeds tol 0
   (7,1)          92          102        Abs err 10 exceeds tol 0
   (8,1)         102           82        Abs err 20 exceeds tol 0
   (9,1)          72           40        Abs err 32 exceeds tol 0
   (10,1)         28           11        Abs err 17 exceeds tol 0
   (11,1)         9            4         Abs err 5 exceeds tol 0
   (1,2)         198          185        Abs err 13 exceeds tol 0
   (2,2)          78           92        Abs err 14 exceeds tol 0
   (3,2)          9            21        Abs err 12 exceeds tol 0
   (4,2)          70           98        Abs err 28 exceeds tol 0
   (5,2)         150          139        Abs err 11 exceeds tol 0
   (6,2)         180          151        Abs err 29 exceeds tol 0
   (7,2)         162          132        Abs err 30 exceeds tol 0
   (8,2)         130          121        Abs err 9 exceeds tol 0
   (9,2)         137           96        Abs err 41 exceeds tol 0
   (10,2)         80           33        Abs err 47 exceeds tol 0
   (11,2)         21           17        Abs err 4 exceeds tol 0
   (1,3)         227          235        Abs err 8 exceeds tol 0
   (2,3)         138          143        Abs err 5 exceeds tol 0
   (3,3)          42           47        Abs err 5 exceeds tol 0
   (4,3)          26           49        Abs err 23 exceeds tol 0
   (5,3)         117          144        Abs err 27 exceeds tol 0
   (6,3)         213          218        Abs err 5 exceeds tol 0
   (7,3)         182          151        Abs err 31 exceeds tol 0
   (8,3)         142          154        Abs err 12 exceeds tol 0
   (9,3)         176          152        Abs err 24 exceeds tol 0
   (10,3)        139           73        Abs err 66 exceeds tol 0
   (11,3)         77           53        Abs err 24 exceeds tol 0
   (1,4)         164          171        Abs err 7 exceeds tol 0
   (2,4)         151          149        Abs err 2 exceeds tol 0
   (3,4)         100          107        Abs err 7 exceeds tol 0
   (4,4)          47           49        Abs err 2 exceeds tol 0
   (5,4)          73           92        Abs err 19 exceeds tol 0
   (6,4)         138          145        Abs err 7 exceeds tol 0
   (7,4)         128          119        Abs err 9 exceeds tol 0
   (8,4)         119          133        Abs err 14 exceeds tol 0
   (9,4)         144          149        Abs err 5 exceeds tol 0
   (10,4)        145          127        Abs err 18 exceeds tol 0
   (11,4)        127          121        Abs err 6 exceeds tol 0
   (1,5)          86           96        Abs err 10 exceeds tol 0
   (2,5)         200          164        Abs err 36 exceeds tol 0
   (3,5)         211          195        Abs err 16 exceeds tol 0
   (4,5)          78           71        Abs err 7 exceeds tol 0
   (5,5)          91          116        Abs err 25 exceeds tol 0
   (6,5)         184          174        Abs err 10 exceeds tol 0
   (7,5)         124           90        Abs err 34 exceeds tol 0
   (8,5)          65           87        Abs err 22 exceeds tol 0
   (9,5)          95          117        Abs err 22 exceeds tol 0
   (10,5)        130          137        Abs err 7 exceeds tol 0
   (11,5)        144          141        Abs err 3 exceeds tol 0
   (1,6)          73           64        Abs err 9 exceeds tol 0
   (2,6)         185          163        Abs err 22 exceeds tol 0
   (3,6)         222          228        Abs err 6 exceeds tol 0
   (4,6)         120          107        Abs err 13 exceeds tol 0
   (5,6)         161          168        Abs err 7 exceeds tol 0
   (6,6)         240          219        Abs err 21 exceeds tol 0
   (7,6)         134           72        Abs err 62 exceeds tol 0
   (8,6)          18           41        Abs err 23 exceeds tol 0
   (9,6)          34           74        Abs err 40 exceeds tol 0
   (10,6)         85          125        Abs err 40 exceeds tol 0
   (11,6)        131          138        Abs err 7 exceeds tol 0
   (1,7)         128          134        Abs err 6 exceeds tol 0
   (2,7)         115          119        Abs err 4 exceeds tol 0
   (3,7)         121          115        Abs err 6 exceeds tol 0
   (4,7)         139          148        Abs err 9 exceeds tol 0
   (5,7)         204          201        Abs err 3 exceeds tol 0
   (6,7)         220          201        Abs err 19 exceeds tol 0
   (7,7)         127           72        Abs err 55 exceeds tol 0
   (8,7)          16           19        Abs err 3 exceeds tol 0
   (9,7)          4            34        Abs err 30 exceeds tol 0
   (10,7)         55          113        Abs err 58 exceeds tol 0
   (11,7)        123          133        Abs err 10 exceeds tol 0
   (1,8)         197          189        Abs err 8 exceeds tol 0
   (2,8)         104          123        Abs err 19 exceeds tol 0
   (3,8)          76           81        Abs err 5 exceeds tol 0
   (4,8)         157          159        Abs err 2 exceeds tol 0
   (5,8)         206          188        Abs err 18 exceeds tol 0
   (6,8)         174          164        Abs err 10 exceeds tol 0
   (7,8)          98           72        Abs err 26 exceeds tol 0
   (8,8)          49           67        Abs err 18 exceeds tol 0
   (9,8)          77          108        Abs err 31 exceeds tol 0
   (10,8)        130          158        Abs err 28 exceeds tol 0
   (11,8)        164          171        Abs err 7 exceeds tol 0
   (1,9)         179          186        Abs err 7 exceeds tol 0
   (2,9)          99          118        Abs err 19 exceeds tol 0
   (3,9)          65           70        Abs err 5 exceeds tol 0
   (4,9)         120          132        Abs err 12 exceeds tol 0
   (5,9)         164          159        Abs err 5 exceeds tol 0
   (6,9)         154          146        Abs err 8 exceeds tol 0
   (7,9)          98           83        Abs err 15 exceeds tol 0
   (8,9)          88          116        Abs err 28 exceeds tol 0
   (9,9)         146          179        Abs err 33 exceeds tol 0
   (10,9)        206          212        Abs err 6 exceeds tol 0
   (11,9)        223          220        Abs err 3 exceeds tol 0
   (1,10)         80           74        Abs err 6 exceeds tol 0
   (2,10)         42           44        Abs err 2 exceeds tol 0
   (3,10)         25           24        Abs err 1 exceeds tol 0
   (4,10)         44           58        Abs err 14 exceeds tol 0
   (5,10)        133          140        Abs err 7 exceeds tol 0
   (6,10)        192          187        Abs err 5 exceeds tol 0
   (7,10)        151          114        Abs err 37 exceeds tol 0
   (8,10)         92           95        Abs err 3 exceeds tol 0
   (9,10)         92          131        Abs err 39 exceeds tol 0
  (10,10)        173          229        Abs err 56 exceeds tol 0
  (11,10)        255          253        Abs err 2 exceeds tol 0
   (1,11)         70           90        Abs err 20 exceeds tol 0
   (2,11)         7            38        Abs err 31 exceeds tol 0
   (3,11)         14           19        Abs err 5 exceeds tol 0
   (4,11)         98          124        Abs err 26 exceeds tol 0
   (5,11)        180          167        Abs err 13 exceeds tol 0
   (6,11)        173          148        Abs err 25 exceeds tol 0
   (7,11)         90           60        Abs err 30 exceeds tol 0
   (8,11)         61          108        Abs err 47 exceeds tol 0
   (9,11)        137          175        Abs err 38 exceeds tol 0
  (10,11)        176          148        Abs err 28 exceeds tol 0
  (11,11)        160          141        Abs err 19 exceeds tol 0
   (1,12)        135          141        Abs err 6 exceeds tol 0
   (2,12)         51           80        Abs err 29 exceeds tol 0
   (3,12)         58           56        Abs err 2 exceeds tol 0
   (5,12)        192          158        Abs err 34 exceeds tol 0
   (6,12)        104           84        Abs err 20 exceeds tol 0
   (7,12)         19           31        Abs err 12 exceeds tol 0
   (8,12)         65          140        Abs err 75 exceeds tol 0
   (9,12)        214          215        Abs err 1 exceeds tol 0
  (10,12)        180           55        Abs err 125 exceeds tol 0
  (11,12)         29           16        Abs err 13 exceeds tol 0
   (1,13)        145          140        Abs err 5 exceeds tol 0
   (2,13)        150          151        Abs err 1 exceeds tol 0
   (3,13)        124          137        Abs err 13 exceeds tol 0
   (4,13)         89           61        Abs err 28 exceeds tol 0
   (5,13)         39           27        Abs err 12 exceeds tol 0
   (6,13)         37           48        Abs err 11 exceeds tol 0
   (7,13)         89          144        Abs err 55 exceeds tol 0
   (8,13)        166          183        Abs err 17 exceeds tol 0
   (9,13)        198          153        Abs err 45 exceeds tol 0
  (10,13)        118           35        Abs err 83 exceeds tol 0
   (1,14)        129          124        Abs err 5 exceeds tol 0
   (2,14)        146          118        Abs err 28 exceeds tol 0
   (3,14)        121          105        Abs err 16 exceeds tol 0
   (4,14)         67           85        Abs err 18 exceeds tol 0
   (5,14)         25           69        Abs err 44 exceeds tol 0
   (6,14)         49           76        Abs err 27 exceeds tol 0
   (7,14)        119          130        Abs err 11 exceeds tol 0
   (8,14)        189          180        Abs err 9 exceeds tol 0
   (9,14)        197          177        Abs err 20 exceeds tol 0
  (10,14)        121           63        Abs err 58 exceeds tol 0
  (11,14)         35           36        Abs err 1 exceeds tol 0
   (1,15)        106          108        Abs err 2 exceeds tol 0
   (2,15)         53           63        Abs err 10 exceeds tol 0
   (3,15)         59           49        Abs err 10 exceeds tol 0
   (4,15)        133          145        Abs err 12 exceeds tol 0
   (5,15)        157          152        Abs err 5 exceeds tol 0
   (6,15)        118          115        Abs err 3 exceeds tol 0
   (7,15)         78           81        Abs err 3 exceeds tol 0
   (8,15)        118          164        Abs err 46 exceeds tol 0
   (9,15)        217          219        Abs err 2 exceeds tol 0
  (10,15)        184           96        Abs err 88 exceeds tol 0
  (11,15)         73           67        Abs err 6 exceeds tol 0
***** xtest assert (imresize (uint8 (in), 1.5, "bilinear"), uint8 (out))

 out = [108  136  125   89  107
        111  132  143  114   99
        106  110  106  127  136
         47  121  163  138   68];
!!!!! known failure
ASSERT errors for:  assert (imresize (uint8 (in), 1.5, "bilinear"),uint8 (out))

  Location  |  Observed  |  Expected  |  Reason
   (2,1)          48           44        Abs err 4 exceeds tol 0
   (3,1)          33           14        Abs err 19 exceeds tol 0
   (4,1)         124          145        Abs err 21 exceeds tol 0
   (5,1)         121          118        Abs err 3 exceeds tol 0
   (6,1)          71           62        Abs err 9 exceeds tol 0
   (7,1)          93          102        Abs err 9 exceeds tol 0
   (8,1)          96           82        Abs err 14 exceeds tol 0
   (9,1)          65           40        Abs err 25 exceeds tol 0
   (10,1)         36           11        Abs err 25 exceeds tol 0
   (11,1)         9            4         Abs err 5 exceeds tol 0
   (1,2)         187          185        Abs err 2 exceeds tol 0
   (2,2)          93           92        Abs err 1 exceeds tol 0
   (3,2)          45           21        Abs err 24 exceeds tol 0
   (4,2)          85           98        Abs err 13 exceeds tol 0
   (5,2)         126          139        Abs err 13 exceeds tol 0
   (6,2)         167          151        Abs err 16 exceeds tol 0
   (7,2)         145          132        Abs err 13 exceeds tol 0
   (8,2)         128          121        Abs err 7 exceeds tol 0
   (9,2)         123           96        Abs err 27 exceeds tol 0
   (10,2)         86           33        Abs err 53 exceeds tol 0
   (11,2)         33           17        Abs err 16 exceeds tol 0
   (1,3)         206          235        Abs err 29 exceeds tol 0
   (2,3)         126          143        Abs err 17 exceeds tol 0
   (3,3)          71           47        Abs err 24 exceeds tol 0
   (4,3)          64           49        Abs err 15 exceeds tol 0
   (5,3)         116          144        Abs err 28 exceeds tol 0
   (6,3)         197          218        Abs err 21 exceeds tol 0
   (7,3)         159          151        Abs err 8 exceeds tol 0
   (8,3)         137          154        Abs err 17 exceeds tol 0
   (9,3)         150          152        Abs err 2 exceeds tol 0
   (10,3)        121           73        Abs err 48 exceeds tol 0
   (11,3)         72           53        Abs err 19 exceeds tol 0
   (1,4)         158          171        Abs err 13 exceeds tol 0
   (2,4)         142          149        Abs err 7 exceeds tol 0
   (3,4)         114          107        Abs err 7 exceeds tol 0
   (4,4)          64           49        Abs err 15 exceeds tol 0
   (5,4)          86           92        Abs err 6 exceeds tol 0
   (6,4)         143          145        Abs err 2 exceeds tol 0
   (7,4)         124          119        Abs err 5 exceeds tol 0
   (8,4)         117          133        Abs err 16 exceeds tol 0
   (9,4)         137          149        Abs err 12 exceeds tol 0
   (10,4)        137          127        Abs err 10 exceeds tol 0
   (11,4)        127          121        Abs err 6 exceeds tol 0
   (1,5)         105           96        Abs err 9 exceeds tol 0
   (2,5)         163          164        Abs err 1 exceeds tol 0
   (3,5)         174          195        Abs err 21 exceeds tol 0
   (4,5)          94           71        Abs err 23 exceeds tol 0
   (5,5)         117          116        Abs err 1 exceeds tol 0
   (6,5)         190          174        Abs err 16 exceeds tol 0
   (7,5)         122           90        Abs err 32 exceeds tol 0
   (8,5)          82           87        Abs err 5 exceeds tol 0
   (9,5)          99          117        Abs err 18 exceeds tol 0
   (10,5)        117          137        Abs err 20 exceeds tol 0
   (11,5)        134          141        Abs err 7 exceeds tol 0
   (1,6)          86           64        Abs err 22 exceeds tol 0
   (3,6)         192          228        Abs err 36 exceeds tol 0
   (4,6)         124          107        Abs err 17 exceeds tol 0
   (5,6)         151          168        Abs err 17 exceeds tol 0
   (6,6)         226          219        Abs err 7 exceeds tol 0
   (7,6)         121           72        Abs err 49 exceeds tol 0
   (8,6)          55           41        Abs err 14 exceeds tol 0
   (9,6)          63           74        Abs err 11 exceeds tol 0
   (10,6)         93          125        Abs err 32 exceeds tol 0
   (11,6)        134          138        Abs err 4 exceeds tol 0
   (1,7)         135          134        Abs err 1 exceeds tol 0
   (2,7)         122          119        Abs err 3 exceeds tol 0
   (3,7)         121          115        Abs err 6 exceeds tol 0
   (4,7)         146          148        Abs err 2 exceeds tol 0
   (5,7)         178          201        Abs err 23 exceeds tol 0
   (6,7)         213          201        Abs err 12 exceeds tol 0
   (7,7)         116           72        Abs err 44 exceeds tol 0
   (8,7)          48           19        Abs err 29 exceeds tol 0
   (9,7)          37           34        Abs err 3 exceeds tol 0
   (10,7)         72          113        Abs err 41 exceeds tol 0
   (11,7)        131          133        Abs err 2 exceeds tol 0
   (1,8)         170          189        Abs err 19 exceeds tol 0
   (2,8)         117          123        Abs err 6 exceeds tol 0
   (3,8)          98           81        Abs err 17 exceeds tol 0
   (4,8)         145          159        Abs err 14 exceeds tol 0
   (5,8)         169          188        Abs err 19 exceeds tol 0
   (6,8)         182          164        Abs err 18 exceeds tol 0
   (7,8)         110           72        Abs err 38 exceeds tol 0
   (8,8)          69           67        Abs err 2 exceeds tol 0
   (9,8)          90          108        Abs err 18 exceeds tol 0
   (10,8)        126          158        Abs err 32 exceeds tol 0
   (11,8)        169          171        Abs err 2 exceeds tol 0
   (1,9)         175          186        Abs err 11 exceeds tol 0
   (2,9)         110          118        Abs err 8 exceeds tol 0
   (3,9)          82           70        Abs err 12 exceeds tol 0
   (4,9)         128          132        Abs err 4 exceeds tol 0
   (5,9)         150          159        Abs err 9 exceeds tol 0
   (6,9)         159          146        Abs err 13 exceeds tol 0
   (7,9)         110           83        Abs err 27 exceeds tol 0
   (8,9)          94          116        Abs err 22 exceeds tol 0
   (9,9)         144          179        Abs err 35 exceeds tol 0
   (10,9)        181          212        Abs err 31 exceeds tol 0
   (11,9)        211          220        Abs err 9 exceeds tol 0
   (1,10)         88           74        Abs err 14 exceeds tol 0
   (2,10)         52           44        Abs err 8 exceeds tol 0
   (3,10)         40           24        Abs err 16 exceeds tol 0
   (4,10)         76           58        Abs err 18 exceeds tol 0
   (5,10)        126          140        Abs err 14 exceeds tol 0
   (6,10)        184          187        Abs err 3 exceeds tol 0
   (7,10)        130          114        Abs err 16 exceeds tol 0
   (8,10)        101           95        Abs err 6 exceeds tol 0
   (9,10)        119          131        Abs err 12 exceeds tol 0
  (10,10)        167          229        Abs err 62 exceeds tol 0
  (11,10)        230          253        Abs err 23 exceeds tol 0
   (1,11)         89           90        Abs err 1 exceeds tol 0
   (2,11)         47           38        Abs err 9 exceeds tol 0
   (3,11)         41           19        Abs err 22 exceeds tol 0
   (4,11)        105          124        Abs err 19 exceeds tol 0
   (5,11)        140          167        Abs err 27 exceeds tol 0
   (6,11)        159          148        Abs err 11 exceeds tol 0
   (7,11)        104           60        Abs err 44 exceeds tol 0
   (8,11)         86          108        Abs err 22 exceeds tol 0
   (9,11)        144          175        Abs err 31 exceeds tol 0
  (10,11)        159          148        Abs err 11 exceeds tol 0
  (11,11)        153          141        Abs err 12 exceeds tol 0
   (1,12)        131          141        Abs err 10 exceeds tol 0
   (2,12)         72           80        Abs err 8 exceeds tol 0
   (3,12)         65           56        Abs err 9 exceeds tol 0
   (4,12)        160          176        Abs err 16 exceeds tol 0
   (5,12)        159          158        Abs err 1 exceeds tol 0
   (6,12)        109           84        Abs err 25 exceeds tol 0
   (7,12)         63           31        Abs err 32 exceeds tol 0
   (8,12)         70          140        Abs err 70 exceeds tol 0
   (9,12)        186          215        Abs err 29 exceeds tol 0
  (10,12)        151           55        Abs err 96 exceeds tol 0
  (11,12)         41           16        Abs err 25 exceeds tol 0
   (1,13)        136          140        Abs err 4 exceeds tol 0
   (2,13)        126          151        Abs err 25 exceeds tol 0
   (3,13)        112          137        Abs err 25 exceeds tol 0
   (4,13)         89           61        Abs err 28 exceeds tol 0
   (5,13)         70           27        Abs err 43 exceeds tol 0
   (6,13)         54           48        Abs err 6 exceeds tol 0
   (7,13)        100          144        Abs err 44 exceeds tol 0
   (8,13)        141          183        Abs err 42 exceeds tol 0
   (9,13)        173          153        Abs err 20 exceeds tol 0
  (10,13)        120           35        Abs err 85 exceeds tol 0
  (11,13)         26           7         Abs err 19 exceeds tol 0
   (1,14)        127          124        Abs err 3 exceeds tol 0
   (2,14)        121          118        Abs err 3 exceeds tol 0
   (3,14)        109          105        Abs err 4 exceeds tol 0
   (4,14)         83           85        Abs err 2 exceeds tol 0
   (6,14)         61           76        Abs err 15 exceeds tol 0
   (7,14)        111          130        Abs err 19 exceeds tol 0
   (8,14)        153          180        Abs err 27 exceeds tol 0
   (9,14)        178          177        Abs err 1 exceeds tol 0
  (10,14)        127           63        Abs err 64 exceeds tol 0
  (11,14)         38           36        Abs err 2 exceeds tol 0
   (1,15)        106          108        Abs err 2 exceeds tol 0
   (2,15)         69           63        Abs err 6 exceeds tol 0
   (3,15)         66           49        Abs err 17 exceeds tol 0
   (4,15)        130          145        Abs err 15 exceeds tol 0
   (5,15)        138          152        Abs err 14 exceeds tol 0
   (6,15)        118          115        Abs err 3 exceeds tol 0
   (7,15)        101           81        Abs err 20 exceeds tol 0
   (8,15)        117          164        Abs err 47 exceeds tol 0
   (9,15)        198          219        Abs err 21 exceeds tol 0
  (10,15)        164           96        Abs err 68 exceeds tol 0
  (11,15)         73           67        Abs err 6 exceeds tol 0
***** xtest assert (imresize (uint8 (in), 0.5, "bilinear"), uint8 (out))

 out = [103  141  124   78  110
        111  134  153  114   91
        115  108   93  128  146
         38  124  175  143   54];
!!!!! known failure
ASSERT errors for:  assert (imresize (uint8 (in), 0.5, "bilinear"),uint8 (out))

  Location  |  Observed  |  Expected  |  Reason
     .          O(4x5)      E(11x15)     Dimensions don't match
***** xtest assert (imresize (uint8 (in), 0.5, "bicubic"), uint8 (out))
!!!!! known failure
ASSERT errors for:  assert (imresize (uint8 (in), 0.5, "bicubic"),uint8 (out))

  Location  |  Observed  |  Expected  |  Reason
     .          O(4x5)      E(11x15)     Dimensions don't match
7 tests, 3 passed, 4 known failures, 0 skipped
[otf2psf]
>>>>> /usr/share/octave/packages/image-2.6.1/otf2psf.m
***** function otf = rand_otf (varargin)
  otf = complex (rand (varargin{:}), rand (varargin{:}));
***** endfunction
***** test
 otf = rand_otf (6, 1);
 assert (otf2psf (otf), circshift (ifft (otf), 3));
***** test
 otf = rand_otf (6, 6);
 assert (otf2psf (otf), circshift (ifft2 (otf), [3 3]));
***** test
 otf = rand_otf (6, 6, 6);
 assert (otf2psf (otf), circshift (ifftn (otf), [3 3 3]));
***** test
 otf = rand_otf (7, 1);
 assert (otf2psf (otf), circshift (ifft (otf), 3));
***** test
 otf = rand_otf (7, 7);
 assert (otf2psf (otf), circshift (ifft2 (otf), [3 3]));
***** test
 otf = rand_otf (6, 7, 8);
 assert (otf2psf (otf), circshift (ifftn (otf), [3 3 4]));
***** test
 otf  = rand_otf (7, 1);
 ppsf = circshift (ifft (otf), 3);
 assert (otf2psf (otf, 6), ppsf(1:6));
 assert (otf2psf (otf, [6 1]), ppsf(1:6));
***** test
 otf = rand_otf (7, 7);
 ppsf = circshift (ifft2 (otf), [3 3]);
 assert (otf2psf (otf, [6 1]), ppsf(1:6,4));
***** test
 otf = rand_otf (6, 7);
 ppsf = circshift (ifft2 (otf), [3 3]);
 assert (otf2psf (otf, [6 6]), ppsf(:,1:6));
***** error <OTF must be numeric> otf2psf ("not a otf")
***** error <OUTSIZE must be smaller than> otf2psf (rand_otf (16), 18)
***** error <OUTSIZE must be smaller than> otf2psf (rand_otf (16), [14 18])
***** error <OUTSIZE must be smaller than> otf2psf (rand_otf (16), [18 18])
***** error <OUTSIZE must be smaller than> otf2psf (rand_otf (16, 1), 18)
***** test
 psf = fspecial ("gaussian", 16);
 otf = psf2otf (psf);
 assert (otf2psf (otf), psf, eps);
***** test
 psf = rand (16);
 otf = psf2otf (psf);
 assert (otf2psf (otf), psf, 2*eps);
***** test
 psf = rand (8);
 otf = psf2otf (psf, [16 16]);
 assert (otf2psf (otf, [8 8]), psf, 2*eps);
17 tests, 17 passed, 0 known failure, 0 skipped
[impyramid]
>>>>> /usr/share/octave/packages/image-2.6.1/impyramid.m
***** test
 in = [116  227  153   69  146  194   59  130  139  106
         2   47  137  249   90   75   16   24  158   44
       155   68   46   84  166  156   69  204   32  152
        71  221  137  230  210  153  192  115   30  118
       107  143  108   52   51   73  101   21  175   90
        54  158  143   77   26  168  113  229  165  225
         9   47  133  135  130  207  236   43   19   73];

 reduced = [
     114  139  131  103  111
      97  122  141  110   99
     103  123  112  123  121
      47  107  134  153   94];

 ## this is what we should return if we were Matlab compatible
 reduced_matlab = [
     114  139  131  103  111
      97  122  141  111  100
     103  123  112  123  122
      47  107  134  153   94];

 expanded = [
    88  132  160  154  132  108   94  102  120  138  138  100   66   74   96  112  116  104   78
    62   98  128  142  146  154  154  140  126  126  122   86   54   58   82  114  132  112   74
    36   54   74  100  130  168  184  156  118  104   92   64   40   44   66  100  122  104   66
    66   68   64   76   98  130  154  148  132  122  108   80   60   78  104  106   98   98   86
   104  106   88   78   78   96  122  144  154  154  140  112   98  124  144  110   74   92  106
   102  130  134  120  108  126  154  174  180  172  156  142  138  146  140   96   60   84  106
    88  140  170  158  140  156  180  188  180  164  152  154  156  140  112   82   66   84   96
    90  136  164  154  134  132  138  136  130  122  120  130  134  108   82   86  100  104   92
    92  126  142  136  116   96   80   74   72   82   94  106  106   88   78  108  138  132  102
    80  116  140  138  122   96   68   52   52   80  110  114  112  118  128  148  164  164  140
    58   98  132  140  130  110   82   62   62  102  142  144  138  154  168  164  156  170  162
    36   68  100  120  130  122  106   92   96  134  174  182  172  156  136  116  104  122  124
    16   34   58   86  108  114  110  106  112  138  170  184  172  126   74   48   44   60   68];

 ## this is what we should return if we were Matlab compatible
 expanded_matlab = [
   115  154  185  178  150  122  105  116  138  159  158  117   78   86  112  129  133  120  103
    69   98  128  141  146  152  152  139  125  127  121   87   55   58   81  113  131  112   84
    40   54   74  100  131  167  184  157  119  104   92   64   41   44   66  100  121  103   74
    76   69   65   75   97  130  153  148  131  122  108   80   61   79  103  105   98   97   98
   120  105   88   77   78   96  121  143  155  154  140  112   98  124  143  109   74   91  123
   117  129  134  119  107  125  153  173  180  172  156  143  138  146  140   96   60   83  122
    99  139  170  157  139  156  181  188  180  164  151  154  156  140  112   81   65   84  110
   101  136  163  153  133  132  138  136  130  122  120  130  133  108   82   86   99  104  104
   103  126  143  136  116   97   81   73   73   82   94  105  105   87   78  108  138  133  116
    90  116  139  139  122   96   69   52   53   80  109  114  111  116  128  148  163  164  160
    66   99  131  140  131  109   83   62   62  102  142  144  138  154  169  164  157  169  184
    41   68   99  121  130  122  107   92   95  133  173  182  172  156  135  114  105  121  142
    21   38   64   98  124  131  127  123  129  160  194  212  199  144   82   52   48   65   85];

 assert (impyramid (uint8 (in), "reduce"), uint8 (reduced))
 assert (impyramid (uint8 (in), "expand"), uint8 (expanded))
!!!!! test failed
ASSERT errors for:  assert (impyramid (uint8 (in), "expand"),uint8 (expanded))

  Location  |  Observed  |  Expected  |  Reason
   (1,1)          87           88        Abs err 1 exceeds tol 0
   (2,1)          61           62        Abs err 1 exceeds tol 0
   (5,1)         105          104        Abs err 1 exceeds tol 0
   (6,1)         103          102        Abs err 1 exceeds tol 0
   (7,1)          89           88        Abs err 1 exceeds tol 0
   (9,1)          91           92        Abs err 1 exceeds tol 0
   (10,1)         79           80        Abs err 1 exceeds tol 0
   (11,1)         59           58        Abs err 1 exceeds tol 0
   (13,1)         17           16        Abs err 1 exceeds tol 0
   (5,2)         105          106        Abs err 1 exceeds tol 0
   (6,2)         129          130        Abs err 1 exceeds tol 0
   (7,2)         139          140        Abs err 1 exceeds tol 0
   (9,2)         125          126        Abs err 1 exceeds tol 0
   (11,2)         99           98        Abs err 1 exceeds tol 0
   (12,2)         67           68        Abs err 1 exceeds tol 0
   (1,3)         159          160        Abs err 1 exceeds tol 0
   (8,3)         163          164        Abs err 1 exceeds tol 0
   (10,3)        139          140        Abs err 1 exceeds tol 0
   (11,3)        131          132        Abs err 1 exceeds tol 0
   (12,3)         98          100        Abs err 2 exceeds tol 0
   (2,4)         141          142        Abs err 1 exceeds tol 0
   (4,4)          75           76        Abs err 1 exceeds tol 0
   (5,4)          77           78        Abs err 1 exceeds tol 0
   (6,4)         118          120        Abs err 2 exceeds tol 0
   (7,4)         157          158        Abs err 1 exceeds tol 0
   (8,4)         152          154        Abs err 2 exceeds tol 0
   (9,4)         135          136        Abs err 1 exceeds tol 0
   (1,5)         131          132        Abs err 1 exceeds tol 0
   (4,5)          97           98        Abs err 1 exceeds tol 0
   (5,5)          77           78        Abs err 1 exceeds tol 0
   (6,5)         106          108        Abs err 2 exceeds tol 0
   (7,5)         139          140        Abs err 1 exceeds tol 0
   (8,5)         132          134        Abs err 2 exceeds tol 0
   (10,5)        121          122        Abs err 1 exceeds tol 0
   (11,5)        131          130        Abs err 1 exceeds tol 0
   (13,5)        109          108        Abs err 1 exceeds tol 0
   (1,6)         107          108        Abs err 1 exceeds tol 0
   (2,6)         152          154        Abs err 2 exceeds tol 0
   (3,6)         167          168        Abs err 1 exceeds tol 0
   (4,6)         129          130        Abs err 1 exceeds tol 0
   (6,6)         124          126        Abs err 2 exceeds tol 0
   (9,6)          97           96        Abs err 1 exceeds tol 0
   (10,6)         95           96        Abs err 1 exceeds tol 0
   (11,6)        109          110        Abs err 1 exceeds tol 0
   (2,7)         152          154        Abs err 2 exceeds tol 0
   (4,7)         152          154        Abs err 2 exceeds tol 0
   (5,7)         121          122        Abs err 1 exceeds tol 0
   (6,7)         153          154        Abs err 1 exceeds tol 0
   (8,7)         137          138        Abs err 1 exceeds tol 0
   (9,7)          81           80        Abs err 1 exceeds tol 0
   (10,7)         69           68        Abs err 1 exceeds tol 0
   (11,7)         83           82        Abs err 1 exceeds tol 0
   (12,7)        107          106        Abs err 1 exceeds tol 0
   (2,8)         139          140        Abs err 1 exceeds tol 0
   (4,8)         147          148        Abs err 1 exceeds tol 0
   (5,8)         142          144        Abs err 2 exceeds tol 0
   (6,8)         173          174        Abs err 1 exceeds tol 0
   (7,8)         187          188        Abs err 1 exceeds tol 0
   (9,8)          73           74        Abs err 1 exceeds tol 0
   (2,9)         125          126        Abs err 1 exceeds tol 0
   (4,9)         131          132        Abs err 1 exceeds tol 0
   (5,9)         155          154        Abs err 1 exceeds tol 0
   (12,9)         95           96        Abs err 1 exceeds tol 0
   (13,9)        111          112        Abs err 1 exceeds tol 0
   (3,10)        103          104        Abs err 1 exceeds tol 0
   (6,10)        171          172        Abs err 1 exceeds tol 0
   (9,10)         81           82        Abs err 1 exceeds tol 0
  (12,10)        133          134        Abs err 1 exceeds tol 0
  (13,10)        139          138        Abs err 1 exceeds tol 0
   (1,11)        137          138        Abs err 1 exceeds tol 0
   (2,11)        120          122        Abs err 2 exceeds tol 0
   (5,11)        139          140        Abs err 1 exceeds tol 0
   (7,11)        151          152        Abs err 1 exceeds tol 0
   (8,11)        119          120        Abs err 1 exceeds tol 0
  (10,11)        109          110        Abs err 1 exceeds tol 0
  (12,11)        172          174        Abs err 2 exceeds tol 0
  (13,11)        169          170        Abs err 1 exceeds tol 0
   (1,12)        101          100        Abs err 1 exceeds tol 0
   (4,12)         79           80        Abs err 1 exceeds tol 0
   (6,12)        143          142        Abs err 1 exceeds tol 0
   (9,12)        104          106        Abs err 2 exceeds tol 0
  (12,12)        181          182        Abs err 1 exceeds tol 0
   (1,13)         67           66        Abs err 1 exceeds tol 0
   (2,13)         55           54        Abs err 1 exceeds tol 0
   (3,13)         41           40        Abs err 1 exceeds tol 0
   (4,13)         61           60        Abs err 1 exceeds tol 0
   (6,13)        137          138        Abs err 1 exceeds tol 0
   (8,13)        133          134        Abs err 1 exceeds tol 0
   (9,13)        105          106        Abs err 1 exceeds tol 0
  (10,13)        111          112        Abs err 1 exceeds tol 0
  (12,13)        171          172        Abs err 1 exceeds tol 0
  (13,13)        173          172        Abs err 1 exceeds tol 0
   (1,14)         73           74        Abs err 1 exceeds tol 0
   (2,14)         57           58        Abs err 1 exceeds tol 0
   (6,14)        145          146        Abs err 1 exceeds tol 0
   (8,14)        107          108        Abs err 1 exceeds tol 0
   (9,14)         86           88        Abs err 2 exceeds tol 0
  (10,14)        116          118        Abs err 2 exceeds tol 0
  (11,14)        153          154        Abs err 1 exceeds tol 0
  (12,14)        155          156        Abs err 1 exceeds tol 0
   (1,15)         97           96        Abs err 1 exceeds tol 0
   (2,15)         81           82        Abs err 1 exceeds tol 0
   (4,15)        103          104        Abs err 1 exceeds tol 0
   (5,15)        143          144        Abs err 1 exceeds tol 0
  (11,15)        169          168        Abs err 1 exceeds tol 0
  (12,15)        135          136        Abs err 1 exceeds tol 0
   (2,16)        113          114        Abs err 1 exceeds tol 0
   (4,16)        105          106        Abs err 1 exceeds tol 0
   (5,16)        109          110        Abs err 1 exceeds tol 0
   (6,16)         95           96        Abs err 1 exceeds tol 0
   (7,16)         81           82        Abs err 1 exceeds tol 0
   (8,16)         85           86        Abs err 1 exceeds tol 0
   (9,16)        107          108        Abs err 1 exceeds tol 0
  (12,16)        114          116        Abs err 2 exceeds tol 0
   (2,17)        130          132        Abs err 2 exceeds tol 0
   (3,17)        121          122        Abs err 1 exceeds tol 0
   (7,17)         65           66        Abs err 1 exceeds tol 0
   (8,17)         98          100        Abs err 2 exceeds tol 0
  (10,17)        163          164        Abs err 1 exceeds tol 0
  (11,17)        157          156        Abs err 1 exceeds tol 0
  (12,17)        105          104        Abs err 1 exceeds tol 0
   (1,18)        105          104        Abs err 1 exceeds tol 0
   (3,18)        103          104        Abs err 1 exceeds tol 0
   (4,18)         97           98        Abs err 1 exceeds tol 0
   (5,18)         91           92        Abs err 1 exceeds tol 0
   (6,18)         83           84        Abs err 1 exceeds tol 0
   (8,18)        103          104        Abs err 1 exceeds tol 0
   (9,18)        133          132        Abs err 1 exceeds tol 0
  (11,18)        169          170        Abs err 1 exceeds tol 0
  (12,18)        121          122        Abs err 1 exceeds tol 0
  (13,18)         59           60        Abs err 1 exceeds tol 0
   (1,19)         79           78        Abs err 1 exceeds tol 0
   (2,19)         75           74        Abs err 1 exceeds tol 0
   (4,19)         85           86        Abs err 1 exceeds tol 0
   (5,19)        107          106        Abs err 1 exceeds tol 0
   (6,19)        105          106        Abs err 1 exceeds tol 0
   (7,19)         95           96        Abs err 1 exceeds tol 0
   (8,19)         91           92        Abs err 1 exceeds tol 0
  (10,19)        139          140        Abs err 1 exceeds tol 0
  (11,19)        160          162        Abs err 2 exceeds tol 0
  (12,19)        123          124        Abs err 1 exceeds tol 0
  (13,19)         67           68        Abs err 1 exceeds tol 0
***** test
 in = randi ([0 255], [40 39 3 5], "uint8");
 red = impyramid (in, "reduce");
 for p = 1:3
   for n = 1:5
     assert (red(:,:,p,n), impyramid (in(:,:,p,n), "reduce"))
   endfor
 endfor

 exp = impyramid (in, "expand");
 for p = 1:3
   for n = 1:5
     assert (exp(:,:,p,n), impyramid (in(:,:,p,n), "expand"))
   endfor
 endfor
***** test
 in = repmat (uint8 (255), [10 10]);
 assert (impyramid (in, "reduce"), repmat (uint8 (255), [5 5]))
 assert (impyramid (in, "expand"), repmat (uint8 (255), [19 19]))
!!!!! test failed
ASSERT errors for:  assert (impyramid (in, "expand"),repmat (uint8 (255), [19, 19]))

  Location  |  Observed  |  Expected  |  Reason
   (1,1)         195          255        Abs err 60 exceeds tol 0
   (2,1)         223          255        Abs err 32 exceeds tol 0
   (3,1)         223          255        Abs err 32 exceeds tol 0
   (4,1)         223          255        Abs err 32 exceeds tol 0
   (5,1)         223          255        Abs err 32 exceeds tol 0
   (6,1)         223          255        Abs err 32 exceeds tol 0
   (7,1)         223          255        Abs err 32 exceeds tol 0
   (8,1)         223          255        Abs err 32 exceeds tol 0
   (9,1)         223          255        Abs err 32 exceeds tol 0
   (10,1)        223          255        Abs err 32 exceeds tol 0
   (11,1)        223          255        Abs err 32 exceeds tol 0
   (12,1)        223          255        Abs err 32 exceeds tol 0
   (13,1)        223          255        Abs err 32 exceeds tol 0
   (14,1)        223          255        Abs err 32 exceeds tol 0
   (15,1)        223          255        Abs err 32 exceeds tol 0
   (16,1)        223          255        Abs err 32 exceeds tol 0
   (17,1)        223          255        Abs err 32 exceeds tol 0
   (18,1)        223          255        Abs err 32 exceeds tol 0
   (19,1)        195          255        Abs err 60 exceeds tol 0
   (1,2)         223          255        Abs err 32 exceeds tol 0
   (19,2)        223          255        Abs err 32 exceeds tol 0
   (1,3)         223          255        Abs err 32 exceeds tol 0
   (19,3)        223          255        Abs err 32 exceeds tol 0
   (1,4)         223          255        Abs err 32 exceeds tol 0
   (19,4)        223          255        Abs err 32 exceeds tol 0
   (1,5)         223          255        Abs err 32 exceeds tol 0
   (19,5)        223          255        Abs err 32 exceeds tol 0
   (1,6)         223          255        Abs err 32 exceeds tol 0
   (19,6)        223          255        Abs err 32 exceeds tol 0
   (1,7)         223          255        Abs err 32 exceeds tol 0
   (19,7)        223          255        Abs err 32 exceeds tol 0
   (1,8)         223          255        Abs err 32 exceeds tol 0
   (19,8)        223          255        Abs err 32 exceeds tol 0
   (1,9)         223          255        Abs err 32 exceeds tol 0
   (19,9)        223          255        Abs err 32 exceeds tol 0
   (1,10)        223          255        Abs err 32 exceeds tol 0
  (19,10)        223          255        Abs err 32 exceeds tol 0
   (1,11)        223          255        Abs err 32 exceeds tol 0
  (19,11)        223          255        Abs err 32 exceeds tol 0
   (1,12)        223          255        Abs err 32 exceeds tol 0
  (19,12)        223          255        Abs err 32 exceeds tol 0
   (1,13)        223          255        Abs err 32 exceeds tol 0
  (19,13)        223          255        Abs err 32 exceeds tol 0
   (1,14)        223          255        Abs err 32 exceeds tol 0
  (19,14)        223          255        Abs err 32 exceeds tol 0
   (1,15)        223          255        Abs err 32 exceeds tol 0
  (19,15)        223          255        Abs err 32 exceeds tol 0
   (1,16)        223          255        Abs err 32 exceeds tol 0
  (19,16)        223          255        Abs err 32 exceeds tol 0
   (1,17)        223          255        Abs err 32 exceeds tol 0
  (19,17)        223          255        Abs err 32 exceeds tol 0
   (1,18)        223          255        Abs err 32 exceeds tol 0
  (19,18)        223          255        Abs err 32 exceeds tol 0
   (1,19)        195          255        Abs err 60 exceeds tol 0
   (2,19)        223          255        Abs err 32 exceeds tol 0
   (3,19)        223          255        Abs err 32 exceeds tol 0
   (4,19)        223          255        Abs err 32 exceeds tol 0
   (5,19)        223          255        Abs err 32 exceeds tol 0
   (6,19)        223          255        Abs err 32 exceeds tol 0
   (7,19)        223          255        Abs err 32 exceeds tol 0
   (8,19)        223          255        Abs err 32 exceeds tol 0
   (9,19)        223          255        Abs err 32 exceeds tol 0
  (10,19)        223          255        Abs err 32 exceeds tol 0
  (11,19)        223          255        Abs err 32 exceeds tol 0
  (12,19)        223          255        Abs err 32 exceeds tol 0
  (13,19)        223          255        Abs err 32 exceeds tol 0
  (14,19)        223          255        Abs err 32 exceeds tol 0
  (15,19)        223          255        Abs err 32 exceeds tol 0
  (16,19)        223          255        Abs err 32 exceeds tol 0
  (17,19)        223          255        Abs err 32 exceeds tol 0
  (18,19)        223          255        Abs err 32 exceeds tol 0
  (19,19)        195          255        Abs err 60 exceeds tol 0
***** test
 in = logical ([
   1  0  1  1  0  0  1  1  0  0
   1  1  0  0  0  1  0  0  1  0
   0  1  1  0  1  1  1  1  1  1
   1  0  1  0  1  0  1  0  1  1
   1  1  1  0  0  0  1  1  1  1
   0  0  1  1  0  0  1  0  0  0
   0  0  1  1  0  1  1  0  1  1
   1  1  0  0  1  0  0  0  1  0
   1  1  1  1  1  1  0  1  0  0
   1  1  0  0  1  0  0  0  1  0]);

 reduced = logical ([
   1  1  0  1  0
   1  1  0  1  1
   1  1  0  1  1
   0  1  0  0  0
   1  1  1  0  0]);

 expanded = logical ([
   1  1  0  0  1  1  1  0  0  0  0  0  1  1  1  0  0  0  0
   1  1  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
   1  1  1  1  0  0  0  0  0  0  1  1  0  0  0  1  1  0  0
   1  1  1  1  0  0  0  0  0  1  1  1  1  0  1  1  1  1  1
   0  1  1  1  1  0  0  0  1  1  1  1  1  1  1  1  1  1  1
   0  0  1  1  1  0  0  0  1  1  1  1  1  1  1  1  1  1  1
   1  1  0  1  1  0  0  0  1  0  0  1  1  1  0  1  1  1  1
   1  1  1  1  1  0  0  0  0  0  0  0  1  1  1  1  1  1  1
   1  1  1  1  1  1  0  0  0  0  0  0  1  1  1  1  1  1  1
   0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0  0  0  0
   0  0  0  1  1  1  1  0  0  0  0  1  1  1  0  0  0  0  0
   0  0  0  0  1  1  1  0  0  0  0  1  1  0  0  0  0  0  0
   0  0  0  0  1  1  1  0  0  0  1  1  1  0  0  0  1  1  1
   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  1  1  1
   1  1  1  1  0  0  0  1  1  1  0  0  0  0  0  0  1  0  0
   1  1  1  1  1  0  1  1  1  1  0  0  0  0  0  0  0  0  0
   1  1  1  1  1  1  1  1  1  1  1  0  0  0  1  0  0  0  0
   1  1  1  1  1  0  1  1  1  1  0  0  0  0  0  0  0  0  0
   1  1  1  1  0  0  0  1  1  1  0  0  0  0  0  0  1  0  0]);

 assert (impyramid (in, "reduce"), reduced)
 assert (impyramid (in, "expand"), expanded)
!!!!! test failed
ASSERT errors for:  assert (impyramid (in, "reduce"),reduced)

  Location  |  Observed  |  Expected  |  Reason
   (4,1)          1            0         Abs err 1 exceeds tol 0
   (1,3)          1            0         Abs err 1 exceeds tol 0
   (2,3)          1            0         Abs err 1 exceeds tol 0
   (3,3)          1            0         Abs err 1 exceeds tol 0
   (4,3)          1            0         Abs err 1 exceeds tol 0
   (4,4)          1            0         Abs err 1 exceeds tol 0
   (5,4)          1            0         Abs err 1 exceeds tol 0
   (1,5)          1            0         Abs err 1 exceeds tol 0
   (4,5)          1            0         Abs err 1 exceeds tol 0
   (5,5)          1            0         Abs err 1 exceeds tol 0
4 tests, 1 passed, 0 known failure, 0 skipped
[histeq]
>>>>> /usr/share/octave/packages/image-2.6.1/histeq.m
***** assert (histeq ([]), []);
***** assert (histeq (0), 1);
***** assert (histeq (1), 1);
***** assert (histeq (1.5), 1);
***** assert (histeq (zeros (100, 200)), ones (100, 200));            # matrix
***** xtest assert (histeq ([0    1]),  [0.4920634921  1],  10^-8);
!!!!! known failure
ASSERT errors for:  assert (histeq ([0, 1]),[0.4920634921, 1],10 ^ -8)

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5        0.49206      Abs err 0.0079365 exceeds tol 1e-08
***** xtest assert (histeq ([0    1]'), [0.4920634921  1]', 10^-8);   # column array
!!!!! known failure
ASSERT errors for:  assert (histeq ([0, 1]'),[0.4920634921, 1]',10 ^ -8)

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5        0.49206      Abs err 0.0079365 exceeds tol 1e-08
***** xtest assert (histeq ([0  255]),  [0.4920634921  1],  10^-8);
!!!!! known failure
ASSERT errors for:  assert (histeq ([0, 255]),[0.4920634921, 1],10 ^ -8)

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5        0.49206      Abs err 0.0079365 exceeds tol 1e-08
***** xtest assert (histeq (uint8  ([0      1])), [  125    190]);    # uint8
!!!!! known failure
ASSERT errors for:  assert (histeq (uint8 ([0, 1])),[125, 190])

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5          125        Abs err 124.5 exceeds tol 0
    (2)           1           190        Abs err 189 exceeds tol 0
***** xtest assert (histeq (uint8  ([0    255])), [  125    255]);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint8 ([0, 255])),[125, 255])

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5          125        Abs err 124.5 exceeds tol 0
    (2)           1           255        Abs err 254 exceeds tol 0
***** xtest assert (histeq (uint16 ([0      1])), [65535  65535]);    # uint16
!!!!! known failure
ASSERT errors for:  assert (histeq (uint16 ([0, 1])),[65535, 65535])

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5         65535       Abs err 65534 exceeds tol 0
    (2)           1          65535       Abs err 65534 exceeds tol 0
***** xtest assert (histeq (uint16 ([0    255])), [32247  48891]);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint16 ([0, 255])),[32247, 48891])

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5         32247       Abs err 32246 exceeds tol 0
    (2)           1          48891       Abs err 48890 exceeds tol 0
***** xtest assert (histeq (uint16 ([0    256])), [32247  48891]);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint16 ([0, 256])),[32247, 48891])

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5         32247       Abs err 32246 exceeds tol 0
    (2)           1          48891       Abs err 48890 exceeds tol 0
***** xtest assert (histeq (uint16 ([0  65535])), [32247  65535]);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint16 ([0, 65535])),[32247, 65535])

  Location  |  Observed  |  Expected  |  Reason
    (1)          0.5         32247       Abs err 32246 exceeds tol 0
    (2)           1          65535       Abs err 65534 exceeds tol 0
***** test assert (histeq  ([0 1 1] ),             [  1/3     1     1] ,  10^-8);
***** test assert (histeq  ([0 0 1]'),             [  2/3   2/3     1]',  10^-8);
***** xtest assert (histeq ([0 1 2] ),             [  1/3     1     1] ,  10^-8);
!!!!! known failure
ASSERT errors for:  assert (histeq ([0, 1, 2]),[1 / 3, 1, 1],10 ^ -8)

  Location  |  Observed  |  Expected  |  Reason
    (2)        0.66667         1         Abs err 0.33333 exceeds tol 1e-08
***** xtest assert (histeq (uint8  ([0   1   2])), [   85   125   215]);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint8 ([0, 1, 2])),[85, 125, 215])

  Location  |  Observed  |  Expected  |  Reason
    (1)        0.33333         85        Abs err 84.667 exceeds tol 0
    (2)        0.66667        125        Abs err 124.33 exceeds tol 0
    (3)           1           215        Abs err 214 exceeds tol 0
***** xtest assert (histeq (uint16 ([0   1   2])), [65535 65535 65535]);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint16 ([0, 1, 2])),[65535, 65535, 65535])

  Location  |  Observed  |  Expected  |  Reason
    (1)        0.33333       65535       Abs err 65535 exceeds tol 0
    (2)        0.66667       65535       Abs err 65534 exceeds tol 0
    (3)           1          65535       Abs err 65534 exceeds tol 0
***** xtest assert (histeq (uint16 ([0 100 200])), [43690 43690 55133]);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint16 ([0, 100, 200])),[43690, 43690, 55133])

  Location  |  Observed  |  Expected  |  Reason
    (1)        0.33333       43690       Abs err 43690 exceeds tol 0
    (2)        0.66667       43690       Abs err 43689 exceeds tol 0
    (3)           1          55133       Abs err 55132 exceeds tol 0
***** xtest
 J = [20    32    57    81   105   125   150   174   198   223   247];
 assert (histeq (uint8 (0:10:100)), J);
!!!!! known failure
ASSERT errors for:  assert (histeq (uint8 (0:10:100)),J)

  Location  |  Observed  |  Expected  |  Reason
    (1)        0.090909        20        Abs err 19.909 exceeds tol 0
    (2)        0.18182         32        Abs err 31.818 exceeds tol 0
    (3)        0.27273         57        Abs err 56.727 exceeds tol 0
    (4)        0.36364         81        Abs err 80.636 exceeds tol 0
    (5)        0.45455        105        Abs err 104.55 exceeds tol 0
    (6)        0.54545        125        Abs err 124.45 exceeds tol 0
    (7)        0.63636        150        Abs err 149.36 exceeds tol 0
    (8)        0.72727        174        Abs err 173.27 exceeds tol 0
    (9)        0.81818        198        Abs err 197.18 exceeds tol 0
    (10)       0.90909        223        Abs err 222.09 exceeds tol 0
    (11)          1           247        Abs err 246 exceeds tol 0
***** xtest
 J = [0.0793650794
      0.1269841270
      0.2222222222
      0.3174603175
      0.4126984127
      0.4920634921
      0.5873015873
      0.6825396825
      0.7777777778
      0.8730158730
      1.0000000000];
 assert (histeq (0:0.1:1), J', 10^-8);
!!!!! known failure
ASSERT errors for:  assert (histeq (0:0.1:1),J',10 ^ -8)

  Location  |  Observed  |  Expected  |  Reason
    (1)        0.090909     0.079365     Abs err 0.011544 exceeds tol 1e-08
    (2)        0.18182      0.12698      Abs err 0.054834 exceeds tol 1e-08
    (3)        0.27273      0.22222      Abs err 0.050505 exceeds tol 1e-08
    (4)        0.36364      0.31746      Abs err 0.046176 exceeds tol 1e-08
    (5)        0.45455       0.4127      Abs err 0.041847 exceeds tol 1e-08
    (6)        0.54545      0.49206      Abs err 0.053391 exceeds tol 1e-08
    (7)        0.63636       0.5873      Abs err 0.049062 exceeds tol 1e-08
    (8)        0.72727      0.68254      Abs err 0.044733 exceeds tol 1e-08
    (9)        0.81818      0.77778      Abs err 0.040404 exceeds tol 1e-08
    (10)       0.90909      0.87302      Abs err 0.036075 exceeds tol 1e-08
22 tests, 7 passed, 15 known failures, 0 skipped
[edge]
>>>>> /usr/share/octave/packages/image-2.6.1/edge.m
***** test
 im = [
   249   238   214   157   106    69    60    90   131   181   224   247   252   250   250
   250   242   221   165   112    73    62    91   133   183   225   248   252   250   251
   252   246   228   173   120    78    63    90   130   181   224   248   253   251   251
   253   248   232   185   132    87    62    80   116   170   217   244   253   251   252
   253   249   236   198   149   101    66    71   101   155   206   238   252   252   252
   254   250   240   210   164   115    73    69    92   143   196   232   252   253   252
    70    70    68    61    49    36    24    22    26    38    52    63    70    70    70
     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0
    62    63    62    59    51    42    33    25    22    26    36    45    56    60    62
   252   253   252   246   221   190   157   114    90    90   118   157   203   235   248
   251   253   254   251   233   209   182   136   103    92   107   139   185   225   245
   251   253   254   253   243   227   206   163   128   108   110   133   175   217   242
   252   253   254   254   249   241   228   195   164   137   127   139   172   212   239
 ] / 255;

 methods = {"kirsch", "prewitt", "sobel"};
 for m_i = 1:numel (methods)
   method = methods{m_i};

   bw = edge (im, method, 0.2, "both", "thinning");
   assert (edge (im, method, 0.2), bw)

   args = perms ({0.2, "both", "thinning"});
   for i = 1:rows (args)
     assert (edge (im, method, args{i,:}), bw)
   endfor

   bw = edge (im, method, 0.2, "vertical", "nothinning");
   args = perms ({0.2, "vertical", "nothinning"});
   for i = 1:rows (args)
     assert (edge (im, method, args{i,:}), bw)
   endfor

   bw = edge (im, method, 0.2, "vertical", "thinning");
   args = perms ({0.2, "vertical"});
   for i = 1:rows (args)
     assert (edge (im, method, args{i,:}), bw)
   endfor

   bw = edge (im, method, 0.2, "both", "nothinning");
   args = perms ({0.2, "nothinning"});
   for i = 1:rows (args)
     assert (edge (im, method, args{i,:}), bw)
   endfor
 endfor
***** error <more than 1 threshold argument>
  bw = edge (rand (10), "sobel", 0.2, 0.4)
***** error <more than 1 thinning argument>
  bw = edge (rand (10), "sobel", "thinning", "nothinning")
***** error <more than 1 direction argument>
  bw = edge (rand (10), "sobel", "both", "both")
***** error <only THRESH, DIRECTION, and THINNING arguments>
  bw = edge (rand (10), "sobel", [0.2 0.7], "both", "thinning")
***** error <more than 1 threshold argument>
  bw = edge (rand (10), "kirsch", 0.2, 0.4)
***** error <more than 1 thinning argument>
  bw = edge (rand (10), "kirsch", "thinning", "nothinning")
***** error <more than 1 direction argument>
  bw = edge (rand (10), "kirsch", "both", "both")
***** error <only THRESH, DIRECTION, and THINNING arguments>
  bw = edge (rand (10), "kirsch", [0.2 0.7], "both", "thinning")
***** error <more than 1 threshold argument>
  bw = edge (rand (10), "prewitt", 0.2, 0.4)
***** error <more than 1 thinning argument>
  bw = edge (rand (10), "prewitt", "thinning", "nothinning")
***** error <more than 1 direction argument>
  bw = edge (rand (10), "prewitt", "both", "both")
***** error <only THRESH, DIRECTION, and THINNING arguments>
  bw = edge (rand (10), "prewitt", [0.2 0.7], "both", "thinning")
***** test
 im = [
   249   238   214   157   106    69    60    90   131   181   224   247   252   250   250
   250   242   221   165   112    73    62    91   133   183   225   248   252   250   251
   252   246   228   173   120    78    63    90   130   181   224   248   253   251   251
   253   248   232   185   132    87    62    80   116   170   217   244   253   251   252
   253   249   236   198   149   101    66    71   101   155   206   238   252   252   252
   254   250   240   210   164   115    73    69    92   143   196   232   252   253   252
    70    70    68    61    49    36    24    22    26    38    52    63    70    70    70
     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0
    62    63    62    59    51    42    33    25    22    26    36    45    56    60    62
   252   253   252   246   221   190   157   114    90    90   118   157   203   235   248
   251   253   254   251   233   209   182   136   103    92   107   139   185   225   245
   251   253   254   253   243   227   206   163   128   108   110   133   175   217   242
   252   253   254   254   249   241   228   195   164   137   127   139   172   212   239
 ] / 255;

 bw = edge (im, "roberts", .2, "thinning");
 assert (edge (im, "roberts", 0.2), bw)
 assert (edge (im, "roberts", "thinning", 0.2), bw)

 bw = edge (im, "roberts", .2, "nothinning");
 assert (edge (im, "roberts", "nothinning", 0.2), bw)
***** error <more than 1 threshold argument>
  bw = edge (rand (10), "roberts", 0.2, 0.4)
***** error <more than 1 thinning argument>
  bw = edge (rand (10), "roberts", "thinning", "nothinning")
***** error <only THRESH and THINNING arguments>
  bw = edge (rand (10), "roberts", "both", "thinning")
***** test
 im = rand (10);
 [~, thresh] = edge (im, "canny");
 assert (size (thresh), [1 2])
 [~, thresh] = edge (im, "canny", [.2 .6]);
 assert (thresh, [.2 .6])
 [~, thresh] = edge (im, "canny", [.2; .6]);
 assert (thresh, [.2 .6])
***** test
 in = zeros (5);
 in(3,3) = 1;

 E = logical ([
    0 0 0 0 0
    0 0 1 0 0
    0 1 0 1 0
    0 0 1 0 0
    0 0 0 0 0]);
 assert (edge (in), E)
 assert (edge (uint8 (in.*100)), E)
 assert (edge (in, "sobel"), E)
 assert (edge (in, "sobel", 0), E)
 assert (edge (in, "sobel", 1), false (5))

 [E, auto_thresh] = edge (in);
 assert (auto_thresh, 0.2449, 1e-4)

 V = logical([
    0 0 0 0 0
    0 1 0 1 0
    0 1 0 1 0
    0 1 0 1 0
    0 0 0 0 0]);
 assert (edge (in, "sobel", 0, "vertical"), V)

 H = logical ([
    0 0 0 0 0
    0 1 1 1 0
    0 0 0 0 0
    0 1 1 1 0
    0 0 0 0 0]);
 assert (edge (in, "sobel", 0, "horizontal"), H)

 V = false (5);
 V(3,2) = true;
 V(3,4) = true;
 assert (edge (in, "sobel", [], "vertical"), V)

 H = false (5);
 H(2,3) = true;
 H(4,3) = true;
 assert (edge (in, "sobel", [], "horizontal"), H)
***** test
 A = ones (5);
 A(3, 3) = 0;
 expected = logical ([
    0  0  0  0  0
    0  0  1  0  0
    0  1  0  1  0
    0  0  1  0  0
    0  0  0  0  0]);
 assert (edge (A), expected)
***** test
 in = zeros (5);
 in(3, 3) = 1;

 E = logical ([
    0 0 0 0 0
    0 1 0 1 0
    0 0 0 0 0
    0 1 0 1 0
    0 0 0 0 0]);

 assert (edge (in, "prewitt"), E)

 [~, auto_thresh] = edge (in, "prewitt");
 assert (auto_thresh, 0.2309, 1e-4)

 V = logical([
    0 0 0 0 0
    0 1 0 1 0
    0 1 0 1 0
    0 1 0 1 0
    0 0 0 0 0]);
 assert (edge (in, "prewitt", 0, "vertical"), V)

 H = logical ([
    0 0 0 0 0
    0 1 1 1 0
    0 0 0 0 0
    0 1 1 1 0
    0 0 0 0 0]);
 assert (edge (in, "prewitt", 0, "horizontal"), H)
***** test
 in = zeros (5);
 in(3,3) = 1;
 in(3,4) = 0.9;

 E = logical ([
    0 0 0 0 0
    0 0 1 0 0
    0 0 1 0 0
    0 0 0 0 0
    0 0 0 0 0]);

 assert (edge (in, "roberts"), E)

 [~, auto_thresh] = edge (in, "roberts");
 assert (auto_thresh, 0.6591, 1e-4)

 E45 = [0     0      0     0  0
        0  -0.5  -0.45     0  0
        0     0   0.50  0.45  0
        0     0      0     0  0
        0     0      0     0  0];
 E135 = [0    0      0      0  0
         0    0  -0.50  -0.45  0
         0  0.5   0.45      0  0
         0    0      0      0  0
         0    0      0      0  0];

 [~, ~, erg45, erg135] = edge (in, "roberts");
 assert (erg45, E45)
 assert (erg135, E135)
***** test
 in_8 = fspecial ("gaussian", [8 8], 2);
 in_8 /= in_8(4,4);
 in_8_uint8 = im2uint8 (in_8);

 ## this is the result from Matlab's old canny method (before 2011a)
 out_8_old = logical ([
  0   0   0   0   0   0   0   0
  0   0   0   1   1   0   0   0
  0   0   1   0   0   1   0   0
  0   1   0   0   0   0   1   0
  0   1   0   0   0   0   1   0
  0   0   1   0   0   1   0   0
  0   0   0   1   1   0   0   0
  0   0   0   0   0   0   0   0]);
 out_8 = logical ([
  0   0   0   0   0   0   0   0
  0   1   1   1   1   1   0   0
  0   1   0   0   0   1   0   0
  0   1   0   0   0   1   0   0
  0   1   0   0   0   1   0   0
  0   1   1   1   1   1   0   0
  0   0   0   0   0   0   0   0
  0   0   0   0   0   0   0   0]);
 out_thresh = [0.34375 0.859375];

 [obs_edge, obs_thresh] = edge (in_8, "Canny");
 assert (obs_edge, out_8)
 assert (obs_thresh, out_thresh)

 [obs_edge_givethresh, obs_thresh_givethresh] ...
    = edge (in_8, "Canny", out_thresh);
 assert (obs_edge_givethresh, out_8)
 assert (obs_thresh_givethresh, out_thresh)

 [obs_edge_uint8, obs_thresh_uint8] = edge (in_8_uint8, "Canny");
 assert (obs_edge_uint8, out_8)
 assert (obs_thresh_uint8, out_thresh)
!!!!! test failed
ASSERT errors for:  assert (obs_thresh,out_thresh)

  Location  |  Observed  |  Expected  |  Reason
    (1)        0.27112      0.34375      Abs err 0.072632 exceeds tol 0
    (2)        0.67779      0.85938      Abs err 0.18158 exceeds tol 0
***** test
 in_9 = fspecial ("gaussian", [9 9], 2);
 in_9 /= in_9(5,5);

 ## this is the result from Matlab's old canny method (before 2011a)
 out_9_old = logical ([
  0   0   0   0   0   0   0   0   0
  0   0   0   0   0   0   0   0   0
  0   0   0   1   1   1   0   0   0
  0   0   1   0   0   0   1   0   0
  0   0   1   0   0   0   1   0   0
  0   0   1   0   0   0   1   0   0
  0   0   0   1   1   1   0   0   0
  0   0   0   0   0   0   0   0   0
  0   0   0   0   0   0   0   0   0]);
 out_9 = logical ([
  0   0   0   0   0   0   0   0   0
  0   0   1   1   1   1   0   0   0
  0   1   1   0   0   1   1   0   0
  0   1   0   0   0   0   1   0   0
  0   1   0   0   0   0   1   0   0
  0   1   1   0   0   1   1   0   0
  0   0   1   1   1   1   0   0   0
  0   0   0   0   0   0   0   0   0
  0   0   0   0   0   0   0   0   0]);
 out_thresh = [0.35 0.875];

 [obs_edge, obs_thresh] = edge (in_9, "Canny");
 assert (obs_edge, out_9)
 assert (obs_thresh, out_thresh)

 [obs_edge_givethresh, obs_thresh_givethresh] ...
    = edge (in_9, "Canny", out_thresh);
 assert (obs_edge_givethresh, out_9)
 assert (obs_thresh_givethresh, out_thresh)
!!!!! test failed
ASSERT errors for:  assert (obs_thresh,out_thresh)

  Location  |  Observed  |  Expected  |  Reason
    (1)         0.261         0.35       Abs err 0.089001 exceeds tol 0
    (2)         0.6525       0.875       Abs err 0.2225 exceeds tol 0
24 tests, 22 passed, 0 known failure, 0 skipped
[isbw]
>>>>> /usr/share/octave/packages/image-2.6.1/isbw.m
***** shared img
 img = round (rand (10));
***** assert (isbw (img, "non-logical"), true);
***** assert (isbw (img, "logical"), false);
***** assert (isbw (logical (img), "logical"), true);
***** assert (isbw (logical (img), "non-logical"), true);
***** test
 img(1, 1) = 2;
 assert (isbw (img, "non-logical"), false);
***** test
 a( 1,  1) = 1;
 a(50, 50) = 2;
 assert (isbw (a, "non-logical"), false);
***** assert (isbw (rand (5, 5, 1, 4) > 0.5), true)
***** assert (isbw (rand (5, 5, 3, 4) > 0.5), false)
***** assert (isbw (rand (5, 5, 3) > 0.5), false)
***** assert (isbw (rand (5, 5, 1, 3, 4) > 0.5), false)
***** assert (isbw (randi ([0 1], 5, 5, 1, 4), "non-logical"), true)
***** assert (isbw (randi ([0 1], 5, 5, 3, 4), "non-logical"), false)
***** assert (isbw (randi ([0 1], 5, 5, 3), "non-logical"), false)
***** assert (isbw (randi ([0 1], 5, 5, 1, 3, 4), "non-logical"), false)
***** assert (isbw (single ([0 0 1]), "non-logical"), true)
***** assert (isbw ([0 NaN 1], "non-logical"), false)
16 tests, 16 passed, 0 known failure, 0 skipped
[grayslice]
>>>>> /usr/share/octave/packages/image-2.6.1/grayslice.m
***** function gs = test_grayslice_vector (I, v)
  gs = zeros (size (I));
  for idx = 1:numel (v)
    gs(I >= v(idx)) = idx;
  endfor
***** endfunction
***** function gs = test_grayslice_scalar (I, n)
  v = (1:(n-1)) / n;
  gs = test_grayslice_vector (I, v);
***** endfunction
***** shared I2d, I3d, I5d, double_corner
 I2d = rand (10, 10);
 I3d = rand (10, 10, 3);
 I5d = rand (10, 10, 4, 3, 5);

 double_corner = I2d;
 double_corner(I2d > 0.1 & I2d < 0.3) = -0.2;
 double_corner(I2d > 0.6 & I2d < 0.7) = 1.3;
***** assert (grayslice (I2d), grayslice (I2d, 10))
***** assert (grayslice (I2d, 10), uint8 (test_grayslice_scalar (I2d, 10)))
***** assert (grayslice (I2d, [0.3 0.5 0.7]),
        uint8 (test_grayslice_vector (I2d, [0.3 0.5 0.7])))
***** assert (grayslice (I3d, 10), uint8 (test_grayslice_scalar (I3d, 10)))
***** assert (grayslice (I5d, 300), test_grayslice_scalar (I5d, 300)+1)
***** assert (grayslice (I3d, [0.3 0.5 0.7]),
        uint8 (test_grayslice_vector (I3d, [0.3 0.5 0.7])))
***** assert (grayslice (im2uint8 (I2d), 3), uint8 (test_grayslice_scalar (I2d, 3)))
!!!!! test failed
ASSERT errors for:  assert (grayslice (im2uint8 (I2d), 3),uint8 (test_grayslice_scalar (I2d, 3)))

  Location  |  Observed  |  Expected  |  Reason
   (6,5)          2            1         Abs err 1 exceeds tol 0
shared variables 
  scalar structure containing the fields:

    I2d =

     Columns 1 through 5:

       2.2108e-01   7.1460e-01   8.6567e-01   3.5439e-01   8.1303e-01
       6.0278e-01   2.3774e-01   5.8131e-01   7.2077e-01   1.1110e-01
       7.0996e-01   4.6300e-02   4.8698e-01   2.5724e-01   6.1860e-01
       7.1942e-01   8.0688e-02   6.3525e-01   8.3008e-01   8.9633e-01
       2.1788e-01   1.8532e-01   3.2400e-01   3.8378e-01   2.0041e-01
       5.0852e-02   6.3537e-02   9.5558e-01   4.1360e-01   6.6543e-01
       1.0681e-01   5.6779e-01   8.8390e-01   6.2696e-01   5.6603e-01
       3.0843e-01   3.7813e-02   5.1968e-01   8.1225e-01   9.5174e-01
       8.1486e-01   1.2409e-01   1.8420e-01   8.8242e-01   5.7982e-01
       7.3654e-01   1.7672e-01   5.3159e-01   5.9625e-01   4.5111e-01

     Columns 6 through 10:

       5.1728e-01   1.0107e-01   6.5419e-01   3.3463e-01   1.0942e-01
       1.7279e-01   2.7808e-01   6.7876e-02   5.4860e-01   5.3571e-01
       7.4577e-01   1.6398e-01   4.4978e-01   9.2166e-01   9.3425e-02
       7.9070e-01   7.6630e-01   4.8991e-01   9.7023e-01   8.0686e-01
       3.9059e-02   1.9876e-01   2.2937e-01   8.3335e-01   8.4557e-01
       5.7511e-01   9.3485e-02   4.2976e-01   1.5719e-01   1.8497e-01
       2.2432e-01   4.5868e-01   9.9131e-01   8.7040e-01   7.9128e-01
       9.3553e-05   6.6808e-01   9.7603e-01   2.5762e-01   4.1599e-01
       7.9825e-01   3.8867e-01   8.7362e-01   1.4623e-01   3.1062e-01
       3.0549e-01   9.1384e-01   9.8013e-01   4.8089e-01   9.4983e-01

    I3d =

    ans(:,:,1) =

     Columns 1 through 6:

       0.9085150   0.1792320   0.5846304   0.2771707   0.2880155   0.9420309
       0.8613022   0.0867448   0.5590647   0.6988739   0.2724803   0.7204822
       0.1855647   0.8378079   0.7677413   0.2595728   0.5104854   0.7870274
       0.4522364   0.0937747   0.9966227   0.0610727   0.1112158   0.2817193
       0.2276822   0.6032556   0.3271703   0.9687399   0.5843361   0.8485225
       0.7477551   0.0935541   0.0397918   0.2241526   0.2214395   0.2617302
       0.8794472   0.4461342   0.7029060   0.3393716   0.7688555   0.9232492
       0.7271264   0.0135106   0.1557253   0.6974208   0.0069772   0.4020502
       0.9869050   0.0169541   0.4121321   0.5420072   0.0759689   0.4529774
       0.3951611   0.8883234   0.9630852   0.5482397   0.2590686   0.2767235

     Columns 7 through 10:

       0.4045911   0.2143361   0.6603151   0.4828948
       0.4372772   0.1877603   0.3025271   0.0906916
       0.1491541   0.4506762   0.6660143   0.5638696
       0.8495631   0.4831842   0.8866188   0.1303504
       0.6335897   0.9267868   0.3939597   0.3463807
       0.5226737   0.5512384   0.3706674   0.2647164
       0.2351980   0.7611097   0.5901221   0.5919692
       0.2260306   0.7774365   0.9966957   0.4580111
       0.2696824   0.2941071   0.6664638   0.1091572
       0.0692295   0.9030892   0.8001783   0.3745571

    ans(:,:,2) =

     Columns 1 through 6:

       0.6358116   0.7210104   0.8962380   0.5977748   0.7720084   0.5213305
       0.7867312   0.4205214   0.9545294   0.3814059   0.8906520   0.2625041
       0.1438551   0.2938348   0.3060704   0.3279878   0.8931884   0.4945498
       0.4845353   0.7323126   0.8208957   0.8710910   0.5035026   0.4881228
       0.5741805   0.5877735   0.4108953   0.3483542   0.8821193   0.0336696
       0.8093164   0.0784516   0.4031445   0.1939100   0.0957019   0.1695865
       0.9424732   0.5602791   0.3306339   0.0844267   0.6953766   0.6677692
       0.3925726   0.1758199   0.4787147   0.4804591   0.0057583   0.6332367
       0.5846225   0.6176720   0.9213075   0.3098178   0.3775534   0.5789479
       0.5169500   0.5357480   0.3968004   0.2105890   0.2748831   0.9091415

     Columns 7 through 10:

       0.5383382   0.1277380   0.7919386   0.9910193
       0.1772733   0.3908723   0.2665560   0.3767360
       0.8033068   0.6287754   0.8694417   0.3273783
       0.1321653   0.5588265   0.7393830   0.8282297
       0.7985915   0.6264328   0.3549167   0.0390456
       0.6336571   0.8055474   0.8279415   0.4747802
       0.9274108   0.7992458   0.4386309   0.1693312
       0.0669233   0.4494325   0.0749771   0.8950862
       0.3647397   0.7922371   0.7000772   0.2596080
       0.0160786   0.5925126   0.9992618   0.2224255

    ans(:,:,3) =

     Columns 1 through 6:

       0.0061426   0.7378355   0.7519356   0.5804171   0.6154007   0.8941715
       0.6575978   0.6255490   0.0711355   0.8374924   0.8314746   0.2497667
       0.2847423   0.0522545   0.6715752   0.2097869   0.0606501   0.5724891
       0.4741217   0.9280973   0.1691334   0.1859933   0.9889718   0.1073489
       0.1766171   0.7981516   0.6994000   0.8907176   0.5814034   0.0419371
       0.8643178   0.0520671   0.4824610   0.6005893   0.4744997   0.4543153
       0.6682848   0.3794387   0.5522350   0.5568276   0.0271924   0.8990382
       0.3069721   0.1232460   0.8136584   0.4909493   0.2771549   0.2706576
       0.4212646   0.9962158   0.5932430   0.0791940   0.6490885   0.6512897
       0.6657112   0.9257975   0.5013654   0.9892049   0.2301217   0.0500173

     Columns 7 through 10:

       0.2258903   0.9350242   0.3612735   0.4738222
       0.8861171   0.1841960   0.5190135   0.5261083
       0.4582520   0.4954488   0.3223983   0.4531726
       0.8396346   0.9743292   0.4215382   0.0489690
       0.4878682   0.0772344   0.2681769   0.7044520
       0.4365548   0.4550444   0.2759317   0.3522443
       0.7292469   0.4410071   0.7824871   0.2465154
       0.4951616   0.4983616   0.1996937   0.0709213
       0.0615712   0.4945864   0.8721199   0.4982466
       0.7153366   0.1861152   0.3921529   0.5475796

    I5d =

    ans(:,:,1,1,1) =

     Columns 1 through 6:

       0.810376   0.098682   0.576878   0.706564   0.819190   0.247543
       0.435225   0.625369   0.373603   0.918725   0.433850   0.772251
       0.485067   0.449270   0.553216   0.787279   0.949005   0.798967
       0.681437   0.416348   0.862801   0.247387   0.499675   0.738336
       0.468978   0.926005   0.079781   0.904408   0.878728   0.829696
       0.114884   0.324622   0.392534   0.383564   0.067494   0.661371
       0.214238   0.833893   0.145222   0.791795   0.193403   0.830096
       0.104963   0.332170   0.627773   0.925863   0.555758   0.869307
       0.988644   0.797814   0.274507   0.449171   0.477658   0.966367
       0.225291   0.813570   0.990809   0.447016   0.959444   0.958199

     Columns 7 through 10:

       0.916102   0.874058   0.786368   0.419681
       0.772763   0.410233   0.981419   0.785152
       0.229611   0.076497   0.055096   0.359925
       0.735858   0.062802   0.453697   0.578421
       0.304172   0.278797   0.794227   0.655945
       0.304396   0.742428   0.330066   0.479694
       0.689693   0.948255   0.154762   0.839338
       0.022627   0.767355   0.302272   0.652870
       0.346508   0.455734   0.206857   0.828140
       0.266232   0.039935   0.291981   0.412147

    ans(:,:,2,1,1) =

     Columns 1 through 6:

       0.276234   0.846525   0.061176   0.140045   0.445964   0.279462
       0.446801   0.428954   0.593714   0.804726   0.162388   0.074579
       0.918022   0.201462   0.185542   0.927933   0.977139   0.302611
       0.771110   0.553937   0.913288   0.462932   0.450807   0.410957
       0.120045   0.567351   0.180486   0.700017   0.993554   0.082247
       0.909432   0.879017   0.127984   0.140255   0.852337   0.188740
       0.223360   0.684406   0.998605   0.908053   0.205410   0.033317
       0.119684   0.721858   0.721251   0.355705   0.368574   0.913923
       0.642101   0.577404   0.567234   0.328714   0.556801   0.473230
       0.056447   0.219470   0.693944   0.070851   0.142890   0.817358

     Columns 7 through 10:

       0.013138   0.203642   0.797660   0.475073
       0.581832   0.940178   0.323563   0.629182
       0.083242   0.203315   0.433784   0.395889
       0.766958   0.755854   0.110398   0.285274
       0.568647   0.627844   0.458146   0.648398
       0.848049   0.047693   0.578580   0.815830
       0.839368   0.768969   0.414103   0.382384
       0.928432   0.228726   0.090722   0.797694
       0.053330   0.801987   0.690028   0.702777
       0.609750   0.052841   0.142793   0.591928

    ans(:,:,3,1,1) =

     Columns 1 through 6:

       0.5209732   0.0843203   0.0586275   0.7436350   0.8676406   0.1172197
       0.6785965   0.0189280   0.8371924   0.1129088   0.4031566   0.1828344
       0.6652239   0.4019332   0.2276184   0.1935138   0.1508922   0.0051881
       0.6424947   0.3763872   0.4583254   0.7549096   0.4031105   0.3927504
       0.8176588   0.3356968   0.0870428   0.2373985   0.3538991   0.5822181
       0.8949977   0.4266026   0.4311177   0.3465940   0.8973854   0.1023099
       0.5465893   0.2078232   0.1344535   0.2617167   0.4746617   0.4718182
       0.4601952   0.6855701   0.9442340   0.2353406   0.6809454   0.3038767
       0.7739653   0.2480496   0.5129697   0.0306575   0.9643645   0.3871131
       0.1672978   0.7420738   0.4181704   0.4270389   0.9200445   0.3316468

     Columns 7 through 10:

       0.9498464   0.3738813   0.4960997   0.0929555
       0.0038414   0.6293277   0.1737913   0.6496748
       0.1709926   0.1237376   0.8221310   0.0481747
       0.7353316   0.8548542   0.0458594   0.3412932
       0.8047790   0.7071608   0.7753484   0.5832220
       0.3047390   0.0329819   0.5165143   0.4323066
       0.2472658   0.4549157   0.1300625   0.0110773
       0.3291799   0.3547561   0.9502443   0.9920188
       0.1856981   0.3352798   0.1850712   0.4557457
       0.4563348   0.9663552   0.0782193   0.9862699

    ans(:,:,4,1,1) =

     Columns 1 through 6:

       0.794770   0.410530   0.148022   0.529149   0.363288   0.207195
       0.523706   0.312083   0.486274   0.429240   0.218603   0.574153
       0.594559   0.177732   0.473127   0.648865   0.739265   0.130675
       0.465082   0.086184   0.781705   0.895195   0.957084   0.866229
       0.035303   0.873758   0.014733   0.183677   0.197174   0.766822
       0.817687   0.861009   0.087369   0.459576   0.305843   0.187788
       0.882185   0.617579   0.664024   0.395632   0.208691   0.902998
       0.924960   0.746975   0.476071   0.309065   0.936185   0.506448
       0.171990   0.468743   0.988962   0.320124   0.719442   0.992578
       0.016150   0.555236   0.883985   0.179951   0.488493   0.437751

     Columns 7 through 10:

       0.050819   0.210973   0.198584   0.275553
       0.367200   0.476461   0.377815   0.259146
       0.863100   0.427207   0.734865   0.764315
       0.206292   0.650585   0.898049   0.195198
       0.488971   0.800481   0.765545   0.246841
       0.491128   0.490847   0.043433   0.646516
       0.208732   0.806342   0.764484   0.664138
       0.805124   0.433424   0.892304   0.506192
       0.538170   0.768819   0.200999   0.893079
       0.394475   0.967602   0.858515   0.898519

    ans(:,:,1,2,1) =

     Columns 1 through 6:

       0.419125   0.801708   0.873315   0.703715   0.905840   0.121056
       0.795143   0.625885   0.103123   0.244379   0.469384   0.133774
       0.966169   0.377714   0.748201   0.144974   0.772168   0.099324
       0.400529   0.157178   0.264000   0.718496   0.784109   0.011721
       0.340166   0.420120   0.745074   0.016972   0.818521   0.188046
       0.207608   0.936520   0.218795   0.456085   0.233022   0.341641
       0.495520   0.841600   0.512516   0.531824   0.412952   0.835727
       0.782307   0.728390   0.725814   0.414064   0.665924   0.900127
       0.596717   0.677278   0.569575   0.939400   0.584586   0.121027
       0.527338   0.645874   0.527975   0.347440   0.843857   0.847947

     Columns 7 through 10:

       0.534677   0.950545   0.475113   0.384314
       0.518978   0.895848   0.537534   0.389922
       0.087276   0.044611   0.888596   0.049048
       0.319639   0.111062   0.817746   0.880923
       0.555878   0.382061   0.677681   0.871777
       0.660479   0.153771   0.335231   0.460487
       0.745573   0.902834   0.970273   0.408826
       0.296409   0.908731   0.025560   0.330915
       0.062144   0.320403   0.564509   0.308299
       0.332799   0.099113   0.131875   0.369725

    ans(:,:,2,2,1) =

     Columns 1 through 6:

       0.0667625   0.4434588   0.2322615   0.9109875   0.4377696   0.3253606
       0.4527177   0.0651558   0.3315827   0.1019568   0.5685801   0.0418888
       0.0473282   0.9841833   0.6112927   0.3025367   0.8748755   0.7882075
       0.3745701   0.8856116   0.7069455   0.2653348   0.2967969   0.0525185
       0.9502550   0.2417517   0.2597097   0.5590371   0.4182782   0.8557862
       0.5102043   0.2738430   0.5187608   0.4156323   0.6944199   0.5934101
       0.8436136   0.3080648   0.0238998   0.8096875   0.1854913   0.6159406
       0.0593120   0.4135516   0.4021995   0.4960027   0.1143986   0.4066538
       0.9197854   0.3165317   0.0551880   0.0417164   0.6550483   0.6269316
       0.1471270   0.3555741   0.1573436   0.1258035   0.8118004   0.0563414

     Columns 7 through 10:

       0.2905911   0.0098594   0.1074483   0.3653092
       0.5687944   0.6673565   0.6230593   0.2375169
       0.5861968   0.7158670   0.7256135   0.7486863
       0.0714501   0.8822895   0.4682427   0.0179792
       0.0244591   0.1613813   0.5592001   0.5022894
       0.9568736   0.0281312   0.5769619   0.5090060
       0.5266264   0.6428395   0.2852004   0.2322997
       0.5417045   0.4404826   0.5275789   0.3680267
       0.3055292   0.9891196   0.2465138   0.1531026
       0.9633465   0.9803822   0.8241016   0.6602472

    ans(:,:,3,2,1) =

     Columns 1 through 6:

       0.8487872   0.8905500   0.9377910   0.8684960   0.5340038   0.6486067
       0.4547180   0.4997198   0.7875987   0.0049704   0.8241293   0.2051052
       0.2395931   0.2442229   0.3500502   0.2905419   0.3150350   0.1750491
       0.5717488   0.2948279   0.2393516   0.8799100   0.0798410   0.9369957
       0.4004781   0.5289274   0.6555123   0.9969869   0.9570398   0.7220818
       0.4023262   0.5851302   0.6405652   0.2888300   0.2495583   0.9202830
       0.0321699   0.4499750   0.7670309   0.2268389   0.8987271   0.8342333
       0.7305865   0.6908330   0.5001874   0.9229585   0.0279327   0.6095449
       0.6060568   0.2107404   0.7223782   0.3920189   0.4876632   0.9492219
       0.7207518   0.9191790   0.8859767   0.2038811   0.6256003   0.7995169

     Columns 7 through 10:

       0.8347789   0.5678921   0.2805064   0.4012978
       0.2143893   0.6999812   0.9810728   0.7272475
       0.2882718   0.0767099   0.2701642   0.2046307
       0.4738332   0.8241256   0.2820355   0.7263221
       0.4344589   0.4198173   0.6620064   0.3204649
       0.7692141   0.8951258   0.7787947   0.3255112
       0.2389707   0.5246297   0.4012678   0.7708479
       0.7492361   0.3582179   0.7673545   0.2743685
       0.1725816   0.2454360   0.9306972   0.1717850
       0.2595417   0.2517398   0.8371412   0.6843575

    ans(:,:,4,2,1) =

     Columns 1 through 6:

       0.416082   0.629340   0.620300   0.616327   0.190143   0.084491
       0.361945   0.281442   0.534239   0.954083   0.825942   0.542995
       0.469400   0.986333   0.217749   0.156239   0.085515   0.403804
       0.406716   0.409443   0.651367   0.900348   0.257977   0.383350
       0.361641   0.312526   0.384863   0.929444   0.081283   0.302890
       0.724502   0.883361   0.865074   0.501750   0.471337   0.104909
       0.607145   0.043828   0.203374   0.165962   0.079829   0.985759
       0.878716   0.906764   0.113423   0.903959   0.538190   0.631155
       0.607674   0.026923   0.621105   0.106972   0.121733   0.353629
       0.394132   0.952002   0.022303   0.381161   0.193216   0.802417

     Columns 7 through 10:

       0.971154   0.423696   0.201953   0.543989
       0.210027   0.877520   0.068125   0.361213
       0.982533   0.633239   0.065602   0.799833
       0.319029   0.234161   0.290546   0.445514
       0.101110   0.627287   0.305455   0.551176
       0.777346   0.101175   0.669952   0.998585
       0.068896   0.493767   0.663224   0.999177
       0.960577   0.556930   0.809245   0.518827
       0.431986   0.177889   0.396948   0.519756
       0.604496   0.726126   0.476635   0.963078

    ans(:,:,1,3,1) =

     Columns 1 through 6:

       0.0051192   0.9642115   0.6467914   0.8485369   0.3367795   0.3916511
       0.8651498   0.3824299   0.4048343   0.5129000   0.0568461   0.2988005
       0.1090879   0.1062871   0.5283745   0.8131848   0.3938530   0.7205317
       0.3265968   0.3017192   0.9198270   0.1461151   0.9379613   0.0089870
       0.7745099   0.2237715   0.8298687   0.3478060   0.4722986   0.4582103
       0.7088194   0.5222636   0.8470160   0.8804550   0.2614177   0.2914650
       0.7500881   0.4096922   0.4335698   0.3125150   0.8714446   0.6881506
       0.3135739   0.1180787   0.2541961   0.5534419   0.8772480   0.6719254
       0.5444778   0.2409311   0.8206862   0.7773879   0.8659744   0.5826321
       0.7138808   0.0905213   0.6064382   0.7062720   0.4397820   0.5705855

     Columns 7 through 10:

       0.0031849   0.6649034   0.9198431   0.1003064
       0.6566476   0.6201431   0.3324817   0.8713365
       0.8614027   0.2492988   0.8141918   0.0247510
       0.2525018   0.9067519   0.3451716   0.9888107
       0.7631954   0.7971038   0.9087908   0.2922930
       0.7464956   0.9444286   0.1913923   0.8875573
       0.1571285   0.5962577   0.4057805   0.8396809
       0.5875000   0.9789866   0.4697268   0.7748592
       0.0855502   0.2323717   0.1751119   0.1201540
       0.1704252   0.4623113   0.3271615   0.4951229

    ans(:,:,2,3,1) =

     Columns 1 through 6:

       0.5973690   0.3982001   0.3266393   0.3945284   0.2504278   0.5428706
       0.3066157   0.2019397   0.3275959   0.0376969   0.4933716   0.8048465
       0.7521998   0.5348336   0.9231731   0.0946847   0.8848275   0.3241261
       0.9951353   0.2644929   0.3555249   0.2598676   0.4748415   0.8246108
       0.7011674   0.5083559   0.9568421   0.1274113   0.6305754   0.1325225
       0.5496720   0.0601821   0.0244317   0.2980860   0.8028220   0.6334425
       0.3767477   0.6368914   0.2611748   0.5216934   0.1587316   0.7043436
       0.7932917   0.9790613   0.6493430   0.5759291   0.1399908   0.7593085
       0.5106853   0.0069769   0.6701336   0.8579557   0.1587473   0.6009623
       0.1267406   0.0806822   0.7929170   0.5037219   0.5099758   0.7923996

     Columns 7 through 10:

       0.4924078   0.6231774   0.6726756   0.2376709
       0.4301648   0.2990099   0.8054499   0.9564681
       0.5753813   0.6445857   0.6709282   0.5839838
       0.1372179   0.9166328   0.9399930   0.8889427
       0.1153677   0.5395731   0.0474958   0.8207998
       0.8171029   0.3164227   0.5009089   0.1273747
       0.8686284   0.4807118   0.7511339   0.8415075
       0.4277779   0.0346180   0.0169095   0.0334487
       0.6913851   0.2302356   0.2614804   0.5996883
       0.7698865   0.1653180   0.3714277   0.2000901

    ans(:,:,3,3,1) =

     Columns 1 through 6:

       0.3673294   0.9310928   0.6944141   0.0291384   0.3594707   0.9045901
       0.5164970   0.8132594   0.8571588   0.4223326   0.7091630   0.8580768
       0.0315146   0.2497343   0.6305408   0.5165458   0.8166352   0.3690522
       0.0630992   0.7650866   0.3799516   0.2870462   0.6177566   0.5705667
       0.3840602   0.0973067   0.8865582   0.5771179   0.1821084   0.5263851
       0.8734286   0.0592813   0.1259235   0.0264619   0.2696337   0.6251776
       0.3709600   0.2788850   0.6147465   0.0028484   0.7663109   0.0262633
       0.0042082   0.9223086   0.5575108   0.6762692   0.8572554   0.5152919
       0.0243544   0.8875509   0.8958823   0.7699428   0.7290951   0.4800880
       0.9173073   0.6194682   0.2524935   0.5880678   0.2092284   0.2648492

     Columns 7 through 10:

       0.8826204   0.8906887   0.8173201   0.0147500
       0.0181336   0.7829348   0.8365039   0.2589379
       0.0569537   0.1441546   0.6442387   0.2406615
       0.0248183   0.1929274   0.4882305   0.0932147
       0.3552673   0.9493918   0.9013098   0.5313287
       0.6024635   0.5908431   0.3854422   0.3208911
       0.0265285   0.3793655   0.4137378   0.5301421
       0.8536833   0.2393343   0.6563048   0.2772838
       0.6340120   0.3848427   0.2024214   0.1717332
       0.2746239   0.3505430   0.6102731   0.1650513

    ans(:,:,4,3,1) =

     Columns 1 through 6:

       0.3321409   0.8011251   0.7911651   0.3987848   0.6076832   0.9440724
       0.6730656   0.3289007   0.6698372   0.6547989   0.2155528   0.7281286
       0.0640711   0.7312586   0.3425904   0.9560479   0.1631463   0.7935855
       0.1890226   0.2227653   0.3707193   0.2555907   0.1217344   0.6544673
       0.5220939   0.7493412   0.0113001   0.9669227   0.4052524   0.7921704
       0.8574233   0.0610000   0.3895241   0.9023984   0.4081744   0.3812959
       0.8935133   0.0988709   0.9062059   0.9678378   0.6976464   0.0603345
       0.9821240   0.1637312   0.2505369   0.1896658   0.7427257   0.3313305
       0.2639491   0.5364443   0.4314255   0.0175309   0.0678695   0.9035357
       0.9132878   0.7721031   0.7490714   0.4765888   0.9494456   0.0239354

     Columns 7 through 10:

       0.4962867   0.8304485   0.2460796   0.3715590
       0.2466159   0.0125134   0.0726971   0.5543683
       0.7719894   0.4127208   0.1506180   0.8240553
       0.5720825   0.0228197   0.3208682   0.4429452
       0.8044129   0.5997317   0.1614014   0.1023594
       0.9284138   0.0405851   0.3361429   0.0340996
       0.7098809   0.8744963   0.6910722   0.0467698
       0.2126441   0.6295077   0.4990928   0.2536376
       0.5383910   0.1317960   0.0327869   0.6306820
       0.0087543   0.4545349   0.8414397   0.3416207

    ans(:,:,1,1,2) =

     Columns 1 through 6:

       0.7110329   0.8780240   0.4496120   0.1588055   0.2367555   0.5472165
       0.6683019   0.3975191   0.4919997   0.5095346   0.6838901   0.4340546
       0.0400900   0.2310279   0.2057475   0.9327393   0.6047668   0.0035260
       0.0963746   0.4375845   0.2923767   0.4233803   0.4786268   0.4987043
       0.1204683   0.7904114   0.3308303   0.9683190   0.9610732   0.4658826
       0.0834552   0.9198336   0.4276609   0.7487897   0.4638412   0.2557878
       0.2383031   0.5166034   0.6468581   0.8770294   0.1036236   0.9069617
       0.9445578   0.8164596   0.2027702   0.5771583   0.7926646   0.9999860
       0.8728387   0.6927377   0.8145227   0.6149674   0.9575772   0.8242791
       0.0903046   0.6864367   0.7184165   0.3253922   0.0278764   0.8276423

     Columns 7 through 10:

       0.1593379   0.0268149   0.7878098   0.7741040
       0.2995835   0.6065372   0.3652583   0.1767655
       0.0804260   0.6675662   0.6701949   0.6737756
       0.2471273   0.8439163   0.0706660   0.9551154
       0.9783697   0.1720289   0.6327307   0.5031399
       0.8673323   0.2480370   0.6143645   0.2205467
       0.1905734   0.3406908   0.0038097   0.1063645
       0.4919964   0.3254222   0.0024640   0.5749885
       0.7113865   0.4963860   0.6523721   0.0589407
       0.7751916   0.9213611   0.7556305   0.7380588

    ans(:,:,2,1,2) =

     Columns 1 through 6:

       0.0102728   0.7869879   0.4224425   0.1847836   0.9911191   0.7171264
       0.6326170   0.4537716   0.6983639   0.8475922   0.7784203   0.6494836
       0.9872571   0.6276377   0.8688471   0.0196818   0.2241776   0.3116178
       0.2738996   0.1599150   0.8873252   0.2603410   0.4524987   0.2994896
       0.3060755   0.4605067   0.0469910   0.4117608   0.1927481   0.8043289
       0.7050812   0.1509867   0.1425108   0.5162964   0.3401355   0.6022343
       0.4265652   0.3726254   0.7981891   0.2168170   0.9888975   0.6476326
       0.6524802   0.5570739   0.8175592   0.2550218   0.9139493   0.0724688
       0.9552424   0.6407442   0.6644576   0.3637030   0.0904287   0.2604093
       0.2482823   0.4084737   0.2589626   0.7900248   0.8356889   0.0010138

     Columns 7 through 10:

       0.0523161   0.2954536   0.9946666   0.5971124
       0.6388745   0.3498102   0.7762737   0.9119895
       0.7772392   0.7447664   0.1293567   0.5012443
       0.5567880   0.7529136   0.3506618   0.4091337
       0.2697423   0.9638289   0.1427652   0.1921481
       0.6502622   0.9979430   0.6982095   0.1404264
       0.0828745   0.0766134   0.6750829   0.8625562
       0.4822215   0.5403436   0.4884062   0.2870998
       0.2537652   0.9961874   0.1483415   0.2586591
       0.2443475   0.2356337   0.7033171   0.2047642

    ans(:,:,3,1,2) =

     Columns 1 through 6:

       0.886570   0.387795   0.674710   0.653723   0.149113   0.797752
       0.878079   0.278299   0.023144   0.217300   0.864953   0.701004
       0.388871   0.903133   0.455367   0.443985   0.501682   0.385823
       0.342179   0.985679   0.903545   0.681919   0.802747   0.856096
       0.996988   0.200966   0.157184   0.380738   0.742683   0.157015
       0.575593   0.142549   0.562835   0.388252   0.422879   0.094094
       0.181369   0.925404   0.822692   0.197060   0.723766   0.515104
       0.952350   0.444017   0.681560   0.662165   0.942260   0.808604
       0.079305   0.566000   0.255629   0.680495   0.903966   0.138276
       0.090300   0.783986   0.535740   0.911551   0.539740   0.036267

     Columns 7 through 10:

       0.222259   0.629112   0.454202   0.748143
       0.385930   0.232702   0.369554   0.385771
       0.502429   0.061489   0.491785   0.500039
       0.985800   0.183869   0.029227   0.807328
       0.825766   0.345752   0.225206   0.058568
       0.699256   0.311132   0.642183   0.075352
       0.644914   0.101891   0.272531   0.217387
       0.430396   0.789706   0.546499   0.884225
       0.509364   0.080719   0.347810   0.552523
       0.789972   0.232638   0.714936   0.608923

    ans(:,:,4,1,2) =

     Columns 1 through 6:

       0.703167   0.895547   0.321455   0.964754   0.636111   0.562098
       0.805162   0.904342   0.629949   0.448413   0.432901   0.635484
       0.381280   0.029067   0.712167   0.090733   0.932404   0.310156
       0.716366   0.476315   0.128624   0.205000   0.741729   0.522251
       0.964924   0.191945   0.306641   0.454506   0.918261   0.387312
       0.583575   0.667824   0.216957   0.733722   0.268015   0.822478
       0.188006   0.859222   0.750902   0.873207   0.890193   0.363098
       0.617089   0.768765   0.759699   0.671263   0.836112   0.435831
       0.182397   0.503122   0.983581   0.111772   0.978514   0.122360
       0.631235   0.641815   0.790211   0.050426   0.211761   0.491106

     Columns 7 through 10:

       0.805627   0.811498   0.742229   0.848890
       0.340196   0.259301   0.222319   0.648404
       0.612253   0.136577   0.394925   0.772409
       0.071778   0.141588   0.913788   0.679360
       0.269393   0.166476   0.263635   0.423187
       0.686158   0.437595   0.454158   0.738118
       0.844870   0.226333   0.050935   0.286054
       0.211835   0.908488   0.451580   0.767429
       0.155943   0.310180   0.052210   0.997174
       0.590957   0.780875   0.716083   0.641756

    ans(:,:,1,2,2) =

     Columns 1 through 6:

       0.1878352   0.8624286   0.3665079   0.9346284   0.8097372   0.9284779
       0.3818379   0.5380551   0.3511858   0.3621515   0.4375099   0.0897530
       0.2033886   0.6267727   0.4514046   0.3064438   0.4398464   0.1861123
       0.7826517   0.0737229   0.0914460   0.6014377   0.8460290   0.7306190
       0.1679334   0.9100354   0.5665778   0.1829216   0.0026763   0.1725150
       0.3000967   0.6898867   0.3373977   0.9283066   0.1095613   0.1012451
       0.1856724   0.7785792   0.0918462   0.2723747   0.8237254   0.0469334
       0.5444948   0.8286812   0.9634168   0.3888340   0.2384108   0.4722390
       0.3702035   0.7133309   0.3465711   0.9603066   0.4341037   0.7701312
       0.4971123   0.7048958   0.7037008   0.8628597   0.7896578   0.2269976

     Columns 7 through 10:

       0.0596639   0.8541383   0.1458686   0.4222925
       0.5366376   0.6475454   0.6719793   0.6302454
       0.2555567   0.6555141   0.5413356   0.4390930
       0.7452817   0.1538712   0.5908946   0.3671833
       0.2530928   0.2819780   0.1573123   0.6293347
       0.3219239   0.6944065   0.9315498   0.2198387
       0.8257163   0.1817305   0.7905729   0.5578306
       0.2679742   0.9576643   0.9092099   0.4662440
       0.2403528   0.8262039   0.4280747   0.5123595
       0.0588874   0.8026308   0.5616471   0.6272292

    ans(:,:,2,2,2) =

     Columns 1 through 6:

       0.2817777   0.2426456   0.9800920   0.4485883   0.9420195   0.0210151
       0.8026816   0.6968762   0.2329937   0.3864551   0.7469092   0.1397848
       0.3604065   0.2609379   0.6908306   0.6449120   0.7933182   0.8722471
       0.6243291   0.6924631   0.6703188   0.8824525   0.5496050   0.3582978
       0.7949584   0.3667689   0.1713776   0.2579087   0.8550084   0.8316173
       0.8861642   0.7375697   0.5709407   0.8717697   0.0297959   0.4739057
       0.4029860   0.0708173   0.4531750   0.6988634   0.9725306   0.2537152
       0.3037881   0.3817658   0.0044153   0.0517739   0.7865039   0.7815663
       0.8142875   0.9779351   0.6364370   0.8089758   0.7452076   0.9534135
       0.0772751   0.5860291   0.9943992   0.3222467   0.7701242   0.3263064

     Columns 7 through 10:

       0.2716679   0.4005586   0.2887278   0.6872264
       0.5503250   0.3952428   0.7999758   0.3053899
       0.3299734   0.3809559   0.6461417   0.9840608
       0.1264273   0.1183382   0.6221502   0.4467041
       0.5175271   0.5742084   0.6400923   0.9573118
       0.7316170   0.0673990   0.5855794   0.9771024
       0.0056992   0.5945818   0.1184796   0.3150174
       0.3239212   0.5616612   0.3554259   0.4474511
       0.1817791   0.9933149   0.0355487   0.0985332
       0.5328323   0.8903889   0.1996794   0.7151594

    ans(:,:,3,2,2) =

     Columns 1 through 6:

       0.4650336   0.1290626   0.5637894   0.6909094   0.8023020   0.9688239
       0.7762508   0.4686659   0.5253495   0.2967104   0.9894615   0.6643910
       0.4146187   0.3799304   0.6445695   0.9634592   0.3051356   0.7322590
       0.0121596   0.8730502   0.6061742   0.8625687   0.1548036   0.8308767
       0.6269605   0.6719517   0.1948955   0.8805310   0.2481145   0.8828404
       0.5021922   0.0020074   0.3464080   0.5400264   0.5584776   0.6148001
       0.6121586   0.8587893   0.2051135   0.3176191   0.6744515   0.1056653
       0.3598432   0.9798290   0.7812014   0.9331295   0.1538925   0.2230421
       0.5179343   0.1550994   0.4213246   0.1235934   0.2573815   0.5212689
       0.9024882   0.7767693   0.2992562   0.6108584   0.4032308   0.0857939

     Columns 7 through 10:

       0.3190705   0.7415331   0.3020702   0.8814395
       0.1383603   0.4121208   0.2586144   0.1448048
       0.5587912   0.0810173   0.8992439   0.0914073
       0.5050345   0.6957303   0.3293078   0.9099616
       0.7795904   0.0128167   0.5730085   0.8210464
       0.9051300   0.6443984   0.9420758   0.2929259
       0.5486139   0.8428771   0.4933654   0.2884004
       0.4987979   0.5632385   0.7008250   0.3480636
       0.4074552   0.8943786   0.6851662   0.2615953
       0.4132316   0.6639066   0.4219204   0.8470077

    ans(:,:,4,2,2) =

     Columns 1 through 6:

       0.1387701   0.7323272   0.5839849   0.3377349   0.5608527   0.4291921
       0.7662255   0.1864237   0.3880898   0.2240633   0.9532640   0.2813417
       0.4694665   0.4050114   0.6872974   0.6890945   0.9732192   0.1751725
       0.4092232   0.8157509   0.5091082   0.3897147   0.5552357   0.2743486
       0.8135658   0.5885752   0.7231130   0.5980365   0.3198819   0.2991516
       0.0542688   0.7818956   0.4371062   0.9334046   0.4949795   0.6461746
       0.4085862   0.3413757   0.8565464   0.8901276   0.5837812   0.0015213
       0.1445362   0.7540329   0.3328202   0.7295881   0.5008343   0.8108689
       0.3134238   0.6581873   0.8769458   0.7714833   0.2454879   0.1323422
       0.7463726   0.3755997   0.7546217   0.9276641   0.8201612   0.9546037

     Columns 7 through 10:

       0.8829186   0.5863462   0.8476416   0.5365916
       0.2361552   0.0726304   0.8838354   0.1502373
       0.8042768   0.2585160   0.5515444   0.4848605
       0.8983858   0.4069385   0.8166760   0.8782747
       0.0577268   0.9604372   0.7152396   0.9542161
       0.5907363   0.0962301   0.9633589   0.7875858
       0.4086413   0.8141418   0.5467496   0.4831412
       0.3067305   0.2918304   0.3994853   0.0681579
       0.9334252   0.6102766   0.6432716   0.1207185
       0.7079995   0.8991320   0.7339144   0.6185315

    ans(:,:,1,3,2) =

     Columns 1 through 6:

       0.850794   0.633792   0.022319   0.584993   0.378538   0.876180
       0.820550   0.566085   0.076135   0.980739   0.468111   0.756060
       0.021893   0.061616   0.244420   0.178111   0.569384   0.242228
       0.387538   0.537468   0.407364   0.981958   0.429383   0.919181
       0.267927   0.511574   0.897277   0.431496   0.096990   0.969997
       0.303660   0.702656   0.993402   0.341931   0.611596   0.807850
       0.768928   0.936842   0.527614   0.808162   0.421734   0.535711
       0.164418   0.788436   0.497669   0.037615   0.673811   0.083115
       0.337013   0.453766   0.176417   0.728280   0.590792   0.333881
       0.934198   0.350312   0.397179   0.337865   0.279992   0.401225

     Columns 7 through 10:

       0.891551   0.203911   0.719829   0.329083
       0.700094   0.326396   0.834893   0.551854
       0.140019   0.476442   0.684188   0.904101
       0.963655   0.113402   0.328759   0.976565
       0.587752   0.804928   0.978060   0.718629
       0.419945   0.579493   0.698214   0.114274
       0.915048   0.438472   0.226911   0.105264
       0.612784   0.189952   0.231739   0.633512
       0.954178   0.435415   0.196564   0.411623
       0.907945   0.639666   0.676578   0.208758

    ans(:,:,2,3,2) =

     Columns 1 through 6:

       0.226755   0.126199   0.703004   0.191332   0.351628   0.785355
       0.240716   0.103539   0.233432   0.358979   0.023161   0.264994
       0.671350   0.490331   0.995962   0.060878   0.924733   0.307135
       0.796921   0.751032   0.786203   0.612042   0.103880   0.430942
       0.276815   0.917041   0.680917   0.173359   0.477252   0.543289
       0.596638   0.520283   0.322937   0.906080   0.449664   0.282786
       0.495594   0.769421   0.055374   0.088746   0.679443   0.293056
       0.300856   0.603273   0.837346   0.679741   0.529878   0.830693
       0.240044   0.623625   0.185466   0.745815   0.157575   0.145465
       0.153187   0.489262   0.447974   0.420381   0.501956   0.713076

     Columns 7 through 10:

       0.555344   0.813898   0.560332   0.214597
       0.672756   0.277195   0.789812   0.080667
       0.644100   0.227224   0.971435   0.370642
       0.919219   0.165152   0.359257   0.329207
       0.667804   0.853995   0.444430   0.490269
       0.111295   0.012433   0.130959   0.624635
       0.578472   0.941766   0.902522   0.129056
       0.277710   0.506310   0.683419   0.792852
       0.387422   0.169937   0.732633   0.570809
       0.145518   0.548646   0.275199   0.520761

    ans(:,:,3,3,2) =

     Columns 1 through 6:

       0.689191   0.479827   0.229239   0.106677   0.399505   0.611669
       0.138483   0.318286   0.647842   0.251831   0.958738   0.688333
       0.273278   0.979835   0.250448   0.765089   0.306333   0.747542
       0.920489   0.760811   0.233740   0.217678   0.168359   0.527905
       0.167515   0.317350   0.606746   0.114158   0.845687   0.532453
       0.859382   0.740998   0.243033   0.785245   0.425521   0.417986
       0.192789   0.269181   0.063988   0.348172   0.914070   0.542250
       0.420217   0.557663   0.159572   0.983462   0.733567   0.877299
       0.012020   0.714532   0.760805   0.185285   0.771359   0.392577
       0.666482   0.575258   0.864656   0.841221   0.530768   0.323908

     Columns 7 through 10:

       0.177994   0.070328   0.089431   0.503279
       0.773427   0.056813   0.039949   0.367435
       0.466352   0.479911   0.815991   0.236570
       0.890969   0.711271   0.292221   0.579875
       0.913373   0.360598   0.933918   0.492918
       0.201973   0.455594   0.623610   0.128726
       0.795043   0.272933   0.782612   0.680447
       0.736731   0.254735   0.313396   0.186607
       0.646843   0.919227   0.864458   0.010671
       0.191913   0.545958   0.526232   0.171408

    ans(:,:,4,3,2) =

     Columns 1 through 6:

       0.651044   0.426291   0.132529   0.309644   0.490345   0.847867
       0.066316   0.918754   0.781046   0.668628   0.734299   0.331468
       0.097357   0.568706   0.445841   0.155303   0.140473   0.931829
       0.027515   0.483933   0.202185   0.348720   0.017776   0.086517
       0.056745   0.877355   0.508475   0.196365   0.940916   0.989078
       0.123305   0.534926   0.324671   0.594712   0.643167   0.694618
       0.094629   0.755468   0.920526   0.361791   0.580710   0.562871
       0.733656   0.208680   0.948009   0.889321   0.489601   0.538729
       0.638333   0.652550   0.473284   0.801093   0.737833   0.517871
       0.319182   0.540627   0.265402   0.659331   0.675305   0.662707

     Columns 7 through 10:

       0.355006   0.039983   0.584125   0.217797
       0.378733   0.204801   0.069714   0.954470
       0.959785   0.874550   0.753330   0.064999
       0.489601   0.945162   0.183287   0.597647
       0.789460   0.566294   0.486116   0.594112
       0.052787   0.120518   0.040279   0.407727
       0.344680   0.211137   0.150753   0.583710
       0.727590   0.610068   0.197102   0.413788
       0.367515   0.561431   0.116795   0.462783
       0.467771   0.385066   0.672628   0.533868

    ans(:,:,1,1,3) =

     Columns 1 through 5:

       7.5862e-01   7.0339e-02   3.6282e-02   5.5131e-01   2.7969e-01
       6.2216e-01   7.5748e-01   3.6294e-01   2.9254e-01   7.6816e-01
       5.4553e-01   5.7890e-01   5.0648e-01   8.0610e-01   5.6458e-01
       1.8127e-01   3.7119e-01   6.7823e-02   8.9845e-02   1.0287e-01
       8.4725e-01   2.5148e-01   4.7502e-01   6.9425e-01   4.9971e-01
       2.6574e-01   9.3057e-01   4.7543e-02   6.5614e-02   4.3115e-02
       8.1758e-01   9.8570e-01   2.5194e-01   9.1936e-01   4.7104e-01
       1.0012e-01   6.1040e-01   7.1138e-01   5.9225e-01   7.5650e-01
       5.8747e-01   2.2277e-01   7.2763e-01   3.6139e-01   7.3308e-01
       2.2427e-01   5.0527e-01   3.3283e-01   7.5260e-01   3.6417e-01

     Columns 6 through 10:

       9.6009e-01   1.8728e-01   8.3446e-01   3.3526e-01   8.3750e-01
       4.2889e-01   5.6616e-01   2.8738e-01   2.1075e-01   4.0626e-01
       6.9434e-01   5.1687e-01   4.6799e-01   5.6063e-01   8.1310e-01
       3.9723e-02   7.0505e-01   8.9811e-01   9.4357e-01   3.7400e-01
       4.6657e-02   6.1032e-01   4.5710e-01   5.6654e-01   2.6755e-02
       4.7177e-01   8.2159e-01   1.9348e-01   4.4297e-04   4.4911e-01
       6.7479e-01   2.4456e-01   4.0061e-03   4.5427e-01   2.3461e-01
       7.2876e-01   2.8433e-01   8.5717e-01   4.5281e-01   4.3909e-01
       5.9167e-01   7.6419e-01   1.4003e-01   4.0845e-02   8.0935e-01
       2.7468e-01   7.4208e-01   9.3800e-01   6.0103e-01   7.5989e-01

    ans(:,:,2,1,3) =

     Columns 1 through 6:

       0.3144406   0.4492238   0.3210776   0.1497821   0.5833951   0.8490552
       0.9824930   0.7265806   0.8706343   0.1787491   0.7706558   0.0922346
       0.8343240   0.5000853   0.3288861   0.2756994   0.7640376   0.0449381
       0.0239175   0.9118305   0.8540507   0.7791173   0.6180356   0.8900255
       0.4609098   0.9856295   0.4481503   0.7467271   0.9205030   0.1736041
       0.2522840   0.5853109   0.7773521   0.0357720   0.5318434   0.1224892
       0.6811796   0.2201579   0.4454656   0.8754586   0.2301040   0.0428462
       0.5919952   0.3561907   0.9231253   0.4670646   0.9991223   0.8102270
       0.8929500   0.9734924   0.4432754   0.6462194   0.2691508   0.1679024
       0.1108776   0.2207221   0.2445374   0.2562309   0.2825925   0.3206091

     Columns 7 through 10:

       0.5482065   0.1904423   0.9086377   0.6126567
       0.3320397   0.1238842   0.0435185   0.7314706
       0.4481993   0.4115661   0.9242669   0.8499299
       0.4386039   0.6351336   0.2455769   0.6618803
       0.4609222   0.9394539   0.6088242   0.3358313
       0.0854179   0.5619829   0.1892635   0.3640896
       0.0096226   0.5155902   0.6920935   0.6643849
       0.2964721   0.8071447   0.6327603   0.2741741
       0.7812418   0.9049199   0.0523360   0.3749038
       0.8870934   0.5149981   0.9373216   0.6739404

    ans(:,:,3,1,3) =

     Columns 1 through 6:

       0.346231   0.694847   0.707671   0.085639   0.466567   0.716807
       0.023801   0.418648   0.961039   0.786690   0.301366   0.934630
       0.833354   0.409944   0.936141   0.448633   0.407969   0.212977
       0.445973   0.866308   0.307409   0.150295   0.307950   0.399792
       0.530967   0.974366   0.274299   0.287140   0.156292   0.447983
       0.501685   0.071529   0.492295   0.192580   0.220192   0.597013
       0.738300   0.871712   0.160501   0.870715   0.751114   0.248977
       0.748594   0.251224   0.582473   0.748841   0.290333   0.172787
       0.315559   0.214128   0.054372   0.933764   0.322828   0.129749
       0.554287   0.172606   0.272414   0.193977   0.188578   0.634297

     Columns 7 through 10:

       0.863770   0.295949   0.467176   0.209818
       0.118984   0.427427   0.211036   0.654256
       0.834705   0.070273   0.053068   0.358345
       0.218966   0.021331   0.420073   0.973724
       0.444437   0.158654   0.017893   0.040638
       0.893008   0.465510   0.266844   0.478578
       0.770323   0.234894   0.740672   0.938118
       0.586680   0.074564   0.431630   0.112819
       0.161049   0.329851   0.373123   0.101998
       0.038160   0.723431   0.848633   0.011059

    ans(:,:,4,1,3) =

     Columns 1 through 6:

       0.4688882   0.2156854   0.6157801   0.3459437   0.7306166   0.1691803
       0.6861487   0.9708954   0.7809346   0.7500212   0.0671029   0.6600254
       0.1429935   0.1575170   0.4164209   0.5889212   0.2715798   0.4538906
       0.0323139   0.1186050   0.3985368   0.0940944   0.9539747   0.0717362
       0.2601728   0.6208839   0.7883033   0.7570049   0.5285336   0.5516416
       0.3017383   0.1942561   0.9151548   0.0355131   0.2005608   0.9926870
       0.1974383   0.5725224   0.1402459   0.9791335   0.0976611   0.2336492
       0.2042691   0.7597393   0.7491054   0.7791514   0.5000714   0.2744578
       0.0089501   0.1159639   0.6710723   0.4272502   0.1681824   0.3603148
       0.4482561   0.0689440   0.1811430   0.8410362   0.4249539   0.8003807

     Columns 7 through 10:

       0.4576554   0.1674037   0.1254396   0.9212458
       0.8617081   0.9788741   0.2704862   0.1131170
       0.1053439   0.3182267   0.5032730   0.4386040
       0.9719134   0.4515963   0.0308440   0.9703481
       0.8575032   0.0638075   0.7834544   0.6449187
       0.5494912   0.9324951   0.3172727   0.2735147
       0.4864995   0.2238607   0.5380475   0.9242677
       0.4528357   0.9043334   0.1666322   0.8277307
       0.3197599   0.8014975   0.9498181   0.5855582
       0.5361182   0.7659236   0.6675139   0.3575443

    ans(:,:,1,2,3) =

     Columns 1 through 6:

       0.7330856   0.3042450   0.8898046   0.1755047   0.4457987   0.8037152
       0.1114979   0.1439123   0.5902880   0.7711424   0.3678137   0.9083077
       0.2445166   0.2329721   0.2395515   0.9756815   0.1064098   0.5483993
       0.9278149   0.8078374   0.8807261   0.3310950   0.3232468   0.1266189
       0.6665967   0.3363437   0.8233265   0.2842847   0.3060392   0.0145264
       0.7546649   0.7868362   0.4076428   0.6631526   0.4638260   0.8560493
       0.8397705   0.5463782   0.4909727   0.1768447   0.2470691   0.4120335
       0.0983401   0.0856996   0.1697998   0.3833083   0.8611075   0.3729273
       0.0990290   0.1564875   0.5247001   0.9386423   0.4074036   0.6870344
       0.9768055   0.2989777   0.4091708   0.9669247   0.0017685   0.5602568

     Columns 7 through 10:

       0.6353499   0.9819943   0.5693483   0.0550054
       0.0709421   0.6059790   0.4243352   0.2394649
       0.9443484   0.9094269   0.3208277   0.3395519
       0.6830302   0.9260379   0.5621889   0.8411683
       0.1032302   0.8202412   0.1200913   0.1045161
       0.2944562   0.9181236   0.5453256   0.5833506
       0.1064836   0.1427281   0.5523289   0.4369657
       0.7475847   0.7739307   0.2310015   0.4928523
       0.0679849   0.2444004   0.5378377   0.8258556
       0.0983835   0.9581749   0.6529665   0.4366992

    ans(:,:,2,2,3) =

     Columns 1 through 6:

       0.801800   0.889606   0.473886   0.413931   0.614331   0.976644
       0.034406   0.132254   0.733489   0.650993   0.118877   0.606720
       0.154382   0.973474   0.248322   0.782100   0.202628   0.340121
       0.814748   0.707078   0.418948   0.035337   0.186991   0.799777
       0.965618   0.817127   0.264575   0.289095   0.191235   0.874288
       0.395955   0.471524   0.456562   0.502931   0.706726   0.986115
       0.156622   0.590867   0.678740   0.726686   0.458974   0.709143
       0.741038   0.427106   0.542616   0.118991   0.690710   0.861181
       0.331060   0.119422   0.836683   0.430782   0.498884   0.654998
       0.604842   0.239425   0.222406   0.849891   0.962850   0.609631

     Columns 7 through 10:

       0.053919   0.300076   0.678275   0.338434
       0.322860   0.747788   0.684467   0.099280
       0.973850   0.286965   0.616203   0.392100
       0.424588   0.503839   0.364567   0.342696
       0.241548   0.804625   0.197536   0.723703
       0.098138   0.362786   0.867388   0.805281
       0.081192   0.378197   0.322923   0.231199
       0.685437   0.804673   0.012785   0.679488
       0.027788   0.182210   0.179127   0.844619
       0.829615   0.239432   0.987732   0.783645

    ans(:,:,3,2,3) =

     Columns 1 through 6:

       0.8638408   0.5383200   0.8390726   0.4922262   0.5377311   0.3070349
       0.8304281   0.9130739   0.2563583   0.1109677   0.6205165   0.4549220
       0.6011665   0.6834816   0.1600743   0.0084841   0.8246802   0.4075215
       0.7767272   0.9947367   0.3790288   0.1316896   0.4813490   0.7754773
       0.6669814   0.3389192   0.8098667   0.2365177   0.7714173   0.1639011
       0.4799822   0.5177266   0.9094590   0.1518632   0.7817404   0.3329719
       0.1490409   0.1085869   0.7535682   0.5204631   0.6424606   0.1484554
       0.5315505   0.3440682   0.8821695   0.1502736   0.4481577   0.6495417
       0.6115610   0.7743779   0.8746075   0.8461900   0.6164543   0.2885691
       0.1790778   0.7667946   0.9706007   0.8380643   0.0561393   0.8824586

     Columns 7 through 10:

       0.6228087   0.4695518   0.1045802   0.5680434
       0.3644617   0.3462045   0.8742075   0.5602357
       0.1129321   0.5047795   0.9976517   0.8098700
       0.2035998   0.2189152   0.7757646   0.4933722
       0.6368288   0.0198674   0.7799486   0.4718916
       0.9115136   0.8247864   0.8294839   0.0896633
       0.7085746   0.4791783   0.0375108   0.1751525
       0.6911451   0.2915172   0.4730333   0.0688938
       0.0986350   0.2037087   0.7406669   0.2259780
       0.6479128   0.7178085   0.5234308   0.9833795

    ans(:,:,4,2,3) =

     Columns 1 through 6:

       0.1228437   0.7780539   0.3690884   0.9366872   0.9085254   0.4931580
       0.9979052   0.3704630   0.8591198   0.9993234   0.0581341   0.7119564
       0.8461543   0.9419168   0.1104134   0.2237329   0.0828601   0.9050517
       0.1915681   0.9889016   0.8505302   0.7926905   0.9537788   0.4099166
       0.2213825   0.0584224   0.4005544   0.1852734   0.4988128   0.6694278
       0.7269050   0.7000921   0.7410180   0.0855901   0.3538941   0.1031796
       0.9176624   0.7027551   0.1879621   0.4757906   0.1168271   0.9169995
       0.2066870   0.0399170   0.4468000   0.6953315   0.2636719   0.8856366
       0.4637182   0.7804980   0.8162842   0.5257744   0.6172873   0.5684309
       0.1870185   0.7035381   0.1542301   0.3177718   0.9447843   0.2016580

     Columns 7 through 10:

       0.9081769   0.2783110   0.7588383   0.5132261
       0.3070008   0.3337840   0.0524411   0.9493287
       0.5895633   0.9659673   0.7425054   0.4342710
       0.4884174   0.3443639   0.9945328   0.2486848
       0.9233115   0.3928765   0.6471286   0.4124642
       0.8274357   0.1576627   0.1288500   0.2563796
       0.9335671   0.0399718   0.3905329   0.9743407
       0.7740407   0.9232492   0.8428377   0.2792094
       0.1646656   0.4630966   0.7754765   0.0027463
       0.9803285   0.3537339   0.0275984   0.7204858

    ans(:,:,1,3,3) =

     Columns 1 through 6:

       0.5451512   0.8501206   0.2304755   0.2498105   0.1888376   0.6490907
       0.6366809   0.5170853   0.4553925   0.3529467   0.2941880   0.9944569
       0.5122925   0.7736511   0.5807332   0.1962239   0.4819563   0.1205416
       0.0650341   0.2077574   0.6380603   0.1652163   0.5069141   0.2623774
       0.5283906   0.0038776   0.7067157   0.8545034   0.4883227   0.4027647
       0.6935661   0.4070631   0.1358483   0.6181418   0.8104914   0.3330237
       0.6968040   0.5745810   0.0931668   0.6721785   0.8460913   0.4107106
       0.5785152   0.8470552   0.0756227   0.6873187   0.0438698   0.9966676
       0.0140942   0.3091861   0.3241048   0.5055772   0.4598760   0.6843525
       0.0522626   0.7262363   0.0841506   0.8864243   0.9317813   0.3542598

     Columns 7 through 10:

       0.3626136   0.3613126   0.0602946   0.7378855
       0.7736633   0.1612781   0.4825160   0.7321479
       0.2645039   0.3064498   0.5197230   0.6318896
       0.8818802   0.9011179   0.1891753   0.1600077
       0.8206620   0.8385200   0.7681921   0.3407088
       0.2611078   0.6914835   0.3115156   0.8106428
       0.3326413   0.3620572   0.1612614   0.7063555
       0.2671771   0.3540776   0.2335775   0.9312685
       0.3925613   0.5362972   0.7036809   0.6310741
       0.5939778   0.1803123   0.1792624   0.0094850

    ans(:,:,2,3,3) =

     Columns 1 through 6:

       0.480055   0.850857   0.123711   0.625405   0.309723   0.263567
       0.975250   0.930985   0.843071   0.239367   0.120495   0.935139
       0.689730   0.339604   0.210789   0.664570   0.992767   0.555746
       0.685839   0.291060   0.192766   0.174706   0.694030   0.864857
       0.580082   0.387641   0.827041   0.085306   0.385927   0.570856
       0.913498   0.934841   0.496802   0.376514   0.843975   0.351227
       0.977695   0.736267   0.376512   0.297048   0.812334   0.067724
       0.221346   0.063625   0.447934   0.894158   0.138811   0.979202
       0.310575   0.708989   0.405779   0.530170   0.167860   0.440096
       0.123417   0.745651   0.695775   0.019632   0.223622   0.477842

     Columns 7 through 10:

       0.999597   0.070435   0.765801   0.415470
       0.020127   0.525837   0.990626   0.225867
       0.757077   0.727578   0.319761   0.863790
       0.827709   0.753525   0.250040   0.926440
       0.659542   0.552003   0.403290   0.920449
       0.241768   0.607339   0.551262   0.106164
       0.174699   0.132699   0.195405   0.222836
       0.877932   0.879486   0.774517   0.732650
       0.619510   0.678228   0.948420   0.272670
       0.672432   0.650404   0.869748   0.087234

    ans(:,:,3,3,3) =

     Columns 1 through 6:

       0.2846252   0.1710440   0.6094655   0.7268151   0.2510088   0.2754298
       0.5488403   0.2882846   0.2726451   0.8317832   0.3331892   0.5142781
       0.1441260   0.7816386   0.7129209   0.0129407   0.4231293   0.7974054
       0.6792504   0.0040439   0.7509981   0.2168169   0.3480927   0.8175583
       0.6077945   0.6052270   0.7635452   0.3597744   0.2559128   0.1531447
       0.6014720   0.5198702   0.9114100   0.4822730   0.7441367   0.0151756
       0.1474322   0.7942648   0.0701747   0.0911274   0.3684599   0.8922914
       0.1539660   0.5633182   0.6048291   0.9356029   0.7782934   0.2643835
       0.0653401   0.4600428   0.0834668   0.5067473   0.2612884   0.3010248
       0.3276631   0.2028324   0.5865180   0.4980144   0.8092142   0.9596885

     Columns 7 through 10:

       0.8011920   0.2816751   0.1209784   0.1871667
       0.8361668   0.9668568   0.6825827   0.1022839
       0.1892759   0.8674382   0.6554186   0.7467678
       0.5897867   0.4231385   0.9867465   0.0485279
       0.1033270   0.7222864   0.1380636   0.4314299
       0.3765269   0.1163341   0.7089589   0.7003331
       0.5845179   0.2773794   0.0189292   0.8931890
       0.6287488   0.4329276   0.1939273   0.5792620
       0.2075719   0.9958989   0.8779850   0.4668706
       0.3564005   0.5261375   0.0130078   0.6342188

    ans(:,:,4,3,3) =

     Columns 1 through 6:

       0.103288   0.749715   0.016936   0.572145   0.352822   0.604138
       0.874111   0.276434   0.436598   0.687274   0.130699   0.169570
       0.467697   0.564932   0.399560   0.109354   0.727055   0.080277
       0.399710   0.820655   0.296942   0.898174   0.472342   0.999163
       0.360285   0.901911   0.171391   0.138758   0.393811   0.588268
       0.014444   0.889683   0.475232   0.092502   0.353702   0.903984
       0.379640   0.427433   0.188672   0.435678   0.376546   0.360428
       0.968674   0.077473   0.635428   0.103905   0.487530   0.197135
       0.154273   0.205481   0.373369   0.273767   0.213899   0.578077
       0.195533   0.707775   0.582127   0.039266   0.305968   0.479923

     Columns 7 through 10:

       0.665827   0.753722   0.885713   0.618882
       0.308906   0.421122   0.663639   0.625722
       0.589005   0.471625   0.679215   0.299922
       0.906937   0.049325   0.442257   0.113711
       0.130041   0.820066   0.385054   0.293687
       0.586955   0.392636   0.412309   0.534002
       0.159771   0.115198   0.133780   0.439231
       0.307487   0.362510   0.973057   0.569527
       0.131633   0.578125   0.357810   0.415215
       0.223604   0.592966   0.445016   0.244886

    ans(:,:,1,1,4) =

     Columns 1 through 6:

       0.3785191   0.0108493   0.9605271   0.0023736   0.4513397   0.7941403
       0.4393758   0.1930053   0.9190101   0.2971234   0.6425911   0.6617955
       0.4839588   0.0155434   0.8736503   0.5692455   0.4682384   0.6035955
       0.0321522   0.8966157   0.7655156   0.4383293   0.4959687   0.1269778
       0.1832596   0.8379255   0.3944127   0.3522696   0.7231979   0.5714074
       0.8226049   0.9250080   0.0482925   0.0394528   0.0673779   0.7472375
       0.9110212   0.8812026   0.4383090   0.6884619   0.4316804   0.6579136
       0.9510257   0.6822651   0.8265268   0.1986968   0.5583221   0.2418278
       0.0822499   0.2769205   0.7628481   0.7232950   0.7167915   0.8057909
       0.4017382   0.7031880   0.3600857   0.1716812   0.2066791   0.3299801

     Columns 7 through 10:

       0.7811152   0.9041819   0.0696058   0.8690373
       0.3228429   0.5467856   0.2348992   0.7928588
       0.1885670   0.9033467   0.7118153   0.1220953
       0.8772282   0.5113753   0.0714468   0.3197514
       0.8149026   0.6432656   0.9754336   0.8634003
       0.3584193   0.7960000   0.7767492   0.6795313
       0.2045736   0.2964510   0.6861184   0.3886449
       0.7996347   0.0800178   0.1172766   0.3637207
       0.4150001   0.2880630   0.6289046   0.5933788
       0.6226515   0.7524806   0.2858924   0.9487069

    ans(:,:,2,1,4) =

     Columns 1 through 6:

       0.8100104   0.3979261   0.3467350   0.4808002   0.8978606   0.5025340
       0.8423734   0.8449910   0.0877013   0.1351406   0.5909174   0.4233560
       0.8292347   0.2863203   0.6685257   0.1828632   0.0766521   0.6964954
       0.6890046   0.0474064   0.7071524   0.2093959   0.5247008   0.9220472
       0.4777844   0.8325253   0.5332144   0.7242996   0.8526023   0.9554140
       0.3216604   0.4375894   0.2453835   0.4818066   0.2881497   0.1257933
       0.0145445   0.4085173   0.5530977   0.8422774   0.2781154   0.2549177
       0.4663474   0.0458723   0.6755106   0.5872221   0.0074437   0.1228561
       0.4814045   0.3968975   0.5946606   0.6045436   0.2928195   0.8705251
       0.1325210   0.5700379   0.5205358   0.8103258   0.8512867   0.9098072

     Columns 7 through 10:

       0.1922647   0.3881156   0.7967817   0.5125256
       0.0335228   0.3212042   0.9422233   0.2639867
       0.9266748   0.6928911   0.1345436   0.9218868
       0.2425319   0.6892601   0.7569770   0.0013963
       0.8980518   0.4587089   0.1340647   0.1629767
       0.6059684   0.4370783   0.1709569   0.4701822
       0.1082179   0.9786090   0.0095417   0.9005811
       0.9201644   0.0600551   0.2403048   0.6353613
       0.9633558   0.0441327   0.2115948   0.1442310
       0.6192783   0.2320528   0.7727746   0.6280055

    ans(:,:,3,1,4) =

     Columns 1 through 6:

       0.431920   0.904283   0.490634   0.966862   0.576891   0.751729
       0.955016   0.394360   0.759523   0.598377   0.674727   0.549850
       0.284063   0.227637   0.718218   0.952498   0.026483   0.399514
       0.668879   0.576639   0.804784   0.952752   0.539398   0.820547
       0.031079   0.152640   0.069120   0.526655   0.085074   0.287305
       0.469471   0.960297   0.077083   0.458250   0.929945   0.439228
       0.578581   0.904569   0.482331   0.118060   0.909695   0.909585
       0.668272   0.669797   0.774112   0.230339   0.482550   0.673848
       0.839362   0.272602   0.317071   0.449671   0.298279   0.745459
       0.769755   0.717374   0.889845   0.676432   0.041727   0.224992

     Columns 7 through 10:

       0.538840   0.495023   0.215640   0.624529
       0.103167   0.082754   0.070717   0.470035
       0.706418   0.292864   0.482974   0.157382
       0.413895   0.527933   0.902264   0.093735
       0.962201   0.032496   0.657382   0.299943
       0.420276   0.040720   0.598305   0.745401
       0.897602   0.681424   0.664921   0.952166
       0.687243   0.192571   0.782766   0.931884
       0.090040   0.603187   0.928007   0.936038
       0.743185   0.499967   0.558059   0.328708

    ans(:,:,4,1,4) =

     Columns 1 through 6:

       0.1329071   0.1336629   0.4882787   0.6386346   0.9141590   0.6183739
       0.4862451   0.5417116   0.1914554   0.4709545   0.5149824   0.1880359
       0.8742992   0.3923178   0.2275061   0.7457718   0.5333878   0.4723723
       0.1478415   0.9754518   0.4300433   0.2446824   0.7490084   0.2412507
       0.4994754   0.6481735   0.8274194   0.8259531   0.7721391   0.7264443
       0.1786777   0.8583073   0.6016381   0.2230578   0.9594751   0.7236471
       0.6662511   0.4089263   0.7545118   0.4192134   0.3741564   0.1917574
       0.9145741   0.2216669   0.5118600   0.8873028   0.0814163   0.9492785
       0.3555764   0.2013435   0.0232607   0.9370945   0.9973404   0.3444831
       0.4940396   0.7258596   0.1706104   0.0016818   0.0928433   0.9611576

     Columns 7 through 10:

       0.3364611   0.6485233   0.6800868   0.0071692
       0.8885098   0.6270486   0.8625918   0.3069994
       0.5025243   0.5172204   0.8686165   0.6249793
       0.2011078   0.9393565   0.9496010   0.0259430
       0.3595349   0.1913845   0.8334979   0.1240816
       0.1919674   0.7618145   0.7406813   0.2758892
       0.7171427   0.4017847   0.2162053   0.6918610
       0.8484749   0.0065517   0.2919607   0.3693019
       0.0545048   0.0701195   0.4613084   0.7994261
       0.6158300   0.0989261   0.2988987   0.5957631

    ans(:,:,1,2,4) =

     Columns 1 through 6:

       0.9221863   0.3937555   0.9604929   0.8230049   0.1144016   0.7122617
       0.3672935   0.1570914   0.0688964   0.5651891   0.2317572   0.0538997
       0.7367600   0.8924232   0.6078225   0.7512682   0.0951665   0.6603563
       0.1536374   0.8423908   0.9164920   0.2159831   0.7297324   0.2513081
       0.2287588   0.3276718   0.9493095   0.5827039   0.9846809   0.9111145
       0.6577846   0.8094693   0.5642568   0.5294142   0.2974792   0.9843389
       0.0519598   0.0941951   0.0553248   0.8868559   0.9624232   0.1564037
       0.6032713   0.9133535   0.7761071   0.6792725   0.8374845   0.2998004
       0.5282124   0.6577550   0.5411139   0.3467639   0.7822044   0.4794027
       0.5400329   0.7851130   0.7214275   0.8928510   0.7034001   0.4389079

     Columns 7 through 10:

       0.5256372   0.3891840   0.5531684   0.4302961
       0.9937101   0.3912479   0.3058315   0.4970499
       0.7892641   0.9058443   0.7333813   0.5971163
       0.9381805   0.1272013   0.0956130   0.1929533
       0.9172565   0.3368015   0.1307791   0.4649270
       0.0083401   0.5142274   0.1292110   0.2124670
       0.2137713   0.1134284   0.2100682   0.4409604
       0.4575967   0.2236272   0.0331036   0.3328078
       0.7761853   0.1085660   0.4492486   0.6909637
       0.4633845   0.8153640   0.8215780   0.3755443

    ans(:,:,2,2,4) =

     Columns 1 through 6:

       0.819123   0.120903   0.484382   0.038341   0.161939   0.636981
       0.838219   0.283026   0.283573   0.199184   0.263532   0.859071
       0.325131   0.873733   0.994821   0.674037   0.128881   0.768851
       0.371981   0.125940   0.512698   0.867149   0.944740   0.916469
       0.180179   0.930897   0.967205   0.226741   0.475812   0.168968
       0.822865   0.450575   0.481773   0.268391   0.037168   0.226606
       0.873644   0.507853   0.995267   0.587533   0.339955   0.408680
       0.759996   0.549796   0.756510   0.446919   0.413644   0.943504
       0.138307   0.175906   0.030845   0.753134   0.662311   0.646046
       0.844333   0.794263   0.645958   0.422030   0.448024   0.427176

     Columns 7 through 10:

       0.445721   0.265980   0.110597   0.107560
       0.646451   0.932811   0.691615   0.244065
       0.866176   0.181976   0.270733   0.351144
       0.121436   0.145280   0.647547   0.693117
       0.078989   0.598467   0.106820   0.226173
       0.608855   0.955578   0.425256   0.950652
       0.697084   0.035168   0.609061   0.723807
       0.475361   0.469438   0.513648   0.944952
       0.352257   0.189332   0.993169   0.443124
       0.765749   0.596841   0.156123   0.294381

    ans(:,:,3,2,4) =

     Columns 1 through 6:

       0.2207312   0.0506856   0.7948222   0.8740116   0.1977410   0.0225726
       0.0129601   0.9909827   0.4778199   0.9156120   0.5315436   0.4643840
       0.8820794   0.8077184   0.7350488   0.6930436   0.8944724   0.1002417
       0.3883300   0.5333843   0.8335439   0.1332570   0.2170623   0.5199104
       0.7644182   0.0916670   0.9178284   0.2444251   0.3463661   0.9430180
       0.4148302   0.0328810   0.6544471   0.0446654   0.9486696   0.8702543
       0.0066148   0.1508441   0.8807896   0.5622397   0.1796325   0.0654344
       0.3284826   0.7146644   0.0730952   0.4683785   0.3821778   0.1356288
       0.7941329   0.9828135   0.9366276   0.4365991   0.7822187   0.3467706
       0.1181847   0.5932183   0.2123378   0.5502300   0.4064237   0.9484115

     Columns 7 through 10:

       0.2814349   0.3358703   0.1909897   0.5761938
       0.1001476   0.4171805   0.0205788   0.8417514
       0.1772972   0.8073782   0.1033353   0.9750542
       0.7781270   0.0594298   0.4628182   0.4482644
       0.6048608   0.1516473   0.0993976   0.4753654
       0.9453228   0.8232433   0.2345676   0.3244100
       0.4168277   0.2724879   0.7021812   0.9570908
       0.4211829   0.1483663   0.5357381   0.2868630
       0.9246399   0.5521450   0.4772562   0.3061049
       0.4107650   0.9296004   0.5825844   0.4040235

    ans(:,:,4,2,4) =

     Columns 1 through 6:

       0.3998692   0.1816136   0.4014900   0.1878816   0.9687808   0.6807696
       0.2743225   0.1820235   0.6939612   0.6013270   0.7215128   0.0301795
       0.5660411   0.0896822   0.2080072   0.1818823   0.5363087   0.9853368
       0.6517941   0.1926007   0.1567062   0.7534557   0.1176018   0.1333705
       0.6836826   0.6915843   0.1046337   0.6909996   0.2060720   0.3076803
       0.8169169   0.7722084   0.5142177   0.3070352   0.8379442   0.1788433
       0.0962919   0.1945839   0.1783261   0.9584661   0.1483848   0.4020275
       0.0024227   0.0592890   0.0585696   0.4118688   0.8106422   0.4602598
       0.7181605   0.6297752   0.7005899   0.7858837   0.3575236   0.0856582
       0.9327273   0.8518045   0.8813047   0.7356853   0.1917535   0.1573381

     Columns 7 through 10:

       0.3341257   0.9666190   0.0500985   0.1787116
       0.5634728   0.0348642   0.4322336   0.7682960
       0.2576974   0.2843808   0.0432594   0.4831940
       0.9855501   0.9954829   0.6100633   0.2294395
       0.0279284   0.0226153   0.7314434   0.7958407
       0.3464461   0.6501314   0.6060481   0.4320377
       0.5402023   0.2511329   0.9928612   0.1246288
       0.4823693   0.5856430   0.1391674   0.7279321
       0.1148116   0.0069934   0.0668799   0.7736395
       0.5978489   0.4175776   0.3291589   0.7364442

    ans(:,:,1,3,4) =

     Columns 1 through 6:

       0.4428318   0.2398345   0.8054242   0.5311792   0.0309002   0.2604719
       0.8039845   0.9816392   0.0176186   0.7378988   0.7496737   0.1005455
       0.2781143   0.5221152   0.7629324   0.9721451   0.0856175   0.8197961
       0.0804212   0.1706542   0.8776389   0.3257413   0.8405505   0.8124761
       0.7845693   0.8186195   0.7931446   0.6896201   0.1012919   0.8148798
       0.4674011   0.2497635   0.8904285   0.5316739   0.9462265   0.5532187
       0.9632776   0.4298828   0.7034344   0.8142668   0.8923561   0.8249331
       0.3329943   0.0030627   0.1135250   0.4431260   0.5723092   0.7205891
       0.6636094   0.5761154   0.0874562   0.4811210   0.7875135   0.8079906
       0.9169652   0.2869805   0.6740854   0.3853947   0.5753733   0.6599927

     Columns 7 through 10:

       0.4581947   0.0190495   0.1994428   0.9169318
       0.2565918   0.3324478   0.4357084   0.9218572
       0.0704882   0.7451727   0.1049664   0.8319775
       0.8347842   0.4330171   0.4950951   0.0253417
       0.0282180   0.9718128   0.2084240   0.6230062
       0.4971704   0.5908029   0.4444892   0.4561286
       0.2362598   0.0493352   0.8117606   0.1696213
       0.9855283   0.7919508   0.5259903   0.5212839
       0.2747836   0.8284489   0.6706880   0.2339590
       0.7480057   0.1340183   0.5515319   0.6119487

    ans(:,:,2,3,4) =

     Columns 1 through 6:

       0.045956   0.453027   0.332471   0.471060   0.769015   0.204756
       0.405728   0.084246   0.806740   0.783708   0.793071   0.929316
       0.307348   0.032294   0.916778   0.914669   0.180892   0.406862
       0.265401   0.027937   0.931253   0.259871   0.975836   0.515867
       0.701070   0.105863   0.063624   0.442207   0.072759   0.076980
       0.351702   0.390311   0.101864   0.544741   0.584084   0.903041
       0.700058   0.368975   0.309714   0.283959   0.059429   0.251071
       0.132286   0.215867   0.188597   0.109037   0.450382   0.922532
       0.096045   0.490030   0.510885   0.050734   0.234843   0.144785
       0.753793   0.663184   0.289764   0.578164   0.376885   0.036052

     Columns 7 through 10:

       0.194204   0.385404   0.935548   0.659758
       0.131649   0.645945   0.600144   0.721072
       0.837149   0.484250   0.235129   0.890835
       0.430541   0.359981   0.803519   0.627617
       0.820869   0.281609   0.058534   0.236352
       0.016961   0.512811   0.871534   0.324573
       0.464656   0.450423   0.053522   0.200902
       0.070603   0.665820   0.133322   0.187405
       0.376772   0.956613   0.723076   0.556708
       0.247163   0.369644   0.241978   0.660996

    ans(:,:,3,3,4) =

     Columns 1 through 6:

       0.1900844   0.5042037   0.2352399   0.4259761   0.5340870   0.7224739
       0.4425407   0.9898682   0.5864365   0.8480903   0.6838866   0.8333596
       0.1653547   0.6113855   0.1806442   0.7444247   0.8381104   0.5388216
       0.5267754   0.1779311   0.0264266   0.0753469   0.1161482   0.5352721
       0.5710416   0.8621054   0.4645747   0.0777636   0.1868425   0.7127999
       0.2048246   0.0687362   0.4413036   0.7715360   0.2181228   0.8413727
       0.6013444   0.3660024   0.8985174   0.9695797   0.6110059   0.5878016
       0.5923611   0.2194472   0.4159441   0.2434017   0.0563829   0.7586861
       0.5594199   0.8369203   0.3973945   0.2624748   0.9266826   0.9693698
       0.5224290   0.9632543   0.2961119   0.3169275   0.7082023   0.0323499

     Columns 7 through 10:

       0.5666893   0.6450891   0.0619235   0.8015281
       0.5236031   0.4093964   0.3465515   0.9741782
       0.4840864   0.1091859   0.9761335   0.9409857
       0.7915930   0.1964440   0.0113213   0.6952987
       0.1304345   0.9664155   0.9790717   0.8100319
       0.5963768   0.2873119   0.7071798   0.1999273
       0.1568308   0.0020468   0.5721391   0.1793425
       0.6041103   0.6636926   0.2359058   0.3164876
       0.1142857   0.0616902   0.6012203   0.1198328
       0.2558451   0.7963141   0.1316205   0.3497879

    ans(:,:,4,3,4) =

     Columns 1 through 6:

       0.455483   0.433091   0.546476   0.770915   0.610159   0.127337
       0.722177   0.375602   0.299812   0.788992   0.439248   0.800542
       0.848727   0.176577   0.971902   0.210796   0.332562   0.095872
       0.895288   0.210152   0.212159   0.179440   0.105010   0.542659
       0.199930   0.210232   0.188306   0.048453   0.715464   0.627898
       0.901017   0.218487   0.234079   0.651553   0.366748   0.254831
       0.187307   0.757084   0.380337   0.555499   0.474192   0.645459
       0.865772   0.438766   0.936289   0.420820   0.372481   0.823051
       0.153491   0.602102   0.630728   0.550746   0.710080   0.513180
       0.900283   0.125030   0.806739   0.781810   0.937753   0.333983

     Columns 7 through 10:

       0.735940   0.956946   0.709751   0.265074
       0.821596   0.966594   0.243540   0.490638
       0.701439   0.227575   0.010666   0.097196
       0.438868   0.945198   0.396448   0.428829
       0.805237   0.209144   0.349541   0.807463
       0.622573   0.763742   0.785789   0.969664
       0.659886   0.363532   0.532697   0.271219
       0.306488   0.326145   0.054343   0.429109
       0.610497   0.939184   0.865744   0.209673
       0.777626   0.094531   0.169519   0.322487

    ans(:,:,1,1,5) =

     Columns 1 through 6:

       0.7525529   0.2526449   0.5518167   0.7476556   0.6590931   0.3645592
       0.8284224   0.2015857   0.8144802   0.1514454   0.4946551   0.2118947
       0.6471742   0.8672025   0.0799349   0.9695598   0.7143175   0.2051612
       0.2201457   0.4645232   0.9393170   0.6166459   0.2899488   0.5894681
       0.1720271   0.0387727   0.3689050   0.8327928   0.8281529   0.3017802
       0.9226222   0.6954933   0.0025359   0.2225603   0.8473578   0.4420238
       0.4429980   0.1232048   0.2873159   0.8691833   0.5007745   0.3834831
       0.6207460   0.4464608   0.3105228   0.2897732   0.1774605   0.0395224
       0.9198031   0.4652506   0.4177073   0.7615541   0.4366602   0.9013855
       0.6761669   0.8181348   0.8552856   0.5985181   0.3988782   0.9557264

     Columns 7 through 10:

       0.1562362   0.9402438   0.4178779   0.4828962
       0.2350522   0.5360951   0.9756493   0.2689078
       0.9775066   0.0783453   0.1572501   0.5173312
       0.4399105   0.8319434   0.8591298   0.0878774
       0.9052349   0.6235324   0.9563297   0.6223853
       0.8190105   0.9753877   0.8739221   0.7005340
       0.8284015   0.1330207   0.7216829   0.2117149
       0.8476556   0.0469990   0.5927292   0.8871432
       0.0493367   0.7829278   0.3196544   0.7290857
       0.8589844   0.1794937   0.2668246   0.3640466

    ans(:,:,2,1,5) =

     Columns 1 through 6:

       0.949101   0.807530   0.184762   0.063234   0.643219   0.423089
       0.802067   0.381490   0.127063   0.174317   0.194559   0.198314
       0.162079   0.340070   0.813433   0.461299   0.068899   0.710028
       0.529192   0.748057   0.444558   0.222226   0.566966   0.055088
       0.165613   0.060685   0.505405   0.380502   0.058439   0.095110
       0.039772   0.903359   0.400247   0.972611   0.846175   0.377672
       0.165600   0.452785   0.415005   0.123863   0.032456   0.191811
       0.087627   0.828465   0.138878   0.117744   0.039669   0.738604
       0.176998   0.959255   0.445712   0.950234   0.307830   0.845644
       0.479856   0.519376   0.855981   0.877873   0.015214   0.111778

     Columns 7 through 10:

       0.851341   0.421584   0.126577   0.380539
       0.987831   0.522625   0.027647   0.390499
       0.622777   0.357686   0.375540   0.693333
       0.584734   0.417811   0.734467   0.607747
       0.244363   0.033658   0.422938   0.126092
       0.235824   0.761113   0.825028   0.182227
       0.752699   0.352376   0.268589   0.507060
       0.628813   0.032904   0.979176   0.988437
       0.048061   0.065858   0.463159   0.266321
       0.815382   0.935908   0.805265   0.579584

    ans(:,:,3,1,5) =

     Columns 1 through 6:

       0.737323   0.905360   0.316564   0.368499   0.753532   0.767448
       0.385909   0.827211   0.341869   0.372557   0.759581   0.862251
       0.410366   0.304743   0.820749   0.990932   0.250699   0.141378
       0.561998   0.093783   0.187227   0.332428   0.849277   0.264085
       0.508426   0.887574   0.955740   0.267614   0.641164   0.441224
       0.606690   0.435946   0.055648   0.662932   0.064705   0.691922
       0.054660   0.083549   0.997945   0.497239   0.982208   0.239593
       0.488767   0.262034   0.415360   0.162416   0.114267   0.414360
       0.041459   0.616860   0.775544   0.097906   0.521429   0.364545
       0.283602   0.530584   0.069798   0.834012   0.875984   0.180513

     Columns 7 through 10:

       0.760188   0.692474   0.572610   0.945949
       0.130591   0.774632   0.671396   0.773314
       0.672971   0.943170   0.135099   0.818206
       0.665143   0.593637   0.234495   0.346348
       0.502504   0.023369   0.676187   0.885779
       0.678728   0.458255   0.366031   0.251197
       0.252500   0.291171   0.290848   0.610278
       0.323417   0.583610   0.800318   0.942947
       0.078138   0.185280   0.690551   0.238598
       0.654039   0.037470   0.901182   0.851475

    ans(:,:,4,1,5) =

     Columns 1 through 6:

       0.0858624   0.5701325   0.6540565   0.0205818   0.5880964   0.3028144
       0.3090545   0.0793148   0.3541483   0.3836416   0.3261831   0.2555240
       0.7507791   0.6948825   0.1497456   0.9160420   0.9465602   0.0798751
       0.8561579   0.3198855   0.9982400   0.6285265   0.7948257   0.5347386
       0.7494093   0.9516750   0.5796647   0.3224356   0.1124342   0.5256283
       0.7508151   0.3623406   0.6603595   0.0781232   0.5626022   0.5841854
       0.6952069   0.8122681   0.8124431   0.0449089   0.8911996   0.0312853
       0.3452848   0.8424360   0.3130398   0.8069593   0.7757878   0.7200304
       0.1977939   0.4842620   0.5158552   0.2752961   0.5354950   0.3448198
       0.6158655   0.4811996   0.5151347   0.8054806   0.3798442   0.5253331

     Columns 7 through 10:

       0.2368545   0.0097400   0.8510853   0.5857612
       0.8785074   0.2719509   0.4371422   0.1039167
       0.1352587   0.3962855   0.4349480   0.1541173
       0.3523106   0.2463757   0.9304385   0.1048577
       0.6833446   0.7245782   0.3270974   0.6919563
       0.8497526   0.8966069   0.8169554   0.2215362
       0.3286397   0.7553802   0.2781760   0.2009482
       0.7997442   0.5672165   0.0512356   0.8973802
       0.8345787   0.5228720   0.0446545   0.7480455
       0.0964453   0.6580536   0.0723279   0.4209157

    ans(:,:,1,2,5) =

     Columns 1 through 6:

       0.438774   0.314456   0.458459   0.926635   0.010484   0.037389
       0.815694   0.879419   0.726062   0.546165   0.135028   0.446645
       0.436101   0.892103   0.540482   0.168270   0.353211   0.158197
       0.999735   0.034360   0.915122   0.154533   0.139559   0.720740
       0.842763   0.273673   0.021058   0.621158   0.794456   0.452874
       0.644759   0.404026   0.377913   0.568501   0.833690   0.768432
       0.744571   0.148542   0.671533   0.121242   0.926864   0.990331
       0.063632   0.491821   0.094314   0.269770   0.656471   0.021625
       0.237936   0.626790   0.562920   0.696457   0.584835   0.778039
       0.015329   0.931627   0.142827   0.216644   0.551701   0.485132

     Columns 7 through 10:

       0.273156   0.430352   0.669936   0.708889
       0.346589   0.908352   0.998360   0.045358
       0.667300   0.114604   0.596104   0.609949
       0.194637   0.732624   0.985820   0.889626
       0.798545   0.789774   0.265795   0.186119
       0.055130   0.554879   0.027643   0.735173
       0.778877   0.616582   0.028475   0.642420
       0.510587   0.606727   0.211427   0.757764
       0.370941   0.839959   0.415943   0.708189
       0.634897   0.618190   0.253100   0.750889

    ans(:,:,2,2,5) =

     Columns 1 through 6:

       0.599960   0.366123   0.172038   0.720374   0.793966   0.635938
       0.802937   0.883986   0.259999   0.982068   0.776531   0.045899
       0.938947   0.967589   0.795366   0.075927   0.485244   0.690240
       0.623743   0.674721   0.401160   0.248431   0.595650   0.222967
       0.872494   0.884911   0.236057   0.474905   0.315514   0.349974
       0.719052   0.421072   0.694964   0.471894   0.820218   0.239910
       0.134472   0.601424   0.704536   0.774624   0.790520   0.917434
       0.947465   0.655852   0.753532   0.725942   0.982712   0.269186
       0.442003   0.749828   0.849785   0.268833   0.120107   0.038457
       0.874144   0.773665   0.737600   0.239593   0.923668   0.732074

     Columns 7 through 10:

       0.411312   0.504910   0.897257   0.871952
       0.132512   0.888823   0.573310   0.888081
       0.657286   0.076431   0.193392   0.458831
       0.024494   0.011068   0.974473   0.661190
       0.995294   0.339811   0.017605   0.772314
       0.448058   0.461953   0.436285   0.544055
       0.556011   0.431284   0.442935   0.767002
       0.604538   0.279958   0.218520   0.563034
       0.532139   0.575311   0.944990   0.031470
       0.655849   0.408060   0.779106   0.218882

    ans(:,:,3,2,5) =

     Columns 1 through 6:

       0.7308850   0.8719699   0.6273512   0.9777553   0.8903067   0.9171131
       0.4312186   0.2807537   0.7029967   0.5344480   0.8271091   0.5667781
       0.6019108   0.8426071   0.7663381   0.0198564   0.4280430   0.0542346
       0.5301294   0.6562546   0.6904015   0.4683159   0.6471575   0.3907886
       0.1368987   0.4757006   0.3496592   0.9893074   0.5882830   0.4034688
       0.5853650   0.3143311   0.0566842   0.4370902   0.3993760   0.8952610
       0.1253357   0.5207573   0.3237674   0.9952988   0.0149685   0.4150831
       0.9651695   0.0363191   0.9682654   0.0940314   0.2193166   0.9363568
       0.9632905   0.1134134   0.1205081   0.4995357   0.5666459   0.7011007
       0.9872827   0.0110440   0.5623660   0.7501842   0.4325043   0.0039972

     Columns 7 through 10:

       0.5951025   0.9789338   0.0735213   0.7822870
       0.8435287   0.2555188   0.5872638   0.1691479
       0.5762648   0.0332170   0.5176996   0.1574856
       0.8602033   0.1569811   0.4382080   0.5341847
       0.1962821   0.5747071   0.3832164   0.9007896
       0.5568725   0.0093489   0.9152092   0.4748951
       0.6660920   0.4159313   0.9116907   0.8330728
       0.2978317   0.0379045   0.9011523   0.0678634
       0.1032624   0.8835024   0.8243145   0.0998555
       0.9064715   0.1293815   0.9863038   0.8610186

    ans(:,:,4,2,5) =

     Columns 1 through 6:

       0.1871997   0.0025077   0.2008516   0.3753066   0.0370124   0.5915076
       0.5867163   0.2677020   0.3666668   0.7767783   0.9844890   0.1567256
       0.7515606   0.8857211   0.2844261   0.5678163   0.3037900   0.7288401
       0.7702729   0.6540770   0.3495550   0.6939664   0.9317906   0.1689494
       0.5243031   0.0191734   0.7021083   0.7801938   0.2983707   0.7862142
       0.6942854   0.2520309   0.2093010   0.1319610   0.6044765   0.8937971
       0.5852260   0.3986314   0.2678591   0.6260540   0.8181763   0.5242560
       0.3679850   0.1002911   0.5795569   0.9290391   0.1943274   0.5763062
       0.8582503   0.8595343   0.3338544   0.1704357   0.5986601   0.3238175
       0.1384983   0.9793223   0.0210770   0.1780496   0.9293071   0.2411204

     Columns 7 through 10:

       0.2724874   0.2144238   0.2393040   0.3405780
       0.6806879   0.6712833   0.2333862   0.2738428
       0.0753792   0.3944164   0.8565890   0.4328555
       0.3737041   0.4171043   0.4193427   0.9452840
       0.0175592   0.6380302   0.2738426   0.5925482
       0.2299823   0.9397760   0.6751462   0.9470003
       0.7361179   0.2450149   0.9937926   0.0901551
       0.5014340   0.4710196   0.4453339   0.7279992
       0.6796307   0.7145715   0.7833796   0.4424184
       0.9226588   0.7416265   0.0031776   0.1889637

    ans(:,:,1,3,5) =

     Columns 1 through 6:

       0.162686   0.826070   0.280811   0.460022   0.409782   0.777538
       0.179209   0.942803   0.062075   0.068898   0.405612   0.251916
       0.194171   0.897989   0.668488   0.222695   0.139410   0.576132
       0.181131   0.713345   0.648146   0.879462   0.093753   0.430555
       0.508321   0.857280   0.707330   0.944771   0.566885   0.310890
       0.319102   0.995842   0.537540   0.232012   0.514900   0.278095
       0.612414   0.127316   0.494216   0.305110   0.821853   0.073798
       0.951200   0.770335   0.452708   0.212228   0.092842   0.113831
       0.492607   0.029941   0.424554   0.451297   0.390969   0.735861
       0.293330   0.824030   0.998432   0.058730   0.752901   0.863079

     Columns 7 through 10:

       0.649692   0.756461   0.548008   0.739541
       0.427832   0.874076   0.642703   0.968906
       0.668597   0.378141   0.815889   0.437688
       0.260223   0.868810   0.747671   0.454604
       0.253437   0.514037   0.857072   0.250732
       0.281889   0.706310   0.610817   0.619007
       0.870881   0.861323   0.281057   0.076955
       0.715648   0.522148   0.019085   0.622887
       0.443207   0.654787   0.926138   0.674028
       0.249230   0.759881   0.204332   0.789773

    ans(:,:,2,3,5) =

     Columns 1 through 6:

       0.476225   0.691057   0.077779   0.580940   0.093755   0.645665
       0.229565   0.939150   0.978505   0.204712   0.266081   0.652791
       0.421190   0.296825   0.621034   0.659870   0.077071   0.029741
       0.913943   0.320447   0.293368   0.371203   0.379352   0.169000
       0.627324   0.134723   0.427428   0.531598   0.233032   0.836492
       0.124042   0.214849   0.988148   0.869166   0.551678   0.309880
       0.039480   0.064019   0.092674   0.922937   0.271340   0.057332
       0.654832   0.204751   0.163468   0.245693   0.093997   0.468796
       0.509544   0.716194   0.709355   0.285992   0.297988   0.292526
       0.975371   0.929956   0.929384   0.628207   0.397132   0.785282

     Columns 7 through 10:

       0.825423   0.575956   0.149509   0.881312
       0.714736   0.817835   0.628735   0.524746
       0.403378   0.678828   0.163393   0.491836
       0.506554   0.900746   0.190431   0.092977
       0.820059   0.354175   0.669619   0.435576
       0.206743   0.947699   0.786225   0.204839
       0.083138   0.418545   0.576873   0.479118
       0.014887   0.678164   0.904250   0.302900
       0.841069   0.325409   0.091608   0.283867
       0.111765   0.037845   0.839086   0.262185

    ans(:,:,3,3,5) =

     Columns 1 through 6:

       0.672430   0.242542   0.897542   0.181572   0.131074   0.919885
       0.308615   0.653643   0.405326   0.746605   0.989897   0.046056
       0.609244   0.874862   0.917142   0.399770   0.866016   0.391503
       0.163367   0.582461   0.752122   0.083745   0.827340   0.462533
       0.685073   0.327312   0.654498   0.855563   0.649997   0.362671
       0.458819   0.140757   0.098637   0.323070   0.426681   0.970997
       0.867835   0.937834   0.393735   0.941417   0.701411   0.761693
       0.877912   0.387325   0.495172   0.600731   0.408191   0.785564
       0.356828   0.346626   0.573745   0.083574   0.696833   0.293935
       0.481151   0.681907   0.015647   0.128826   0.334606   0.313441

     Columns 7 through 10:

       0.399627   0.510351   0.249768   0.407851
       0.125632   0.914163   0.072396   0.214518
       0.574734   0.902247   0.146615   0.782473
       0.866140   0.844211   0.242116   0.775236
       0.567439   0.742191   0.124226   0.889794
       0.568529   0.470481   0.725047   0.925437
       0.570398   0.249993   0.257579   0.825237
       0.126306   0.911775   0.024731   0.399424
       0.383687   0.737874   0.677939   0.996629
       0.868467   0.889697   0.392372   0.914340

    ans(:,:,4,3,5) =

     Columns 1 through 6:

       0.661622   0.636417   0.872851   0.465302   0.690350   0.173233
       0.547391   0.032970   0.753829   0.990549   0.399422   0.463375
       0.200451   0.580093   0.846572   0.348690   0.999825   0.475279
       0.692338   0.555580   0.978246   0.118080   0.539186   0.168355
       0.089671   0.601060   0.792428   0.746589   0.568380   0.265944
       0.811798   0.266757   0.555606   0.872422   0.705870   0.880789
       0.277688   0.624231   0.087208   0.351108   0.989752   0.930447
       0.086334   0.786207   0.270813   0.422604   0.356176   0.778987
       0.596131   0.929575   0.693070   0.588203   0.637101   0.995736
       0.345290   0.363953   0.370261   0.961436   0.183752   0.454368

     Columns 7 through 10:

       0.671345   0.074775   0.013161   0.764867
       0.587133   0.393859   0.112282   0.763690
       0.165523   0.906492   0.781467   0.503899
       0.570264   0.026450   0.666447   0.821832
       0.469820   0.063610   0.978358   0.825583
       0.115245   0.858375   0.249852   0.474317
       0.987010   0.439399   0.454045   0.635855
       0.614975   0.501581   0.237833   0.101266
       0.065735   0.178675   0.183031   0.307975
       0.456399   0.331072   0.606279   0.450220

    double_corner =

     Columns 1 through 5:

      -2.0000e-01   7.1460e-01   8.6567e-01   3.5439e-01   8.1303e-01
       1.3000e+00  -2.0000e-01   5.8131e-01   7.2077e-01  -2.0000e-01
       7.0996e-01   4.6300e-02   4.8698e-01  -2.0000e-01   1.3000e+00
       7.1942e-01   8.0688e-02   1.3000e+00   8.3008e-01   8.9633e-01
      -2.0000e-01  -2.0000e-01   3.2400e-01   3.8378e-01  -2.0000e-01
       5.0852e-02   6.3537e-02   9.5558e-01   4.1360e-01   1.3000e+00
      -2.0000e-01   5.6779e-01   8.8390e-01   1.3000e+00   5.6603e-01
       3.0843e-01   3.7813e-02   5.1968e-01   8.1225e-01   9.5174e-01
       8.1486e-01  -2.0000e-01  -2.0000e-01   8.8242e-01   5.7982e-01
       7.3654e-01  -2.0000e-01   5.3159e-01   5.9625e-01   4.5111e-01

     Columns 6 through 10:

       5.1728e-01  -2.0000e-01   1.3000e+00   3.3463e-01  -2.0000e-01
      -2.0000e-01  -2.0000e-01   6.7876e-02   5.4860e-01   5.3571e-01
       7.4577e-01  -2.0000e-01   4.4978e-01   9.2166e-01   9.3425e-02
       7.9070e-01   7.6630e-01   4.8991e-01   9.7023e-01   8.0686e-01
       3.9059e-02  -2.0000e-01  -2.0000e-01   8.3335e-01   8.4557e-01
       5.7511e-01   9.3485e-02   4.2976e-01  -2.0000e-01  -2.0000e-01
      -2.0000e-01   4.5868e-01   9.9131e-01   8.7040e-01   7.9128e-01
       9.3553e-05   1.3000e+00   9.7603e-01  -2.0000e-01   4.1599e-01
       7.9825e-01   3.8867e-01   8.7362e-01  -2.0000e-01   3.1062e-01
       3.0549e-01   9.1384e-01   9.8013e-01   4.8089e-01   9.4983e-01

***** assert (grayslice (im2uint16 (I2d), 3), uint8 (test_grayslice_scalar (I2d, 3)))
8 tests, 7 passed, 0 known failure, 0 skipped
[im2col]
>>>>> /usr/share/octave/packages/image-2.6.1/im2col.m
***** demo
 ## Divide A using distinct blocks and then reverse the operation
 A = [ 1:10
      11:20
      21:30
      31:40];
 B = im2col (A, [2 5], "distinct")
 C = col2im (B, [2 5], [4 10], "distinct")
***** test
 a = rand (10);
 assert (im2col (a, [5 5]), im2col (a, [5 5], "sliding"))
***** test
 a = rand (10);
 assert (im2col (a, [5 5]), im2col (a, "indexed", [5 5]))
***** error <BLOCK_TYPE> im2col (rand (20), [2 5], 10)
***** error <BLOCK_TYPE> im2col (rand (20), [2 5], "wrong_block_type")
***** error im2col (rand (10), [5 5], "sliding", 5)
***** error im2col (rand (10), "indexed", [5 5], "sliding", 5)
***** shared B, A, Bs, As, Ap, Bp0, Bp1, Bp0_3s
 v   = [1:10]';
 r   = reshape (v, 2, 5);
 B   = [v v+20  v+40 v+10  v+30 v+50];
 A   = [r r+10; r+20 r+30; r+40 r+50];
 As  = [ 1  2  3  4  5
         6  7  8  9 10
        11 12 13 14 15];
 b1  = As(1:2, 1:4)(:);
 b2  = As(2:3, 1:4)(:);
 b3  = As(1:2, 2:5)(:);
 b4  = As(2:3, 2:5)(:);
 Bs  = [b1, b2, b3, b4];
 Ap  = A(:, 1:9);
 Bp1 = Bp0 = B;
 Bp0(9:10, 4:6) = 0;
 Bp1(9:10, 4:6) = 1;
 Bp0_3s = Bp0;
 Bp0_3s(11:30, :) = 0;
***** assert (im2col (A, [2 5], "distinct"), B);
***** assert (im2col (Ap, [2 5], "distinct"), Bp0);
***** assert (im2col (Ap, [2 5 3], "distinct"), Bp0_3s);
***** assert (im2col (Ap, "indexed", [2 5], "distinct"), Bp1);
***** assert (im2col (uint8  (Ap), "indexed", [2 5], "distinct"), uint8  (Bp0));
***** assert (im2col (uint16 (Ap), "indexed", [2 5], "distinct"), uint16 (Bp0));
***** assert (im2col (int16  (Ap), "indexed", [2 5], "distinct"), int16  (Bp1));
***** assert (im2col (uint32 (Ap), "indexed", [2 5], "distinct"), uint32 (Bp1));
***** assert (im2col (uint8   (A),  [2 5], "distinct"), uint8   (B));
***** assert (im2col (single  (A),  [2 5], "distinct"), single  (B));
***** assert (im2col (logical (A),  [2 5], "distinct"), logical (B));
***** assert (im2col (uint8   (As), [2 4], "sliding"),  uint8   (Bs));
***** assert (im2col (single  (As), [2 4], "sliding"),  single  (Bs));
***** assert (im2col (logical (As), [2 4], "sliding"),  logical (Bs));
***** assert (im2col (As, [2 4], "sliding"), Bs);
***** assert (im2col (As, [3 5], "sliding"), As(:));
***** test
 A = randi (9, 10, 9, 5);
***** assert (convn (A, ones (3, 3, 3), "valid"),
        reshape (sum (im2col (A, [3 3 3])), [8 7 3]));

 A = randi (9, 10, 9, 5, 7);
***** assert (convn (A, ones (3, 3, 3), "valid"),
        reshape (sum (im2col (A, [3 3 3])), [8 7 3 7]));
***** assert (convn (A, ones (3, 4, 3), "valid"),
        reshape (sum (im2col (A, [3 4 3])), [8 6 3 7]));
***** assert (convn (A, ones (3, 5, 3, 2), "valid"),
        reshape (sum (im2col (A, [3 5 3 2])), [8 5 3 6]));
***** assert (im2col (1:8, [2 1]), zeros (2, 0))
28 tests, 28 passed, 0 known failure, 0 skipped
[isgray]
>>>>> /usr/share/octave/packages/image-2.6.1/isgray.m
***** assert (isgray ([0 0 1; 1 0 1]), true)
***** assert (isgray (zeros (3)), true)
***** assert (isgray (ones (3)), true)
***** test
 a = rand (10);
 assert (isgray (a), true);
 a(5, 5) = 2;
 assert (isgray (a), false);
***** test
 a = uint8 (randi (255, 10));
 assert (isgray (a), true);
 a = int8 (a);
 assert (isgray (a), false);
***** test
 a = rand (10);
 a(50) = NaN;
 assert (isgray (a), true);
***** assert (isgray (rand (5, 5, 1, 4)), true);
***** assert (isgray (rand (5, 5, 3, 4)), false);
***** assert (isgray (rand (5, 5, 3)), false);
***** assert (isgray (rand (5, 5, 1, 3, 4)), false);
***** assert (isgray (rand (5, "single")), true)
***** assert (isgray ([.1 .2 .3; .4 NaN .6; .7 .8 .9]), true)
***** assert (isgray ([.1 .2 .3; NA NaN .6; .7 .8 .9]), true)
***** assert (isgray ([.1 .2 .3; NA  .5 .6; .7 .8 .9]), true)
***** assert (isgray (NaN (5)), false)
***** assert (isgray (NA (5)), false)
16 tests, 16 passed, 0 known failure, 0 skipped
[imadjust]
>>>>> /usr/share/octave/packages/image-2.6.1/imadjust.m
***** error <must be an image or a colormap> imadjust ("bad argument");
***** error <numeric floating-point arrays> imadjust ([1:100], "bad argument", [], 1);
***** error <2 row column per plane> imadjust ([1:100], [0 1 1], [], 1);
***** error <2 row column per plane> imadjust ([1:100], [], [0 1 1], 1);
***** error <scalar or 1 row per plane> imadjust ([1:100], [], [], [0; 1]);
***** error <scalar or 1 row per plane> imadjust (rand (5, 5, 3), [], [], [0 1]);
***** error <non-negative floating point> imadjust ([1:100], [0; 1], [], -1);
***** error <be on the range \[0 1]> imadjust ([1:100], [0; 5], []);
***** error <be on the range \[0 1]> imadjust ([1:100], [-2; 1], []);
***** error <be on the range \[0 1]> imadjust ([1:100], [], [0; 4]);
***** error <be on the range \[0 1]> imadjust ([1:100], [], [-2; 1]);
***** error <must be numeric> imadjust (rand (5) > .5);
***** test
 im = [0.01:0.01:1];
 assert (imadjust (im), [0 linspace(0, 1, 98) 1], eps)
 assert (imadjust (im), imadjust (im, stretchlim (im, 0.01), [0; 1], 1))
 assert (imadjust (im, []), imadjust (im, [0; 1], [0; 1], 1))
 assert (imadjust (im, [], []), imadjust (im, [0; 1], [0; 1], 1))
 assert (imadjust (im, [], [.25 .75]), imadjust (im, [0; 1], [.25; .75], 1))
 assert (imadjust (im, [.25; .75], []), imadjust (im, [.25; .75], [0; 1], 1))
***** assert (imadjust (linspace (0, 1), [], [.25 .75]), linspace (.25, .75, 100))
***** assert (imadjust (linspace (0, 1, 100),[1/99; 98/99]),
        [0 linspace(0, 1, 98) 1], eps)
***** shared cm
 cm = [[0:8]' [1:9]' [2:10]'] / 10;
***** assert (imadjust (cm, [0; 1], [0.5; 1]), (cm /2) + .5)
***** assert (imadjust (cm, [0 1], [0.5 1]), (cm /2) + .5)
***** assert (imadjust (cm, [0; 1], [.1 .2 .3; .7 .8 .9]),
        (cm*.6) .+ [.1 .2 .3], eps)
***** assert (imadjust (cm, [.2 .4 .6; .7 .8 .9], [0; 1]),
       [[0 0 linspace(0, 1, 6) 1]' ...
        [0 0 0 linspace(0, 1, 5) 1]' ...
        [0 0 0 0 linspace(0, 1, 4) 1]'], eps)
***** assert (imadjust (cm, [.2 .4 .6; .7 .8 .9], [0 .1 .2; .8 .9 1]),
        [[0 0 linspace(0, .8, 6) .8]' ...
         [.1 .1 .1 linspace(.1, .9, 5) .9]' ...
         [.2 .2 .2 .2 linspace(.2, 1, 4) 1]'], eps)
***** assert (imadjust (cm, [.2 .4 .6; .7 .8 .9], [0 .1 .2; .8 .9 1], [0.5 1 2]),
        [[0 0 0 (((([.3 .4 .5 .6]-.2)/.5).^.5)*.8) .8 .8]' ...
         [.1 .1 .1 linspace(.1, .9, 5) .9]' ...
         [.2 .2 .2 .2 .2  ((((([.7 .8]-.6)/.3).^2).*.8)+.2) 1 1]'], eps*10)
***** test
 im = [-0.4:.1:0.8
        0.0:.1:1.2
        0.1:.1:1.3
       -0.4:.2:2.0];

 ## just clipping
 assert (imadjust (im, [0; 1], [0; 1]),
         [0 0 0 0 (0:.1:.8)
          (0:.1:1) 1 1
          (.1:.1:1) 1 1 1
          0 0 (0:.2:1) 1 1 1 1 1], eps)

 ## clipping and invert
 assert (imadjust (im, [0; 1], [1; 0]),
         [1 1 1 1 (1:-.1:.2)
          (1:-.1:0) 0 0
          (.9:-.1:0) 0 0 0
          1 1 (1:-.2:0) 0 0 0 0 0], eps)

 ## rescale
 assert (imadjust (im, [.2; .7], [.1; .9]),
         [1 1 1 1 1 1 1 2.6 4.2 5.8 7.4 9 9
          1 1 1 2.6 4.2 5.8 7.4 9 9 9 9 9 9
          1 1 2.6 4.2 5.8 7.4 9 9 9 9 9 9 9
          1 1 1 1 4.2 7.4 9 9 9 9 9 9 9]/10, eps)

 ## rescale and invert
 assert (imadjust (im, [.2; .7], [.9; .1]),
         [9 9 9 9 9 9 9 7.4 5.8 4.2 2.6 1 1
          9 9 9 7.4 5.8 4.2 2.6 1 1 1 1 1 1
          9 9 7.4 5.8 4.2 2.6 1 1 1 1 1 1 1
          9 9 9 9 5.8 2.6 1 1 1 1 1 1 1]/10, eps)
***** assert (imadjust (linspace (0, 1), [], [], 2), linspace (0, 1) .^ 2)
***** shared oRGB
 oRGB = zeros (10, 1, 3);
 oRGB(:,:,1) = [0 linspace(0,1,6) 1 1 1]';
 oRGB(:,:,2) = [0 0 linspace(0,1,6) 1 1]';
 oRGB(:,:,3) = [0 0 0 linspace(0,1,6) 1]';
***** assert (imadjust (oRGB, [0; 1], [0; 1]), oRGB)
***** assert (imadjust (oRGB, [.2; .8], [0; 1]),
        reshape ([[0 0 0 1/3 2/3 1 1 1 1 1]'
                  [0 0 0 0 1/3 2/3 1 1 1 1]'
                  [0 0 0 0 0 1/3 2/3 1 1 1]'], [10 1 3]), eps)
***** assert (imadjust (oRGB, [.2; .8], [.1; .9]),
        reshape ([[.1 .1 .1 (1/3)+(.1/3) (2/3)-(.1/3) .9 .9 .9 .9 .9]'
                  [.1 .1 .1 .1 (1/3)+(.1/3) (2/3)-(.1/3) .9 .9 .9 .9]'
                  [.1 .1 .1 .1 .1 (1/3)+(.1/3) (2/3)-(.1/3) .9 .9 .9]'],
                 [10 1 3]), eps)
***** assert (imadjust (oRGB, [.2; .8], [.2; .8]),
        reshape ([[2 2 2 4 6 8 8 8 8 8]'
                  [2 2 2 2 4 6 8 8 8 8]'
                  [2 2 2 2 2 4 6 8 8 8]']/10, [10 1 3]), eps)
***** assert (imadjust (oRGB, [0; 1], [.1 .2 .3; .9 .8 .7]),
        reshape ([[1 1 2.6 4.2 5.8 7.4 9 9 9 9]'
                  [2 2 2 3.2 4.4 5.6 6.8 8 8 8]'
                  [3 3 3 3 3.8 4.6 5.4 6.2 7 7]']/10, [10 1 3]), eps)
***** assert (imadjust (oRGB, [.1 .2 .3; .9 .8 .7], [0; 1]),
        reshape ([[0 0 .125 .375 .625 .875 1 1 1 1]'
                  [0 0 0 0 1/3 2/3 1 1 1 1]'
                  [0 0 0 0 0 .25 .75 1 1 1]'], [10 1 3]), eps*10)
***** assert (imadjust (oRGB, [.1 .2 .3; .9 .8 .7], [.2 0 .4; .5 1 .7 ]),
        reshape ([[.2 .2 .2375 .3125 .3875 .4625 .5 .5 .5 .5]'
                  [0 0 0 0 1/3 2/3 1 1 1 1]'
                  [.4 .4 .4 .4 .4 .475 .625 .7 .7 .7]'], [10 1 3]), eps)
***** test
 img = rand (4, 4, 2, 3, 4);
 adj = zeros (4, 4, 2, 3, 4);
 for p = 1:2
   for q = 1:3
     for r = 1:4
       adj(:,:,p,q,r) = imadjust (img(:,:,p,q,r));
     endfor
   endfor
 endfor
 assert (imadjust (img), adj)
***** test
 img = rand (4, 4, 2, 3, 2);
 adj = zeros (4, 4, 2, 3, 2);
 in  = reshape ([ 3  5  7  9 11 13 15 17 19 21 23 25;
                 97 95 93 91 89 87 85 83 81 79 77 75] / 100, [2 2 3 2]);
 out = reshape ([ 5  7  9 11 14 15 17 19 21 23 25 27;
                 95 93 91 89 87 85 83 81 79 77 75 73] / 100, [2 2 3 2]);
 gamma = reshape (0.6:.1:1.7, [1 2 3 2]);
 for p = 1:2
   for q = 1:3
     for r = 1:2
       adj(:,:,p,q,r) = imadjust (img(:,:,p,q,r), in(:,p,q,r),
                                  out(:,p,q,r), gamma(1,p,q,r));
     endfor
   endfor
 endfor
 assert (imadjust (img, in, out, gamma), adj)
***** test
 in = int16 (1:6);
 assert (imadjust (in), int16 ([-32768 -19661  -6554   6553  19660  32767]))
 assert (imadjust (in, []), in)
***** test
 in = uint8([
  35   1   6  26  19  24
   3  32   7  21  23  25
  31   9   2  22  27  20
   8  28  33  17  10  15
  30   5  34  12  14  16
   4  36  29  13  18  11]);
 out = uint8([
  12   0   0   1   0   0
   0   8   0   0   0   0
   7   0   0   0   2   0
   0   3   9   0   0   0
   6   0  11   0   0   0
   0  13   4   0   0   0]);
 assert (imadjust (in, [.1 .9], [0 1]), out);
***** test
 in = uint8([
  140    4   24  104   76   96
   12  128   28   84   92  100
  124   36    8   88  108   80
   32  112  132   68   40   60
  120   20  136   48   56   64
   16  144  116   52   72   44]);
 out = uint8([
  143    0    0   98   63   88
    0  128    3   73   83   93
  123   13    0   78  103   68
    8  108  133   53   18   43
  118    0  138   28   38   48
    0  148  113   33   58   23]);
 assert (imadjust (in, [.1 .9], [0 1]), out);
***** test
 in_u8 = randi ([0 255], 5, 5, 2, 3, "uint8");
 in_u16 = randi ([0 65535], 5, 5, 2, 3, "uint16");
 in_i16 = randi ([-32768 32767], 5, 5, 2, 3, "int16");
 in_u8_d = im2double (in_u8);
 in_u16_d = im2double (in_u16);
 in_i16_d = im2double (in_i16);

 ## default values
 assert (imadjust (in_u8), im2uint8 (imadjust (in_u8_d)))
 assert (imadjust (in_u16), im2uint16 (imadjust (in_u16_d)))
 assert (imadjust (in_i16), im2int16 (imadjust (in_i16_d)))

 ## single adjustment for all planes
 args = {[.3; .7], [.1; .9], [1.5]};
 assert (imadjust (in_u8, args{:}), im2uint8 (imadjust (in_u8_d, args{:})))
 assert (imadjust (in_u16, args{:}), im2uint16 (imadjust (in_u16_d, args{:})))
 assert (imadjust (in_i16, args{:}), im2int16 (imadjust (in_i16_d, args{:})))

 ## single adjustment for all planes (mixed with some complement)
 args = {reshape([.2 .3 .25 .1 0 .1; .9 .7 .85 .9 1 .8], [2 2 3]),
         reshape([.1 .2 .05 .9 1 .3; .9 .85 .7 .1 0 .9], [2 2 3]),
         reshape([1 .75 1 1.2 1.5 2], [1 2 3])};
 assert (imadjust (in_u8, args{:}), im2uint8 (imadjust (in_u8_d, args{:})))
 assert (imadjust (in_u16, args{:}), im2uint16 (imadjust (in_u16_d, args{:})))
 assert (imadjust (in_i16, args{:}), im2int16 (imadjust (in_i16_d, args{:})))

 ## test use of [] as limit and negative
 args = {[], [.95; 0], 1.25};
 assert (imadjust (in_u8, args{:}), im2uint8 (imadjust (in_u8_d, args{:})))
 assert (imadjust (in_u16, args{:}), im2uint16 (imadjust (in_u16_d, args{:})))
 assert (imadjust (in_i16, args{:}), im2int16 (imadjust (in_i16_d, args{:})))
36 tests, 36 passed, 0 known failure, 0 skipped
[immultiply]
>>>>> /usr/share/octave/packages/image-2.6.1/immultiply.m
***** assert (immultiply (uint8   ([255 50]), uint16  ([300 50])),           uint8  ([255 255]));  # default to first class and truncate
***** assert (immultiply (uint8   ([250 50]), uint16  ([  3  4]), "uint32"), uint32 ([750 200]));  # defining output class works (not in matlab?)
***** assert (immultiply (uint8   ([255 50]),                  4),           uint8  ([255 200]));  # works multiplying by a scalar
***** assert (immultiply (logical ([  1  0]), uint16  ([300 50])),           uint16 ([300   0]));  # output class defaults to whatever input is not logical
***** assert (immultiply (logical ([  1  0]), logical ([  1  1])),           double ([  1   0]));  # tested on matlab for compatibility
5 tests, 5 passed, 0 known failure, 0 skipped
[imdivide]
>>>>> /usr/share/octave/packages/image-2.6.1/imdivide.m
***** assert (imdivide (uint8   ([23 250]), uint8   ([ 2  50])),            uint8   ([ 12   5])); # default to first class
***** assert (imdivide (uint8   ([56 255]), uint8   ([ 0   0])),            uint8   ([255 255])); # dividing by zero works (tested in matlab)
***** assert (imdivide (uint8   ([23 250]), 2),                             uint8   ([ 12 125])); # works subtracting a scalar
***** assert (imdivide (uint8   ([23 250]), uint8   ([ 2  50]), "uint16"),  uint16  ([ 12   5])); # defining output class works (not in matlab)
***** assert (imdivide (logical ([1 1 0 0]), logical ([1 0 1 0])),          double  ([1 Inf 0 NaN])); # dividing logical matrix  (tested in matlab)
***** fail  ("imdivide (uint8   ([23 250]), uint16  ([23 250]))");                                # input needs to have same class
6 tests, 6 passed, 0 known failure, 0 skipped
[psf2otf]
>>>>> /usr/share/octave/packages/image-2.6.1/psf2otf.m
***** test
 psf = rand (6, 1);
 assert (psf2otf (psf), fft (circshift (psf, [-3])));
***** test
 psf = rand (6, 6);
 assert (psf2otf (psf), fft2 (circshift (psf, [-3 -3])));
***** test
 psf = rand (6, 6, 6);
 assert (psf2otf (psf), fftn (circshift (psf, [-3 -3 -3])));
***** test
 psf = rand (7, 1);
 assert (psf2otf (psf), fft (circshift (psf, [-3])));
***** test
 psf = rand (7, 7);
 assert (psf2otf (psf), fft2 (circshift (psf, [-3 -3])));
***** test
 psf = rand (6, 7, 8);
 assert (psf2otf (psf), fftn (circshift (psf, [-3 -3 -4])));
***** test
 psf = rand (6, 1);
 ppsf = [psf; 0];
 assert (psf2otf (psf, 7), fft (circshift (ppsf, [-3])));
***** test
 psf = rand (6, 1);
 ppsf = [[psf; 0] zeros(7, 6)];
 assert (psf2otf (psf, [7 7]), fft2 (circshift (ppsf, [-3 0])));
***** test
 psf = rand (6, 6);
 ppsf = [psf zeros(6, 1)];
 assert (psf2otf (psf, [6 7]), fft2 (circshift (ppsf, [-3 -3])));
***** error <PSF must be numeric and real> psf2otf (complex (rand (16), rand (16)))
***** error <OUTSIZE must be larger than> psf2otf (rand (16), 14)
***** error <OUTSIZE must be larger than> psf2otf (rand (16), [14 14])
***** error <OUTSIZE must be larger than> psf2otf (rand (16), [18])
***** error <OUTSIZE must be larger than> psf2otf (rand (16), [18 14])
14 tests, 14 passed, 0 known failure, 0 skipped
[imsmooth]
>>>>> /usr/share/octave/packages/image-2.6.1/imsmooth.m
***** test
 ## checking Bilateral Filter

 ##  constant image remain the same after Bilateral Filter
 A = uint8(255*ones(128,128));
 B = uint8(imsmooth(A, 'Bilateral', 2, 10));
 assert (A,B);

 ## Bilateral Filter does not smear outlayers
 A = zeros(256,256);
 A(128,128) = 256;
 ## bilateral filter does not smear outlayers
 B = imsmooth(A, 'Bilateral', 2, 10);
 assert (A,B,1.e-140);

 ## When sigma_r is large the filter behaves almost
 ## like the isotropic Gaussian filter

 A0 = fspecial ('gaussian',100,100);
 A = uint8(A0/max(max(A0))*255);
 B1 = imsmooth(A, 'Bilateral', 2, 100);
 B2 = imsmooth(A, 'Gaussian', 2);
 assert (B1,B2);
1 test, 1 passed, 0 known failure, 0 skipped
[normxcorr2]
>>>>> /usr/share/octave/packages/image-2.6.1/normxcorr2.m
***** function offsets = get_max_offsets (c)
  l = find (c == max (c(:)));
  offsets = nthargout (1:ndims (c), @ind2sub, size (c), l);
***** endfunction
***** test
 row_shift = 18;
 col_shift = 20;
 a = randi (255, 30, 30);
 b = a(row_shift-10:row_shift, col_shift-7:col_shift);
 c = normxcorr2 (b, a);
 ## should return exact coordinates
 assert (get_max_offsets (c), {row_shift col_shift});

 ## Even with some small noise, should return exact coordinates
 b = imnoise (b, "gaussian");
 c = normxcorr2 (b, a);
 assert (get_max_offsets (c), {row_shift col_shift});
***** test
 a = rand (10, 10);
 c = normxcorr2 (a(5:7, 6:9), a);
 assert (c(7, 9), 1, eps*2);
!!!!! test failed
ASSERT errors for:  assert (c (7, 9),1,eps * 2)

  Location  |  Observed  |  Expected  |  Reason
     ()           1            1         Abs err 7.7716e-16 exceeds tol 4.4409e-16
***** test
 a = 10 * randn (100, 100);
 auto = normxcorr2 (a, a);
 add_in = normxcorr2 (a, -a);
 assert (auto, -add_in);
***** test
 a = 10 * randn (50, 50);
 b = 10 * randn (100, 100);
 do
   scale = 100 * rand ();
 until (scale != 0)

 assert (max ((normxcorr2 (scale*a,b) .- normxcorr2 (a,b))(:)), 0, 1e-10);
 assert (max ((normxcorr2 (a,scale*b) .- normxcorr2 (a,b))(:)), 0, 1e-10);

 a_shift1 = a .+ scale * ones (size (a));
 b_shift1 = b .+ scale * ones (size (b));
 a_shift2 = a .- scale * ones (size (a));
 b_shift2 = b .- scale * ones (size (b));
 assert (max ((normxcorr2 (a_shift1,b) .- normxcorr2 (a,b))(:)), 0, 1e-10);
 assert (max ((normxcorr2 (a,b_shift1) .- normxcorr2 (a,b))(:)), 0, 1e-10);
 assert (max ((normxcorr2 (a_shift2,b) .- normxcorr2 (a,b))(:)), 0, 1e-10);
 assert (max ((normxcorr2 (a,b_shift2) .- normxcorr2 (a,b))(:)), 0, 1e-10);
***** test
 a = randi (100, 15, 15, 15);
 c = normxcorr2 (a(5:10, 2:6, 3:7), a);
 assert (get_max_offsets (c), {10 6 7});

 a = randi (100, 15, 15, 15);
 c = normxcorr2 (a(5:10, 2:6, 1:1), a);
 assert (get_max_offsets (c), {10 6 1});
***** warning <swapped> normxcorr2 (rand (20), rand (5));
***** error normxcorr2 (rand (5));
***** error normxcorr2 (rand (5), rand (20), 2);
***** test
 a =  [ 252  168   50    1   59;
        114    0    0    0    0] ./ 255;
 b = [    1  171  255  255  255  255  240   71  131  254  255  255  255;
          0  109  254  255  255  233   59    0  131  254  255  255  255;
         76   13  195  253  194   34    0   19  217  255  255  255  255;
        110    0    0    0    0    0    3  181  255  255  255  255  255;
        153    0    0    0    0    2  154  254  255  255  255  255  255]./255;
  c = normxcorr2 (a, b);
 assert (max (imag (c(:))), 0);
9 tests, 8 passed, 0 known failure, 0 skipped
[qtsetblk]
>>>>> /usr/share/octave/packages/image-2.6.1/qtsetblk.m
***** demo
 J=qtsetblk(eye(4),qtdecomp(eye(4)),2,ones(2,2,2))
 % Sets upper-right and lower-left blocks of 2*2 zeros to ones
***** shared A, S
 A=[ 1, 4, 2, 5,54,55,61,62;
     3, 6, 3, 1,58,53,67,65;
     3, 6, 3, 1,58,53,67,65;
     3, 6, 3, 1,58,53,67,65;
    23,42,42,42,99,99,99,99;
    27,42,42,42,99,99,99,99;
    23,22,26,25,99,99,99,99;
    22,22,24,22,99,99,99,99];
 S = qtdecomp (A, 10);
***** test
 R=A;
 vals=zeros(4,4,2);
 vals(:,:,1)=reshape([1:16],4,4);
 vals(:,:,2)=reshape([21:36],4,4);
 R(1:4,1:4)=reshape([1:16],4,4);
 R(5:8,5:8)=reshape([21:36],4,4);
 assert(qtsetblk(A,S,4,vals),R);
***** test
 R=A;
 R(1:4,5:8)=1;
 R(7:8,1:4)=1;
 R(5:6,3:4)=1;
 assert(qtsetblk(A,S,2,ones(2,2,7)),R);
***** test
 R=A;
 R(5:6,1:2)=10;
 assert(qtsetblk(A,S,1,ones(1,1,4)*10),R);
3 tests, 3 passed, 0 known failure, 0 skipped
[impixel]
>>>>> /usr/share/octave/packages/image-2.6.1/impixel.m
***** shared img2d, img3d
 img2d = uint8 (magic (10));
 img3d(:,:,1) = img2d;
 img3d(:,:,2) = img2d + 1;
 img3d(:,:,3) = img2d + 2;
 img3d = uint8 (img3d);

***** assert (impixel (img2d, 2, 2), single ([80 80 80]));
***** assert (impixel (img2d, -2, 2), single ([NA NA NA]));

***** assert (impixel (img2d, [1 10], [1 10]), single ([92 92 92; 59 59 59]));
***** assert (impixel (img3d, [1 10], [1 10]), single ([92 93 94; 59 60 61]));
***** assert (impixel (double (img2d), [1 10], [1 10]), [92 92 92; 59 59 59]);

***** assert (impixel ([1 10], [1 10], img2d, [1 10], [1 10]), single ([92 92 92; 59 59 59]));
***** assert (impixel ([3 12], [-4 12], img2d, [1 10], [1 10]), single ([NA NA NA; 44 44 44]));
***** assert (impixel ([3 5], [-4 3], img2d, [1 10], [1 10]), single ([NA NA NA; NA NA NA]));

 ## the following returns double because it's an indexed image
***** assert (impixel ([3 12], [-4 12], img2d, gray (100), [1 10], [1 10]), [NA NA NA; 4/9 4/9 4/9]);
9 tests, 9 passed, 0 known failure, 0 skipped
[edgetaper]
>>>>> /usr/share/octave/packages/image-2.6.1/edgetaper.m
***** assert (class (edgetaper (rand (100), rand (16))), "double")
***** assert (class (edgetaper (randi (255, 100, "uint8"), rand (16))), "uint8")
2 tests, 2 passed, 0 known failure, 0 skipped
[colfilt]
>>>>> /usr/share/octave/packages/image-2.6.1/colfilt.m
***** demo
 ## Perform moving average filter with a 4x4 window
 A = magic (12)
 colfilt (A, [4 4], "sliding", @mean)
***** test
 A = reshape (1:36, [6 6]);
 assert (colfilt (A, [2 2], [3 3], "sliding", @sum),
         conv2 (A, ones (2), "same"));
1 test, 1 passed, 0 known failure, 0 skipped
[ycbcr2rgb]
>>>>> /usr/share/octave/packages/image-2.6.1/ycbcr2rgb.m
***** assert (ycbcr2rgb (rgb2ycbcr (jet (10))), jet (10), 0.00001);
1 test, 1 passed, 0 known failure, 0 skipped
[fftconv2]
>>>>> /usr/share/octave/packages/image-2.6.1/fftconv2.m
***** test
 a = repmat (1:10, 5);
 b = repmat (10:-1:3, 7);
 assert (fftconv2 (a, b), conv2 (a, b), 1.3e4*eps)
 assert (fftconv2 (b, a), conv2 (b, a), 1.3e4*eps)
 assert (fftconv2 (a, b, "full"), conv2 (a, b, "full"), 1.3e4*eps)
 assert (fftconv2 (b, a, "full"), conv2 (b, a, "full"), 1.3e4*eps)
 assert (fftconv2 (a, b, "same"), conv2 (a, b, "same"), 1e4*eps)
 assert (fftconv2 (b, a, "same"), conv2 (b, a, "same"), 1e4*eps)
 assert (isempty (fftconv2 (a, b, "valid")));
 assert (fftconv2 (b, a, "valid"),  conv2 (b, a, "valid"), 1e4*eps)
***** test
 x = 1:4;
 y = 4:-1:1;
 a = repmat(1:10, 5);
 assert (fftconv2 (x, y, a),          conv2 (x, y, a),          1e4*eps)
 assert (fftconv2 (x, y, a, "full"),  conv2 (x, y, a, "full"),  1e4*eps)
 assert (fftconv2 (x, y, a, "same"),  conv2 (x, y, a, "same"),  1e4*eps)
 assert (fftconv2 (x, y, a, "valid"), conv2 (x, y, a, "valid"), 1e4*eps)
***** demo
 ## Draw a cross
 z = zeros (101, 101);
 z(50, :) = 1;
 z(:, 50) = 1;
 subplot (1, 3, 1)
 imshow (z);
 title ("Original thin cross")

 ## Draw a sinc blob
 b = getheight (strel ("ball", 10, 1));
 subplot (1, 3, 2)
 imshow (b);
 title ("Sync blob")

 ## Convolve the cross with the blob
 fc = real (fftconv2 (z, b, "same"));
 subplot (1, 3, 3)
 imshow (fc, [min(fc(:)) max(fc(:))])
 title ("Convolution in the frequency domain")
2 tests, 2 passed, 0 known failure, 0 skipped
[imcrop]
>>>>> /usr/share/octave/packages/image-2.6.1/imcrop.m
***** test
 a = randi (255, [100 100]);
 rect = [20 30 3 5];
 assert (nthargout ([1 2], @imcrop, a, rect), {a(30:35, 20:23) rect});
 assert (nthargout (2, @imcrop, a, rect), rect);
 assert (nthargout ([3 4], 4, @imcrop, a, rect), {a(30:35, 20:23) rect});
***** test
 rgb = randi (255, [100 100 3]);
 rect = [20 30 3 5];
 assert (nthargout ([1 2], @imcrop, rgb, rect), {rgb(30:35, 20:23,:) rect});
 assert (nthargout (2, @imcrop, rgb, rect), rect);
 assert (nthargout ([3 4], 4, @imcrop, rgb, rect), {rgb(30:35, 20:23,:) rect});
***** test
 a = randi (255, [100 100]);
 rect = [20 30 3 5];
 cmap = jet (255);
 assert (nthargout ([1 2], @imcrop, a, cmap, rect), {a(30:35, 20:23) rect});
 assert (nthargout (2, @imcrop, a, cmap, rect), rect);
 assert (nthargout ([3 4], 4, @imcrop, a, cmap, rect), {a(30:35, 20:23) rect});
***** test
 a = rand (100) > 0.5;
 rect = [20 30 3 5];
 assert (nthargout ([1 2], @imcrop, a, rect), {a(30:35, 20:23) rect});
 assert (nthargout (2, @imcrop, a, rect), rect);
 assert (nthargout ([3 4], 4, @imcrop, a, rect), {a(30:35, 20:23) rect});
***** assert (imcrop (0, [0.5 0.5 0.9 0.9]), 0);
***** assert (imcrop (zeros (5), [1 1 1 1]), zeros (2));
6 tests, 6 passed, 0 known failure, 0 skipped
[qtdecomp]
>>>>> /usr/share/octave/packages/image-2.6.1/qtdecomp.m
***** demo
 full(qtdecomp(eye(8)))
 %It finds 2 big blocks of 0 and it decomposes further where 0 and 1 are mixed.
***** # Test if odd-sized limits split
***** assert(full(qtdecomp(eye(5))), reshape([5,zeros(1,24)],5,5));
***** assert(full(qtdecomp(eye(6))), repmat(reshape([3,zeros(1,8)],3,3),2,2));
***** # Test 'equal' method
***** test
 a=ones(2,2);
 b=[2,0;0,0];
 assert(full(qtdecomp(eye(4))), [a,b;b,a]);
***** shared A, B2, B4, f
 A=[ 1, 4, 2, 5,54,55,61,62;
     3, 6, 3, 1,58,53,67,65;
     3, 6, 3, 1,58,53,67,65;
     3, 6, 3, 1,58,53,67,65;
    23,42,42,42,99,99,99,99;
    27,42,42,42,99,99,99,99;
    23,22,26,25,99,99,99,99;
    22,22,24,22,99,99,99,99];
 B2=[2,0;0,0];
 B4=zeros(4); B4(1,1)=4;
***** test
 R=[ones(4,8); [ones(2),B2;ones(2,4)], B4];
 assert(full(qtdecomp(A)), R);
 assert(full(qtdecomp(A,0)), R);
***** # Test 'threshold' method
***** test
 R=[ones(4,8); [ones(2),B2;B2,ones(2)],B4];
 assert(full(qtdecomp(A,1)), R);
***** test
 R=[[B4,[B2,B2;B2,B2]]; [[ones(2),B2;B2,B2],B4]];
 assert(full(qtdecomp(A,10)), R);
***** test
 R=[[B4,[B2,B2;B2,B2]]; [[B2,B2;B2,B2],B4]];
 assert(full(qtdecomp(A,10,2)), R);

 assert(full(qtdecomp(A,100,[2, 4])), [B4,B4;B4,B4]);
***** test
 f = @(A, c1 = 54, c2 = 0, c3 = 0) y = (A (1, 1, :) != ((c1+c2+c3) * ones (1, 1, size (A, 3))))(:);

 assert(full(qtdecomp(A,f)),[ones(4),B4;ones(4,8)]); 
 assert(full(qtdecomp(A,f,54)),[ones(4),B4;ones(4,8)]);
 assert(full(qtdecomp(A,f,4,40,10)),[ones(4),B4;ones(4,8)]);
***** test
***** # no params
 first_eq=inline("(A(1,1,:)!=(54*ones(1,1,size(A,3))))(:)","A");
 assert(full(qtdecomp(A,first_eq)),[ones(4),B4;ones(4,8)]);
***** test
***** # 1 param
 first_eq=inline("(A(1,1,:)!=(c*ones(1,1,size(A,3))))(:)","A","c");
 assert(full(qtdecomp(A,first_eq,54)),[ones(4),B4;ones(4,8)]);
***** test
***** # 3 params
 first_eq=inline("(A(1,1,:)!=((c1+c2+c3)*ones(1,1,size(A,3))))(:)","A","c1","c2","c3");
 assert(full(qtdecomp(A,first_eq,4,40,10)),[ones(4),B4;ones(4,8)]);
11 tests, 11 passed, 0 known failure, 0 skipped
[imquantize]
>>>>> /usr/share/octave/packages/image-2.6.1/imquantize.m
***** error <LEVELS must be nondecreasing>
  imquantize (rand (5), [3 4 2 5])
***** error <VALUES must be a numeric vector>
  imquantize (rand (5), [1 2 3], "foo")
***** error <VALUES must have 1 element more than LEVELS>
  imquantize (rand (5), [1 2 3 4], 1:6)
***** error <VALUES must have 1 element more than LEVELS>
  imquantize (rand (5), [1 2 3 4], 1:2)
***** test
 img = [-inf 0 10000000; -100000 -3 1/1000000; 5 5 10];
 [q, q_idx] = imquantize (img, 5);
 assert (q, [1 1 2; 1 1 1; 1 1 2])
 assert (q_idx, q)
***** test
 img = [1:10; 11:20; 21:30; 31:40; 41:50; 51:60; 61:70];

 expected_q = [
     0    0    0    0    0    1    1    1    1    1
     1    1    1    1    1    5    5    5    5    5
     5    5    5    5    5   10   10   10   10   10
    20   20   20   20   20   20   20   20   20   20
    30   30   30   30   30   30   30   30   30   30
    30   30   30   30   30   30   30   30   30   30
    15   15   15   15   15   15   15   15   15   15];

 expected_q_idx = [
    1   1   1   1   1   2   2   2   2   2
    2   2   2   2   2   3   3   3   3   3
    3   3   3   3   3   4   4   4   4   4
    5   5   5   5   5   5   5   5   5   5
    6   6   6   6   6   6   6   6   6   6
    6   6   6   6   6   6   6   6   6   6
    7   7   7   7   7   7   7   7   7   7];

 [q, q_idx] = imquantize (img, [5 15 25 30 40 60], [0 1 5 10 20 30 15]);
 assert (q, expected_q)
 assert (q_idx, expected_q_idx)

 [q, q_idx] = imquantize (single (img), [5 15 25 30 40 60],
                          [0 1 5 10 20 30 15]);
 assert (q, expected_q)
 assert (q_idx, expected_q_idx)

 [q, q_idx] = imquantize (uint8 (img), [5 15 25 30 40 60],
                          [0 1 5 10 20 30 15]);
 assert (q, expected_q)
 assert (q_idx, expected_q_idx)

 [q, q_idx] = imquantize (uint8 (img), uint8 ([5 15 25 30 40 60]),
                          [0 1 5 10 20 30 15]);
 assert (q, expected_q)
 assert (q_idx, expected_q_idx)

 [q, q_idx] = imquantize (uint8 (img), uint8 ([5 15 25 30 40 60]),
                          uint8 ([0 1 5 10 20 30 15]));
 assert (q, uint8 (expected_q))
 assert (q_idx, expected_q_idx)
***** test
 img = randi ([0 255], 10, "uint8");
 [q, q_idx] = imquantize (img, [50 100 150 200]);
 assert (class (q), "double")
 assert (class (q_idx), "double")

 [q, q_idx] = imquantize (img, [50 100 150 200], uint16 ([5 7 8 9 2]));
 assert (class (q), "uint16")
 assert (class (q_idx), "double")

 [q, q_idx] = imquantize (img, [50 100 150 200], uint8 ([5 7 8 9 2]));
 assert (class (q), "uint8")
 assert (class (q_idx), "double")
***** test
 img = [1:10; 11:20; 21:30; 31:40; 41:50; 51:60; 61:70].';
 r_idx = reshape (randperm (numel (img)), size (img));

 [quant, quant_idx] = imquantize (img, [5 15 25 30 40 60]);
 [quant_r, quant_r_idx] = imquantize (img(r_idx), [5 15 25 30 40 60]);

 assert (imquantize (img(r_idx), [5 15 25 30 40 60]), quant(r_idx))
 assert (quant_r, quant_r_idx)
8 tests, 8 passed, 0 known failure, 0 skipped
[imsubtract]
>>>>> /usr/share/octave/packages/image-2.6.1/imsubtract.m
***** assert (imsubtract (uint8   ([23 250]), uint8   ([24  50])),            uint8   ([ 0 200])); # default to first class and truncate
***** assert (imsubtract (uint8   ([23 250]), 10),                            uint8   ([13 240])); # works subtracting a scalar
***** assert (imsubtract (uint8   ([23 250]), uint8   ([24  50]), "uint16"),  uint16  ([ 0 200])); # defining output class works (not in matlab)
***** assert (imsubtract (logical ([ 1   0]), logical ([ 1   1])),            double  ([ 0  -1])); # return double for two logical images
***** assert (imsubtract (logical ([ 1   0]), logical ([ 1   1]), "logical"), logical ([ 0   0])); # this is matlab incompatible on purpose
***** error <same class> imsubtract (uint8 ([23 250]), uint16 ([23 250]));
***** warning <signed integer> imsubtract (uint8 ([23 250]), uint8 ([24 255]), "int8");
***** test
 warning ("off", "all");
 assert (imsubtract (uint8 ([23 250]), uint8 ([24 255]), "int8"),
         int8 ([-1 0]))
8 tests, 8 passed, 0 known failure, 0 skipped
[imattributes]
>>>>> /usr/share/octave/packages/image-2.6.1/imattributes.m
***** shared x, map, img, rgb, bw
 [x, map] = imread ("default.img");
 rgb = ind2rgb (x, map);
 img = ind2gray (x, map);
 bw = im2bw (img);
***** test
 h = imshow (img);
 a = imattributes (h);
 assert ([a.("Height (rows)") a.("Width (columns)")], [53 40]);
 assert (a.Class, "uint8");
 assert (a.("Image type"), "intensity");
 assert (a.("Minimum intensity"), uint8 (28));
 assert (a.("Maximum intensity"), uint8 (250));
***** xtest
 h = imshow (rgb);
 a = imattributes (h);
 assert ([a.("Height (rows)") a.("Width (columns)")], [53 40]);
 assert (a.Class, "uint8");
 assert (a.("Image type"), "truecolor");
 assert (isfield (a, "Minimum intensity"), false);
 assert (isfield (a, "Maximum intensity"), false);
!!!!! known failure
ASSERT errors for:  assert (a.Class,"uint8")

  Location  |  Observed  |  Expected  |  Reason
     []         double       uint8       Strings don't match
***** test
 h = imshow (bw);
 a = imattributes (h);
 assert ([a.("Height (rows)") a.("Width (columns)")], [53 40]);
 assert (a.Class, "logical");
 assert (a.("Image type"), "binary");
 assert (isfield (a, "Minimum intensity"), false);
 assert (isfield (a, "Maximum intensity"), false);
***** test
 h = imshow (x, map);
 a = imattributes (h);
 assert ([a.("Height (rows)") a.("Width (columns)")], [53 40]);
 assert (a.Class, "uint8");
 assert (a.("Image type"), "indexed");
 assert (a.("Minimum intensity"), uint8 (0));
 assert (a.("Maximum intensity"), uint8 (55));
***** test
 h = imshow (img);
 a1 = imattributes ();
 a2 = imattributes (h);
 assert (a1, a2);
5 tests, 4 passed, 1 known failure, 0 skipped
[iptnum2ordinal]
>>>>> /usr/share/octave/packages/image-2.6.1/iptnum2ordinal.m
***** assert (strcmp (iptnum2ordinal (1), 'first'));    # simple works
***** assert (strcmp (iptnum2ordinal (21), '21st'));    # after 20, goes stupid
***** assert (strcmp (iptnum2ordinal (100), '100th'));  # use th correctly
***** fail ("iptnum2ordinal (inf)");                    # must be real
***** fail ("iptnum2ordinal (0)");                      # must be positive
***** fail ("iptnum2ordinal (-1)");                     # must be positive
***** fail ("iptnum2ordinal (3.4)");                    # must be integer
7 tests, 7 passed, 0 known failure, 0 skipped
[radon]
>>>>> /usr/share/octave/packages/image-2.6.1/radon.m
***** test
 A = radon(ones(2,2),30);
 assert (A,[0 0 0.608253175473055 2.103325780167649 1.236538105676658 0.051882938682637 0]',1e-10)
1 test, 1 passed, 0 known failure, 0 skipped
[imgradientxy]
>>>>> /usr/share/octave/packages/image-2.6.1/imgradientxy.m
***** test
 A = [0 1 0
      1 1 1
      0 1 0];

 [gxSobel,  gySobel]  = imgradientxy (A);
 [gxSobel2, gySobel2] = imgradientxy (A, "Sobel");
 assert (gxSobel,
         [ 3   0  -3
           4   0  -4
           3   0  -3]);
 assert (gySobel,
         [ 3   4   3
           0   0   0
          -3  -4  -3]);

 ## test default method
 assert(gxSobel, gxSobel2);
 assert(gySobel, gySobel2);

 [gxPrewitt, gyPrewitt] = imgradientxy (A, "Prewitt");
 assert (gxPrewitt,
         [ 2   0  -2
           3   0  -3
           2   0  -2]);
 assert (gyPrewitt,
         [ 2   3   2
           0   0   0
          -2  -3  -2]);

 [gxCd, gyCd] = imgradientxy (A, "CentralDifference");
 assert (gxCd,
         [ 0.5   0.0  -0.5
           0.5   0.0  -0.5
           0.5   0.0  -0.5]);
 assert (gyCd,
         [ 0.5   0.5   0.5
           0     0     0
          -0.5  -0.5  -0.5]);

 [gxId, gyId] = imgradientxy(A, "IntermediateDifference");
 assert (gxId,
         [ 1  -1   0
           0   0  -1
           1  -1   0]);
 assert (gyId,
         [ 1   0   1
          -1   0  -1
           0  -1   0]);
1 test, 1 passed, 0 known failure, 0 skipped
[imlincomb]
>>>>> /usr/share/octave/packages/image-2.6.1/imlincomb.m
***** assert (imlincomb (0.5, uint8 ([255 10]), 0.5, uint8 ([50 20])),           uint8  ([153 15])); # default to first class and truncate
***** assert (imlincomb (0.5, uint8 ([255 10]), 0.5, uint8 ([50 20]), "uint16"), uint16 ([153 15])); # defining output class works
2 tests, 2 passed, 0 known failure, 0 skipped
[rgb2gray]
>>>>> /usr/share/octave/packages/image-2.6.1/rgb2gray.m
***** shared img
 img = zeros (2, 2, 3);
 img(:,:,1) = [1 0; 0 1];
 img(:,:,2) = [0 1; 0 1];
 img(:,:,3) = [0 0; 1 1];
 img = rgb2gray (img);
***** assert ([img(1,1) img(1,2) img(2,1) img(2,2)], [0.29894 0.58704 0.11402 1]);
1 test, 1 passed, 0 known failure, 0 skipped
[bwareafilt]
>>>>> /usr/share/octave/packages/image-2.6.1/bwareafilt.m
***** shared a2d, a3d
 a2d = [1   0   0   0   0   0   1   0   0   1
        1   0   0   1   0   1   0   1   0   1
        1   0   1   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   1   1   1   0   0   0   0
        1   1   0   1   0   0   0   1   0   0
        1   1   0   0   0   0   1   0   1   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   1   1   0   0   1];

 a3d = a2d;
 a3d(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
        1   0   0   1   1   0   0   1   0   0
        0   0   0   1   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   0   1   1   0   0   0   0
        1   1   0   1   0   0   0   0   0   0
        1   0   0   0   0   0   1   0   0   0
        0   1   0   0   0   0   0   0   0   1
        1   1   0   0   0   0   1   0   0   0];

 a3d(:,:,3) = [
        1   0   0   0   0   0   0   0   0   0
        0   1   0   1   1   0   0   1   0   0
        0   0   0   1   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   1
        1   1   0   0   0   0   0   0   0   0];
***** test
 f2d = [0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   1   1   1   0   0   0   0
        1   1   0   1   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];
 assert (bwareafilt (a2d, 2), logical (f2d));
 assert (bwareafilt (a2d, 2, 8), logical (f2d));
 assert (bwareafilt (a2d, 2, 4), logical (f2d));
***** test
 f2d = [1   0   0   0   0   0   1   0   0   0
        1   0   0   0   0   1   0   1   0   0
        1   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   1   1   1   0   0   0   0
        1   1   0   1   0   0   0   1   0   0
        1   1   0   0   0   0   1   0   1   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];
 assert (bwareafilt (a2d, 5), logical (f2d));
 assert (bwareafilt (a2d, 5, 8), logical (f2d));
***** test
 f2d = [0   0   0   0   0   0   1   0   0   1
        0   0   0   1   0   1   0   1   0   1
        0   0   1   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   1   0   0
        0   0   0   0   0   0   1   0   1   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   1   1   0   0   1];
 assert (bwareafilt (a2d, 11, "smallest", 4), logical (f2d));
***** test
 f2d = [1   0   0   0   0   0   1   0   0   0
        1   0   0   0   0   1   0   1   0   0
        1   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0
        0   0   0   1   0   0   0   1   0   0
        0   0   0   0   0   0   1   0   1   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0];
 assert (bwareafilt (a2d, [3 5]), logical (f2d));
 assert (bwareafilt (a2d, [3 5], 8), logical (f2d));
***** test
 f2d = [1   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0
        0   0   0   1   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0];
 assert (bwareafilt (a2d, [3 4], 4), logical (f2d));
 assert (bwareafilt (a2d, [3 4], [0 1 0; 1 1 1; 0 1 0]), logical (f2d));
***** test
 f2d = [1   0   0   0   0   0   1   0   0   1
        1   0   0   1   0   1   0   1   0   1
        1   0   1   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0
        0   0   0   1   0   0   0   1   0   0
        0   0   0   0   0   0   1   0   1   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   1   1   0   0   0];
 assert (bwareafilt (a2d, [2 4]), logical (f2d));
 assert (bwareafilt (a2d, [2 4], 8), logical (f2d));
 assert (bwareafilt (a2d, [2 4], ones (3)), logical (f2d));
***** test
 f3d = [0   0   0   0   0   0   1   0   0   0
        0   0   0   1   0   1   0   1   0   0
        0   0   1   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];

 f3d(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   0   0   1   0   0
        0   0   0   1   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];

 f3d(:,:,3) = [
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   0   0   1   0   0
        0   0   0   1   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];
 assert (bwareafilt (a3d, 2), logical (f3d));
 assert (bwareafilt (a3d, 2, 26), logical (f3d));
 assert (bwareafilt (a3d, 2, ones (3, 3, 3)), logical (f3d));
***** test
 f3d = [0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   1   1   1   0   0   0   0
        1   1   0   1   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];

 f3d(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   0   1   1   0   0   0   0
        1   1   0   1   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];

 f3d(:,:,3) = [
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   0];
 assert (bwareafilt (a3d, 2, 6), logical (f3d));
 assert (bwareafilt (a3d, 2, conndef (3, "minimal")), logical (f3d));
8 tests, 8 passed, 0 known failure, 0 skipped
[lab2single]
>>>>> /usr/share/octave/packages/image-2.6.1/lab2single.m
***** test
 l_max_f = 100 + (25500 / 65280);
 ab_max_f = 127 + (255 / 256);
 cm = [
   -Inf
   Inf
   NaN
   l_max_f
   ab_max_f
   -200
   -129
   -128
   -128+(255/65280)*(0.499)
   -128+(255/65280)*(0.500)
   -128+(255/65280)*(0.501)
   -127
   -1
   0
   (100/65280)*(0.499999)
   (100/65280)*(0.51)
   (100/65280)*(0.500001)
   1
   99
   100
   101
   126
   127
   128
   254
   255
   256
   257];
 cm = repmat (single (cm), [1 3]);
 im2d = reshape (cm, [7 4 3]);
 imnd = permute (im2d, [1 4 3 2]);

 cm_uint8 = uint8 ([
     0    0    0
   255  255  255
   255  255  255
   255  228  228
   255  255  255
     0    0    0
     0    0    0
     0    0    0
     0    0    0
     0    0    0
     0    0    0
     0    1    1
     0  127  127
     0  128  128
     0  128  128
     0  128  128
     0  128  128
     3  129  129
   252  227  227
   255  228  228
   255  229  229
   255  254  254
   255  255  255
   255  255  255
   255  255  255
   255  255  255
   255  255  255
   255  255  255]);

 assert (lab2uint8 (cm), cm_uint8)
 im2d_uint8 = reshape (cm_uint8, [7 4 3]);
 assert (lab2uint8 (im2d), im2d_uint8)
 assert (lab2uint8 (imnd), permute (im2d_uint8, [1 4 3 2]))

 cm_uint16 = uint16 ([
       0      0      0
   65535  65535  65535
   65535  65535  65535
   65535  58468  58468
   65535  65535  65535
       0      0      0
       0      0      0
       0      0      0
       0      0      0
       0      1      1
       0      1      1
       0    256    256
       0  32512  32512
       0  32768  32768
       0  32768  32768
       1  32768  32768
       1  32768  32768
     653  33024  33024
   64627  58112  58112
   65280  58368  58368
   65535  58624  58624
   65535  65024  65024
   65535  65280  65280
   65535  65535  65535
   65535  65535  65535
   65535  65535  65535
   65535  65535  65535
   65535  65535  65535]);

 assert (lab2uint16 (cm), cm_uint16)
 im2d_uint16 = reshape (cm_uint16, [7 4 3]);
 assert (lab2uint16 (im2d), im2d_uint16)
 assert (lab2uint16 (imnd), permute (im2d_uint16, [1 4 3 2]))

 assert (lab2double (cm), double (cm))
 assert (lab2double (im2d), double (im2d))
 assert (lab2double (imnd), double (imnd))
1 test, 1 passed, 0 known failure, 0 skipped
[imfilter]
>>>>> /usr/share/octave/packages/image-2.6.1/imfilter.m
***** test
  img = [
   8   2   6   7   4   3   7   8   4   1
   9   9   1   1   4   7   3   3   8   1
   2   9   8   3   7   6   5   8   6   5
   9   5   9   1   8   2   7   3   5   8
   6   8   7   1   2   2   9   9   9   9
   1   2   7   8   5   5   9   4   3   2
   3   4   7   7   5   9   5   2   7   6
   5   9   4   3   6   4   2   3   7   5
   9   8   6   9   7   6   2   6   4   1
   9   9   2   1   7   3   3   5   6   4];

 expected_corr = [
  46  53  30  34  44  42  40  51  42  19
  48  66  57  42  46  50  59  58  49  34
  48  67  55  54  44  58  50  50  64  39
  44  77  52  43  28  55  57  75  70  50
  29  51  65  51  42  50  60  62  55  42
  23  44  58  59  63  59  55  57  50  36
  36  50  52  56  56  47  48  45  47  39
  51  64  70  62  56  50  40  38  41  31
  58  72  50  49  58  45  41  42  49  28
  27  37  27  21  19  26  16  23  24  17];
 assert (imfilter (img, [0 1 0; 2 1 1; 1 2 2]), expected_corr)

 ## test order of options (and matching with defaults)
 assert (imfilter (img, [0 1 0; 2 1 1; 1 2 2], 0), expected_corr)
 assert (imfilter (img, [0 1 0; 2 1 1; 1 2 2], "corr"), expected_corr)
 assert (imfilter (img, [0 1 0; 2 1 1; 1 2 2], "corr", 0), expected_corr)
 assert (imfilter (img, [0 1 0; 2 1 1; 1 2 2], 0, "corr"), expected_corr)

 expected_conv = [
  21  31  23  22  21  28  29  26  22   6
  47  55  43  43  51  44  49  64  44  24
  56  69  53  34  47  50  57  48  52  37
  38  70  60  56  41  57  54  61  66  44
  46  67  53  48  32  54  59  65  63  46
  28  56  63  50  36  54  58  66  63  47
  20  43  55  62  67  57  52  53  44  28
  42  51  54  61  57  53  44  46  48  39
  53  70  63  50  57  42  38  38  43  33
  53  62  50  54  52  44  38  40  40  20];
 assert (imfilter (img, [0 1 0; 2 1 1; 1 2 2], "conv"), expected_conv)

 ## alternative class
 assert (imfilter (single (img), [0 1 0; 2 1 1; 1 2 2]),
         single (expected_corr))
 assert (imfilter (int8 (img), [0 1 0; 2 1 1; 1 2 2]),
         int8 (expected_corr))
 assert (imfilter (uint8 (img), [0 1 0; 2 1 1; 1 2 2]),
         uint8 (expected_corr))

 assert (imfilter (single (img), [0 1 0; 2 1 1; 1 2 2], "conv"),
         single (expected_conv))
 assert (imfilter (int8 (img), [0 1 0; 2 1 1; 1 2 2], "conv"),
         int8 (expected_conv))
 assert (imfilter (uint8 (img), [0 1 0; 2 1 1; 1 2 2], "conv"),
         uint8 (expected_conv))

***** test
 I = zeros (6);
 I(2:3,2:3) = 1;
 F = zeros (4);
 F(2,2:3) = 1;
 result = [0 0 0 0 0 0
           1 2 1 0 0 0
           1 2 1 0 0 0
           0 0 0 0 0 0
           0 0 0 0 0 0
           0 0 0 0 0 0];
 assert (imfilter (I, F), result)
2 tests, 2 passed, 0 known failure, 0 skipped
[lab2uint16]
>>>>> /usr/share/octave/packages/image-2.6.1/lab2uint16.m
***** test
 cm_uint16 = uint16 ([0 127 128 383 384 65151 65152 65279 65280 65281 65534 65535]);
 cm_uint16 = repmat (cm_uint16(:), [1 3]);
 im2d_uint16 = reshape (cm_uint16, [4 3 3]);
 imnd_uint16 = permute (im2d_uint16, [1 4 3 2]);

 cm_uint8 = uint8 ([0 0 1 1 2 254 255 255 255 255 255 255]);
 cm_uint8 = repmat (cm_uint8(:), [1 3]);
 assert (lab2uint8 (cm_uint16), cm_uint8)
 im2d_uint8 = reshape (cm_uint8, [4 3 3]);
 assert (lab2uint8 (im2d_uint16), im2d_uint8)
 assert (lab2uint8 (imnd_uint16), permute (im2d_uint8, [1 4 3 2]))

 l1 = 100/65280;
 ab1 = 255/65280;
 cm = [
         0  -128
    127*l1  -128+(ab1*127)
    128*l1  -128+(ab1*128)
    383*l1  -128+(ab1*383)
    384*l1  -128+(ab1*384)
  65151*l1  -128+(ab1*65151)
  65152*l1  -128+(ab1*65152)
  65279*l1  -128+(ab1*65279)
       100   127
  65281*l1  -128+(ab1*65281)
  65534*l1  -128+(ab1*65534)
  65535*l1  -128+(ab1*65535)];
 cm(:,3) = cm(:,2);
 im2d = reshape (cm, [4 3 3]);
 imnd = permute (im2d, [1 4 3 2]);

 assert (lab2double (cm_uint16), cm)
 assert (lab2double (im2d_uint16), im2d)
 assert (lab2double (imnd_uint16), imnd)

 assert (lab2single (cm_uint16), single (cm))
 assert (lab2single (im2d_uint16), single (im2d))
 assert (lab2single (imnd_uint16), single (imnd))
1 test, 1 passed, 0 known failure, 0 skipped
[roicolor]
>>>>> /usr/share/octave/packages/image-2.6.1/roicolor.m
***** demo
 roicolor([1:10],2,4);
 % Returns '1' where input values are between 2 and 4 (both included).
***** assert(roicolor([1:10],2,4),logical([0,1,1,1,zeros(1,6)]));
***** assert(roicolor([1,2;3,4],3,3),logical([0,0;1,0]));
***** assert(roicolor([1,2;3,4],[1,4]),logical([1,0;0,1]));
3 tests, 3 passed, 0 known failure, 0 skipped
[col2im]
>>>>> /usr/share/octave/packages/image-2.6.1/col2im.m
***** demo
 ## Divide A using distinct blocks and then reverse the operation
 A = [ 1:10
      11:20
      21:30
      31:40];
 B = im2col (A, [2 5], "distinct")
 C = col2im (B, [2 5], [4 10], "distinct")
***** demo
 ## Get sliding blocks of size from A into columns, calculate the
 ## mean of each block (mean of each column), and reconstruct A
 ## after a median filter.
 A = reshape (1:24, [4 6])
 B = im2col (A, [2 3], "sliding")
 C = mean (B);
 col2im (C, [1 1], [3 4], "sliding")
***** error <BLOCK_TYPE> col2im (ones (10), [5 5], [10 10], "wrong_block_type");
***** error <resize B>   col2im (ones (10), [1 1], [ 7  7], "sliding");
***** error <rows in B>  col2im (ones (10), [3 3], [10 10], "distinct")
***** error <rows in B>  col2im (ones (10), [5 5], [10 11], "distinct");
***** assert (col2im (sum (im2col (magic (10), [3 3], "sliding")), [1 1], [8 8]),
        convn (magic (10), ones (3, 3), "valid"));
***** test
 B = ones (1, (10-2+1)*(7-3+1));
 A = ones ((10-2+1), (7-3+1));
 assert (col2im (B, [2 3], [10 7]), A);

 ## same but different classes
 assert (col2im (int16   (B), [2 3], [10 7]), int16   (A));
 assert (col2im (single  (B), [2 3], [10 7]), single  (A));
 assert (col2im (logical (B), [2 3], [10 7]), logical (A));
***** test
 a = rand (10)(:);
 assert (col2im (a, [1 1], [10 10]), col2im (a, [1 1], [10 10], "sliding"))
***** shared A, B
 v  = [1:10]';
 r  = reshape (1:10, [2 5]);
 B  = [v  v+10  v+20  v+30  v+40  v+50];
 A  = [r    r+30
       r+10 r+40
       r+20 r+50];
 assert (col2im (B, [2 5], [6 10], "distinct"), A);
***** assert (col2im (int16   (B), [2 5], [6 10], "distinct"), int16   (A));
***** assert (col2im (logical (B), [2 5], [6 10], "distinct"), logical (A));
***** assert (col2im (single  (B), [2 5], [6 10], "distinct"), single  (A));
***** test
 a = rand (10, 8);
 b = im2col (a, [5 5], "distinct");
 assert (col2im (b, [5 5], [10 8], "distinct"), a);

 a = rand (8);
 b = im2col (a, [5 5], "distinct");
 assert (col2im (b, [5 5], [8 8], "distinct"), a);
***** shared a, b
 ## Same number of multiple dimensions
 a = rand (10, 10, 10);
 b = im2col (a, [5 5 5], "distinct");
***** assert (col2im (b, [5 5 5], [10 10 10], "distinct"), a);

 ## Different number of dimensions
 a = rand (10, 10, 10);
 b = im2col (a, [5 5], "distinct");
***** assert (col2im (b, [5 5], [10 10 10], "distinct"), a);

 ## Removing padding from multiple dimensions
 a = rand (10, 10, 7);
 b = im2col (a, [5 5 3], "distinct");
***** assert (col2im (b, [5 5 3], [10 10 7], "distinct"), a);

 a = rand (10, 10, 7);
 b = im2col (a, [5 5 5 2], "distinct");
***** assert (col2im (b, [5 5 5 2], [10 10 7], "distinct"), a);
15 tests, 15 passed, 0 known failure, 0 skipped
[regionprops]
>>>>> /usr/share/octave/packages/image-2.6.1/regionprops.m
***** shared bw2d, gray2d, bw2d_over_bb, bw2d_insides
 bw2d = logical ([
  0 1 0 1 1 0
  0 1 1 0 1 1
  0 1 0 0 0 0
  0 0 0 1 1 1
  0 0 1 1 0 1]);

 gray2d = [
  2 4 0 7 5 2
  3 0 4 9 3 7
  0 5 3 4 8 1
  9 2 0 5 8 6
  8 9 7 2 2 5];

 ## For testing overlapping bounding boxes
 bw2d_over_bb = logical ([
  0 1 1 1 0 1 1
  1 1 0 0 0 0 1
  1 0 0 1 1 0 1
  1 0 0 1 1 0 0
  0 0 0 1 1 1 1]);

 ## For testing when there's regions inside regions
 bw2d_insides = logical ([
  0 0 0 0 0 0 0 0
  0 1 1 1 1 1 1 0
  0 1 0 0 0 0 1 0
  0 1 0 1 1 0 1 0
  0 1 0 1 1 0 1 0
  0 1 0 0 0 0 1 0
  0 1 1 1 1 1 1 0
  0 0 0 0 0 0 0 0]);
***** function c = get_2d_centroid_for (idx)
  subs = ind2sub ([5 6], idx);
  m = false ([5 6]);
  m(idx) = true;
  y = sum ((1:5)' .* sum (m, 2) /sum (m(:)));
  x = sum ((1:6)  .* sum (m, 1) /sum (m(:)));
  c = [x y];
***** endfunction
***** assert (regionprops (bw2d, "Area"), struct ("Area", {8; 6}))
***** assert (regionprops (double (bw2d), "Area"), struct ("Area", {14}))
***** assert (regionprops (bwlabel (bw2d, 4), "Area"), struct ("Area", {4; 6; 4}))
***** assert (regionprops (bw2d, "PixelIdxList"),
        struct ("PixelIdxList", {[6; 7; 12; 8; 16; 21; 22; 27]
                                 [15; 19; 20; 24; 29; 30]}))
***** assert (regionprops (bwlabel (bw2d, 4), "PixelIdxList"),
        struct ("PixelIdxList", {[6; 7; 8; 12]
                                 [15; 19; 20; 24; 29; 30]
                                 [16; 21; 22; 27]}))
***** assert (regionprops (bw2d, "PixelList"),
        struct ("PixelList", {[2 1; 2 2; 3 2; 2 3; 4 1; 5 1; 5 2; 6 2]
                              [3 5; 4 4; 4 5; 5 4; 6 4; 6 5]}))
***** assert (regionprops (bwlabel (bw2d, 4), "PixelList"),
        struct ("PixelList", {[2 1; 2 2; 2 3; 3 2]
                              [3 5; 4 4; 4 5; 5 4; 6 4; 6 5]
                              [4 1; 5 1; 5 2; 6 2]}))
***** assert (regionprops (bw2d, gray2d, "PixelValues"),
        struct ("PixelValues", {[4; 0; 4; 5; 7; 5; 3; 7]
                                [7; 5; 2; 8; 6; 5]}))
***** assert (regionprops (bw2d, gray2d, "MaxIntensity"),
        struct ("MaxIntensity", {7; 8}))
***** assert (regionprops (bw2d, gray2d, "MinIntensity"),
        struct ("MinIntensity", {0; 2}))
***** assert (regionprops (bw2d, "BoundingBox"),
        struct ("BoundingBox", {[1.5 0.5 5 3]; [2.5 3.5 4 2]}))
***** assert (regionprops (bw2d, "Centroid"),
        struct ("Centroid", {get_2d_centroid_for([6 7 8 12 16 21 22 27])
                             get_2d_centroid_for([15 19 20 24 29 30])}))
***** test
 props = struct ("Area", {8; 6},
                 "Centroid", {get_2d_centroid_for([6 7 8 12 16 21 22 27])
                              get_2d_centroid_for([15 19 20 24 29 30])},
                 "BoundingBox", {[1.5 0.5 5 3]; [2.5 3.5 4 2]});
 assert (regionprops (bw2d, "basic"), props)
 assert (regionprops (bwconncomp (bw2d, 8), "basic"), props)
 assert (regionprops (bwlabeln (bw2d, 8), "basic"), props)
***** test
 props = struct ("Area", {4; 6; 4},
                 "Centroid", {get_2d_centroid_for([6 7 8 12])
                              get_2d_centroid_for([15 19 20 24 29 30])
                              get_2d_centroid_for([16 21 22 27])},
                 "BoundingBox", {[1.5 0.5 2 3]; [2.5 3.5 4 2]; [3.5 0.5 3 2]});
 assert (regionprops (bwconncomp (bw2d, 4), "basic"), props)
 assert (regionprops (bwlabeln (bw2d, 4), "basic"), props)
***** assert (regionprops (double (bw2d), "basic"),
        struct ("Area", 14,
                "Centroid", get_2d_centroid_for (find (bw2d)),
                "BoundingBox", [1.5 0.5 5 5]), eps*1000)
***** assert (regionprops ([0 0 1], "Centroid").Centroid, [3 1])
***** assert (regionprops ([0 0 1; 0 0 0], "Centroid").Centroid, [3 1])
***** assert (regionprops ([0 1 1], "Centroid").Centroid, [2.5 1])
***** assert (regionprops ([0 1 1; 0 0 0], "Centroid").Centroid, [2.5 1])
***** test
 a = zeros (2, 3, 3);
 a(:, :, 1) = [0 1 0; 0 0 0];
 a(:, :, 3) = a(:, :, 1);
 c = regionprops (a, "centroid");
 assert (c.Centroid, [2 1 2])
***** test
 d1=2; d2=4; d3=6;
 a = ones (d1, d2, d3);
 c = regionprops (a, "centroid");
 assert (c.Centroid, [mean(1:d2), mean(1:d1), mean(1:d3)], eps*1000)
***** test
 a = [0 0 2 2; 3 3 0 0; 0 1 0 1];
 c = regionprops (a, "centroid");
 assert (c(1).Centroid, [3 3])
 assert (c(2).Centroid, [3.5 1])
 assert (c(3).Centroid, [1.5 2])
***** test
***** assert (regionprops (bw2d, gray2d, "WeightedCentroid"),
                     struct ("WeightedCentroid",
                             {sum([2 1; 2 2; 3 2; 2 3; 4 1; 5 1; 5 2; 6 2]
                              .* ([4; 0; 4; 5; 7; 5; 3; 7] / 35))
                              sum([3 5; 4 4; 4 5; 5 4; 6 4; 6 5]
                                  .* ([7; 5; 2; 8; 6; 5] / 33))}))
***** test
 img = zeros (3, 9);
 img(2, 1:9) = 0:0.1:0.8;
 bw = im2bw (img, 0.5);
 props = regionprops (bw, img, "WeightedCentroid");
 ix = 7:9;
 x = sum (img(2,ix) .* (ix)) / sum (img(2,ix));
 assert (props(1).WeightedCentroid(1), x, 10*eps)
 assert (props(1).WeightedCentroid(2), 2, 10*eps)
***** assert (regionprops (bw2d, gray2d, "MeanIntensity"),
        struct ("MeanIntensity", {mean([4 0 5 4 7 5 3 7])
                                  mean([7 5 2 8 6 5])}))
***** assert (regionprops (bwlabel (bw2d, 4), gray2d, "MeanIntensity"),
        struct ("MeanIntensity", {mean([4 0 5 4])
                                  mean([7 5 2 8 6 5])
                                  mean([7 5 3 7])}))
***** assert (regionprops (bw2d, "SubarrayIdx"),
        struct ("SubarrayIdx", {{[1 2 3], [2 3 4 5 6]}
                                {[4 5], [3 4 5 6]}}))
***** assert (regionprops (bwlabel (bw2d, 4), "SubarrayIdx"),
        struct ("SubarrayIdx", {{[1 2 3], [2 3]}
                                {[4 5], [3 4 5 6]}
                                {[1 2], [4 5 6]}}))
***** test
 out = struct ("Image", {logical([1 0 1 1 0; 1 1 0 1 1; 1 0 0 0 0])
                         logical([0 1 1 1; 1 1 0 1])});
 assert (regionprops (bw2d, "Image"), out)
 assert (regionprops (bw2d, gray2d, "Image"), out)
 assert (regionprops (bwlabel (bw2d), "Image"), out)
***** assert (regionprops (bwlabel (bw2d, 4), "Image"),
        struct ("Image", {logical([1 0; 1 1; 1 0])
                          logical([0 1 1 1; 1 1 0 1])
                          logical([1 1 0; 0 1 1])}))
***** test
 out = struct ("Image", {logical([0 1 1 1; 1 1 0 0; 1 0 0 0; 1 0 0 0])
                         logical([1 1 0 0; 1 1 0 0; 1 1 1 1])
                         logical([1 1; 0 1; 0 1])});
 assert (regionprops (bw2d_over_bb, "Image"), out)
 assert (regionprops (bwlabel (bw2d_over_bb), "Image"), out)
***** test
 out = struct ("Image", {logical([1 1 1 1 1 1
                                  1 0 0 0 0 1
                                  1 0 0 0 0 1
                                  1 0 0 0 0 1
                                  1 0 0 0 0 1
                                  1 1 1 1 1 1])
                         logical([1 1; 1 1])});
 assert (regionprops (bw2d_insides, "Image"), out)
 assert (regionprops (bwlabel (bw2d_insides), "Image"), out)
***** test
 l = uint8 ([
   0  0  0  0  0  0
   0  1  1  1  1  0
   0  1  2  2  1  0
   0  1  2  2  1  0
   0  1  1  1  1  0
   0  0  0  0  0  0
 ]);
 assert (regionprops (l, "EulerNumber"),
         struct ("EulerNumber", {0; 1}))

 l = uint8 ([
   0  0  0  0  0  0  0
   0  1  1  1  1  1  0
   0  1  2  2  2  1  0
   0  1  2  3  2  1  0
   0  1  2  2  2  1  0
   0  1  1  1  1  1  0
   0  0  0  0  0  0  0
 ]);
 assert (regionprops (l, "EulerNumber"),
         struct ("EulerNumber", {0; 0; 1}))
***** test
 l = uint8 ([
   0  0  0  0  0  0  0
   0  1  1  1  1  1  0
   0  1  0  0  0  1  0
   0  1  0  1  0  1  0
   0  1  0  0  0  1  0
   0  1  1  1  1  1  0
   0  0  0  0  0  0  0
 ]);
 assert (regionprops (l, "EulerNumber"),
         struct ("EulerNumber", 1))
***** test
 l = uint8 ([
   1  1  1  1  1  1  1
   1  1  2  1  2  2  1
   1  2  1  2  1  2  1
   1  1  2  1  2  1  1
   1  2  1  2  1  2  1
   1  2  2  1  2  1  1
   1  1  1  1  1  1  1
 ]);
 assert (regionprops (l, "EulerNumber"),
         struct ("EulerNumber", {-9; -4}))
***** test
 l = uint8 ([
   1  1  1  1  1  1  1
   1  1  4  1  5  5  1
   1  3  1  4  1  5  1
   1  1  3  1  4  1  1
   1  2  1  3  1  4  1
   1  2  2  1  3  1  1
   1  1  1  1  1  1  1
 ]);
 assert (regionprops (l, "EulerNumber"),
         struct ("EulerNumber", {-9; 1; 1; 1; 1}))
***** test
 l = uint8 ([
   1  1  1  1  1  1  1
   0  1  2  1  2  2  1
   1  2  1  2  1  2  1
   1  1  2  1  2  1  1
   1  2  1  2  1  2  1
   1  2  2  1  2  1  1
   1  1  1  1  1  1  1
 ]);
 filled = {
   logical([
     1  1  1  1  1  1  1
     0  1  1  1  1  1  1
     1  1  1  1  1  1  1
     1  1  1  1  1  1  1
     1  1  1  1  1  1  1
     1  1  1  1  1  1  1
     1  1  1  1  1  1  1
   ]);
   logical([
     0  1  0  1  1
     1  1  1  1  1
     0  1  1  1  0
     1  1  1  1  1
     1  1  0  1  0
   ]);
  };
 assert (regionprops (l, {"FilledImage", "FilledArea"}),
         struct ("FilledImage", filled, "FilledArea", {48; 19}))
***** test
 l = uint8 ([
   0  0  0  0  0  0  0
   0  1  0  1  0  1  0
   0  1  0  1  0  1  0
   0  0  0  0  0  0  0
 ]);
 filled = logical ([
   1  0  1  0  1
   1  0  1  0  1
 ]);
 assert (regionprops (l, {"FilledImage", "FilledArea"}),
         struct ("FilledImage", filled, "FilledArea", 6))

 l = uint8 ([
   2  2  2  2  2  2  2
   2  1  2  1  2  1  2
   2  1  2  1  2  1  2
   2  2  2  2  2  2  2
 ]);
 filled = {
   logical([
     1  0  1  0  1
     1  0  1  0  1
   ]);
   true(4, 7)
 };
 assert (regionprops (l, {"FilledImage", "FilledArea"}),
         struct ("FilledImage", filled, "FilledArea", {6; 28}))
***** test
 l = uint8 ([
   0  0  0  0  0  0  0
   0  1  1  1  1  1  0
   0  1  2  2  2  1  0
   0  1  2  3  2  1  0
   0  1  2  2  2  1  0
   0  1  1  1  1  1  0
   0  0  0  0  0  0  0
 ]);
 filled = {true(5, 5); true(3, 3); true};
 assert (regionprops (l, {"FilledImage", "FilledArea"}),
         struct ("FilledImage", filled, "FilledArea", {25; 9; 1}))
***** test
 l = uint8 ([
   1  1  1  2  0  0
   1  0  2  1  2  0
   1  2  0  1  0  2
   1  2  1  1  0  2
   0  1  2  2  2  2
 ]);
 filled = {
   logical([
     1  1  1  0
     1  1  1  1
     1  1  1  1
     1  1  1  1
     0  1  0  0
   ]);
   logical([
     0  0  1  0  0
     0  1  1  1  0
     1  1  1  1  1
     1  1  1  1  1
     0  1  1  1  1
   ])
 };
 assert (regionprops (l, {"FilledImage", "FilledArea"}),
         struct ("FilledImage", filled, "FilledArea", {16; 18}))
***** test
 bw = false (5, 5, 5);
 bw(2:4, 2:4, [1 5]) = true;
 bw(2:4, [1 5], 2:4) = true;
 bw([1 5], 2:4, 2:4) = true;
 filled = bw;
 filled(2:4, 2:4, 2:4) = true;
 assert (regionprops (bw, {"FilledImage", "FilledArea"}),
         struct ("FilledImage", filled, "FilledArea", 81))
***** test
 l = uint8 ([
   1  1  1  2  0  0
   1  0  2  1  2  0
   1  2  0  1  0  2
   1  2  1  1  0  2
   0  1  2  2  2  2
 ]);
 assert (regionprops (l, {"Extent"}), struct ("Extent", {0.55; 0.44}))
***** test
 bw = logical ([0 0 0; 0 1 0; 0 0 0]);
 assert (regionprops (bw, {"MinorAxisLength", "MajorAxisLength", ...
                           "Eccentricity"}),
         struct ("MajorAxisLength", 4 .* sqrt (1/12),
                 "MinorAxisLength", 4 .* sqrt (1/12),
                 "Eccentricity", 0))
***** test
 a = eye (4);
 t = regionprops (a, "majoraxislength");
 assert (t.MajorAxisLength, 6.4291, 1e-3);
 t = regionprops (a, "minoraxislength");
 assert(t.MinorAxisLength, 1.1547 , 1e-3);
 t = regionprops (a, "eccentricity");
 assert (t.Eccentricity, 0.98374 , 1e-3);
 t = regionprops (a, "orientation");
 assert (t.Orientation, -45);
 t = regionprops (a, "equivdiameter");
 assert (t.EquivDiameter, 2.2568,  1e-3);
***** test
 b = ones (5);
 t = regionprops (b, "majoraxislength");
 assert (t.MajorAxisLength, 5.7735 , 1e-3);
 t = regionprops (b, "minoraxislength");
 assert (t.MinorAxisLength, 5.7735 , 1e-3);
 t = regionprops (b, "eccentricity");
 assert (t.Eccentricity, 0);
 t = regionprops (b, "orientation");
 assert (t.Orientation, 0);
 t = regionprops (b, "equivdiameter");
 assert (t.EquivDiameter, 5.6419,  1e-3);
***** test
 c = [0 0 1; 0 1 1; 1 1 0];
 t = regionprops (c, "minoraxislength");
 assert (t.MinorAxisLength, 1.8037 , 1e-3);
 t = regionprops (c, "majoraxislength");
 assert (t.MajorAxisLength, 4.1633 , 1e-3);
 t = regionprops (c, "eccentricity");
 assert (t.Eccentricity, 0.90128 , 1e-3);
 t = regionprops (c, "orientation");
 assert (t.Orientation, 45);
 t = regionprops (c, "equivdiameter");
 assert (t.EquivDiameter, 2.5231,  1e-3);
***** test
 f = [0 0 0 0; 1 1 1 1; 0 1 1 1; 0 0 0 0];
 t = regionprops (f, "Extrema");
 shouldbe = [0.5  1.5; 4.5  1.5; 4.5 1.5; 4.5 3.5; 4.5 3.5; 1.5 3.5; 0.5 2.5; 0.5  1.5];
 assert (t.Extrema, shouldbe,  eps);
***** test
 bw = false (5);
 bw([8 12 13 14 18]) = true;
 extrema = [2 1; 3 1; 4 2; 4 3; 3 4; 2 4; 1 3; 1 2] + 0.5;
 assert (regionprops (bw, "extrema"), struct ("Extrema", extrema))
***** test
 ext1 = [1 0; 5 0; 6 1; 6 2; 2 3; 1 3; 1 3; 1 0] + 0.5;
 ext2 = [3 3; 6 3; 6 3; 6 5; 6 5; 2 5; 2 5; 2 4] + 0.5;
 assert (regionprops (bw2d, "extrema"), struct ("Extrema", {ext1; ext2}))
***** assert (regionprops (bw2d, "equivDiameter"),
        struct ("EquivDiameter", {sqrt(4*8/pi); sqrt(4*6/pi)}))
***** assert (regionprops (bw2d_over_bb, "equivDiameter"),
        struct ("EquivDiameter", {sqrt(4*7/pi); sqrt(4*8/pi); sqrt(4*4/pi)}))
***** assert (regionprops (bw2d_insides, "equivDiameter"),
        struct ("EquivDiameter", {sqrt(4*20/pi); sqrt(4*4/pi)}))
***** test
 I = zeros (40);
 disk = fspecial ("disk",10);
 disk = disk ./ max (disk(:));
 I(10:30, 10:30) = disk;
 bw = im2bw (I, 0.5);
 props = regionprops (bw, "Perimeter");
 assert (props.Perimeter, 10*4 + (sqrt (2) * 4)*4, eps*100)

 props = regionprops (bwconncomp (bw), "Perimeter");
 assert (props.Perimeter, 10*4 + (sqrt (2) * 4)*4, eps*100)
***** assert (regionprops (bw2d, "Perimeter"),
        struct ("Perimeter", {(sqrt (2)*6 + 4); (sqrt (2)*3 + 4)}), eps*10)
***** assert (regionprops (bw2d_insides, "Perimeter"),
        struct ("Perimeter", {20; 4}))
***** assert (regionprops (bwconncomp (bw2d_insides), "Perimeter"),
        struct ("Perimeter", {20; 4}))
***** assert (regionprops ([1 0 1; 1 0 1], "Area"), struct ("Area", 4))
***** assert (regionprops ([1 0 2; 1 1 2], "Area"), struct ("Area", {3; 2}))
***** assert (regionprops ([1 0 3; 1 1 3], "Area"), struct ("Area", {3; 0; 2}))
***** assert (size (regionprops ([1 0 0; 0 0 2], "Area")), [2, 1])
***** error <L must be non-negative integers> regionprops ([1 -2   0 3])
***** error <L must be non-negative integers> regionprops ([1  1.5 0 3])
***** test
 im = rand (5);

 ## First do this so we get a list of all supported properties and don't
 ## have to update the list each time.
 bw = false (5);
 bw(13) = true;
 props = regionprops (bw, im, "all");
 all_props = fieldnames (props);

 bw = false (5);
 props = regionprops (bw, im, "all");
 assert (size (props), [0 1])
 assert (sort (all_props), sort (fieldnames (props)))
***** test
 im = rand (5);

 ## First do this so we get a list of all supported properties and don't
 ## have to update the list each time.
 labeled = zeros (5);
 labeled(13) = 1;
 props = regionprops (labeled, im, "all");
 all_props = fieldnames (props);

 labeled = zeros (5);
 props = regionprops (labeled, im, "all");
 assert (size (props), [0 1])
 assert (sort (all_props), sort (fieldnames (props)))
***** test
 im = rand (5);

 ## First do this so we get a list of all supported properties and don't
 ## have to update the list each time.
 bw = false (5);
 bw(13) = true;
 props = regionprops (bwconncomp (bw), im, "all");
 all_props = fieldnames (props);

 bw = false (5);
 props = regionprops (bwconncomp (bw), im, "all");
 assert (size (props), [0 1])
 assert (sort (all_props), sort (fieldnames (props)))
***** warning <ignoring perimeter, extrema properties for non 2 dimensional image>
        regionprops (rand (5, 5, 5) > 0.5, {"perimeter", "extrema"});
***** warning <ignoring minintensity, weightedcentroid properties due to missing grayscale image>
        regionprops (rand (5, 5) > 0.5, {"minintensity", "weightedcentroid"});
***** error <L must be non-negative integers only>
      regionprops ([0 -1 3 4; 0 -1 3 4])
***** error <L must be non-negative integers only>
      regionprops ([0 1.5 3 4; 0 1.5 3 4])
***** error <L must be non-negative integers only>
      regionprops (int8 ([0 -1 3 4; 0 -1 3 4]))
***** error <not yet implemented> regionprops (rand (5, 5) > 0.5, "ConvexArea")
***** error <not yet implemented> regionprops (rand (5, 5) > 0.5, "ConvexHull")
***** error <not yet implemented> regionprops (rand (5, 5) > 0.5, "ConvexImage")
***** error <not yet implemented> regionprops (rand (5, 5) > 0.5, "Solidity")
75 tests, 75 passed, 0 known failure, 0 skipped
[im2int16]
>>>>> /usr/share/octave/packages/image-2.6.1/im2int16.m
***** assert (im2int16 (int16 ([-2 2 3])),    int16 ([-2 2 3]));
***** assert (im2int16 (uint16 ([0 65535])),  int16 ([-32768 32767]));
***** assert (im2int16 ([false true]),        int16 ([-32768 32767]));
***** assert (im2int16 ([true false]),        int16 ([32767 -32768]));
***** assert (im2int16 (uint8 ([0 127 128 255])), int16 ([-32768 -129 128 32767]));
***** assert (im2int16 ([0 1.4/65535 1.5/65535 2/65535 1]), int16 ([-32768 -32767 -32766 -32766 32767]));
***** assert (im2int16 ([0 0.5 1]),  int16 ([-32768 0 32767]));
***** assert (im2int16 ([-1 0 1 2]), int16 ([-32768 -32768 32767 32767]));
***** error im2int16 ([1 2], "indexed");
9 tests, 9 passed, 0 known failure, 0 skipped
[im2single]
>>>>> /usr/share/octave/packages/image-2.6.1/im2single.m
***** assert (im2single (single ([1 2 3])), single ([1 2 3]));
***** assert (im2single ([1 2 3]), single ([1 2 3]));
***** assert (im2single (uint8 ([0 127 128 255])), single ([0 127/255 128/255 1]));
***** assert (im2single (uint16 ([0 127 128 65535])), single ([0 127/65535 128/65535 1]));
***** assert (im2single (int16 ([-32768 -32767 -32766 32767])), single ([0 1/65535 2/65535 1]));
***** assert (im2single (uint8 ([0 1 255]), "indexed"), single ([1 2 256]));
***** assert (im2single (uint16 ([0 1 2557]), "indexed"), single ([1 2 2558]));
***** assert (im2single ([3 25], "indexed"), single ([3 25]));
***** error <indexed> im2single ([0 1 2], "indexed");
***** error <indexed> im2single (int16 ([17 8]), "indexed");
***** error <indexed> im2single (int16 ([-7 8]), "indexed");
***** error <indexed> im2single ([false true], "indexed");
12 tests, 12 passed, 0 known failure, 0 skipped
[findbounds]
>>>>> /usr/share/octave/packages/image-2.6.1/findbounds.m
***** test
 im = checkerboard ();
 theta = pi/6;
 T = maketform ('affine', [cos(theta) -sin(theta); ...
                           sin(theta) cos(theta); 0 0]);
 inbnd = [0 0; 1 1];
 outbnd = findbounds (T, inbnd);
 diag = 2^.5;
 ang = pi/4;
 assert (diff (outbnd(:,1)), diag * abs (cos (theta - ang)), eps)
 assert (diff (outbnd(:,2)), diag * abs (cos (theta - ang)), eps)
1 test, 1 passed, 0 known failure, 0 skipped
[imclearborder]
>>>>> /usr/share/octave/packages/image-2.6.1/imclearborder.m
***** test
 a = logical ([
    0   1   0   0   1   0   0   0   0   1
    1   0   0   0   0   1   0   0   0   0
    0   1   0   0   0   0   0   0   0   0
    1   0   1   0   1   0   1   0   0   1
    0   0   0   0   0   0   0   1   1   0
    0   0   1   0   0   1   0   1   0   0
    0   1   0   1   0   1   1   0   0   0
    0   0   0   1   0   0   0   0   0   0
    0   0   0   1   0   1   1   0   0   0
    0   0   0   1   1   0   0   0   1   0]);

 a4 = logical ([
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   1   0   0   0   0
    0   1   0   0   0   0   0   0   0   0
    0   0   1   0   1   0   1   0   0   0
    0   0   0   0   0   0   0   1   1   0
    0   0   1   0   0   1   0   1   0   0
    0   1   0   0   0   1   1   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   1   1   0   0   0
    0   0   0   0   0   0   0   0   0   0]);

 a8 = logical ([
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   1   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0]);

 assert (imclearborder (a, 4), a4)
 assert (imclearborder (a, [0 1 0; 1 1 1; 0 1 0]), a4)
 assert (imclearborder (a), a8)
 assert (imclearborder (a, 8), a8)
 assert (imclearborder (a, ones (3)), a8)
***** test
 a = false (5, 5, 3);
 a(2:4,2:4,:) = true;
 assert (imclearborder (a, 4), a)

 a(1,2) = true;
 a4 = a;
 a4(:,:,1) = false;
 assert (imclearborder (a, 4), a4)
2 tests, 2 passed, 0 known failure, 0 skipped
[@strel/strel]
>>>>> /usr/share/octave/packages/image-2.6.1/@strel/strel.m
***** test
 shape  = logical ([0 0 0 1]);
 assert (getnhood (strel (shape)), shape);
 assert (getnhood (strel ("arbitrary", shape)), shape);

 height = [0 0 0 3];
 assert (getnhood (strel ("arbitrary", shape, height)), shape);
 assert (getheight (strel ("arbitrary", shape, height)), height);
***** test
 shape = logical ([0 0 1]);
 height = [-2 1 3];  ## this works for matlab compatibility
 assert (getnhood (strel ("arbitrary", shape, height)), shape);
 assert (getheight (strel ("arbitrary", shape, height)), height);
***** test
 shape = logical ([0 0 0 1 0 0 0
                   0 1 1 1 1 1 0
                   0 1 1 1 1 1 0
                   1 1 1 1 1 1 1
                   0 1 1 1 1 1 0
                   0 1 1 1 1 1 0
                   0 0 0 1 0 0 0]);
 height = [ 0.00000   0.00000   0.00000   0.00000   0.00000   0.00000   0.00000
            0.00000   0.33333   0.66667   0.74536   0.66667   0.33333   0.00000
            0.00000   0.66667   0.88192   0.94281   0.88192   0.66667   0.00000
            0.00000   0.74536   0.94281   1.00000   0.94281   0.74536   0.00000
            0.00000   0.66667   0.88192   0.94281   0.88192   0.66667   0.00000
            0.00000   0.33333   0.66667   0.74536   0.66667   0.33333   0.00000
            0.00000   0.00000   0.00000   0.00000   0.00000   0.00000   0.00000];
 assert (getnhood (strel ("ball", 3, 1)), shape);
 assert (getheight (strel ("ball", 3, 1)), height, 0.0001);
***** test
 shape = logical ([0 0 0 1 0 0 0
                   0 0 1 1 1 0 0
                   0 1 1 1 1 1 0
                   1 1 1 1 1 1 1
                   0 1 1 1 1 1 0
                   0 0 1 1 1 0 0
                   0 0 0 1 0 0 0]);
 assert (getnhood (strel ("diamond", 3)), shape);
***** test
 shape = logical ([0 0 0 1 0 0 0
                   0 1 1 1 1 1 0
                   0 1 1 1 1 1 0
                   1 1 1 1 1 1 1
                   0 1 1 1 1 1 0
                   0 1 1 1 1 1 0
                   0 0 0 1 0 0 0]);
 assert (getnhood (strel ("disk", 3, 0)), shape);
***** test
 shape = logical ([1 1 1]);
 assert (getnhood (strel ("line", 3.9, 20.17)), shape);
 shape = logical ([0 0 1
                   0 1 0
                   1 0 0]);
 assert (getnhood (strel ("line", 3.9, 20.18)), shape);
 shape = logical ([1 0 0 0 0 0 0 0 0
                   0 1 0 0 0 0 0 0 0
                   0 0 1 0 0 0 0 0 0
                   0 0 1 0 0 0 0 0 0
                   0 0 0 1 0 0 0 0 0
                   0 0 0 0 1 0 0 0 0
                   0 0 0 0 0 1 0 0 0
                   0 0 0 0 0 0 1 0 0
                   0 0 0 0 0 0 1 0 0
                   0 0 0 0 0 0 0 1 0
                   0 0 0 0 0 0 0 0 1]);
 assert (getnhood (strel ("line", 14, 130)), shape);
***** test
 se = strel ("octagon", 0);
 seq = getsequence (se);
 assert (getnhood (se), true (1));
 assert (getnhood (seq(1)), true (1));

 se = strel ("octagon", 3);
 seq = getsequence (se);
 shape = logical ([0 0 1 1 1 0 0
                   0 1 1 1 1 1 0
                   1 1 1 1 1 1 1
                   1 1 1 1 1 1 1
                   1 1 1 1 1 1 1
                   0 1 1 1 1 1 0
                   0 0 1 1 1 0 0]);
 assert (getnhood (se), shape);
 assert (size (seq), [4 1]);

 templ1 = logical ([0 0 0; 1 1 1; 0 0 0]);
 templ2 = logical ([0 1 0; 0 1 0; 0 1 0]);
 templ3 = logical ([1 0 0; 0 1 0; 0 0 1]);
 templ4 = logical ([0 0 1; 0 1 0; 1 0 0]);
 assert ({getnhood(seq(1)) getnhood(seq(2)) getnhood(seq(3)) getnhood(seq(4))},
         {templ1 templ2 templ3 templ4});

 seq = getsequence (strel ("octagon", 21));
 assert (size (seq), [28 1]);
 assert (arrayfun (@(x) getnhood (seq(x)), 1:4:25, "UniformOutput", false),
         repmat ({templ1}, 1, 7));
 assert (arrayfun (@(x) getnhood (seq(x)), 2:4:26, "UniformOutput", false),
         repmat ({templ2}, 1, 7));
 assert (arrayfun (@(x) getnhood (seq(x)), 3:4:27, "UniformOutput", false),
         repmat ({templ3}, 1, 7));
 assert (arrayfun (@(x) getnhood (seq(x)), 4:4:28, "UniformOutput", false),
         repmat ({templ4}, 1, 7));
***** test
 shape = logical ([1 1 0]');
 assert (getnhood (strel ("pair", [-1 0])), shape);
 shape = logical ([1 0 0 0 0 0 0
                   0 0 0 1 0 0 0
                   0 0 0 0 0 0 0]);
 assert (getnhood (strel ("pair", [-1 -3])), shape);
 shape = logical ([0 0 0 0 0 0 0
                   0 0 0 0 0 0 0
                   0 0 0 1 0 0 0
                   0 0 0 0 0 0 0
                   0 0 0 0 0 0 1]);
 assert (getnhood (strel ("pair", [2 3])), shape);
***** test
 assert (getnhood (strel ("rectangle", [10 5])), true (10, 5));
 assert (getnhood (strel ("square", 5)), true (5));
***** shared se, seq
 se = strel ("square", 5);
 seq = getsequence (se);
 assert (class (se(1)),  "strel")
 assert (class (se(1,1)),"strel")
 assert (class (seq),    "strel")
 assert (class (seq(1)), "strel")
 assert (class (seq(2)), "strel")
 assert (numel (se), 1)
 assert (numel (seq), 2)
 assert (getnhood (seq(1)), true (5, 1))
 assert (getnhood (seq(2)), true (1, 5))
 assert (size (se),  [1 1])
 assert (size (seq), [2 1])
 assert (isscalar (se),  true)
 assert (isscalar (seq), false)
***** error <index out of bounds> se(2);
***** error <index out of bounds> seq(3);
!!!!! error failed.
Expected <index out of bounds>, but got <se(3): out of bound 2>

***** test
 se = strel ("arbitrary", [1 0 0; 1 1 0; 0 1 0], [2 0 0; 3 1 0; 0 3 0]);
 ref = reflect (se);
 assert (getnhood (ref), logical([0 1 0; 0 1 1; 0 0 1]));
 assert (getheight (ref), [0 3 0; 0 1 3; 0 0 2]);
***** error strel()
***** error strel("nonmethodthing", 2)
***** error strel("arbitrary", "stuff")
***** error strel("arbitrary", [0 0 1], [2 0 1; 4 5 1])
***** error strel("arbitrary", [0 0 1], "stuff")
***** error strel("ball", -3, 1)
***** error strel("diamond", -3)
***** error strel("disk", -3)
***** error strel("line", 0, 45)
***** error <positive integer multiple of 3> strel("octagon", 3.5)
***** error <positive integer multiple of 3> strel("octagon", 4)
***** error <positive integer multiple of 3> strel("octagon", -1)
***** error strel("pair", [45 67 90])
***** error strel("rectangle", 2)
***** error strel("rectangle", [2 -5])
***** error strel("square", [34 1-2])
28 tests, 27 passed, 0 known failure, 0 skipped
[imopen]
>>>>> /usr/share/octave/packages/image-2.6.1/imopen.m
***** shared in, out
 in =  [ 0   0   0   1   1   1   0   0   1   1
         0   1   0   1   1   1   0   0   0   1
         1   1   1   1   1   0   0   0   0   0
         0   1   1   1   1   0   0   0   0   0
         0   0   0   1   0   0   0   0   1   0
         0   0   0   0   0   0   0   1   1   1
         0   0   0   0   1   0   1   0   1   0
         0   0   0   1   1   1   1   1   0   0
         0   0   0   0   1   1   1   0   0   0
         0   0   0   1   1   1   0   0   0   0];

 out = [ 0   0   0   1   1   1   0   0   0   0
         0   0   0   1   1   1   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0];
***** assert (imopen (logical (in), ones (3)), logical (out));

 out = [80   80    1    8   15   51   51   51   51   40
        80   80    7    8   15   54   55   55   55   40
         4    7    7    8   15   54   55   55   55   40
        17   17   17    7    3   54   55   55   55   28
        17   17   17    2    9   54   54   54   52   33
        17   17   17   29   29   29   29   26   33   33
         5    5   13   29   29   29   30   32   39   39
         6    6   13   29   29   29   30   32   39   39
        10   12   77   77   77   35   35   35   39   39
        10   12   77   77   77   35   35   35   27   27];
***** assert (imopen (magic (10), ones (3)), out);
***** assert (imopen (uint8 (magic (10)), strel ("square", 3)), uint8 (out));

 ## using a se that will be decomposed in 2 pieces
 out =[ 1    1    1    8   15   40   40   40   40   40
        4    4    4    8   15   40   40   40   40   40
        4    4    4    8   15   40   40   40   40   40
        5    5    5    3    3   28   28   28   28   28
        5    5    5    2    9   28   28   28   28   28
        5    5   13   26   26   26   26   26   26   26
        5    5   13   29   29   29   29   29   27   27
        6    6   13   29   29   29   29   29   27   27
        6    6   13   29   29   29   29   29   27   27
        6    6   13   29   29   29   29   29   27   27];
***** assert (imopen (magic (10), ones(5)), out);

 ## using a weird non-symmetric and even-size se
 out =[ 7    7    1    8   15   55   51   51   41   40
        7    7    7    8   16   55   55   55   51   41
        4    9    7    7   16   54   55   54   55   47
       25   25    9    9    3   52   54   52   54   28
       25   24   25    2    9   33   52   34   52   34
       17   24   29   31   29   30   33   26   33   34
       17    5   29   31   31   31   30   32   39   33
       10    6   13   35   35   29   31   32   45   39
       10   12   77   36   36   35   35   31   45   45
       11   12   77   77   77   36   36   35   27   45];
***** assert (imopen (magic (10), [1 0 0 0; 1 1 1 0; 0 1 0 1]), out);
5 tests, 5 passed, 0 known failure, 0 skipped
[bweuler]
>>>>> /usr/share/octave/packages/image-2.6.1/bweuler.m
***** demo
 A=zeros(9,10);
 A([2,5,8],2:9)=1;
 A(2:8,[2,9])=1
 bweuler(A)
 # Euler number (objects minus holes) is 1-2=-1 in an 8-like object
***** test
 A=zeros(10,10);
 A(2:9,3:8)=1;
 A(4,4)=0;
 A(8,8)=0; # not a hole
 A(6,6)=0;
 assert(bweuler(A),-1);
***** test
 A=zeros(10,10);
 A(2:4,2:4)=1;
 A(5:8,5:8)=1;
 assert(bweuler(A,4),2);
 assert(bweuler(A,8),1);
 assert(bweuler(A),1);
***** error <2 dimensions> bweuler (true (5, 5, 1, 5))
3 tests, 3 passed, 0 known failure, 0 skipped
[im2uint16]
>>>>> /usr/share/octave/packages/image-2.6.1/im2uint16.m
***** assert (im2uint16 (uint16 ([1 2 3])), uint16 ([1 2 3]));
***** assert (im2uint16 (uint8 ([0 127 128 255])), uint16 ([0 32639 32896 65535]));
***** assert (im2uint16 ([0 0.5 1]), uint16 ([0 32768 65535]));
***** assert (im2uint16 ([0 1/65535 1.4/65535 1.5/65535 1]), uint16 ([0 1 1 2 65535]));
***** assert (im2uint16 ([1 2]), uint16 ([65535 65535]));
***** assert (im2uint16 ([-1 0 0.5 1]), uint16 ([0 0 32768 65535]));
***** assert (im2uint16 (int16 ([-32768 -1 0 32768])), uint16 ([0 32767 32768 65535]));
***** assert (im2uint16 ([false true]), uint16 ([0 65535]));
***** assert (im2uint16 ([true false]), uint16 ([65535 0]));
***** assert (im2uint16 (uint8 ([3 25]), "indexed"), uint16 ([3 25]));
***** assert (im2uint16 ([1 3 25], "indexed"), uint16 ([0 2 24]));
***** error <indexed> im2uint16 ([0 1 2], "indexed");
***** error <indexed> im2uint16 (int16 ([17 8]), "indexed");
***** error <indexed> im2uint16 (int16 ([-7 8]), "indexed");
***** error <indexed> im2uint16 ([false true], "indexed");
***** error <range of values> im2uint16 (65537, "indexed");
16 tests, 16 passed, 0 known failure, 0 skipped
[imrotate]
>>>>> /usr/share/octave/packages/image-2.6.1/imrotate.m
***** test
 a = reshape (1:18, [2 3 3]);

 a90(:,:,1) = [5 6; 3 4; 1 2];
 a90(:,:,2) = a90(:,:,1) + 6;
 a90(:,:,3) = a90(:,:,2) + 6;

 a180(:,:,1) = [6 4 2; 5 3 1];
 a180(:,:,2) = a180(:,:,1) + 6;
 a180(:,:,3) = a180(:,:,2) + 6;

 am90(:,:,1) = [2 1; 4 3; 6 5];
 am90(:,:,2) = am90(:,:,1) + 6;
 am90(:,:,3) = am90(:,:,2) + 6;

 assert (imrotate (a,    0), a);
 assert (imrotate (a,   90), a90);
 assert (imrotate (a,  -90), am90);
 assert (imrotate (a,  180), a180);
 assert (imrotate (a, -180), a180);
 assert (imrotate (a,  270), am90);
 assert (imrotate (a, -270), a90);
 assert (imrotate (a,  360), a);
1 test, 1 passed, 0 known failure, 0 skipped
[imcomplement]
>>>>> /usr/share/octave/packages/image-2.6.1/imcomplement.m
***** assert (imcomplement (10), -9);
***** assert (imcomplement (single (10)), single (-9));
***** assert (imcomplement (0.2), 0.8);
***** assert (imcomplement (uint8 (0)), uint8 (255));
***** assert (imcomplement (uint8 (1)), uint8 (254));
***** assert (imcomplement (uint16 (0)), uint16 (65535));
***** assert (imcomplement (uint16 (1)), uint16 (65534));
***** assert (imcomplement (int8 (-128)), int8 ( 127));
***** assert (imcomplement (int8 ( 127)), int8 (-128));
***** assert (imcomplement (int16 (-1)), int16 ( 0));
***** assert (imcomplement (int16 ( 0)), int16 (-1));
***** assert (imcomplement (int16 ( 1)), int16 (-2));
***** assert (imcomplement ([true false true]), [false true false])
***** error <must be an image> imcomplement ("not an image")
14 tests, 14 passed, 0 known failure, 0 skipped
[immse]
>>>>> /usr/share/octave/packages/image-2.6.1/immse.m
***** error <same size> immse (rand (10), rand (12))
***** error <same class> immse (uint8 ([0 1 2 3]), uint16 ([0 1 2 3]))
***** error <same class> immse (double ([0 1 2 3]), single ([0 1 2 3]))
***** assert (immse (magic (5), magic (5)), 0)
***** assert (immse (single (magic (5)), single (magic (5))), single (0))
***** assert (immse (uint8 (magic (5)), uint8 (magic (5))), 0)
6 tests, 6 passed, 0 known failure, 0 skipped
[im2uint8]
>>>>> /usr/share/octave/packages/image-2.6.1/im2uint8.m
***** assert (im2uint8 (uint8 ([1 2 3])), uint8 ([1 2 3]));
***** assert (im2uint8 (uint16 ([0 65535])), uint8 ([0 255]));
***** assert (im2uint8 ([0 0.5 1]), uint8 ([0 128 255]));
***** assert (im2uint8 ([1 2]), uint8 ([255 255]));
***** assert (im2uint8 ([-1 0 0.5 1 2]), uint8 ([0 0 128 255 255]));
***** assert (im2uint8 (int16 ([-32768 0 32768])), uint8 ([0 128 255]));
***** assert (im2uint8 ([false true]), uint8 ([0 255]));
***** assert (im2uint8 ([true false]), uint8 ([255 0]));
***** assert (im2uint8 ([1 256], "indexed"), uint8 ([0 255]));
***** assert (im2uint8 ([3 25], "indexed"), uint8 ([2 24]));
***** assert (im2uint8 (uint16 ([3 25]), "indexed"), uint8 ([3 25]));
***** error <indexed> im2uint8 ([0 1 2], "indexed");
***** error <indexed> im2uint8 (int16 ([17 8]), "indexed");
***** error <indexed> im2uint8 (int16 ([-7 8]), "indexed");
***** error <indexed> im2uint8 ([false true], "indexed");
***** error <range of values> im2uint8 (uint16 (256), "indexed");
***** error <range of values> im2uint8 (257, "indexed");
17 tests, 17 passed, 0 known failure, 0 skipped
[rgb2xyz]
>>>>> /usr/share/octave/packages/image-2.6.1/rgb2xyz.m
***** assert (rgb2xyz ([0 0 0]), [0, 0, 0], 1e-3)
***** assert (rgb2xyz ([1 0 0]), [0.4125, 0.2127, 0.0193], 1e-3)
***** assert (rgb2xyz ([1 1 0]), [0.7700, 0.9278, 0.1385], 1e-3)
***** assert (rgb2xyz ([0 1 0]), [0.3576, 0.7152, 0.1192], 1e-3)
***** assert (rgb2xyz ([0 1 1]), [0.5380, 0.7873, 1.0694], 1e-3)
***** assert (rgb2xyz ([0 0 1]), [0.1804, 0.0722, 0.9502], 1e-3)
***** assert (rgb2xyz ([1 0 1]), [0.5929, 0.2848, 0.9696], 1e-3)
***** assert (rgb2xyz ([1 1 1]), [0.9505, 1.0000, 1.0888], 1e-3)
***** assert (rgb2xyz ([0.5 0.5 0.5]), [0.2034, 0.2140, 0.2330], 1e-3)
***** assert (rgb2xyz ([0.75 0 0]), [0.2155, 0.1111, 0.0101], 1e-3)
***** assert (rgb2xyz ([0.5 0 0]), [0.0883, 0.0455, 0.0041], 1e-3)
***** assert (rgb2xyz ([0.25 0 0]), [0.0210, 0.0108, 0.0010], 1e-3)
***** assert (rgb2xyz ([1 0.5 0.5]), [0.5276, 0.3812, 0.2482], 1e-3)
***** assert (rgb2xyz ([1.5 1 1]), [1.5845, 1.3269, 1.1185], 1e-3)
***** test
 rgb_map = rand (64, 3);
 assert (xyz2rgb (rgb2xyz (rgb_map)), rgb_map, 2e-5);
***** test
 rgb_img = rand (64, 64, 3);
 assert (xyz2rgb (rgb2xyz (rgb_img)), rgb_img, 2e-5);
***** assert (rgb2xyz (sparse ([0 0 0])), [0 0 0], 1e-3)
***** assert (rgb2xyz (sparse ([0 0 1])), [0.1804, 0.0722, 0.9502], 1e-3)
***** assert (rgb2xyz (uint8([255 255 255])), [0.9505, 1.0000, 1.0888], 1e-3)
***** assert (class (rgb2xyz (single([1 1 1]))), 'single')
***** error rgb2xyz ()
***** error rgb2xyz (1,2)
***** error <invalid data type 'cell'> rgb2xyz ({1})
***** error <RGB must be a colormap or RGB image> rgb2xyz (ones (2,2))
***** test
 rgb = rand (16, 16, 3, 5);
 xyz = zeros (size (rgb));
 for i = 1:5
   xyz(:,:,:,i) = rgb2xyz (rgb(:,:,:,i));
 endfor
 assert (rgb2xyz (rgb), xyz)
25 tests, 25 passed, 0 known failure, 0 skipped
[bestblk]
>>>>> /usr/share/octave/packages/image-2.6.1/bestblk.m
***** demo
 siz = bestblk ([200; 10], 50);
 disp (siz)
***** error <numeric vector> bestblk ("string")
***** error <positive scalar> bestblk ([100 200], "string")
***** error <2 elements> bestblk ([100], 5)
***** assert (bestblk ([ 10  12],   2), [  2   2]);
***** assert (bestblk ([ 10  12],   3), [  2   3]);
***** assert (bestblk ([300 100], 150), [150 100]);
***** assert (bestblk ([256 128],  17), [ 16  16]);
***** assert (bestblk ([ 17  17],   3), [  3   3]);
***** assert (bestblk ([230 470]), bestblk ([230 470], 100))
***** assert (bestblk ([10 12 10], 3), [2 3 2]);
***** assert (bestblk ([ 9 12  9], 3), [3 3 3]);
***** assert (bestblk ([10 12 10 11], 5), [5 4 5 4]);
12 tests, 12 passed, 0 known failure, 0 skipped
[bwmorph]
>>>>> /usr/share/octave/packages/image-2.6.1/bwmorph.m
***** demo
 bwmorph (true (11), "shrink", Inf)
 # Should return 0 matrix with 1 pixel set to 1 at (6,6)
***** test
 slBW = logical ([  0   0   0   0   0   0   0
                    0   1   0   0   0   0   0
                    0   0   1   1   0   0   0
                    0   0   1   1   0   0   0
                    0   0   1   1   1   0   0
                    0   0   1   1   1   0   0
                    0   1   1   1   1   1   0
                    0   1   1   1   1   1   0
                    0   1   1   1   1   1   0
                    0   1   1   1   1   1   0
                    0   1   1   1   1   1   0
                    0   0   0   0   0   0   0]);

 rslBW = logical ([ 0   0   0   0   0   0   0
                    0   1   0   0   0   0   0
                    0   0   1   1   0   0   0
                    0   0   1   1   0   0   0
                    0   0   0   0   0   0   0
                    0   0   0   1   0   0   0
                    0   0   0   1   0   0   0
                    0   0   0   0   0   0   0
                    0   0   0   1   0   0   0
                    0   0   0   0   0   0   0
                    0   0   0   0   0   0   0
                    0   0   0   0   0   0   0]);
 assert (bwmorph (slBW, "skel-lantuejoul",   1), [rslBW(1:5,:); false(7, 7)]);
 assert (bwmorph (slBW, "skel-lantuejoul",   2), [rslBW(1:8,:); false(4, 7)]);
 assert (bwmorph (slBW, "skel-lantuejoul",   3), rslBW);
 assert (bwmorph (slBW, "skel-lantuejoul", Inf), rslBW);
***** test
 bw = [
   0   1   1   1   1   1
   0   1   1   1   1   1
   0   1   1   1   1   1
   1   1   1   1   1   1
   1   1   1   1   1   1
   1   1   1   1   1   1
   1   1   1   1   1   0
   1   1   1   1   1   0
   1   1   1   1   1   0];

 final = logical ([
   0   1   0   0   0   1
   0   0   1   0   1   0
   0   0   0   1   0   0
   0   0   0   1   0   0
   0   0   1   1   0   0
   0   0   1   0   0   0
   0   0   1   0   0   0
   0   1   0   1   0   0
   1   0   0   0   1   0]);
 assert (bwmorph (bw, "skel", Inf), final)
 assert (bwmorph (bw, "skel", 3), final)
***** error bwmorph ("not a matrix", "dilate")
***** assert (bwmorph (magic (10), "dilate"), imdilate (logical (magic (10)), ones (3)));
***** test
 in = logical ([1  1  0  0  1  0  1  0  0  0  1  1  1  0  1  1  0  1  0  0
                1  1  1  0  1  0  1  1  1  1  0  1  0  1  0  0  0  0  0  0
                0  1  1  1  0  1  1  0  0  0  1  1  0  0  1  1  0  0  1  0
                0  0  0  0  0  1  1  1  1  0  0  1  1  1  1  1  1  0  0  1
                0  1  0  0  1  1  0  1  1  0  0  0  0  0  1  1  0  0  1  0
                0  0  1  1  1  1  1  0  0  1  0  1  1  1  0  0  1  0  0  1
                0  1  1  1  1  1  1  0  1  1  1  0  0  0  1  0  0  1  0  0
                1  0  1  1  1  0  1  1  0  1  0  0  1  1  1  0  0  1  0  0
                1  0  1  1  1  0  1  0  0  1  0  0  1  1  0  0  1  1  1  0
                1  0  1  1  1  1  0  0  0  1  0  0  0  0  0  0  1  1  0  0
                1  1  1  1  1  1  0  1  0  1  0  0  0  0  0  0  1  0  1  1
                0  1  0  1  1  0  0  1  1  1  0  0  0  0  0  0  0  1  0  0
                0  0  1  1  0  1  1  1  1  0  0  1  0  0  0  0  1  0  1  1
                0  0  1  1  0  0  1  1  1  0  0  0  1  1  1  1  0  0  0  0
                0  0  1  0  0  0  0  0  0  1  0  0  1  1  1  1  0  0  0  0
                0  0  0  0  0  0  1  1  1  0  0  0  1  1  1  1  1  0  0  0
                0  1  0  0  0  1  1  0  1  1  0  0  1  1  1  0  1  1  1  1
                1  0  0  1  0  1  1  0  1  0  0  0  0  0  0  1  0  1  1  1
                0  0  1  1  0  1  1  1  1  0  0  0  0  1  1  0  1  1  1  1
                0  1  1  0  0  1  0  0  1  1  0  0  1  0  0  1  0  0  0  1]);
 se = strel ("arbitrary", ones (3));

 assert (bwmorph (in, "dilate"), imdilate (in, se));
 assert (bwmorph (in, "dilate", 3), imdilate (imdilate (imdilate (in, se), se), se));
 assert (bwmorph (in, "bothat"), imbothat (in, se));
 assert (bwmorph (in, "tophat"), imtophat (in, se));
 assert (bwmorph (in, "open"), imopen (in, se));
 assert (bwmorph (in, "close"), imclose (in, se));
***** assert (bwmorph ([1 0 0; 1 0 1; 0 0 1], "bridge"), logical ([1 1 0; 1 1 1; 0 1 1]));
***** assert (bwmorph ([0 0 0; 1 0 1; 0 0 1], "clean"), logical ([0 0 0; 0 0 1; 0 0 1]));
***** assert (bwmorph ([0 0 0; 0 1 0; 0 0 0], "clean"), false (3));
***** assert (bwmorph ([0 1 0; 1 0 0; 0 0 0], "diag"), logical ([1 1 0; 1 1 0; 0 0 0]));
***** test
 in  = logical ([0  1  0  1  0
                 1  1  1  0  1
                 1  0  0  1  0
                 1  1  1  0  1
                 1  1  1  1  1]);
 out = logical ([0  1  0  1  0
                 1  1  1  1  1
                 1  0  0  1  0
                 1  1  1  1  1
                 1  1  1  1  1]);
 assert (bwmorph (in, "fill"), out);
***** assert (bwmorph ([1 1 1; 0 1 0; 1 1 1], "hbreak"), logical ([1 1 1; 0 0 0; 1 1 1]));
***** test
 in  = logical ([0  1  0  0  0
                 1  0  0  1  0
                 1  0  1  0  0
                 1  1  1  1  1
                 1  1  1  1  1]);

 out = logical ([0  1  0  0   0
                 1  0  0  1  0
                 1  0  1  0  0
                 1  1  0  1  1
                 1  1  1  1  1]);
 assert (bwmorph (in, "remove"), out);

 out = logical ([0  1  0  0  0
                 1  0  0  1  0
                 1  0  1  0  0
                 1  1  0  1  1
                 1  1  1  1  1]);
 assert (bwmorph (in, "remove", Inf), out);

 ## tests for spur are failing (matlab incompatible)
 out = logical ([0  1  0  0  0
                 1  0  0  0  0
                 1  0  1  0  0
                 1  1  1  1  1
                 1  1  1  1  1]);
 assert (bwmorph (in, "spur"), out);

 out = logical ([0  1  0  0  0
                 1  0  0  0  0
                 1  0  0  0  0
                 1  1  1  1  1
                 1  1  1  1  1]);
 assert (bwmorph (in, "spur", Inf), out);
!!!!! test failed
ASSERT errors for:  assert (bwmorph (in, "spur"),out)

  Location  |  Observed  |  Expected  |  Reason
   (1,2)          0            1         Abs err 1 exceeds tol 0
***** test
 in = [
   0   0   0   1   0
   1   1   1   1   0
   0   0   1   1   0
   0   0   1   1   0
   0   0   0   1   0];
 out = [
   0   0   0   0   0
   0   1   1   0   0
   0   0   0   1   0
   0   0   0   0   0
   0   0   0   0   0];
 assert (bwmorph (in, "shrink"), logical (out));
!!!!! test failed
ASSERT errors for:  assert (bwmorph (in, "shrink"),logical (out))

  Location  |  Observed  |  Expected  |  Reason
   (2,4)          1            0         Abs err 1 exceeds tol 0
   (3,4)          0            1         Abs err 1 exceeds tol 0
   (4,4)          1            0         Abs err 1 exceeds tol 0
   (5,4)          1            0         Abs err 1 exceeds tol 0
13 tests, 11 passed, 0 known failure, 0 skipped
[mat2gray]
>>>>> /usr/share/octave/packages/image-2.6.1/mat2gray.m
***** assert(mat2gray([1 2 3]), [0 0.5 1]);           # standard use
***** assert(mat2gray(repmat ([1 2; 3 3], [1 1 3])), repmat ([0 0.5; 1 1], [1 1 3])); # setting min and max
***** assert(mat2gray([1 2 3], [2 2]), [1 1 1]);      # equal min and max
***** assert(mat2gray([-1 0 0.5 3], [2 2]), [0 0 0.5 1]);      # equal min and max
***** assert(mat2gray(ones(3*0.5)), ones(3*0.5));      # equal min and max from the image (not set)
***** assert(mat2gray([1 2 3], [3 1]), [1 0.5 0]);    # max and min inverted
***** assert (mat2gray ([-3 -2 -1]), [0 0.5 1])
7 tests, 7 passed, 0 known failure, 0 skipped
[fftconvn]
>>>>> /usr/share/octave/packages/image-2.6.1/fftconvn.m
***** function test_shapes (a, b, precision)
  shapes = {"valid", "same", "full"};
  for i = 1:3
    shape = shapes{i};
    assert (fftconvn (a, b, shape), convn (a, b, shape), precision);
  endfor
  assert (fftconvn (a, b), fftconvn (a, b, "full"));
***** endfunction
***** test test_shapes (randi (255, 100), randi (255, 10), 0.1)
***** test test_shapes (randi (255, 100, 100), randi (255, 10, 10), 0.1)
***** test test_shapes (randi (255, 100, 100, 100), randi (255, 10, 10, 10), 0.1)
***** test test_shapes (randi (255, 100, 50, 20), randi (255, 10, 7), 0.1)
***** test test_shapes (randi (255, 100, 50, 20), randi (255, 10), 0.1)
***** test
 for s = [55 56 57 58]
   test_shapes (randi (255, 200, 200), randi (255, s, s), 0.1)
 endfor
***** test
 for s = [203 204 205 206]
   test_shapes (randi (255, s, s), randi (255, 52, 52), 0.1)
 endfor
***** test test_shapes (randi (255, 100, 100, "uint8"), randi (255, 10, 10, "uint8"), 0.1)
***** test test_shapes (randi (255, 100, 100, "uint8"), randi (255, 10, 10), 0.1)
***** test test_shapes (randi (255, 100, 100, "single"), randi (255, 10, 10, "single"), 0.9)
***** test test_shapes (randi (255, 100, 100, "single"), randi (255, 10, 10), 0.9)
11 tests, 11 passed, 0 known failure, 0 skipped
[imgradient]
>>>>> /usr/share/octave/packages/image-2.6.1/imgradient.m
***** test
 A = [0 1 0
      1 1 1
      0 1 0];

 [gMag, gDir] = imgradient (A);
 assert (gMag,[sqrt(18) 4 sqrt(18); 4 0 4; sqrt(18),4,sqrt(18)]);
 assert (gDir,[-45 -90 -135; -0 -0 -180; 45 90 135]);

 ## the following just test if passing gx and gy separately gets
 ## us the same as the image and method though imgradient
 [gxSobel, gySobel] = imgradientxy (A, "Sobel");
 [gxPrewitt, gyPrewitt] = imgradientxy (A, "Prewitt");
 [gxCd, gyCd] = imgradientxy (A, "CentralDifference");
 [gxId, gyId] = imgradientxy (A, "IntermediateDifference");

 assert (imgradient (A),
         imgradient (gxSobel, gySobel));
 assert (imgradient (A, "Sobel"),
         imgradient (gxSobel, gySobel));
 assert (imgradient (A, "Prewitt"),
         imgradient(gxPrewitt, gyPrewitt));
 assert (imgradient (A, "CentralDifference"),
         imgradient (gxCd, gyCd));
 assert (imgradient (A, "IntermediateDifference"),
         imgradient (gxId, gyId));
1 test, 1 passed, 0 known failure, 0 skipped
[poly2mask]
>>>>> /usr/share/octave/packages/image-2.6.1/poly2mask.m
***** demo
 s = [0:pi/4:2*pi];
 x = cos (s) * 90 + 101;
 y = sin (s) * 90 + 101;
 bw = poly2mask(x, y, 200, 200);
 imshow (bw);
***** demo
 s = [0:2*pi/5:pi*4];
 s = s ([1, 3, 5, 2, 4, 6]);
 x = cos (s) * 90 + 101;
 y = sin (s) * 90 + 101;
 bw = poly2mask (x, y, 200, 200);
 imshow (bw);
***** # Convex polygons
***** shared xs, ys, Rs, xt, yt, Rt
 xs=[3,3,10,10];
 ys=[4,12,12,4];
 Rs=zeros(16,14);
 Rs(5:12,4:10)=1;
 Rs=logical(Rs);
 xt=[1,4,7];
 yt=[1,4,1];
 Rt=[0,0,0,0,0,0,0;
     0,0,1,1,1,1,0;
     0,0,0,1,1,0,0;
     0,0,0,1,0,0,0;
     0,0,0,0,0,0,0];
 Rt=logical(Rt);
***** assert(poly2mask(xs,ys,16,14),Rs);          # rectangle
***** assert(poly2mask(xs,ys,8,7),Rs(1:8,1:7));   # clipped
***** assert(poly2mask(xs-7,ys-8,8,7),Rs(9:16,8:14)); # more clipping
***** assert(poly2mask(xt,yt,5,7),Rt);            # triangle
***** assert(poly2mask(xt,yt,3,3),Rt(1:3,1:3));   # clipped
***** # Concave polygons
***** test
 x=[3,3,5,5,8,8,10,10];
 y=[4,12,12,8,8,11,11,4];
 R=zeros(16,14);
 R(5:12,4:5)=1;
 R(5:8,6:8)=1;
 R(5:11,9:10)=1;
 R=logical(R);
 assert(poly2mask(x,y,16,14), R);
***** # Complex polygons
***** test
 x=[1,5,1,5];
 y=[1,1,4,4];
 R=[0,0,0,0,0,0;
    0,0,1,1,0,0;
    0,0,1,1,0,0;
    0,1,1,1,1,0;
    0,0,0,0,0,0];
 R=logical(R);
 assert(poly2mask(x,y,5,6), R);
7 tests, 7 passed, 0 known failure, 0 skipped
[medfilt2]
>>>>> /usr/share/octave/packages/image-2.6.1/medfilt2.m
***** shared b, f
 b = [ 0  1  2  3
       1  8 12 12
       4 20 24 21
       7 22 25 18];
 f = [ 0  1  2  0
       1  4 12  3
       4 12 20 12
       0  7 20  0];
***** assert (medfilt2 (b), f);

 f = [ 0  1  2  3
       1  8 12 12
       4 20 24 18
       4 20 24 18];
***** assert (medfilt2 (b, true (3, 1)), f);
***** assert (medfilt2 (b, [3 1]), f);

 f = [ 1  8 10 10
       1  8 12 12
       4 20 24 18
       7 20 24 18];
***** assert (medfilt2 (b, [3 1], 10), f);
***** assert (medfilt2 (b, 10, [3 1]), f);

 f = [ 0.5  4.5  7.0  7.5
       2.5 14.0 18.0 15.0
       2.5 14.0 18.0 15.0
       2.0 10.0 12.0  9.0];
***** assert (medfilt2 (b, true (4, 1)), f);
***** assert (medfilt2 (b, [4 1]), f);
7 tests, 7 passed, 0 known failure, 0 skipped
echo Checking CC files ...
warning: function /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/inst/private/iscolormap.m shadows a core library function
warning: called from
    /var/tmp/file8moa2S at line 833 column 1
[watershed]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/watershed.cc
***** test
 ex = tril (ones (50), -1) + triu (repmat (2, [50 50]), 2);
 ex(1, 1) = 1;
 ex(end, end) = 1;

 in = ones (50);
 in(end,1) = 0;
 in(1,end) = 0;
 assert (watershed (in), ex)
***** test
 ex = tril (ones (49), -1) + triu (repmat (2, [49 49]), 2);
 ex(1, 1) = 1;
 ex(end, end) = 1;

 in = ones (49);
 in(end,1) = 0;
 in(1,end) = 0;
 assert (watershed (in), ex)

 c = (fspecial ('disk', 5) > 0) + 1;
 in(20:30,20:30) = c;
 c = (fspecial ('disk', 4) > 0) + 2;
 in(21:29,21:29) = c;
 assert (watershed (in), ex)
***** test
 ex = tril (ones (49), -1) + triu (repmat (2, [49 49]), 2);
 ex(1:28,1:28) = (tril (ones (28) ,7) + triu (repmat (2, [28 28]), 10));
 ex(1,9) = 1;
 ex(end,end) = 1;
 ex(20:29, 29) = 0;

 in = ones (49);
 in(end,1) = 0;
 in(1,end) = 0;
 c = (fspecial ("disk", 5) > 0) + 1;
 in(1:11,38:48) = c;

 assert (watershed (in), ex)
***** test
 im = [
     3     4     5     6     0
     2     3     4     5     6
     1     2     3     4     5
     0     1     2     3     4
     1     0     1     2     3];

 labeled8 = [
     1     1     1     0     2
     1     1     1     0     0
     1     1     1     1     1
     1     1     1     1     1
     1     1     1     1     1];
 labeled4 = [
     1     1     1     0     3
     1     1     1     0     0
     1     1     0     2     2
     1     0     2     2     2
     0     2     2     2     2];
 labeled_weird = [
     1     1     1     0     2
     1     1     1     1     0
     1     1     1     1     1
     1     1     1     1     1
     1     1     1     1     1];

 assert (watershed (im), labeled8);
 assert (watershed (im, 8), labeled8);
 assert (watershed (im, 4), labeled4);
 assert (watershed (im, [1 1 0; 1 1 1; 0 1 1]), labeled_weird);
***** test
 im = [
     2     3    30     2
     3    30     3    30
   255    31    30     4
     2   255    31    30
     1     2   255     5];

 labeled4 = [
     1     1     0     4
     1     0     3     0
     0     2     0     5
     2     2     2     0
     2     2     0     6];
 labeled_weird = [
     1     1     0     3
     1     1     1     0
     0     1     1     1
     2     0     0     0
     2     2     0     4];

 assert (watershed (im, 4), labeled4);
 assert (watershed (im, [1 1 0; 1 1 1; 0 1 1]), labeled_weird);
***** test
 im = [
     2     3    30     2
     3    30     3    30
   255    31    30     4
     2   255    31    30
     1     2   255     5];

 labeled8 = [
     1     1     0     3
     1     1     0     3
     0     0     0     0
     2     2     0     4
     2     2     0     4];
 assert (watershed (im), labeled8);
 assert (watershed (im, 8), labeled8);
!!!!! test failed
ASSERT errors for:  assert (watershed (im),labeled8)

  Location  |  Observed  |  Expected  |  Reason
   (3,4)          3            0         Abs err 3 exceeds tol 0
   (4,4)          0            4         Abs err 4 exceeds tol 0
***** test
 im = [
    2    2    2    2    2    2    2
    2    2   30   30   30    2    2
    2   30   20   20   20   30    2
   40   40   20   20   20   40   40
    1   40   20   20   20   40    0
    1    1   40   20   40    0    0
    1    1    1   20    0    0    0];

 labeled8 = [
    1    1    1    1    1    1    1
    1    1    1    1    1    1    1
    1    1    1    1    1    1    1
    0    0    0    0    0    0    0
    2    2    2    0    3    3    3
    2    2    2    0    3    3    3
    2    2    2    0    3    3    3];
 labeled4 = [
    1    1    1    1    1    1    1
    1    1    1    1    1    1    1
    1    1    1    1    1    1    1
    0    1    1    1    1    1    0
    2    0    1    1    1    0    3
    2    2    0    1    0    3    3
    2    2    2    0    3    3    3];
 labeled_weird = [
    1    1    1    1    1    1    1
    1    1    1    1    1    1    1
    1    1    1    1    1    1    1
    0    1    1    0    0    0    0
    2    0    0    0    3    3    3
    2    2    0    3    3    3    3
    2    2    2    0    3    3    3];

 assert (watershed (im), labeled8);
 assert (watershed (im, 8), labeled8);
 assert (watershed (im, 4), labeled4);
 assert (watershed (im, [1 1 0; 1 1 1; 0 1 1]), labeled_weird);
***** test
 im = [
   40   40   40   40   40   40   40   40   40   40   40   40   40
   40    3    3    5    5    5   10   10   10   10   15   20   40
   40    3    3    5    5   30   30   30   10   15   15   20   40
   40    3    3    5   30   20   20   20   30   15   15   20   40
   40   40   40   40   40   20   20   20   40   40   40   40   40
   40   10   10   10   40   20   20   20   40   10   10   10   40
   40    5    5    5   10   40   20   40   10   10    5    5   40
   40    1    3    5   10   15   20   15   10    5    1    0   40
   40    1    3    5   10   15   20   15   10    5    1    0   40
   40   40   40   40   40   40   40   40   40   40   40   40   40];

 labeled8 = [
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    0    0    0    0    0    0    0    0    0    0    0    0    0
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3];
 labeled4 = [
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    0    0    0    0    1    1    1    1    1    0    0    0    0
    2    2    2    2    0    1    1    1    0    3    3    3    3
    2    2    2    2    2    0    1    0    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3];
 labeled_weird = [
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    1    1    1    1    1    1    1    1    1    1    1    1
    0    0    0    0    1    1    0    0    0    0    0    0    0
    2    2    2    2    0    0    0    3    3    3    3    3    3
    2    2    2    2    2    0    3    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3
    2    2    2    2    2    2    0    3    3    3    3    3    3];

 assert (watershed (im), labeled8);
 assert (watershed (im, 8), labeled8);
 assert (watershed (im, 4), labeled4);
 assert (watershed (im, [1 1 0; 1 1 1; 0 1 1]), labeled_weird);
***** test
 im_full = [
   1   2  10   3   8   7   5
   3   2   5  10   8   1   4
   1   8   2   3   8   3   6];

 matlab_result_full = [
   1   1   0   3   0   4   4
   0   0   0   0   0   4   4
   2   2   2   0   4   4   4];

 assert (watershed (im_crop), matlab_result_crop);

 im_crop = [
       2  10   3   8   7   5
       2   5  10   8   1   4
       8   2   3   8   3   6];

 matlab_result_crop = [
       1   0   2   0   3   3
       1   0   0   0   3   3
       1   1   1   0   3   3];

 assert (watershed (im_crop), matlab_result_crop);
!!!!! test failed
'im_crop' undefined near line 13 column 21
9 tests, 7 passed, 0 known failure, 0 skipped
[graycomatrix]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/graycomatrix.cc
***** shared a
***** test
  a = [0 0 0 1 2;
       1 1 0 1 1;
       2 2 1 0 0;
       1 1 0 2 0;
       0 0 1 0 1];
  squeeze(graycomatrix(a, 3, 1, -pi/4)) == [4 2 0;
                                     2 3 2;
                                     1 2 0];

***** assert(size(graycomatrix(a, 3, 1:5, [0:3]*-pi/4)), [3, 3, 5, 4])
***** demo

  # Pattern Recognition Engineering (Nadler & Smith)
  # Digital Image Processing (Gonzales & Woods), p. 668

  a = [0 0 0 1 2;
       1 1 0 1 1;
       2 2 1 0 0;
       1 1 0 2 0;
       0 0 1 0 1];

  graycomatrix(a, 3, 1, [0 1]*-pi/4)

2 tests, 2 passed, 0 known failure, 0 skipped
[imreconstruct]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/imreconstruct.cc
***** function recon = parallel_reconstruction (marker, mask,
                                          conn = conndef (ndims (marker), "maximal"))
  do
    previous = marker;
    marker = imdilate (marker, conn);
    ## FIXME https://savannah.gnu.org/bugs/index.php?43712
    if (strcmp (class (marker), "logical"))
      marker = marker & mask;
    else
      marker = min (marker, mask);
    endif
  until (all ((marker == previous)(:)))
  recon = marker;
***** endfunction
***** test
 for cl = {"int8", "uint8", "int16", "uint16", "int32", "uint32"}
   cl = cl{1};
   a = randi ([intmin(cl) intmax(cl)-30], 100, 100, cl);
   b = a + randi (20, 100, 100, cl);
   assert (imreconstruct (a, b), parallel_reconstruction (a, b))
 endfor
 for cl = {"double", "single"}
   cl = cl{1};
   a = (rand (100, 100, cl) - 0.5) .* 1000;
   b = a + rand (100, 100, cl) * 100;
   assert (imreconstruct (a, b), parallel_reconstruction (a, b))
 endfor
***** test
 for cl = {"int8", "uint8", "int16", "uint16", "int32", "uint32"}
   cl = cl{1};
   a = randi ([intmin(cl) intmax(cl)-30], 100, 100, cl);
   b = a + randi (20, 100, 100, cl);
   c = [0 1 0; 1 1 1; 0 1 0];
   assert (imreconstruct (a, b, c), parallel_reconstruction (a, b, c))
 endfor
***** test
 a = randi (210, 100, 100);
 b = a + randi (20, 100, 100);
 c = ones (3, 1);
 assert (imreconstruct (a, b, c), parallel_reconstruction (a, b, c))
***** test
 a = randi (210, 500, 500, 10, 4);
 b = a + randi (20, 500, 500, 10, 4);
 c = ones (3, 3, 3);
 assert (imreconstruct (a, b, c), parallel_reconstruction (a, b, c))
***** test
 a = randi (210, 500, 500, 10, 4);
 b = a + randi (20, 500, 500, 10, 4);
 c = conndef (4, "minimal");
 assert (imreconstruct (a, b, c), parallel_reconstruction (a, b, c))
***** test
 a = [   0   0   0   0   0   0   0   1   0   0
         0   0   0   0   0   0   0   1   0   0
         1   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   1   0   0
         0   0   0   0   0   0   1   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   1   0   0   0   0   0
         0   0   0   0   0   0   0   1   0   0];

 b = [   0   1   0   0   0   0   0   1   1   0
         1   1   0   0   0   1   0   1   1   0
         1   1   0   0   1   0   0   0   0   0
         1   1   0   0   0   1   1   0   0   0
         1   0   0   0   0   0   1   1   0   0
         0   1   0   0   0   0   1   1   0   0
         0   0   0   1   0   0   0   0   0   0
         0   0   0   0   1   1   0   0   0   0
         0   0   0   1   1   0   0   0   0   0
         1   0   0   0   1   0   0   1   0   1];

 c = [   0   1   0   0   0   0   0   1   1   0
         1   1   0   0   0   1   0   1   1   0
         1   1   0   0   1   0   0   0   0   0
         1   1   0   0   0   1   1   0   0   0
         1   0   0   0   0   0   1   1   0   0
         0   1   0   0   0   0   1   1   0   0
         0   0   0   1   0   0   0   0   0   0
         0   0   0   0   1   1   0   0   0   0
         0   0   0   1   1   0   0   0   0   0
         0   0   0   0   1   0   0   1   0   0];
 assert (imreconstruct (logical (a), logical (b)), logical (c));

 c = [   0   1   0   0   0   0   0   1   1   0
         1   1   0   0   0   0   0   1   1   0
         1   1   0   0   0   0   0   0   0   0
         1   1   0   0   0   1   1   0   0   0
         1   0   0   0   0   0   1   1   0   0
         0   0   0   0   0   0   1   1   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   0   1   1   0   0   0   0
         0   0   0   1   1   0   0   0   0   0
         0   0   0   0   1   0   0   1   0   0];
 assert (imreconstruct (logical (a), logical (b), [0 1 0; 1 1 1; 0 1 0]),
         logical (c));
***** test
 do
   b = rand (100, 100, 100) > 0.98;
 until (nnz (b) > 4)
 b = imdilate (b, ones (5, 5, 5));
 a = false (size (b));
 f = find (b);
 a(f(randi (numel (f), 6, 1))) = true;
 assert (imreconstruct (a, b), parallel_reconstruction (a, b))
***** test
 a = randi (200, 100,100, 10, 10);
 b = a + randi (20, 100,100, 10, 10);
 c1 = ones (3, 3, 3);
 c2 = zeros (3, 3, 3, 3);
 c2(:,:,:,2) = c1;
 assert (imreconstruct (a, b, c1), imreconstruct (a, b, c2))
***** error <MARKER must be less or equal than MASK> imreconstruct (randi([5 10], [10 10]), randi([1 5], [10 10]))
9 tests, 9 passed, 0 known failure, 0 skipped
[imerode]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/imerode.cc
***** assert (imerode (eye (3), [1]), eye (3));
***** assert (imerode (eye (3), []), Inf (3, 3));
***** test
 im = [0 1 0
       1 1 1
       0 1 0];
 se = [1 0 0
       0 1 0
       0 1 1];
 assert (imerode (im,          se),          [0 1 0; 0 0 0; 0 1 0]);
 assert (imerode (logical(im), se), logical ([0 1 0; 0 0 0; 0 1 0]));
 assert (imerode (im, se, "full"),
                 [  0    0    0    0  Inf
                    1    0    1    0  Inf
                    0    0    0    0    0
                  Inf    0    1    0    1
                  Inf  Inf    0    1    0]);
 assert (imerode (logical(im), se, "full"),
                 logical([0     0     0     0     1
                          1     0     1     0     1
                          0     0     0     0     0
                          1     0     1     0     1
                          1     1     0     1     0]));
***** test
 a = rand ([10 40 15 6 8 5]) > 0.2;
 se = ones ([5 3 7]);

 ## the image is not really indexed but this way it is padded with 1s
 assert (imerode (a, se), colfilt (a, "indexed", size (se), "sliding", @all))

 assert (imerode (a, se, "valid"), convn (a, se, "valid") == nnz (se))
 ## again, we need to pad it ourselves because convn pads with zeros
 b = true (size (a) + [4 2 6 0 0 0]);
 b(3:12, 2:41, 4:18,:,:,:) = a;
 assert (imdilate (b, se, "same"), convn (b, se, "same") > 0)
 b = true (size (a) + [8 4 12 0 0 0]);
 b(5:14, 3:42, 7:21,:,:,:) = a;
 assert (imdilate (b, se, "full"), convn (b, se, "full") > 0)
***** test
 im = [0 0 0 0 0 0 0
       0 0 1 0 1 0 0
       0 0 1 1 0 1 0
       0 0 1 1 1 0 0
       0 0 0 0 0 0 0];
 se = [0 0 0
       0 1 0
       0 1 1];
 out = [0 0 0 0 0 0 0
        0 0 1 0 0 0 0
        0 0 1 1 0 0 0
        0 0 0 0 0 0 0
        0 0 0 0 0 0 0];
 assert (imerode (im, se), out);
 assert (imerode (logical (im), se), logical (out));
 assert (imerode (im, logical (se)), out);
 assert (imerode (logical (im), logical (se)), logical (out));

 # with an even-size SE
 se =  [0 0 0 1
        0 1 0 0
        0 1 1 1];
 out = [0 0 0 0 0 0 0
        0 0 0 0 0 0 0
        0 0 1 0 0 0 0
        0 0 0 0 0 0 0
        0 0 0 0 0 0 0];
 assert (imerode (im, se), out);
 out = [ 0 0 0 0 1 0 1
        0 0 1 0 1 1 0
        0 0 1 1 1 1 1
        0 0 1 1 1 1 1
        0 0 1 1 1 1 1];
 assert (imdilate (im, se), out);
***** test
 a = [ 82    2   97   43   79   43   41   65   51   11
       60   65   21   56   94   77   36   38   75   39
       32   68   78    1   16   75   76   90   81   56
       43   90   82   41   36    1   87   19   18   63
       63   64    2   48   18   43   38   25   22   99
       12   46   90   79    3   92   39   79   10   22
       38   98   11   10   40   90   88   38    4   76
       54   37    9    4   33   98   36   47   53   57
       38   76   82   50   14   74   64   99    7   33
       88   96   41   62   84   89   97   23   41    3];

 domain = ones (3);
 out = [  2    1    1    1   16   36   36   11
         21    1    1    1    1    1   18   18
          2    1    1    1    1    1   18   18
          2    2    2    1    1    1   10   10
          2    2    2    3    3   25    4    4
          9    4    3    3    3   36    4    4
          9    4    4    4   14   36    4    4
          9    4    4    4   14   23    7    3];
 assert (imerode (a, domain, "valid"), out);
 assert (imerode (uint8 (a), domain, "valid"), uint8 (out));
 assert (imerode (uint8 (a), strel ("arbitrary", domain), "valid"), uint8 (out));
 assert (imerode (uint8 (a), strel ("square", 3), "valid"), uint8 (out));

***** ## Test for non-flat strel
 assert (imerode (a, strel ("arbitrary", domain, ones (3)), "valid"), out -1);

 out = [ 97   97   97   94   94   90   90   90
         90   90   94   94   94   90   90   90
         90   90   82   75   87   90   90   99
         90   90   90   92   92   92   87   99
         98   98   90   92   92   92   88   99
         98   98   90   98   98   98   88   79
         98   98   82   98   98   99   99   99
         96   96   84   98   98   99   99   99];
 assert (imdilate (a, domain, "valid"), out);
 assert (imdilate (uint8 (a), domain, "valid"), uint8 (out));

***** ## Test for non-flat strel
 assert (imdilate (a, strel ("arbitrary", domain, ones (3)), "valid"), out +1);

 ## test while using SE that can be decomposed and an actual sequence
 domain = ones (5);
 out = [   2   1   1   1   1   1  16  11  11  11
           2   1   1   1   1   1   1   1  11  11
           2   1   1   1   1   1   1   1  11  11
           2   1   1   1   1   1   1   1  10  10
           2   1   1   1   1   1   1   1   4   4
           2   2   2   1   1   1   1   1   4   4
           2   2   2   2   2   3   3   4   4   4
           9   4   3   3   3   3   3   3   3   3
           9   4   4   4   4   4   4   3   3   3
           9   4   4   4   4   4   7   3   3   3];
 assert (imerode (a, domain), out);
 assert (imerode (a, strel ("square", 5)), out);
 assert (imerode (a, getsequence (strel ("square", 5))), out);

 ## using a non-symmetric SE
 domain = [ 1 1 0
            0 1 1
            0 1 0];

 out = [  2    2    1   16   36   36   38   39
         60    1    1   16    1   36   19   18
         32    2    1    1    1   19   18   18
          2    2   18    3    1    1   19   10
         46    2    2    3   18   38   10    4
         11    9    4    3    3   36    4    4
          9    4    4   10   36   36   38    4
         37    9    4    4   33   36    7    7];
 assert (imerode (a, domain, "valid"), out);
 assert (imerode (a, strel ("arbitrary", domain, ones (3)), "valid"), out -1);

 out = [ 78   97   56   94   94   90   90   81
         90   82   78   94   87   87   90   90
         90   90   82   43   75   87   90   99
         90   90   79   92   92   87   79   25
         98   90   90   90   92   92   79   79
         98   98   79   98   98   90   88   57
         98   82   50   74   98   99   99   53
         96   82   84   89   98   97   99   99];
 assert (imdilate (a, domain, "valid"), out);
 assert (imdilate (a, strel ("arbitrary", domain, ones (3)), "valid"), out +1);
***** test
 im = reshape (magic(16), [4 8 4 2]);
 se = true (3, 3, 3);
 out = zeros (4, 8, 4, 2);
 out(:,:,1,1) = [
     3   3  46   2   2   2  47  47
     3   3  30   2   2   2  31  31
    17  17  16  16  16  20  13  13
    33  33  16  16  16  36  13  13];
 out(:,:,2,1) = [
     3   3  46   2   2   2  43  43
     3   3  30   2   2   2  27  27
    17  17  12  12  12  20  13  13
    33  33  12  12  12  36  13  13];
 out(:,:,3,1) = [
     3   3  42   6   6   6  43  43
     3   3  26   6   6   6  27  27
    21  21  12  12  12  20   9   9
    37  37  12  12  12  36   9   9];
 out(:,:,4,1) = [
     7   7  42   6   6   6  43  43
     7   7  26   6   6   6  27  27
    21  21  12  12  12  24   9   9
    37  37  12  12  12  40   9   9];
 out(:,:,1,2) = [
    11  11  38  10  10  10  39  39
    11  11  22  10  10  10  23  23
    25  25   8   8   8  28   5   5
    41  41   8   8   8  44   5   5];
 out(:,:,2,2) = [
    11  11  38  10  10  10  35  35
    11  11  22  10  10  10  19  19
    25  25   4   4   4  28   5   5
    41  41   4   4   4  44   5   5];
 out(:,:,3,2) = [
    11  11  34  14  14  14  35  35
    11  11  18  14  14  14  19  19
    29  29   4   4   4  28   1   1
    45  45   4   4   4  44   1   1];
 out(:,:,4,2) = [
    15  15  34  14  14  14  35  35
    15  15  18  14  14  14  19  19
    29  29   4   4   4  32   1   1
    45  45   4   4   4  48   1   1];
 assert (imerode (im, se), out);
 assert (imerode (uint16 (im), se), uint16 (out));

 ## trying a more weird SE
 se(:,:,1) = [1 0 1; 0 1 1; 0 0 0];
 se(:,:,3) = [1 0 1; 0 1 1; 0 0 1];
 out(:,:,1,1) = [
    3  17  46   2   2   2  47  47
   17   3  30   2   2   2  31  31
   17  17  16  16  16  20  13  31
   33  33  16  16  16  36  13  13];
 out(:,:,2,1) = [
    3   3  46   2   2  20  43  61
    3   3  30   2  20   2  27  43
   33  17  12  20  20  20  13  13
   51  33  12  12  30  36  13  13];
 out(:,:,3,1) = [
    3  21  42   6   6   6  43  43
   21   3  26   6   6   6  27  27
   21  21  12  12  12  20   9  27
   37  37  12  12  12  36   9   9];
 out(:,:,4,1) = [
    7   7  42   6   6  24  57  57
    7   7  26   6  24   6  43  43
   37  21  26  24  24  24   9   9
   55  37  12  12  26  40   9   9];
 out(:,:,1,2) = [
   11  25  38  10  10  10  39  39
   25  11  22  10  10  10  23  23
   25  25   8   8   8  28   5  23
   41  41   8   8   8  44   5   5];
 out(:,:,2,2) = [
   11  11  38  10  10  28  35  53
   11  11  22  10  22  10  19  35
   41  25   4  22  22  28   5   5
   59  41   4   4  22  44   5   5];
 out(:,:,3,2) = [
   11  29  34  14  14  14  35  35
   29  11  18  14  14  14  19  19
   29  29   4   4   4  28   1  19
   45  45   4   4   4  44   1   1];
 out(:,:,4,2) = [
   15  15  34  14  14  32  49  49
   15  15  18  14  18  14  35  35
   45  29  18  18  18  32   1   1
   63  45   4   4  18  48   1   1];
 assert (imerode (im, se), out);
 assert (imerode (uint16 (im), se), uint16 (out));
***** error imerode (ones (10), 45)
***** error imerode (ones (10), "some text")
***** error imerode (ones (10), {23, 45})
***** error imerode (rand (10) > 10 , strel ("arbitrary", true (3), ones (3)))
***** test
 a = rand ([10 40 15 6 8 5]) > 0.8;
 se = ones ([5 3 7]);
 assert (imdilate (a, se), convn (a, se, "same") > 0)
 assert (imdilate (a, se, "full"), convn (a, se, "full") > 0)
 assert (imdilate (a, se, "valid"), convn (a, se, "valid") > 0)
 assert (imdilate (a, se), colfilt (a, size (se), "sliding", @any))
***** test
 im = reshape (magic(16), [4 8 4 2]);
 se = true (3, 3, 3);
 out = zeros (4, 8, 4, 2);

 out(:,:,1,1) = [
   256   256   209   253   253   253   212   212
   256   256   225   253   253   253   228   228
   238   238   243   243   243   239   242   242
   222   222   243   243   243   223   242   242];
 out(:,:,2,1) = [
   256   256   213   253   253   253   212   212
   256   256   229   253   253   253   228   228
   238   238   243   243   243   239   246   246
   222   222   243   243   243   223   246   246];
 out(:,:,3,1) = [
   252   252   213   253   253   253   216   216
   252   252   229   253   253   253   232   232
   238   238   247   247   247   235   246   246
   222   222   247   247   247   219   246   246];
 out(:,:,4,1) = [
   252   252   213   249   249   249   216   216
   252   252   229   249   249   249   232   232
   234   234   247   247   247   235   246   246
   218   218   247   247   247   219   246   246];
 out(:,:,1,2) = [
   248   248   217   245   245   245   220   220
   248   248   233   245   245   245   236   236
   230   230   251   251   251   231   250   250
   214   214   251   251   251   215   250   250];
 out(:,:,2,2) = [
   248   248   221   245   245   245   220   220
   248   248   237   245   245   245   236   236
   230   230   251   251   251   231   254   254
   214   214   251   251   251   215   254   254];
 out(:,:,3,2) = [
   244   244   221   245   245   245   224   224
   244   244   237   245   245   245   240   240
   230   230   255   255   255   227   254   254
   214   214   255   255   255   211   254   254];
 out(:,:,4,2) = [
   244   244   221   241   241   241   224   224
   244   244   237   241   241   241   240   240
   226   226   255   255   255   227   254   254
   210   210   255   255   255   211   254   254];
 assert (imdilate (im, se), out);
 assert (imdilate (uint16 (im), se), uint16 (out));

 ## trying a more weird SE
 se(:,:,1) = [1 0 1; 0 1 1; 0 0 0];
 se(:,:,3) = [1 0 1; 0 1 1; 0 0 1];
 out(:,:,1,1) = [
  256   256   209   239   253   253   212   194
  256   256   225   239   239   239   228   212
  222   222   243   239   243   239   242   242
  208   208   225   243   243   223   242   242];
 out(:,:,2,1) = [
  256   256   213   253   253   253   212   212
  238   256   229   253   253   253   228   228
  238   238   243   243   243   239   246   228
  222   222   243   243   243   223   228   246];
 out(:,:,3,1) = [
  252   252   213   235   253   253   216   198
  252   252   229   235   235   253   232   216
  222   238   247   235   247   235   246   246
  204   222   229   247   247   219   246   246];
 out(:,:,4,1) = [
  252   252   213   249   249   249   216   216
  234   252   229   249   249   249   232   232
  234   234   247   247   247   235   246   232
  218   218   247   247   247   219   232   246];
 out(:,:,1,2) = [
  248   248   217   231   245   245   220   202
  248   248   233   233   233   231   236   220
  214   214   251   233   251   231   250   250
  200   200   233   251   251   215   250   250];
 out(:,:,2,2) = [
  248   248   221   245   245   245   220   220
  230   248   237   245   245   245   236   236
  230   230   251   251   251   231   254   236
  214   214   251   251   251   215   236   254];
 out(:,:,3,2) = [
  244   244   221   227   245   245   224   206
  244   244   237   237   237   245   240   224
  214   230   255   237   255   227   254   254
  196   214   237   255   255   211   254   254];
 out(:,:,4,2) = [
  244   244   221   241   241   241   224   224
  226   244   237   241   241   241   240   240
  226   226   255   255   255   227   254   240
  210   210   255   255   255   211   240   254];
 assert (imdilate (im, se), out);
 assert (imdilate (uint16 (im), se), uint16 (out));
***** test    # scalar blank SE
 se = 0;
 assert (imerode (5, se), Inf)
 assert (imerode (true, se), true)
 assert (imerode (false, se), true)
 assert (imerode (uint8 (3), se), uint8 (255))

 assert (imdilate (5, se), -Inf)
 assert (imdilate (true, se), false)
 assert (imdilate (false, se), false)
 assert (imdilate (uint8 (3), se), uint8 (0))
***** test    # empty SE
 se = [];
 assert (imerode (5, se), Inf)
 assert (imerode (true, se), true)
 assert (imerode (false, se), true)
 assert (imerode (uint8 (3), se), uint8 (255))

 assert (imdilate (5, se), -Inf)
 assert (imdilate (true, se), false)
 assert (imdilate (false, se), false)
 assert (imdilate (uint8 (3), se), uint8 (0))
***** test    # non-scalar blank SE
 se = zeros (3, 3);
 assert (imerode (5, se), Inf)
 assert (imerode (true, se), true)
 assert (imerode (false, se), true)
 assert (imerode (uint8 (3), se), uint8 (255))

 assert (imdilate (5, se), -Inf)
 assert (imdilate(true, se), false)
 assert (imdilate (false, se), false)
 assert (imdilate (uint8 (3), se), uint8 (0))
***** test    # erode only with out-of-border elements
 se = [1 1 1; 1 0 1; 1 1 1];
 assert (imerode (5, se), Inf)
 assert (imerode (true, se), true)

 assert (imdilate (5, se), -Inf)
 assert (imdilate (true, se), false)
***** test    # only true elements of SE are out-of-border
 se = [0 0 0; 1 0 0; 1 1 0];
 assert (imerode (zeros (3), se), [0 0 0; 0 0 0; Inf 0 0])
 assert (imerode (false (3), se), logical ([0 0 0; 0 0 0; 1 0 0]))
 assert (imdilate (zeros (3), se), [0 0 -Inf; 0 0 0; 0 0 0])
 assert (imdilate (false (3), se), false (3, 3))

 se = [0 0 0; 0 0 0; 1 1 1];
 assert (imerode (zeros (3, 3), se), [0 0 0; 0 0 0; Inf Inf Inf])
 assert (imerode (false (3, 3), se), logical ([0 0 0; 0 0 0; 1 1 1]))
 assert (imdilate (zeros (3, 3), se), [-Inf -Inf -Inf; 0 0 0; 0 0 0])
 assert (imdilate (false (3, 3), se), false (3, 3))
***** test  # only true elements of even-sized SE are out-of-border
 se = logical ([0 1; 1 1]);
 assert (imerode (false (3, 3), se), logical ([0 0 0; 0 0 0; 0 0 1]))
 assert (imerode (zeros (3, 3), se), [0 0 0; 0 0 0; 0 0 Inf])

 assert (imdilate (false (3, 3), se), false (3, 3))
 assert (imdilate (zeros (3, 3), se), [-Inf 0 0; 0 0 0; 0 0 0])
19 tests, 19 passed, 0 known failure, 0 skipped
[intlut]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/intlut.cc
***** assert (intlut (uint8  (1:4), uint8  (  255:-1:0)), uint8  (254:-1:251));
***** assert (intlut (uint16 (1:4), uint16 (65535:-1:0)), uint16 (65534:-1:65531));
***** assert (intlut (int16  (1:4), int16  (32767:-1:-32768)), int16 (-2:-1:-5));
***** assert (intlut (uint8 (255), uint8 (0:255)), uint8 (255));
***** assert (intlut (uint16 (65535), uint16 (0:65535)), uint16 (65535));
***** assert (intlut (int16 (32767), int16 (-32768:32767)), int16 (32767));
***** error intlut ()
***** error intlut ("text")
***** error <must be of same class> intlut (1:20, uint8 (0:255));
***** error <must be of same class> intlut (uint16 (1:20), uint8 (0:255));
***** error <must have 256 elements> intlut (uint8 (1:20), uint8 (0:200));
***** error <must have 65536 elements> intlut (uint16 (1:20), uint16 (0:500));
 error <LUST must be a vector> intlut (uint8 (56), uint8 (magic (16) -1))
12 tests, 12 passed, 0 known failure, 0 skipped
[bwconncomp]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/bwconncomp.cc
***** test
 a = rand (10) > 0.5;
 cc = bwconncomp (a, 4);
 assert (cc.Connectivity, 4)
 assert (cc.ImageSize, [10 10])

 b = false (10);
 for i = 1:numel (cc.PixelIdxList)
   b(cc.PixelIdxList{i}) = true;
 endfor
 assert (a, b)
***** test
 a = rand (10, 13) > 0.5;
 cc = bwconncomp (a, 4);
 assert (cc.ImageSize, [10 13])

 b = false (10, 13);
 for i = 1:numel (cc.PixelIdxList)
   b(cc.PixelIdxList{i}) = true;
 endfor
 assert (a, b)
***** test
 a = rand (15) > 0.5;
 conn_8 = bwconncomp (a, 8);
 assert (conn_8, bwconncomp (a))
 assert (conn_8, bwconncomp (a, ones (3)))
 assert (conn_8.Connectivity, 8)
 assert (bwconncomp (a, ones (3)).Connectivity, 8)
 assert (bwconncomp (a, [0 1 0; 1 1 1; 0 1 0]).Connectivity, 4)
***** test
 a = rand (40, 40) > 0.2;
 cc = bwconncomp (a, 4);
 assert (rows (cc.PixelIdxList), 1)
 assert (columns (cc.PixelIdxList) > 1)
***** assert (bwconncomp (false (5)), struct ("ImageSize", [5 5], "NumObjects", 0,
                                        "PixelIdxList", {cell(1, 0)},
                                        "Connectivity", 8))
***** test
 in = [ 0   0   1   0   0   1   0   1   0   0
        0   0   1   0   0   0   0   0   1   1
        1   0   0   0   0   1   1   0   0   0
        1   0   0   0   1   0   0   0   0   0
        1   1   1   1   0   0   0   0   0   1
        0   1   0   1   1   0   0   1   0   0
        1   0   0   0   1   0   0   0   0   0
        0   0   0   1   1   0   0   1   0   0
        0   1   0   1   1   0   0   1   1   0
        0   1   0   1   1   1   0   0   1   0];
 assert (bwareaopen (in, 1, 4), logical (in))

 out = [0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   1   1   1   0   0   0   0   0   0
        0   1   0   1   1   0   0   0   0   0
        0   0   0   0   1   0   0   0   0   0
        0   0   0   1   1   0   0   0   0   0
        0   0   0   1   1   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0];
 assert (bwareaopen (logical (in), 10, 4), logical (out))
 assert (bwareaopen (in, 10, 4), logical (out))
 assert (bwareaopen (in, 10, [0 1 0; 1 1 1; 0 1 0]), logical (out))

 out = [0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   1   1   0   0   0
        1   0   0   0   1   0   0   0   0   0
        1   1   1   1   0   0   0   0   0   0
        0   1   0   1   1   0   0   0   0   0
        1   0   0   0   1   0   0   0   0   0
        0   0   0   1   1   0   0   0   0   0
        0   0   0   1   1   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0];
 assert (bwareaopen (in, 10, 8), logical (out))
 assert (bwareaopen (in, 10, ones (3)), logical (out))
 assert (bwareaopen (in, 10), logical (out))

 out = [0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   1   1   1   0   0   0   0   0   0
        0   1   0   1   1   0   0   0   0   0
        0   0   0   0   1   0   0   0   0   0
        0   0   0   1   1   0   0   1   0   0
        0   0   0   1   1   0   0   1   1   0
        0   0   0   1   1   1   0   0   1   0];
 assert (bwareaopen (in, 4, [1 1 0; 1 1 1; 0 1 1]), logical (out))
***** error bwareaopen ("not an image", 78, 8)
***** error bwareaopen (rand (10) > 0.5, 10, 100)
***** error bwareaopen (rand (10) > 0.5, 10, "maximal")
***** error bwareaopen (rand (10) > 0.5, 10, [1 1 1; 0 1 1; 0 1 0])
10 tests, 10 passed, 0 known failure, 0 skipped
[hough_line]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/hough_line.cc
***** test
 I = zeros(100, 100);
 I(1,1) = 1; I(100,100) = 1; I(1,100) = 1; I(100, 1) = 1; I(50,50) = 1;
 [J, R] = houghtf(I); J = J / max(J(:));
 assert(size(J) == [length(R) 181]);

***** demo
 I = zeros(100, 150);
 I(30,:) = 1; I(:, 65) = 1; I(35:45, 35:50) = 1;
 for i = 1:90, I(i,i) = 1;endfor
 I = imnoise(I, 'salt & pepper');
 imshow(I);
 J = houghtf(I); J = J / max(J(:));
 imshow(J, bone(128), 'truesize');
1 test, 1 passed, 0 known failure, 0 skipped
[__spatial_filtering__]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/__spatial_filtering__.cc
***** shared a, domain, s, out
 a = [ 82    2   97   43   79   43   41   65   51   11
       60   65   21   56   94   77   36   38   75   39
       32   68   78    1   16   75   76   90   81   56
       43   90   82   41   36    1   87   19   18   63
       63   64    2   48   18   43   38   25   22   99
       12   46   90   79    3   92   39   79   10   22
       38   98   11   10   40   90   88   38    4   76
       54   37    9    4   33   98   36   47   53   57
       38   76   82   50   14   74   64   99    7   33
       88   96   41   62   84   89   97   23   41    3];

 domain = ones  (3);
 s      = zeros (3);

 out = [  2    1    1    1   16   36   36   11
         21    1    1    1    1    1   18   18
          2    1    1    1    1    1   18   18
          2    2    2    1    1    1   10   10
          2    2    2    3    3   25    4    4
          9    4    3    3    3   36    4    4
          9    4    4    4   14   36    4    4
          9    4    4    4   14   23    7    3];
***** assert (__spatial_filtering__ (a, domain, "min", s), out);
***** assert (__spatial_filtering__ (a, domain, "ordered", s, 1), out);

 out = [ 97   97   97   94   94   90   90   90
         90   90   94   94   94   90   90   90
         90   90   82   75   87   90   90   99
         90   90   90   92   92   92   87   99
         98   98   90   92   92   92   88   99
         98   98   90   98   98   98   88   79
         98   98   82   98   98   99   99   99
         96   96   84   98   98   99   99   99];
***** assert (__spatial_filtering__ (a, domain, "max", s), out);
***** assert (__spatial_filtering__ (a, domain, "ordered", s, nnz (domain)), out);

 out = [ 60   43   43   43   43   43   51   51
         60   56   36   36   36   38   38   39
         63   48   18   18   36   38   25   25
         46   48   36   36   36   38   22   22
         38   46   11   40   39   39   25   22
         37   11   10   33   39   47   38   38
         38   11   11   33   40   64   38   38
         41   41   33   50   64   64   41   33];
***** assert (__spatial_filtering__ (a, domain, "ordered", s, 4), out);

 out = [ 31.223   33.788   35.561   31.011   26.096   20.630   20.403   24.712
         23.428   29.613   32.376   34.002   33.593   32.470   29.605   26.333
         27.834   32.890   29.903   24.207   30.083   32.497   31.898   32.600
         32.027   28.995   33.530   31.002   32.241   32.004   27.501   32.070
         34.682   36.030   33.046   33.745   32.509   27.352   28.607   34.180
         32.709   37.690   32.992   40.036   34.456   26.656   27.685   26.863
         30.971   36.227   25.775   34.873   29.917   25.269   32.292   30.410
         29.135   31.626   30.056   33.594   30.814   28.853   30.917   29.120];
***** assert (__spatial_filtering__ (a, domain, "std", s), out, 0.001);

 out = [ 95   96   96   93   78   54   54   79
         69   89   93   93   93   89   72   72
         88   89   81   74   86   89   72   81
         88   88   88   91   91   91   77   89
         96   96   88   89   89   67   84   95
         89   94   87   95   95   62   84   75
         89   94   78   94   84   63   95   95
         87   92   80   94   84   76   92   96];
***** assert (__spatial_filtering__ (a, domain, "range", s), out);

 domain = [ 1 1 0
            0 1 1
            0 1 0];

 out = [  2    2    1   16   36   36   38   39
         60    1    1   16    1   36   19   18
         32    2    1    1    1   19   18   18
          2    2   18    3    1    1   19   10
         46    2    2    3   18   38   10    4
         11    9    4    3    3   36    4    4
          9    4    4   10   36   36   38    4
         37    9    4    4   33   36    7    7];
***** assert (__spatial_filtering__ (a, domain, "min", s), out);
***** assert (__spatial_filtering__ (a, domain, "ordered", s, 1), out);

 out = [ 82   97   97   94   79   76   90   81
         90   82   56   94   94   90   90   81
         90   82   78   36   87   87   90   90
         90   90   82   43   92   87   87   99
         98   90   79   92   92   88   79   25
         98   90   90   90   98   92   79   79
         98   98   50   98   98   90   99   57
         96   82   62   84   98   99   99   53];
***** assert (__spatial_filtering__ (a, domain, "max", s), out);
***** assert (__spatial_filtering__ (a, domain, "ordered", s, nnz (domain)), out);

 out = [ 68   78   94   79   77   43   75   75
         78   78   41   75   77   87   81   75
         82   78   48   18   75   76   76   81
         64   90   79   41   43   39   79   22
         90   79   48   48   90   79   38   22
         46   46   79   79   92   88   47   76
         76   82   33   40   90   88   88   53
         82   50   50   74   89   98   47   47];
***** assert (__spatial_filtering__ (a, domain, "ordered", s, 4), out);

 out = [ 34.2389   39.2772   39.6699   31.6812   20.7364   16.5439   22.2419   17.2395
         11.9248   36.3084   21.6217   30.8350   36.4047   21.6726   30.9144   26.1017
         22.2980   33.2746   27.5808   14.5017   36.8890   29.0259   34.6020   33.2521
         32.2490   37.9579   26.9685   17.1959   32.5346   31.3847   33.5976   36.8280
         21.3354   40.1833   34.0044   33.9882   32.9894   24.1102   25.6613    9.0995
         35.4641   35.3794   39.0871   35.4753   39.9775   28.7193   26.7451   35.6553
         35.2179   45.3398   19.3210   35.2987   28.4042   24.0832   26.8421   25.0539
         23.4307   26.2812   26.3287   35.6959   25.2646   28.1016   34.9829   17.9221];
***** assert (__spatial_filtering__ (a, domain, "std", s), out, 0.001);

 out = [ 80   95   96   78   43   40   52   42
         30   81   55   78   93   54   71   63
         58   80   77   35   86   68   72   72
         88   88   64   40   91   86   68   89
         52   88   77   89   74   50   69   21
         87   81   86   87   95   56   75   75
         89   94   46   88   62   54   61   53
         59   73   58   80   65   63   92   46];
***** assert (__spatial_filtering__ (a, domain, "range", s), out);

 s = [  1  -3   4
        6  -7   2
       -1   3  -5];

 out = [ -1    3    4   19   38   29   31   41
         61    3   -6    9    4   33   22   21
         33    5   -2    2   -6   21   12   11
          4   -5   20    6   -2    2   16   13
         39   -1    3   -4   19   32   12    3
         13    4    3    0    4   36    6   -3
         11    2   -3   11   38   29   35    1
         34    6    1    5   34   33    9    0];
***** assert (__spatial_filtering__ (a, domain, "min", s), out);
***** assert (__spatial_filtering__ (a, domain, "ordered", s, 1), out);

 out = [  83    94    98    87    80    79    93    84
          93    85    53    91    95    92    83    74
          84    75    79    29    89    80    87    91
          87    93    83    45    95    84    88   101
         101    83    72    94    93    91    72    26
          91    87    91    92   101    93    76    80
          95    99    53   100    91    91   102    59
          99    75    65    87    95   101    92    50];
***** assert (__spatial_filtering__ (a, domain, "max", s), out);
***** assert (__spatial_filtering__ (a, domain, "ordered", s, nnz (domain)), out);

 out = [  71    81    96    79    78    44    77    68
          80    71    44    77    78    90    83    72
          83    75    51    21    72    76    77    78
          57    91    82    42    40    42    82    20
          92    81    45    49    85    81    41    24
          43    47    76    80    90    81    50    78
          79    85    35    37    87    85    89    46
          84    52    43    76    92   100    44    48];
***** assert (__spatial_filtering__ (a, domain, "ordered", s, 4), out);

 out = [ 34.903   40.206   39.885   28.627   20.620   19.248   25.209   17.111
         14.536   35.865   23.221   32.230   34.903   23.923   28.879   22.621
         20.635   30.113   29.351   11.610   38.863   25.936   34.608   34.482
         29.811   40.998   28.279   17.897   34.666   29.978   36.150   38.213
         25.066   39.240   30.013   37.300   31.856   27.428   22.884   10.281
         31.890   34.761   39.645   37.526   39.336   27.031   25.648   39.285
         35.017   47.776   22.764   35.912   25.460   25.636   29.861   24.566
         25.213   25.000   26.391   38.451   24.631   31.305   31.118   20.611];
***** assert (__spatial_filtering__ (a, domain, "std", s), out, 0.001);

 out = [ 84   91   94   68   42   50   62   43
         32   82   59   82   91   59   61   53
         51   70   81   27   95   59   75   80
         83   98   63   39   97   82   72   88
         62   84   69   98   74   59   60   23
         78   83   88   92   97   57   70   83
         84   97   56   89   53   62   67   58
         65   69   64   82   61   68   83   50];
***** assert (__spatial_filtering__ (a, domain, "range", s), out);
21 tests, 21 passed, 0 known failure, 0 skipped
[bwdist]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/bwdist.cc
***** shared bw

 bw = [0   1   0   1   0   1   1   0
       0   0   0   1   1   0   0   0
       0   0   0   1   1   0   0   0
       0   0   0   1   1   0   0   0
       0   0   1   1   1   1   1   1
       1   1   1   1   0   0   0   1
       1   1   1   0   0   0   1   0
       0   0   1   0   0   0   1   1];
***** test
 out = [ 1.00000   0.00000   1.00000   0.00000   1.00000   0.00000   0.00000   1.00000
         1.41421   1.00000   1.00000   0.00000   0.00000   1.00000   1.00000   1.41421
         2.23607   2.00000   1.00000   0.00000   0.00000   1.00000   2.00000   2.00000
         2.00000   1.41421   1.00000   0.00000   0.00000   1.00000   1.00000   1.00000
         1.00000   1.00000   0.00000   0.00000   0.00000   0.00000   0.00000   0.00000
         0.00000   0.00000   0.00000   0.00000   1.00000   1.00000   1.00000   0.00000
         0.00000   0.00000   0.00000   1.00000   1.41421   1.00000   0.00000   1.00000
         1.00000   1.00000   0.00000   1.00000   2.00000   1.00000   0.00000   0.00000];
 out = single (out);

 assert (bwdist (bw), out, 0.0001);  # default is euclidean
 assert (bwdist (bw, "euclidean"), out, 0.0001);
 assert (bwdist (logical (bw), "euclidean"), out, 0.0001);
***** test
 out = [ 1   0   1   0   1   0   0   1
         1   1   1   0   0   1   1   1
         2   2   1   0   0   1   2   2
         2   1   1   0   0   1   1   1
         1   1   0   0   0   0   0   0
         0   0   0   0   1   1   1   0
         0   0   0   1   1   1   0   1
         1   1   0   1   2   1   0   0];
 out = single (out);

 assert (bwdist (bw, "chessboard"), out);
***** test
 out = [ 1   0   1   0   1   0   0   1
         2   1   1   0   0   1   1   2
         3   2   1   0   0   1   2   2
         2   2   1   0   0   1   1   1
         1   1   0   0   0   0   0   0
         0   0   0   0   1   1   1   0
         0   0   0   1   2   1   0   1
         1   1   0   1   2   1   0   0];
 out = single (out);

 assert (bwdist (bw, "cityblock"), out);
***** test
 out = [ 1.00000   0.00000   1.00000   0.00000   1.00000   0.00000   0.00000   1.00000
         1.41421   1.00000   1.00000   0.00000   0.00000   1.00000   1.00000   1.41421
         2.41421   2.00000   1.00000   0.00000   0.00000   1.00000   2.00000   2.00000
         2.00000   1.41421   1.00000   0.00000   0.00000   1.00000   1.00000   1.00000
         1.00000   1.00000   0.00000   0.00000   0.00000   0.00000   0.00000   0.00000
         0.00000   0.00000   0.00000   0.00000   1.00000   1.00000   1.00000   0.00000
         0.00000   0.00000   0.00000   1.00000   1.41421   1.00000   0.00000   1.00000
         1.00000   1.00000   0.00000   1.00000   2.00000   1.00000   0.00000   0.00000];
 out = single (out);

 assert (bwdist (bw, "quasi-euclidean"), out, 0.0001);

 bw(logical (bw)) = 3; # there is no actual check if matrix is binary or 0 and 1
 assert (bwdist (bw, "quasi-euclidean"), out, 0.0001);

 bw(logical (bw)) = -2; # anything non-zero is considered object
 assert (bwdist (bw, "quasi-euclidean"), out, 0.0001);
***** test
 bw =    [  1   1   1   1   0   1   1   1   1
            1   1   1   1   0   1   1   1   1
            1   1   0   1   1   1   1   1   1
            0   1   1   1   1   1   1   1   1];

 dist = [   0   0   0   0   1   0   0   0   0
            0   0   0   0   1   0   0   0   0
            0   0   1   0   0   0   0   0   0
            1   0   0   0   0   0   0   0   0];
 dist = single (dist);

 c =    [   1   5   9  13  13  21  25  29  33
            2   6  10  14  14  22  26  30  34
            3   7  10  15  19  23  27  31  35
            8   8  12  16  20  24  28  32  36];
 c = uint32 (c);

 [dout, cout] = bwdist (bw, "euclidean");
 assert (dout, dist)
 assert (cout, c)
***** test
 bw = [  0   1   1   0   0   0   1   0
         0   0   0   0   0   0   0   0
         1   1   0   0   0   0   0   0
         0   0   0   0   0   0   1   0
         0   0   0   0   1   0   0   1
         0   0   0   0   0   0   0   0
         1   0   0   0   0   0   0   0
         0   0   1   0   0   1   1   0];
 out = single ([
 1.00000   0.00000   0.00000   1.00000   2.00000   1.00000   0.00000   1.00000
 1.00000   1.00000   1.00000   sqrt(2)   sqrt(2)+1 sqrt(2)   1.00000   sqrt(2)
 0.00000   0.00000   1.00000   2.00000   2.00000   sqrt(2)   1.00000   sqrt(2)
 1.00000   1.00000   sqrt(2)   sqrt(2)   1.00000   1.00000   0.00000   1.00000
 2.00000   2.00000   2.00000   1.00000   0.00000   1.00000   1.00000   0.00000
 1.00000   sqrt(2)   2.00000   sqrt(2)   1.00000   sqrt(2)   sqrt(2)   1.00000
 0.00000   1.00000   1.00000   sqrt(2)   sqrt(2)   1.00000   1.00000   sqrt(2)
 1.00000   1.00000   0.00000   1.00000   1.00000   0.00000   0.00000   1.00000
 ]);
 assert (bwdist (bw, "quasi-euclidean"), out);
***** error <unknown METHOD> bwdist (bw, "not a valid method");
7 tests, 7 passed, 0 known failure, 0 skipped
[bwlabeln]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/bwlabeln.cc
***** shared a2d, a3d
 a2d = [1   0   0   0   0   0   1   0   0   1
        1   0   0   1   0   1   0   1   0   1
        1   0   1   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   1   1   1   0   0   0   0
        1   1   0   1   0   0   0   1   0   0
        1   1   0   0   0   0   1   0   1   0
        1   1   0   0   0   0   0   0   0   0
        1   1   0   0   0   1   1   0   0   1];

 a3d = a2d;
 a3d(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
        1   0   0   1   1   0   0   1   0   0
        0   0   0   1   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   1   0   0   0   0   0   0   0   0
        1   1   0   0   1   1   0   0   0   0
        1   1   0   1   0   0   0   0   0   0
        1   0   0   0   0   0   1   0   0   0
        0   1   0   0   0   0   0   0   0   1
        1   1   0   0   0   0   1   0   0   0];

 a3d(:,:,3) = [
        1   0   0   0   0   0   0   0   0   0
        0   1   0   1   1   0   0   1   0   0
        0   0   0   1   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   1   1   1   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        1   0   0   0   0   0   0   0   0   0
        1   1   0   0   0   0   0   0   0   1
        1   1   0   0   0   0   0   0   0   0];
***** test
 label2dc4 = [
        1   0   0   0   0   0   8   0   0  13
        1   0   0   4   0   6   0  10   0  13
        1   0   3   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   2   0   0   0   0   0   0   0   0
        2   2   0   5   5   5   0   0   0   0
        2   2   0   5   0   0   0  11   0   0
        2   2   0   0   0   0   9   0  12   0
        2   2   0   0   0   0   0   0   0   0
        2   2   0   0   0   7   7   0   0  14];
 assert (bwlabeln (a2d, 4), label2dc4)
 assert (bwlabeln (a2d, [0 1 0; 1 1 1; 0 1 0]), label2dc4)
 assert (bwlabeln (a2d, conndef (2, "minimal")), label2dc4)
 assert (bwlabeln (a2d, conndef (3, "minimal")), label2dc4)
***** test
 label2dc8 = [
        1   0   0   0   0   0   5   0   0   8
        1   0   0   3   0   5   0   5   0   8
        1   0   3   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   2   0   0   0   0   0   0   0   0
        2   2   0   4   4   4   0   0   0   0
        2   2   0   4   0   0   0   7   0   0
        2   2   0   0   0   0   7   0   7   0
        2   2   0   0   0   0   0   0   0   0
        2   2   0   0   0   6   6   0   0   9];
 assert (bwlabeln (a2d, 8), label2dc8)
 assert (bwlabeln (a2d, ones (3)), label2dc8)
 assert (bwlabeln (a2d, conndef (2, "maximal")), label2dc8)
 assert (bwlabeln (a2d, conndef (3, "maximal")), label2dc8)
***** test
 label3dc8 = [
        1   0   0   0   0   0   5   0   0   8
        1   0   0   3   0   5   0   5   0   8
        1   0   3   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   2   0   0   0   0   0   0   0   0
        2   2   0   4   4   4   0   0   0   0
        2   2   0   4   0   0   0   7   0   0
        2   2   0   0   0   0   7   0   7   0
        2   2   0   0   0   0   0   0   0   0
        2   2   0   0   0   6   6   0   0   9];
 label3dc8(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
       10   0   0  12  12   0   0  16   0   0
        0   0   0  12   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0  11   0   0   0   0   0   0   0   0
       11  11   0   0  13  13   0   0   0   0
       11  11   0  13   0   0   0   0   0   0
       11   0   0   0   0   0  14   0   0   0
        0  11   0   0   0   0   0   0   0  17
       11  11   0   0   0   0  15   0   0   0];
 label3dc8(:,:,3) = [
       18   0   0   0   0   0   0   0   0   0
        0  18   0  20  20   0   0  22   0   0
        0   0   0  20   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0  21  21  21   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
       19   0   0   0   0   0   0   0   0   0
       19  19   0   0   0   0   0   0   0  23
       19  19   0   0   0   0   0   0   0   0];
 assert (bwlabeln (a3d, 8), label3dc8)
 assert (bwlabeln (a3d, ones (3, 3)), label3dc8)
 assert (bwlabeln (a3d, conndef (2, "maximal")), label3dc8)
***** test
 label3dc26 = [
        1   0   0   0   0   0   3   0   0   7
        1   0   0   3   0   3   0   3   0   7
        1   0   3   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   2   0   0   0   0   0   0   0   0
        2   2   0   4   4   4   0   0   0   0
        2   2   0   4   0   0   0   6   0   0
        2   2   0   0   0   0   6   0   6   0
        2   2   0   0   0   0   0   0   0   0
        2   2   0   0   0   5   5   0   0   6];
 label3dc26(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
        1   0   0   3   3   0   0   3   0   0
        0   0   0   3   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   2   0   0   0   0   0   0   0   0
        2   2   0   0   4   4   0   0   0   0
        2   2   0   4   0   0   0   0   0   0
        2   0   0   0   0   0   6   0   0   0
        0   2   0   0   0   0   0   0   0   6
        2   2   0   0   0   0   5   0   0   0];
 label3dc26(:,:,3) = [
        1   0   0   0   0   0   0   0   0   0
        0   1   0   3   3   0   0   3   0   0
        0   0   0   3   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   4   4   4   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        2   0   0   0   0   0   0   0   0   0
        2   2   0   0   0   0   0   0   0   6
        2   2   0   0   0   0   0   0   0   0];
 assert (bwlabeln (a3d, 26), label3dc26)
 assert (bwlabeln (a3d, ones (3, 3, 3)), label3dc26)
 assert (bwlabeln (a3d, conndef (3, "maximal")), label3dc26)
***** test
 label3dc18 = [
        1   0   0   0   0   0   3   0   0   7
        1   0   0   3   0   3   0   3   0   7
        1   0   3   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   2   0   0   0   0   0   0   0   0
        2   2   0   4   4   4   0   0   0   0
        2   2   0   4   0   0   0   6   0   0
        2   2   0   0   0   0   6   0   6   0
        2   2   0   0   0   0   0   0   0   0
        2   2   0   0   0   5   5   0   0   8];
 label3dc18(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
        1   0   0   3   3   0   0   3   0   0
        0   0   0   3   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   2   0   0   0   0   0   0   0   0
        2   2   0   0   4   4   0   0   0   0
        2   2   0   4   0   0   0   0   0   0
        2   0   0   0   0   0   6   0   0   0
        0   2   0   0   0   0   0   0   0   8
        2   2   0   0   0   0   5   0   0   0];
 label3dc18(:,:,3) = [
        1   0   0   0   0   0   0   0   0   0
        0   1   0   3   3   0   0   3   0   0
        0   0   0   3   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   4   4   4   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        2   0   0   0   0   0   0   0   0   0
        2   2   0   0   0   0   0   0   0   8
        2   2   0   0   0   0   0   0   0   0];
 assert (bwlabeln (a3d, 18), label3dc18)
***** test
 label2dc3 = [
        1   0   0   0   0   0  11   0   0  17
        1   0   0   5   0   8   0  14   0  17
        1   0   4   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   3   0   0   0   0   0   0   0   0
        2   3   0   6   7   9   0   0   0   0
        2   3   0   6   0   0   0  15   0   0
        2   3   0   0   0   0  12   0  16   0
        2   3   0   0   0   0   0   0   0   0
        2   3   0   0   0  10  13   0   0  18];
 assert (bwlabeln (a2d, [1 1 1]'), label2dc3)

 label3dc3 = label2dc3;
 label3dc3(:,:,2) = [
        0   0   0   0   0   0   0   0   0   0
       19   0   0  24  26   0   0  31   0   0
        0   0   0  24   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0  22   0   0   0   0   0   0   0   0
       20  22   0   0  27  28   0   0   0   0
       20  22   0  25   0   0   0   0   0   0
       20   0   0   0   0   0  29   0   0   0
        0  23   0   0   0   0   0   0   0  32
       21  23   0   0   0   0  30   0   0   0];
 label3dc3(:,:,3) = [
       33   0   0   0   0   0   0   0   0   0
        0  35   0  37  39   0   0  42   0   0
        0   0   0  37   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
        0   0   0  38  40  41   0   0   0   0
        0   0   0   0   0   0   0   0   0   0
       34   0   0   0   0   0   0   0   0   0
       34  36   0   0   0   0   0   0   0  43
       34  36   0   0   0   0   0   0   0   0];
 assert (bwlabeln (a3d, [1 1 1]'), label3dc3)
***** test
 label2dc1 = zeros (size (a2d));
 label2dc1(a2d != 0) = 1:nnz (a2d);
 assert (bwlabeln (a2d, [1]), label2dc1);
 assert (bwlabeln (a2d, [0 1 0]'), label2dc1);

 label3dc1 = zeros (size (a3d));
 label3dc1(a3d != 0) = 1:nnz (a3d);
 assert (bwlabeln (a3d, [1]), label3dc1);
 assert (bwlabeln (a3d, [0 1 0]'), label3dc1);
***** shared in
 in = rand (10) > 0.8;
***** assert (bwlabel (in, 4), bwlabeln (in, 4));
***** assert (bwlabel (in, 4), bwlabeln (in, [0 1 0; 1 1 1; 0 1 0]));
***** assert (bwlabel (in, 8), bwlabeln (in, 8));
***** assert (bwlabel (in, 8), bwlabeln (in, [1 1 1; 1 1 1; 1 1 1]));
***** assert (bwlabel (logical ([0 1 0; 0 0 0; 1 0 1])), [0 2 0; 0 0 0; 1 0 3]);
***** assert (bwlabel ([0 1 0; 0 0 0; 1 0 1]), [0 2 0; 0 0 0; 1 0 3]);
***** assert (bwlabel ([0 -1 0; 0 0 0; 5 0 0.2]), [0 2 0; 0 0 0; 1 0 3]);
***** shared in, out

 in = [  0   1   1   0   0   1   0   0   0   0
         0   0   0   1   0   0   0   0   0   1
         0   1   1   0   0   0   0   0   1   1
         1   0   0   0   0   0   0   1   0   0
         0   0   0   0   0   1   1   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   1   0   0   0   0   0   0
         0   0   0   0   1   1   0   1   0   0
         0   0   0   1   0   1   0   1   0   1
         1   1   0   0   0   0   0   1   1   0];

 out = [ 0   3   3   0   0   9   0   0   0   0
         0   0   0   5   0   0   0   0   0  13
         0   4   4   0   0   0   0   0  13  13
         1   0   0   0   0   0   0  11   0   0
         0   0   0   0   0  10  10   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   6   0   0   0   0   0   0
         0   0   0   0   8   8   0  12   0   0
         0   0   0   7   0   8   0  12   0  14
         2   2   0   0   0   0   0  12  12   0];
***** assert (nthargout ([1 2], @bwlabel, in, 4), {out, 14});
***** assert (nthargout ([1 2], @bwlabel, logical (in), 4), {out, 14});

 out = [ 0   3   3   0   0   7   0   0   0   0
         0   0   0   3   0   0   0   0   0  11
         0   4   4   0   0   0   0   0  11  11
         1   0   0   0   0   0   0   9   0   0
         0   0   0   0   0   8   8   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   5   0   0   0   0   0   0
         0   0   0   0   5   5   0  10   0   0
         0   0   0   6   0   5   0  10   0  12
         2   2   0   0   0   0   0  10  10   0];
***** assert (nthargout ([1 2], @bwlabel, in, 6), {out, 12});
***** assert (nthargout ([1 2], @bwlabel, logical (in), 6), {out, 12});

 ## The labeled image is not the same as Matlab, but they are
 ## labeled correctly. Do we really need to get them properly
 ## ordered? (the algorithm in bwlabeln does it)
 mout = [0   1   1   0   0   4   0   0   0   0
         0   0   0   1   0   0   0   0   0   5
         0   1   1   0   0   0   0   0   5   5
         1   0   0   0   0   0   0   5   0   0
         0   0   0   0   0   5   5   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   3   0   0   0   0   0   0
         0   0   0   0   3   3   0   6   0   0
         0   0   0   3   0   3   0   6   0   6
         2   2   0   0   0   0   0   6   6   0];

 out = [ 0   2   2   0   0   4   0   0   0   0
         0   0   0   2   0   0   0   0   0   5
         0   2   2   0   0   0   0   0   5   5
         2   0   0   0   0   0   0   5   0   0
         0   0   0   0   0   5   5   0   0   0
         0   0   0   0   0   0   0   0   0   0
         0   0   0   3   0   0   0   0   0   0
         0   0   0   0   3   3   0   6   0   0
         0   0   0   3   0   3   0   6   0   6
         1   1   0   0   0   0   0   6   6   0];
***** assert (nthargout ([1 2], @bwlabel, in, 8), {out, 6});
***** assert (nthargout ([1 2], @bwlabel, logical (in), 8), {out, 6});

***** error bwlabel (rand (10, 10, 10) > 0.8, 4)
***** error bwlabel (rand (10) > 0.8, "text")
***** error bwlabel ("text", 6)
23 tests, 23 passed, 0 known failure, 0 skipped
[conndef]
>>>>> /var/tmp/autopkgtest.ccVgDx/build.jQf/real-tree/src/conndef.cc
***** assert (conndef (1, "minimal"), [1; 1; 1]);
***** assert (conndef (2, "minimal"), [0 1 0; 1 1 1; 0 1 0]);
***** test
 C = zeros (3, 3, 3);
 C(:,2,2) = 1;
 C(2,:,2) = 1;
 C(2,2,:) = 1;
 assert (conndef (3, "minimal"), C);
***** test
 C = zeros (3, 3, 3, 3);
 C(:,:,2,1) = [0   0   0
               0   1   0
               0   0   0];
 C(:,:,1,2) = [0   0   0
               0   1   0
               0   0   0];
 C(:,:,2,2) = [0   1   0
               1   1   1
               0   1   0];
 C(:,:,3,2) = [0   0   0
               0   1   0
               0   0   0];
 C(:,:,2,3) = [0   0   0
               0   1   0
               0   0   0];
 assert (conndef (4, "minimal"), C);
***** assert (conndef (1, "maximal"), ones (3, 1));
***** assert (conndef (2, "maximal"), ones (3, 3));
***** assert (conndef (3, "maximal"), ones (3, 3, 3));
***** assert (conndef (4, "maximal"), ones (3, 3, 3, 3));
***** assert (nnz (conndef (3, "minimal")), 7)
***** assert (nnz (conndef (4, "minimal")), 9)
***** assert (nnz (conndef (5, "minimal")), 11)
***** assert (nnz (conndef (6, "minimal")), 13)
***** assert (find (conndef (3, "minimal")), [5 11 13 14 15 17 23](:))
***** assert (find (conndef (4, "minimal")), [14 32 38 40 41 42 44 50 68](:))
***** assert (find (conndef (5, "minimal")),
        [   41   95  113  119  121  122  123  125  131  149  203](:))
***** assert (find (conndef (6, "minimal")),
        [  122  284  338  356  362  364  365  366  368  374  392  446  608](:))
***** error conndef ()
***** error <must be a positive integer> conndef (-2, "minimal")
***** error conndef (char (2), "minimal")
***** error conndef ("minimal", 3)
***** error <TYPE must be "maximal" or "minimal"> conndef (3, "invalid")
***** error <CONN must be logical or in the set> conndef (10)
***** assert (conndef (2, "minimal"), conndef (4))
***** assert (conndef (2, "maximal"), conndef (8))
***** assert (conndef (3, "minimal"), conndef (6))
***** assert (conndef (3, "maximal"), conndef (26))
***** assert (conndef (18), reshape ([0 1 0 1 1 1 0 1 0
                                1 1 1 1 1 1 1 1 1
                                0 1 0 1 1 1 0 1 0], [3 3 3]))
***** error <expected error> fail ("iptcheckconn ( 4, 'func', 'var')");
***** error <expected error> fail ("iptcheckconn ( 6, 'func', 'var')");
***** error <expected error> fail ("iptcheckconn ( 8, 'func', 'var')");
***** error <expected error> fail ("iptcheckconn (18, 'func', 'var')");
***** error <expected error> fail ("iptcheckconn (26, 'func', 'var')");
***** error <expected error> fail ("iptcheckconn (1, 'func', 'var')");
***** error <expected error> fail ("iptcheckconn (ones (3, 1), 'func', 'var')");
***** error <expected error> fail ("iptcheckconn (ones (3, 3), 'func', 'var')");
***** error <expected error> fail ("iptcheckconn (ones (3, 3, 3), 'func', 'var')");
***** error <expected error> fail ("iptcheckconn (ones (3, 3, 3, 3), 'func', 'var')");
***** error <VAR must be logical or in> iptcheckconn (3, "func", "VAR");
***** error <VAR center is not true> iptcheckconn ([1 1 1; 1 0 1; 1 1 1], "func", "VAR");
***** error <VAR must be logical or in> iptcheckconn ([1 2 1; 1 1 1; 1 1 1], "func", "VAR");
***** error <VAR is not symmetric relative to its center> iptcheckconn ([0 1 1; 1 1 1; 1 1 1], "func", "VAR");
***** error <VAR is not 1x1, 3x1, 3x3, or 3x3x...x3> iptcheckconn (ones (3, 3, 3, 4), "func", "VAR");
42 tests, 42 passed, 0 known failure, 0 skipped
Summary: 1169 tests, 1134 passed, 21 known failures, 0 skipped
/usr/share/cdbs/1/class/octave-pkg.mk:108: recipe for target 'check-pkg' failed
make: *** [check-pkg] Error 1
autopkgtest [11:06:09]: test unit-tests: -----------------------]
autopkgtest [11:06:09]: test unit-tests:  - - - - - - - - - - results - - - - - - - - - -
unit-tests           FAIL non-zero exit status 2
autopkgtest [11:06:09]: @@@@@@@@@@@@@@@@@@@@ summary
unit-tests           FAIL non-zero exit status 2


More information about the Pkg-octave-devel mailing list