如何迭代地改变 function arguments 而不是使用递归？

Question

I am trying to subdivide a triangular mesh till the length of each edge are smaller than an arbitrary value. My approach is pretty simple, I take a look at each edge and calculate its length. If the length of the edge is greater than say 100, I subdivide the faces containing this edge. Say for example, I subdivide the pair of faces sharing an edge into 2 faces each, then I update the vertices list as well as face list. This however only handles the first edge that is greater than 100. The newly formed edges might share edges with existing faces which are longer than 100. I want to check all those edges. My guess now is that, I can either do it recursively or iteratively. I am trying to do this recursively, but I have now a code that I barely understand and am unsure if it returns the correct result. Here's what I have till now in Pseudocode. How would I do this iteratively?

vertices= [[0.0, 0.0, 0.0], [0.0, 0.0, 50.0], [0.0, 50.0, 0.0], [0.0, 50.0, 50.0], [100.0, 0.0, 0.0], [100.0, 0.0, 50.0], [100.0, 50.0, 0.0], [100.0, 50.0, 50.0]]
faces = [[6, 7, 4], [4, 7, 5], [2, 6, 0], [0, 6, 4], [3, 2, 1], [1, 2, 0], [7, 3, 5], [5, 3, 1], [2, 3, 6], [6, 3, 7], [1, 0, 5], [5, 0, 4]]

edges = get_edges_from_faces(faces)

def subdivide_mesh(faces, vertices,edges):
   for edge in edges:
       if length(edge) > 100:
          create_new_faces_and_update() #delete the face sharing this edge and update faces list
          add_new_vertices() # add new vertices to 
       edges = get_edges_from_faces(faces)
       subdivide_mesh(faces, vertices, edges) 

Answer 1

The danger lies in modifying a list on which you are currently iterating. The easiest way to avoid that danger is to make a copy of the list, so that your input list (on which you are iterating) and your output list (which you are modifying) are not the same object.

The code you supplied in your question is not a reproducible example (it's lacking the definition of get_edges_from_faces , for instance). So instead of fixing your code, I'll solve a similar but simpler problem and you can draw inspiration from that.

Problem: In a given list of numbers, replace every number x which is bigger than 10 by smaller numbers which sum to x . For instance, the list [3, 12, 5] should become [3, 6, 6, 5] or something similar.

We are going to iterate on a list l , and add its elements to a result list result , subdivising them when necessary.

Code:

def subdivise_numbers(l):
  result = []
  for x in l:
    if x < 10:
      result.append(x)
    else:
      y = x // 2
      z = x - y
      result.append(y)
      result.append(z)
  return result

Note how we never added elements to the original list l .

Does this answer your question?

Note that if the list originally contains a number greater than 20, the y and z we add to the result might still be too big. One possible way to fix this is to encapsulate our code into a while loop with stop condition "if we didn't subdivise anything in the last run, stop". This require adding a variable to keep track of whether you've subdivided something is this current run or not.

def subdivise_numbers(l):
  keep_going = True
  result = l
  while keep_going:
    keep_going = False
    l = result
    result = []
    for x in l:
      if x < 10:
        result.append(x)
      else:
        keep_going = True
        y = x // 2
        z = x - y
        result.append(y)
        result.append(z)
  return result

Another, better way, is to make sure the numbers y and z we add are already smaller than 10:

def subdivise_numbers(l):
  result = []
  for x in l:
    while x >= 10 and x > 0:
      y = min(9, x // 2)
      x = x - y
      result.append(y)
    result.append(x)
  return result