Starplot: como fazer um planisfério celeste usando Python

Figura 1 Planisfério celeste customizado para a localização geográfica do Astronomiapratica, para o dia 15 de fevereiro de 2026, às 22:00 (Tempo local). Clique na imagem para ampliá-la.

O Python é muito mais que uma simples linguagem de programação. Ela pode dar acesso a bibliotecas de software que fornecem módulos estruturados para uma grande quantidade de aplicações em astronomia.

Neste post, mostro como plotar um planisfério celeste customizado (como o da Fig. 1) para a sua localização e para qualquer data utilizando a biblioteca Starplot. Nesse planisfério, são grafados os nomes e traçados das constelações e principais estrelas. Por enquanto, a posição dos planetas e da Lua não é mostrada nele, o que poderá ser feito em um próximo post.

A biblioteca starplot pode ser baixada no link:

https://pypi.org/project/starplot/

que, em fevereiro de 2026, se apresenta na versão 0.19.6. 

Você também precisará das bibliotecas datetime e zoneinfo. A datetime cria uma estrutura de dados de entrada para a data (e hora), enquanto que zoneinfo permite determinar o fuso horário, que também é usado pelo Starplot.

Configurações iniciais

Esses recursos precisam ser instalados no terminal de sua IDE preferida (ou no ambiente de programação Jupyter) de Python usando os comandos:

pip install starplot

pip install DateTime

pip install backports.zoneinfo

Uma vez baixado o módulo do Starplot, é necessário inicializá-lo, o que é feito pelo comando:

starplot setup

Isso instalará diversos catálogos de estrelas default da versão baixada do Starplot.

Comandos para invocar as bibliotecas

No início do arquivo que conterá o script para gerar o planisfério, as bibliotecas são invocadas pelos comandos:

from datetime import datetime                        
from zoneinfo import ZoneInfo                       
from starplot import ZenithPlot, Observer         
from starplot import _ as sp

Ao invés de se usar o método do starplot _, preferiu-se acima chamá-lo "sp" para evitar conflito com eventuais reservas internas desse símbolo. De fato, houve um problema na compilação do código, que indicava "_" como um nome inexistente. O ambiente do PyCharm 24.1 (Community Edition) foi usado para se criar a aplicação e o Python 3.12 foi utilizado como interpretador.

Fuso horário e data 

Para se gerar o planisfério, é necessário prover inicialmente uma data, que é composta de 5 números: dia, mês, ano, e hora e minuto. Isso se faz pelas funções ZoneInfo() que, para o fuso do "Brasil oriental" (correspondente ao horário de Brasília) é designado "Brazil/East" e  datetime(). As estruturas tz e dt são criadas desta forma:

tz = ZoneInfo("Brazil/East") #estabelece o fuso horário

#Inserção da data
dt = datetime(2026, 2, 15, 22, 0, tzinfo=tz)

A estrutura dt acima criada corresponde as 22:00 do dia 15/2/2026.

 Localização do observador.

O próximo passo é criar a estrutura que provê a informação sobre a posição geográfica do observador. Isso é feito pela instrução:

#Estrutura que armazena a latitude e longitude do observador
observador = Observer(
    dt=dt,
    lat=-23.208851340637068,
    lon=-45.86052842478029,
)

A latitude é armazenada em "lat" e a longitude em "lon". Note que, no código acima, adicionamos casas decimais suficientes para resolver a posição do observador até menos de 100 metros. Isso não é necessário, pois o planisfério celeste não tem resolução suficiente para tanto. 

Para encontrar os números equivalentes à posição de nossos leitores, basta abrir o "google maps", clicar na posição desejada sobre o mapa com o botão direito do mouse e copiar os números (lat, lon) para o clipboard. Daí, esses números são modificados no código acima.

Criando o planisfério

Uma instância de ZenitPlot é criada para dar início à estrutura do planisfério. 

#Cria uma instância que dá início à construção do planisfério
p = ZenithPlot(
    observer=observador,
    resolution=4000,
    scale=0.9,
)

Essa estrutura admite os seguintes parâmetros: observer (que foi criado anteriormente para a posição e data do observador), a resolution ou resolução (em pixels) para a mais larga dimensão do gráfico a ser plotado (quanto maior esse número, maior o gráfico e menor será o tamanho das estrelas) e scale  ou escala que controla o tamanho dos textos e rótulos adicionados às estrelas e objetos celestes. 

A partir disso, a criação do planisfério é feita internamente chamando-se um conjunto de funções na seguinte ordem:

p.constellations()  #Primeiro desenha as linhas das constelações

# Estabelece o limite de brilho e de rotulagem dos objetos
p.stars(where=[sp.magnitude < 4.5], where_labels=[sp.magnitude < 2])
#Indlui a Via-Láctea e a eclíptica
p.milky_way()
p.ecliptic()

p.horizon() #desenha o horizonte
# Desenha os rótulos das constelações por último
p.constellation_labels()

Inicialmente, p.constellations() irá plotar as linhas das constelações. Isso é necessário pois outros objetos serão plotados em cima (inclusive os rótulos). Inverter a posição dessa linha criará um gráfico com rótulos eventualmente apagados. Em seguida, são estabelecidos os limites para as magnitudes das estrelas: mag. abaixo de 4,5, ou seja, somente estrelas até a mag. 4.5, pois um planisfério não admite mesmo mais estrelas que isso. Como moramos em cidades, esse limite é bastante razoável. O parâmetro:

where_labels=[sp.magnitude<2]

faz com que apenas estrelas com mag. abaixo de 2 tenham seus nomes plotados. Alterar esse parâmetro (para um valor maior, p. ex., 4) não permitirá obter mais nomes, porque a biblioteca padrão de objetos do starplot é limitada. 

Em seguida, plota-se a Via Láctea e a linha da eclíptica. Depois, a linha do horizonte é criada e, finalmente, os rótulos das constelações são grafados.

# Exporta o resultado para um arquivo de imagem
p.export("planisferio_celeste.png", transparent=True)

Finalmente, o planisfério é armazenado no arquivo de imagem  planisferio_celeste.png. O parâmetro transparent apenas faz com que o fundo externo do planisfério seja transparente se verdadeiro.

O algoritmo completo está copiado abaixo na função SkyMap01(), lembrando que essa função pode ser invocada por uma main() em que as bibliotecas tenham sido preparadas antecipadamente conforme explicado acima.

Referências

• Starplot (2025) Creating a Basic Star Chart - https://starplot.dev/tutorial/02/

Script final para criação do planisfério

def SkyMap01():

    tz = ZoneInfo("Brazil/East") #estabelece o fuso horário

    #Inserção da data
    dt = datetime(2026, 2, 15, 22, 0, tzinfo=tz)

    # Estrutura que armazena a latitude e longitude do observador
    observador = Observer(
        dt=dt,
        lat=-23.208851340637068,
        lon=-45.86052842478029,
    )

    #Cria uma instância que dá início à construção do planisfério
    p = ZenithPlot(
        observer=observador,
        resolution=5000,
        scale=0.9,
    )

    p.constellations()  #Primeiro desenha as linhas das constelações

    # Estabelece o limite de brilho e de rotulagem dos objetos
    p.stars(where=[sp.magnitude < 4.5], where_labels=[sp.magnitude < 2])
    #Inclui a Via-Láctea e a eclíptica
    p.milky_way()
    p.ecliptic()

    p.horizon() #desenha o horizonte
    # Desenha os rótulos das constelações por último
    p.constellation_labels()

    #Exporta o resultado para um arquivo de imagem
    p.export("planisferio_celeste.png", transparent=True)