How can I re-sort the points/indexes of an object in geometry nodes?

Question

I wonder if there is a possibility to re-sort the indexes of a mesh according to a certain criterion?

Again and again in Geometry Nodes unfavorable situations arise where the point distribution or their indexes are in irregular order.

For example, I want to re-sort the points distributed on a grid with the node Distribute Points on Faces along a certain axis so that I can process them in order.

If I convert the distributed points for example with the node Mesh Line into a curve, a totally confused pattern comes out, because the indexes are distributed in a random order:

However, I would like the indexes to be sorted and numbered from right to left so I can create a line along those points:

Bonus task: The whole thing should at best also work with three-dimensional objects, because just a grid is sometimes pretty bland.

PS: I know there are "hacky solutions" out there, but that's what I really want to avoid and find a solid and as simple as possible logic based technique.

---

Techniques comparison

Even though it's not a contest here, I'm providing an overview of the answers below.

Each approach is very different, but each also has its justification. How, when, which technique is best depends very much on the situation.

I have now combined and modified all five techniques in such a way that they are meaningfully comparable, and run according to the following criteria:

• All get as input any test value (float/integer)
• All process points in the point domain
• All provide the sorted index as result for further processing

(Native Sorting, Quadratic Sorting, Resolution Sorting, Circular Sorting, Ramp Sorting)

Features & Capabilities

	Native Sorting	Quadratic Sorting	Resolution Sorting	Circular Sorting	Ramp Sorting
Reliability	Perfect	Perfect (?) (Review pending)	Acceptable (Depends on density & resolution settings)	Bad (at higher density)	Acceptable (Depends on density)
Performance assessment	Perfect	Acceptable *	Good * (Depends on resolution settings)	Perfect (if you don't care about missed points)	Bad (!!!)
Can handle identical values	Yes	Yes	Yes, partially (Depends on resolution settings)	No	No

*With a few points (below ~400), Quadratic Sorting is actually faster than Resolution Sorting. However, Resolution Sorting shows its strength with many values to be sorted and clearly outperforms Quadratic Sorting!

Note: I tried to make a comparison of the timings, but since the variants work too differently in the end and that depends on too many factors, it's not really possible to do that in a meaningful way.

Advantages & Disadvantages

	Advantages	Disadvantages
Native Sorting	Captures all points, Best performance	-
Quadratic Sorting	Captures all points (?) (Review pending)	Average performance
Resolution Sorting	Performance depends on adjustable resolution	Performance/Reliability depends on adjustable resolution Has a small error rate at high density
Circular Sorting	Is ultra-fast *	"Swallows" points very easily at higher density
Ramp Sorting	-	Is computationally intensive at high density Does not work reliably at high density

*The "Circular Sorting Technique" is so fast mainly because at high density the more points are discarded and thus no real comparison to other methods can be made!

Use cases

• If you set a high value on precision and no point should be lost: Native Sorting
• If you set a high value on precision and you have less then ~5000 (?) Points: Quadtratic Sorting
• If you need a good result, but can live with a small error rate: Resolution Sorting
• If you need it really fast, and if you don't care about precise detection: Circular Sorting
• If you are totally crazy and feel like experimenting: Ramp Sorting

Download the comparison and try it yourself

_{(Blender 3.2+, all methods except "Native Sorting")}

_{(Blender 3.4+, all five methods)}

These files are all adapted for use on point clouds (!)

Answer 1

"Circular Sorting Technique"

How does this work?

Roughly speaking, I assign a range of the value to be sorted to a range from $0$ to $\pi$, which results in the distribution of points on a semicircle.

On the resulting shape, I apply a mesh trick that gives me a curve with ordered points.

This may sound rather muddled now, but it is really quite easy to understand if you represent it with pictures...

For example, if you distribute points on a grid with the node Distribute Points on Faces, and display the value of the X-axis on a semicircle, it looks like this:

If you now create a convex hull from the points on the semicircle and convert them back into curves, you get nicely sorted points. This works basically with arbitrary values.

Here you can see an example of sorting along the X-axis and along the Y-axis:

And this is how it looks, for example, with a grid rotating on the Z-axis:

---

Step by step to the solution

1. First of all, you define by which value you want to sort. In this example I use the X-axis and separate it from the single points.

   

2. Next I use the node Attribute Statistics to determine the lowest and the highest value, which serves as input range for the node Map Range.

   I then map the values used here to a semicircle, so that the previously captured value of the X-axis is distributed along this semicircle.

   

3. Then I create a line with the node Mesh Line, whose subdivision corresponds to the number of the original points, and set their positions to the previously created positions on the semicircle.

   I achieve this by simply rotating a vector with the previously obtained angle.

   

4. And now comes the crucial step: I first capture the index of each point, so that I can later determine the original index, and then I use the nodes Convex Hull and Mesh to Curve.

   The ingenious thing about this is that Convex Hull forms a mesh hull around the points previously distributed on the semicircle, but this does not yet lead to the goal.

   Only by using the node Mesh to Curve, this mesh is transformed into a curve, whose indexes are ordered continuously from left to right.

   Since the original index was previously captured with the node Capture Attribute, a connection between the new ordered indexes and the original indexes can be established with Transfer Attribute.

   

5. With the help of this index now arbitrary values can be fetched and used in another mesh/object with the node Transfer Attribute.

   

---

Download the file and try it yourself

Important Notes: Since this technique is based on the node Convex Hull, but this ignores distances between vertices below a certain value and combines the points arbitrarily, this technique may lead to unexpected results.

For less densely distributed points it works great, but as soon as the vertices are very close to each other along the sort (or even identical), they are ignored.

in this particular case: if the points on the circle are distributed with an angle of less than $0.01°$, they will not be recognized. (Thanks to @Robin Betts for the attentive reading).

Q & A

Q: It does not work at all with my mesh! Why?
A: Since this technique counts the points in the domain Points with the node Domain Size, and a mesh returns Vertices and is not a Point Cloud, you have two options:

• Either you apply the node Mesh to Points before, which converts your mesh to points.
• Or you switch the contained node Domain Size from Points to Mesh.

Q: Why actually a semicircle and not a whole circle?
A: Because the numbering is finally done by converting the convex hull into a curve with the node Mesh to Curve, which uses the longest edge as a reference point for the first vertex.

Answer 2

"Native Sorting Technique"

Blender 3.4+

In version 3.4 there is an interesting new node, which allows a native sorting of the points of a curve based on a weighting.

The node is called Points of Curve, and returns the index of a specific point of the curve depending on the value passed.

To achieve sorting with this, first the point cloud is converted into a curve, and the sorting criterion is used as Weights for Points of Curve.

Basically all possible sorting can be done in this way:

_{(Blender 3.4+)}

---

Examples

• Here you can find an example of use (in which, funnily enough, exactly the opposite should be generated, namely a jumble of the indices): How to randomize/shuffle indices in Distribute Points on Volume?

• And here is a nice practical example that uses a texture map as a sorting criterion (thanks to @RobinBetts for this creative idea!): Sorting Indices of points circularly

As you can see: Only the value that is passed as sort criterion is decisive.

Blender 4.0+

The concept of weighting has been used in some other nodes since version 4.0, and Points to Curve is available here with precisely this feature.

This converts points into curves and uses the weighting as a criterion for the order of the points to be used.

As a result, a curve is obtained whose points are arranged exactly according to the value of the weighting.

This curve can then be converted back into points if necessary.

Blender 4.1+

Well, Blender is (fortunately) evolving, and so are the possibilities for sorting elements natively.

In simple terms, the current solution should therefore be presented with a single node without any detours:

Answer 3

Quadratic Sort (Pre B3.4)

This is one of outdated answers that would unnecessarily bury (currently) objectively the best answer by quellenform. You can still access this answer by reading the previous revision.

Answer 4

Resolution based sorting (pre B3.4)

This is one of outdated answers that would unnecessarily bury (currently) objectively the best answer by quellenform. You can still access this answer by reading the previous revision.

Answer 5

"Ramp Sorting Technique"

This is one of the outdated answers that would unnecessarily bury the (currently) objectively best answer from quellenform. You can still access this answer by reading the previous revision.

Answer 6

Another approach is to Sort Elements with a Gradient texture.

on Linear:

on Radial:

Edit: the setup:

the blend:

I hope it helps.