nihui
/
ncnn
Not watched
1
0
Fork 0
Code
Releases 46 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
ncnn/tests/test_crop_1.cpp

377 lines
17 kB
Raw Permalink Blame History 

  1. // Copyright 2020 Tencent

  2. // SPDX-License-Identifier: BSD-3-Clause

  3. 

  4. #include "testutil.h"

  5. 

  6. static std::vector<int> IntArray(int a0)

  7. {

  8.     std::vector<int> m(1);

  9.     m[0] = a0;

  10.     return m;

  11. }

  12. 

  13. static std::vector<int> IntArray(int a0, int a1)

  14. {

  15.     std::vector<int> m(2);

  16.     m[0] = a0;

  17.     m[1] = a1;

  18.     return m;

  19. }

  20. 

  21. static std::vector<int> IntArray(int a0, int a1, int a2)

  22. {

  23.     std::vector<int> m(3);

  24.     m[0] = a0;

  25.     m[1] = a1;

  26.     m[2] = a2;

  27.     return m;

  28. }

  29. 

  30. static std::vector<int> IntArray(int a0, int a1, int a2, int a3)

  31. {

  32.     std::vector<int> m(4);

  33.     m[0] = a0;

  34.     m[1] = a1;

  35.     m[2] = a2;

  36.     m[3] = a3;

  37.     return m;

  38. }

  39. 

  40. static void print_int_array(const std::vector<int>& a)

  41. {

  42.     fprintf(stderr, "[");

  43.     for (size_t i = 0; i < a.size(); i++)

  44.     {

  45.         fprintf(stderr, " %d", a[i]);

  46.     }

  47.     fprintf(stderr, " ]");

  48. }

  49. 

  50. static int test_crop(const ncnn::Mat& a, const std::vector<int>& starts_array, const std::vector<int>& ends_array, const std::vector<int>& axes_array)

  51. {

  52.     ncnn::Mat starts(starts_array.size());

  53.     {

  54.         int* p = starts;

  55.         for (size_t i = 0; i < starts_array.size(); i++)

  56.         {

  57.             p[i] = starts_array[i];

  58.         }

  59.     }

  60. 

  61.     ncnn::Mat ends(ends_array.size());

  62.     {

  63.         int* p = ends;

  64.         for (size_t i = 0; i < ends_array.size(); i++)

  65.         {

  66.             p[i] = ends_array[i];

  67.         }

  68.     }

  69. 

  70.     ncnn::Mat axes(axes_array.size());

  71.     {

  72.         int* p = axes;

  73.         for (size_t i = 0; i < axes_array.size(); i++)

  74.         {

  75.             p[i] = axes_array[i];

  76.         }

  77.     }

  78. 

  79.     ncnn::ParamDict pd;

  80.     pd.set(9, starts); // starts

  81.     pd.set(10, ends);  // ends

  82.     pd.set(11, axes);  // axes

  83. 

  84.     std::vector<ncnn::Mat> weights(0);

  85. 

  86.     int ret = test_layer("Crop", pd, weights, a);

  87.     if (ret != 0)

  88.     {

  89.         fprintf(stderr, "test_crop failed a.dims=%d a=(%d %d %d %d)", a.dims, a.w, a.h, a.d, a.c);

  90.         fprintf(stderr, " starts=");

  91.         print_int_array(starts_array);

  92.         fprintf(stderr, " ends=");

  93.         print_int_array(ends_array);

  94.         fprintf(stderr, " axes=");

  95.         print_int_array(axes_array);

  96.         fprintf(stderr, "\n");

  97.     }

  98. 

  99.     return ret;

  100. }

  101. 

  102. static int test_crop_1d(const ncnn::Mat& a)

  103. {

  104.     std::vector<int> params[][3] = {

  105.         {IntArray(12), IntArray(-233), IntArray(0)},

  106.         {IntArray(16), IntArray(-233), IntArray(0)},

  107.         {IntArray(11), IntArray(11 + 16), IntArray(0)},

  108.         {IntArray(12), IntArray(12 + 7), IntArray(-1)},

  109.         {IntArray(16), IntArray(16 + 12), std::vector<int>()},

  110.         {IntArray(11), IntArray(-7 + 1), IntArray(0)},

  111.         {IntArray(12), IntArray(-12 + 1), IntArray(-1)},

  112.         {IntArray(16), IntArray(-16 + 1), std::vector<int>()}

  113.     };

  114. 

  115.     for (int i = 0; i < sizeof(params) / sizeof(params[0]); i++)

  116.     {

  117.         int ret = test_crop(a, params[i][0], params[i][1], params[i][2]);

  118.         if (ret)

  119.             return ret;

  120.     }

  121. 

  122.     return 0;

  123. }

  124. 

  125. static int test_crop_2d(const ncnn::Mat& a)

  126. {

  127.     std::vector<int> params[][3] = {

  128.         {IntArray(12), IntArray(-233), IntArray(0)},

  129.         {IntArray(8), IntArray(-233), IntArray(0)},

  130.         {IntArray(4), IntArray(-233), IntArray(1)},

  131.         {IntArray(5, 11), IntArray(-233, -233), IntArray(0, 1)},

  132.         {IntArray(11), IntArray(11 + 16), IntArray(0)},

  133.         {IntArray(12), IntArray(12 + 7), IntArray(0)},

  134.         {IntArray(8), IntArray(8 + 12), IntArray(-2)},

  135.         {IntArray(5), IntArray(8), IntArray(1)},

  136.         {IntArray(6), IntArray(9), IntArray(1)},

  137.         {IntArray(4), IntArray(12), IntArray(-1)},

  138.         {IntArray(11, 5), IntArray(11 + 7, 11), IntArray(0, 1)},

  139.         {IntArray(12, 6), IntArray(12 + 12, 12), IntArray(0, 1)},

  140.         {IntArray(8, 4), IntArray(8 + 16, 10), IntArray(0, -1)},

  141.         {IntArray(11), IntArray(-16 + 1), IntArray(0)},

  142.         {IntArray(12), IntArray(-7 + 1), IntArray(0)},

  143.         {IntArray(8), IntArray(-12 + 1), IntArray(-2)},

  144.         {IntArray(5), IntArray(-5 + 1), IntArray(1)},

  145.         {IntArray(6), IntArray(-6 + 1), IntArray(1)},

  146.         {IntArray(4), IntArray(-4 + 1), IntArray(-1)},

  147.         {IntArray(11, 5), IntArray(-12 + 1, -6 + 1), IntArray(0, 1)},

  148.         {IntArray(12, 6), IntArray(-16 + 1, -5 + 1), IntArray(0, 1)},

  149.         {IntArray(8, 4), IntArray(-7 + 1, -4 + 1), IntArray(-2, -1)}

  150.     };

  151. 

  152.     for (int i = 0; i < sizeof(params) / sizeof(params[0]); i++)

  153.     {

  154.         int ret = test_crop(a, params[i][0], params[i][1], params[i][2]);

  155.         if (ret)

  156.             return ret;

  157.     }

  158. 

  159.     return 0;

  160. }

  161. 

  162. static int test_crop_3d(const ncnn::Mat& a)

  163. {

  164.     std::vector<int> params[][3] = {

  165.         {IntArray(11), IntArray(-233), IntArray(0)},

  166.         {IntArray(8), IntArray(-233), IntArray(0)},

  167.         {IntArray(5), IntArray(-233), IntArray(1)},

  168.         {IntArray(6), IntArray(-233), IntArray(2)},

  169.         {IntArray(4), IntArray(-233), IntArray(-1)},

  170.         {IntArray(12, 6), IntArray(-233, -233), IntArray(0, 1)},

  171.         {IntArray(11, 5), IntArray(-233, -233), IntArray(0, -1)},

  172.         {IntArray(8, 4), IntArray(-233, -233), IntArray(0, 2)},

  173.         {IntArray(6, 6), IntArray(-233, -233), IntArray(1, -1)},

  174.         {IntArray(11, 5, 5), IntArray(-233, -233, -233), IntArray(0, 1, 2)},

  175.         {IntArray(8, 4, 4), IntArray(-233, -233, -233), IntArray(0, 1, -1)},

  176.         {IntArray(11), IntArray(11 + 7), IntArray(0)},

  177.         {IntArray(12), IntArray(12 + 12), IntArray(0)},

  178.         {IntArray(8), IntArray(8 + 16), IntArray(0)},

  179.         {IntArray(5), IntArray(13), IntArray(1)},

  180.         {IntArray(6), IntArray(12), IntArray(1)},

  181.         {IntArray(4), IntArray(11), IntArray(-2)},

  182.         {IntArray(5), IntArray(12), IntArray(2)},

  183.         {IntArray(6), IntArray(11), IntArray(2)},

  184.         {IntArray(4), IntArray(13), IntArray(-1)},

  185.         {IntArray(11, 5), IntArray(11 + 7, 11), IntArray(0, 1)},

  186.         {IntArray(12, 6), IntArray(12 + 16, 12), IntArray(0, 1)},

  187.         {IntArray(8, 4), IntArray(8 + 12, 13), IntArray(0, -2)},

  188.         {IntArray(11, 5), IntArray(11 + 16, 13), IntArray(0, 2)},

  189.         {IntArray(12, 6), IntArray(12 + 12, 11), IntArray(0, 2)},

  190.         {IntArray(8, 4), IntArray(8 + 7, 12), IntArray(0, -1)},

  191.         {IntArray(5, 4), IntArray(12, 12), IntArray(1, 2)},

  192.         {IntArray(6, 3), IntArray(13, 13), IntArray(1, 2)},

  193.         {IntArray(4, 2), IntArray(11, 11), IntArray(-2, -1)},

  194.         {IntArray(11, 5, 2), IntArray(11 + 7, 11, 11), IntArray(0, 1, 2)},

  195.         {IntArray(12, 6, 4), IntArray(12 + 16, 12, 12), IntArray(0, 1, 2)},

  196.         {IntArray(8, 4, 3), IntArray(8 + 12, 13, 13), IntArray(-3, -2, -1)},

  197.         {IntArray(11), IntArray(-7 + 1), IntArray(0)},

  198.         {IntArray(12), IntArray(-12 + 1), IntArray(0)},

  199.         {IntArray(8), IntArray(-16 + 1), IntArray(-3)},

  200.         {IntArray(5), IntArray(-6 + 1), IntArray(1)},

  201.         {IntArray(6), IntArray(-5 + 1), IntArray(1)},

  202.         {IntArray(4), IntArray(-4 + 1), IntArray(-2)},

  203.         {IntArray(5), IntArray(-5 + 1), IntArray(2)},

  204.         {IntArray(6), IntArray(-4 + 1), IntArray(2)},

  205.         {IntArray(4), IntArray(-6 + 1), IntArray(-1)},

  206.         {IntArray(11, 5), IntArray(-7 + 1, -4 + 1), IntArray(0, 1)},

  207.         {IntArray(12, 6), IntArray(-12 + 1, -6 + 1), IntArray(0, 1)},

  208.         {IntArray(8, 4), IntArray(-16 + 1, -5 + 1), IntArray(-3, -2)},

  209.         {IntArray(11, 5), IntArray(-12 + 1, -6 + 1), IntArray(0, 2)},

  210.         {IntArray(12, 6), IntArray(-16 + 1, -5 + 1), IntArray(0, 2)},

  211.         {IntArray(8, 4), IntArray(-7 + 1, -4 + 1), IntArray(-3, -1)},

  212.         {IntArray(5, 2), IntArray(-5 + 1, -5 + 1), IntArray(1, 2)},

  213.         {IntArray(6, 4), IntArray(-4 + 1, -4 + 1), IntArray(1, 2)},

  214.         {IntArray(4, 3), IntArray(-6 + 1, -6 + 1), IntArray(-2, -1)},

  215.         {IntArray(11, 5, 4), IntArray(-7 + 1, -5 + 1, -5 + 1), IntArray(0, 1, 2)},

  216.         {IntArray(12, 6, 3), IntArray(-12 + 1, -6 + 1, -6 + 1), IntArray(0, 1, 2)},

  217.         {IntArray(8, 4, 2), IntArray(-16 + 1, -4 + 1, -4 + 1), IntArray(-3, -2, -1)}

  218.     };

  219. 

  220.     for (int i = 0; i < sizeof(params) / sizeof(params[0]); i++)

  221.     {

  222.         int ret = test_crop(a, params[i][0], params[i][1], params[i][2]);

  223.         if (ret)

  224.             return ret;

  225.     }

  226. 

  227.     return 0;

  228. }

  229. 

  230. static int test_crop_4d(const ncnn::Mat& a)

  231. {

  232.     std::vector<int> params[][3] = {

  233.         {IntArray(11), IntArray(-233), IntArray(0)},

  234.         {IntArray(8), IntArray(-233), IntArray(0)},

  235.         {IntArray(6), IntArray(-233), IntArray(1)},

  236.         {IntArray(5), IntArray(-233), IntArray(2)},

  237.         {IntArray(4), IntArray(-233), IntArray(-2)},

  238.         {IntArray(6), IntArray(-233), IntArray(3)},

  239.         {IntArray(5), IntArray(-233), IntArray(-1)},

  240.         {IntArray(8, 4), IntArray(-233, -233), IntArray(0, 1)},

  241.         {IntArray(12, 6), IntArray(-233, -233), IntArray(0, 2)},

  242.         {IntArray(11, 5), IntArray(-233, -233), IntArray(-4, -2)},

  243.         {IntArray(4, 4), IntArray(-233, -233), IntArray(1, 2)},

  244.         {IntArray(12, 6), IntArray(-233, -233), IntArray(0, 3)},

  245.         {IntArray(5, 5), IntArray(-233, -233), IntArray(1, 3)},

  246.         {IntArray(4, 4), IntArray(-233, -233), IntArray(2, 3)},

  247.         {IntArray(12, 6, 6), IntArray(-233, -233, -233), IntArray(0, 1, 2)},

  248.         {IntArray(11, 5, 5), IntArray(-233, -233, -233), IntArray(0, 1, 2)},

  249.         {IntArray(8, 4, 4), IntArray(-233, -233, -233), IntArray(0, 1, 3)},

  250.         {IntArray(12, 6, 6), IntArray(-233, -233, -233), IntArray(0, 2, 3)},

  251.         {IntArray(11, 5, 5), IntArray(-233, -233, -233), IntArray(0, 2, 3)},

  252.         {IntArray(4, 4, 4), IntArray(-233, -233, -233), IntArray(1, 2, 3)},

  253.         {IntArray(6, 6, 6), IntArray(-233, -233, -233), IntArray(1, 2, 3)},

  254.         {IntArray(11, 5, 5, 5), IntArray(-233, -233, -233, -233), IntArray(0, 1, 2, 3)},

  255.         {IntArray(8, 4, 4, 4), IntArray(-233, -233, -233, -233), IntArray(0, 1, 2, 3)},

  256.         {IntArray(12, 6, 6, 6), IntArray(-233, -233, -233, -233), IntArray(-4, -3, -2, -1)},

  257.         {IntArray(11), IntArray(11 + 16), IntArray(0)},

  258.         {IntArray(12), IntArray(12 + 7), IntArray(0)},

  259.         {IntArray(8), IntArray(8 + 12), IntArray(-4)},

  260.         {IntArray(5), IntArray(11), IntArray(1)},

  261.         {IntArray(6), IntArray(13), IntArray(1)},

  262.         {IntArray(4), IntArray(12), IntArray(-3)},

  263.         {IntArray(3), IntArray(12), IntArray(2)},

  264.         {IntArray(4), IntArray(13), IntArray(2)},

  265.         {IntArray(5), IntArray(11), IntArray(-2)},

  266.         {IntArray(1), IntArray(8), IntArray(3)},

  267.         {IntArray(2), IntArray(7), IntArray(3)},

  268.         {IntArray(3), IntArray(6), IntArray(-1)},

  269.         {IntArray(11, 5), IntArray(11 + 7, 11), IntArray(0, 1)},

  270.         {IntArray(12, 6), IntArray(12 + 12, 12), IntArray(0, 1)},

  271.         {IntArray(8, 4), IntArray(8 + 16, 13), IntArray(-4, -3)},

  272.         {IntArray(11, 4), IntArray(11 + 12, 13), IntArray(0, 2)},

  273.         {IntArray(12, 3), IntArray(12 + 16, 11), IntArray(0, 2)},

  274.         {IntArray(8, 2), IntArray(8 + 7, 12), IntArray(-4, -2)},

  275.         {IntArray(11, 1), IntArray(11 + 16, 5), IntArray(0, 3)},

  276.         {IntArray(12, 2), IntArray(12 + 7, 6), IntArray(0, 3)},

  277.         {IntArray(8, 3), IntArray(8 + 12, 7), IntArray(-4, -1)},

  278.         {IntArray(3, 3), IntArray(13, 4), IntArray(1, 2)},

  279.         {IntArray(4, 2), IntArray(12, 3), IntArray(1, 2)},

  280.         {IntArray(5, 1), IntArray(11, 2), IntArray(-3, -2)},

  281.         {IntArray(5, 5), IntArray(11, 8), IntArray(1, 3)},

  282.         {IntArray(4, 6), IntArray(12, 9), IntArray(1, 3)},

  283.         {IntArray(3, 4), IntArray(13, 7), IntArray(-3, -1)},

  284.         {IntArray(2, 3), IntArray(12, 9), IntArray(2, 3)},

  285.         {IntArray(3, 2), IntArray(11, 7), IntArray(2, 3)},

  286.         {IntArray(4, 1), IntArray(10, 8), IntArray(-2, -1)},

  287.         {IntArray(11, 2, 2), IntArray(11 + 6, 9, 9), IntArray(0, 1, 2)},

  288.         {IntArray(12, 3, 3), IntArray(12 + 1, 10, 10), IntArray(0, 1, 2)},

  289.         {IntArray(8, 4, 4), IntArray(8 + 3, 11, 11), IntArray(-4, -3, -2)},

  290.         {IntArray(11, 4, 4), IntArray(11 + 12, 12, 12), IntArray(0, 1, 3)},

  291.         {IntArray(12, 5, 5), IntArray(12 + 8, 11, 11), IntArray(0, 1, 3)},

  292.         {IntArray(8, 6, 6), IntArray(8 + 4, 13, 13), IntArray(-4, -3, -1)},

  293.         {IntArray(11, 1, 4), IntArray(11 + 5, 12, 12), IntArray(0, 2, 3)},

  294.         {IntArray(12, 3, 3), IntArray(12 + 3, 11, 11), IntArray(0, 2, 3)},

  295.         {IntArray(8, 2, 5), IntArray(8 + 2, 10, 10), IntArray(-4, -2, -1)},

  296.         {IntArray(1, 1, 1), IntArray(7, 7, 7), IntArray(1, 2, 3)},

  297.         {IntArray(2, 2, 2), IntArray(8, 9, 10), IntArray(1, 2, 3)},

  298.         {IntArray(3, 3, 3), IntArray(11, 12, 13), IntArray(-3, -2, -1)},

  299.         {IntArray(11, 2, 3, 6), IntArray(11 + 11, 10, 12, 11), IntArray(0, 1, 2, 3)},

  300.         {IntArray(12, 3, 4, 5), IntArray(12 + 12, 9, 11, 13), IntArray(0, 1, 2, 3)},

  301.         {IntArray(8, 4, 5, 4), IntArray(8 + 8, 8, 10, 12), IntArray(-4, -3, -2, -1)},

  302.         {IntArray(11), IntArray(-7 + 1), IntArray(0)},

  303.         {IntArray(12), IntArray(-12 + 1), IntArray(0)},

  304.         {IntArray(8), IntArray(-16 + 1), IntArray(-4)},

  305.         {IntArray(5), IntArray(-6 + 1), IntArray(1)},

  306.         {IntArray(6), IntArray(-5 + 1), IntArray(1)},

  307.         {IntArray(4), IntArray(-4 + 1), IntArray(-3)},

  308.         {IntArray(4), IntArray(-4 + 1), IntArray(2)},

  309.         {IntArray(5), IntArray(-5 + 1), IntArray(2)},

  310.         {IntArray(6), IntArray(-6 + 1), IntArray(-2)},

  311.         {IntArray(1), IntArray(-5 + 1), IntArray(3)},

  312.         {IntArray(2), IntArray(-4 + 1), IntArray(3)},

  313.         {IntArray(3), IntArray(-3 + 1), IntArray(-1)},

  314.         {IntArray(11, 3), IntArray(-7 + 1, -3 + 1), IntArray(0, 1)},

  315.         {IntArray(12, 4), IntArray(-12 + 1, -4 + 1), IntArray(0, 1)},

  316.         {IntArray(8, 5), IntArray(-16 + 1, -5 + 1), IntArray(-4, -3)},

  317.         {IntArray(11, 1), IntArray(-12 + 1, -5 + 1), IntArray(0, 2)},

  318.         {IntArray(12, 2), IntArray(-16 + 1, -4 + 1), IntArray(0, 2)},

  319.         {IntArray(8, 3), IntArray(-7 + 1, -6 + 1), IntArray(-4, -2)},

  320.         {IntArray(11, 3), IntArray(-12 + 1, -2 + 1), IntArray(0, 3)},

  321.         {IntArray(12, 4), IntArray(-16 + 1, -3 + 1), IntArray(0, 3)},

  322.         {IntArray(8, 5), IntArray(-7 + 1, -4 + 1), IntArray(-4, -1)},

  323.         {IntArray(2, 3), IntArray(-4 + 1, -2 + 1), IntArray(1, 2)},

  324.         {IntArray(3, 4), IntArray(-2 + 1, -3 + 1), IntArray(1, 2)},

  325.         {IntArray(4, 5), IntArray(-3 + 1, -4 + 1), IntArray(-3, -2)},

  326.         {IntArray(3, 2), IntArray(-2 + 1, -4 + 1), IntArray(1, 3)},

  327.         {IntArray(4, 3), IntArray(-3 + 1, -2 + 1), IntArray(1, 3)},

  328.         {IntArray(5, 4), IntArray(-4 + 1, -3 + 1), IntArray(-3, -1)},

  329.         {IntArray(2, 3), IntArray(-4 + 1, -6 + 1), IntArray(2, 3)},

  330.         {IntArray(1, 2), IntArray(-5 + 1, -5 + 1), IntArray(2, 3)},

  331.         {IntArray(3, 1), IntArray(-6 + 1, -4 + 1), IntArray(-2, -1)},

  332.         {IntArray(11, 3, 3), IntArray(-7 + 1, -3 + 1, -4 + 1), IntArray(0, 1, 2)},

  333.         {IntArray(12, 4, 4), IntArray(-12 + 1, -4 + 1, -3 + 1), IntArray(0, 1, 2)},

  334.         {IntArray(8, 5, 5), IntArray(-16 + 1, -5 + 1, -5 + 1), IntArray(-4, -3, -2)},

  335.         {IntArray(11, 2, 2), IntArray(-7 + 1, -5 + 1, -4 + 1), IntArray(0, 1, 3)},

  336.         {IntArray(12, 1, 1), IntArray(-12 + 1, -6 + 1, -5 + 1), IntArray(0, 1, 3)},

  337.         {IntArray(8, 3, 3), IntArray(-16 + 1, -4 + 1, -6 + 1), IntArray(-4, -3, -1)},

  338.         {IntArray(11, 2, 5), IntArray(-7 + 1, -2 + 1, -5 + 1), IntArray(0, 2, 3)},

  339.         {IntArray(12, 3, 3), IntArray(-12 + 1, -3 + 1, -4 + 1), IntArray(0, 2, 3)},

  340.         {IntArray(8, 4, 4), IntArray(-16 + 1, -4 + 1, -3 + 1), IntArray(-4, -2, -1)},

  341.         {IntArray(1, 3, 3), IntArray(-3 + 1, -6 + 1, -4 + 1), IntArray(1, 2, 3)},

  342.         {IntArray(2, 2, 2), IntArray(-4 + 1, -4 + 1, -5 + 1), IntArray(1, 2, 3)},

  343.         {IntArray(3, 1, 1), IntArray(-5 + 1, -5 + 1, -6 + 1), IntArray(-3, -2, -1)},

  344.         {IntArray(11, 3, 4, 4), IntArray(-7 + 1, -3 + 1, -2 + 1, -4 + 1), IntArray(0, 1, 2, 3)},

  345.         {IntArray(12, 4, 5, 3), IntArray(-12 + 1, -4 + 1, -3 + 1, -5 + 1), IntArray(0, 1, 2, 3)},

  346.         {IntArray(8, 5, 6, 2), IntArray(-16 + 1, -5 + 1, -4 + 1, -3 + 1), IntArray(-4, -3, -2, -1)}

  347.     };

  348. 

  349.     for (int i = 0; i < sizeof(params) / sizeof(params[0]); i++)

  350.     {

  351.         int ret = test_crop(a, params[i][0], params[i][1], params[i][2]);

  352.         if (ret)

  353.             return ret;

  354.     }

  355. 

  356.     return 0;

  357. }

  358. 

  359. int main()

  360. {

  361.     SRAND(776757);

  362. 

  363.     return 0

  364.            || test_crop_1d(RandomMat(112))

  365.            || test_crop_1d(RandomMat(126))

  366.            || test_crop_1d(RandomMat(127))

  367.            || test_crop_2d(RandomMat(20, 48))

  368.            || test_crop_2d(RandomMat(15, 36))

  369.            || test_crop_2d(RandomMat(16, 33))

  370.            || test_crop_3d(RandomMat(20, 20, 48))

  371.            || test_crop_3d(RandomMat(15, 15, 36))

  372.            || test_crop_3d(RandomMat(16, 16, 33))

  373.            || test_crop_4d(RandomMat(20, 20, 20, 48))

  374.            || test_crop_4d(RandomMat(15, 15, 15, 36))

  375.            || test_crop_4d(RandomMat(16, 16, 16, 33));

  376. }