Personalizando Paisagens do Stellarium

O planetário virtual Stellarium é um software gratuito e de código aberto, disponível para Linux, Mac OS e Windows, capaz de gerar visualizações realistas do céu em posições e instantes definidos pelo usuário. Essas visualizações criam uma experiência imersiva que pode ficar ainda mais interessante quando criamos uma cenário personalizado retratando uma paisagem conhecida ou seu local de observação preferido.

Paisagem personalizada do Museu Interativo de Ciências de São José dos Campos (SP) [Wandeclayt M./Céu Profundo].

Essa personalização é simples e pode ser gerada em poucos passos. É preciso ter alguma familiaridade com edição de imagens e com as funções do Stellarium, mas nenhuma ferramenta complexa é necessária.

  1. Crie uma imagem panorâmica de 360º. Não é preciso incluir todo o céu. É possível criar a imagem fundindo duas imagens panorâmicas de 180º (ou conjuntos de imagens menores, desde que cubram os 360º de horizonte) num programa de edição de imagens (Photoshop, Gimp). Uma opção gratuita é a ferramenta de montagem de panoramas Hugin.
  2. Remova o céu (a área do céu deve ficar transparente em um arquivo png).
  3. A relação de aspecto da imagem deve ser 2:1. 2048×1024 funciona bem.
  4. Crie um arquivo “landscape.ini” com os dados de sua paisagem. Este é um exemplo de arquivo:
Exemplo de arquivo landscape.ini
[landscape]
name = MIC
author = Wandeclayt M/@ceuprofundo
description = Museu Interativo de Ciências de São José dos Campos - SP - Brasil.
type = spherical
maptex = mic_sjc2k.png
angle_rotatez = 150

[location]
planet = Earth
country = Brazil
timezone = America/Sao_Paulo
latitude = -23d10'59"
longitude = -45d51'31"
altitude = 650

Você pode precisar ajustar o azimute de sua imagem para que os pontos cardeais coincidam com a paisagem. Esse ajuste pode ser feito pelo parâmetro “angle_rotatez” no arquivo landscape.ini.
Depois destes passos, compacte seu arquivo de imagem png e seu arquivo landscape.ini em um único arquivo zipado. A instalação será feita a partir do arquivo zip.

Para instalar, acesse o menu de paisagens na barra esquerda da interface do Stellarium, ou use a tecla de função F4. Na aba paisagem você encontrará a opção de adicionar/remover paisagens. Selecione seu arquivo Zip e a nova paisagem será incorporada ao aplicativo.

Instalação de um novo pacote de paisagem.
Stellarium com a nova paisagem instalada e selecionada.

Para Saber Mais.

O blog Astrocamera de Dave Kodama também descreve o procedimento de criação/instalação de paisagens. E documentação do Stellarium voltada a desenvolvedores pode ser encontrada em http://stellarium.org/doc/head/index.html

Stellarium: Viajando pelo Sistema Solar

Se você já usou a versão desktop do planetário virtual Stellarium, ou se já assistiu alguma sessão de planetário digital que utilizou o aplicativo, sabe que suas simulações além de envolventes possuem um imenso potencial como recurso visual para aulas e apresentações.

Mas essa experiência pode ficar ainda mais envolvente e fluida com o uso de scripts, automatizando funções e mudanças de parâmetros do aplicativo. É possível criar apresentações que são verdadeiros filmes, com transições suaves e com uma dinâmica quase vertiginosa que prende a atenção da audiência.

Para exemplificar o poder dos scripts do Stellarium, vamos juntos criar um tour pelos planetas do Sistema Solar, demonstrando algumas das principais classes de objetos acessíveis através de scripts. Vamos colocar a mão na massa?

Com a Mão na Massa!

Antes de tudo, você vai precisar ter o Stellarium instalado em sua máquina. Ele é gratuito e está disponível para os principais sistemas operacionais de desktops e laptops atuais (Linux, MacOS e Windows). Para baixar os arquivos de instalação, acesse: http://stellarium.org

Assumindo que você tenha o aplicativo instalado e tenha se familiarizado com sua interface gráfica, é hora de acessar o console para escrevermos os scripts. Use a tecla de função F12 para acessar diretamente o Script Console.

Script Console do Stellarium. Acessível pela tecla de função F12.

A partir de agora escreveremos um roteiro para nossa sessão cinema interplanetário. Precisaremos acessar funções que estão agrupadas em diferentes classes. Algumas comandam a exibição de símbolos e linhas na tela. Outras comandam os movimentos do telescópio. Outros são funções básicas do aplicativo, comandando, por exemplo, a passagem do tempo, os modos de visualização ou a seleção de objetos.

Conhecendo algumas Classes

  • core – Funções básicas.
  • LandscapeMgr – Gerenciamento de visualização da paisagem.
  • StelMovementMgr – Gerenciamento de movimento.
  • GridLinesMgr – Gerenciamento de linhas de grade.

É possível consultar a documentação detalhada dessas e de outras classes acessando: http://stellarium.org/doc/head/scripting.html

Loops

É possível criar iterações dentro dos scripts. A sintaxe de um loop for é:

for (i=valor inicial; i<valor final; i++)
{
    comandos
}

Inicializando a apresentação

Queremos inicialmente configurar o Stellarium para a data atual e para a localização do observador, além de habilitar uma visualização em disco e sem a atmosfera. Esses parâmetros são ajustáveis atrav´s de funções das classes core e LandscapeMgr.

  1. Ajustar data inicial.
  2. Ajustar localização do observador.
  3. Habilitar visualização em disco.
  4. Desabilitar a atmosfera.
  5. Desabilitar o cenário (landscape).

Adicionaremos antes duas variáveis para controlar a duração (em segundos) das pausas estabelecidas nas funções core.wait().

// Stellarium - Tour pelo Sistema Solar

var pausa = 3; // variavel criada para a funcao core.wait()
var pausaLonga = 6;
 
//ajuste de data e localizacao
core.setDate("now");
core.setObserverLocation(-45.9, -23.2, 650, 3, "São José dos Campos", "Terra");
core.setDiskViewport(true);

//ajuste da paisagem
LandscapeMgr.setFlagAtmosphere(false);
core.wait(pausa);

LandscapeMgr.setFlagLandscape(false);

Primeiro Movimentos

Agora comandaremos os primeiros movimentos de nossa apresentação. Queremos que a visualização corresponda a de um telescópio em montagem equatorial, evitando que o campo gire sempre que o objeto cruzar o meridiano local, como ocorre em telescópios em montagem altazimutal. Isso, felizmente, também pode ser configurado.

Queremos inicialmente um campo amplo, olhando para o zênite e cobrindo 180º do céu.

  1. Configurar montagem equatorial.
  2. Desfazer qualquer seleção de objeto pré-existente.
  3. Olhar para o zênite.
  4. Ajustar o zoom para 180º.
StelMovementMgr.setEquatorialMount(true);
StelMovementMgr.deselection();
StelMovementMgr.lookZenith(pausa);
core.wait(pausa);
StelMovementMgr.zoomTo(180, pausa);
core.wait(pausa);

Criando o Roteiro da Viagem.

Nossos destinos serão incluídos em uma lista que será acessada dentro de nosso script.

var planets = ["Sun", "Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]

Em seguida vamos apontar para o primeiro objeto, inciando um loop for para varrer toda a lista, aproximando a visualização, aguardando por um tempo e em seguida afastando a visualização e passando ao próximo objeto.

for (i=0; i<planets.length; i++)
{
	objName = planets[i];
	core.selectObjectByName(objName);
        core.output(objName); //exibe o nome do objeto no console
	StelMovementMgr.autoZoomIn(pausa);
	core.wait(pausaLonga);
	StelMovementMgr.zoomTo(40,8); // zoom out
	core.wait(pausaLonga);
}

Já temos até aqui, um tour completo pelos maiores corpos do Sistema Solar. Você pode digitar ou colar cada um desses blocos no Script Console do seu Stellarium e executar o script para ver a magia acontecer.

É um script curto e fácil de compreender, que pode servir de ponto de partida para suas ideias mais complexas. Por sinal, talvez você tenha sentido falta de um planeta, não? Que tal criar um passo final no seu script para levar o observador até a Lua e exibir a Terra?

Hora do desafio: que tal irmos até a Lua pra dar uma olhadinha em nossa Terra?

Faixa Bônus

O próximo bloco de código é um bônus em nosso passeio. Você consegue identificar o que ele faz e integrá-lo ao seu script?

//Jupiter
var planet = "Jupiter"
core.setDate("now")
LandscapeMgr.setFlagLandscape(false);
LandscapeMgr.setFlagAtmosphere(false);
core.output(planet);
core.moveToObject(planet , 3);
core.selectObjectByName(planet)
StelMovementMgr.autoZoomIn(3);
core.output(planet);
core.wait(3);
StelMovementMgr.zoomTo(0.05, 3);
//core.wait(pausaLonga);
for (i=0; i<360; i++)
{
    var data = core.getDate()
    core.output(data)
    core.setDate("data +0.2hours");
    core.wait(0.02);
}

Dominando o Stellarium: o poder oculto dos scripts.

O planetário virtual Stellarium é uma poderosa e divertida ferramenta para a simulação do céu. E é possível torná-lo ainda mais poderoso e divertido através de scripts que automatizam sua execução.

Os scripts são arquivos de texto com roteiros que comandam a execução automática de funções e a alteração de configurações no Stellarium. São especialmente úteis em exibições públicas, palestras e sessões de planetário, dispensando a necessidade da interação com o operador durante a sessão e tornando muito mais suaves as transições e animações.

Quer conhecer mais esse recurso do Stellarium e criar apresentações para impressionar seu público? Então esse post é pra você.

“Hello World”

Nosso primeiro script é o clássico “Hello World”, escrevendo uma saudação na tela do aplicativo.

Usaremos o console acessível através da tecla de função F12 de seu teclado.

Console de execução de Scripts no Stellarium 0.22.2 [Wandeclayt M./@ceuprofundo]

Dentro da aba “Script” no console, vamos digitar o nosso código. O código é razoavelmente simples e você certamente vai entender os parâmetros envolvidos, mas se quiser conhecer com mais detalhes a classe LabelMgr, utilizada para escrever a mensagem na tela, consulte a documentação do Stellarium aqui.

As linhas iniciadas com “//” são comentários, e não são interpretadas como comandos.

// primeiro vamos limpar a tela, apagando rotulos que possam estar exibidos
LabelMgr.deleteAllLabels();

// criamos variaveis para cada parametro
var mensagem = "Hello World!";
var posicaoX = 200;
var posicaoY = 400;
var tamanhoFonte = 36;
var corFonte = "#FFFF00" //amarelo

// exibicao da mensagem
LabelMgr.labelScreen(mensagem, posicaoX, posicaoY, true, tamanhoFonte, corFonte);

O resultado desse script é a exibição da mensagem “Hello World” em caracteres amarelos, com tamanho 36, na posição (x=200, y=400) da tela.

Um jeito mais curto de escrever isso seria inserir os valores diretamente na função, sem o uso de variáveis. :

LabelMgr.deleteAllLabels();
LabelMgr.labelScreen("Hello World", 200, 400, true, 36, "#FFFF00");

Segundos Passos

Você agora já deu seus primeiros passos no maravilhoso mundo dos scripts do Stellarium e é hora de descobrir um pouco mais do que esse mundo pode oferecer.

No próximo exemplo vamos automatizar algumas funções básicas, alterando seus parâmetros para visualizar a passagem meridiana do Sol em diversas latitudes no dia do equinócio de setembro de 2024.

Queremos que as funções sejam executadas em sequência e que haja um intervalo entre a execução de algumas delas.

A sequência de comandos desejada é:

  1. Ajustar a data e hora para (“2024:09:22T12:00:00”, “local”)
  2. Interromper passagem do tempo;
  3. Habilitar visualização realista;
  4. Ajustar posição para São José dos Campos (-23.22, -45.90, 650m)
  5. Ajustar campo para 180º;
  6. Olhar para o zênite, de frente para o sul.;
  7. Exibir linha da eclíptica;
  8. Exibir equador celeste;
  9. Deslocar para a latitude de alcântara, mantendo a longitude;
  10. Deslocar para o trópico de câncer, mantendo a longitude;
// Author: Projeto Ceu Profundo
// Version: 0.0.1
// License: Public Domain
// Name: Primeira Luz - Tarefa 1 (Equinócio de Setembro)
// Description: Exibe o Sol ao meio dia local em três latitudes diferentes.

// Made on Stellarium 0.22.2

//1. Ajustar a data e hora para ("2024:09:22T12:00:00", "local")
core.setDate("2024:09:22T12:00:00", "local");
//2. Interromper passagem do tempo;
core.setTimeRate(0);
//3. Habilitar visualização realista;
core.clear("natural");
core.wait(5) // introduz um atraso de 5 segundos até a próxima função
//4. Ajustar posição para São José dos Campos (-23.22, -45.90, 650m)
core.setObserverLocation(-45.9, -23.22, 650., 3., "São José dos Campos", "Terra");
//5. Ajustar campo para 180º;
StelMovementMgr.zoomTo(180, 2);
//6. Olhar para o zênite, de frente para o sul.;
StelMovementMgr.lookZenith();
core.wait(2) // introduz um atraso de 2 segundos até a próxima função
//7. Exibir linha da eclíptica;
GridLinesMgr.setFlagEclipticLine(true);
core.wait(2) // introduz um atraso de 2 segundos até a próxima função
//8. Exibir equador celeste;
GridLinesMgr.setFlagEquatorLine(true);
core.wait(2) // introduz um atraso de 2 segundos até a próxima função
//9. Deslocar para a latitude de alcântara, mantendo a longitude;
core.setObserverLocation(-45.9, -2.5, 10., 3., "Alcântara", "Terra");
core.wait(5) // introduz um atraso de 5 segundos até a próxima função
//10. Deslocar para o trópico de câncer, mantendo a longitude;
core.setObserverLocation(-45.9, 23.22, 10., 3., "Trópico de Câncer", "Terra");

Próximos Passos

Agora você já deve ter percebido que o céu não é o limite (#BaDumTss) para a sua criatividade na hora de escrever scripts para o Stellarium.

Os seus scripts serão tão complexos e atraentes quanto o seu repertório permitir. Familiarização com as funções e capacidades do Stellarium é a condição fundamental para automatizar essas funções e capacidades através de scripts. A documentação em http://stellarium.org/doc/head/ é bem completa e é uma grande aliada para usuários mais avançados. Mas se você quer seguir adiante sem mergulhar no manual, listamos a seguir alguns comandos úteis em um guia de referência para seus primeiros scripts.


GUIA DE REFERÊNCIA

Core (Funções Básicas)

core.clear(“natural“) – Limpa as opções de exibição. Apaga linhas, marcadores e rótulos. Exibe atmosfera e paisagem.

core.setDate(“aaaa-mm-ddThh:mm:ss”, “local/utc”) – Ajusta a data/hora.
core.setDate(“now”) – Ajusta a data/hora para a data/hora atual do sistema.

core.wait(i) – Introduz uma pausa de i segundos.
core.setTimeRate(i) – Ajusta a velocidade da simulação (0=tempo interrompido, 1=velocidade natural, n = tempo acelerado n vezes.)
core.waitFor(“aaaa-mm-ddThh:mm:ss”, “local/utc”) – Espera até a data/hora indicada.

core.setObserverLocation(longitude, latitude, altitude, duração, nome, planeta)
core.setGuiVisible(true/false) – exibe(true)/oculta(false) a interface gráfica.
core.setFlagGravityLabels(true/false) – habilita/desabilita rótulos orientados com o horizonte.

core.selectConstellationByName(“constelação”) – Seleciona a constelação indicada. Use o nome da constelação em latim ou o código de três letras (ex: “Virgo” ou “Vir”).
core.selectObjectByName(“nome do objeto”) – Seleciona um objeto celeste. Use a designação do objeto em um catálogo de céu profundo (NGC, Messier…), uma designação estelar (Bayer, Flamsteed, HD… ), o nome de uma constelação – em latim ou usando a designação de 3 letras da IAU – ou o nome de um planeta (em inglês).

core.moveToAltAzi(atura, azimute, duração) – aponta para a atura e azimute indicados.
core.moveToObject(“nome do objeto”, duração) – aponta para um objeto celeste indicado. Use a designação do objeto em um catálogo de céu profundo (NGC, Messier…), uma designação estelar (Bayer, Flamsteed, HD… ), o nome de uma constelação – em latim ou usando a designação de 3 letras da IAU – ou o nome de um planeta (em inglês).
core.moveToSelectedObject(duração) – Aponta para um objeto selecionado.

http://stellarium.org/doc/head/classStelMainScriptAPI.html

LandscapeMgr (Atributos de Cenário)

LandscapeMgr.setFlagCardinalPoints(false) – exibe(true)/oculta(false) os pontos cardais.
LandscapeMgr.setFlagAtmosphere(true/false) – exibe(true)/oculta(false) atmosfera.

GridLinesMgr (Atributos de Linhas)

GridLinesMgr.setFlagEquatorGrid(true/false) – exibe(true)/oculta(false) a grade equatorial.
GridLinesMgr.setFlagEquatorLine(
true/false) – exibe(true)/oculta(false) o equador celeste.
GridLinesMgr.setFlagAzimuthalGrid(
true/false) – exibe(true)/oculta(false) a grade azimutal.
GridLinesMgr.setFlagEclipticLine(true/false) – exibe(true)/oculta(false) a linha da eclíptica.
GridLinesMgr.setFlagMeridianLine(true/false) – exibe(true)/oculta(false) a linha do meridiano local.
GridLinesMgr.setFlagCircumpolarCircles(
true/false) – exibe(true)/oculta(false) círculos circumpolares.
GridLinesMgr.setFlagCelestialPoles(true/false) – exibe(true)/oculta(false) os polos celestes.

http://stellarium.org/doc/head/classGridLinesMgr.html

ConstellationMgr (Atributos de constelações)

ConstellationMgr.setFlagArt(true/false) – exibe(true)/oculta(false) arte das constelações.
ConstellationMgr.setFlagBoundaries(true/false) – exibe(true)/oculta(false) bordas das constelações.
ConstellationMgr.setFlagLines(true/false) – exibe(true)/oculta(false) linhas das constelações.
ConstellationMgr.setFlagLabels(true/false) – exibe(true)/oculta(false) rótulos das onstelações.

StelMovementMgr ()

StelMovementMgr.lookZenith() – aponta para o zênite, com o Sul na parte de baixo da tela.
StelMovementMgr.deselection() – desfaz a seleção de objeto.
StelMovementMgr.zoomTo(campo em graus, duração) – ajusta o zoom para o campo indicado.

http://stellarium.org/doc/head/classStelMovementMgr.html