GAUSS | Gaggle of Algorithms and Utilities for Simulating Stuff

It's hard to debug without a codesandbox but I'm guessing since you want the useEffect to trigger when you do

setRenderedCharacters([...word.renderedCharacters]);

You should add renderedCharacters as the dependency

You can use a 2D FFT to find the general direction in which the crop is aligned (as proposed by mozway in the comments). The idea is that the general direction can be easily extracted from centred beaming rays appearing in the magnitude spectrum when the input contains many lines in the same direction. You can find more information about how it works in this previous post. It works directly with the input image, but it is better to apply the Gaussian + Canny filters.

Here is the interesting part of the magnitude spectrum of the filtered gray image:

The main beaming ray can be easily seen. You can extract its angle by iterating over many lines with an increasing angle and sum the magnitude values on each line as in the following figure:

Here is the magnitude sum of each line plotted against the angle (in radian) of the line:

Based on that, you just need to find the angle that maximize the computed sum.

Here is the resulting code:

This problem is well suited for rejection sampling. Basically you randomly choose a point, and select if a connection should be made based on a defined probability. You have to take in account that there are many more points at further distance than at # closer distances (its number grows with radius), so maybe you have to introduce an extra weighing in the probability function. In this case I choose to use an exponential decay probability.

This code is not optimal in terms of speed, particularly for higher connectivity percents, but the ideas are better presented this way: see below for a better option.

You should use the product of PDFs for both X and Y in function myFun2d

Here is how you can use the np.diff() method to find the index of first row from where the pixel changes from 0 to 255, and vice-versa for the bottom edge (the cv2 is only there to read in the image and threshold it, which you have already accomplished using diplib):

The first code is bounded by the time to generate the random numbers. This is a generally a slow operation (whatever the language although there are tricks to speed up the performance of low-level native codes). Thus, there is not much to do in Numpy. You can use Numba to parallelize this operation, but note that the current random number generator of Numba is a bit slower in sequential than Numpy.

The read/write operations should be bounded by your storage device and the speed of encoding/decoding. For the former, you can use in-RAM virtual devices, but if you cannot control that then there is nothing to do (apart from using a faster hardware like a Nvme SSD). For the latter, the Python wrapper of OpenCV already use an highly-optimized JPEG encoder/decoder that should already be fast regarding the operation to perform. So you cannot speed up this part, but you can do multiple of them in parallel.

Regarding the Numpy code, there are two main issues:

First, np.random.normal generate a 64-bit floating-point number (float64) array while the image array contains only 8-bit integers (uint8). Working on float64 values is much more expensive than uint8 ones (up to one order of magnitude slower in the worst case). Unfortunately, there is no (simple) way to generate random integer with a normal distribution as this distribution is tightly bounded to real numbers. Numpy also lack of a parameter to work on float32. Your solution to reuse numbers is quite good to improve the performances. Still, adding a uint8 array with a float64 one is expensive as Numpy converts the first to a float64 array and then produce a new float64 array. You can convert the random array to an uint8 array in the first place but this is not so easy in practice. Indeed, the negative values cannot be converted to correct uint8 ones and even if they could, the addition likely cause some overflows. Note that Numba can help to further speed up this part as it can convert the float64 values to uint8 ones on the fly (and in parallel).

Moreover, np.tile should theoretically not copy the array but it sadly does make a copy here. Hopefully, you can remove this expensive copy using broadcasting.

Here is the resulting code:

The stated goal was to utilize the reduced procedure.

One way to do that is to augment the input Matrix by the identity Matrix, reduce that, and then return the right half the augmented Matrix.

The steps that transform the input Matrix into the identity Matrix also transform the identity Matrix into the inverse (of the input Matrix).

For example, using your procdures,

What I found so far: a commonly used method, e.g. in finite element simulations, is meshing or triangulation. The following is an attempt of a gnuplot implementation of the "Delaunay Triangulation" of a set of points. https://en.wikipedia.org/wiki/Delaunay_triangulation However, I'm aware that gnuplot is not really the tool for such a task.

So, probably, there are better solutions which I am not aware of. I am curious to learn about them.

Delaunay triangulation:

The following code is certainly not the most efficient way to get the triangulation, improvements are welcome

Procedure (short version):

1. sort your N data points by increasing x and if identical x then by increasing y
2. find the first m>=3 points which are not collinear
3. loop points from m to N

3.1) find all hull points whose connections to point m+1 do not intersect with any current hull segment

3.2) connect these hull points to point m+1 and modify the hull accordingly

1. loop all inner edges

4.1) find the 2 triangles containing the current edge. These form a quadrangle

4.2) if the quadrangle is convex, check if the diagonal needs to be flipped ("Lawson-flip")

4.3) start over with 4) until no flips are necessary anymore

In order to color the triangles

1. split each triangle into 3 quadrangles using the centroid as a 4th point

1. color the 3 sub-quadrangles according to the z-value of the respective data point

Comments:

• gnuplot has no native sort capability (especially sorting by >=2 columns), so you have to use sort (already included on Linux, on Windows you have to install, e.g. CoreUtils from GnuWin.
• Flipping the edges will take some time. I guess, it scales with O(n^2). So, above 100 datapoints it becomes unpractial, because it will simply take too long. But there seem to be algorithms which should run in O(n log n).
• Improvements are welcome, or maybe even an implementation in gnuplot would be great ;-)

Code: