ccw | Counterclockwise is an Eclipse plugin helping developers | Code Editor library

As per what @YvesDaoust said in the comments, for each polygon/hole, you can find all the polygons/holes which contain it.

This will give you a directed graph. In this graph, for each node, you may have more than one incoming edges. For instance, something like this:

Identify all edges that you cut by the indexes (or labels) of the endpoints. Make sure that every edge belongs to exactly two faces and is cut twice. Also make sure to orient the edge that results from the intersection consistently with the direction of the face normal.

Now the intersection edges form a chain that you can reconstruct by sorting: store the indexes of the endpoints separately, each with a link to the originating edge. After sorting on the indexes, the common vertices will appear in pairs in the sorted array. Using this structure, you can trace the polygon(s).

In the example below, from the faces aebf, bcgf, cdgh and dhea, you generate the edges ae-dh, bf-ae, cg-bf and dh-cg in some order. After splitting the endpoints and sorting, ae-, -ae, dh-, -dh, cg-, -cg, bf-, -bf, which generate the cycle ae-dh, dh-cg, cg-bf, bf-ae.

In your program/function you are sorting the points, then you calculate the indices along with the hull. And you return the indices (based on the sorted vector). You then apply the indices to the vector, which is not sorted.

Remember, C++ can pass by reference or value/copy (I am a bit vague maybe but I hope you get the idea; if you have no idea what I am talking about then that is a topic you have to learn about).

What you can do in the second program is: sort the vector before you print it. Maybe that will give you the expected result.

A better solution takes a bit more effort: Pass by reference

The problem comes from the mix between integers and floats typed values. Numba try to defined a type of the array and found that [1, 0, 0] is a list of integer but the overall array is initialized with both a list of integer and a list of floats. The type inference is confused and raised an error because the overall type is ambiguous. You can write 1.0 and 0.0 instead of 1 and 0 so to fix the issue. More generally, specifying the dtype of arrays is generally a good practice, especially in Numba due to the type inference.

If you want to avoid compilation errors at runtime when the function is called the first time, then you can precise the parameter types. Note that you can use njit instead of nopython=True (shorter). The resulting decorator should be @njit('(float64, float64, float64)').

I found the solution: passing a new normal matrix (extracted from the model-view matrix) to the shader when drawing the dynamic mesh.

Not sure about what the issue is ..., but something may help here.

Almost all the same options for lot of rows with text and combo, so following way for layout maybe better.

Stupid me. It was a small bug in the extruding method, which should be like:

Modifying the binding from

The averaging effect of the interpolation changes the distribution...

Note:

• There is a mistake in your code sample (not related to the percentiles).
  The 4'th argument of warpAffine is dst.
  replace cv2.warpAffine(newImg, M, (nW, nH), cv2.INTER_CUBIC with: