Existe um método estabelecido para aproximar a distribuição de poeira nas superfícies?

Intuitivamente, a poeira assenta nas superfícies a uma taxa mais alta em áreas onde o fluxo de ar é mais lento. Isso significa que, em vez de uma superfície acumular uma camada uniforme de poeira, haverá mais cantos - cantos de uma sala / prateleira, cantos formados pela colocação de objetos em uma superfície, concavidades em uma superfície.

Eu posso obter um aumento no realismo simplesmente reduzindo a espessura / densidade da poeira com a distância de um objeto e combinando esse efeito para vários objetos, incluindo paredes. Isso naturalmente fornece a ordem esperada de espessuras - as bordas de um piso têm mais poeira que o centro, os cantos onde as bordas se encontram têm mais poeira do que o centro das bordas. No entanto, o aumento no realismo de obter a ordem correta ainda deixa o problema de acertar a proporção. Há mais poeira nos lugares que você espera ter mais poeira, mas não necessariamente a quantidade certa mais.

Existe um método estabelecido para aproximar uma proporção realista de espessura entre diferentes pontos de uma superfície? Não preciso que isso seja completamente preciso fisicamente (isso levaria em conta objetos que se movem pelo ambiente durante o longo período necessário para o acúmulo de poeira). Estou apenas procurando um comportamento comum que pareça crível para o olho humano.

Na pesquisa on-line, encontrei principalmente modelos atmosféricos para poeira em suspensão, em vez de uma maneira de modelar a deposição de poeira em uma superfície.

Minhas tentativas - distribuições lineares e exponenciais

Aqui está um código no Python 3 usando travesseiro (o garfo PIL) que demonstra algumas distribuições com as quais experimentei:

from PIL import Image
from math import exp


def linear(distance, scale):
    return max(0, 64 - distance * scale)


def exponential(distance, scale):
    return 64 * exp(-distance * scale)


def exponential_squared(distance, scale):
    return 64 * exp(-distance * distance * scale)


def gamma_corrected(value):
    corrected_value = int((value/255)**(1/2.2)*255)
    return corrected_value


def produce_image(image_size=(1024,1024),
                  glasses=(((100,300),90),((300,300),110)),
                  distribution=exponential,
                  scale=0.1,
                  background_level=0,
                  gamma=2.2,
                  filename='dusttest.png'
                  ):
    width, height = image_size
    pixels = []
    for y in range(height):
        for x in range(width):
            red, green, blue = pixel_value(x, y, image_size, glasses,
                                           distribution, scale,
                                           background_level
                                           )
            pixels.append((red, green, blue))

    image = Image.new('RGB', image_size, color=None)
    image.putdata(pixels)
    image.save(filename)


def pixel_value(x, y, image_size, glasses, distribution, scale,
                background_level
                ):
    width, height = image_size
    value = background_level
    value += distribution(x, scale)
    value += distribution(width-x, scale)
    value += distribution(y, scale)
    for glass in glasses:
        coords, radius = glass
        a, b = coords
        distance = ((x-a) ** 2 + (y-b) ** 2) ** 0.5 - radius
        if distance < 0:
            value = 0
            break
        value += distribution(distance, scale)
    value = 255 - gamma_corrected(value)
    return ((value, value, value))


if __name__ == '__main__':
    for scale in [0.1, 0.2, 0.4, 0.8]:
        produce_image(distribution=linear,
                      scale=scale,
                      background_level=20,
                      filename='linear-' + str(scale) + '-dusttest.png'
                      )
    for scale in [0.1, 0.05, 0.03, 0.01]:
        produce_image(distribution=exponential,
                      scale=scale,
                      background_level=0,
                      filename='exponential-' + str(scale) + '-dusttest.png'
                      )
    for scale in [0.01, 0.001, 0.0001, 0.00001]:
        produce_image(distribution=exponential_squared,
                      scale=scale,
                      background_level=0,
                      filename='exponential-squared-' + str(scale) + '-dusttest.png'
                      )

Imagine olhar de cima para baixo em uma prateleira branca com copos colocados nela. Algum tempo depois, os óculos são removidos para deixar regiões circulares livres de poeira e uma distribuição de poeira sobre o restante da prateleira. O pó é afetado pelas posições dos óculos e pelas paredes traseira e lateral. A frente da prateleira (parte inferior da imagem) está aberta, sem parede para aumentar a poeira.

Resultado

(Clique para imagens maiores)

Redução linear na densidade do pó mais nível constante de fundo do pó:

Redução exponencial na densidade do pó (nível zero de fundo):

Eu esperava que a versão exponencial estivesse mais próxima da realidade e prefiro o resultado visualmente. No entanto, ainda não sei se isso está perto o suficiente.

Seguindo a sugestão de Alan Wolfe da distribuição normal, também adicionei imagens usando exp(-distance ** 2)em uma variedade de escalas.

Também gosto disso, mas ainda não consegui adivinhar qual exp(-distance)é o melhor e exponencial ( ).

Estou procurando feedback de duas maneiras:

1. Alguma dessas distribuições parece certa / natural para você? Quero sugestões de uma ampla gama de olhos humanos, idealmente com problemas / inconsistências específicas.
2. Existe uma interpretação física que justifique o uso de uma dessas distribuições ou que sugira uma melhor?

Veja o artigo Modelagem por Computador da Neve Caída, publicado no SIGGRAPH 2000:

Neste artigo, apresentamos um novo modelo de acumulação e estabilidade de neve para computação gráfica. Nossa contribuição é dividida em dois componentes principais, cada um essencial para modelar a aparência de uma espessa camada de neve no chão. Nosso modelo de acumulação determina quanta neve uma determinada superfície recebe, permitindo fenômenos como vibração de flocos, poeira de flocos e neve soprada pelo vento. Calculamos o acúmulo de neve atirando partículas para cima em direção ao céu, dando a cada fonte controle independente da superfície sobre sua própria densidade de amostragem, precisão e tempo de computação. A ordem de importância minimiza o esforço de amostragem enquanto maximiza as informações visuais, gerando resultados globais que podem ser interrompidos a qualquer momento. Depois que a neve cai no chão, nosso modelo de estabilidade afasta o material de áreas fisicamente instáveis ​​em uma série de pequenas avalanches simultâneas. Utilizamos um teste simples de estabilidade local que lida com superfícies muito íngremes, obstáculos, arestas e trânsito de ventos. Nosso algoritmo de estabilidade também lida com outros materiais, como farinha, areia e água corrente.

Sua página do projeto contém explicações e imagens de exemplo. Um PDF está aqui .

Um artigo antigo é Simulating Dust Accumulation , publicado na IEEE Computer Graphics & Applications em 1995:

Este artigo descreve uma técnica de modelagem de poeira. Um método empírico é usado para simular visualmente o efeito do acúmulo de poeira nas superfícies dos objetos. A quantidade de poeira é prevista primeiro com base nas propriedades das superfícies: inclinação e aderência da superfície. Esse valor previsto é então ajustado de acordo com alguns fatores externos: exposição da superfície ao vento e raspagem por outros objetos. A quantidade calculada de poeira é finalmente perturbada por uma função de ruído na renderização para fornecer um efeito visual difuso.