Matlab Funktion impresize in Java

Question

Ich möchte die MATLab-Funktion imresize in einem Java-Projekt verwenden. Dazu suche ich den Quellcode dieser Funktion oder eine gleichwertige Klasse in Java.

Ich möchte eine doppelte [] [] mit einem Skalierungsfaktor von 0,4 zu einem neuen Doppel [] [] ändern.

fand ich schon ein Sourcecode, aber dieser Code verwendet eine Matlab.sum Funktion, die ich nicht haben:

import java.util.ArrayList; 
import java.util.List; 

public class MatlabResize { 
    private static final double TRIANGLE_KERNEL_WIDTH = 2; 

    public static double[][] resizeMatlab(double[][] data, double scale) { 
     int out_x = (int)Math.ceil(data[0].length * scale); 
     int out_y = (int)Math.ceil(data.length * scale); 

     double[][][] weights_indizes = contribution(data.length, out_y, scale, TRIANGLE_KERNEL_WIDTH); 
     double[][] weights = weights_indizes[0]; 
     double[][] indices = weights_indizes[1]; 

     final double[][] result = new double[out_y][data[0].length]; 
     double value = 0; 

     for (int p=0; p<result[0].length; p++) { 
      for (int i=0; i<weights.length; i++) { 
       value = 0; 

       for (int j=0; j<indices[0].length; j++) { 
        value += weights[i][j] * data[(int)indices[i][j]][p]; 
       } 

       result[i][p] = value; 
      } 
     } 

     weights_indizes = contribution(data[0].length, out_x, scale, TRIANGLE_KERNEL_WIDTH); 
     weights = weights_indizes[0]; 
     indices = weights_indizes[1]; 

     final double[][] result2 = new double[result.length][out_x]; 
     for (int p=0; p<result.length; p++) { 
      for (int i=0; i<weights.length; i++) { 
       value = 0; 

       for (int j=0; j<indices[0].length; j++) { 
        value += weights[i][j] * result[p][(int)indices[i][j]]; 
       } 

       result2[p][i] = value; 
      } 
     } 

     return result2; 
    } 


    private static double[][][] contribution(int length, int output_size, double scale, double kernel_width) { 
     if (scale < 1.0) { 
      kernel_width = kernel_width/scale; 
     } 

     final double[] x = new double[output_size]; 
     for (int i=0; i<x.length; i++) { 
      x[i] = i+1; 
     } 

     final double[] u = new double[output_size]; 
     for (int i=0; i<u.length; i++) { 
      u[i] = x[i]/scale + 0.5*(1 - 1/scale); 
     } 

     final double[] left = new double[output_size]; 
     for (int i=0; i<left.length; i++) { 
      left[i] = Math.floor(u[i] - kernel_width/2); 
     } 

     int P = (int)Math.ceil(kernel_width) + 2; 

     final double[][] indices = new double[left.length][P]; 
     for (int i=0; i<left.length; i++) { 
      for (int j=0; j<=P-1; j++) { 
       indices[i][j] = left[i] + j; 
      } 
     } 

     double[][] weights = new double[u.length][indices[0].length]; 
     for (int i=0; i<u.length; i++) { 
      for (int j=0; j<indices[i].length; j++) { 
       weights[i][j] = u[i] - indices[i][j]; 
      } 
     } 

     if (scale < 1.0) { 
      weights = triangleAntiAliasing(weights, scale); 
     } else { 
      weights = triangle(weights); 
     } 

     double[] sum = Matlab.sum(weights, 2); 
     for (int i=0; i<weights.length; i++) { 
      for (int j=0; j<weights[i].length; j++) { 
       weights[i][j] = weights[i][j]/sum[i]; 
      } 
     } 

     for (int i=0; i<indices.length; i++) { 
      for (int j=0; j<indices[i].length; j++) { 
       indices[i][j] = Math.min(Math.max(indices[i][j], 1.0), length); 
      } 
     } 

     sum = Matlab.sum(weights, 1); 
     int a = 0; 

     final List<Integer> list = new ArrayList<Integer>(); 
     for (int i=0; i<sum.length; i++) { 
      if (sum[i] != 0.0) { 
       a++; 
       list.add(i); 
      } 
     } 

     final double[][][] result = new double[2][weights.length][a]; 
     for (int i=0; i<weights.length; i++) { 
      for (int j=0; j<list.size(); j++) { 
       result[0][i][j] = weights[i][list.get(j)]; 
      } 
     } 
     for (int i=0; i<indices.length; i++) { 
      for (int j=0; j<list.size(); j++) { 
       result[1][i][j] = indices[i][list.get(j)]-1; //java indices start by 0 and not by 1 
      } 
     } 

     return result; 
    } 

    private static double[][] triangle(final double[][] x) { 
     for (int i=0; i<x.length; i++) { 
      for (int j=0; j<x[i].length; j++) { 
       if (-1.0 <= x[i][j] && x[i][j] < 0.0) { 
        x[i][j] = x[i][j] + 1; 
       } else if (0.0 <= x[i][j] && x[i][j] < 1.0) { 
        x[i][j] = 1 - x[i][j]; 
       } else { 
        x[i][j] = 0; 
       } 
      } 
     } 

     return x; 
    } 

    private static double[][] triangleAntiAliasing(final double[][] x, final double scale) { 
     for (int i=0; i<x.length; i++) { 
      for (int j=0; j<x[i].length; j++) { 
       x[i][j] = x[i][j] * scale; 
      } 
     } 

     for (int i=0; i<x.length; i++) { 
      for (int j=0; j<x[i].length; j++) { 
       if (-1.0 <= x[i][j] && x[i][j] < 0.0) { 
        x[i][j] = x[i][j] + 1; 
       } else if (0.0 <= x[i][j] && x[i][j] < 1.0) { 
        x[i][j] = 1 - x[i][j]; 
       } else { 
        x[i][j] = 0; 
       } 
      } 
     } 

     for (int i=0; i<x.length; i++) { 
      for (int j=0; j<x[i].length; j++) { 
       x[i][j] = x[i][j] * scale; 
      } 
     } 

     return x; 
    } 
} 

Answer 1

Meine Sum-Funktion, die jetzt arbeiten: :)

public class Matlab { 

    public static double[] sum(double[][] weights, int i) { 
     double[] des; 

     switch (i) { 
     case 1: 
      des = new double[weights[0].length]; 
      for (int k = 0; k < weights[0].length; k++) { 

       double sum =0; 
       for(int j = 0; j<weights.length;j++){ 
        sum += weights[j][k]; 
       } 
       des[k]=sum; 

      } 
      return des; 

     case 2: 
      des = new double[weights.length]; 
      for(int j = 0; j<weights.length;j++){ 
       double sum =0; 
       for (int k = 0; k < weights[j].length; k++) { 
        sum += weights[j][k]; 
       } 
       des[j]=sum; 
      } 
      return des; 

     return null; 
    } 

}