Laplacian | A flexible music player and manager | Music Player library

The main difference, and the one that causes the difference you showed, is that matplotlib will, by default, scale the image so that its minimum value is black and its maximum value is white. OpenCV always shows images according to their data type, for example for a uint8 image, 0 is black and 255 is white. In your case, you have a signed 16-bit image, which has -32768 as black and 32767 as white. Your pixel values occupy a way smaller range, and so all appear as the same middle-gray color.

Try this:

outVertexBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, 5000000, 12);

Notice the changed Target. Graphics buffer needs at least one of the Compute target flags to be able to be bound to a compute kernel. Target.Vertex is not such a flag. You could still add it but in your case it's not needed.

In fact outVertexBuffer could just be a ComputeBuffer. No need to use GraphicsBuffer since you just copy it to the mesh on the CPU side.

EDIT---

Another thing: SetVertexBufferData() requires you to configure all vertex attributes first and the data you pass should basically be raw vertex data: positions, normals, uvs (if any) and so on.

If you only want to set vertices perhaps it would be easier to just use Mesh.SetVertices().

The convertTo can not add channels as well can not reduce/convert image to image with smaller amount of channels. The key in this case is to use :

The code below uses cv2.HoughLinesP() on the thresholded image to produce this:

Don't optimize before you know what is taking time.

Most time is spent on loading the image. Time it, you'll see. This involves accessing mass storage and decoding the image format. PNG isn't the most complex out there, so it could be worse.

The laplacian calculation uses a specific kernel. Convolving the picture with an arbitrary 3x3 kernel would cost 9 multiplications and 9 additions. This kernel costs one shift and five adds/subs. The CPU's SIMD will eat this for breakfast.

A GPU won't help at all. It takes time to transfer this data to the GPU. Then there are other constant costs (latency, "warm-up") to starting any calculations on a GPU. A CPU would already be done calculating. If you had a ton of pictures, at least the transfer could be pipelined and the upload of kernel code would only be required once.

Both the GPU and the CPU are likely memory-bound in this entire operation, meaning compute capability is far from challenged by this.

If you really wanted to get a GPU involved, the easiest way would be to wrap the numpy array in a cv.UMat and pass the UMat object in instead. OpenCV will then use OpenCL. The result will be a UMat again, so you would need to see what OpenCV function can calculate the variance for you.

The slow performance comes from the bad complexity of the algorithm. Indeed, the complexity of the original code is O(N**4)! This is due to np.concatenate which creates a new array by copying the old one and adding a few items at the end of the new one. This means that O(N**2) copies of 3 growing arrays are performed. In general, you should avoid np.concatenate in a loop to make a growing array. You should use Python lists in that case.

Note that you can use np.tile to repeat values of an array and pre-compute the constant dxx * np.array([-4, 1, 1, 1, 1]).

Here is the corrected code:

First of all, I would say, my solution below is a brute-force method, thus only working well for graphs of small size, i.e., not many vertices or arcs.

If you have large networks, you should refer to some more advanced algorithms, e.g., https://link.springer.com/article/10.1007/s40747-018-0079-7

Since you have 6 arcs and 5 vertices, you only need to remove 2 arcs out of 6 to find the spanning tree. There would be combn(6,2) options, and you can delete those edge combinations one by one to check if a spanning tree remains

The issue is getting your meshgrid into the same dimensions as the training matrix, before applying the laplacian. So if we run the code below to fit the svm :

You calculated pred_y using your train inputs which has 105 elements and y_test has 45 elements.

You need to add a step: