void Objectness::meanStdDev(CMat &data1f, Mat &mean1f, Mat &stdDev1f)
{
    const int DIM = data1f.cols, NUM = data1f.rows;
    mean1f = Mat::zeros(1, DIM, CV_32F), stdDev1f = Mat::zeros(1, DIM, CV_32F);
    for (int i = 0; i < NUM; i++)
        mean1f += data1f.row(i);
    mean1f /= NUM;
    for (int i = 0; i < NUM; i++) {
        Mat tmp;
        pow(data1f.row(i) - mean1f, 2, tmp);
        stdDev1f += tmp;
    }
    pow(stdDev1f/NUM, 0.5, stdDev1f);
}
Exemple #2
0
int S4r::Simulation::GetSMatrix(
	size_t layer_start, size_t layer_end,
	CMat &S
){
	S4R_TRACE("> Simulation::GetSMatrix(start = %lu, end = %lu)\n",
		layer_start, layer_end
	);
	
	const size_t n0 = layers[layer_start]->GetNumModes();
	
	// Ultimately, S will have dimensions:
	//
	//           n0   n1
	//     n1 [ S11  S12 ]
	// S =    [          ]
	//     n0 [ S21  S22 ]
	//
	
	S.resize(n0+n0,n0+n0); // S starts off at layer_start
	S.setIdentity();
	for(size_t l = layer_start; l < layer_end; ++l){
		const size_t lp1 = l+1;
		const size_t nl = layers[l]->GetNumModes();
		const size_t nlp1 = layers[lp1]->GetNumModes();
		
		const Layer &Ll = (*layers[l]);
		const Layer &Llp1 = (*layers[lp1]);
		
		
		// At this point, S is
		//           n0   nl
		//     nl [ S11  S12 ]
		// S =    [          ]
		//     n0 [ S21  S22 ]
		
		// Make the interface matrices. They will have dimensions:
		//          nlp1 nlp1
		//     nl [ I11  I12 ]   [ in1  in2 ]
		// I =    [          ] = [          ]
		//     nl [ I21  I22 ]   [ in2  in1 ]
		//
		CMat in1, in2;
		{
			// The interface matrix is the inverse of the mode-to-field matrix of layer l
			// times the mode-to-field matrix of layer l+1 (lp1).
			// The mode-to-field matrix is of the form
			//   [ B -B ] where A = phi
			//   [ A  A ] where B = kp*phi*inv(diag(q)) = G*A/q
			// So we want
			//   Interface = 0.5 * [  iBl  iAl ] [ Blp1 -Blp1 ]
			//                     [ -iBl  iAl ] [ Alp1  Alp1 ]
			// where iBl = inv(Bl), etc.
			// Multiplying out gives
			//   0.5 * [ P+Q P-Q ] // where P = iAl*Alp1, and i in front means inverse
			//         [ P-Q P+Q ] // where Q = iBl*Blp1
			// Making P is easy, since A is a single matrix.
			// Making Q is as follows:
			//   Q = iBl*Blp1
			//     = ql*iAl*iGl * Gl*Alp1*iqlp1
			// We will only store I11 and I21

			{
				// Make Blp1 in in2
				CMat t1(Llp1.modes.kp * Llp1.modes.phi);
				
				// Make Q in in1
				// Take care when inverting t1, since it may be singular at a
				// diffraction threshold.
				Eigen::ColPivHouseholderQR<CMat> iBl(Ll.modes.kp * Ll.modes.phi);
				in1 = Ll.modes.q.asDiagonal() * iBl.solve(t1);
				{ // Take special care since an element of q may be zero
					double maxel = 0;
					for(size_t i = 0; i < nlp1; ++i){
						double el = std::abs(Llp1.modes.q[i]);
						if(el > maxel){ 
							maxel = el;
						}
					}
					for(size_t i = 0; i < nlp1; ++i){
						double el = std::abs(Llp1.modes.q[i]);
						if(el > maxel * DBL_EPSILON){
							in1.col(i) *= 1./Llp1.modes.q[i];
						}else{
							in1.col(i).setZero();
						}
					}
				}
			}
			
			// Make P in in2
			{
				Eigen::ColPivHouseholderQR<CMat> iAl(Ll.modes.phi);
				// t1 may become singular for planewaves at diffraction thresholds
				// with a z-directed polarization.
				in2 = iAl.solve(Llp1.modes.phi);
			}
			
			CMat t1(in2); // in2 = P, t1 = P, in1 = Q
			in2 = 0.5*(t1-in1);
			in1 = 0.5*(t1+in1);
			
			// The inverse of the Interface matrix is
			//   inv(Interface) = 0.5 * [ iP+iQ    iP-iQ ]
			//                          [ iP-iQ    iP+iQ ]
			// where iP = inv(P), etc.
		}
		
		CMat SI = T2Sblocks(nl, nlp1, in1, in2);

		for(size_t i = 0; i < nl; ++i){
			S.row(i) *= std::exp(Ll.modes.q[i] * std::complex<double>(0,Ll.description.thickness));
		}
		for(size_t i = 0; i < nlp1; ++i){
			SI.col(nl+i) *= std::exp(Llp1.modes.q[i] * std::complex<double>(0,Llp1.description.thickness));
		}
		
		CMat Snew = StarProduct(n0, nl, nlp1, S, SI);
		S = Snew;
	}
	
	S4R_TRACE("< Simulation::GetSMatrix\n");
	return 0;
}