docs: public static void computeOBBCenterAxisExtents(
  			Iterable<? extends Point3D> points,
  			Vector3f R, Vector3f S, Vector3f T, Point3f center,
  			double[] extents) {
  		assert (points != null);
  		assert (center != null);
  		assert (extents != null && extents.length >= 3);
  
  		Vector3f vecNull = new Vector3f();
  		if (R.equals(vecNull) && S.equals(vecNull) && T.equals(vecNull)) {
  			// Determining the covariance matrix of the points
  			// and set the center of the box
  			Matrix3f cov = new Matrix3f();
  			cov.cov(points);
  
  			// Determining eigenvectors of covariance matrix and defines RST axis
  			Matrix3f rst = new Matrix3f();// eigenvectors
  
  			cov.eigenVectorsOfSymmetricMatrix(rst);
  			rst.getColumn(0, R);
  			rst.getColumn(1, S);
  			rst.getColumn(2, T);
  		}//else we have already set some constraints on OBB axis, dosen't need to compute them again 
  
  		double minR = Double.POSITIVE_INFINITY;
  		double maxR = Double.NEGATIVE_INFINITY;
  		double minS = Double.POSITIVE_INFINITY;
  		double maxS = Double.NEGATIVE_INFINITY;
  		double minT = Double.POSITIVE_INFINITY;
  		double maxT = Double.NEGATIVE_INFINITY;
  
  		double PdotR;
  		double PdotS;
  		double PdotT;
  		Vector3f v = new Vector3f();
  
  		for (Point3D tuple : points) {
  			v.set(tuple);
  
  			PdotR = v.dot(R);
  			PdotS = v.dot(S);
  			PdotT = v.dot(T);
  
  			if (PdotR < minR)
  				minR = PdotR;
  			if (PdotR > maxR)
  				maxR = PdotR;
  			if (PdotS < minS)
  				minS = PdotS;
  			if (PdotS > maxS)
  				maxS = PdotS;
  			if (PdotT < minT)
  				minT = PdotT;
  			if (PdotT > maxT)
  				maxT = PdotT;
  		}
  
  		double a = (maxR + minR) / 2.f;
  		double b = (maxS + minS) / 2.f;
  		double c = (maxT + minT) / 2.f;
  
  		// Set the center of the OBB
  		center.set(a * R.getX() + b * S.getX() + c * T.getX(),
  
  				a * R.getY() + b * S.getY() + c * T.getY(),
  
  				a * R.getZ() + b * S.getZ() + c * T.getZ());
  
  		// Compute extents
  		extents[0] = (maxR - minR) / 2.f;
  		extents[1] = (maxS - minS) / 2.f;
  		extents[2] = (maxT - minT) / 2.f;
  
  		// Normalize axis
  		R.normalize();
  		S.normalize();
  		T.normalize();
  
  		// Selection with largest magnitude eigenvalue to identify R
  		int max = -1;
  		for (int i = 0; i < 3; i++) {
  			if (extents[i] > max) {
  				max = i;
  			}
  		}
  		switch (max) {
  		case 0: {
  			// do nothing, right order
  		}
  		break;
  
  		case 1: {
  			Vector3f tmpVec = new Vector3f(R);
  			R.set(S);
  			S.set(T);
  			T.set(tmpVec);
  
  			double tmpD = extents[0];
  			extents[0] = extents[1];
  			extents[1] = extents[2];
  			extents[2] = tmpD;
  		}
  		break;
  		case 2: {
  			Vector3f tmpVec = new Vector3f(S);
  			S.set(R);
  			R.set(T);
  			T.set(tmpVec);
  
  			double tmpD = extents[1];
  			extents[1] = extents[0];
  			extents[0] = extents[2];
  			extents[2] = tmpD;
  
  		}
  		break;
  		default:
  		}
  	}