Question

只是想知道是否有人可以帮助我进行一些编程数学我遇到了麻烦。

我想要创建的是Nuke（vfx）的提交脚本（使用python和.bat）。我遇到的问题是我无法弄清楚如何将剩余的帧添加到已经计算的堆栈中。

更清楚......

在Nuke中，我必须渲染20帧。我有16个线程。 Nuke只使用1个线程。我想编写一个脚本，它接受帧数并除以线程数，并使用python写出一个bat文件。问题来自于我有余数。我想取余数并将其应用于渲染堆栈。

示例（第一个循环）

thread1 = 1 frame
thread2 = 1 frame
thread3 = 1 frame
thread4 = 1 frame
thread5 = 1 frame
thread6 = 1 frame
...
thread16 = 1 frame

一旦完成了这个......剩下的就是4.我希望其余部分分布在线程中。所以...

示例（第二个循环）

thread1 = 2 frame
thread2 = 2 frame
thread3 = 2 frame
thread4 = 2 frame
thread5 = 1 frame
thread6 = 1 frame
...
thread16 = 1 frame

在前20个帧的前几个线程中添加了4个。

我将非常感谢任何人提供的任何帮助，提示和评论。：）

由于

Answer 1

这是Bressenham algorithm：

的经典用法

def partition(lst, n):
    increment = len(lst) / float(n)
    last = 0
    i = 1
    results = []
    while last < len(lst):
        idx = int(round(increment * i))
        results.append(lst[last:idx])
        last = idx
        i += 1
    return results


for i, frames in enumerate(partition(range(20),16)):
    if len(frames)>1:
        print 'thread'+str(i+1),'=', len(frames),'frames'
    else:
        print 'thread'+str(i+1),'=', len(frames),'frame'

分区位来自HERE。

打印：

thread1 = 1 frame
thread2 = 2 frames
thread3 = 1 frame
thread4 = 1 frame
thread5 = 1 frame
thread6 = 2 frames
thread7 = 1 frame
thread8 = 1 frame
thread9 = 1 frame
thread10 = 2 frames
thread11 = 1 frame
thread12 = 1 frame
thread13 = 1 frame
thread14 = 2 frames
thread15 = 1 frame
thread16 = 1 frame

如果你不介意前面加载2帧线程，你也可以使用Mark Dickinson的解决方案HERE。

然后你有：

def partition(lst, n):
    q, r = divmod(len(lst), n)
    indices = [q*i + min(i, r) for i in xrange(n+1)]
    return [lst[indices[i]:indices[i+1]] for i in xrange(n)]

打印：

thread1 = 2 frames
thread2 = 2 frames
thread3 = 2 frames
thread4 = 2 frames
thread5 = 1 frame
thread6 = 1 frame
thread7 = 1 frame
thread8 = 1 frame
thread9 = 1 frame
thread10 = 1 frame
thread11 = 1 frame
thread12 = 1 frame
thread13 = 1 frame
thread14 = 1 frame
thread15 = 1 frame
thread16 = 1 frame

Answer 2

frames可以是任何对象的列表，例如dict或“Frame”对象。这里我刚刚使用了整数

>>> frames = range(20)
>>> threads = 16
>>> [frames[x::threads] for x in range(threads)]
[[0, 16], [1, 17], [2, 18], [3, 19], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15]]

我认为你可能最好把帧放在Queue中，因为有些帧可能比其他帧渲染得快

Answer 3

frames=20
tPos=16
Ts=divmod(frames,tPos)
threads=[Ts[0]+1 if i < Ts[1] else Ts[0] for i in range(tPos)]

>>> threads    
>>> [2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

如果您在列表推导方面遇到问题，可以用这种方式编写相同的内容：

threads=[]
for i in range(tPos):
    threads.append(Ts[0]+1 if i<Ts[1] else Ts[0])

然后格式化它，执行以下操作：

for i,e in enumerate(threads):
    print 'thread{} {}frames'.format(i,e)

Answer 4

这就是我最终使用的....感谢你帮助每个人。

frames=20 
tPos=16 
Ts=divmod(frames,tPos) 
threads=[] 
for i in range(tPos): 
    threads.append(Ts[0]+1 if i<Ts[1] else Ts[0])

start = 1
end = 0
x=1
while x <= (tPos):
    end = start +(threads[x-1]-1)
    print (start, "-", end)
    start = end + 1
    x+=1


prints:
1 - 2
3 - 4
5 - 6
7 - 8
9 - 9
10 - 10
11 - 11
12 - 12
13 - 13
14 - 14
15 - 15
16 - 16
17 - 17
18 - 18
19 - 19
20 - 20

一点点的编程数学

4 个答案: