vertice | Omni scheduler/core engine for Megam Vertice | Job Scheduling library

I would guess that you have an input that specifies the maximum flow through each edge.

The algorithm is then:

1. Because edges with a common source must have same actual, final flow the first step must be a little pre-processing to reduce the max flow at each edge to the minimum flow from the common source.

2. apply the standard maximum flow algorithm.

3. do a depth first search from the flow origin ( I assume there is just one ) until you find a node with unequal outflows. Reduce the max flows on all edges from this node to the minimum flow assigned by the algorithm. Re-apply the algorithm.

Repeat step 3 until no uneven flows remain.

=====================

Second algorithm:

1. Adjust capacity of every out edge to be equal to the minimum capacity of all out edges from the common vertex

2. Perform breadth first search through graph. When an edge is added, set the flow through the edge the minimum of

• the flow into the source node divided by the number of exiting edges
• the edge capacity

1. When search is complete sum flows into destination node.

For reference, here is the C++ code I use for depth first searching using recursion

One way to determine what section of your terrain should be culled is to use a quadtree (for a heightmap) or an octree (for a voxel map). Basically, you divide your terrain into little chunks that then get divided further accordingly. You can then test if these chunks are in your viewing frustum and cull them if necessary. This technique was already discussed in great detail:

• Efficient (and well explained) implementation of a Quadtree for 2D collision detection
• https://www.rastertek.com/tertut05.html
• https://gamedev.stackexchange.com/questions/15697/quadtree-terrain-splitting-i-dont-get-it

I saw some websites saying to use GL_DYNAMIC_DRAW instead of GL_STATIC_DRAW, but I did not understand it.

These are usage hints to OpenGL on how the data will be accessed so the implementation has the ability to apply certain optimizations on how to store/use it.

usage is a hint to the GL implementation as to how a buffer object's data store will be accessed. This enables the GL implementation to make more intelligent decisions that may significantly impact buffer object performance. (https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glBufferData.xhtml)

Please note that these are only indications, no restrictions:

It does not, however, constrain the actual usage of the data store.

Because you will likely update your VBO's and IBO's constantly (see culling) and only want to draw them GL_DYNAMIC_DRAW would be a good choice:

The data store contents will be modified repeatedly (because of culling) and used many times. The data store contents are modified by the application and used as the source for GL drawing and image specification commands.

as I have googled that it can affect the performance of the game

Well, it will cost some performance to cull your terrain but in the end, it will likely gain performance because many vertices (triangles) can be discarded. This performance gain may grow with larger terrains.

Looks like your question is related to this forum topic.

You can do the things this way (just an option, not the ultimate solution): use an additional array stored in userData, and use .setXYZ() method.

Your problem is one of mathematics. You said "As observed, the side length is 10px". It very definitely is not 10px. The distance from (10,5) to (5,0) is sqrt(5*5 + 5*5), which is 7.07. That's exactly what we expect for a square that is inscribed in a circle of radius 5: 5 x sqrt(2).

And that's what the other squares are as well.

FOLLOWUP

As an added bonus, here is a function that returns the radius of the circle that circumscribes a regular polygon with N sides of length L:

This is as close as I have managed to get it:

I think you are looking for breadth first search, starting at your root:

My idea would be to get the contour of the shape, try to detect "corners", e.g. using Harris corner detection, find matching points from the contour, and piecewise calculate the length of the edges using cv2.arcLength.

The input for the below extract_and_measure_edges method needs some binarized contour image like that one derived from your actual input image:

So, the pre-processing must be adapted to the input images, and is out of scope of my answer! In the below code, the pre-processing is for the given input image, not for the two other examples.

You need to close the outline around the triangles:

The problem was caused by you adding nodes, which is a list in your new data structure, to new_path