johner.org: Applet

1. Schritt: Konvertierung in Graustufen

Dies ist nötig, da die Rückprojektion nur graustufen Bilder konvertieren kann. Der folgende Code wird dies veranschaulichen.

private void convertToByte(int[] pixels32) throws InterruptedException {

		int c, r, g, b;
		
		//convert to grayscale

		double rw=1d/3d, gw=1d/3d, bw=1d/3d;

		for (int i=0; i < this.width*this.height; i++) {

			c = pixels32[i];
			r = (c&0xff0000)>>16;

			g = (c&0xff00)>>8;
			b = c&0xff;

			data[i] = (byte)(r*rw + g*gw + b*bw + 0.5);

		}

	}

2. Schritt: Verbessern der Signal-zu-Rausch-Werten

Dies geschieht, in dem ein geradenhaftes Nutsignal s(x) gegenüber dem Hintergrundbild n(x) verstärkt wird. Nutsignale können zum Beispiel Linien sein, die in dem Bild auf einer bestimmten Ebene angesiedelt sind. Dadurch können zum Beispiel Bugwellen von einem Schiff gegenüber der Meeresoberfläche verstärkt werden.

Xcenter = inputimgsize / 2;
Ycenter = inputimgsize / 2;

y = (int) Math.round(a*x + b);

weight = Math.abs((a*x + b) - Math.ceil(a*x + b));

                            
if (y >= -Xcenter && y+1 < Xcenter )

   val += (1-weight) * pix[(x+Xcenter)][(y+Ycenter)]

             + weight * pix[(x+Xcenter)][(y+Ycenter+1)];

3. Schritt: Anwenden einer Punkt-Operation

Auf das vorhandene Bild, das lauter Linien zeigt, wird eine Punktoperation angewendet.

public static void FFT(int dir, int s, double[] x,double[] y) {

        int n, i, i1, j, k, i2, l, l1, l2;

        double c1, c2, tx, ty, t1, t2, u1, u2, z;

        int m = (int) (Math.log(s)/Math.log(2));

        double[] spectrum = new double[s];
        
        /* Calculate the number of points */

        n = 1;
        for (i=0;i<m;i++)

            n *= 2;
        
        /* Do the bit reversal */
        i2 = n >> 1;

        j = 0;
        for (i=0;i<n-1;i++) {

            if (i < j) {
                tx = x[i];

                ty = y[i];
                x[i] = x[j];

                y[i] = y[j];
                x[j] = tx;

                y[j] = ty;
            }
            k = i2;

            while (k <= j) {
                j -= k;

                k >>= 1;
            }
            j += k;

        }
        
        /* Compute the FFT */
        c1 = -1.0;
        c2 = 0.0;

        l2 = 1;
        for (l=0;l<m;l++) {

            l1 = l2;
            l2 <<= 1;
            u1 = 1.0;

            u2 = 0.0;
            for (j=0;j<l1;j++) {

                for (i=j;i<n;i+=l2) {

                    i1 = i + l1;
                    t1 = u1 * x[i1] - u2 * y[i1];

                    t2 = u1 * y[i1] + u2 * x[i1];

                    x[i1] = x[i] - t1;

                    y[i1] = y[i] - t2;

                    x[i] += t1;
                    y[i] += t2;

                }
                z =  u1 * c1 - u2 * c2;

                u2 = u1 * c2 + u2 * c1;

                u1 = z;
            }
            c2 = Math.sqrt((1.0 - c1) / 2.0);

            if (dir == 1)
                c2 = -c2;

            c1 = Math.sqrt((1.0 + c1) / 2.0);

        }
        
        /* Scaling for forward transform */
        if (dir == 1) {

            for (i=0;i<n;i++) {
                x[i] /= n;

                y[i] /= n;
                
            }
            
        }

        
}

4. Schritt: Rekonstruktion des Bildes

Dies geschieht mit folgendem Code:

for (phi=ang1;phi<ang2;phi=phi+stepsize){

                        pos = (x1 * sintab[i] - y1 * costab[i]);

                        
                        //perform linear interpolation
                        if (pos>=0){
                            a = (int)Math.floor(pos/scale);

                            int b = a + scans/2;
                            if (b<scans-1 && b>0){

                                val = val +  fprojection[i][b] + (fprojection[i][b+1]

                                        - fprojection[i][b])
                                        * (pos/scale-(double)a);

                            }
                        } else if (pos<0){
                            a = (int)Math.floor(pos/scale);

                            int b = a + scans/2;
                            if (b<scans-1 && b>0){

                                val = val + fprojection[i][b] + (fprojection[i][b]

                                        - fprojection[i][b+1])
                                        * (Math.abs(pos/scale) - Math.abs(a));

                            }
                        }
                    }
                    i++;
}

To view this content, you need to install Java from java.com

Sie haben sich nun alle Algorithmen, die auf dieser Seite verfügbar sind, angesehen. Überprüfen Sie Ihr Wissen in unserem >Quiz