Página Inicial>Relacionado com a programação>Outro código-fonte
Baixar

Um planetário de desktop para KDE

KStars é um software de astronomia gratuito, de código aberto e multiplataforma.

Ele fornece uma simulação gráfica precisa do céu noturno, de qualquer local da Terra, em qualquer data e hora. A exibição inclui até 100 milhões de estrelas, 13.000 objetos do céu profundo, todos os 8 planetas, o Sol e a Lua, e milhares de cometas, asteróides, supernovas e satélites.

Para alunos e professores, ele suporta velocidades de simulação ajustáveis ​​para visualizar fenômenos que acontecem em longas escalas de tempo, a Astrocalculadora KStars para prever conjunções e muitos cálculos astronômicos comuns. Para o astrônomo amador, ele fornece um planejador de observação, uma ferramenta de calendário celeste e um editor FOV para calcular o campo de visão do equipamento e exibi-los. Descubra objetos interessantes na ferramenta "What's up Tonight", trace gráficos de altitude versus tempo para qualquer objeto, imprima mapas celestes de alta qualidade e tenha acesso a muitas informações e recursos para ajudá-lo a explorar o universo!

Incluído no KStars está o pacote de astrofotografia Ekos, uma solução completa de astrofotografia que pode controlar todos os dispositivos INDI, incluindo vários telescópios, CCDs, DSLRs, focalizadores, filtros e muito mais. O Ekos suporta rastreamento altamente preciso usando solucionador de astrometria on-line e off-line, recursos de foco automático e orientação automática e captura de imagens únicas ou múltiplas usando o poderoso gerenciador de sequência integrado.

Direitos autorais

Copyright (c) 2001 - 2024 da Equipe KStars:

KStars é Software Livre, lançado sob a Licença Pública GNU. Consulte COPIANDO para obter informações sobre licença GPL.

Transferências

KStars está disponível para Windows, MacOS e Linux. Você pode baixar a versão mais recente no site oficial do KStars.

No Linux, está disponível para a maioria das distribuições Linux.

A versão estável mais recente é v3.6.8

URLs e arquivos importantes.

  • A página inicial do KStars

  • Repositório Git do KStars

  • Bate-papo Web do KStars

  • Fórum onde o KStars é frequentemente discutido

Documentação do KStars

O manual do KStars pode ser encontrado no diretório $(KDEDIR)/share/doc/HTML//kstars/. Você também pode acessá-lo facilmente no menu Ajuda, pressionando a tecla [F1] ou visitando https://docs.kde.org/?application=kstars Infelizmente, está um pouco desatualizado. Congratulamo-nos com voluntários para ajudar a atualizá-lo.

Além disso, existem os seguintes arquivos README:

LEIA-ME: Este arquivo; informações gerais README.planetmath: Explicação dos algoritmos usados ​​para calcular as posições dos planetas README.customize: Opções avançadas de personalização README.images: Informações de direitos autorais para imagens usadas no KStars. README.i18n: Instruções para tradutores

Desenvolvimento

O código pode ser clonado, visualizado e solicitações de mesclagem podem ser feitas através do repositório KStars. Se você é novo em repositórios git remotos, consulte a seção Dicas do Git abaixo. Nota: Anteriormente o KStars usava o Phabricator para os seus pedidos de fusão. Esse sistema não está mais em uso.

IDE de ambiente de desenvolvimento integrado

Se você planeja desenvolver o KStars, é altamente recomendado utilizar um IDE. Você pode usar qualquer IDE de sua escolha, mas QtCreator(https://www.qt.io/product) ou KDevelop(https://www.kdevelop.org) são recomendados, pois são mais adequados para desenvolvimento em Qt/KDE.

Para abrir o KStars no QtCreator, selecione o arquivo CMakeLists.txt na pasta de origem do KStars e então configure o local e o tipo de compilação.

Prédio

  1. Pacotes de pré-requisitos

Para construir e desenvolver o KStars, poderão ser necessários vários pacotes da sua distribuição. Aqui está uma lista.

  • Dependências necessárias

    • GNU Make, GCC – Ferramentas essenciais para construção

    • cmake -- sistema de compilação usado pelo KDE

    • Biblioteca Qt> 5.12.0

    • Vários frameworks KDE: KConfig, KDocTools, KGuiAddons, KWidgetsAddons, KNewStuff, KI18n, KInit, KIO, KXmlGui, KPlotting, KIconThemes

    • eigen – biblioteca de álgebra linear

    • zlib – biblioteca de compactação

    • StellarSolver - consulte https://github.com/rlancaste/stellarsolver

  • Dependências opcionais

    • libcfitsio -- Biblioteca FITS

    • libindi -- Interface Distribuída Neutra de Instrumento, para controle de equipamentos.

    • planeta x

    • astrometria.net

    • biblioteca

    • wcslib

    • libgsl

    • qtkeychain

  1. Instalando pré-requisitos

Debian/Ubuntu

O comando apt-add-respository é necessário para o libstellarsolver-dev do apt-get. Alternativamente, você pode pular o apt-add-repository, remover o libstellarsolver-dev do apt-get e construir e instalar o stellarsolver em https://github.com/rlancaste/stellarsolver. 

sudo apt-add-repository ppa:mutlaqja/ppa
sudo apt-get -y install build-essential cmake git libstellarsolver-dev libxisf-dev libeigen3-dev libcfitsio-dev zlib1g-dev libindi-dev extra-cmake-modules libkf5plotting-dev libqt5svg5-dev libkf5xmlgui-dev libkf5kio-dev kinit-dev libkf5newstuff-dev libkf5doctools-dev libkf5notifications-dev qtdeclarative5-dev libkf5crash-dev gettext libnova-dev libgsl-dev libraw-dev libkf5notifyconfig-dev wcslib-dev libqt5websockets5-dev xplanet xplanet-images qt5keychain-dev libsecret-1-dev breeze-icon-theme libqt5datavisualization5-dev

Fedora 

yum install cfitsio-devel eigen3-devel stellarsolver-devel cmake extra-cmake-modules.noarch xisf-devel kf5-kconfig-devel kf5-kdbusaddons-devel kf5-kdoctools-devel kf5-kguiaddons-devel kf5-ki18n-devel kf5-kiconthemes-devel kf5-kinit-devel kf5-kio-devel kf5-kjobwidgets-devel kf5-knewstuff-devel kf5-kplotting-devel kf5-ktexteditor-devel kf5-kwidgetsaddons-devel kf5-kwindowsystem-devel kf5-kxmlgui-devel libindi-devel libindi-static qt5-qtdeclarative-devel qt5-qtmultimedia-devel qt5-qtdatavis3d-devel qt5-qtsvg-devel wcslib-devel xplanet zlib-devel

  1. Compilando

Abra um console e execute os seguintes comandos: 

mkdir -p ~/Projects/build/kstars
cd ~/Projects
git clone https://invent.kde.org/education/kstars.git
cd build/kstars
cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=RelWithDebInfo ~/Projects/kstars
make -j16
sudo make install

Para executar o KStars, basta digitar kstars no terminal.

Estilo de código

O KStars usa o Estilo Artístico para formatar todos os arquivos fonte C++. Certifique-se de aplicar as seguintes regras de estilo a qualquer código enviado ao INDI. No Linux, você pode criar o arquivo ~/.astylerc contendo as seguintes regras: 

--style=allman
--align-reference=name
--indent-switches
--indent-modifiers
--indent-classes
--pad-oper
--indent-col1-comments
--lineend=linux
--max-code-length=124

Alguns IDEs (por exemplo, QtCreator) suportam formatação automática do código sempre que você salva o arquivo no disco.

Fazendo atualizações no manual

No Linux execute o seguinte para instalar os programas necessários: 

sudo apt-get install docbook docbook-utils

A fonte do manual está em kstars/doc. Você pode editar esses arquivos, incluí-los em commits e MRs como faria com arquivos c++ (veja abaixo). Você pode descobrir a marcação por exemplo ou aprender com o documento on-line do docbook. Em geral, é melhor primeiro copiar todo o diretório kstars/doc para um diretório temporário e editar e gerar o manual lá, porque se você executasse o meinproc no diretório fonte principal, você geraria muitos arquivos .html lá, e você não quero enviar os arquivos gerados para o seu repositório git. 

cp -pr kstars/doc ~/DOCBOOK
cd ~/DOCBOOK
meinproc5 index.docbook

O acima deve gerar arquivos html. Então, em um navegador, você pode simplesmente abrir DOCBOOK/index.html e navegar até a parte desejada, por exemplo, basta digitar algo semelhante a isto na barra de URL do Chrome: file:///home/YOUR_USER_NAME/DOCBOOK/ doc/tool-ekos.html Faça alterações em alguns dos arquivos .docbook em ~/DOCBOOK/*.docbook. Gere novamente os arquivos html e visualize suas alterações no navegador, como antes. Iterar.

Para verificar a sintaxe, você pode querer executar: 

checkXML5 index.docbook

Quando estiver satisfeito, copie seus arquivos modificados de volta para kstars/doc e trate os arquivos editados/novos como de costume com o git, incluindo seus arquivos modificados em um novo commit e, eventualmente, em uma nova solicitação de mesclagem.

Mesclar descrições de solicitação

Consulte a seção abaixo, Dicas do Git, sobre detalhes técnicos de como gerar uma solicitação de mesclagem. No processo de fazer a solicitação, você precisará descrevê-la. Por favor, use um formato semelhante a este que contém seções para um resumo do que foi feito, o que foi modificado em cada arquivo, outras notas relevantes e como testar suas alterações.

Dicas Git

Você deve estar familiarizado com o git para fazer alterações no KStars, e este não é o lugar para tal tutorial. Existem muitos recursos excelentes para isso na web. O parágrafo abaixo, porém, dará uma visão geral de uma maneira de fazer um pedido de mesclagem, dado que você já tem experiência suficiente em git para clonar o KStars, criar um branch local, modificar o código como desejar, submeter suas alterações ao seu branch local, e teste seu código completamente.

Aqui está um bom recurso para um fluxo de trabalho fork-branch-git-git para fazer alterações no KStars. As etapas abaixo são inspiradas nessa página.

Configuração única do ambiente git do KStars.

  • Crie sua identidade KDE

  • Conecte-se. Vá para a página gitlab do KStars e faça login no canto superior direito.

  • Bifurque o projeto. Então, ainda na página gitlab do KStars, clique em FORK no canto superior direito, para criar seu próprio fork do projeto.

  • Copie seu URL. Observe o URL do seu fork. Deveria ser https://invent.kde.org/YOUR_KDE_NAME/kstars

  • Clonar o KStars. De volta ao seu computador, execute estes comandos

    • mkdir -p ~/Projetos

    • cd ~/Projetos

    • clone do git https://invent.kde.org/SEU_KDE_NAME/kstars

    • cd kstars

  • Adicione seu upstream. Adicione o repositório principal do KStars ao seu repositório bifurcado.

    • git remoto adicionar upstream https://invent.kde.org/education/kstars

Você está configurado agora.

Etapas usadas para cada alteração. Após a configuração única (acima), as etapas abaixo podem ser usadas para cada envio de novo recurso. Em resumo, você criará um branch de recursos em seu repositório local, fará as alterações desejadas lá e testará, enviará por push para seu fork, criará uma solicitação para mesclar seu fork com o repositório principal do KStars, aguardará o feedback e possivelmente iterará em seu mudanças esperando a aprovação de uma autoridade.

  • Crie seu branch de recursos.

    • git checkout -b YOUR_BRANCH_NAME

  • Faça suas alterações

  • Confirme suas alterações

    • git commit -a

  • Envie as alterações para seu repositório bifurcado.

    • origem do git push YOUR_BRANCH_NAME

  • Crie uma solicitação de mesclagem

    • Use seu navegador para visitar seu repositório bifurcado em https://invent.kde.org/YOUR_KDE_NAME/kstars

    • Você deverá ver uma opção para criar uma solicitação de mesclagem para YOUR_BRANCH_NAME. Preencha os detalhes (veja a seção acima).

    • Você deverá conseguir ver um novo URL dedicado a essa solicitação de mesclagem.

  • Faça algumas alterações. Você pode receber solicitações para modificar parte do seu código.

    • Nesse caso, basta voltar à sua filial local, fazer e testar suas alterações.

    • Confirme suas alterações conforme acima, dentro de seu branch, com: git commit -a

    • Envie as alterações da sua branch para o seu repositório bifurcado como acima com: git push origin YOUR_BRANCH_NAME

    • Suas alterações devem ser adicionadas automaticamente à sua solicitação de mesclagem. Verifique a página da solicitação de mesclagem para ter certeza.

    • Pode ser necessário rebasear seu código - veja detalhes abaixo.

Rebaseando suas alterações. Outros poderão estar a fazer alterações no KStars ao mesmo tempo que você está a trabalhar na sua funcionalidade. Rebasear é atualizar a sua versão do KStars e suas alterações específicas para fazer com que seja como se você tivesse alterado a versão mais recente do KStars, por exemplo, refletir as alterações na base de código feitas após você clonar ou atualizar sua própria cópia do KStars. Este é um tópico importante que você pode pesquisar no Google, mas as instruções a seguir funcionam na maioria das vezes.

Observe que isso é feito antes de você criar sua solicitação de mesclagem, quando você é o único a ver as alterações no código. Depois de iniciar sua solicitação de mesclagem, seu código será "público" e, em vez de rebase, você deverá seguir o procedimento de mesclagem abaixo. 

cd ~/Projects/kstars
git checkout master
git pull upstream master  # Get the master from the main KStars repo onto your local clone
git push origin master    # Then push your updated local clone into your forked repo
git checkout YOUR_BRANCH_NAME
git rebase master
git push origin YOUR_BRANCH_NAME -f

Se houver complicações com o rebase, o git fará sugestões sobre como corrigir os problemas.

Mesclando as alterações de outros. Depois de enviar uma solicitação de mesclagem, seu código poderá ser visto (e editado) por outras pessoas. Neste ponto, embora você ainda precise atualizar para a versão mais recente do KStars, o rebase destrói as informações de alteração e pode sobrescrever o que os outros estão fazendo. Em vez disso, é melhor 'fundir' a versão atual do KStars no seu código. 

cd ~/Projects/kstars
git checkout master
git pull upstream master  # Get the master from the main KStars repo onto your local clone
git push origin master    # Then push your updated local clone into your forked repo
git checkout YOUR_BRANCH_NAME
git merge master
git push origin YOUR_BRANCH_NAME

As diferenças da seção rebase são os 2 últimos comandos: 'git merge master' é usado em vez de 'git rebase master'. Além disso, o 'git push' não usa a opção -f. Na primeira vez que você executar o 'git push', o git pode solicitar que você adicione 'set-upstream origin' ao comando. Nesse caso, siga essas instruções.

Se você seguir este procedimento, encontrará um novo 'commit de mesclagem' adicionado ao log git da sua filial.

Sua próxima mudança . Assim que o seu pedido de fusão estiver completo (e possivelmente integrado no KStars), você poderá querer seguir em frente e desenvolver novamente. A próxima alteração usará outra (nova) ramificação de recurso, e a primeira ramificação de recurso poderá ser excluída. Você pode querer executar o seguinte regularmente para manter seu branch master atualizado com o KStars. 

cd ~/Projects/kstars
git checkout master
git pull upstream master  # Get the master from the main KStars repo onto your local clone
git push origin master    # Then push your updated local clone into your forked repo

Escrevendo testes

Os testes são armazenados na pasta Tests e usam QTest como estrutura de suporte:

  • Os testes unitários podem ser encontrados em auxiliary , capture , fitsviewer , etc. Eles tentam verificar o comportamento de um conjunto mínimo de classes e são suporte para desenvolvimento de funcionalidades.

  • Os testes de UI podem ser encontrados em kstars_lite_ui e kstars_ui . Eles executam casos de uso como o usuário final faria na interface do usuário e concentram-se na disponibilidade de feedback visual e na estabilidade dos procedimentos.

Escrevendo testes unitários

  1. Decida onde seu novo teste unitário residirá em Tests . As classes do KStars devem residir numa pasta que corresponda à sua origem: por exemplo, os testes da classe auxiliar residem em auxiliary . Encontre um local adequado para o seu teste, com base na parte do sistema que está sendo testada. Por exemplo, uma pasta chamada thatkstarscategory .

  2. Crie uma nova classe de teste unitário ou copie e cole um teste unitário existente em um novo. Verifique Tests/kstars_ui_tests/kstars_ui_tests.h como exemplo. Nomeie os arquivos .h e .cpp como "test[classe kstars minúscula]" (por exemplo "testthatkstarsclass") e atualize-os para corresponder ao seguinte: 

/* [Author+Licence header] */
#ifndef TESTTHATKSTARSCLASS_H
#define TESTTHATKSTARSCLASS_H

#include <QtTest>
#include <QObject>

class TestThatKStarsClass: public QObject
{
    Q_OBJECT
public:
    explicit TestThatKStarsClass(QObject *parent = null);

private slots:
    void initTestCase();                    // Will trigger once at beginning
    void cleanupTestCase();                 // Will trigger once at end

    void init();                            // Will trigger before each test
    void cleanup();                         // Will trigger after each test

    void testThisParticularFunction_data(); // Data fixtures for the test function (Qt 5.9+)
    void testThisParticularFunction();      // Test function
}
#endif // TESTTHATKSTARSCLASS_H
/* [Author+Licence header] */
#include "testthatkstarsclass.h"
TestThatKStarsClass::TestThatKStarsClass(QObject* parent): QObject(parent) {}
TestThatKStarsClass::initTestCase() {}
TestThatKStarsClass::cleanupTestCase() {}
TestThatKStarsClass::init() {}
TestThatKStarsClass::cleanup() {}

TestThatKStarsClass::testThisParticularFunction_data()
{
    // If needed, add data fixtures with QTest::AddColumn/QTest::AddRow, each will trigger testThisParticularFunction
}

TestThatKStarsClass::testThisParticularFunction()
{
    // Write your tests here, eventually using QFETCH to retrieve the current data fixture
}

QTEST_GUILESS_MAIN(TestThatKStarsClass);

Você pode usar um único arquivo para armazenar a declaração e a definição, mas precisará #include "testthatkstarsclass.moc" entre a declaração e a definição.

  1. Atualize a configuração do CMake para adicionar seu teste. Se você criou uma nova pasta, crie um novo CMakeLists.txt para adicionar seu teste: 

ADD_EXECUTABLE( testthatkstarsclass testthatkstarsclass.cpp )
TARGET_LINK_LIBRARIES( testthatkstarsclass ${TEST_LIBRARIES})
ADD_TEST( NAME ThatKStarsClassTest COMMAND testthatkstarsclass )

Faça com que o CMakeLists.txt que reside uma pasta acima no sistema de arquivos inclua esse CMakeLists.txt adicionando: 

include_directories(
    ...
    ${kstars_SOURCE_DIR}/kstars/path/to/the/folder/of/the/kstars/class/you/are/testing
)
...
add_subdirectory(thatkstarscategory)

Certifique-se de adicionar seu add_subdirectory no grupo de dependências correto. Os testes Ekos requerem INDI_FOUND , por exemplo.

  1. Escreva seus testes Certifique-se de documentar o comportamento com seus testes. Se acontecer de você encontrar um bug, não o corrija, marque-o com uma macro QEXPECT_FAIL . O teste documentará o comportamento incorreto enquanto o bug estiver ativo e falhará quando o bug for corrigido. Só depois disso o teste poderá ser atualizado. Preste atenção também ao suporte à versão da biblioteca Qt. Por exemplo, os equipamentos de dados requerem Qt 5.9+.

Escrevendo testes de interface do usuário

Siga as mesmas etapas dos testes unitários, mas localize suas classes de teste em kstars_ui_tests .

Uma coisa importante sobre os testes de UI é que todos eles devem usar QStandardPaths::setTestModeEnabled(true) , para que sejam executados com uma configuração de usuário separada que está inicialmente em branco. Os testes de interface do usuário exigem, portanto, uma configuração preliminar para funcionar corretamente, como usar o novo assistente de configuração ou definir a localização geográfica. Por esse motivo, você precisa adicionar a execução do seu teste em Tests/kstars_ui_tests/kstars_ui_tests.cpp , em main() , após a execução de TestKStarsStartup .

Uma segunda coisa importante sobre o QTest geralmente é que as funções de teste não possuem código de retorno. Portanto, é necessário escrever macros para fatorar código duplicado. Você encontrará muitas macros existentes nos arquivos de cabeçalho das classes de teste kstars_ui_tests , para recuperar gadgets, para clicar em botões ou para preencher widgets QComboBox ...

Uma terceira coisa importante sobre a interface do KStars é que ela mistura elementos KDE e Qt UI. Assim, às vezes os testes exigem que o código de verificação seja movido para uma chamada QTimer::singleShot , e às vezes até mesmo o clique em um botão deve ser feito de forma assíncrona para que o teste permaneça no controle (diálogos modais). Felizmente, esses hacks não alteram a execução do código testado.

Ao testar, você precisa sempre usar elementos que o usuário final possa usar. Obviamente, se um teste exigir uma configuração que não faça parte das chamadas interessantes, você poderá hackear uma chamada direta. Por exemplo, alguns testes Ekos que exigem que o Simulador de Telescópio aponte para um local específico usam QVERIFY(Ekos::Manager::Instance()->mountModule()->sync(ra,dec)) . Lembre-se de que às vezes você precisa reservar um tempo para que os sinais assíncronos sejam emitidos e captados.

Créditos

A equipe KStars

Autor original

Jason Harris [email protected]

Mantenedor Atual

Jasem Mutlaq [email protected]

Colaboradores (em ordem alfabética)

Fontes de dados:

A maior parte dos dados do catálogo veio do Centro de Dados Astronômicos, administrado pela NASA. O site é: http://adc.gsfc.nasa.gov/

Os dados NGC/IC são compilados por Christian Dersch do banco de dados OpenNGC. https://github.com/mattiaverga/OpenNGC (licença CC-BY-SA-4.0)

Os dados de supernovas são do projeto Open Supernova Catalog em https://sne.space Consulte o artigo publicado aqui: http://adsabs.harvard.edu/abs/2016arXiv160501054G

Links do KStars para as excelentes coleções de imagens e páginas HTML reunidas pelos Estudantes para a Exploração e Desenvolvimento do Espaço, em: http://www.seds.org

Links do KStars para as imagens online do Digitized Sky Survey, que você pode consultar em: http://archive.stsci.edu/cgi-bin/dss_form

Links do KStars para imagens do projeto HST Heritage e dos comunicados de imprensa do HST: http://heritage.stsci.edu http://oposite.stsci.edu/pubinfo/pr.html

Links do KStars para imagens do Programa de Observadores Avançados no Observatório Nacional de Kitt Peak. Se você estiver interessado em astrofotografia, considere conferir o programa: http://www.noao.edu/outreach/aop/

Os créditos de cada imagem usada no programa estão listados em README.images

Agradecimento original do fundador do projeto

KStars é um trabalho de amor. Começou como um hobby pessoal meu, mas logo depois de postar o código no Sourceforge, começou a atrair outros desenvolvedores. Estou completamente impressionado e satisfeito com meus co-desenvolvedores. Eu não poderia pedir uma equipe mais talentosa e amigável. Escusado será dizer que o KStars não estaria nem perto do que é hoje sem os seus esforços. Juntos, fizemos algo de que todos podemos nos orgulhar.

Usámos (principalmente) dois livros como guia para escrever os algoritmos usados ​​no KStars:

  • "Astronomia prática com sua calculadora", de Peter Duffett-Smith

  • "Algoritmos Astronômicos" por Jean Meeus

Obrigado aos desenvolvedores do Qt e do KDE, cuja API incomparável tornou o KStars possível. Obrigado também aos esforços incansáveis ​​das equipes de tradução do KDE, que levam o KStars a um público global.

Obrigado a todos nos fóruns do KDevelop e no irc.kde.org, por responderem às minhas perguntas frequentes.

Obrigado também aos muitos usuários que enviaram relatórios de bugs ou outros comentários.

Você ainda está lendo isso? :) Bem, é isso. Espero que você goste do KStars!

Jason Harris [email protected]

Lista de discussão de desenvolvimento do KStars [email protected]

Envie-nos ideias e comentários!

Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos