How to select the middle point of a subdivided face?

Question

Suppose I have the following geometry, which was created with Ico Sphere > Subdivide Mesh > Dual Mesh:

Now I apply the node Subdivide Mesh (or Subdivision Surface), which divides the mesh into smaller faces.

But how do I select the point in the middle?

Of course, the whole thing should work the same way for further subdivision levels, so not only for a subdivision of $1$:

The problem here are the faces that have exactly four vertices (all other faces are easy to figure out), where it is obviously relatively complicated to find the center.

I have of course found and tried different variants with scaling and Sample Nearest, and by comparing direction vectors based on positions, but I am looking for a solution based only on logic/mathematics.

The problem with alternative methods is mainly that when using Subdivision Surface there is a shift of the points, which makes any mechanism via vectors or comparisons not stable. That is why I am looking for a way to determine the center point via logic/index.

I'm at a loss right now. How can this be solved (with as little effort as possible and as performant as possible!)?

---

It turned out that due to the diversity of possible geometries, a solution based purely on mathematics is obviously really extremely complicated.

For those who want to try the solution, there are basically the following scenarios in which it should work:

• Simple non-manifold meshes
• Manifold meshes created with Geometry Nodes or in the editor (Cube, Ico Sphere, etc.)
• But also meshes that have been subdivided before with the node Subdivide Mesh

So in short: I am looking for a solution that reliably finds the center point no matter which geometry is passed to the node Subdivision Surface or Subdivide Mesh, and that without chaining several subdivision nodes.

Here is the test file:

---

Because it was asked about in the comments: "What is the final goal of the question?"

Here is the answer:

I'm creating a custom node group here that does some horrible things to a mesh. The node Subdivision Surface is used within the node group, and at the end of the group a selection should be available at the output socket, so that further objects can be instantiated at these points.

Answer 1

The subdivision of a face follows a certain pattern. As Martynas Žiemys also correctly discovered, the points on the edges of the original faces have lower indices than the points in the center, because they are divided first.

He wrote:

Studying vertex indices when applying Subdivision Surface modifier it seems as if vertices with new increasing indices are added when subdividing. They seem to be first added to the existing edges and then they are 'connected' and vertices are added to intersections.

So that's true.

And lemon commented in his answer:

• vertices of edges are indexed first
• then inner vertices of faces are indexed in second (face per face)
• and center vertex is the middle of this last indexation

And that is also true.

But both proposed solutions unfortunately did not lead to the goal and could not solve the problem satisfactorily and in all cases.

For example, if you create the following mesh with Geometry Nodes before (and this is the case in my example) and the subdivision level is greater/equal $2$, then their approach does not work:

So I took another look at the issue, and created a combination of math and logic game...

Reliably select the inner points of subdivided faces

Selecting the points within the faces is a relatively simple game, as it turns out.

All you need to know is how many points ($Po$) and edges ($Eo$) the original mesh had before the subdivision.

And with each subdivision ($S$), additional points are created on the existing edges. This looks like this:

Subdivision Level	Additional Points on Edges
0	0
1	1
2	3
3	7
4	15
5	31
6	63

This value is obtained with $2^S-1$.

Now, multiplying this value by the number of edges existing before the subdivision, and adding it to the number of points existing before the subdivision, we get the number of all points running along the original edges after the subdivision ($Pt$):

$Pt = (2^S - 1) * Eo + Po$.

Since these points always have the lowest index of the points added by the subdivision, any index higher than or equal to this value is a point in the inside of a subdivided face.

This reliably gives you a selection that includes only the points inside the faces:

_{(Inverse selection, points lying along original edges)}.

Find the middle point within this selection

If a face has 3, 5, 6 or more vertices, then this procedure is simple.

For a face that does not have four vertices, the center point is always the point whose number of adjacent points is equal to the number of vertices of the original face.

But it is even simpler, as I found out:
For a face that does not have four vertices, the point in the middle after a subdivision always has the lowest index of all points lying within the face!

_{(Subdivided pentagon with lowest index in the center)}

Thus only one switch is needed to distinguish between faces with four vertices and all others.

For faces with four vertices, the middle point always has the middle value of the values of all points lying within a face.

_{(Index Range from $741$ to $749$, and the center has index $745$)}

And to do this, you need to calculate how many points lie within a face.

Since this depends on the subdivision level, this is achieved by the following formula:

$\frac{(2^S-1)^2-1}{2}$

And so, for example, with a number of $9$ points, you would have selected the point with the index $4$ (Reminder: The index starts counting at $0$).

With the previously mentioned switch you can now toggle between the value $0$ (for faces with more than four vertices) and this average value (for faces with exactly four vertices).

In the last step we only have to compare the current index with these values.

And in this case we have to start counting again at $0$ for each face, so we politely ask the node Accumulate Field to create a new counter for each face, so that the indices of all points that are inside a face and start in a new face will always start counting at $0$.

Since I capture the index of the faces in the domain Face before the subdivision with Capture Attribute, these values remain in the points even after the subdivision. This is because the interpolation (from Face to Point) of these values only takes place at the points along the original edges, but not at the points created by the subdivision inside the original faces. Thus all points within the original faces always receive the same original value, which I use as a Group Index for Accumulate Field. This way the counter can start counting again at $0$ for each original face.

_{(All points within a face use the original face index as Group input of Accumulate Field)}

_{(Iterate through the indices of a face and capture the midpoint with index $4$)}

So if one of the indices obtained in this way is equal to the value calculated before, then it is the midpoint of a subdivided face:

And in this example, with a subdivision level of $2$, the center index is $4$.

...Yay! The center point has been found!

And the node group ended up being simpler than initially thought:

---

And the coolest thing about this solution is:

• This node group can handle faces with any number of vertices.
• It can be used with all geometries, even if they were created in a "strange" way.
• The solution is extremely performant.

_{(Blender 3.4+)}

Answer 2

Studying vertex indices when applying Subdivision Surface modifier it seems as if vertices with new increasing indices are added when subdividing. They seem to be first added to the existing edges and then they are 'connected' and vertices are added to intersections.

If I have a cube, it seems vertices at the centers of faces are created the last. So it seems that the number of last indices matching the number of faces in the original mesh will be the center vertices of the faces. Further subdivisions don't seem to matter, because after the first subdivision the centers remain the same.

This seems to also be the case if I dissolve one vert of the cube to have geometry that's not so regular as a cube(further testing might be needed):

So if it's all correct as far, you would have to get all the indices that are greater than the amount of verts in mesh subdivided once minus the amount of faces in the original mesh. To pass that information to higher subdivisions, we could store an attribute. It will get interpolated with higher subdivisions, but the original verts will retain value of 1:

I am sure it is possible to put it into one node group that takes care of the cases of 1 subdivision and more than 1 subdivisions so you have only one number input.

This is getting a bit complex for me, so I might be mistaken in some or possibly many ways. Here is the file:

Answer 3

For quad meshes only.

As Martynas found that face centers have the last indices for the first subdivision, we can complete observing that

• vertices of edges are indexed first
• then inner vertices of faces are indexed in second (face per face)
• and center vertex is the middle of this last indexation

(at least, these rules seem to work in my test cases)

We can know:

• total amount of vertices Vt and faces Ft
• number of original faces Fo, knowing the subdivisions n is Fo = Ft / 4**n
• inner vertices per face (the one that are not in the borders: 1, 9, 49, 225, 961 etc.) is Vi = (2**n - 1)**2
• border vertices Vb = Vt - Ft * Vi

So, the first center comes at I0 = Vb + floor(Vi / 2). And the consecutive other face centers have (index - I0) % Vi == 0 (with index - I0 positive or null).

Which is in GN the following: