Beispiel #1
0
  // Apply filter
  public double[] Apply(BufferedImage image) {
    Fuzzy10Bin Fuzzy10 = new Fuzzy10Bin(false);
    Fuzzy24Bin Fuzzy24 = new Fuzzy24Bin(false);
    FuzzyFCTHpart FuccyFCTH = new FuzzyFCTHpart();

    double[] Fuzzy10BinResultTable = new double[10];
    double[] Fuzzy24BinResultTable = new double[24];
    double[] FuzzyHistogram192 = new double[192];

    int Method = 2;
    int width = image.getWidth();
    int height = image.getHeight();

    for (int R = 0; R < 192; R++) {
      FuzzyHistogram192[R] = 0;
    }

    RGB2HSV HSVConverter = new RGB2HSV();
    int[] HSV = new int[3];

    WaveletMatrixPlus Matrix = new WaveletMatrixPlus();

    double[][] ImageGrid = new double[width][height];
    int[][] ImageGridRed = new int[width][height];
    int[][] ImageGridGreen = new int[width][height];
    int[][] ImageGridBlue = new int[width][height];

    for (int x = 0; x < width; x++) {
      for (int y = 0; y < height; y++) {
        int pixel = image.getRGB(x, y);
        ImageGridRed[x][y] = (pixel >> 16) & 0xff;
        ImageGridGreen[x][y] = (pixel >> 8) & 0xff;
        ImageGridBlue[x][y] = (pixel) & 0xff;

        int mean =
            (int)
                (0.114 * ImageGridBlue[x][y]
                    + 0.587 * ImageGridGreen[x][y]
                    + 0.299 * ImageGridRed[x][y]);
        ImageGrid[x][y] = mean;
      }
    }

    int NumberOfBlocks = 1600;
    int Step_X = (int) Math.floor(width / Math.sqrt(NumberOfBlocks));
    int Step_Y = (int) Math.floor(height / Math.sqrt(NumberOfBlocks));

    if ((Step_X % 2) != 0) {
      Step_X = Step_X - 1;
    }
    if ((Step_Y % 2) != 0) {
      Step_Y = Step_Y - 1;
    }

    if (Step_Y < 4) Step_Y = 4;
    if (Step_X < 4) Step_X = 4;
    ///
    // Filter

    for (int y = 0; y < height - Step_Y; y += Step_Y) {
      for (int x = 0; x < width - Step_X; x += Step_X) {
        // int[][] BinaryBlock = new int[4][4];
        double[][] Block = new double[4][4];
        int[][] BlockR = new int[4][4];
        int[][] BlockG = new int[4][4];
        int[][] BlockB = new int[4][4];
        int[][] BlockCount = new int[4][4];

        int[] CororRed = new int[Step_Y * Step_X];
        int[] CororGreen = new int[Step_Y * Step_X];
        int[] CororBlue = new int[Step_Y * Step_X];

        int[] CororRedTemp = new int[Step_Y * Step_X];
        int[] CororGreenTemp = new int[Step_Y * Step_X];
        int[] CororBlueTemp = new int[Step_Y * Step_X];

        int MeanRed = 0;
        int MeanGreen = 0;
        int MeanBlue = 0;
        int CurrentPixelX = 0;
        int CurrentPixelY = 0;
        for (int i = 0; i < 4; i++) {

          for (int j = 0; j < 4; j++) {
            Block[i][j] = 0;
            BlockCount[i][j] = 0;
          }
        }
        // #endregion

        int TempSum = 0;
        for (int i = 0; i < Step_X; i++) {
          for (int j = 0; j < Step_Y; j++) {
            CurrentPixelX = 0;
            CurrentPixelY = 0;

            if (i >= (Step_X / 4)) CurrentPixelX = 1;
            if (i >= (Step_X / 2)) CurrentPixelX = 2;
            if (i >= (3 * Step_X / 4)) CurrentPixelX = 3;

            if (j >= (Step_Y / 4)) CurrentPixelY = 1;
            if (j >= (Step_Y / 2)) CurrentPixelY = 2;
            if (j >= (3 * Step_Y / 4)) CurrentPixelY = 3;

            Block[CurrentPixelX][CurrentPixelY] += ImageGrid[x + i][y + j];
            BlockCount[CurrentPixelX][CurrentPixelY]++;

            BlockR[CurrentPixelX][CurrentPixelY] = ImageGridRed[x + i][y + j];
            BlockG[CurrentPixelX][CurrentPixelY] = ImageGridGreen[x + i][y + j];
            BlockB[CurrentPixelX][CurrentPixelY] = ImageGridBlue[x + i][y + j];

            CororRed[TempSum] = BlockR[CurrentPixelX][CurrentPixelY];
            CororGreen[TempSum] = BlockG[CurrentPixelX][CurrentPixelY];
            CororBlue[TempSum] = BlockB[CurrentPixelX][CurrentPixelY];

            CororRedTemp[TempSum] = BlockR[CurrentPixelX][CurrentPixelY];
            CororGreenTemp[TempSum] = BlockG[CurrentPixelX][CurrentPixelY];
            CororBlueTemp[TempSum] = BlockB[CurrentPixelX][CurrentPixelY];

            TempSum++;
          }
        }

        for (int i = 0; i < 4; i++) {
          for (int j = 0; j < 4; j++) {
            Block[i][j] = Block[i][j] / BlockCount[i][j];
          }
        }

        Matrix = singlePassThreshold(Block, 1);

        for (int i = 0; i < (Step_Y * Step_X); i++) {
          MeanRed += CororRed[i];
          MeanGreen += CororGreen[i];
          MeanBlue += CororBlue[i];
        }

        MeanRed = (int) (MeanRed / (Step_Y * Step_X));
        MeanGreen = (int) (MeanGreen / (Step_Y * Step_X));
        MeanBlue = (int) (MeanBlue / (Step_Y * Step_X));

        HSV = HSVConverter.ApplyFilter(MeanRed, MeanGreen, MeanBlue);

        if (Compact == false) {
          Fuzzy10BinResultTable = Fuzzy10.ApplyFilter(HSV[0], HSV[1], HSV[2], Method);
          Fuzzy24BinResultTable =
              Fuzzy24.ApplyFilter(HSV[0], HSV[1], HSV[2], Fuzzy10BinResultTable, Method);
          FuzzyHistogram192 =
              FuccyFCTH.ApplyFilter(
                  Matrix.F3, Matrix.F2, Matrix.F1, Fuzzy24BinResultTable, Method, 24);

        } else {
          Fuzzy10BinResultTable = Fuzzy10.ApplyFilter(HSV[0], HSV[1], HSV[2], Method);
          FuzzyHistogram192 =
              FuccyFCTH.ApplyFilter(
                  Matrix.F3, Matrix.F2, Matrix.F1, Fuzzy10BinResultTable, Method, 10);
        }
      }
    }

    // end of the filter
    double TotalSum = 0;

    for (int i = 0; i < 192; i++) {

      TotalSum += FuzzyHistogram192[i];
    }

    for (int i = 0; i < 192; i++) {

      FuzzyHistogram192[i] = FuzzyHistogram192[i] / TotalSum;
    }

    FCTHQuant Quant = new FCTHQuant();
    FuzzyHistogram192 = Quant.Apply(FuzzyHistogram192);

    return FuzzyHistogram192;
  }
Beispiel #2
0
  private WaveletMatrixPlus singlePassThreshold(double[][] inputMatrix, int level) {

    WaveletMatrixPlus TempMatrix = new WaveletMatrixPlus();
    level = (int) Math.pow(2.0, level - 1);

    // GETLENGTH*************
    double[][] resultMatrix = new double[inputMatrix.length][inputMatrix[0].length];

    int xOffset = inputMatrix.length / 2 / level;

    int yOffset = inputMatrix[0].length / 2 / level;

    int currentPixel = 0;

    // double size = inputMatrix.length * inputMatrix[0].length;

    double multiplier = 0;

    for (int y = 0; y < inputMatrix[0].length; y++) {

      for (int x = 0; x < inputMatrix.length; x++) {

        if ((y < inputMatrix[0].length / 2 / level) && (x < inputMatrix.length / 2 / level)) {

          currentPixel++;

          resultMatrix[x][y] =
              (inputMatrix[2 * x][2 * y]
                      + inputMatrix[2 * x + 1][2 * y]
                      + inputMatrix[2 * x][2 * y + 1]
                      + inputMatrix[2 * x + 1][2 * y + 1])
                  / 4;

          double vertDiff =
              (-inputMatrix[2 * x][2 * y]
                  - inputMatrix[2 * x + 1][2 * y]
                  + inputMatrix[2 * x][2 * y + 1]
                  + inputMatrix[2 * x + 1][2 * y + 1]);

          double horzDiff =
              (inputMatrix[2 * x][2 * y]
                  - inputMatrix[2 * x + 1][2 * y]
                  + inputMatrix[2 * x][2 * y + 1]
                  - inputMatrix[2 * x + 1][2 * y + 1]);

          double diagDiff =
              (-inputMatrix[2 * x][2 * y]
                  + inputMatrix[2 * x + 1][2 * y]
                  + inputMatrix[2 * x][2 * y + 1]
                  - inputMatrix[2 * x + 1][2 * y + 1]);

          resultMatrix[x + xOffset][y] = (int) (byte) (multiplier + Math.abs(vertDiff));

          resultMatrix[x][y + yOffset] = (int) (byte) (multiplier + Math.abs(horzDiff));

          resultMatrix[x + xOffset][y + yOffset] = (int) (byte) (multiplier + Math.abs(diagDiff));

        } else {

          if ((x >= inputMatrix.length / level) || (y >= inputMatrix[0].length / level)) {

            resultMatrix[x][y] = inputMatrix[x][y];
          }
        }
      }
    }

    double Temp1 = 0;
    double Temp2 = 0;
    double Temp3 = 0;

    for (int i = 0; i < 2; i++) {
      for (int j = 0; j < 2; j++) {
        Temp1 += 0.25 * Math.pow(resultMatrix[2 + i][j], 2);
        Temp2 += 0.25 * Math.pow(resultMatrix[i][2 + j], 2);
        Temp3 += 0.25 * Math.pow(resultMatrix[2 + i][2 + j], 2);
      }
    }

    // double[] MatrixResults = new double[4];

    TempMatrix.F1 = Math.sqrt(Temp1);
    TempMatrix.F2 = Math.sqrt(Temp2);
    TempMatrix.F3 = Math.sqrt(Temp3);

    TempMatrix.Entropy = 0;

    return TempMatrix;
  }