Page d'accueil>Lié à la programmation>Autre code source
Télécharger

Un planétarium de bureau pour KDE

KStars est un logiciel d'astronomie gratuit, open source et multiplateforme.

Il fournit une simulation graphique précise du ciel nocturne, depuis n’importe quel endroit sur Terre, à n’importe quelle date et heure. L'affichage comprend jusqu'à 100 millions d'étoiles, 13 000 objets du ciel profond, les 8 planètes, le Soleil et la Lune, ainsi que des milliers de comètes, d'astéroïdes, de supernovae et de satellites.

Pour les étudiants et les enseignants, il prend en charge des vitesses de simulation réglables afin de visualiser les phénomènes qui se produisent sur de longues périodes, l'Astrocalculateur KStars pour prédire les conjonctions et de nombreux calculs astronomiques courants. Pour l'astronome amateur, il fournit un planificateur d'observation, un outil de calendrier céleste et un éditeur FOV pour calculer le champ de vision des équipements et les afficher. Découvrez des objets intéressants dans l'outil « Quoi de neuf ce soir », tracez des graphiques d'altitude en fonction du temps pour n'importe quel objet, imprimez des cartes du ciel de haute qualité et accédez à de nombreuses informations et ressources pour vous aider à explorer l'univers !

KStars comprend la suite d'astrophotographie Ekos, une solution d'astrophotographie complète qui peut contrôler tous les appareils INDI, y compris de nombreux télescopes, CCD, reflex numériques, porte-oculaires, filtres et bien plus encore. Ekos prend en charge un suivi très précis à l'aide d'un solveur d'astrométrie en ligne et hors ligne, de capacités de mise au point automatique et d'autoguidage, ainsi que de la capture d'images uniques ou multiples à l'aide du puissant gestionnaire de séquences intégré.

Droit d'auteur

Copyright (c) 2001 - 2024 par l'équipe KStars :

KStars est un logiciel libre, publié sous la licence publique GNU. Voir COPIE pour les informations sur la licence GPL.

Téléchargements

KStars est disponible pour Windows, MacOS et Linux. Vous pouvez télécharger la dernière version sur le site officiel de KStars.

Sous Linux, il est disponible pour la plupart des distributions Linux.

La dernière version stable est la v3.6.8

URL et fichiers importants.

  • La page d'accueil de KStars

  • Dépôt Git KStars

  • Chat en ligne KStars

  • Forum où KStars est souvent discuté

Documentation KStars

Le manuel KStars se trouve dans votre répertoire $(KDEDIR)/share/doc/HTML//kstars/. Vous pouvez également y accéder facilement depuis le menu Aide, ou en appuyant sur la touche [F1], ou en visitant https://docs.kde.org/?application=kstars Malheureusement, il est un peu obsolète. Nous accueillons les bénévoles pour nous aider à le mettre à jour.

De plus, il existe les fichiers README suivants :

README : ce fichier ; informations générales README.planetmath : Explication des algorithmes utilisés pour calculer les positions des planètes README.customize : Options de personnalisation avancées README.images : Informations de copyright pour les images utilisées dans KStars. README.i18n : Instructions pour les traducteurs

Développement

Le code peut être cloné, visualisé et des demandes de fusion peuvent être effectuées via le référentiel KStars. Si vous êtes nouveau dans les référentiels git distants, veuillez consulter la section Conseils Git ci-dessous. Remarque : Auparavant, KStars utilisait Phabricator pour ses demandes de fusion. Ce système n'est plus utilisé.

Environnement de développement intégré IDE

Si vous envisagez de développer KStars, il est fortement recommandé d'utiliser un IDE. Vous pouvez utiliser n'importe quel IDE de votre choix, mais QtCreator(https://www.qt.io/product) ou KDevelop(https://www.kdevelop.org) sont recommandés car ils sont plus adaptés au développement Qt/KDE.

Pour ouvrir KStars dans QtCreator, sélectionnez le fichier CMakeLists.txt dans le dossier source de KStars, puis configurez l'emplacement et le type de build.

Bâtiment

  1. Forfaits prérequis

Pour construire et développer KStars, plusieurs packages peuvent être requis dans votre distribution. Voici une liste.

  • Dépendances requises

    • GNU Make, GCC -- Outils essentiels pour la construction

    • cmake -- système de construction utilisé par KDE

    • Bibliothèque Qt > 5.12.0

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

    • eigen -- bibliothèque d'algèbre linéaire

    • zlib -- bibliothèque de compression

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

  • Dépendances facultatives

    • libcfitsio -- Bibliothèque FITS

    • libindi -- Interface distribuée neutre pour instrument, pour contrôler l'équipement.

    • xplanète

    • astrométrie.net

    • bibliothèque

    • wcslib

    • libgsl

    • qtporte-clés

  1. Installation des conditions préalables

Debian/Ubuntu

La commande apt-add-respository est nécessaire pour le libstellarsolver-dev d'apt-get. Alternativement, vous pouvez ignorer le dépôt apt-add, supprimer le libstellarsolver-dev de apt-get et créer et installer stellarsolver à partir de 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

Feutre 

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. Compilation

Ouvrez une console et exécutez les commandes suivantes : 

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

Pour exécuter KStars, tapez simplement kstars dans le terminal.

Style de code

KStars utilise Artistic Style pour formater tous les fichiers sources C++. Veuillez vous assurer d'appliquer les règles de style suivantes à tout code soumis à INDI. Sous Linux, vous pouvez créer un fichier ~/.astylerc contenant les règles suivantes : 

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

Certains IDE (par exemple QtCreator) prennent en charge le formatage automatique du code à chaque fois que vous enregistrez le fichier sur le disque.

Effectuer des mises à jour du manuel

Sous Linux, exécutez ce qui suit pour installer les programmes nécessaires : 

sudo apt-get install docbook docbook-utils

La source du manuel se trouve dans kstars/doc. Vous pouvez modifier ces fichiers, les inclure dans les commits et les MR comme vous le feriez pour les fichiers C++ (voir ci-dessous). Vous pouvez comprendre le balisage par exemple ou apprendre de la documentation en ligne pour docbook. En général, il est préférable de copier d'abord l'intégralité du répertoire kstars/doc dans un répertoire temporaire, puis d'y éditer et de générer le manuel, car si vous exécutiez meinproc dans le répertoire source principal, vous y généreriez de nombreux fichiers .html, et vous je ne veux pas valider les fichiers générés dans votre référentiel git. 

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

Ce qui précède devrait générer des fichiers HTML. Ensuite, dans un navigateur, vous pouvez simplement ouvrir DOCBOOK/index.html et naviguer jusqu'à la partie souhaitée, par exemple, tapez simplement quelque chose de similaire à ceci dans la barre d'URL de Chrome : file:///home/YOUR_USER_NAME/DOCBOOK/ doc/tool-ekos.html Apportez des modifications à certains fichiers .docbook dans ~/DOCBOOK/*.docbook. Régénérez les fichiers html et affichez vos modifications dans le navigateur, comme auparavant. Répéter.

Pour vérifier la syntaxe, vous souhaiterez peut-être exécuter : 

checkXML5 index.docbook

Une fois que vous êtes satisfait, copiez vos fichiers modifiés dans kstars/doc et traitez les fichiers modifiés/nouveaux comme d'habitude avec git, en incluant vos fichiers modifiés dans un nouveau commit et éventuellement une nouvelle demande de fusion.

Descriptions des demandes de fusion

Consultez la section ci-dessous, Git Tips, pour connaître les détails techniques sur la façon de générer une demande de fusion. Lors du processus de demande, vous devrez décrire la demande. Veuillez utiliser un format similaire à celui-ci qui comporte des sections pour un résumé de ce qui a été fait, ce qui a été modifié dans chaque fichier, d'autres notes pertinentes et comment tester vos modifications.

Astuces Git

Vous devez être familier avec git pour apporter des modifications à KStars, et ce n'est pas le lieu pour un tel tutoriel. Il existe de nombreuses excellentes ressources à ce sujet sur le Web. Le paragraphe ci-dessous, cependant, donnera un aperçu d'une façon de faire une demande de fusion, étant donné que vous avez déjà suffisamment d'expérience avec Git pour cloner KStars, créer une branche locale, modifier le code à votre guise, valider vos modifications dans votre branche locale, et testez minutieusement votre code.

Voici une bonne ressource pour un fork-branch-git-workflow permettant d'apporter des modifications à KStars. Les étapes ci-dessous sont inspirées de cette page.

Configuration unique de l'environnement git KStars.

  • Créez votre identité KDE

  • Se connecter. Accédez à la page gitlab de KStars et connectez-vous dans le coin supérieur droit.

  • Forkez le projet. Ensuite, toujours sur la page gitlab de KStars, cliquez sur FORK dans le coin supérieur droit, pour créer votre propre fork du projet.

  • Copiez votre URL. Notez l'URL de votre fork. Cela devrait être https://invent.kde.org/YOUR_KDE_NAME/kstars

  • Clonez KStars. De retour sur votre ordinateur, exécutez ces commandes

    • mkdir -p ~/Projets

    • cd ~/Projets

    • clone git https://invent.kde.org/YOUR_KDE_NAME/kstars

    • cd kstars

  • Ajoutez votre amont. Ajoutez le dépôt principal KStars à votre dépôt forké.

    • git distant ajouter en amont https://invent.kde.org/education/kstars

Vous êtes configuré maintenant.

Étapes utilisées pour chaque changement. Après la configuration unique (ci-dessus), les étapes ci-dessous peuvent être utilisées pour chaque soumission de nouvelle fonctionnalité. En résumé, vous créerez une branche de fonctionnalités dans votre référentiel local, y apporterez les modifications souhaitées et les testerez, les pousserez vers votre fork, créerez une demande pour fusionner votre fork avec le référentiel KStars principal, attendrez les commentaires et éventuellement itérerez sur votre changements en espérant l’approbation d’une autorité.

  • Créez votre branche de fonctionnalités.

    • git checkout -b VOTRE_BRANCH_NAME

  • Apportez vos modifications

  • Validez vos modifications

    • git commit -a

  • Envoyez les modifications à votre dépôt forké.

    • git push origine VOTRE_BRANCH_NAME

  • Créer une demande de fusion

    • Utilisez votre navigateur pour visiter votre dépôt forké à l'adresse https://invent.kde.org/YOUR_KDE_NAME/kstars

    • Vous devriez voir une option permettant de créer une demande de fusion pour YOUR_BRANCH_NAME. Remplissez les détails (voir la section ci-dessus).

    • Vous devriez pouvoir voir une nouvelle URL dédiée à cette demande de fusion.

  • Apportez quelques modifications. Vous pouvez recevoir des demandes de modification d’une partie de votre code.

    • Si tel est le cas, retournez simplement à votre succursale locale, effectuez et testez vos modifications.

    • Validez vos modifications comme ci-dessus, dans votre branche, avec : git commit -a

    • Transférez les modifications de votre branche vers votre dépôt forké comme ci-dessus avec : git push origin YOUR_BRANCH_NAME

    • Vos modifications devraient automatiquement être ajoutées à votre demande de fusion. Vérifiez la page de la demande de fusion pour en être sûr.

    • Vous devrez peut-être rebaser votre code (voir ci-dessous pour plus de détails).

Rebaser vos modifications. D'autres peuvent apporter des modifications à KStars en même temps que vous travaillez sur votre fonctionnalité. Le rebasage consiste à mettre à jour votre version de KStars et vos modifications particulières pour faire comme si vous aviez modifié la dernière version de KStars, par exemple pour refléter les modifications apportées à la base de code après avoir cloné ou mis à jour votre propre copie de KStars. Il s'agit d'un sujet important que vous pouvez rechercher sur Google, mais les instructions suivantes fonctionnent la plupart du temps.

Notez que cela est fait avant de créer votre demande de fusion, lorsque vous êtes le seul à voir les modifications de votre code. Une fois que vous avez lancé votre demande de fusion, votre code est "public" et au lieu de rebaser, vous devez suivre la procédure de fusion ci-dessous. 

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

S'il y a des complications avec le rebase, git fera des suggestions sur la façon de corriger les problèmes.

Fusionner les modifications des autres. Une fois que vous soumettez une demande de fusion, votre code peut être vu (et modifié) par d'autres. À ce stade, même si vous devrez peut-être encore mettre à jour vers la dernière version de KStars, le rebasage détruit les informations de modification et peut écraser ce que font les autres. Au lieu de cela, il est préférable de « fusionner » la version actuelle de KStars dans votre code. 

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

Les différences par rapport à la section rebase résident dans les 2 dernières commandes : 'git merge master' est utilisé à la place de 'git rebase master'. De plus, le 'git push' n'utilise pas l'option -f. La première fois que vous exécutez 'git push', git peut vous demander d'ajouter 'set-upstream origin' à la commande. Dans ce cas, suivez ces instructions.

Si vous suivez cette procédure, vous trouverez un nouveau « commit de fusion » ajouté au journal git de votre branche.

Votre prochain changement . Une fois votre demande de fusion terminée (et éventuellement intégrée à KStars), vous souhaiterez peut-être continuer et développer à nouveau. Le prochain changement utilisera une autre (nouvelle) branche de fonctionnalités, et la première branche de fonctionnalités pourrait être supprimée. Vous souhaiterez peut-être exécuter régulièrement ce qui suit pour maintenir votre branche principale à jour avec 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

Tests d'écriture

Les tests sont stockés dans le dossier Tests et utilisent QTest comme framework de support :

  • Les tests unitaires peuvent être trouvés dans auxiliary , capture , fitsviewer , etc. Ils tentent de vérifier le comportement d'un ensemble minimal de classes et prennent en charge le développement de fonctionnalités.

  • Les tests d'interface utilisateur peuvent être trouvés dans kstars_lite_ui et kstars_ui . Ils exécutent des cas d'utilisation comme le ferait l'utilisateur final à partir de l'interface utilisateur et se concentrent sur la disponibilité du retour visuel et la stabilité des procédures.

Écrire des tests unitaires

  1. Décidez où résidera votre nouveau test unitaire dans Tests . Les classes KStars doivent résider dans un dossier correspondant à leur origine : par exemple, les tests de classes auxiliaires vivent dans auxiliary . Trouvez un endroit approprié pour votre test, en fonction de la partie du système testée. A titre d'exemple, un dossier nommé thatkstarscategory .

  2. Créez une nouvelle classe de test unitaire ou copiez-collez un test unitaire existant dans un nouveau. Vérifiez Tests/kstars_ui_tests/kstars_ui_tests.h à titre d'exemple. Nommez les fichiers .h et .cpp comme « test[classe kstars minuscule] » (par exemple « testthatkstarsclass ») et mettez-les à jour pour qu'ils correspondent à ce qui suit : 

/* [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);

Vous pouvez utiliser un seul fichier pour contenir à la fois la déclaration et la définition, mais vous devrez #include "testthatkstarsclass.moc" entre la déclaration et la définition.

  1. Mettez à jour la configuration CMake pour ajouter votre test. Si vous avez créé un nouveau dossier, créez un nouveau CMakeLists.txt pour ajouter votre test : 

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

Demandez au CMakeLists.txt résidant un dossier plus haut dans le système de fichiers d'inclure ce CMakeLists.txt en ajoutant : 

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

Assurez-vous d'ajouter votre add_subdirectory dans le bon groupe de dépendances. Les tests Ekos nécessitent par exemple INDI_FOUND .

  1. Écrivez vos tests Assurez-vous de documenter le comportement avec vos tests. Si vous trouvez un bug, ne le corrigez pas, marquez-le avec une macro QEXPECT_FAIL . Le test documentera le comportement incorrect pendant que le bogue est actif et échouera une fois le bogue corrigé. Ce n’est qu’après cela que le test pourra être mis à jour. Faites également attention à la prise en charge des versions de la bibliothèque Qt. Par exemple, les appareils de données nécessitent Qt 5.9+.

Rédaction de tests d'interface utilisateur

Suivez les mêmes étapes que pour les tests unitaires, mais localisez vos classes de test dans kstars_ui_tests .

Une chose importante à propos des tests d'interface utilisateur est qu'ils doivent tous utiliser QStandardPaths::setTestModeEnabled(true) , afin qu'ils s'exécutent avec une configuration utilisateur distincte initialement vide. Les tests d'interface utilisateur nécessitent ainsi un paramétrage préalable pour fonctionner correctement, comme l'utilisation du nouvel assistant de configuration ou le paramétrage de la localisation géographique. Pour cette raison, vous devez ajouter l'exécution de votre test dans Tests/kstars_ui_tests/kstars_ui_tests.cpp , dans main() , après l'exécution de TestKStarsStartup .

Une deuxième chose importante à propos de QTest en général est que les fonctions de test n'ont pas de code retour. Il faut donc écrire des macros pour factoriser le code dupliqué. Vous trouverez de nombreuses macros existantes dans les fichiers d'entête des classes de tests kstars_ui_tests , pour récupérer des gadgets, cliquer sur des boutons ou remplir des widgets QComboBox ...

Une troisième chose importante à propos de l'interface KStars est qu'elle mélange des éléments d'interface utilisateur KDE et Qt. Ainsi, parfois les tests nécessitent que le code de vérification soit déplacé vers un appel QTimer::singleShot , et parfois même le clic sur un bouton doit être rendu asynchrone pour que le test reste sous contrôle (boîtes de dialogue modales). Heureusement, ces hacks n’altèrent pas l’exécution du code testé.

Lors des tests, vous devez vous assurer de toujours utiliser des éléments que l'utilisateur final peut utiliser. Bien entendu, si un test nécessite une configuration qui ne fait pas réellement partie des appels intéressants, vous pouvez pirater un appel direct. Par exemple, certains tests Ekos nécessitant que le simulateur de télescope pointe vers un emplacement spécifique utilisent QVERIFY(Ekos::Manager::Instance()->mountModule()->sync(ra,dec)) . N'oubliez pas que vous devez parfois laisser du temps pour que les signaux asynchrones soient émis et captés.

Crédits

L'équipe KStars

Auteur original

Jason Harris [email protected]

Responsable actuel

Jasem Mutlaq [email protected]

Contributeurs (Alphabétique)

Sources de données :

La plupart des données du catalogue provenaient du Centre de données astronomiques, géré par la NASA. Le site Web est : http://adc.gsfc.nasa.gov/

Les données NGC/IC sont compilées par Christian Dersch à partir de la base de données OpenNGC. https://github.com/mattiaverga/OpenNGC (licence CC-BY-SA-4.0)

Les données Supernovae proviennent du projet Open Supernova Catalog sur https://sne.space. Veuillez vous référer à l'article publié ici : http://adsabs.harvard.edu/abs/2016arXiv160501054G.

KStars renvoie aux excellentes collections d'images et aux pages HTML rassemblées par les étudiants pour l'exploration et le développement de l'espace, sur : http://www.seds.org

Liens KStars vers les images Digitized Sky Survey en ligne, que vous pouvez consulter sur : http://archive.stsci.edu/cgi-bin/dss_form

Liens KStars vers des images du projet HST Heritage et des communiqués de presse HST : http://heritage.stsci.edu http://oposite.stsci.edu/pubinfo/pr.html

KStars renvoie à des images du programme Advanced Observer de l'observatoire national de Kitt Peak. Si vous êtes intéressé par l'astrophotographie, vous pourriez envisager de consulter leur programme : http://www.noao.edu/outreach/aop/

Les crédits pour chaque image utilisée dans le programme sont répertoriés dans README.images

Remerciement original du fondateur du projet

KStars est un travail d'amour. Cela a commencé comme un passe-temps personnel, mais très peu de temps après avoir publié le code sur Sourceforge, cela a commencé à attirer d'autres développeurs. Je suis tout simplement complètement impressionné et satisfait par mes co-développeurs. Je ne pouvais pas rêver d'un équipage plus talentueux et plus sympathique. Il va sans dire que KStars ne serait pas ce qu'il est aujourd'hui sans leurs efforts. Ensemble, nous avons créé quelque chose dont nous pouvons tous être fiers.

Nous avons utilisé (principalement) deux livres comme guide pour écrire les algorithmes utilisés dans KStars :

  • "Astronomie pratique avec votre calculatrice" par Peter Duffett-Smith

  • "Algorithmes Astronomiques" de Jean Meeus

Merci aux développeurs de Qt et de KDE dont l'API hors pair a rendu KStars possible. Merci également aux efforts inlassables des équipes de traduction de KDE, qui font connaître KStars à un public mondial.

Merci à tous ceux qui sont présents sur les forums de discussion de KDevelop et sur irc.kde.org pour avoir répondu à mes questions fréquentes.

Merci également aux nombreux utilisateurs qui ont soumis des rapports de bugs ou d'autres commentaires.

Vous lisez toujours ceci ? :) Eh bien, c'est à peu près tout. J'espère que vous apprécierez KStars !

Jason Harris [email protected]

Liste de diffusion de développement KStars [email protected]

Envoyez-nous des idées et des commentaires !

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout