java - 如何减少位平面代码的计算时间

Question

我有 256 个二元矩阵 B(x,y)，我尝试将它们合并到 8 个矩阵组中。考虑特定位置 (x,y) 处的单个像素，可以使用来自由 8 个矩阵组成的池中的矩阵的一组二进制值来构造 8 位的二进制代码。下面的公式说明了这一点: see the formula

8 个矩阵组中的 256 个矩阵池将产生 32 个矩阵。我用java写了代码，代码运行正常，但是我想降低时间复杂度，大约需要30秒才能得到结果!每个矩阵的大小为 300 X 100，我可以更改或使用什么来以更少的时间获得相同的结果？

        //index-Strat
    int start = 0;
    //index-end
    int end = 7;
    //pool evey eghit matrices togather, and produces 32 matrices
    for (int j = 0; j < 32; j++)
    {
        //call the pooling function 
        Mat bit - 8 = new Mat();
        bit - 8 = pool(start, end);
        //add 8-bit matrix to pool array
        p.add(bit - 8);
        //increamt the indexs to pool the next 8 matrix 
        start = end + 1;
        end = start + 7;
    }

 //---------------------------
    Mat pool(int s, int e)

    {   
        Mat bit - 8 = new Mat(binary.get(0).size(), binary.get(0).type());
        //apply the Bit Plane 
        for (int i = 0; i < bit - 8. rows(); i++)
        {
            for (int j = 0; j < bit - 8. cols(); j++)
            {
                double[] sum = new double[1];
                for (int k = 0; k < 8; k++)
                {
                    double[] v = new double[1];
                    v = binary.get(s + k).get(i, j);
                    double new_value = v[0] * Math.pow(2, k);
                    sum[0] = sum[0] + new_value;
                }

                bit - 8. put(i, j, sum);
            }

            return bit - 8
        }

Answer 1

我怀疑它是否完全解释了您的长计算时间，但是您可以避免 pool(int, int) 中的大量对象分配通过分配 v和sum嵌套 for 循环之外的数组，并使用 int[]相反:

int[] v = new int[1];
int[] sum = new int[1];
for (int i = 0; i < rows; ++i) {
  for (int j = 0; j < cols; ++j) {
    sum[0] = 0;
    for (int k = 0; k < 8; ++k) {
      binary.get(s + k).get(i, j, v);
      sum[0] += v[0] << k;
    }
    bitMinus8.put(i, j, sum);
  }
}

这减少了分配数组的数量 (rows*cols)*(8 + 2)到只是2 .

对象创建相当便宜，但避免重复创建可以加快速度。

<小时/>

请注意这句话:

double[] v = new double[1];
v = <something>;

是多余的:您分配一个新数组，然后立即覆盖它，丢弃分配的数组。你可以简单地写:

double[] v = <something>;

<小时/>

查看文档，我相信您还可以避免显式的逐元素求和:

Mat bitMinus8 = new Mat(binary.get(0).size(), binary.get(0).type());
for (int k = 0; k < 8; ++k) {
  Core.addWeighted(binary.get(s + k), 1 << k, bitMinus8, 1, 0, bitMinus8);
}