CommunityImagemgithub.com

reconstrução-de-cena-fotográfica

Recrie uma foto de referência como uma cena do Blender que se lê como uma fotografia da mesma câmera, usando um harness multiagente com domínios próprios, um loop de renderizar-e-comparar, uma ordem fixa de fidelidade, luz e materiais medidos a partir da foto (sol a partir de sombras, sombra fora do quadro, acabamento do sensor, verificações de albedo), uma regra de obtenção de malha real (sem substitutos primitivos para objetos complexos) e uma lista classificada de técnicas de geração de código para edifícios orgânicos detalhados (seção 7). Use quando o usuário pedir edifícios gerados em código, ou quando pedir para recriar, reconstruir ou igualar uma foto ou imagem de referência em 3D, para aumentar a fidelidade ou o realismo de uma cena gerada, ou para configurar agentes para construir uma cena em paralelo.

O que é reconstrução-de-cena-fotográfica?

Este skill define um método robusto e estruturado para reconstruir uma fotografia de referência como uma cena 3D realista no Blender, utilizando uma arquitetura multiagente. Ele foi desenvolvido e testado em projetos como a reconstrução de uma rua com bonde em Freiburg e uma praça com uma fonte gótica. O processo começa com a configuração do líder, que resolve a câmera e estabelece âncoras de medição, divide a cena em domínios (como iluminação, calçada, fachada principal) e define um livro de regras. Cada domínio é de propriedade de um agente, que constrói sua parte da cena de forma independente, mas seguindo contratos rígidos para garantir a integração: a iluminação é sempre um domínio separado, medições são armazenadas em pixels e valores mundiais, e refinamentos são propagados automaticamente. A ordem de fidelidade é fixa e hierárquica (leitura, silhueta, proporção, cor, partes pequenas, variação e desgaste), com portões que impedem que detalhes sejam adicionados antes que os estágios anteriores estejam corretos. Para objetos orgânicos ou complexos (como árvores, pessoas, veículos, estátuas), o skill exige malhas reais de fontes como a biblioteca do próprio usuário, Poly Haven, ou malhas geradas por IA (Meshy, Tripo) a partir de crops limpos da foto, proibindo primitivas simples como 'esfera no palito'. O loop central usa uma ferramenta de iteração que constrói, renderiza e gera comparações (overlay, bordas) para que o agente e o líder avaliem a fidelidade visualmente, lado a lado com a foto. Após a aprovação do usuário, são aplicados passes de realismo (chanfros, desgaste, vidro), qualidade de renderização, acabamento de sensor, provas de outros ângulos e variações de iluminação. O skill suporta ambientes como Claude Code, Cursor e Codex, e requer Blender (Cycles), Python com numpy, opencv e pillow, e um runtime de agente que possa iniciar subagentes.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/liangjunglj-cpu/ginkgo-skills/tree/main/skills/photo-scene-reconstruction

Installed? Explore more Imagem skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Reconstrução de cena fotográfica

Este método foi desenvolvido em três projetos em novembro de 2026: uma foto de rua com um bonde (Freiburg), uma praça com uma fonte gótica (o Fischbrunnen, Freiburg) e três dioramas de cidade, loja e porto gerados por código. Os exemplos abaixo vêm deles. O harness genérico (câmera, orquestrador, ferramentas de renderizar e comparar) está em harness/ junto a este arquivo: copie harness/blender e harness/tools para uma nova pasta de execução. Nomes de ferramentas escritos abaixo que não estão em harness/ (por exemplo facade_solve.py) são sondas por domínio que cada execução escreve para si; sua finalidade é descrita onde são nomeadas.

Requisitos: Blender (escrito para 5.1, Cycles), Python com numpy, opencv e pillow para as ferramentas 2D (tools/py.sh as executa com uv), e um runtime de agente que possa iniciar subagentes.

O usuário julga a fidelidade a olho nu, lado a lado com a foto. Tudo abaixo existe para tornar essa comparação barata, frequente e honesta.

0. Líder configura antes de qualquer agente iniciar

O líder (a sessão principal) faz estas etapas sozinho. Os agentes iniciam somente quando todas estiverem concluídas.

  1. Pasta de execução. <runs>/<scene>/ com ref/photo.jpg, blender/, tools/, layout/, gen/, renders/, work/, final/. Copie lib.py, arch.py, assets.py, render.py, build_scene.py e as ferramentas genéricas (cam.py, vp.py, solve_cam.py, iterate.sh, overlay.py, edges.py, pair.py, crop.py, stats.py, py.sh, fetch_polyhaven.py, fetch_ph_model.py) de harness/.

  2. Resolva a câmera com tools/vp.py. Encontre o ponto de fuga vertical e um ponto de fuga horizontal ao longo da fachada principal. tools/solve_cam.py então obtém:

    • a distância focal, a partir das duas direções estarem em ângulo reto (não assuma uma lente);
    • a inclinação, a partir do ponto de fuga vertical;
    • o ângulo de guinada, escolhido para que a fachada siga ao longo do eixo +X do mundo.

    Escreva o resultado em layout/camera.json. A câmera fica então congelada para toda a execução.

  3. Meça as âncoras com tools/cam.py:

    • on_z atinge um plano horizontal, on_y um plano vertical, project dá um pixel, e ray dá um raio de visão.
    • Meça as linhas do chão, os planos da fachada e a distância de cada ponto de referência.
    • Escreva as primeiras estimativas do líder no livro de regras como valores iniciais.
    • Em ângulos rasantes, um pixel de uma linha do chão pode ser meio metro de profundidade. Prefira as alturas e larguras de coisas conhecidas (porta 2,1 m, olho 1,6 m, meio-fio 0,12 m) em vez de pontos únicos do chão.
  4. Inventário de objetos. Liste cada objeto visível na foto e marque cada um como roteirizado ou malha (seção 3). Esta lista decide a divisão de domínios e as buscas de ativos.

  5. Escreva AGENTS.md para a execução: objetivo, quadro do mundo, âncoras, tabela de domínios, regras rígidas, o loop, a ordem de trabalho, a regra de conclusão.

1. Propriedade de domínio (como os agentes compartilham uma cena)

Dividindo a cena

  • Um domínio = um módulo com build(L, ctx) + um arquivo layout/<domain>.json + um prefixo de arquivo para qualquer coisa nova (tools/<domain>_*.py, tex/<domain>_*, gen/<domain>_*).
  • Divida por área da tela e tipo de trabalho, não por contagem de objetos. Uma boa divisão dá a cada agente uma região que pode recortar e julgar sozinho. Freiburg usou cinco: luz, rua, edifícios à esquerda, fachada principal, adereços.
  • A luz é sempre seu próprio domínio e possui céu, exposição, gerenciamento de cores e a classificação. Nenhum outro agente toca na exposição para fazer seu próprio material parecer correto.
  • O elemento principal (aquilo em que o olho pousa) recebe um domínio para si.
  • Quatro a seis domínios. Menos e os agentes colidem dentro de um arquivo; mais e o líder não consegue revisá-los.

Contratos

  • build_scene.py apenas orquestra: mescla layout/*.json em L, cria a câmera, chama cada módulo em uma ordem fixa, salva. Nenhuma geometria vive lá.
  • Cada agente pode LER qualquer chave de layout e pode ESCREVER apenas seu próprio arquivo de layout e módulo.
  • Auxiliares compartilhados (lib.py, arch.py, assets.py, cam.py, iterate.sh) estão congelados. Um agente que precise de um auxiliar alterado o copia para seu próprio módulo sob um novo nome. assets.py contém as etapas de ajuste de malha para que cada domínio ajuste malhas da mesma forma:
    • import_gltf importa e define a rotação XYZ;
    • world_bounds calcula limites a partir dos vértices;
    • fit escala para uma altura ou largura medida, gira e abaixa o vértice mais baixo sobre seu suporte.
  • O domínio que mede uma âncora a possui. As âncoras do líder são valores iniciais. O domínio proprietário as refina e publica o resultado em seu arquivo de layout, por exemplo L['facade']['plane_y'] ou L['fountain']['centre']. Cada outro domínio lê o valor de L e nunca copia o número em seu próprio código, para que um refinamento atinja todos na próxima construção.
  • Armazene medições em pixels da foto ao lado dos valores mundiais derivados (por exemplo facade.px ao lado de facade.sec). Um script de solução (tools/facade_solve.py) transforma pixels em números mundiais e os escreve no layout. Remedir significa então editar um pixel e executar novamente o solucionador, não editar coordenadas manualmente.
  • Nomes que outros módulos importam estão listados no livro de regras com a regra "adicione novas funções, nunca altere estas". Valores entre domínios viajam através de ctx (por exemplo ctx['track_x']), não por edições.
  • build(L, ctx) deve funcionar em todos os momentos. Cada agente reconstrói a cena inteira, então um módulo quebrado bloqueia todos. Verifique a sintaxe antes de salvar uma edição arriscada.

Executando os agentes

  • Cada agente constrói em seu próprio work/<domain>.blend; as renderizações são serializadas por work/.gpu_lock (um bloqueio mais antigo que 6 minutos está obsoleto). only= pula outros domínios para velocidade; use a cena completa ao julgar cor, porque os vizinhos refletem luz.
  • No máximo dois ou três agentes que renderizam ao mesmo tempo. Vários processos do Blender aumentaram o arquivo de paginação do Windows além de 50 GB e encheram C:. Exclua o work/<domain>.blend de um agente assim que ele terminar. Aguarde um ID de processo específico, nunca "nenhum Blender em execução".
  • Execute em ondas. Onda 1 são os domínios que fazem geometria (por exemplo chão, fachada e o principal), no máximo três ao mesmo tempo. Onda 2 é a luz e o domínio orgânico ou de móveis, que precisam da geometria para iluminar, sombrear e crescer. Luz julgada em geometria inacabada é trabalho desperdiçado.
  • Mantenha a máquina ativa (request_keep_awake) antes de qualquer onda. Quando o PC entrava em suspensão ociosa, as renderizações congelavam por nove horas.
  • Rodadas. Após cada onda ou rodada, o líder constrói main, revisa a renderização em comparação com a foto a olho nu e escreve as piores diferenças como as instruções da próxima rodada. As anotações do usuário em uma folha de comparação enviada, por exemplo "textura mais áspera" ou "iluminação parece artificial", tornam-se uma rodada própria.
  • Cada agente mantém seus três últimos conjuntos de prévias em renders/ e exclui os mais antigos de seu próprio prefixo.
  • Agentes nunca gastam créditos pagos. Eles relatam o que um ativo gerado corrigiria, com o recorte da foto a ser usado; o líder leva isso ao usuário com o custo.
  • Agentes não fazem commit, não tocam no git e não escrevem fora da pasta de execução.

Instrução do agente (o que o líder envia)

Mantenha curto; o livro de regras carrega o resto.

  • "Leia AGENTS.md primeiro." Depois: seu domínio, seu módulo e arquivo de layout, sua região da foto em pixels.
  • O que já está lá e o que está errado (nomeie as três piores diferenças da foto).
  • A lista de malhas para aquele domínio do inventário, já buscadas em gen/.
  • A regra de conclusão e formato de relatório (abaixo).

Finalização e integração

  • Um agente para quando sua área se sustenta em um recorte de 960 px ao lado da foto, ou após cerca de 12 iterações.
  • Relatório final, abaixo de 250 palavras: o que mudou, o que ainda difere da foto, onde um ativo gerado ajudaria, a tag da última renderização.
  • O líder então constrói work/main.blend a partir de todos os módulos, renderiza o quadro completo e o revisa em comparação com a foto sem ler os relatórios dos agentes primeiro. Relatórios descrevem intenções; a imagem é a evidência. Diferenças tornam-se as instruções da próxima rodada.
  • Humores e efeitos de iluminação são aplicados posteriormente como uma sobreposição não destrutiva em main.blend, para que uma mudança de visual nunca perturbe a fidelidade aprovada. A execução do bonde usou blender/mood.py sobre main.blend. Fischbrunnen faz merge profundo de mood/<variant>.json (escrito por tools/mood_make.py) sobre os layouts quando FB_MOOD está definido; aceita uma lista separada por vírgulas, por exemplo warm_a,film. Use a forma Fischbrunnen: o humor reconstrói através dos mesmos módulos e não precisa de um segundo arquivo de cena.

2. Ordem de fidelidade e o loop

O loop, a cada mudança

tools/iterate.sh <domain> <n> [width=480] [spp=24] [only=a,b] [x0 y0 x1 y1]

Ele constrói, renderiza e escreve ovl_* (foto | renderização | mescla 50%) e edg_* (bordas da foto em vermelho sobre a renderização com uma grade de pixels). Com uma caixa em pixels da foto, renderiza apenas essa região e escreve crop_* (recorte da foto | recorte da renderização, ampliado); na largura 960 leva cerca de 25 s. Abra as imagens e olhe para elas. Nunca relate uma mudança como uma melhoria sem ter visto a comparação.

Trabalhe nesta ordem; não pule etapas

Cada estágio tem um portão. Detalhe adicionado antes de um portão anterior passar é desperdiçado, porque se move quando o erro anterior é corrigido.

estágioo que fazerportão antes de prosseguir
1. LeituraAmplie o recorte da foto da sua área. Anote o que realmente está lá: contagens, materiais, o que toca o quê.Uma lista escrita existe; cada item está no inventário.
2. SilhuetaColoque massas a partir das medições do cam.py.Os contornos ficam sobre as bordas vermelhas em edg_* dentro de alguns pixels a 960 de largura.
3. ProporçãoAberturas, linhas de piso, vãos, contagens de repetição.As bordas de janelas e portas se alinham com as bordas da foto; as contagens coincidem.
4. CorCores base do material medidas em relação à foto, cena completa construída, exposição do domínio de luz intocada. Compare versões de material como albedo (seção 4.2).tools/stats.py e a verificação de região do domínio estão próximos da foto, e a mescla de 50% não mostra manchas com matiz.
5. Partes pequenasGuarnições, ferragens, cabos, placas, calhas, luminárias, desordem de rua. Malhas conforme seção 3.Cada item do inventário para a área existe no recorte.
6. Variação e desgasteChanfros, variação de cor, manchas sob parapeitos, estrias, desgaste do chão, ondulação e reflexos do vidro.O recorte passa na verificação de sinal de CG abaixo, e a verificação de energia de textura (seção 4.3) está próxima da foto.

Regras que valem em todos os estágios:

  • Dimensões do mundo real, em milímetros para padrões. Meça com cam.py; não adivinhe.
  • Nada flutua ou se interpenetra. As coisas ficam no chão ou estão fixadas em uma parede.
  • Uma mudança por iteração ao perseguir uma diferença, para que a comparação mostre o que a mudança fez.

Verificação de sinal de CG (após cada renderização: "o que ainda me diz que isso é CG?")

sinalcorreção usual
Bordas perfeitamente nítidasChanfro ou bisel, de 2 a 10 mm em partes construídas
Superfície plana de cor únicaVariação de cor medida, manchas, estrias, textura em escala real
Repetição visívelVariação por instância no tom, rotação, desgaste
Sombra de contato ausenteVerifique se o objeto toca o chão; verifique luz e denoise
Vidro sem nada atrás ou refletidoPlano interior ou matiz, reflexão real, leve ondulação
Escala de textura erradaRemeça o padrão em milímetros a partir da foto
Objeto em forma de primitivaSubstitua por uma malha real (seção 3)
Chão muito limpoDesgaste, manchas de umidade, folhas, juntas

Após o usuário aprovar a fidelidade

Só então faça estas, nesta ordem:

  1. Passo de realismo: chanfros, vidro e desgaste do chão. A execução do bonde fez isso como um módulo (um módulo weather); Fischbrunnen fez dentro de cada domínio. Qualquer um funciona, mas um domínio deve possuir cada superfície.
  2. Qualidade de renderização: supersample de 2160 px e denoise preciso.
  3. Acabamento do sensor (seção 4.1).
  4. Vistas de prova de outros ângulos (um proof.py que renderiza câmeras extras).
  5. Humor de iluminação.
  6. Filme (seção 5).

Envie uma folha de foto versus renderização em cada um desses pontos de verificação e aguarde o usuário.

3. Malhas: sem primitivas para objetos complexos

Regra: objetos complexos nunca são construídos a partir de geometria primitiva simples. Use uma malha real existente em vez disso.

O que conta

  • Geometria roteirizada é permitida para arquitetura e infraestrutura: paredes, lajes, telhados, caixilhos de janelas e portas, cornijas e guarnições perfiladas, meios-fios, pavimentação, trilhos, postes, fios, placas planas.
  • Uma malha real é necessária para tudo orgânico ou semelhante a objeto: árvores, arbustos, plantas em vasos, pessoas, veículos, bicicletas, cadeiras, mesas, bancos, floreiras, guarda-sóis, luminárias com corpos moldados, ornamentos esculpidos, estátuas, tecido com dobras.
  • Teste: se uma pessoa descreveria sua construção como "uma esfera em um palito", "uma caixa com quatro pernas" ou "um cilindro", é um substituto primitivo e não é permitido, mesmo como espaço reservado em uma renderização enviada ao usuário.

Escada de obtenção (pare na primeira que servir)

  1. Sua própria biblioteca de malhas. Mantenha um índice (categoria, tamanho, contagem de triângulos, caminho, licença) de cada malha de adereço que projetos anteriores produziram ou baixaram, e pesquise-a primeiro. Reutilizar é melhor que comprar.
  2. Poly Haven CC0, gratuito: tools/fetch_ph_model.py <id> (glTF 2k em gen/ph/<id>/), texturas e céus com tools/fetch_polyhaven.py <id>. Mantenha os downloads abaixo de cerca de 150 MB por agente.
  3. Malha gerada, paga, somente através do líder e somente após o usuário ter visto o custo: Meshy para adereços macios ou orgânicos e ornamentos, Tripo H3.1 detalhado para heróis de superfície dura. Prepare e ajuste a malha em três etapas:
    • Limpe o recorte. Recorte o objeto da foto (gen/meshy_refs/<name>_crop.jpg). Execute uma passagem de edição de imagem barata para remover oclusores, finalizar partes cortadas e dar um fundo simples, salvando <name>_clean.png. Só então chame imagem para 3D. Na execução da fonte, isso tornou todas as quatro estátuas e o dossel utilizáveis na primeira tentativa.
    • Decime uma vez, offline, em gen/<domain>_meshes.blend com um alvo de contagem de triângulos, e importe o resultado decimado. Mantenha o original para redecimar se o alvo mudar.
    • Ajuste com assets.fit(): dimensões medidas manualmente (altura, largura, profundidade ou diâmetro), orientação fixa e o vértice inferior colocado no plano de suporte. Se a malha estiver distorcida (por exemplo, um banco inclinado), gira e escala manualmente no editor do Blender com o recorte da foto como referência.

Adereços (malha) precisam de um layout dedicado

Um adereço como uma estátua, fonte, luminária decorativa ou banco merece seu próprio arquivo de layout mesmo quando está em um domínio maior. A fonte fountain.json guardou centre, pedestal_height, pedestal_width, bowl_radius, figure_heights, e o script do módulo (fountain.py) fez assets.fit() para cada malha em relação ao pedestal. Isso manteve o domínio de adereços editável sem bagunçar square.json.

Refinamento dirigido por recorte

Quando a malha não se encaixa no recorte, selecione a malha, entre em modo de edição e mova vértices individuais para corresponder ao contorno no edg_* sobreposto. Nunca repita um ajuste quebrado mais de três vezes sem decimar novamente ou limpar a foto novamente.

4. Luz medida a partir da foto

A luz é resolvida a partir de uma sombra, não de um ambiente

tools/sun_from_shadow.py encontra o sol a partir de uma única sombra horizontal na foto:

  1. O usuário desenha um segmento de borda de sombra de 200 a 400 px no ref/photo.jpg e o salva em ref/shadow_edge.png (o lado da sombra é transparente; a face iluminada é o traço).
  2. Dois cliques em cam.py dão os raios da câmera para o objeto e a extremidade da sombra.
  3. O sol está em: azimute = azimuth no plano do chão + altura = altitude. A altitude vem da razão entre o comprimento da sombra e a altura do objeto, com um sinal +/- para a posição do sol em relação ao objeto. O script escreve layout/sun.json.

Se não houver sombra horizontal, use um ponto de luz de área que corresponda ao brilho e à direção da luz ambiente e verifique com um render de teste contra uma esfera de teste.

A luz de preenchimento (sombra fora do quadro) é um plano de área grande, com ângulo amplo, colocado atrás da câmera, na cor da parte mais escura de um objeto iluminado pelo sol, com uma intensidade que corresponde ao contraste da foto. tools/fill_from_shadow.py executa uma busca binária sobre a intensidade para igualar o contraste em uma região escolhida.

Albedo verificado contra recortes

Cada cor de material é verificada isoladamente (albedo) antes de ser atribuída a um objeto. O procedimento:

  1. Renderize a cena com o material definido para 50% de cinza difuso (sRGB 188,188,188), sem iluminação de ambiente, apenas com uma luz de referência direcional.
  2. Meça o albedo em um recorte de 30x30 px de uma região plana na foto e na renderização.
  3. Ajuste a cor base até que a diferença seja inferior a 3 unidades sRGB por canal.
  4. Só então adicione textura, variação e reflexão.

Energia de textura deve corresponder

Use tools/tex_energy.py para comparar o histograma de gradientes da região da foto com o da renderização. Se a textura renderizada tiver muito mais bordas de alto contraste, reduza a nitidez ou adicione um filtro passa-baixa. Se tiver poucas bordas, aumente a escala da textura ou adicione detalhes de alta frequência.

Acabamento do sensor (fidelidade final)

Após a renderização de 2160 px, aplique:

  • Curva de tom da câmera (a partir de uma calibração de cor, ou use um LUT genérico para a marca da câmera).
  • Ruído do sensor (adicione ruído gaussiano e de Poisson correspondente ao ISO).
  • Aberração cromática (0,5 a 1 pixel nos cantos, com base no perfil da lente).
  • Vinheta (queda de borda de 0,1 a 0,3 EV).

Tudo isso é feito em tools/sensor_finish.py, que pega a renderização e produz final/<name>_sensor.png.

5. Filme (apenas após aprovação total da fidelidade)

Se o usuário pedir uma variante de filme, use uma câmera virtual com profundidade de campo rasa (abertura f/2.8 equivalente em full-frame, distância focal correspondente à cena) e adicione:

  • Granulação de filme (tamanho e quantidade correspondentes ao ISO 400).
  • Respiração de foco (mude o ponto de foco ligeiramente ao longo do quadro).
  • Trepidação da câmera (movimento aleatório de baixa frequência, 0,5 a 2 Hz).

Aplique sobre main.blend como um módulo de pós-processamento, nunca alterando a cena de fidelidade.

6. Edifícios orgânicos gerados por código

Quando o usuário pedir edifícios gerados por código (por exemplo, "gere a cidade" ou "preencha a rua com edifícios"), use a seguinte lista classificada de técnicas, da mais preferida para a menos:

  1. Manhattan com variação: gere blocos com variação de altura, largura e recuo, com fachadas a partir de uma biblioteca de padrões. Use arch.py para gerar caixilhos de janelas e portas.
  2. Edifício de forma livre com subdivisão: use um único bloco subdividido com ruído de deslocamento para formas orgânicas de edifício (por exemplo, museu, teatro). Aplique arch.py depois.
  3. Geração processual de fachada: um único script que gera uma fachada completa com janelas, varandas, cornijas e letreiros, com variação aleatória controlada por semente.
  4. Sistema de lotes: gere lotes com largura e profundidade, e preencha cada um com um edifício da lista acima, com recuos aleatórios.
  5. Geração interno-externo: gere um interior visto através de janelas (paredes, móveis, iluminação) e refletido no vidro.

Regra: ao gerar código, cada edifício deve ser um módulo separado em gen/<building>.py que build_scene.py importa e chama. Nenhuma geometria de edifício vive em build_scene.py.

7. Técnicas para edifícios orgânicos detalhados

Use estas técnicas em ordem decrescente de preferência para fachadas detalhadas e orgânicas:

  1. Geometria de nós: use nós de geometria do Blender para gerar fachadas com variação, especialmente para janelas, varandas e ornamentos. Mantenha o nó em gen/<domain>_nodes.blend.
  2. Matriz de instâncias: gere uma grade de instâncias de um bloco de janela com variação por instância (escala, rotação, material). Use arch.py para gerar o bloco base.
  3. Subdivisão com deslocamento: para formas orgânicas de edifício, use um plano subdividido com um modificador de deslocamento usando uma textura de ruído, então extrude para dar espessura.
  4. Geração de perfil: gere perfis de cornija, peitoril e rodapé a partir de splines curvos com arch.py.
  5. Geometria booleana: para ornamentos complexos, use booleanos de um volume base com formas subtraídas (arcos, nichos). Aplicar depois um chanfro.

Cada técnica deve ser autocontida em um script que aceita L e ctx e escreve em L.

8. Exemplo: Fischbrunnen (Fonte de Peixes, Freiburg)

(Esta seção documenta um exemplo real; os nomes e caminhos abaixo são do projeto.)

Domínios: light, square (praça e edifícios ao redor), fountain (a fonte e estátuas), props (bancos, árvores, luminárias).

Harness: harness/ copiado para runs/fischbrunnen/. Câmera resolvida com vp.py e solve_cam.py.

Âncoras:

  • Chão da praça em z=0 (medido a partir da altura de uma pessoa em pé ao lado da fonte).
  • Pedestal da fonte centrado em (0, 0) com largura de 2,4 m (medida a partir de um banco próximo).
  • Fachada do museu em y=12 m (medida a partir da largura de uma janela conhecida).

Inventário: 23 objetos, 8 roteirizados (paredes da praça, chão, pedestal da fonte, etc.), 15 malha (4 estátuas, 2 anjos, 2 vasos, 3 bancos, 4 árvores, 2 luminárias).

Execução: 5 rodadas, cada uma com uma folha de comparação enviada ao usuário. A última rodada (variação e ), 15 malha (4 estátuas, 2 anjos, 2 vasos, 3 bancos, 4 árvores, 2 luminárias).

Execução: 5 rodadas, cada uma com uma folha de comparação enviada ao usuário. A última rodada (variação e desgaste) levou 3 iterações para passar na verificação de CG.

9. Caminhos e nomenclatura

Tudo pertence a <runs>/<scene>/:

  • ref/: fotos de referência, recortes, bordas de sombra, etc.
  • blender/: scripts .py para o Blender.
  • tools/: ferramentas Python 2D, scripts de solução, auxiliares.
  • layout/: arquivos JSON com medições de cena, câmera, âncoras.
  • gen/: ativos gerados (malhas, texturas, código de edifício).
  • renders/: imagens renderizadas, prévias, overplays.
  • work/: arquivos .blend de trabalho para cada domínio e o principal.
  • final/: saída final para o usuário.

Convenções de nomenclatura:

  • Domínios: light, street, facade, props, etc.
  • Scripts do módulo: <domain>.py com build(L, ctx).
  • Layout: <domain>.json com chaves JSON simples.
  • Ferramentas: <domain>_<tool>.py.
  • Ferramentas genéricas: sem prefixo de domínio.

10. Solução de problemas

problemacausa provávelsolução
A renderização mostra artefatos de bordaRecorte da câmera muito grande para a resoluçãoAumente spp para 64 ou use denoise
A luz não corresponde à fotoÂngulo do sol errado ou intensidade de preenchimentoRemeça a sombra com uma borda de sombra mais longa
A malha não se encaixa no recorteÂngulo da foto, malha baixada muito distorcidaGire e escale manualmente, ou decime novamente a partir do original
O agente trava com erro de sintaxeErro de digitação no script do móduloVerifique sintaxe antes de executar
O arquivo de layout está corrompidoDois agentes escrevendo no mesmo arquivoUse arquivos separados por domínio e mescle em build_scene.py
A renderização tem baixo contrasteExposição da luz muito baixaVerifique o domínio de luz; ajuste a exposição global

11. Licença e atribuição

Este skill é fornecido como está, sob a licença MIT. Consulte LICENSE para detalhes. Poly Haven assets são CC0. Assets gerados podem ter suas próprias licenças; verifique os termos do serviço de cada provedor.


Este arquivo é a especificação completa para reconstrução de cena fotográfica com agentes. Consulte AGENTS.md em uma pasta de execução para a configuração específica da cena.

Habilidades Relacionadas