FMWH !

Coucou

Vu que je suis en arrêt de travail... Et bien je tue le temps...

J'ai commencé à écrire un outil qui permettra de trier automatiquement les photos d'une soirée astro en fonction de plusieurs paramètres :

- Fmwh pour chaque étoile
- Fmwh global de toutes les étoiles présente sur l'image.
- Calcul de la courbe de gauss, moyenne, écart type, ...
- Tri des étoiles en fonction de la luminance relative.
- Tri des étoiles en fonction de la luminosité.
- Tri des étoiles en fonction de la saturation.
- Tri des étoiles en fonction de l'intensité lumineuse.

Pour le moment mon algo est capable de détecter des étoiles dans des parties très sombres du ciel ! Mais bon... j'ai passé la journée entière dessus pfff.

Au niveau de l'interpolation, j'arrive à un rendu visuel plus précis que DeepSkyStacker. Je convertis toutes les images en Bitmap 24 bits avant traitement.

Ensuite j'effectue les calcule sur 2 images différentes générées en mémoire, la première en 24 bits couleur et la suivante, je génère une palette de 256 couleurs en niveau de gris en me basant sur des moyennes calculées d'après la luminance de l'image et je la transforme en 8bits indexés afin de réaliser un masque qui facilite la détection des étoiles.

Pourquoi du Bitmap ? C'est simple... Il n'y a aucune perte de couleur car c'est un format non compressé et ce format est compatible avec tous les OS...

Voici un aperçu :



L'exemple ci-dessous trouve même les étoiles présentes dans la nébuleuse :



Et un autre aperçu montrant bien la détection des étoiles dans une zone sombre :



Voilà,

Edition :

Voici la suite Le logiciel fait plein de choses maintenant Mais il n'est pas encore terminé !

Vous pouvez télécharger la version actuelle ici : http://astro.aubedutemps.info/download/FWHM.rar

Voici les captures d'écran :

Tu t'amuses, là... Joli... 

Mais tant que tu y es, exploite les RAW (dcraw, of course), ou le FITS ,sans conversion... 

Rem : Visual Studio, certes, mais en quoi ? C# ?

Fantastique !

ttf a écrit:

Visual Studio, certes, mais en quoi ? C# ?

Vu les quelques lignes de code on dirait bien.

Oui, j'utilise c#, c'est bien plus rapide.

L'application utilise déjà les fits . mais toutes les applications convertissent en Bitmap , même ma librairie Fits présente sur le site de la Nasa utilise du Bitmap. Tu es obligé de convertir en BGR pour les traitements des données afin de te facilité la tâche sinon trop de boulot pour traiter tout les formats dispo

Quant à Siril, il utilise la librairie OpenCV qui utilise aussi du Bitmap cela ne change rien et c'est bien plus simple pour travailler sur les images car les outils de base sont déjà existants.

Voici le lien des librairies Fits :

https://fits.gsfc.nasa.gov/fits_viewer.html

Si tu parles de "bitmap" en format interne, ok, en effet, c'est le destin de toutes les images  

En Python (mon langage de préférence) j'utilise aussi des librairies équivalentes (dont OpenCV).

Vous verrez un de ces jours un projet sur lequel je travaille...
(j'ai encore un paquet de man/day dessus)  

La j'en bave sur le Fits...

J'arrive à extraire les données du fichier et lire le header, les HDUs... Mais je viens de remarquer qu'il y a une palette de couleurs à construire en fonction des données présentes dans le fichier.

Ce sont toutes des palettes astronomiques à générer dynamiquement en fonction des fits... Mais je pense utiliser la palette SAO DS9.. à voir : http://chandra.harvard.edu/edu/formal/age_snr/3color_ds9.html

Mais pour cela... Il faut que je trouve dans le fichier les seuils (pas encore trouvé mais je pense que c'est entre 0 est 32767 vu que les données du FITS sont en short_16).

Donc... Je dois continuer mes recherches !

En plus les librairies FITS sur le site de la Nasa ne sont plus maintenues à jour...

J'ai aussi remarqué que la version 4.0 du format FITS pouvait contenir des données d'images 24, 32 et 64 bits... Mais je vais me limité au 16bits dans un premier temps.

Et pour les formats RAW, je prends tous les APN en compte... Mais j'ai du créer un wrapper pour pouvoir utiliser la libraire car elle n'existe pas en C#

Voici la liste des types d'images que je prends en compte pour le moment :

Code:

Fichier image BMP (*.BMP, *.DIB, *.RLE)
Fichier image JPEG (*.JPG, *.JPEG, *.JPE, *.JFIF)
Fichier image GIF (*.GIF)
Fichier image TIFF (*.TIF, *.TIFF)
Fichier image PNG (*.PNG)
Fichier image RAW Canon (*.CRW, *.CR2)
Fichier image RAW Nikon (*.NEF)
Fichier image RAW Fuji (*.RAF)
Fichier image RAW Hasselblad (*.3FF)
Fichier image RAW Kodak (*.KDC, *.DCR)
Fichier image RAW Minolta (*.MRW)
Fichier image RAW Olympus (*.ORF)
Fichier image RAW Panasonic (*.RW2)
Fichier image RAW Pentax (*.PTX, *.PEF)
Fichier image RAW Samsung (*.SRW)
Fichier image RAW Sony (*.ARW)
Fichier image RAW Sigma (*.X3F)
Fichier image RAW Leaf Imaging (*.MOS)
Fichier image RAW Universel (*.DNG)
Fichier image RAW (*.RAW)
Fichier image FITS (*.FIT, *.FITS)

Voici le lien vers le code source de LibRaw : https://www.libraw.org/

Maintenant je code peut-être des trucs totalement inutiles Mais çà m'occupe

Je vais commencer l'importation de plusieurs fichiers afin de pouvoir calculer le FMWH total des images et commencer à créer les routines de tri des images.

@ttf : Oui je parle du format bitmap interne

"pas mis à jour" en effet, mais comme le format est largement répandu en-dehors de l'astro...

Si tu regardes :

https://pythonhosted.org/pyfits/

A module for reading and writing Flexible Image Transport System (FITS) files. This file format was endorsed by the International Astronomical Union in 1999 and mandated by NASA as the standard format for storing high energy astrophysics data. For details of the FITS standard, see the NASA/Science Office of Standards and Technology publication, NOST 100-2.0.

For detailed examples of usage, see the PyFITS User’s Manual.

File Handling and Convenience Functions
open()
writeto()
info()
append()
update()
getdata()
getheader()
getval()
setval()
delval()
HDU Lists
HDUList
Header Data Units
PrimaryHDU
GroupsHDU
GroupData
Group
StreamingHDU
Headers
Header
Cards
Card
Tables
BinTableHDU
TableHDU
Column
ColDefs
FITS_rec
FITS_record
Table Functions
new_table()
tabledump()
tableload()
Images
ImageHDU
CompImageHDU
Section
Differs
FITSDiff
HDUDiff
HeaderDiff
ImageDataDiff
RawDataDiff
TableDataDiff
Verification options
exception
ignore
fix
silentfix
warn

Il y a plein de documentation sur le contenu... 
Ex : 
https://pythonhosted.org/pyfits/usage/examples.html#converting-a-3-color-image-jpg-to-separate-fits-images

De mon côté, il y a plusieurs "library" 

Coucou

La version est dispo !

J'ai édité le premier message et ajouter des images Si vous avez des suggestions !!! Je prends !

Maintenant l'outil fait :

-Affichage d'une liste d'images
-Analyse plusieurs images
-Calcul l'intensité du ciel en pourcentage
-Calcul le nombre d'étoiles
-Calcul l'intensité maximale et minimum
-Calcul la qualité du ciel en pourcentage
-Calcul du centre d'une étoile
-Génère et enregistre la couche alpha
-Génère et enregistre la couche rouge
-Génère et enregistre la couche verte
-Génère et enregistre la couche bleue
-Génère et enregistre la luminescence
-Génère et enregistre une heat map
-Calcul le rayon de toutes les étoiles (pas encore d'affichage)
-Importe tous les types d'image d'apn numérique

À venir :

Calcul de l'intensité des étoiles
Calcul du rayon sous différents angles
Calcul des axes des étoiles
Calcul de l'axe le plus grand
Calcul de l'axe le plus petit

Edition :

Euh .... J'ai un QI d'huitre... L'exportation de la couche Alpha... C'est totalement useless.... Ce sera toujours une image entièrement blanche vu que les photos astro ne gèrent pas la transparence des images... Je vais retirer cette option.

J'ai une question !

J'aimerais calculer la magnitude absolue et la magnitude d'une étoile.

Le premier souci, depuis une photo je n'ai pas d'indice de distance par rapport à la terre.
Donc... est-ce que je peux utiliser une constante stellaire pour faire mes calcules ?

Si oui, est-ce que je dois prendre la luminosité du soleil ou de Véga pour mon calcul de magnitude ? car sur internet ils utilisent une ou l'autre constante.

Perso... je pense que la meilleure méthode c'est de prendre Véga qui à une magnitude de référence de 0.

Salut Hugues,

Là tu t'embarque dans un truc...
Car à moins d'avoir un appareil calibré dans l'espace pour moi c'est mission impossible.
Tu peux soit avec une astrométrie et photométrie différentielle calculer la magnitude d'un astre par rapport à un astre connu.
Soit calculer les luminosités de tes étoiles en "ADU".

D'accord avec Téca, c'est impossible avec nos instruments trop difficiles à calibrer.
Véga a une mag de 0,03 je crois (vu quand je synchro Véga)) mais impossible de prendre comme référence la constante stellaire qui ne marche vraiment bien que pour les mesures de galaxies.

Normalement la magnitude absolue se calcule sous 10 arcsec... Mais le souci... je n'ai aucune distance entre la terre et l'astre et impossible à évaluer avec des images d'apn... Il n'y a que le fits qui contiennent les informations sur la position sur la terre.

Mais là, il me manque encore toutes les informations de l'instrument pour les calculs...

En plus les bases de données des astres font plusieurs giga... donc impossible à mettre avec mon petit outil

Je vais donc devoir me limiter au calcul de la luminosité en me basant sur la luminosité du soleil pour le calcul de l'éclat(radiance) de mes étoiles. (pour le moment j'obtiens des informations comparables à stellarium).

En faisant çà, je pourrais calculer une magnitude absolue en me basant sur des unités astronomiques je pense... Mais pas certain

Et pour la distance ? Si je fais une équation sur le flux lumineux en prenant en compte la distance soleil - terre ? Est-ce qu'il est possible d'obtenir une constante utilisable ?

C'est trop imprécis (distance 150 millions de km en comparaison de +/-. 1500 AL).
Il te faudrait une constante à bcp trop de décimales pour espérer extrapoler .....
Tu obtiens les résultats de stellarium c'est cela qui est extraordinnaire ! ! ! ! ! !
Ton raisonnement est bon mais on n'a pas les outils ....

J'ai trouvé une solution pas trop mauvaise...

Pour le moment mes magnitudes sont bonne sur une image.

Voici mes formules (à voir si bon...)

Radiance de l'étoile :

IntensitéEtoile / (4 * Pi * (MoyenneRayonEtoile^2.0))

Constante de Stefan-Boltzmann :

5.670374 * 10.0^-8.0

Luminosité de l'étoile :

4.0 * Pi * ConstanteDeStefan * (MoyenneRayonEtoile^2.0) * RadianceEtoile^4.0

Luminosité du soleil :

-26.74

Magnitude de l'étoile :

100^(LuminositéSoleil - LuminositéEtoile) / 5.0

Voilà... Je sais pas si c'est la bonne solution mais j'ai beaucoup de magnitudes correspondantes sans prendre en compte la distance entre l'astre et la terre.

Vous en pensez quoi ?

Que je ne vais te répondre "comme cela" entre deux trois trucs et sur mon GSM... 
Il faut que je
- regarde ton application
- replonge dans la théorie... 
- car perso : plus vu cela depuis des lustres... 

Mais dès que j'ai le temps... 
Serge, t'en penses quoi ?

çà fonctionne pas

J'arrive à calculer correctement sur une image... Mais si je change d'image avec une autre focal :p

Owned !

Sans la distance de l'astre par rapport à la terre, je pourrais absolument rien faire

@Thierry: Je crois que ça ne peut pas marcher sans la vraie distance de l'étoile étudiée.
               Les constantes introduites pour la luminosité finale imposent des calculs à un grand nombre de décimales (dans la constante de Stefan l'exp-8 introduit 8 décimales de plus aux 6 déjà déterminées).
Bien-sûr le rapport distance étoile/distance Soleil efface pas mal de décimales mais la moindre erreur 
de distance fausse complètement le résultat. C'est pour cette raison que je ne comprends pas qu'on 
puisse arriver a un résultat cohérent avec nos instruments.
J'ajoute aussi que ça fait longtemps que j'ai étudié cette théorie et j'ai pas mal oublié. En plus la constante de Stefan-Boltzmann a changé tous les 20 ans….
@Hugues: Ton idée peut se défendre mais il est hors de question de déterminer la luminosité absolue 
                d'une étoile sans en connaître la distance. La technique de mesures différentielles donne 
de bons résultats (luminosité apparente) sauf qu'on ne peut pas en déduire la luminosité absolue sans
connaître son éloignement.
Or l'important c'est la mag absolue nécessaire à l'étude de la chimie de l'étoile, et ton idée de la chercher fait preuve d'une bonne démarche scientifique.

Coucou

Voici une mise à jour

Alors ...

- Correction du FWMH sur les images floues
- Ajout de la valeur HDF (Calcul de la largeur de l'étoile hors foyer cf : www005.upp.so-net.ne.jp/k_miyash/occ02/halffluxdiameter/halffluxdiameter_en.html )
- Début du codage d'une gestion des images (Gamma, Histogramme, ...) pour faire quelques modifications rapides au niveau des courbes, niveaux, ...
- Début de l'analyse d'un projet pour créer des filtres qui automatiquement supprimeront les fonds de ciel verts, ...)

Au fait l'affichage des 0.00 c'est temporaire... C'est parce que je travail en même temps sur un module qui fera l'astrométrie via nova.astrometry.net. Ce qui me permettra d'avoir les coordonnées des objets présent sur l'image et ensuite je pourrais extraire des index de nova les informations exactes des étoiles (magnitude).

Une fois que j'aurais la magnitude et les coordonnées galactiques, je pourrais faire pas mal de travaux sur la photométrie sans me prendre la tête.

Un nouveau point important, Maintenant mon outils calcul totalement le FWHM sur tous les 10° d'axe, ce qui me permet d'avoir une moyenne bien plus correcte.

Mon but :

J'aimerais que mon outil soit capable d'analyser les images et de faire un tri automatique sur celles-ci afin de ne plus devoir les visionner manuellement avant stacking

Voici les dernières images :







Je prends toujours les suggestions hein !

Faudrait déjà avoir le temps de te suivre...  
Surtout que perso, je suis sur trois projets à la fois 
(cours sur PL, certification IA, "santé à récupérer" )

Donc : pas le temps de creuser pour le moment... Je laisse la place à ceux qui ont (un peu) de temps libre pour voir cela de près...  Je me planifie du temps pour regarder ton travail en juillet-Aout   
Bon debugging...