www.astronomieforum.at

Hallo nebuloes!
Anbei noch ein Screenshot wie das Entfernen der Sterne funktionieren kann
am linearen Einzelbild. Das Prinzip ist aber für gestreckte und gestackte Bilder ähnlich.
http://www.werbeagentur.org/oldwexi/fot ... script.jpg
Links oben das Einzelbild
Links unten das sternbefreite Bild mit Prozess Historie.

Im Schritt 1 wird das Original mit dem Script "LargescaleStructureEnhance" in die
"kurzwelligen" und "langwelligen" Komponenten geteilt (SSView und LSView)
Aus dem SSView wird nachdem "LinearFit" von SSView auf LSView sichergestellt dass beide
gleich hell sind. (nicht unbedingt notwendig, erleichtert aber das Erstellen der RangeMask/Sternenmaske)

Mit dem Prozess "RangeMask" wird aus der Luminanz des SSVIEW eine Sternenmaske erzeugt.
Diese Sternenmaske wird über die Kopie des Originales (sanstars) gelegt und dann werden mit "PixelMath"
einfach in die Sternlücken unter der Maske die korrespondierenden Daten aus dem LSView
ins sanstars kopiert. Das ist der Hauptteil der Vorgangsweise.Die Sternenlöcher werden mit den geglätteten
Daten aus dem LSView gefüllt.

Zur kosmetischen Verbesserung wird eine reduzierte Maske (range_mask1) des Kometenkopfes mit RangeMask erzeugt.
Mithilfe dieser Maske wird vom Original der Kometenkopf ins sansstar reinkopiert
um sicher zu gehen dass nach der PixelMath Aktion keine Artefakte im Kometen entstehen.

Wie schon früher erwähnt "it depends" wie das Bild beisammen ist, das Prinzip sollte gaber immer
ähnlich sein im wesentlichen ändern sich aber nur die Reglereinstellung beim RangeMask Prozess.

Natürlich kann ich erst mit Deinen echten Daten feststellen was bisher aus dem Ruder gelaufen ist
obwohl, für mich ist es sensationell wie schnell Du Dich mit der Software vertraut gemacht hast.

Mostschädel hat geschrieben: obwohl, für mich ist es sensationell wie schnell Du Dich mit der Software vertraut gemacht hast.

Danke - ich hatte Hilfe
Das Kompliment geht an dich zurück !

###
Alles andere später - sonst werf ich noch auf der Stelle der ganze Astro Krempel mit Stumpf und Stiel zum Fenster raus !!!
(siehe voriges posting)

Hallo Heiko!
Das Schöne an PixInsight ist u.a. auch dass laufend neue Werzeuge entwickelt bzw.
bestehende erweitert werden.
So gerade geschehen mit dem "CometAlignment" Modul.
D.h. das Rausrechnen des Kometen aus dem "nur" Sternenbild ist jetzt im Prozess unterstützt.

Siehe im PixInsight Forum diesen Link:
http://pixinsight.com/forum/index.php?t ... 8#msg53248

Auf Seite 1 dieses Threads im PI-Forum steht auch der Link zum Runterladen der neuen Version.
Achtung dieser *.dll File muss nach dem simplen Download in den /bin Directory von PI kopiert werden.

Hallo Gerald,

Vielen Dank für Deinen Workflow und Screenshot.
Immer wieder bin ich perplex, welche Wege Du beschreitest.
Aber so vom Lesen her klingt es klasse. Ich hätte mir da wieder einen abgefriemelt.
Besonders interessant finde ich die Wege, die Du gehst um Masken zu erzeugen.

Super Dein Tip mit dem Comet Align Module.
Ich muß ohnehin noch die neueste PI-Version installieren. Bin nur zu faul, weil ich die ganzen Scripts dann wieder neu laden muß.
Dann werde ich mir das Comet Align Module mal genauer ansehen.

Welchen Link muß ich für den Download nutzen?
"Sources code for PI 1.8.3 PCL2.00.13.0689"?
oder
"Bin v.1.2.1.0001"?

Letzteren denke ich.

Ja, neue Werkzeuge gibt es immer wieder. Drauf stoßen tue ich immer erst, wenn Du mich mit der Nase drauf stößt.
Ich lese einfach zu wenig im PI-Forum.

@nebuloes

Ich kann mich Gerald nur anschließen. Es ist beeindruckend, wie schnell Du Ratschläge in PI umsetzen kannst.
Ich tue mich da wesentlich schwerer und muß mehrmals nachfragen.
Mit viel Geduld wird es aber.

Liebe Grüße
Heiko

Sorry ich hinke hinterher.

Mostschädel hat geschrieben:Hallo nebuloes!
Anbei noch ein Screenshot wie das Entfernen der Sterne funktionieren kann
am linearen Einzelbild. Das Prinzip ist aber für gestreckte und gestackte Bilder ähnlich.
http://www.werbeagentur.org/oldwexi/fot ... script.jpg
Links oben das Einzelbild
Links unten das sternbefreite Bild mit Prozess Historie.


Im Schritt 1 wird das Original mit dem Script "LargescaleStructureEnhance" in die
"kurzwelligen" und "langwelligen" Komponenten geteilt (SSView und LSView)
Aus dem SSView wird nachdem "LinearFit" von SSView auf LSView sichergestellt dass beide
gleich hell sind. (nicht unbedingt notwendig, erleichtert aber das Erstellen der RangeMask/Sternenmaske)

Ah, so geht das mit der feinen Klinge - nicht so grob geprügelt wie mit meinem WaveletLayer Ansatz!

Das LargeScaleStructureEnhance Script habe ich hier gefunden - ich hoffe es gibt nicht schon irgendwoaders einen neuere Version?
http://www.qdigital-astro.com/pixinsigh ... re-enhance

Die "Installation" des script hat auch einigermassen geklappt und vor allem -es funktionert super.

Die Übertragung / Angleichung der Helligkeit von zwei Bilder mittels LinearFit ist ein lässiger Trick. Danke.
http://pixinsight.com/forum/index.php?topic=2302.0

So weit so gut.

Mostschädel hat geschrieben: Mit dem Prozess "RangeMask" wird aus der Luminanz des SSVIEW eine Sternenmaske erzeugt.
Diese Sternenmaske wird über die Kopie des Originales (sanstars) gelegt und dann werden mit "PixelMath"
einfach in die Sternlücken unter der Maske die korrespondierenden Daten aus dem LSView
ins sanstars kopiert. Das ist der Hauptteil der Vorgangsweise.Die Sternenlöcher werden mit den geglätteten
Daten aus dem LSView gefüllt.

Zur kosmetischen Verbesserung wird eine reduzierte Maske (range_mask1) des Kometenkopfes mit RangeMask erzeugt.
Mithilfe dieser Maske wird vom Original der Kometenkopf ins sansstar reinkopiert
um sicher zu gehen dass nach der PixelMath Aktion keine Artefakte im Kometen entstehen.

Nicht so gut ist erstens dass ich das PixelMath zum maskierten übereinanderlegen nicht auf die Reihe bekomme - ich bin einfach eine mathematische Null äh ich meine - mathematisch eine Null


Habe mit Addition Multiplikation und Min Max in verschiedener Konfiguration samt "*($M)" etc mein Glück versucht, - aber den geglätten Hintergrund des LSView in die Löcher giessen - das habe ich noch nicht heraussen.
Muss ich wohl noch ein paar tutorials schauen und länger im PixelMath stöbern

https://pixinsight.com/doc/legacy/LE/22 ... tml#010407
http://pixinsight.com/forum/index.php?topic=1684.0


Das zweite Problem mit dem ich kämpfe ist, dass der glatte Hintergrund des LSView gar so glatt dann doch nicht ist wenn ich mit stretchen näher hinschaue:



Melde mich dann wieder, wenn ich was sinnvolles weitergebracht haben sollte

klausbaerbel hat geschrieben:
@nebuloes

Ich kann mich Gerald nur anschließen. Es ist beeindruckend, wie schnell Du Ratschläge in PI umsetzen kannst.
Ich tue mich da wesentlich schwerer und muß mehrmals nachfragen.
Mit viel Geduld wird es aber.

Danke für die aufmunternden Worte !

nebuloes hat geschrieben:

Nicht so gut ist erstens dass ich das PixelMath zum maskierten übereinanderlegen nicht auf die Reihe bekomme - ich bin einfach eine mathematische Null äh ich meine - mathematisch eine Null


Habe mit Addition Multiplikation und Min Max in verschiedener Konfiguration samt "*($M)" etc mein Glück versucht, - aber den geglätten Hintergrund des LSView in die Löcher giessen - das habe ich noch nicht heraussen.
Muss ich wohl noch ein paar tutorials schauen und länger im PixelMath stöbern

https://pixinsight.com/doc/legacy/LE/22 ... tml#010407
http://pixinsight.com/forum/index.php?topic=1684.0

Hätte ich gleich am richtigen Platz geschaut, hätt ichs mir einfacher gemacht:
https://dl.dropboxusercontent.com/u/579 ... tionen.wmv



Warum muss aber auch unbedingt grad das "iff" in der Reterenz nicht enthalten sein?
https://pixinsight.com/doc/legacy/LE/22 ... tml#010407


Noch a bissal tuning an den Masken - dann könnts schon hinhauen
schau mer mal

Hallo zusammen,

Den Pixelmathbefehl "*($M)" kenne ich garnicht. Google hat nichts dazu zu sagen.
Wofür steht der Befehl?

Liebe Grüße
Heiko

klausbaerbel hat geschrieben:Hallo zusammen,

Den Pixelmathbefehl "*($M)" kenne ich garnicht. Google hat nichts dazu zu sagen.
Wofür steht der Befehl?

Liebe Grüße
Heiko

Im Prinzip inkludiert es die Maske, so eine vorhanden ist.
Allerdings muss man aufpassen, dass bei der Ausführung das maskierte Bild auch jenes ist welches aktuell ausgewählt ist - sonst gibts eine Fehlermeldung

In the case of PixelMath, you can use the target image's mask with the $M (or $mask) metasymbol. For example, the following expression:

$T*$M

will multiply the target image by its current mask, or will yield a runtime error if there's no mask selected for the target image. Note that if the mask is currently enabled, the result of the above expression will also be masked. If the mask is disabled, the result will be the plain multiplication (possibly rescaled if the rescale result PixelMath option is enabled).

http://pixinsight.com/forum/index.php?topic=1684.0

nebuloes hat geschrieben: Noch a bissal tuning an den Masken - dann könnts schon hinhauen
schau mer mal

Mit DIESER Maske hauts nun hin:



Und das sogar in einem Rutsch

Habe meinen "groben Prügel" des "ExtractWavletLayer" Skriptes aus dem pulldown von Image Analysis in verfeinerter Form angewendet.
Diese Maske kombiniert mit dem Tip zum "LargeScaleStructureEnhance" erhält nun die feinen Struktiren des Schweif und trotzdem werden sogar Sterne im Halo des Kometen noch sauber unterdrückt.

Die Maske hat mich allerdings ziemliche Zeit und Neven gekostet.

Hallo nebuloes!
Danke für Deine Daten.
Anbei ein Link zum Screenshot der ersten Schritte nach dem Comet Align dass Du ja schon drauf hast.

Wie schon früher erwähnt ist es notwendig, um die Sigma Clipping Wirkung zu verbessern
sicherzustellen dass die Sterne von einem Bild zum Anderen weit genug auseinander stehen
damit bei der Integration das Sigma Clipping sie auch als "Ablehnbar" erkennt.
Dass habe ich so gemacht dass ich Deine 29 Bilder in 7 Gruppen zu jeweils 5 Bilder
unterteilt habe. Also zuerst Bild 17,24,31,38,45 dann 18,25,32,39,45(!) etc....
Der Screenshot zeigt die Bearbeitung der ersten Gruppe, alle anderen Gruppen werden dann analog
genauso bearbeitet mit minimalen Abweichungen bei den Reglern.(Ausprobieren)

http://www.werbeagentur.org/oldwexi/fot ... tAlign.jpg

Also alles beginnt im Bild von Links und geht nach Rechts.
Zuerst der Prozess ImageIntegration mit seinen Einstellungen. Beachte dass die Sigma Einstellungen
stark reduziert wurden um mehr Clipping zu erreichen. Auch hier machte ich einige Versuche
die zeigten ab wann der Komet angegriffen wird - so bin ich auf die Werte gekommen die aber
auf alle Gruppen passen.
Das Ergebnis ist das Bild (integration6) links oben an dem noch einige Sternüberbleibsel der größeren Sterne
sichtbar sind. Die Image Integration liefert aber auch noch ein Bild der abgelehnten Pixel (rejection_high6) !!

Dieses machen wir uns zunutze um es als Maske auszubauen. Wir strecken dieses Bild zuerst mit RangeSelection
und erzeugen daraus das rechts befindliche range_mask Bild. Hier sehen wir besser was alles rejected wurde.
Mit einem weiteren RangeSelection reduzieren wir dieses Bild (range_mask) auf die wesentlichen Teile und zeichnen
sie auch etwas weicher, Ergebnis range_mask1 weiter rechts. Die dazugehörigen RangeSelection Parameter
stehen immer unterhalb zwischen den Bildern, das ProzessIcon in der Mitte darüber.

Nun legen wir range_mask1 als Maske über das Bild integration6
Mit CurvesTransformation, siehe rechts daneben, reduzieren wir die Reststerne auf einen
Wert der weit unterm Median liegt. Vorsicht beim Reduzieren dass nicht im Schweif dunkle Scheibchen
entstehen! Das darüber befindliche Bild (integration6_clone) zeigt das Ergebnis.

Mit dem PixelMath Ausdruck med($T) wird mehrfach im noch immer maskierten Bild
der Wert dieser dunklen Scheibchen SChritt für Schritt auf den Medianwert des aktuellen Bildes
angehoben.
Im Prozess Container links oben sieht man dass ich es 7x gemacht habe.
Warum so oft - die Maske ist ja relativ dunkel daher wird nicht alles sofort
erhellt und ich kann aufhören wenn ich der Meinung bin das Maximum erreicht zu haben.
Ganz rechts sieht man dann das Ergebnis integration6_clone1.

Das wiederhole ich jetzt für alle restlichen 6 Gruppen
die Prozesse mit Ihren Parametern hebe ich neben den Bildern immer auf
damit ich nicht jedes Mal alles neu erfinden muss.
Am Schluss werden die 7 Gruppenbilder nochmals mit ImageIntegration summiert.

Ich hoffe das hilft

Vielleicht interessiert den Vorgang der Maskenerstellung mittels ExtractWavletLayer ja wen.

Der Grundgedanke ist simpel:
Wavelet Analyse ist eine super Sache wenn es darum geht "ortsfeste Frequenzen" zu bestimmen.
Dh dass damit Kontrast bzw. Helligkeitsgradienten aufgedröselt werden können.
Auf je kürzerem Weg sich die Helligkeit stark ändert umso höher die "Frequenz".
Sterne sind darin ja Weltmeister - auf wenigen Pixeln andert sich die Helligkeit extrem.
Nebel und Kometenschweif und Halo weisen nur tiefe "Frequenzen" auf - dh der Kontrast/ Helligkeitsgradient ist gering.

Das Tool ExtractWavletLayer kann nun Frequenzbereiche in Bilder umsetzen bzw aus dem Ausgangsbild jene Anteile herausziehen welche ähnliche Helligkeitsgradienten aufweisen.
Ja nach Anzahl der generierten Layer sind die Bereiche feiner oder weniger fein aufgelöst.

Wenn man dann nur jene Layer für die Maske heranzieht, welche hohe Gradienten herausgezogen haben, dann kommt man auf diesem Wege zu einer relativ perfekten Sternenmaske.



- Das Bild aus welchem die Sterne entfernt werden sollen zuerst mit STF stretchen und per HistogramTransformation eine permanente Kopie erstellen.

- in PixelMath mit CIEL($T) eine Luninanzbild generieren

- ExtractWaveletLayer mit 10 Leveln am Luninanzbild durchführen




- in PixelMath mit max(layer00,layer01,layer02,layer03,layer04) aus den höherfrequenten Anteilen eine Rohmaske generieren




- in PixelMath mit iif($T>0.6,0,1) die Rohmaske hart auf schwarz/ weiss clippen

- mit Convolution die Maskierungen etwas vergrössern




- in PixelMath mit iif($T>0.99,1,0) die vergrösserte Maskierung hart auf schwarz/ weiss clippen




- fertige Maske auflegen und checken

Hallo nebuloes!
Deine Fortschritte sind bemerkenswert - Heute ein Paar Stunden noch PI Deinerseits
und dann kann ich schon von Dir lernen...

Gratuliere zu Deiner Idee und zu Deinem Verständnis des PI Werkzeugkastens.

Mostschädel hat geschrieben: Ich hoffe das hilft

Also wenn mir das nicht hilft, ist mir auch nicht mehr zu helfen !!!
Recht recht herzlichen Dank für die viele Arbeit die du dir damit gemacht hast.

Ich muss mich da allerdings erst bis zum Ende durchwurschteln.

Die Maskierung habe ich für mich nun als abgehakt beiseite gelegt - aber das säubern des Bildes in welchem die Steren entfernt wurden steht noch aus - bzw eben das säubern jenes Bildes, aus welchem der Hintergrund anstelle der Sterne eingefügt wird.

Hallo Heiko!
Ja, der Fortschritt des nebuloes ist wirklich bemerkenswert!

Zu Deiner Frage von wo ist das neue Modul(!!!) CometAlign herunterzuladen?
Es ist auf dem separaten speziellen Server der PI Group

http://endor.uv.es/files/data/public/cee73c.php?lang=en

Der obige Link plus Information zum Modul stehen im Forum -
Daher siehe:
http://pixinsight.com/forum/index.php?t ... 8#msg27348

Das Modul gehört dann in Deinen C:/Programme/PixInsight/bin Ordner kopiert.(das alte CometAlign Modul
sollte schon drinnen sein).

Mostschädel hat geschrieben: ... ein Paar Stunden noch PI Deinerseits
und dann kann ich schon von Dir lernen...

Oho
Das glaub ich dann doch nicht, aber Danke für die Ermunterung !

nebuloes hat geschrieben:Vielleicht interessiert den Vorgang der Maskenerstellung mittels ExtractWavletLayer ja wen.

Aber sicher tut es das.

Vor Allem, weil es ein ganz anderer und eleganterer Weg ist eine Maske (per Pixelmath) zu erzeugen, als ich es mache.

Aber eine Frage zu der Maske. Ich kenne es so, daß die Maske eher weiche Übergaänge haben sollte. Welchen Vorteil siehst Du darin, die Übergänge so hart zu gestalten?

Den Rest muß ich mir jetzt erstmal eine Weile in Ruhe ansehen und ausprobieren.

Liebe Grüße
Heiko

Das harte clipping braucht es damit die Maske - für das Entfernen der Sterne - überhaupt zu 100% abdeckt/ freistellt.
Für fliessende Übergänge kann man dann immer noch die Ränder etwas weichzeichnen (ich habe damit noch nicht gestackt, weiss daher also noch nicht, ob bzw wieviel das eventuell bringt).

Habe ich jedoch von vorn herein nirgends - auch in der Mitte der Abdekcungen nicht - eine 100%ige Abdeckung bzw Freistellung, dann bleiben beim übertragen des mittels des "ExtractWavletLayer" Skriptes von Sternen befreiten Hintergrundes auf das Originalbild (das Bild MIT den Sternen), immer Reste der Sterne erhalten. Das gibt dann ein Geparden-Muster wie weiter vorn gezeigt

Derzeit habe ich "nur" noch das Prolem das mittels des "ExtractWavletLayer" Skriptes erzeugte sternbefreite Bild noch sauberer hinzubekommen.
Alle Artefakte (Stern Reststruktruren) im sternbefreiten Bild stammen bei mir leider daher - aber nicht mehr vom Vorgang an sich:



- rechts hinten ist das mittels des "ExtractWavletLayer" Skriptes von Sternen befreite Bild des Hintergrundes (hier zusätzlich mit "MorphologicalTransform" noch etwas nachgeglättet)
- in der Mitte das Originalbild mit Maske
- links vorne das von Sternen befreite Bild, bei welchem auch die feinen Strukturen im Schweif noch enthalten sind.


Zweifellos ist das alles noch optimierbar. (die letzten Tips von Gerald habe ich noch nicht durchgearbeitet)
Und hoffentlich irgendwann auch per script automatisierbar.

nebuloes hat geschrieben:Das harte clipping braucht es damit die Maske - für das Entfernen der Sterne - überhaupt zu 100% abdeckt/ freistellt.
Für fliessende Übergänge kann man dann immer noch die Ränder etwas weichzeichnen (ich habe damit noch nicht gestackt, weiss daher also noch nicht, ob bzw wieviel das eventuell bringt).

Habe ich jedoch von vorn herein nirgends - auch in der Mitte der Abdekcungen nicht - eine 100%ige Abdeckung bzw Freistellung, dann bleiben beim übertragen des mittels des "ExtractWavletLayer" Skriptes von Sternen befreiten Hintergrundes auf das Originalbild (das Bild MIT den Sternen), immer Reste der Sterne erhalten. Das gibt dann ein Geparden-Muster wie weiter vorn gezeigt

|

Ich habe mir Gestern mal ein Bild geschnappt und Sterne auf die beschriebene Art entfernt.
Also Maske aus den Layers erstellt und dann per med($T) die Sterne entfernt.

Durch das Einfügen des Medianwertes erhalte ich auch dieses Fleckenmuster, was sich dann noch bei weiterer Bearbeitung verstärkt. Die Sternbefreiten Stellen sind ja mit glattem Median aufgefüllt und enthalten kein Rauschmuster, wie die umliegenden Bereiche.

Ich hatte dann mal versucht mit NoiseGeneration diesen Bereichen ein Rauschmuster zu verpassen, was aber nicht so den gewünschten Effekt hatte.

Vielleicht hat Gerald dafür noch was in der Hinterhand.

Liebe Grüße
Heiko

Ja das ist ein Problem.

Man hat ja wenig Möglichkeiten einen "fake" Hintergrund über die Sterne zu legen - jedenfalls kenne ich bisher nur die folgenden Möglichkeiten (was ja nicht viel heissen mag)

1.) den Bild-Median hernehmen
2.) das MorphologicalTransform - welches "lokal" auf das selbe rausläuft
3.) den LargeScale Anteil aus "LargescaleStructureEnhance" hernehmen
4.) aus "ExtractWavletLayer" die tiefen Fequenzen hernehme was im Prinzip das selbe ist wie 3
5.) CloneStamp verwenden

Da alle Methoden von 1-4 einen mehr oder wenigen glatten - farblich mehr oder weniger angepassten Batzen hinterlassen, wäre mein dz Favorit das CloneStamp - bzw eine abgewandelte Form.

Irgendwie müsste es doch machbar sein, das Bild mit Maske mit dem Bild mit invertierter Maske zu überlagern. Genau das macht man doch beim manuellen CloneStamp und überträgt dabei sowohl die umgebenden Helligkeit als auch die Rauschstruktur.

Ich dachte dabei daran die beiden Bilder (Stern-maskiert und invertert maskiert) jeweils um einige Pixel zu verschieben und dann den naheliegenden Hintergrund zu übertragen.
Das ein paar mal im Kreis mit unterschiedlichen Abständen durchführen und nur die noch nicht "gestempelten" Bereiche jeweils ergänzen - ferddisch.

Hätte ich mir gedacht.

Leider steh ich was die Umsetzung anbelangt im Wald.
Habe zu "strukturiertem" CloneStamp bisher nichts gefunden.

Werde dazu noch etwas recherchieren - vielleicht finde ich noch was.

Im Prinzip liefe es darauf hinaus mittels PixelMath einen (bzw alle) Pixel um einen gewissen Bertrag zu verschieben und je nach Maske am Ziel abzulegen oder eben nicht.

Mal sehen.

Aller Anfang ist schwer


Aber der hier ist leicht:

pixel($T, xpos()+10,ypos())

Damit fange ich an - schau mer mal

Hallo nebuloes!
In dem Thread weiter oben gibt's den Hinweis auf das Script:
LargeScaleStructureEnhance.
Damit splittet man die kurzwelligen Strukturen und langwelligen Strukturen,
Das Bild mit den langwelligen Strukturen werden in dem obigen Beispiel als Füllung für die
Sternenlöcher verwendet. Sie sind ja aus den Umgebungspixeln erzeugt.

Median Füllung ist hier nicht unbedingt zielführend. Speziell im Schweif des Kometen entstehen
klarerweise dadurch Flecken.

Am Besten ist es natürlich, wie in meinem letzten Beispiel mit Prozessen und Parameter
gezeigt, die Sterne drinnen zu lassen auf den Kometen zu registrieren und diese
Bilder gruppenweise dann zu integrieren. Damit gehen die Sterne am Besten weg.
Und alles ohne Malen...

Danke für den Hinweis

Das mit dem "LargeScaleStructureEnhance" habe ich gesehen und auch probiert.
Das Problem dabei ist nur - wie bei den andern drei Einfüllmethoden - dass ein strukturloses Batzerl das Ergebnis ist.
Deshalb will ich noch versuchen dem Batzerl passende Struktur zu verpassen.

Wird auch eine gute Übung für PixelMath

Den Einstigspunkt (pixelweise bearbeitung) habe ich übrignes aus deinem suprigen Tutorial für "Plot/Display Profile of Image" - das habe ich mir dann gleich nachgeschrieben und abgespeichtert.

###

Ich habe versucht meinen Ansastz für die Sternenmaskenerzeugung per Wavelet Analyse zu automatisieren.
Ein script zu erstellen würde offenbar bedeuten, mich in Java programming einzulasssen zu müssen und das ist mir dann doch zu steil.
Oder gibt es da Vereinfahungen - zB weitgehendes copy & paste aus dem History explorer?

Am Makro / Prozesscontainer bin ich (hierfür) bislang ebenfalls gescheitert.
Einerseits weil "ExtractWaveletLayers" offenbar eine Analyse und keine Process Funktion/ Script ist - und andererseits weil sich der gesamte Vorgang ja nicht nur auf eine einziges Bild bezieht sondern etliche Zwischenbilder involbiert sind.

Hättest du dazu eventuell auch ein Rat?
Kann man zB Container in Containern zusammenfassen?

Das "StructuredCloneStamp" klappt nicht mal so schlecht:
Im Vordergrundbild ists - zum zeigen - noch nicht vollständig durchgeführt.





zuerst die Sterne stanzen, dann von allen vier Seiten her Pixel auffüllen.
Die simple PixelMath dazu:

Stene stanzen (nach Maske):
iif($T*($M) > 0.001, 0, $T)

Nach links verschobenes Bild generieren
pixel($T, xpos()+10,ypos())

Nach rechts verschobenes Bild generieren
pixel($T, xpos()-10,ypos())

Nach oben verschobenes Bild generieren
pixel($T, xpos(),ypos()+10)

Nach unten verschobenes Bild generieren
pixel($T, xpos(),ypos()-10)

gestanztes Loch von links her stopfen
iif ($T < 0.00001, left_shift10, $T)

gestanztes Loch von rechts her stopfen
iif ($T < 0.00001, right_shift10, $T)

gestanztes Loch von oben her stopfen
iif ($T < 0.00001, up_shift10, $T)

gestanztes Loch von unten her stopfen
iif ($T < 0.00001,down_shift10, $T)

etc


Das Hauptprblem dabei ist, dass ich im Halo des Kometen nicht automatisch "die richtigen" Pixel zum auffüllen hernehme (das würde man beim händischen Stempeln natürlich berücksichtigen bzw anders angehen) und andererseits dass der Hintergrund nicht völlig von Sternen befreit ist was dann dazu führt dass diese schwachen Sterne teilweise vervielfacht werden (auch das würde man beim händischen Stempeln natürlich berücksichtigen bzw anders angehen)

Das gute an der Methode ist allerdings, dass die lokale Rauschstruktur intakt bleibt.


Nach diesem Ausflug würde ich mir gerne noch eine Variante überlegen, das spezifische Rauschmuster eines Bildes zu extrahieren und auf ein LargeScale Gradientenbild aufzprägen.
Das wäre dann vielleicht das Beste aus beiden Welten.

Wollte noch das Löcher-auffüllen ewas verfeinern, indem ich wie beim Socken-stopfen jeweils nur eine Zeile von links und die nächste dann von rechts her einfülle.
Auf diese Weise könnte ich Artefaktebildung wahrscheinlich deutlich vermindern, vor allem wenn ich dieses Prinzip in mehrere Richtungen ausbaue.


Irgendwie habe ich aber beim PixelMath offenbar was grundlegendes nicht kapiert:

pixel($T, xpos()+10, ypos())
klappt bzw ersetzt mir ein pixel mit einem rechts danebenliegenden

Will ich nun "interleacen" - also nur in jeder zweiten Zeile mit einem rechts danebenliegenden Pixel ersetzen, hätte ich mir folgende Bedingung ausgedacht
pixel($T, iif(!frac(y/2), xpos()+10, xpos()),ypos())

Das scheint aber nicht zu klappen.
Offenbar hängt es mit meinem un-Verständnis von "pixel" und "y" zusammen.

Probehalber anstelle des "y" eine gerade oder ungerade Zahl eingesetzt - zB.: iif(!frac(9/2) - und alles klappt wie gewünscht.


Aus dem Help zu "y" und "pixel" im PixelMath werde ich einfach nicht schlau (genug). Aus der Fehlermeldung von "parse" leider auch nicht

nebuloes hat geschrieben:
Irgendwie habe ich aber beim PixelMath offenbar was grundlegendes nicht kapiert:

Hat sich erledigt



"y" durch "y()" ersetzt ( Variable ! ) und alles wie gewünscht.

Hallo nebuloes!

Ich bewundere absolut, wie Du Pixelmath versteht, bzw selber Formeln entwickeln kannst.
Das ist mit noch nie gelungen.

Dein Ansatz sieht auf jeden Fall sehr vielversprechend aus.
Die nächsten Tage bin ich unterwegs und werde danach auch mal ausprobieren, was Du da gemacht hast.

Mach bloß weiter so. Du bist verdammt schnell auf dem richtigen Weg.

Liebe Grüße
Heiko

Hallo nebuloes!
Ich habs ja weiter oben schon gesagt - der Zeitpunkt ab dem mir vor Staunen der Mund offen bleibt
kommt bald und er ist schon da!

Deine Idee die nicht vorhandenen Daten "hinter" den Sternen schrittweise von
außen nach innen mit "Noise" zu füllen ist genial und sicher die Ehrlichste.
Gratuliere auch zu Deiner PixelMath Lösung dazu. Die habe ich mir schon
in meinen "wiegehtdas" Sammlungs Ordner kopiert.

Möglicherweise ist eine Neuerstellung der Maske in etwas feinerer Form die Lösung
da ja Deine Sternderl eher klein sind d.h. viel viel kleiner als die jetzt verwendete Maske.
Auf die kleineren Sternderl der neuen Maske sollte die PixelMath Lösung die restlichen Artefakte verschwinden

lassen.

Ja, Process Container oder/und Prozesse kannst Du beliebig in den vorhandenen Process Container ziehen, verreihen
löschen etc. und damit in einem Container die Prozesse Sammlung (Macros) so arrangieren wie Du es gerne hättest.
Also vom History Explorer das blaue Dreieckerl auf den FREIEN Workspace ziehen. Das Icon dann anklicken
damit ist der Container offen und jetzt kannst Du Prozesse und Container in diesen hinein ziehen und dort

verschieben etc.

Ein Muster der kleineren Sternderlmaske erzeugt aus den kurzwelligen Resten des
LargeScaleStructureEnhance Script ist im Screenshot zu sehen.
http://www.werbeagentur.org/oldwexi/fotos/s.jpg
Also von links Oben das Original,
darunter das Resultat aus dem Script,
rechts daneben die mit RangeMask ums Rauschen reduzierte Sternenmaske.
Oberhalb davon das Resultat mit PixelMath den Wert Null eingesetzt.
Rechts davon die Löcher mit Med($T) aufgefüllt UND mit NoiseGenerator verrauscht.

Das StructuredCloneStamp scheint nicht sooo schlecht zu funktionieren:




http://www.kinotechnik.at/pages/astro/S ... eStamp.gif

Ich weiss nicht ob das relativ grosse animierte GIF hier klapppt - man muss auch etwas warten, am anfang tut sich wenig.
Es zeigt im Rücklauf wie es mit dem Stopfen der ausgestanzten Löcher klappt. Etwa 20 Einzelaktinen waren hier erforderlich um die relativ grosszügigen Löcher zu füllen.


Die PixelMath ist simpel und Macros per copy&paste in einer Minute erstellt
(einfach 4 oder 8 davon in unterschiedlicher Abfolge in einem Prozess Container zusammenfassen und diese dann mehrfach aufs maskierte Bild werfen):

pixel($T, iif(!frac(y()/2), xpos()+10, xpos()),ypos())
pixel($T, iif(!frac((y()+1)/2), xpos()-10, xpos()),ypos())
pixel($T, xpos(),iif(!frac((x())/2), ypos()-10, ypos()))
pixel($T, xpos(),iif(!frac((x()+1)/2), ypos()+10, ypos()))


Wäre sicher noch erheblich optimierbar, hier werden nur die vier Hauptrichtungen herangezogen.
Der proof liegt im Pudding - werde also jetzt mit dem stacking der verschiedenen Varianten probieren - hatte dazu noch keine Zeit

schau mer mal.