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

我怀疑它是否完全解释了您的长计算时间，但是您可以通过在嵌套for循环外部分配pool(int, int)和v数组来避免sum中的大量对象分配，并改为使用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);
}

如何减少位平面代码

1 个答案: