Laphroaig

Yep

Image bien nette

Avec sa longue focale le mak pour le planetaire est nikel

Non ce n'est pas une hérésie mais un grossissement à d/2, ça ne vole pas très haut quand même. Tout est une histoire de compromis...

Je parlais juste du chromatisme apres tu peux grossir plus suivant le seeing bien sur

tu verra plus clairement le chromatisme mais la resolution restera correcte jusqu'au grossiement Utile.

Suivant le seeing jusq'au grossissement utile aucun souci, après la resolution se degrade petit a petit.

Contrairement aux autres formule qui apparemment conserve une bonne résolution après le grossissement utile. (Normal vu le prix !)

J'ai une chinoise 70 / 900

et une 120 /1000

La 70 /900 lune et planète elle se défend très bien : pour le ciel profond c'est plus complique

Par contre la 120 / 1000 est plus encombrante mais ca reste en dessous de 5kg

En ciel profond elle se défend.

Une achro avec un F/D a 8,3 n'est pas une heresie du tout.

Pour le chromatisme ca dépend du grossissement à D/2 et un peu plus l'image est très correcte

Pour le décalage :

vu que c'est l'algo d'openCV je suppose qu'il doit faire un gaussien au vu du résultat

Le chromatisme disparait pres du bord

Mais derriere ca bave en bleu

D'ailleur je trouve l'image un peu flou

Pour le super_pixel :

Il pixelise normal mais garde bien les details quand meme

Mais possede un tres leger liseré bleu

Interpolation et Teinte :

Sur le lisere bleu : produise a peu pres les mêmes resultats.

mais je prefere l'interpolation de teinte.

Pour etayer voila une interpolation de teinte

avec un calcul de la balance des blancs automatique possible

Le vert sert de luminance et ensuite on calcul les rapport R/V et B/V

Le chromatisme bleu est encore mieux corrige.

Je trouve l'image de meilleure qualité aussi ...

Et vos avis

Info pour la prise : 70 image de lunes empilée,11 flats (15 darks et 15 offset) [Empilement avec mon programme]

Camera : 1280 * 960 - 3,75µm - Bayer RGGB

Lunette : 120 / 1000 achromatique

Image decoupe : 320 * 200 et (110 * 100 pour la SUPER_PIXEL)

Balance des blancs : effectuer sur Copernic

Luminosite exagerée bien sur

Interpretation a venir ...

Un peu déçu que ça motive personne : au moins ça peut me servir de journal de bord.

Avec tous les photographes present sur le forum, certain doivent connaitre les techniques de pre-traitrement de façon précise ....

Aujourd hui présentation des algorithmes de dé matriçage. En esperant en interessé

Merci a ce site d'ailleur pour les algos

http://www-iut.univ-lille1.fr/lp_vi/projets/2011_dematricage.pdf

je vais poster les resultats des differentes algos

- Décalage et copie des pixels.

- Interpolation avec les voisins.

- Le super pixel qui ne crée pas de nouvelles données mais reduit la resolution de 2

- Et la derniere qui est une interpolation de la teinte (rapport rouge / vert et bleu /vert)

Pour information la methode de décalage est celle de openCV

Les 3 autres mes petites mains ...

Un autre methode (j'ai oublie le nom)existe qui apparemment est celle qui a les meilleurs résultats.

Mais bien plus compliquer a mettre en oeuvre.

Rémi

Pour etayer sur une brute (capteur couleur) de la lune alpha = 2

Si vous avez des explications pour les carres noirs ? Je suppose que c'est le pixel bleu qui capte pas trop sur la lune ..?. Sur la resol native en 1280*960 en zoomant au max cela fait le meme damier accentuer par la miniature

Cela permet de detecter les zone lumineuse

Promis voila des images de mes resultat on verra si ca motive du monde

Pour le sigma clipping :

Reprenons la formule ValeurMedianeImage +/- ecartTypeImage * alpha

Apres un empilement median de 15 dark de 15sec

Donc voila le resultat des pixels qu'on peut ecarter suivant le alpha choisi pour donner une idee

alpha = 2

alpha = 5

alpha = 10

alpha = 20

Que fait on de ces pixels apres ?

Problematique du Dark Master apres calcul du BiasMaster :

- Enlever le bias master a chaque dark ou enlever le bias master uniquement au dark issu de l'empilement ?

- Une fois enlever le bias master du dark : des pixels peuvent etre legerement negatif .

Continuons le calcul avec ce leger negatif qui peut provoquer un leger positif plus tard.

Ou remettons à 0 ces pixels ?

- Pour le sigma clipping voila la formule merci au site :

https://www.gnu.org/software/gnuastro/manual/html_node/Sigma-clipping.html

Calculate the mean, standard deviation (σ) and median (m) of a distribution.

Remove all points that are smaller or larger than m±ασ.

Que fait t - on de ses pixels ecartees par la suite pour trouver leur bonne valeur

- Et derniere question comment effectuer l'empilement des darks ? Median moyen ou autre ?

J'essairai d'apporter des images pour le sigma clipping ca motivera des gens peut etre

Rémi

N'ayant pas de réponse pour le Dark Master

J'ai developper un decodeur pour lire un fichier texte qui permmetra de constuire la chaine de traitement est de l'executer

Plus besoin de recompiler ...

Voila un exemple

#Operation_______Output__________Affect_____Classe______________input__________parametres

CHAIN__________BiasMaster_______=_______ChainBiasMaster_____INPUT/OFFSET/

CHAIN__________DarkMaster_______= ______ChainDarkMaster_____INPUT/DARK/ __________BiasMaster,EMPILEMENT_MEDIAN

CHAIN_________ FlatMaster________= ______ChainFlatMaster_____ INPUT/FLAT/__________BiasMaster,DarkMaster,1.0

OPER__________ShowFlat__________= ______ShowImage__________FlatMaster__________title,0,65535

EXEC__________BiasMaster

EXEC__________DarkMaster

EXEC__________FlatMaster

EXEC__________ShowFlat

[ Pour une meilleur visibilite "_" = espace autant qu on veut]

Cet exemple :

Chaine BiasMaster => classe utilise ChainBiasMaster et input : dossier contenant la liste des bias

Chaine DarkMaster=> classe utilise ChainDarkMaster, input :dossier contenant la liste des darks

et parametres biasMiaster(resultat ci dessus) et l'empilement souhaite

Chaine FlatMaster=> classe utilise ChainFlatMaster, input :dossier contenant la liste des flats

et parametres biasMiaster et darkMaster(resultat ci dessus) et niveau de normalisation (1.0)

Oper ShowFlat => classe utilise ShowImage, permettra de visualiser une image input : FlatMaster (resultat ci dessus) parametre : titre fenetre et niveau de normalisation affichage en unsigned int 16bits

Mon interpreteur jusqu'a la n'aura fait que constuire la chaine

Pas grand chose sera prix en memoire

Chaque execution chargera les inputs pour calculer l output

Si un operateur est constuit avec un output declare APRES cela posera un probleme bien sur

Ou si l'operateur est executé avant le calcul de l'output utilise.

Donc a l'execution

Voila pour l'exec de la premiere chaine BiasMaster

1/ Chargement list images Bias

2/ Calcul Bias Master

3/ Dechargement des images bias plus necessaire pour la suite

Idem pour FlatMaster et DarkMaster c'est pareil a part que leurs parametres leur permet de recuperer les résultats precedents

La derniere execution permet visualiser le flat en ayant reetaler sur 0 65535

Merci pour ceux qui ont eu le courage

En esperant avoir des réponses

desolé pour le pavé

Je trouve opencv assez performant y a pas mal de "C" derrière.

Et au vu de la reputation du "C" ...

Apres j'ai deja vu des super truc en java : par exemple ImageJ

J'utilise pas le GPU ... je me suis jamais penché sur ce genre de programmation pour le traitement d'image

Par contre a une époque lointaine en utilisant OpenGL pour la 3D, j'utilisais le GPU

Je mixe C/C++

Pour les acces fichier j'ai prefere optimiser en C avec des fread et fwrite malloc et tout le bordel ...

En tout cas si tu as des idée mathematique pour le dark master

Je veux bien les coder

Bonjour,

Cela fait 2/3 semaines que je développe un Programme sous windows en C/C++ avec openCV permettant de faire le pré-traitrement de manière automatique.

J'ai pas trouvé de methodes assez detaillée

Une idée detaillé pour calculer biasMaster, darkMaster, et flatMaster ?

Voila le topo de l'etat de mon programme :

Bias Master : Pour le moment je fait simple, mais je pense que pour le biasMaster il faut

Moyenne des bias (ou Median au choix)

Dark Master : Pour le moment je fait simple : je suis un peu pommer ...

pour le sigma/clipper chepas quoi : j'ai calcule esperance, variance et eType de mes images

Soustraction du BiasMaster

Constuction du Dark Master par la moyenne ou median (au choix) des darks

Flat Master : Je pense que pour ce calcul je suis bien (Merci Fred_76 et Eric S)

Soustraction Bias Master et DarkFlatMaster

Trouver le niveau Median des flats et normaliser au niveau Median

Constuction du Flat Master par la valeur mediane des flats

Traitement Brutes :

Soustraction BiasMaster et FlatMaster

et division par le FlatMaster

Construction Image Finale : Recalage image -> Moyenne des brutes traites -> Bayer Image Couleur

Pour Recaler l'image :

methode de translation, grace a un template (découpage d'un bout de l'image qui servira de reference)

Pour Bayer : je pense que opencv fait une interpolation basique

(il faudra que je la fasse moi meme

pour ca j'ai trouvé des méthodes, le super pixel peut être sympa d'ailleurs ... )

Pour le calcul des biasMaster, darkMaster et flatMaster :

Toutes la pile d'images(flats,darks,bias) est stockée en RAM et liberer juste apres le calcul

Pour la chaine de traitement des brutes (Problematique de taille)

2 possibilités :

"-" 500Mo de brute : Chargement de toutes les brutes en RAM et execution de la chaine (optimal)

"+" 500Mo de brute : Ou écriture des résultat temporaires (plus lent mais aucune problematique de taille)

Le but final est de pouvoir constuire une chaine de traitement automatique en ligne de commande.

A terme les Avantages

- Possibilite d'avoir un calcul rapide si les données brutes ne depasse pas une certaine taille

- Faire une chaine de traitement spécifique avec par ex application d'un empilement Median ou Moyen

- Empiler plusieurs chaines de traitement : les exécuter et aller au lit et avoir de la place sur le disque dur

- Des outils nous permettant de sauvegarder des résultats pour les visualiser ou éviter de recalculer

A terme les inconvenients

- Pas d interface graphique permettant de visualiser les donnees temporaire stockees lors du calcul

- Programme sous windows : Systeme de creation d'arborescence coder pour windows (à porter ...)

- C/C++ non portable : Mes compilations sont sous windows 64bits

- Lors de l'execution, impossibilité d'interagir : il faudra executer plusieur programme

- Lecture uniquement de Fits 8 - 16 bits : je pourrait etendre a d'autre format libre (.dng ? . ? ...)

Bien sur mon code est disponible pour ceux qui le souhaite

Merci a ceux qui ont eu le courage de lire

Et merci au réponses futur

Je mettrai a jour sur fil au fur et a mesure de mes avancées.

Rémi

Oui pareil je l'ai découvert il y a quelques jours.

Je le trouve très complet,et assez puissant aussi il gère la debayerisation

mais le problème il ne lit pas mes .fit

Ok ca revient a la methode 2 (plus compliqué )

A part que tu fixes le niveau de normalisation automatiquement (pas forcement bête)

Le darkMaster et le biasMaster je reviendrai sur ca apres

J'ai codé la methode 2 en fixant moi meme le niveau de normalisation

Par Contre quand je fait pretraitre(brute) / flat_Master

Je peux faire ce que je veux a la sortie pour le reequilbrage

1 er cas

Ou je remonte tout les pixels avec moins de sensibilité

En considerant le max

En clair les max du flat ne changeront pas dans la brute

2eme cas

Ou si je prend la median de mon flat

Et dans ce cas la les pixels de la brute qui sont au median de mon flat ne changeront pas de valeur

et ceux en dessous je rehausserai leur intensite

et ceux au dessus je baisserai leur intensité

Voila mon petit probleme

---------------- Ajouter-------------

OK excuse Eric je viens de comprendre tu es pour le deuxieme cas

Tu prend la moyenne et plus la mediane aussi : c'est du détail mais je peux aller dans ce sens

------------------------------------

Autre question

Comment vous faites un bias Master ?

Normaliser les bias ? Median comme flat ?

Quand tu dit Brute - darkM -offsetM : le darkMaster ne contient pas l'offset ?

Après je m'occuperai du dark master sans sigma/clipping

Et encore après si je suis pas degouter du dark master du sigma/clipping

Voila si vous avez du temps a perdre

Merci Eric

PS : je donne acces a mon code sans aucun probleme

Pour ceux qui le souhaite et qui s'y connaisse : Attention les controles sont minimalistes !

Pour les raws je lit que les .fits 8 et 16 bits 2D

les dependances : openCV et compilateur C (ca fonctionne sous windows)

Pour normaliser il me faut une borne min et une borne max de toute façon

Donc deux solution possibles

Prenons 1000 comme valeur de normalisation

La facon simple : 1000 est le maximum apres normalisation

borneMin = minImage / maxImage * 1000

borneMax = 1000

Facon plus complique : 1000 est le niveau Moyen

borneMin = minImage / medianImage * 1000

borneMax = maxImage / medianImage * 1000

Dans le second cas si on prend 1 comme valeur de normalisation

On va se retrouver avec des valeurs superieure a 1.

Lors de la division des brutes par le flatMaster ca aura tendance a baisser l'intensite des pixels les plus sensible ? (et vice versa) ...

C'est ca l'idée ...

Excusez moi ca fait longtemps ... j

Je reprend ce que dit fred

La méthode utilisée par Iris est de calculer l'intensité médiane de chaque image de flat (prétraitée après retrait de l'offset et du dark maître) et de normaliser chaque image à un niveau commun (par exemple 1000). Une fois cette opération faite, le flat maître est obtenu en prenant pour chaque pixel la médiane des pixels correspondants des images individuelles. Si tu calcules ton flat maître en réel et non en nombre entier, tu peux normaliser à 1.

J'essaie de resumer pour voir si j'ai compris ...

Soit N : le niveau commun choisi (1000 dans ton exemple)

Et une image I1 avec une intensite Mediane M1

Est ce que cela veut dire que les pixels égal a M1 dans l'image I1

apres normalisation auront pris la valeur N ?

Ou

Est ce que la valeur N est la valeur Maximale après normalisation ?

Ou

rien compris et aucun des deux

Merci d'avance

PS : Sur la doc iris rentre pas trop dans le detail

Toute ma chaine de traitement est faite sur des flottants 32bits

Je viens faire l'operateur Median

Sur 11 flats avec pour résolution 1280 * 960

Moins de 6 secs ça reste correct.

Sur le calcul de la médiane, comme elle est calculée pixel par pixel, on pourrait se contenter de charger en mémoire un seul pixel de chaque image à la fois. Je pense aussi qu'il existe un algorithme itératif permettant de ne charger qu'une image à la fois (ou peut-être deux pour conserver l'histoire de nombre impair).

Ce n'est pas nécessaire toutes les images sont en RAM

Pour la normalisation tu as raison je m'embrouille ...

Car c'est sur que si j’étale de 0 a 1 ca va pas aller

Mais merci je vais regarder la doc Iris

Merci beaucoup Fred pour l'aide

Ok

J'étale sur la dynamique commune entre 0 et 1 c'est tres bien d'ailleurs

Et après faut que je code intelligemment cette médiane qui va être couteuse.

D'ou pourquoi on dit de prendre toujours un nombre impair d'image.

Pour le offset Master : faut il normaliser aussi de la même façon ?

Meme question pour le Dark Master ?

Je suppose que pour le Dark Master ca sera forcement plus compliqué

Je me met sur cette fameuse mediane.

Faire un "sort" sur chaque pixel ca va faire mal.

Je vais faire un rangement par dichotomie je pense que ça sera mieux ...

Merci encore pour tes réponses Fred

PS:

Je devrais peut être renommer le sujet, mais je sais pas si c'est possible.

C est réglé j'inversais les octets.

Je peux lire des fits sur 16bits qui contiennent des informations uniquement sur 12 bits

Pour les compiler sous windows c'est le bordel

Je vais mettre peut être plus de temps a compilé cette satanée librairie qu a coder le décodeur

Surtout que c'est pas si complique a lire les .fits

mais je doit avoir un cast qui me met dedans ... les 16bits sont signées dans les fits.

Je vais me replonger dessus aujourd'hui

Peut etre que ma donnée est corrompu

Une question normaliser les flats entres eux ...

Cela consite a prendre le minimum et maximum global des flats

Et étaler tous les flats sur la dynamique [minGlobal - maxGlobal] ?

Rémi

Désolé pour l'orhographe ...

J'ai déjà regardé les spécifications sur le site je lis très bien l'entête

Mais j'ai un problème au chargement des data 16 bits

Le fait que les données soient signées m’embête je pense

Si flat, dark offsset master sont deja calculé

Traiter a la volée image par image avec visualisation comme un film ça devrait être faisable (tout dépend de la taille de la matrice bien sur et du rafraichissement)

Le probleme c'est que c'est du C/C++ donc il faut le recompiler sur ta machine

Autant mon code que la lib openCV

Chez moi tout est compiler en 64bits.

Donc deja il faudra installer compilateur C/C++ et compiler OpenCV.

Je peux t'aider

Pour faire des setups j'ai pas les outils pour ...

Mon code sera beaucoup moins complique à compiler

C'est vraiment le bordel tout ces formats raw ...

Fit, cr2, dng, ...

Pas beaucoup de soft lise bien le fit

Et je n'arrive pas a decoder ces satanée FIT 16 bits contrairement aux 8 bits

Je comprend pas la matrice de données

Si qqu un un a une idée ...

Bon pour ce que ca interesse

Voila l'idée pour le gain de performance

-------------------------ATTENTION CODE-------------------------------

/// Calcul Alignement

AlignementOperator *align = new AlignementOperator(pileImagesBrute,new AlignementParameters(new DataPile<OPENCV_IMAGE>(templateMat)));

/// dark Master

EmpilementOperator *darkMaster = new EmpilementOperator(pileImagesDark);

/// Offset Master

EmpilementOperator *offsetMaster= new EmpilementOperator(pileImagesOffset);

/// Flat Master

EmpilementOperator *flatMaster = new EmpilementOperator(pileImagesFlat);

/// brute - darkMaster : ecrasement pileImageBrute

SupprOperator *preTreat1= new SupprOperator(pileImagesBrute,new SupprParameters(darkMaster->getOutput()));

/// flatMaster - offsetMaster : ecrasement flatMaster

SupprOperator *preTreat2 = new SupprOperator(flatMaster->getOutput(),new SupprParameters(offsetMaster->getOutput()));

/// brute - darkMaster / flatMaster - offsetMaster : ecrasement pileImageBrute

NormaliseOperator *preTreat3 = new NormaliseOperator (preTreat1->getOutput(),new NormaliseOperator (preTreat2->getOutput()));

/// Recalage effectif : ecrasement pileImageBrute

RecalageOperator *recalage = new RecalageOperator(align->getOutput(),new RecalageParameters(pileImagesBrute));

/// empilement

EmpilementOperator *empilement = new EmpilementOperator(recalage->getOutput());

empilement->addListenerShow(); //visualisation resultat

empilement->addListenerWrite(); // ecriture resultat

/// Kmeans

//SplitRegionChain *splitRegion=new SplitRegionChain(empilement->getOutput(),9);

/// Construction Chaine

ChainAndromede<OPENCV_IMAGE,OPENCV_IMAGE> *chain = new ChainAndromede<OPENCV_IMAGE,OPENCV_IMAGE>(pileImagesBrute,new Parameters());

chain->addOperatorAndromede(align);

chain->addOperatorAndromede(darkMaster);

chain->addOperatorAndromede(offsetMaster);

chain->addOperatorAndromede(flatMaster);

chain->addOperatorAndromede(preTreat1);

chain->addOperatorAndromede(preTreat2);

chain->addOperatorAndromede(preTreat3);

chain->addOperatorAndromede(recalage);

chain->addOperatorAndromede(empilement);

// EXECUTION DE TOUTE LA CHAINE

chain->exec();

--------------------------------------------------

Allocation en RAM de toutes les images brutes, flat, offset et dark

Ca peut faire mal au PC

Si probleme

On Pourrait optimiser pour faire pas a pas ... ca serait plus intelligent d'ailleurs

Chargement Darks => calcul Dark Master => Vidange des Darks : on conserve que le dark Master

et ainsi de suite ...

Par contre toutes les brutes devront etre en RAM

Voila en esperant pas pollué

J'ai pu faire des test sur la lune pour la methode d'alignement uniquement en translation

Ca fonctionne tres bien avec ma focale et ma camera, sur une duree assez courte

En plus j'ai pas de suivi. Donc pour le moment je vais m'en contenter.

Rémi

Merci beaucoup de vos reponses Eric et fred

Je vois bien que le Dark Master est pas si simple.

Pour l'alignement pour le moment j'ai laisse tombé.

J'ai galerer aujourd'hui a extraire la matrice dans les .fits pourtant pas si compliqué

Et encore j'ai fait que les 8 bits

PS2 : en fait, ça m'intéresserait un programme qui puisse effectuer rapidement le pré-traitement d'une image éventuellement en s'arrêtant avant le dématriçage. On peut imaginer que les offset, dark et flat maîtres sont calculés à l'avance. Ça serait pour utiliser depuis mes logiciels avant de faire des calculs astrométriques à la volée.

Oui c'est le but ultime ca.

Mais j y suis pas encore.

Pour le moment je veux faire la chaine (sans alignement et empilement final) avec les données Raws.

Sans trop m'occuper des problematiques du Darks

Ensuite je repasserai aux Dark surtout ...

Mais le cote median, FFT ca fait exploser le calcul, ca c'est sur

Recoder un programme plus simple que d'utiliser iris...

 

Faut pas déconner quand même. A part si ça te fait plaisir de passer du temps là dessus, je ne vois pas l'intérêt.

 

....

Par contre Benjamin ton intervention n'est pas tres sympa et pas tres constructive.

Si tu veux tu peux passer ton chemin ...

Mais je vais quand meme te repondre

Etant au chomage, et developpeur informatique avec des competence en traitement d'image et ayant recu une cam ... le chemin etait tout tracé ...

Le but n'est pas de remplacer iris, je n'ai pas cette pretention ....

Mais comme Eric a compris si une partie du pretraitement peut etre plus rapide ca peut etre sympa

Je pense que le pretraitement Dark Offset Flat et Brute est faisable...

wait and see

Rémi

Ok je vois le probleme pour l'alignement

Je perfectionnerai ca avec le temps

Pour le moment avec ma cam(1280 * 960) et ma focale de 1000mm, je pense que la translation suffira Par contre pour le grand champ pas la peine

Par contre j'ai plein d'autre boulot.

Normaliser FLAT entre eux

Se repencher sur le DarkMaster

Lire les image raw dans le .fit, je galere un peu d'ailleurs

Optimiser Iris oula la je sais pas

Iris est un tres bon logiciel de traitement d'images astronomie avec un visualiseur et beaucoup d'outils permettant de corriger des artefacts

Pas le plus performant, mais assez fiable et tres exhaustif.

Son choix a ete de faire du "pas à pas" pour etre plus rigoureux.

Moi c'est uniquement un programme qui prend en

ENTREE: brutes, flats, offsets, darks

SORTIE: Image finale

Ma chaine de traitement est statique. Le resultat intermediaire n'est pas stockée. Donc l'interpretation du resultat intermediaire par l'operateur ne peut avoir lieu.

Le seul avantage de mon programme par rapport a Iris ne peut etre que la performance avec le defaut de ne pas pouvoir interagir pendant l'execution de la chaine.

Ayant des competences en traitement d'image moi j'utilise d'autres logiciels avec des operateurs primaires.