// ############################## START FUNC ############################################

function calc_angles_and_distances(xm, ym, zm, feature_sorts, x, y, z)
{

var number_of_features=feature_sorts.length;

// This procedure creates three matrixes, two distances and an angle for each comb. of features + mass p
var dist1matrix=def_matrix(number_of_features ,number_of_features, 0, "undefined");
var dist2matrix=def_matrix(number_of_features ,number_of_features, 0, "undefined");
var anglematrix=def_matrix(number_of_features ,number_of_features, 0, "undefined");

// Now - To calculate the angle I need four distances and the cosine theoreme
// From 2 distances - mass point + feature 1 resp. mass point + feature 2 I will
// choose the biggest to calculate the big angle where the line from the
// mass point meets the line between the feature points in their average point

var dist_masspoint_feature1=0;
var dist_masspoint_feature2=0;
var dist_feature1_feature2=0;
var half_dist_feature1_feature2=0;
var maxdist=0;
var averagedist=0;
var bigangle=0;
var smallangle=0;
var n=0;
var m=0;

for(n=0;n<number_of_features;n++){
dist_masspoint_feature1=Math.sqrt(Math.pow(xm-x[n],2)+Math.pow(ym-y[n],2)+Math.pow(zm-z[n],2));
for(m=0;m<number_of_features;m++){

  if(n==m){
   anglematrix[n][m]=0;
   dist1matrix[n][m]=0;
   dist2matrix[n][m]=0;
  }

  if(n<m){ 

// Now calculated more then once, but the alternative is to save a lot of distances

   dist_masspoint_feature2=Math.sqrt(Math.pow(xm-x[m],2)+Math.pow(ym-y[m],2)+Math.pow(zm-z[m],2));
   dist_feature1_feature2=Math.sqrt(Math.pow(x[m]-x[n],2)+Math.pow(y[m]-y[n],2)+Math.pow(z[m]-z[n],2));
   half_dist_feature1_feature2=dist_feature1_feature2/2;
   maxdist=Math.max(dist_masspoint_feature1,dist_masspoint_feature2);

// The average distance is that one from the mass point to the point between the features.
// The triangle from this middle point, to one feature (most far from mass point), and to the
// mass point makes the triangle. The angle in the middle point will be >90 degree.

averagedist=Math.sqrt(Math.pow(xm-(parseFloat(x[m])+parseFloat(x[n]))/2,2)+Math.pow(ym-(parseFloat(y[m])+parseFloat(y[n]))/2,2)+Math.pow(zm-(parseFloat(z[m])+parseFloat(z[n]))/2,2));
   bigangle=(maxdist*maxdist-averagedist*averagedist-half_dist_feature1_feature2*half_dist_feature1_feature2);
  // The cosinus theoreme, beginning above, ended below
   bigangle=Math.acos(-bigangle/(2*averagedist*half_dist_feature1_feature2))/3.1415926535*180;

   smallangle=180-bigangle;
   anglematrix[n][m]=smallangle;
   dist1matrix[n][m]=averagedist;
   dist2matrix[n][m]=dist_feature1_feature2;
  }

  if(n>m){
   anglematrix[n][m]=anglematrix[m][n];
   dist1matrix[n][m]=dist1matrix[m][n];
   dist2matrix[n][m]=dist2matrix[m][n];
  }

}
}

// All angles and distances are put in a common 3D variable for easy transfer. 

var all_matrix=new Array(3);
all_matrix[0]=anglematrix;
all_matrix[1]=dist1matrix;
all_matrix[2]=dist2matrix;

return all_matrix;

}

// ############################### end func ############################################