Mais

Edifícios sem textura na cena da web 3D exportada do ArcScene

Edifícios sem textura na cena da web 3D exportada do ArcScene


Uma amostra aleatória de edifícios está sem texturas. Os modelos foram feitos no Sketchup 8 e exportados para COLLADA, depois lançados no ArcScene. Todas as texturas são .jpg "> exportar 3d arcscene cityengine web-scene

Edição especial "Extração de edifícios baseada em sensoriamento remoto"

Uma edição especial de Sensoriamento remoto (ISSN 2072-4292). Esta edição especial pertence à seção "Sensoriamento Remoto Urbano".

Prazo para envio de manuscritos: fechado (31 de outubro de 2019) .

Edição impressa disponível!
Uma edição impressa desta edição especial está disponível aqui.


1 resposta 1

O que está descrito na pergunta é provavelmente devido à falta de dados UV no modelo (ou todos os UVs definidos para zero).

Para resolver isso, carregue o modelo original no Blender e adicione um mapa UV. Você provavelmente precisará desembrulhar o modelo e talvez ajustar manualmente alguns UVs após desembrulhar.

Apenas chegar ao ponto de ver a textura do modelo no Blender não é suficiente, o Blender pode mapear texturas em malhas sem UVs, mas isso não será exportado para a maioria dos motores de jogo (se não todos).

O usuário que fez a pergunta já sabe o que se segue, mas estou adicionando à resposta para obter uma resposta mais completa

Para desembrulhar um modelo

É recomendado usar uma visão dividida, com o editor de UV visível em uma das vistas. Para dividir visualizações no Blender: https://www.youtube.com/watch?v=rhh513vUgME

Então, trabalhando na visualização com o modelo, selecione o modelo, entre no modo de edição, pressione U, no menu de contexto que aparece clique em Unwrap ou qualquer um dos algoritmos de desempacotamento que o Blender oferece (tente minimizar a quantidade de edição manual para os UVs que você terá que fazer após desembrulhar, a zero se possível).

Verifique no editor do Mapa UV se está tudo OK com os UVs, corrija o que você vê que está errado. Este é um trabalho de artista e a intuição desempenha um papel fundamental.

Agora vá para o painel de textura e verifique se você está usando o mapa UV e não as coordenadas geradas.

Finalmente exporte seu modelo, provavelmente FBX é a melhor opção disponível ao trabalhar com Blender e Unity. Ou deixe o Unity lidar com o arquivo de blend (eu mantenho meus arquivos de blend longe do diretório de ativos do Unity, longa história, e só coloco lá a exportação FBX. Este não é um procedimento padrão nem nada, apenas minha preferência pessoal).

No caso desta questão, o uso de um material externo provavelmente significa que o material já vem configurado para usar os dados UV do modelo. Portanto, a etapa de alterar as propriedades do painel de textura no Blender pode não ter nenhum efeito. Ao criar ambos, seus próprios modelos e materiais, você provavelmente precisará verificar o painel de textura no Blender.


2 respostas 2

Você pode usar o filtro Vanishing Point do Photoshop para isso.

É mais fácil usar uma versão compatível com 3D do Photoshop, ¹ que presumo que você tenha, já que não mencionou nenhum outro software 3D. Existe um caminho alternativo para aqueles que usam uma versão do Photoshop que não possui os recursos 3D, que abordarei inline abaixo.

Essa técnica funciona melhor com uma foto retilínea, ou seja, sem qualquer distorção. A distorção torna impossível para o Photoshop criar geometria 3D que se alinhe com precisão aos recursos da foto. Você pode editar manualmente a geometria que o Photoshop cria para fazer um impreciso modelo para combinar com sua foto imprecisa, mas isso é um incômodo evitável.

A melhor maneira de obter uma fotografia retilínea é usar uma lente de baixa distorção para tirar a foto. O banco de dados de lentes DxO pode ajudá-lo a selecionar um. Além disso, você deve usar uma lente compatível com o recurso de correção de lente do Lightroom ou ACR e, em seguida, usar essa correção automática em sua foto antes de tentar construir um modelo 3D a partir dela.

Veja como fazer isso:

Abra sua foto no Photoshop e diga Filter & rarr Vanishing Point. Usando a ferramenta Criar plano, desenhe uma caixa ao redor da superfície de assento das duas almofadas totalmente visíveis.

Você precisa ser bastante preciso sobre como estabelecer este plano, uma vez que qualquer erro aqui se propagará para o resto do modelo 3D. O Photoshop irá ajudá-lo com isso: a grade dentro do plano muda de cor para indicar o quão plausível o plano é. Você deseja ver uma grade azul, não amarela ou vermelha. Uma grade azul não garante que seja correta para sua cena, no entanto, apenas que poderia ser correto.

Enquanto mantém pressionado Command (Mac) ou Control (Windows), arraste para baixo da caixa de redimensionamento na borda frontal desse plano para soltar um novo plano vertical sobre a borda frontal dessas almofadas distantes.

Agora repita o movimento Cmd / Ctrl e arraste mais 4 vezes para criar os planos que cobrem a almofada mais próxima da câmera: primeiro um vertical para cobrir a parte frontal oculta da almofada, depois um horizontal cobrindo a área de estar e, em seguida, mais dois verticais uns para cobrir os lados voltados para a câmera.

Finalmente, estenda o primeiro plano para cobrir a superfície de assento da almofada do canto interno.

Dimensione esses planos para cobrir toda a superfície visível, embora isso exija a cobertura de algumas áreas da foto que não fazem parte das almofadas: ²

Ajustaremos a cobertura do avião mais tarde.

Se você descobrir que, à medida que se afasta do primeiro plano, os novos se alinham cada vez menos com as superfícies do sofá, a causa mais provável é que você não alinhou precisamente o primeiro plano com a superfície de assento da almofada. Conforme você se estende a partir desse plano desalinhado, você está ampliando esse erro. A melhor solução para isso é excluir tudo, exceto o primeiro plano e, em seguida, ajustar um pouco seus cantos para que se encaixem melhor na cena. Quando você estende novamente aqueles outros 5 planos, eles agora devem corresponder à cena com mais precisão.

Outra causa provável é que você ignorou o conselho acima para começar com uma foto retilínea.

Diga ao filtro de Ponto de Fuga que você deseja que ele retorne uma camada 3D para o Photoshop:

Se sua versão do Photoshop não tiver esse recurso, fique no filtro Ponto de Fuga por enquanto. Faremos a próxima etapa de maneira um pouco diferente para contornar essa falta de suporte 3D direto.

Caso contrário, diga OK e você obterá uma nova camada 3D com um modelo primitivo das superfícies do sofá que você delineou.

Isso praticamente responde à sua pergunta original. Sim, são apenas 6 superfícies em 3D, não exatamente um modelo detalhado, mas como você verá, é o suficiente para alguns propósitos.

O que vamos fazer a seguir é semelhante ao mapeamento de câmera, uma técnica frequentemente usada em VFX para obter efeitos 3D rápidos em uma cena 2D sem ir totalmente 3D. Em vez de projetar uma fotografia em geometria 3D grosseira, vamos usar nossa geometria 3D grosseira para auxiliar na projeção de texturas de volta na fotografia.

Quando você retorna a camada 3D para o Photoshop a partir da caixa de diálogo do filtro Ponto de Fuga, pode ser perguntado se você deseja pular para a área de trabalho 3D³ aceite a oferta.

Se ele perguntar sobre as unidades de medida para a nova camada, você pode preencher valores precisos se isso te deixar feliz, mas isso não afetará os resultados, até onde esta resposta vai. Isso só importa se você for exportar a camada 3D para outro programa e precisar que a nova geometria se ajuste à escala de uma cena maior.

Agora você verá seu modelo 3D primitivo sobreposto à fotografia base. O Photoshop tentará extrair texturas da foto base para este modelo, mas não se preocupe com isso, pois usaremos as ferramentas de pintura do Photoshop para preencher essas superfícies 3D com a textura que desejamos.⁴

Aqui, usei o pincel de padrão com um padrão berrante, então é fácil ver o efeito. Para começar, basta preencher todas as superfícies com sua textura:

Observe que o padrão está na perspectiva adequada, diminuindo na distância. Isso acontece porque estamos pintando em uma superfície 3D que corresponde à geometria áspera de nossa cena 2D.

Se estiver usando uma versão que não tem a capacidade de criar um objeto 3D a partir de planos de Ponto de Fuga, você pode usar a ferramenta Carimbo de dentro da caixa de diálogo Ponto de Fuga para copiar texturas planas nos planos. Isso tem o mesmo efeito de pintar em um modelo 3D, que consiste em aplicar sua textura à cena na perspectiva adequada.

Adicione uma máscara de camada preta à camada 3D clicando com a tecla Option / Alt no ícone da máscara da camada e pinte de branco sobre as áreas em que deseja mostrar o padrão:

Como você pode ver, fiz um trabalho muito difícil aqui. Eu intencionalmente fiz a máscara um pouco maior do que o necessário, usando um grande pincel de arestas duras e pinceladas grandes e desleixadas. Se demorar mais de 30 segundos, você está perdendo tempo. Vamos sufocar a máscara com algum trabalho de detalhe na próxima etapa.

Reduza a opacidade da camada para cerca de 50% para que você possa ver a fotografia subjacente bem o suficiente para ver as bordas da almofada e, em seguida, refine cuidadosamente as bordas de sua máscara para cobrir apenas as partes do modelo 3D que você deseja mostrar o padrão.

Dica profissional: um único clique com um pincel do Photoshop seguido por um Shift-clique em outro lugar fornece um belo traçado reto que você não pode duplicar facilmente à mão. Aqui, você pode clicar na máscara de camada perto de um canto de uma almofada com um pincel de arestas duras para que o pincel apenas toque a borda da almofada e, em seguida, clicar com a tecla Shift na mesma distância do outro canto ao longo dessa borda da almofada . Isso permite que você apare com rapidez e precisão as excursões da máscara além das bordas retas.

Aumente a opacidade da camada 3D para 90-100% e mude seu modo de mesclagem para algo adequado. Para esta combinação de textura e foto de fundo, Linear Burn funciona bem: ⁵

Voilà, estofamento eletrônico!

Agora, essa técnica não é perfeita. O modelo tem apenas alguns planos, então as texturas pintadas nele não dobram nas curvas do sofá com precisão. Como você pode ver na imagem acima, esta limitação pode não ser importante para alguns fins práticos. As sombras da foto se misturam à textura para dar a ilusão de que a textura se ajusta perfeitamente à superfície do sofá, embora na verdade não o seja.

Uma maneira rápida de corrigir isso, se necessário, é usar os filtros Liquify e Warp para dobrar um pouco a textura para seguir os contornos.

Se você realmente precisa de um modelo preciso ou de um arquivo de mapa UV 2D para que possa fazer substituições automatizadas de textura, você tem algumas opções:

Siga as etapas 1 e 2 acima. Então, em vez de selecionar a opção "Return 3D Layer to Photoshop" no menu flyout, diga ao Photoshop para Exportar para 3DS.

Isso fornece um arquivo 3ds Max, que muitos outros aplicativos 3D também podem abrir. Esse formato é usado amplamente o suficiente para que você possa obter importações de boa fidelidade para programas diferentes do 3ds Max, especialmente para geometria tão simples quanto a que criamos aqui.

No Photoshop CS4 Extended ou posterior, você pode continuar com a etapa 3 acima para retornar a camada 3D para o Photoshop a partir da caixa de diálogo do filtro Ponto de Fuga e dizer 3D & rarr Exportar Camada 3D.

Estranhamente, o formato 3ds Max não é uma de suas escolhas aqui. Dos que o Photoshop oferece, recomendo o Wavefront OBJ. É tão amplamente compatível quanto * .3ds. Muitos programas 3D abrirão ambos, enquanto outros abrirão apenas um ou outro.

COLLADA é um padrão aberto, portanto, em teoria, deveria ser a melhor opção, mas acho que os importadores freqüentemente destroem a geometria.⁶ Ainda assim, você pode querer tentar se as opções * .3ds e * .obj não funcionarem para vocês.

O Photoshop também pode exportar para STL e DXF, que são amplamente aceitos, mas inadequados para esse tipo de trabalho. Eles são formatos CAD do mundo real, não formatos de imagem criativos. Você pode usá-los na fabricação de sofás de verdade.

Todas as outras opções são "padrões" no sentido do XKCD. Evite-os.

Agora você "apenas" precisa abrir este arquivo de modelo em um verdadeiro modelador 3D e refiná-lo. Um pacote 3D completo também permitirá que você trabalhe diretamente com o mapa UV, se necessário.

Isso nos deixa muito fora do escopo deste site, no entanto. Mesmo que a modelagem 3D fosse o assunto aqui, para ir muito além disso, eu basicamente teria que responder à pergunta: "Como você faz modelagem 3D?" Esse tópico requer livros inteiros para explicar. Você precisa de meses de prática para adquirir competência e cerca de 10.000 horas de prática focada no desenvolvimento de habilidades para atingir certa medida de especialização. Essa habilidade é rara, difícil e valiosa o suficiente para que você ganhe a vida fazendo isso.

Depois de ter um modelo 3D detalhado, você pode trazê-lo de volta para o Photoshop, se desejar. Photoshop é uma boa ferramenta de pintura de textura 3D. Existem também ferramentas dedicadas como MARI, 3D-Coat e BodyPaint 3D. Pacotes 3D de ponta geralmente incluem recursos de pintura de textura que rivalizam ou excedem o Photoshop em seu escopo mais especializado: CINEMA 4D, modo, Blender, etc.

Se você assinou o Creative Cloud completo, já tem o CINEMA 4D Lite, uma versão simplificada, mas bastante funcional do C4D, que agora inclui BodyPaint, um recurso que costumava estar disponível apenas nas versões não Lite. Você pode pensar no BodyPaint como uma alternativa apenas 3D ao Photoshop, feita para pintar diretamente nos modelos, como fizemos acima. A principal restrição prática é que você deve usá-lo por meio do After Effects, o que é estranho se você ainda não estiver usando o AE para o seu projeto. No lado positivo, você pode obter a AE diretamente do filtro de Ponto de Fuga:

Isso significa CS3 Extended a CS6 Extended ou qualquer uma das versões da Creative Cloud. Testei essa técnica no CS3 Extended e no CC 2014.2.

Você verá grades azuis, em vez de planos numerados de cores sólidas. Pintei e enumerei os planos para tornar o exemplo mais claro.

Se você está procurando o terceiro plano amarelo, ele está de costas para a câmera. Só tivemos que construí-lo para contornar o canto da forma de L do sofá.

Todas as versões 3D do Photoshop possuem o recurso Workspaces, mas as versões anteriores não faziam essa troca automática de modo de workspace. O espaço de trabalho 3D não foi adicionado ao Photoshop até CS4. Além disso, as versões que oferecem a opção de alternar para o espaço de trabalho 3D podem ser instruídas a lembrar a escolha, portanto, ele pode simplesmente mudar o espaço de trabalho sem perguntar.

Estritamente falando, isso não fornece o mapa UV que você pediu, mas a pintura direta do modelo é o que você realmente deseja na maioria dos casos. Se você realmente precisa de um arquivo de mapa UV separado, precisa exportar o modelo 3D do Photoshop para outro aplicativo, conforme descrito acima.

A pintura de textura funciona de maneira diferente no Photoshop CS3 Extended. O CS4 adicionou a capacidade de pintar diretamente no modelo, enquanto no CS3, você precisa abrir e editar cada textura separadamente. Para esta técnica, a diferença realmente não importa.

O modo de mesclagem Multiply também pode funcionar bem para esse tipo de combinação. Outras texturas e fotos de base podem exigir outro modo de mesclagem inteiramente.

Isso provavelmente ocorre porque o COLLADA não é apoiado por um dos maiores produtores de software 3D e, portanto, não tem influência no mercado para definir o que o padrão significa no mundo real. É um padrão aberto, portanto, cada empresa que o implementa tem sua própria abordagem incompatível.


LandInfra (e InfraGML) na teoria e na prática

LandInfra é um padrão relativamente novo e atualmente é difícil identificar quaisquer exemplos concretos de seu uso na prática, a maioria dos artigos científicos que mencionam LandInfra apenas descrevem a necessidade de considerá-lo em trabalhos futuros.

Existem muitos documentos que discutem a relação entre LandInfra e o Modelo de Domínio de Administração de Terras ISO 19152 (LADM), ver por exemplo [15, 33, 34, 42, 66, 67, 78]. Nestes artigos, o InfraGML é citado, ao lado de outros modelos como CityGML e LandXML, em relação à coleta dos dados 3D existentes que são coletados para abrir a possibilidade de criar um banco de dados cadastral 3D.

Existem vários artigos que discutem a integração do LandInfra em casos de uso específicos. Kara et al. [34] avaliaram o uso de vários modelos diferentes para fornecer um modelo de informação de avaliação para impostos sobre a propriedade. Pouliot et al. [68] comparou o esquema de correspondência entre as necessidades do usuário e três padrões geoespaciais (CityGML UtilityNetwork ADE, InfraGML e IFC) em relação à modelagem de redes de utilidades subterrâneas. Eles não foram capazes de chegar a uma conclusão definitiva devido a resultados contraditórios baseados em diferenças nas técnicas de correspondência de esquemas e na variação entre os vários níveis e o número de elementos ao comparar um esquema a outro. [69] avaliaram o LandInfra, junto com outros modelos de informações espaciais 3D, em termos de sua capacidade de modelar interesses legais e limites legais, conforme definido na jurisdição de Victoria na Austrália. Eles descobriram que a abordagem LandInfra para referenciar elementos físicos baseados em IFC pode ser utilizada para incorporar objetos físicos no modelo vitoriano, mas eles precisariam incorporar elementos de vários modelos de informações espaciais 3D para seu modelo final. LandInfra também é mencionado como um dos padrões potenciais para representar dados sobre infraestrutura subterrânea (serviços públicos e outros recursos de subsuperfície) pelo Estudo de Desenvolvimento de Conceito de Infraestrutura Subterrânea (CDS) da OGC para melhorar a interoperabilidade de dados de infraestrutura subterrânea [65]. LandInfra considera infraestrutura úmida e utilitários dentro de seu escopo [73], seus possíveis alinhamentos com CityGML Utility Networks ADE [5] e PipelineML [56] foram destacados no estudo [65].

Existem vários artigos discutindo a integração do LandInfra e InfraGML com outros padrões geoespaciais. Um trabalho importante está sendo feito nessa direção pela equipe da Institut Géographique National (IGN) França para alinhar CityGML e InfraGML [12, 17]. Sua pesquisa investigou o processo acústico e as entradas para determinar quais dados disponíveis entre CityGML e InfraGML são mais adequados para estudos acústicos de ambiente inicial [12]. A pesquisa também levantou vários pontos importantes, como a falta de flexibilidade para extensões no modelo conceitual LandInfra e a indisponibilidade de conjuntos de dados InfraGML do mundo real na prática. Devys [17] discutiu a interoperabilidade, entre o RailTopoModel [81] e o LandInfra, para infraestrutura ferroviária e propôs um mapeamento entre os dois modelos. Labetski et al. [39] analisaram o uso do LandInfra como uma estrutura para estender a definição dos LODs para estradas no módulo de transporte do CityGML, mas descobriram que a falta do conceito de níveis de detalhe no LandInfra o tornava irrelevante. [49] também propõe analisar LandInfra no contexto de estradas, mas com o propósito de determinar limitações nos padrões de dados atuais para ativos rodoviários e criar recomendações para um padrão melhorado, a fim de aplicar tecnologias SW (Web Semântica) para construir uma solução de protótipo para confluência de dados de ativos rodoviários. Conforme eles continuaram suas análises, [48] descobriram que o uso de IFC, IFC Alignment e InfraGML deve ser considerado, uma vez que esses padrões são suportados por vários aplicativos de software industrial. Eles concluem com a convicção de que ao invés de tentar desenvolver outro padrão de informação sobre ativos rodoviários, deveria haver uma investigação sobre as abordagens de tradução para auxiliar a comunicação entre os padrões [48]. Malmkvist et al. [45] utilizou o InfraGML e o IFC Alignment para a troca de informações de dados de ativos rodoviários entre as fases de projeto e operação de um projeto rodoviário em diferentes sistemas de software.


Investigações arqueológicas

As investigações arqueológicas fornecem oportunidades desafiadoras de análise facial para retratar rostos do passado, para mostrar ao público como essas pessoas antigas eram e para permitir a comparação com rostos contemporâneos (Prag & Neave, 1997). Eles também podem fornecer diferentes tipos de material em comparação com as investigações forenses e a quantidade de interpretação artística pode ser maior, dependendo do nível de preservação. Em casos forenses, é preferível incluir apenas detalhes de aparência que foram verificados diretamente da evidência da cena, e não estimar quaisquer incógnitas, pois os detalhes estimados incorretamente podem confundir e desestimular o reconhecimento e a identificação (Wilkinson, 2004). No entanto, em investigações arqueológicas, o reconhecimento do rosto raramente é o objetivo principal e produzir a representação mais provável pode ser mais importante do que a identidade individual. Nestes casos, o arqueólogo irá sugerir o penteado, a cor do cabelo, a cor da pele e a cor dos olhos mais prováveis ​​a partir de evidências históricas textuais e pictóricas.

A representação de corpos preservados

Os antigos egípcios forneceram uma rica fonte de análise, já que o processo de mumificação preserva (com algumas modificações) os tecidos moles do rosto, bem como o material esquelético. O desenvolvimento da imagem clínica tem permitido a análise não invasiva dos tecidos moles e duros das faces dos antigos egípcios. Dados transversais criados por tomografia computadorizada (TC) podem ser empregados para produzir um modelo digital tridimensional do crânio (Spoor et al. 2000) e réplicas de crânios podem ser produzidas a partir de dados digitais usando estereolitografia (Hjalgrim et al. 1995) ou outra forma de fabricação de modelo tridimensional (Seitz et al. 2005). Modelos digitais 3D do crânio também podem ser importados para sistemas de reconstrução facial baseados em computador. Exemplos de tais trabalhos incluem a reconstrução facial de Tut Ankh Amun (Gatliff, 2001 Handwerk, 2005), Nesperrenub (Taylor, 2004) e Janus (Tukker & Dassen, 1999).

Freqüentemente, a avaliação dos tecidos moles mumificados revelará detalhes da morfologia facial que não podem ser determinados apenas pelo esqueleto (Fig. 9A), aumentando a confiabilidade e reduzindo a interpretação artística da reconstrução facial. Freqüentemente, as orelhas serão preservadas e pode ser possível determinar o formato, tamanho e detalhes da orelha diretamente da múmia (Taylor, 2004). Da mesma forma, a linha do cabelo e o padrão dos lábios podem ser visíveis, detalhes que requerem interpretação artística em muitas reconstruções faciais. O encolhimento, a distorção e os efeitos do procedimento de mumificação devem ser considerados, pois podem afetar a aparência dos tecidos moles: muitas características faciais serão distorcidas pelas bandagens, o nariz pode ser distorcido pela remoção do cérebro e os olhos fundos devido à autópsia mudanças (Aufderheide, 2003). Por exemplo, a grande maioria das múmias egípcias parecem exibir narizes em forma de gancho de perfil, embora isso seja tipicamente uma distorção da bandagem em vez do perfil real do nariz, e profissionais experientes reconhecerão esse fenômeno (Cesarani et al. 2004).

Reconstrução facial de múmia egípcia (A) e representação de trauma (B). 12th Dynasty Ancient Egyptian Priest (A) - a réplica 3D dos tecidos moles de uma múmia egípcia (à esquerda) produzida por estereolitografia a partir dos dados de tomografia computadorizada e da reconstrução facial resultante (à direita) - cortesia do Museu Nacional da Escócia. A reconstrução facial de um soldado da coleção da Batalha de Towton de 1996 (B) na Universidade de Bradford mostrando um ferimento de espada curado em sua mandíbula (esquerda). O trauma esquelético curado pode ser visto à direita - cortesia da Universidade de Bradford.

A aparência facial dos corpos das turfeiras tem sido de grande interesse desde as primeiras descobertas, uma vez que os tecidos moles são preservados pela acidez do ambiente das turfeiras (Asingh & Lynnerup, 2007). Isso pode levar à incrível preservação das faces dos corpos dos pântanos, embora possa haver distorção severa devido à pressão do ambiente de sepultamento. Onde há distorção dos tecidos moles, pode ser difícil visualizar as características e proporções faciais e, nessas circunstâncias, a reconstrução facial foi utilizada (Prag & Neave, 1997, Cap. 8, Bergen et al. 2002). A tomografia computadorizada permite a visualização do crânio, mas as condições ácidas da turfa causam a deterioração da superfície óssea e isso, em combinação com qualquer distorção, torna difícil a avaliação do esqueleto para a reconstrução facial. No entanto, a falta de detalhes do esqueleto é mais do que compensada pela enorme quantidade de morfologia facial preservada, e a reconstrução facial dos corpos dos pântanos será realizada principalmente a partir das informações fornecidas pelo material do tecido mole (Wilkinson, 2007). Tal como acontece com as múmias, as orelhas são frequentemente preservadas e pode ser possível determinar a forma, tamanho, protrusão e detalhes da orelha diretamente. Da mesma forma, os padrões de linha vermelha, linha do cabelo e rugas faciais podem ser visíveis, detalhes que requerem interpretação artística em muitas reconstruções faciais (Wilkinson, 2009). Grauballe Man e Clonycavan Man são exemplos desse tipo de trabalho (Wilkinson, 2007, 2009). Junto com os detalhes da morfologia facial, os corpos dos pântanos geralmente exibem informações adicionais sobre o penteado, a cor do cabelo e os pelos faciais (Wilkinson, 2009), diminuindo ainda mais a interpretação artística da reconstrução e aumentando sua confiabilidade.

A representação de doenças e traumas

Os casos arqueológicos podem ser desafiadores, pois os restos do esqueleto podem exibir certas condições patológicas, deformidade facial ou feridas faciais. Onde isso for evidente, a técnica de reconstrução facial pode ser uma ferramenta valiosa para ajudar a estabelecer a aparência facial relacionada ao tratamento médico, processos de doenças antigas e condições hereditárias. Onde o trauma facial foi peri-mortem, geralmente é inapropriado para a reconstrução demonstrar quaisquer feridas resultantes. Quando as feridas mostrarem sinais de cicatrização, pode ser apropriado demonstrar a cicatriz do tecido mole como parte da reconstrução. O primeiro caso de reconstrução facial que envolveu trauma facial foi de Philip II Macedon, da Grécia antiga de 250 aC (Prag & Neave, 1997), mostrando uma ferida bem curada no olho direito.

Um exemplo mais recente pode ser visto no caso de um soldado (número 16) da Batalha de Towton (Fig. 9B). Seus restos mortais fazem parte da coleção de 1996 da Batalha de Towton de 37 esqueletos da Universidade de Bradford (Fiorato et al. 2000). O crânio exibia uma lesão de lâmina bem curada no corpo mandibular esquerdo. O ferimento da lâmina havia penetrado na superfície lingual do corpo, removendo o ápice do primeiro molar e impactando a superfície interna do corpo mandibular direito. Um buraco aberto permaneceu entre os primeiros e segundos molares esquerdos, onde o osso foi removido. Todas as margens da ferida estavam bem cicatrizadas e não exibiam evidências de infecção. A reconstrução foi produzida demonstrando esta ferida curada, pois teria alterado muito a aparência facial viva do soldado, com o tecido cicatricial resultante distorcendo o lado esquerdo do rosto em um grau significativo. Além disso, ele pode ter sofrido dificuldades para comer e falar e alguns problemas com o fechamento da boca do lado esquerdo, levando a dribles e queda do canto esquerdo da boca (Wilkinson & Neave, 2003).

Reconstruções representando condições patológicas podem fornecer informações úteis para comparação com populações contemporâneas e reconstruções foram produzidas de indivíduos com meningioma, hiperostose e um hemangioma (Wilkinson, 2008). Essas reconstruções fornecem mais detalhes em relação aos detalhes da superfície da face e, dessa forma, podem ser consideradas como envolvendo uma maior avaliação científica. No entanto, a interpretação do trauma e da doença, embora baseada na ciência, ainda pode ser considerada como incluindo um elemento de estimação artística.

O uso de retratos para detalhes de superfície

Ocasionalmente, retratos podem estar disponíveis para uso como material de referência para a adição de detalhes de superfície, como gordura, mudanças relacionadas à idade, cor da pele, cor dos olhos, penteado e cor e pelos faciais. Nessas circunstâncias, as reconstruções faciais resultantes podem ser consideradas mais confiáveis ​​em termos de semelhança. Normalmente, o processo de reconstrução facial do crânio ao rosto é realizado às cegas para o retrato e, em seguida, o detalhe da superfície é adicionado para representar o rosto do passado de forma mais confiável.

Exemplos do uso de retratos para detalhes de superfície são as reconstruções faciais de múmias do Egito Antigo com retratos relacionados. Os retratos (retratos de Fayuum) datam todos do século I ao século II dC e foram produzidos usando uma técnica encáustica (Walker, 1997). Esses retratos foram analisados ​​por egiptólogos para determinar estilos de cabelo, joias, moda e status social. Estima-se que haja mais de 1000 retratos de múmias, mas menos de 100 ainda estão encadernados em suas múmias. Várias múmias com retratos foram estudadas (Wilkinson, 2003b Prag, 2002 Brier & Wilkinson, 2005) e, em todos os casos, após uma avaliação de semelhança, os retratos foram usados ​​para aplicar detalhes de superfície adicionais às reconstruções.

Um estudo recente do crânio de Johann Sebastian Bach (1685–1750), o famoso compositor e organista alemão, incluiu a avaliação de um retrato conhecido de Bach para informações adicionais de superfície (Hansen, 2008). Bach era conhecido por ter trabalhado para o pintor Elias Gottlob Haussmann em 1746, alguns anos antes de sua morte (Müller, 1935). Haussmann (1695-1774) serviu como pintor da corte em Dresden e, a partir de 1720, como retratista oficial em Leipzig. A reconstrução facial foi produzida como um modelo 3D computadorizado usando uma varredura a laser da cópia de bronze do crânio de Bach fornecida pelo Bachhaus, Eisenach (Fig. 10). O crânio sugeria um homem de meia-idade com nariz grande, queixo forte e mordedura baixa. Dados de profundidade de tecido de homens alemães contemporâneos em seus 60 anos foram empregados para a reconstrução (Helmer, 1984), mas o grau de gordura do rosto foi diretamente influenciado pelo retrato de Haussmann. Os registros da vida de Bach sugerem que ele tinha problemas nos olhos que o deixaram com as pálpebras inchadas e doloridas e o retrato retratou essa doença (David & Mendel, 1945 Zegers, 2005) Os detalhes dos olhos, cor dos olhos, cor da pele e detalhes do envelhecimento facial foram determinados a partir do retrato (Fig. 10). A combinação de avaliação esquelética e avaliação de retrato apresenta uma representação facial de Bach que pode ser considerada o mais precisa possível com o material disponível (Hansen, 2008).

A reconstrução facial de Johann Sebastian Bach. A reconstrução facial computadorizada (A) utilizou um modelo 3D do crânio a partir de dados de varredura a laser. A textura foi adicionada à face resultante (B) usando o retrato Haussmann 1746 (D) como material de referência em relação ao grau de gordura, condição dos olhos, cor da pele, cor dos olhos, cor do cabelo e texturas da pele (C). Cortesia de Bachhaus, Eisenach e Dra. Caroline Wilkinson & Janice Aitken, University of Dundee.


Gênese

A versão 1.42 do software Image Cutter foi lançada ontem. Isso inclui a adição de um modelo para permitir o uso da API v3 do Google & # 8217s. Esta versão da API do Google Maps não requer uma chave de API e funciona melhor do que a v2 em dispositivos móveis como iPhones, iPads e tablets Android.

Você pode baixar a versão mais recente no seguinte link: Image Cutter 1.42

Trackernet: Onde estão todos os trens do metrô?

Isso está começando a ficar obsessivo, mas não posso deixar de me perguntar quantos trens estão circulando no metrô de Londres e onde estão todos eles. O serviço da web Trackernet lançado pela TfL permite que você veja todos os estribos das estações em uma linha, mas não informa onde todos os trens estão. I did an earlier post about just the Victoria line trains, but I’ve now built this into a web service that works out locations for trains on the whole network.

Trains on the London Underground network for 11:30am on 30th November 2011

The map colours follow the normal line colours, so District (Green), Victoria (Light Blue), Central (Red), Northern (Black), Bakerloo (Brown), Jubilee (Grey), Piccadilly (Dark Blue), Waterloo and City (light green). Note that Circle and Hammersmith and City are all shown as yellow and there are no pink markers on the map. This is because the Trackernet API does not distinguish between Circle and Hammersmith and City trains and both lines are queried in one web request, so they’re difficult to separate out.

The idea is to build this into a web service and publish it on MapTube as a real-time Tube map. Using the locations of trains and the time to station information we can build a model of whether a line is running normally and where delays are occurring.

The basic technique behind how the positions are calculated relies on using the time to station information from the running boards at every station on the route to find the minimum time for every unique train. This is then taken as the most accurate location estimate and its position interpolated between the last and next stations based on the time. It is actually a lot harder to work out which line a train is on due to the fact that multiple lines can share platforms at the same station. For example, query the Piccadilly line and the District line and the resulting data will contain Barons Court for both, so you have to separate out the Piccadilly trains and the District trains and make sure you don’t count the same ones twice.

Now that the code can handle the Underground network, the next steps are to do the same for National Rail, London Buses and London River Services.

If you’re interested in live train data, it’s also worth looking at the following site that was created by Matthew Somerville: http://traintimes.org.uk/map/tube

FBX Exporters Part 4

In the previous three parts, I outlined the plan for getting geometry from MapTube via C Sharp into an FBX file using the C++ SDK provided by Autodesk. This final part shows data in a world map exported from MapTube and imported into 3DS Max.

The above image shows the world countries 2010 outline from MapTube. There a few countries missing as there was no data for them in the original dataset, so they show as blank on a MapTube map and their geometry is not exported. This is more visible in the perspective view where you can see the holes in Africa and the Middle East:

The exported geometry will eventually be coloured in the same way as MapTube, but for the moment all the geometry objects have a green material assigned to them.

The final export file can be downloaded from the following link: MyFBXExport

It’s worth pointing out that I’ve had a number of problems with the Quicktime FBX plugin that comes with the Autodesk FBX SDK. It seems to crash every time I close it and when displaying the above file there are some significant problems with how it renders the geometry. Most notably around the Hudson Bay area in Canada, parts of Europe and much of Russia. As it displays fine in Max, I can only assume this is a limitation of the Quicktime FBX renderer. I’ve also had to do some re-scaling of the geometry as it is exported in the Google Mercator projection, using metres. This means that the numbers are too big for Max to handle, so I’ve had to rescale them.

To recap on how this process works, here are the development steps needed to achieve it:

1. A C Sharp program which is a modification of the MapTubeD tile rendering procedure reads the geometry and data from the MapTube server and returns it as an iteration of SqlGeometry objects.

2. Each SqlGeometry object is simplified using the Reduce operation as we don’t need the full level of detail in the output FBX file.

3. The C Sharp program uses native methods in a C++ DLL, which I’ve written to control the operation of the FBX exporter in Autodesk’s SDK. A handle to the FBX document and scene that we want to create is obtained and then a native “AddGeometry” function is used on every geometry object until a final “WriteFile” function is called. The geometry is passed using the OGC well known binary format which is an efficient way of passing large blocks of complex geometry and is also independent of byte ordering.

The DLL which does the actual export is a 32 bit program with functions exported using C names rather than decorated C++ names to make it easy to link to the C Sharp function stubs. Internally, I’m using the GEOS library to parse the well known binary geometry, extract polygons and write the points to the FBX scene hierarchy.

That’s the proof of concept to demonstrate that this method works. The aim now is to see what we can do with geographic data now that we have the ability to load it into art tools like Max and Maya, game engines like Unity, or frameworks like XNA.

FBX Exporters Part 3

The first two parts of the FBX export process dealt with getting the FBX SDK working and exporting some simple geometry. Now what’s required is the ability to pass complex geometry from the MapTube side using C# over to the FBX side using C++. The obvious way to do this is to pass the geometry in the OGC well known binary format (WKB), so I’ve been looking at GEOS which is a C++ port of the Java Topology Suite (JTS). I’ve managed to use this in conjunction with the FBX exporter to create simple geometry from WKT which I’ve loaded into 3DS Max.

One of the problems I had was building a debug version of GEOS version 3.3.1 as the instructions aren’t quite right. The make command for a debug build is:

nmake /f makefile.vc BUILD_DEBUG=YES

As I’m using Visual Studio 2008, I had to run “autogen.bat” first to create the required header files, and also make sure I do a clean between the release build and the debug build. Once this library was built successfully, I could use the WKT reader to read in some test geometry and build an FBX exporter around it.

[c language=”++”]
string version = geos::geom::geosversion()
cout<<version
//geom::Geometry* geos::io::WKBReader::read ( std::istream & is )
std::string poly("POLYGON ((30 10 0, 10 20 10, 20 40 20, 40 40 30, 30 10 0))")
cout<<poly<<endl
WKTReader* reader = new WKTReader()
Geometry* geom = reader->read(poly)
delete reader
[/c]

The entire FBX exporter is too big to replicate here, but the part that extracts the geometry from the GEOS geometry object and creates the FBX control points is as follows:

[c language=”++”]
//create control points
int NumPoints = geom->getNumPoints()
lMesh->InitControlPoints(NumPoints)
KFbxVector4* lControlPoints = lMesh->GetControlPoints()
CoordinateSequence* coords = geom->getCoordinates()
for (int i=0 i<NumPoints i++)
<
lControlPoints[i]=KFbxVector4(coords->getOrdinate(i,0), coords->getOrdinate(i,1), coords->getOrdinate(i,2) )
cout<<coords->getOrdinate(i,0)<<","<<coords->getOrdinate(i,1)<<","<<coords->getOrdinate(i,2)<<endl
>
[/c]

The only other thing I’ve done is to create a material for the polygon so it shows up as red in 3DS Max.

Now I’ve demonstrated that all the component parts work, the final stage of getting geometry from MapTube into 3DS Max will be to write a C++ library on top of the FBX exporter and GEOS which can be used as a native library from C#.

FBX Exporters Part 2

In the first FBX exporter post I got to the point where the export of simple geometry from one of the Autodesk SDK examples could be loaded by the Quicktime plugin. This used the SDK as a multithreaded statically linked library which I used with one of the examples to create a plane object. The following image shows a more complicated file containing a marker (red), custom geometry in the form of a cube (grey) and a camera (looks like a camera).

The code to get to this point is rather complicated, but I copied the UI Examples CubeCreator example program supplied with the SDK which showed how to set up the cube mesh with all the correct normals and textures.

The scene graph is set up with a camera, marker and mesh as follows:

[c language=”++”]
// build a minimum scene graph
KFbxNode* lRootNode = pScene->GetRootNode()
lRootNode->AddChild(lMarker)
lRootNode->AddChild(lCamera)
// Add the mesh node to the root node in the scene.
lRootNode->AddChild(lMeshNode)
[/c]

The creation of the mesh object prior to this is a lot more complicated:

[c language=”++”]
// Define the eight corners of the cube.
// The cube spans from
// -5 to 5 along the X axis
// 0 to 10 along the Y axis
// -5 to 5 along the Z axis
KFbxVector4 lControlPoint0(-5, 0, 5)
KFbxVector4 lControlPoint1(5, 0, 5)
KFbxVector4 lControlPoint2(5, 10, 5)
KFbxVector4 lControlPoint3(-5, 10, 5)
KFbxVector4 lControlPoint4(-5, 0, -5)
KFbxVector4 lControlPoint5(5, 0, -5)
KFbxVector4 lControlPoint6(5, 10, -5)
KFbxVector4 lControlPoint7(-5, 10, -5)

KFbxVector4 lNormalXPos(1, 0, 0)
KFbxVector4 lNormalXNeg(-1, 0, 0)
KFbxVector4 lNormalYPos(0, 1, 0)
KFbxVector4 lNormalYNeg(0, -1, 0)
KFbxVector4 lNormalZPos(0, 0, 1)
KFbxVector4 lNormalZNeg(0, 0, -1)

// Initialize the control point array of the mesh.
lMesh->InitControlPoints(24)
KFbxVector4* lControlPoints = lMesh->GetControlPoints()
// Define each face of the cube.
// Face 1
lControlPoints[0] = lControlPoint0
lControlPoints[1] = lControlPoint1
lControlPoints[2] = lControlPoint2
lControlPoints[3] = lControlPoint3
// Face 2
lControlPoints[4] = lControlPoint1
lControlPoints[5] = lControlPoint5
lControlPoints[6] = lControlPoint6
lControlPoints[7] = lControlPoint2
// Face 3
lControlPoints[8] = lControlPoint5
lControlPoints[9] = lControlPoint4
lControlPoints[10] = lControlPoint7
lControlPoints[11] = lControlPoint6
// Face 4
lControlPoints[12] = lControlPoint4
lControlPoints[13] = lControlPoint0
lControlPoints[14] = lControlPoint3
lControlPoints[15] = lControlPoint7
// Face 5
lControlPoints[16] = lControlPoint3
lControlPoints[17] = lControlPoint2
lControlPoints[18] = lControlPoint6
lControlPoints[19] = lControlPoint7
// Face 6
lControlPoints[20] = lControlPoint1
lControlPoints[21] = lControlPoint0
lControlPoints[22] = lControlPoint4
lControlPoints[23] = lControlPoint5

// We want to have one normal for each vertex (or control point),
// so we set the mapping mode to eBY_CONTROL_POINT.
KFbxGeometryElementNormal* lGeometryElementNormal= lMesh->CreateElementNormal()

// Set the normal values for every control point.
lGeometryElementNormal->SetReferenceMode(KFbxGeometryElement::eDIRECT)

lGeometryElementNormal->GetDirectArray().Add(lNormalZPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalZPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalZPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalZPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalXPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalXPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalXPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalXPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalZNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalZNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalZNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalZNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalXNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalXNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalXNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalXNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalYPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalYPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalYPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalYPos)
lGeometryElementNormal->GetDirectArray().Add(lNormalYNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalYNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalYNeg)
lGeometryElementNormal->GetDirectArray().Add(lNormalYNeg)

// Array of polygon vertices.
int lPolygonVertices[] = < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,12, 13,
14, 15, 16, 17, 18, 19, 20, 21, 22, 23 >

// Create UV for Diffuse channel.
KFbxGeometryElementUV* lUVDiffuseElement = lMesh->CreateElementUV( "DiffuseUV")
K_ASSERT( lUVDiffuseElement != NULL)
lUVDiffuseElement->SetMappingMode(KFbxGeometryElement::eBY_POLYGON_VERTEX)
lUVDiffuseElement->SetReferenceMode(KFbxGeometryElement::eINDEX_TO_DIRECT)

KFbxVector2 lVectors0(0, 0)
KFbxVector2 lVectors1(1, 0)
KFbxVector2 lVectors2(1, 1)
KFbxVector2 lVectors3(0, 1)

lUVDiffuseElement->GetDirectArray().Add(lVectors0)
lUVDiffuseElement->GetDirectArray().Add(lVectors1)
lUVDiffuseElement->GetDirectArray().Add(lVectors2)
lUVDiffuseElement->GetDirectArray().Add(lVectors3)

//Now we have set the UVs as eINDEX_TO_DIRECT reference and in eBY_POLYGON_VERTEX mapping mode
//we must update the size of the index array.
lUVDiffuseElement->GetIndexArray().SetCount(24)

// Create polygons. Assign texture and texture UV indices.
for(int i = 0 i < 6 i++)
<
// all faces of the cube have the same texture
lMesh->BeginPolygon(-1, -1, -1, false)

for(int j = 0 j < 4 j++)
<
// Control point index
lMesh->AddPolygon(lPolygonVertices[i*4 + j])

// update the index array of the UVs that map the texture to the face
lUVDiffuseElement->GetIndexArray().SetAt(i*4+j, j)
>

So, we have to define the vertices (control points in the language of the SDK), normals and UV coordinates for the mesh to show in the Quicktime viewer. It’s also worth mentioning that I’ve had to force the output FBX file from the exporter to be in binary format as the viewer refuses to load the ASCII format FBX. In addition to this, I’m still getting application crashes when I close the Quicktime viewer.

Now I have the ability to create custom geometry, the next step is to write an interface to allow me to pass geographic data to the exporter via C#. After giving this some thought, the obvious solution is to pass well-known binary (WKB) from the C# program to the C++ library as a block of bytes. This is a relatively easy format to produce and decode into geometry, so shouldn’t take long to write.

Part three will deal with the mechanics of getting actual geometry to the exporter and generating an FBX file from real geographic data.

Exporting Geographic Data in FBX Files

I’ve been looking at how to export the geographic information contained in a MapTube map into an art tool like 3DS Max or Maya. The reason for this is firstly to make it easier to produce high quality geographic presentations, but also, by employing a recognised art tool chain, we can also get the data into 3D visualisation systems built around XNA (XBox) or Unity.

Originally, I was going to implement a 3DS exporter as this is a well-used format that would allow geometry to be imported by Google Sketchup, Blender, or a long list of professional art tools. After coming across Autodesk’s FBX SDK, I decided to create an FBX exporter instead. Although this is a format that can’t be loaded by either Sketchup or Blender, the SDK is quite flexible and can also export Collada (DAE) and Wavefront OBJ files which the free tools can import. In addition to this, it can be imported by both Unity and XNA.

Autodesk supply a viewer plugin for Quicktime, but I had some problems getting this to work with my first export attempts. The example below shows a simple screenshot:

Although a flat black plane on a grey background isn’t fantastic for a first attempt, it took a while to get this far as the examples don’t tell you that the Quicktime viewer doesn’t like ASCII format FBX files and you have to change the example format to BINARY.

[c language=”++”]
//altered export from ASCII to Binary
int lFormatIndex, lFormatCount = pSdkManager->GetIOPluginRegistry()->GetWriterFormatCount()

for (lFormatIndex=0 lFormatIndex<lFormatCount lFormatIndex++)
<
if (pSdkManager->GetIOPluginRegistry()->WriterIsFBX(lFormatIndex))
<
KString lDesc =pSdkManager->GetIOPluginRegistry()->GetWriterFormatDescription(lFormatIndex)
printf("%s ",lDesc.Buffer()) //print out format strings
//char *lASCII = "ascii"
char *lBinary = "binary"
if (lDesc.Find(/*lASCII*/lBinary)>=0)
<
pFileFormat = lFormatIndex
break
>
>
>
[/c]

This is a copy of the “ExportDocument” example that comes with the SDK, but with the type changed to binary to allow it to load.

The next problem is learning how to create my own geometry and figuring out a way of connecting the native C++ library to the managed C# code used by MapTube. My initial thought was to create a managed wrapper for the FBX SDK and use marshalling, but, on further examination of the SDK, it’s much too complicated to do in any reasonable amount of time. So, plan B is to write the code to do the export as a native C++ process, expose enough methods to allow this to be controlled through marshalling and interop via the C# code and do the FBX export through that route. This only depends on being able to marshall the large amount of geometry data, but this should be possible to work out.

After these first experiments, it’s looking like the pattern will be something like a reader/writer object with a choice of export formats as FBX, Collada or OBJ to allow the assets to be loaded into as many art packages as possible.

The next post will cover the generation of the geometry and its export to FBX.

Trackernet: The Victoria Line

I’ve been meaning to look at TfL’s Trackernet API for a while now. It works through a REST based web service which gives access to all the London Underground running boards on a line by line basis. You issue an http request of the form:

and the result is an XML file containing train information for every station on the Victoria Line. Substitute “B” instead of “V” and you get the Bakerloo line instead. I had managed to figure out a way to get approximate train locations when the Victoria Line got suspended one morning, so I couldn’t resist looking to see where all the trains had ended up:

According to my data, there are 25 trains on the line. The way the positions are calculated is quite complicated as the original information comes from the running boards for every station and the time to platform estimates. Trains are uniquely identified through a train number and a set number as a composite key. I simply iterate through all the data for every station and take the lowest time to station for every train, which gives me the train’s next station. Then I use the location code provided by the API and the time to station estimate to interpolate between the last station and the next station.

One feature worth noting is that because the time to station is given for every station along the train’s whole route, you can use the data to build up a dataset of the time required to travel between any pair of stations. Also, because the information is processed from the running boards, the program should be able to process National Rail train locations from the information on their website.

By using only the information provided in the XML response from the API means that I am able to construct a web service that doesn’t require any state information to be retained between calls. In addition to this, it doesn’t require any knowledge of the tube network and how the stations are connected together.

This is still very much a prototype, but once it’s working for all the lines, it will be released as a real-time feed on MapTube.

Twitter Maps and #ukriots

With all the media hype surrounding the use of social networking and the London riots, it left me wondering what was actually being said on Twitter in the UK. It was also a good opportunity to test out the new MapTube map creation software which can handle 35,000 clickable points on a map with ease (we tested with 500,000). So, the aim was to create a map of UK tweets which I could explore around the areas where the riots were happening to see what people were saying about them on Twitter.

In order to do this, I used the Twitter client that Steven Gray wrote to collect geocoded tweets from Twitter. This has been used for things like the real-time heatmap of London 2012 #1yeartogo tweets: http://bigdatatoolkit.org/

The resulting map can be seen below:

Tweets captured from Twitter between 15:00 and 22:00 on Tuesday 9th August 2011. See text for further details.

Once the data had been collected as a CSV file containing “UserId”, “Time”, “Tweet”, “lat” and “lon”, the processing was done using Excel. This will feature as a separate blog post in more detail, but I created columns of riot related hashtags and cleanup related hashtags. Then these were combined into a colour code based on whether the tweet is a general tweet (Blue), contained a riot tag (red), contained a cleanup tag (green) or both riot and cleanup tags (yellow).

There are full details in the “more information” link on the live map, but I collected 34,314 geocoded tweets in the period, of which 1,330 contained riot hashtags and 87 contained cleanup hashtags.

What’s interesting about this map is that I was expecting more tweeting about the riots. 13,330 is less than 4% of all geocoded tweets.

Where this map really comes into its own is the ability to click on messages around the riot areas and see what people are saying. I think what this highlights is that you need some sort of natural language processing as there is obviously a lot of discussion about the riots not using hash tags. People are tweeting that they or their children are scared as it sounds really close, or tweeting to people to tell them they have arrived home safely.

The other interesting thing for natural language processing researchers is that Twitter has a language all of its own. When you start reading some of the tweets it’s obvious that the contractions and slang that is being used will be a challenge to understand.

One thing I need to fix in MapTube is that it returns too much information on the popup when you click on a location. The point and click functionality returns all points covering the area of your click. If you are zoomed out a long way, then this can be hundreds of points on the speech bubble popup which causes the client browser a number of problems. I think limiting to around 20 returned points would be a safer option.

Making Maps From Wikipedia

I’ve been looking at web-based sources of geographic data and Wikipedia links are something I’ve wanted to try out for a while. I found the following page containing Worldwide fossil sites:

This gives a list of sites, but with no locations:

The “Site” column contains href links which can be followed to pages like the following:

The coordinates can just be made out in the top right hand corner of the page.

As all Wikipedia pages follow a common theme, the coodinates are embedded in a <span> tag with I already had a Java program for loading a web page and converting it into xhtml, so I used this to turn the original list page into a csv file by extracting the data out of the html tables. One of the columns in this file contained the links to the site-specific pages, so another program was written to follow all these links and extract the location from the site page.

While the general technique works, only about 25% of the data had links to pages with lat/lon coordinates, so the final map is somewhat incomplete, but this can be edited manually. The map itself was built using MapTube’s new map creation system which works using the CSV file of data. The final map can be viewed at the following link:

New MapTube Map Creation Feature

We released a new feature on the MapTube website today which will make it easier to create new maps from data in CSV files. The underlying technology is used on the SurveyMapper site and for other real-time visualisations like http://bigdatatoolkit.org/2011/07/26/1yeartogo/ which shows tweets using the #1yeartogo hashtag for the London 2012 Olympics.

Creating a map of abandoned vehicles from the London Datastore using MapTube

The new update to MapTube adds a graphical user interface which allows the user to upload a data file, choose a colour scale and publish the map on MapTube directly. One of the driving forces behind this was the idea that creating a map should be simple enough that you could do it using an iPad. Data on the London Datastore is in the correct format, so you can copy the CSV link directly from the site, which is exactly what has been done in the above image. I’ve created a YouTube clip showing the whole process, which can be viewed at the following link:

This feature is still experimental, but at the m0ment it handles point data in lat/lon coordinates (WGS84) or OS coordinates for the UK (OSGB36). Point data can be drawn using markers, or as a heatmap showing point density. For area data, one column in the data is selected as a key field and this is joined with the geographic data stored in MapTube’s database to draw the map. For example, using the following data:

We have four columns: Constituency, Party, PartyCode and Change. In the CSV file the first line must be the column headings, then every subsequent line contains data. The CSV file would contain the following:

The “Constituency” column is the area key in this case, but MapTube determines this automatically when the CSV file is loaded, along with the type of geography, which is Parliamentary Constituencies. In order to colour the map, numeric data is required, so in this example, a column labelled “PartyCode” has been added where “LAB”=1, “”CON”=2, LD=𔄥” etc.

The colour scale is then chosen and the finished map submitted to MapTube where it can be viewed along with any of the other maps. There are help pages accessible through the ‘i’ icon on each section which contain further information.

As mentioned before, this feature is still experimental and we will be gradually adding more geographic data to the MapTube database to allow maps to be built from additional geographies. The aim is for MapTube to be able to automatically detect the geography just by analysing the data and, at the moment, the following geographies can be used:

US States and Zip code areas will be added shortly, along with adminsitrative and Census boundaries for other parts of the World.


Browse Books

In the 1990s, a new type of learning algorithm was developed, based on results from statistical learning theory: the Support Vector Machine (SVM). This gave rise to a new class of theoretically elegant learning machines that use a central concept of SVMs -kernels--for a number of learning tasks. Kernel machines provide a modular framework that can be adapted to different tasks and domains by the choice of the kernel function and the base algorithm. They are replacing neural networks in a variety of fields, including engineering, information retrieval, and bioinformatics.

Learning with Kernels provides an introduction to SVMs and related kernel methods. Although the book begins with the basics, it also includes the latest research. It provides all of the concepts necessary to enable a reader equipped with some basic mathematical knowledge to enter the world of machine learning using theoretically well-founded yet easy-to-use kernel algorithms and to understand and apply the powerful algorithms that have been developed over the last few years.


Author Profile Pages

  1. Description: The Author Profile Page initially collects all the professional information known about authors from the publications record as known by the ACM bibliographic database, the Guide. Coverage of ACM publications is comprehensive from the 1950's. Coverage of other publishers generally starts in the mid 1980's. The Author Profile Page supplies a quick snapshot of an author's contribution to the field and some rudimentary measures of influence upon it. Over time, the contents of the Author Profile page may expand at the direction of the community.
    Please see the following 2007 Turing Award winners' profiles as examples:
  2. History: Disambiguation of author names is of course required for precise identification of all the works, and only those works, by a unique individual. Of equal importance to ACM, author name normalization is also one critical prerequisite to building accurate citation and download statistics. For the past several years, ACM has worked to normalize author names, expand reference capture, and gather detailed usage statistics, all intended to provide the community with a robust set of publication metrics. The Author Profile Pages reveal the first result of these efforts.
  3. Normalization: ACM uses normalization algorithms to weigh several types of evidence for merging and splitting names.
    These include:
    • co-authors: if we have two names and cannot disambiguate them based on name alone, then we see if they have a co-author in common. If so, this weighs towards the two names being the same person.
    • affiliations: names in common with same affiliation weighs toward the two names being the same person.
    • publication title: names in common whose works are published in same journal weighs toward the two names being the same person.
    • keywords: names in common whose works address the same subject matter as determined from title and keywords, weigh toward being the same person.

The more conservative the merging algorithms, the more bits of evidence are required before a merge is made, resulting in greater precision but lower recall of works for a given Author Profile. Many bibliographic records have only author initials. Many names lack affiliations. With very common family names, typical in Asia, more liberal algorithms result in mistaken merges.

Automatic normalization of author names is not exact. Hence it is clear that manual intervention based on human knowledge is required to perfect algorithmic results. ACM is meeting this challenge, continuing to work to improve the automated merges by tweaking the weighting of the evidence in light of experience.

ACM will expand this edit facility to accommodate more types of data and facilitate ease of community participation with appropriate safeguards. In particular, authors or members of the community will be able to indicate works in their profile that do not belong there and merge others that do belong but are currently missing.

A direct search interface for Author Profiles will be built.

An institutional view of works emerging from their faculty and researchers will be provided along with a relevant set of metrics.

It is possible, too, that the Author Profile page may evolve to allow interested authors to upload unpublished professional materials to an area available for search and free educational use, but distinct from the ACM Digital Library proper. It is hard to predict what shape such an area for user-generated content may take, but it carries interesting potential for input from the community.


Buildings missing texture in 3d web scene exported from ArcScene - Geographic Information Systems

Behind the Scenes: Floating Cottage

New Edge Scrolling for Node Editor

Behind the Scenes: The Gate

The Best Blender Art on Sketchfab: 2021, week 26

New Chapter of Scripting for Artists Released

Community News


Assista o vídeo: Showing DEM in 3D View in ArcGIS. DEM in 3D View in ArcMap. DEM in Arcsene