BestesRauschsignal



  • Hi,

    ich durchsuche ein Rechteck mit Pixeln, und möchte das Signalrauschen
    also die Streuung möglichst bestens ermitteln, und verwende folgendes:

    float CDeepImage::Sigma32(const DWORD pMem,short x,short y,const short sw,const short sh)
    {
        #define SLOT 1
    	double Wight(0);
    	const short w(m_drv.GetWidth()<<2);
    	const short h(m_drv.GetHeight()<<2);
    	register DWORD off;
    	register int  pix1,pix2,pix3,pix4,pix5,pix6,pix7,pix8,pix9,xx,yy,cnt(0);
    
    	for(xx=x; xx < x+sw; xx+=SLOT)
    	for(yy=y; yy < y+sh; yy+=SLOT)
    	{
    		off = pMem+m_drv.Off(xx,yy);
    
    		pix1 = m_drv.GetBWpix(off);     // 0, 0
    		pix2 = m_drv.GetBWpix(off+w+4); // 1, 1
    		pix3 = m_drv.GetBWpix(off-w+4); // 1,-1
    		pix4 = m_drv.GetBWpix(off+4);   // 1, 0
    		pix5 = m_drv.GetBWpix(off-w+4); //-1, 1
    		pix6 = m_drv.GetBWpix(off-w-4); //-1,-1
    		pix7 = m_drv.GetBWpix(off-w);   //-1, 0
    		pix8 = m_drv.GetBWpix(off+w);   // 0, 1
    		pix9 = m_drv.GetBWpix(off-4);   // 0,-1
    
    		Wight += ((pix1-pix2) * (pix1-pix2) + (pix1-pix2) * (pix1-pix2)),
    		Wight += ((pix1-pix3) * (pix1-pix3) + (pix1-pix3) * (pix1-pix3)),
    		Wight += ((pix1-pix4) * (pix1-pix4) + (pix1-pix4) * (pix1-pix4)),
    		Wight += ((pix1-pix5) * (pix1-pix5) + (pix1-pix5) * (pix1-pix5)),
    		Wight += ((pix1-pix6) * (pix1-pix6) + (pix1-pix6) * (pix1-pix6)),
    		Wight += ((pix1-pix7) * (pix1-pix7) + (pix1-pix7) * (pix1-pix7)),
    		Wight += ((pix1-pix8) * (pix1-pix8) + (pix1-pix8) * (pix1-pix8)),
    		Wight += ((pix1-pix9) * (pix1-pix9) + (pix1-pix9) * (pix1-pix9));
    
    		cnt++;
    	}
    
    	return (100.0/(double)((cnt<<3)<<8)) * Wight;//(100 / cnt * 8 * 255)
    }
    

    Natürlich habe ich auch im Step 3 das Rechteck durchlaufen und erhalte minimal
    schlechtere Ergebnisse, auch die Wurzel aus den gewichten liefert kein besseres Signal, die Klassifizierung als histogram liefert ein sehr viel schlechteres Signal. Dennoch muss eine Optimierung möglichsein, aus der Kombination von Klassifiezierung und Wichtung.

    Danke für Hinweise
    K.



  • Um was fuer ein Bild handelt es sich und was soll darauf zu sehen sein? wie sieht dein Signalmodell aus?

    Die Differenz benachbarter Pixel zu benutzen, halte ich fuer fragwuerdig. Auch fliessen Pixel mehrfach ein, da sie eben mehr als 1 Nachbarn haben. Was spricht gegen Mittelwert und Varianz?

    Auch sind deine "Optimierungen" mittels Shift voelliger Quark, das sollte der Kompiler allein hinbekommen. Es verhunzt nur den Quelltext und macht ihn undurchsichtig. Gleiches gilt fuer register.

    Kombination von Klassifiezierung und Wichtung

    Ich sehe in deinem Quelltext weder Klassifizierung noch Gewichtung.

    auch im Step 3

    Ich sehe auch kein Schritt 3.



  • bei gleicher Helligkeit gibt es auch kein ungleiches Gewicht egal wie oft der selbe Pixel berechnet wird. Klassifizierung wurde verworfen, daher auch nicht zu sehen, der Code ist dann gut lesbar wenn man das Sprachmittel versteht. Die Speicherklasse Register steht nicht zur Debatte. Was für ein Bild es ist, ist gleichgültig. shiften geht immer schnelle als mullen .. usw.. ich glaube nicht das Du positiv bist.



  • Keine Ahnung, was du ueberhaupt willst. In unserer Firma wird Rauschen von Kameras wie folgt gemessen: Sequenz mit Bildern aufnehmen, Mittelwert und Varianz ueber jeden Pixel berechnen. Das bei schwarz, grau und fast weiss. Mittelwert fuer Fixed pattern noise und Varianz fuer alles andere.

    Klassifizierung wurde verworfen, daher auch nicht zu sehen

    Warum eraehnst du es dann?

    Was für ein Bild es ist, ist gleichgültig.

    Kommt auf das Problem an. Nein, du hast es noch nicht deutlich dargelegt. Leider hat mir visiongrid.do auch nicht geholfen.

    shiften geht immer schnelle als mullen

    Darum geht es nicht. Es geht darum, was der Kompiler draus macht. Eine Multiplikation mit 2er Potenzen ersetzt er schon durch shifts. Er kann noch viel mehr, beispielsweise bei Ganzzahlen eine Division mit einer Konstanten durch eine Multiplikation und Addition ersetzen. Machste ja auch nicht per Hand.

    Es gibt da noch mehr Mankos in deinem Quelltext, aber sei's drum.



  • knivil schrieb:

    Es gibt da noch mehr Mankos in deinem Quelltext, aber sei's drum.

    Da lach ich nur drüber, und schade das Diskusionen von solchen Hilfsschülern
    zunichte gefaselt werden, ohne auch nur im Hauch mit der Wirklichkeit zu schwelgen.

    Hier geht es darum im Rauschen ggf. Päärchen zu lokaliesieren oder andere Vorschläge zu machen die den SingSang der Pixel zu verstehen helfen.

    Das Signalrauschen ist nicht nur einfach der Abstand von jedem zu jedem.



  • Also du willst Stichworte fuer google wie unsupervised learning oder mustererkennung? Naja, ich habe mir gedacht, dass du so reagierst. Viel Spass noch, vielleicht findet sich noch jemand fuer dich. Wenn das Problem genauer beschrieben ist, schaue ich nochmal vorbei.



  • Das beste Rauschsignal sind erweiterte Pupillen!



  • kahn schrieb:

    Da lach ich nur drüber, und schade das Diskusionen von solchen Hilfsschülern zunichte gefaselt werden, ohne auch nur im Hauch mit der Wirklichkeit zu schwelgen.

    Hier geht es darum im Rauschen ggf. Päärchen zu lokaliesieren oder andere Vorschläge zu machen die den SingSang der Pixel zu verstehen helfen.

    Das Signalrauschen ist nicht nur einfach der Abstand von jedem zu jedem.

    Wer hier der Hilfsschüler ist, erkennt man deutlich an der Rechtschreibung.

    Es ist auch einfach peinlich derart über jmd. herzuziehen.



  • Hehe, der Zorn des Kahn!



  • @kahn
    Du klatscht uns ein Stück (ziemlich unsinnigen) Code hin, und willst jetzt wissen wie man es besser machen kann? Ohne auf die Frage antworten zu wollen was der Code überhaupt genau machen will/soll?
    Macht nicht so viel Sinn.

    Um zu beantworten wie man am besten die "Verrauschtheit" eines Signals berechnen könnte, muss man nunmal wissen was überhaupt als Rauschen anzusehen ist. Dein Code würde z.B. für ein Bild das einen einfachen, komplett "sauberen" Verlauf von Schwarz nach Weiss enthält einen deutlich von Null verschiedenen Wert berechnen. Ich glaube nicht dass das in deinem Sinn wäre, da so ein "sauberer" Verlauf ja nicht wirklich "verrauscht" ist.

    Also was genau ist das Rauschen das du messen willst? Alles oberhalb einer bestimmten Grenzfrequenz? Wenn ja dann brauchst du einen Hochpassfilter, und vom gefilterten Signal kannst du dann z.B. den RMS Wert nehmen.

    Oder gibt es Dinge die über das unverrauschte Bild bekannt sind, anhand derer man eine bessere Metrik für die Verrauschtheit des Signals finden könnte? Können wir ja nicht wissen, und du verrätst es uns nicht.

    Und für was muss der Wert den du Berechnen möchtest dann verwendbar sein? Spielt der absolute Wert eine Rolle? Muss er linear sein? Oder ist nur interessant ob er grösser bzw. kleiner als ein von der selben Funktion für ein anderes Bild berechneter Wert ist?



  • Und was die Kritik an deinem Code angeht: die ist durchaus berechtigt. register als Schlüsselwort wird nunmal von fast allen Compilern ignoriert, genau so wie quasi jeder Compiler schlau genug ist um die Multiplikation selbst durch nen Shift zu ersetzen.

    Und es ist irgendwie krass solche "Optimierungen" in einem Stück Code zu sehen, der daneben dann Zeilen wie diese enthält:

    Wight += ((pix1-pix2) * (pix1-pix2) + (pix1-pix2) * (pix1-pix2)),
    

    Wenn du dem Compiler nicht zutraust so einfache Optimierungen wie die oben Beschriebene (mul -> shift) zu machen, wieso verlässt du dich dann darauf dass er Teilausdrücke wie das hier doppelt vorhandene (pix1-pix2) * (pix1-pix2) wegoptimieren kann?
    Mal ganz davon abgesehen dass es total sinnfrei ist, da du das selbe erreichen kannst indem du nach der Schleife durch 1024 statt durch 2048 dividierst.

    ps:

    return (100.0/(double)((cnt<<3)<<8)) * Wight;//(100 / cnt * 8 * 255)
    

    255 != 256 und "weight" schreibt man mit e.


Log in to reply