Blender-Python: Select and iterate vertices after each other from left to rigth, top to bottom

Question

I want to build a blender python loop around all my vertices of one plane which is subdivided and so has many vertices. It should select one vertice (do something else with it which is not the question here) and select the next vertice after each iteration.

It should start with the top left, then go through the first row to the right and then step over to the second row and again go from left to right.:

Answer 1

Operator solution

Since you're asking specifically to select a vertex:

import bpy
data = bpy.context.view_layer.objects.active.data
bpy.ops.object.mode_set(mode = 'OBJECT')
verts = sorted([(v.co.z, v.co.x, v.index) for v in data.vertices], reverse=True)
bpy.ops.object.mode_set(mode = 'EDIT')
for z, x, v_index in verts:
    bpy.ops.mesh.select_mode(type="VERT")
    bpy.ops.mesh.select_all(action = 'DESELECT')
    bpy.ops.object.mode_set(mode = 'OBJECT')
    data.vertices[v_index].select = True
    # modify manually here, e.g.:
    # data.vertices[v_index].co.y += x
    bpy.ops.object.mode_set(mode = 'EDIT') 
    # use bpy.ops here, e.g.:
    # if x > 0: bpy.ops.mesh.hide()

Bmesh solution

import bpy, bmesh
mesh = bpy.context.edit_object.data
bm = bmesh.from_edit_mesh(mesh)
verts = sorted([(v.co.z, v.co.x, v) for v in bm.verts], reverse=True)
for z, x, v in verts:
    v.co.y = z+x # example
bmesh.update_edit_mesh(mesh)

Changing for different planes (views)

I assumed the Back Orthographic view and XZ plane: . For other planes you need to sort differently. Perhaps remove reverse argument and use minus signs to swap the sign of the coordinate inside the tuple used for sorting. So the following line:

verts = sorted([(v.co.z, v.co.x, v) for v in bm.verts], reverse=True)

would become: [for Back Orthographic]

verts = sorted([(-v.co.z, -v.co.x, v) for v in bm.verts])

and for Front Orthographic you would change the sign of x for sorting:

verts = sorted([(-v.co.z, v.co.x, v) for v in bm.verts])

Likewise you may want to turn (v.co.z, v.co.x, v) to (v.co.x, v.co.z, v) if you rotate the camera by 90 degrees or want to iterate by columns instead of rows.

Interactive Testing

Here's a script allowing to test if the order is correct, by pressing Ctrl+Shift+F12

bl_info = {
    "name": "Vertex iterator",
    "category": "Mesh",
}
import bpy
addon_keymaps = []
current_vertex = 0
class WorkMacro(bpy.types.Operator):
    """Work Macro"""
    bl_idname = "object.work_macro"
    bl_label = "Work Macro"
    bl_options = {"REGISTER"}
def execute(self, context):    
    global current_vertex    
    data = bpy.context.view_layer.objects.active.data
    bpy.ops.object.mode_set(mode = 'OBJECT')
    verts = sorted([(-v.co.z, -v.co.x, v.index) for v in data.vertices])
    bpy.ops.object.mode_set(mode = 'EDIT')
    z, x, v_index = verts[current_vertex]
    bpy.ops.mesh.select_mode(type="VERT")
    bpy.ops.mesh.select_all(action = 'DESELECT')
    bpy.ops.object.mode_set(mode = 'OBJECT')
    data.vertices[v_index].select = True
    bpy.ops.object.mode_set(mode = 'EDIT')
    current_vertex = (current_vertex + 1) % len(verts) 
    return {'FINISHED'}



def register():
    bpy.utils.register_class(WorkMacro)
    wm = bpy.context.window_manager
    km = wm.keyconfigs.addon.keymaps.new(name='3D View Generic', space_type='VIEW_3D')
    kmi = km.keymap_items.new(WorkMacro.bl_idname, 'F12', 'PRESS', ctrl=True, shift=True)
    addon_keymaps.append(km)
def unregister():
    bpy.utils.unregister_class(WorkMacro)
    wm = bpy.context.window_manager
    for km in addon_keymaps:
        wm.keyconfigs.addon.keymaps.remove(km)
    del addon_keymaps[:]
if name == "main":
    register()

Answer 2

Default order of things.

If we add a primitive grid, the vertices are ordered left to right ($X$), bottom to top ($Y$).

With all geometry selected, Scaling by -1 in local $Y$ axis, SYY -1 will change index order to left to right, top to bottom, but will flip the normals.

Use AltN to flip them back.

Sorting and Saving

The answer here contains links and shows how to re-sort a meshes indices using bmesh.

So similarly to method of @MarkusvonBroady can sort by geo (in this case $XY$ plane) and set the verts in this order.

import bpy
import bmesh
context = bpy.context
me = context.edit_object.data
bm = bmesh.from_edit_mesh(me)
for i, v in enumerate(
        sorted(
            bm.verts, 
            key=lambda v: (-v.co.y, v.co.x)
            )
        ):
    v.index = i
bm.verts.sort()
bmesh.update_edit_mesh(me)

Iterate over indices ==> the order we want.

Now simply iterating thru the verts will give the desired order, eg for 4x4 grid as shown in gif,

for v in mesh.vertices:
    row = v.index // 4
    col = v.index % 4 

Note, counting from zero, not one.