Example usage for org.apache.commons.math.complex Complex Complex

List of usage examples for org.apache.commons.math.complex Complex Complex

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.math.complex.*
  5. Complex
  6. Complex

Introduction

In this page you can find the example usage for org.apache.commons.math.complex Complex Complex.

Prototype

public Complex(double real, double imaginary)

Source Link

Document

Create a complex number given the real and imaginary parts.

Usage

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

/**
 * Robi filtr dolnoprzepustowy. Tworzy kwadrat, na Fourierze, ktrego bok
 * jest odlegy od rodka o distanceFromCenter
 *
 * @param distanceFromCenter// www .j av a 2s .co  m
 */
public void computeLowPassFilter(int radius, int circleCenterX, int circleCenterY) {
    fourierImage = FourierProc.changeImageQuadrants(fourierImage);
    if (isCircleInImage(radius, circleCenterX, circleCenterY)) {
        for (int x = 0; x < imageWidth; x++) {
            for (int y = 0; y < imageHeight; y++) {
                if (computeDistance(circleCenterX, circleCenterY, x, y) > radius) {
                    fourierImage[x][y] = new Complex(0, 0);
                }
            }
        }
    }
    fourierImage = FourierProc.changeImageQuadrants(fourierImage);
}

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

/**
 *
 * @param distanceFromCenterExternal - zewntrzny kwadrat
 * @param distanceFromCenterInternal - wewntrzny kwadrat
 *///www.  ja  v a  2  s .  co  m
public void computeBandPassFilter(int radiusExternal, int radiusInternal, int circleCenterX,
        int circleCenterY) {
    fourierImage = FourierProc.changeImageQuadrants(fourierImage);
    if (isCircleInImage(radiusExternal, circleCenterX, circleCenterY)
            && isCircleInImage(radiusInternal, circleCenterX, circleCenterY)) {

        for (int x = 0; x < imageWidth; x++) {
            for (int y = 0; y < imageHeight; y++) {
                if (x == imageWidth / 2 && y == imageHeight / 2) {
                    continue;
                }
                if (computeDistance(circleCenterX, circleCenterY, x, y) > radiusExternal) {
                    fourierImage[x][y] = new Complex(0, 0);
                } else if (computeDistance(circleCenterX, circleCenterY, x, y) < radiusInternal) {
                    fourierImage[x][y] = new Complex(0, 0);
                }
            }
        }
    }
    fourierImage = FourierProc.changeImageQuadrants(fourierImage);
}

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

public void computeEdgeDetectionFilter(int radiusExternal, int radiusInternal, int circleCenterX,
        int circleCenterY, double alpha1, double alpha2) {
    fourierImage = FourierProc.changeImageQuadrants(fourierImage);
    if (isCircleInImage(radiusExternal, circleCenterX, circleCenterY)
            && isCircleInImage(radiusInternal, circleCenterX, circleCenterY)) {
        for (int x = 0; x < imageWidth; x++) {
            for (int y = 0; y < imageHeight; y++) {
                if (x == imageWidth / 2 && y == imageHeight / 2) {
                    continue;
                }/*from  w ww  .  ja va2 s  .  c o m*/
                if (computeDistance(circleCenterX, circleCenterY, x, y) > radiusExternal) {
                    fourierImage[x][y] = new Complex(0, 0);
                } else if (computeDistance(circleCenterX, circleCenterY, x, y) < radiusInternal) {
                    fourierImage[x][y] = new Complex(0, 0);
                } else {
                    //Tutaj wycinanie tych kawakw
                    //obliczamy x do ktrego trzeba
                    double px = x - imageWidth / 2;
                    double py = y - imageHeight / 2;
                    double d = Math.sqrt(px * px + py * py);
                    px /= d;
                    py /= d;
                    double aRad1 = Math.toRadians(alpha1);
                    double aRad2 = Math.toRadians(alpha2);
                    double a = Math.atan2(-py, -px) + Math.PI;
                    double a2 = Math.atan2(py, px) + Math.PI;
                    if ((aRad1 <= a && a <= aRad2) || (aRad1 <= a2 && a2 <= aRad2)) {
                        fourierImage[x][y] = new Complex(0, 0);
                    }
                }
            }
        }
    }
    fourierImage = FourierProc.changeImageQuadrants(fourierImage);
}

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

public void computeFourierPhaseModificationFilter(int k, int l) {

    for (int n = 0; n < imageWidth; n++) {
        for (int m = 0; m < imageHeight; m++) {
            double real = Math.cos((-n * k * 2 * Math.PI / (double) imageWidth)
                    + (-m * l * 2 * Math.PI / (double) imageHeight) + (k + l) * Math.PI);
            double img = -Math.sin((-n * k * 2 * Math.PI / (double) imageWidth)
                    + (-m * l * 2 * Math.PI / (double) imageHeight) + (k + l) * Math.PI);
            fourierImage[n][m] = fourierImage[n][m].multiply(new Complex(real, img));
        }//from w  w  w .j  a v a  2  s  . c om
    }
}

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

public void computeDFT() {

    int N = imageWidth;
    int M = imageHeight;
    int counter = 1;
    for (int x = 0; x < imageHeight; x++) {
        for (int y = 0; y < imageWidth; y++) {

            double[] t = new double[1];
            double imageValue = image.getRaster().getPixel(x, y, t)[0];
            double realValue = 0;
            double imaginaryValue = 0;
            for (int k = 0; k < N; k++) {
                for (int l = 0; l < M; l++) {
                    realValue += imageValue * Math.cos(((2.0 * Math.PI * (double) k * (double) x)
                            + (2.0 * Math.PI * (double) l * (double) y)) / N);
                    imaginaryValue += imageValue * (-Math.sin(((2.0 * Math.PI * (double) k * (double) x)
                            + (2.0 * Math.PI * (double) l * (double) y)) / N));
                }//w  ww  . j  a  va 2 s.  com
            }
            fourierImage[x][y] = new Complex(realValue, imaginaryValue);
            System.out.println(counter + " of " + (M * N));
            counter++;
        }
    }

}

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

private Complex[] computeDIFForOneDimension(Complex[] pixelTable) {
    int bits = 9;
    double N = pixelTable.length;

    Complex[] transformedSignal = new Complex[(int) N];

    for (int i = 0; i < transformedSignal.length; i++) {
        transformedSignal[i] = new Complex(0.0, 0.0);
    }//from www.ja va  2 s  .c  o m

    Complex signalTab[] = new Complex[(int) N];
    Complex[] localTR = new Complex[(int) N];
    int index = 0;
    for (int i = 0; i < pixelTable.length; i++) {
        signalTab[index] = new Complex(pixelTable[i].getReal(), pixelTable[i].getImaginary());
        index++;
    }

    index = 0;
    for (Complex cv : signalTab) {
        //            System.out.println("x(" + index + ") = " + cv.getReal() + " IM: i" + cv.getImaginary());
        index++;
    }
    //Zmienna okrelajca na jakiej wielkoci ma operowa na tablicy
    int part = 2;
    //Ptla okrelajca cykl przechodzenia, przez kolejne kolumny 
    for (int iteration = 1; iteration <= bits; iteration++) {
        //            System.out.println("PART "+part);
        //Ile razy ma si wykona
        for (int i = 0; i < part; i += 2) {

            int r = 0;
            for (int actualIndex = (signalTab.length / part) * i, counter = 0; counter < signalTab.length
                    / part; counter++, actualIndex++) {
                int secondIndex = (actualIndex + (signalTab.length / part));
                Complex a = signalTab[actualIndex].add(signalTab[secondIndex]);
                Complex b = signalTab[actualIndex].subtract(signalTab[secondIndex]);
                Complex W = new Complex(Math.cos((2.0 * Math.PI * r) / N), -Math.sin((2.0 * Math.PI * r) / N));
                b = b.multiply(W);
                signalTab[actualIndex] = a;
                signalTab[secondIndex] = b;
                r += part - (part / 2);
            }
        }
        part += part;
    }

    localTR[0] = signalTab[0];
    localTR[localTR.length - 1] = signalTab[signalTab.length - 1];
    for (int i = 1; i < signalTab.length - 1; i++) {
        String bitIndex = Integer.toBinaryString(i);
        if (bitIndex.length() < bits) {
            while (bitIndex.length() < bits) {
                bitIndex = "0" + bitIndex;
            }
        }
        char[] tab = bitIndex.toCharArray();

        for (int j = 0; j < tab.length / 2; j++) {
            char temp = tab[j];
            tab[j] = tab[tab.length - j - 1];
            tab[tab.length - j - 1] = temp;
        }
        bitIndex = new String(tab);
        localTR[Integer.parseInt(bitIndex, 2)] = signalTab[i];
    }
    for (int i = 0; i < localTR.length; i++) {
        transformedSignal[i] = new Complex(localTR[i].getReal(), localTR[i].getImaginary());
    }
    return transformedSignal;
}

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

private Complex[] computeInverseDIFForOneDimension(Complex[] pixelTable) {
    int bits = 9;
    double N = pixelTable.length;

    Complex[] transformedSignal = new Complex[(int) N];

    for (int i = 0; i < transformedSignal.length; i++) {
        transformedSignal[i] = new Complex(0.0, 0.0);
    }/*from   w ww  .  j av a  2 s. c  om*/

    Complex signalTab[] = new Complex[(int) N];
    Complex[] localTR = new Complex[(int) N];
    int index = 0;
    for (int i = 0; i < pixelTable.length; i++) {
        signalTab[index] = new Complex(pixelTable[i].getReal(), pixelTable[i].getImaginary());
        index++;
    }

    index = 0;
    for (Complex cv : signalTab) {
        //            System.out.println("x(" + index + ") = " + cv.getReal() + " IM: i" + cv.getImaginary());
        index++;
    }
    //Zmienna okrelajca na jakiej wielkoci ma operowa na tablicy
    int part = 2;
    //Ptla okrelajca cykl przechodzenia, przez kolejne kolumny 
    for (int iteration = 1; iteration <= bits; iteration++) {
        //            System.out.println("PART "+part);
        //Ile razy ma si wykona
        for (int i = 0; i < part; i += 2) {

            int r = 0;
            for (int actualIndex = (signalTab.length / part) * i, counter = 0; counter < signalTab.length
                    / part; counter++, actualIndex++) {
                int secondIndex = (actualIndex + (signalTab.length / part));
                Complex a = signalTab[actualIndex].add(signalTab[secondIndex]);
                Complex b = signalTab[actualIndex].subtract(signalTab[secondIndex]);
                Complex W = new Complex(Math.cos((2.0 * Math.PI * r) / N), Math.sin((2.0 * Math.PI * r) / N));
                b = b.multiply(W);
                signalTab[actualIndex] = a;
                signalTab[secondIndex] = b;
                r += part - (part / 2);
            }
        }
        part += part;
    }

    localTR[0] = signalTab[0];
    localTR[localTR.length - 1] = signalTab[signalTab.length - 1];
    for (int i = 1; i < signalTab.length - 1; i++) {
        String bitIndex = Integer.toBinaryString(i);
        if (bitIndex.length() < bits) {
            while (bitIndex.length() < bits) {
                bitIndex = "0" + bitIndex;
            }
        }
        char[] tab = bitIndex.toCharArray();

        for (int j = 0; j < tab.length / 2; j++) {
            char temp = tab[j];
            tab[j] = tab[tab.length - j - 1];
            tab[tab.length - j - 1] = temp;
        }
        bitIndex = new String(tab);
        localTR[Integer.parseInt(bitIndex, 2)] = signalTab[i];
    }
    for (int i = 0; i < localTR.length; i++) {
        transformedSignal[i] = new Complex(localTR[i].getReal() / N, localTR[i].getImaginary() / N);
    }
    return transformedSignal;
}

From source file:pl.dp.bz.poid.fouriertest.FourierProc.java

private Complex[] inverseDFT(Complex[] tab) {
    double N = 256;
    double[] realSamples = new double[tab.length];
    double[] imaginarySamples = new double[tab.length];
    Complex[] returnTable = new Complex[tab.length];
    for (int i = 0; i < tab.length; i++) {
        realSamples[i] = tab[i].getReal();
        imaginarySamples[i] = tab[i].getImaginary();
    }/*from   w ww. j  a  v a  2s.  c  o m*/

    double realValue = 0;
    double imaginaryValue = 0;
    for (double n = 0; n < N; n++) {
        realValue = 0;
        imaginaryValue = 0;
        for (int m = 0; m < N; m++) {
            realValue += realSamples[m] * Math.cos((2.0 * Math.PI * (double) m * n) / N);
            realValue += imaginarySamples[m] * Math.sin((2.0 * Math.PI * (double) m * n) / N);
            imaginaryValue += realSamples[m] * Math.sin((2.0 * Math.PI * (double) m * n) / N);
            imaginaryValue -= imaginarySamples[m] * Math.cos((2.0 * Math.PI * (double) m * n) / N);
        }
        //            System.out.println("Con: "+con+" z "+(int)N*2+" pixel "+n+" z "+(int)N+" : "+realValue+" "+imaginaryValue);
        returnTable[(int) n] = new Complex(realValue / (N), imaginaryValue / (N));
    }
    con++;
    return returnTable;
}

From source file:pl.dpbz.poid.zadanie4.filter.SOIFilterEqualizer.java

@Override
public void computeFilter() {
    Double[] eqResp = new Double[(int) N];
    outputSignal = new Double[samplesCount];
    for (int i = 0; i < outputSignal.length; i++) {
        outputSignal[i] = 0.0;// w ww. j  a va2s  .co  m
    }
    Complex[] signalTab;
    Complex[] resultOfChangingAmplitude;
    resultsOfFilterOperations.clear();
    double frequencyResolution = SAMPLING_FREQUENCY / N;
    List<SoundSignal> signals = new ArrayList<>(signalWindows);

    for (int i = 0; i < eqResp.length; i++) {
        eqResp[i] = 0.0;
    }

    for (int equalizerSlide = 0; equalizerSlide < equalizer.getSliders().size(); equalizerSlide++) {
        int leftSide = (int) ((equalizer.getSliders().get(equalizerSlide).getLeftSideOfFrequencies() * N)
                / SAMPLING_FREQUENCY);
        int rightSide = (int) ((equalizer.getSliders().get(equalizerSlide).getRightSideOfFrequencies() * N)
                / SAMPLING_FREQUENCY);
        double edge = 0;
        if (equalizer.getSliders().get(equalizerSlide).getEdge() >= 1) {
            edge = equalizer.getSliders().get(equalizerSlide).getEdge();
        } else {
            edge = 1.0 / Math.abs(equalizer.getSliders().get(equalizerSlide).getEdge());
        }
        //                    System.out.println(leftSide + " " + rightSide + " " + edge);
        for (int spectrumIndex = leftSide; spectrumIndex < rightSide; spectrumIndex++) {
            eqResp[spectrumIndex] = new Double(edge);
            eqResp[eqResp.length - spectrumIndex - 1] = new Double(edge);
        }
    }
    ChartDrawer.drawChart(eqResp, "Equalizer");
    for (int windowIndex = 0; windowIndex < signalWindows.size(); windowIndex++) {
        signalTab = new Complex[signals.get(windowIndex).getSamples().size()];
        //            System.out.println(signalTab.length);
        for (int sampleIndex = 0; sampleIndex < signalTab.length; sampleIndex++) {
            signalTab[sampleIndex] = new Complex(signals.get(windowIndex).getSamples().get(sampleIndex), 0.0);
        }
        signalTab = Fourier.computeFastFourier(signalTab, bits);

        resultOfChangingAmplitude = new Complex[signalTab.length];
        for (int i = 0; i < resultOfChangingAmplitude.length; i++) {
            resultOfChangingAmplitude[i] = new Complex(0, 0);
        }
        for (int i = 0; i < resultOfChangingAmplitude.length; i++) {
            resultOfChangingAmplitude[i] = signalTab[i].multiply(eqResp[i]);
        }
        if (windowIndex == signalWindows.size() / 2) {
            ChartDrawer.drawChart(signalTab, "Signal before");
            ChartDrawer.drawChart(resultOfChangingAmplitude, "Window spectrum after");
        }
        resultOfChangingAmplitude = Fourier.computeInverseFastFourier(resultOfChangingAmplitude, bits);
        if (windowIndex == signalWindows.size() / 2) {
            ChartDrawer.drawFromChart(resultOfChangingAmplitude, "Window after inverse");
        }
        Double[] d = new Double[resultOfChangingAmplitude.length];
        for (int i = 0; i < d.length; i++) {
            d[i] = resultOfChangingAmplitude[i].getReal();
        }
        resultsOfFilterOperations.add(d);
    }
    System.out.println("Kocowka dodaj");
    for (int i = 0; i < resultsOfFilterOperations.size(); i++) {
        System.out.println((i + 1) + " Elem " + (i * R));
        addElems((int) (i * R), resultsOfFilterOperations.get(i), outputSignal);
    }
}

From source file:pl.dpbz.poid.zadanie4.filter.SOIFilterSpectrum.java

@Override
public void computeFilter() {
    System.out.println("Samples count " + samplesCount);
    outputSignal = new Double[samplesCount];
    for (int i = 0; i < outputSignal.length; i++) {
        outputSignal[i] = 0.0;//w  ww  .j  a v  a 2s  .co  m
    }
    Complex[] signalTab;
    Complex[] impulseResponseComplex = new Complex[impulseResponse.size()];
    Complex[] resultOfMultiplication;
    resultsOfFilterOperations.clear();
    for (int i = 0; i < impulseResponse.size(); i++) {
        impulseResponseComplex[i] = new Complex(impulseResponse.get(i), 0.0);
    }
    impulseResponseComplex = Fourier.computeFastFourier(impulseResponseComplex, bits);

    for (int windowIndex = 0; windowIndex < signalWindows.size(); windowIndex++) {
        signalTab = new Complex[signalWindows.get(windowIndex).getSamples().size()];
        //            System.out.println(signalTab.length);
        for (int sampleIndex = 0; sampleIndex < signalTab.length; sampleIndex++) {
            signalTab[sampleIndex] = new Complex(signalWindows.get(windowIndex).getSamples().get(sampleIndex),
                    0.0);
        }
        signalTab = Fourier.computeFastFourier(signalTab, bits);

        resultOfMultiplication = new Complex[signalTab.length];
        for (int i = 0; i < resultOfMultiplication.length; i++) {
            resultOfMultiplication[i] = signalTab[i].multiply(impulseResponseComplex[i]);
        }

        resultOfMultiplication = Fourier.computeInverseFastFourier(resultOfMultiplication, bits);
        Double[] d = new Double[resultOfMultiplication.length];
        for (int i = 0; i < d.length; i++) {
            d[i] = resultOfMultiplication[i].getReal();
        }
        resultsOfFilterOperations.add(d);
        if (windowIndex == signalWindows.size() - 1) {
            //ChartDrawer.drawChart(signalTab, "signal spec" + windowIndex);
            //ChartDrawer.drawChart(impulseResponseComplex, "impulse resp spec" + windowIndex);
            //ChartDrawer.drawChart(d, "result of inverse from mul" + windowIndex);
        }
    }

    System.out.println("Windows " + resultsOfFilterOperations.size());
    System.out.println("OutputSize " + outputSignal.length);
    System.out.println("Size of one window" + resultsOfFilterOperations.get(0).length);
    System.out.println("HOP Size " + R);
    for (int i = 0; i < resultsOfFilterOperations.size(); i++) {
        System.out.println((i + 1) + " Elem " + (i * R));
        addElems((int) (i * R), resultsOfFilterOperations.get(i), outputSignal);
    }
}