自学教程：C++ I1函数代码示例

void Postprocessing::initialise(){	// Read in the input maps	fn_I1 = fn_in + "_half1_class001_unfil.mrc";	fn_I2 = fn_in + "_half2_class001_unfil.mrc";	if (verb > 0)	{		std::cout <<"== Reading input half-reconstructions: " <<std::endl;		std::cout.width(35); std::cout << std::left <<"  + half1-map: "; std::cout << fn_I1 << std::endl;		std::cout.width(35); std::cout << std::left <<"  + half2-map: "; std::cout << fn_I2 << std::endl;	}	I1.read(fn_I1);	I2.read(fn_I2);	I1().setXmippOrigin();	I2().setXmippOrigin();	if (!I1().sameShape(I2()))	{		std::cerr << " Size of half1 map: "; I1().printShape(std::cerr); std::cerr << std::endl;		std::cerr << " Size of half2 map: "; I2().printShape(std::cerr); std::cerr << std::endl;		REPORT_ERROR("Postprocessing::initialise ERROR: The two half reconstructions are not of the same size!");	}	if (do_auto_mask && fn_mask != "")		REPORT_ERROR("Postprocessing::initialise ERROR: provide either --auto_mask OR --mask, but not both!");	if (do_auto_bfac && ABS(adhoc_bfac) > 0.)		REPORT_ERROR("Postprocessing::initialise ERROR: provide either --auto_bfac OR --adhoc_bfac, but not both!");}

static void reset_locks(void){	local_irq_disable();	I1(A); I1(B); I1(C); I1(D);	I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);	lockdep_reset();	I2(A); I2(B); I2(C); I2(D);	init_shared_classes();	local_irq_enable();}

void S2weaveCell::FindCellIndex(const P2& lptc)  {	// set the index for this cell 	iu = FindCellParal(ps2w->ufibs, lptc.u); 	iv = FindCellParal(ps2w->vfibs, lptc.v); 	ASSERT(I1(ps2w->ufibs[iu - 1].wp, ps2w->ufibs[iu].wp).Contains(lptc.u)); 	ASSERT(I1(ps2w->vfibs[iv - 1].wp, ps2w->vfibs[iv].wp).Contains(lptc.v)); 	// rebuild the rest of the cell info	ConstructCellBounds(); 	CreateBoundList();}

void S2weaveCellLinearCutTraverse::AdvanceToLamPos(double llamcp) {	ASSERT(!bOnContour); 	ASSERT(I1(lamcb, lamcf).Contains(lamcp)); 	ASSERT(llamcp >= lamcb); 	TOL_ZERO((ptcst + vbearing * lamcp - ptcp).Len()); 	ASSERT((ibb == -1) || (lamcpbb > llamcp)); 	lamcp = llamcp; 	double clam = I1(lamcb, lamcf).InvAlong(lamcp); 	ptcp = Along(clam, ptcb, ptcf); // or use an AlongAcc.  	TOL_ZERO((ptcst + vbearing * lamcp - ptcp).Len()); }

void nemo_main (){  setparams();	/* get cmdline stuff and compute x,y,u,v,etot,lz */  optr = NULL;				/* make an orbit */  allocate_orbit (&optr, 3, 1);  Masso(optr)  = 1.0;                     /* and set Mass */  Key(optr) = 0;  Torb(optr,0) = tnow;  Xorb(optr,0) = x;			/* .. positions */  Yorb(optr,0) = y;  Zorb(optr,0) = z;  Uorb(optr,0) = u;			/* .. velocities */  Vorb(optr,0) = v;  Worb(optr,0) = w;  I1(optr) = etot;			/*  energy (zero if not used) */  I2(optr) = lz;                          /* angular momentum */    dprintf(0,"pos: %f %f %f  /nvel: %f %f %f  /netot: %f/nlz=%f/n",	  x,y,z,u,v,w,etot,lz);  outstr = stropen (outfile,"w");		/* write to file */  put_history(outstr);  PotName(optr) = p.name;  PotPars(optr) = p.pars;  PotFile(optr) = p.file;  write_orbit(outstr,optr);  strclose(outstr);}

void Solver::DiagramI1(){    double time0, time1;    time0 = omp_get_wtime();    #pragma omp parallel    {        int id = omp_get_thread_num();        int threads = omp_get_num_threads();        for (int n=id; n<Npphh; n+=threads) blockspphh[n]->SetUpMatrices_I1(t0);    }    time1 = omp_get_wtime(); //cout << "Inside I1. SetUpMatrices needs: " << time1-time0 << " seconds" << endl;    time0 = omp_get_wtime();    for (int n=0; n<Npphh; n++){        mat I1 = 0.5* blockspphh[n]->T * blockspphh[n]->I1 / blockspphh[n]->epsilon;        for (double I=0; I<blockspphh[n]->Holes.n_rows; I++){            for (double A=0; A<blockspphh[n]->Particles.n_rows; A++){                int i = blockspphh[n]->Holes(I,0); int j = blockspphh[n]->Holes(I,1);                int a = blockspphh[n]->Particles(A,0); int b = blockspphh[n]->Particles(A,1);                t( Index(a,b,i,j) ) += I1(A,I);                //StoreT(Index(a,b,i,j), I1(A,I));            }        }    }    time1 = omp_get_wtime(); //cout << "Inside I1. Calculate matrices needs: " << time1-time0 << " seconds" << endl;}

Mat Assignment2::computeH(const vector<Point2f> &query, const vector<Point2f> &train){	Mat I1(3,4,CV_64FC1,0.0);	Mat I2(3,4,CV_64FC1,0.0);	Mat H(3,3,CV_64FC1,0.0);		for(unsigned int i=0; i<(query.size()); i++)	{		// Assign co-ordinates to the matrix		I1.at<double>(0,i)=query[i].x;		I1.at<double>(1,i)=query[i].y;		I1.at<double>(2,i)=1;				I2.at<double>(0,i)=train[i].x;		I2.at<double>(1,i)=train[i].y;		I2.at<double>(2,i)=1;	}		// solve linear equations	solve(I1.t(), I2.t(), H, DECOMP_SVD);	H = H.t();	return H;}

static void reset_locks(void){	local_irq_disable();	lockdep_free_key_range(&ww_lockdep.acquire_key, 1);	lockdep_free_key_range(&ww_lockdep.mutex_key, 1);	I1(A); I1(B); I1(C); I1(D);	I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);	I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);	lockdep_reset();	I2(A); I2(B); I2(C); I2(D);	init_shared_classes();	ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);	memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));	memset(&ww_lockdep.acquire_key, 0, sizeof(ww_lockdep.acquire_key));	memset(&ww_lockdep.mutex_key, 0, sizeof(ww_lockdep.mutex_key));	local_irq_enable();}

double K1(double z){//1st Modified Bessel Function of the second kind  z=fabs(z/2);  if(z<=1)    return log(z)*I1(2*z)+1./(2*z)*      (1.+0.15443144*z*z-0.67278579*z*z*z*z-0.18156897*pow(z,6)-       0.01919402*pow(z,8)-0.00110404*pow(z,10)-0.00004686*pow(z,12));  else    return exp(-2*z)/sqrt(2*z)*      (1.25331414+0.23498619/z-0.0365562/z/z+0.01504268/z/z/z-       0.00780353/z/z/z/z+0.00325614/pow(z,5)-0.00038245/pow(z,6));}

int test_string_cast_vector(){	int Error = 0;		glm::vec2 A1(1, 2);	std::string A2 = glm::to_string(A1);	Error += A2 != std::string("fvec2(1.000000, 2.000000)") ? 1 : 0;		glm::vec3 B1(1, 2, 3);	std::string B2 = glm::to_string(B1);	Error += B2 != std::string("fvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;	glm::vec4 C1(1, 2, 3, 4);	std::string C2 = glm::to_string(C1);	Error += C2 != std::string("fvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;		glm::ivec2 D1(1, 2);	std::string D2 = glm::to_string(D1);	Error += D2 != std::string("ivec2(1, 2)") ? 1 : 0;		glm::ivec3 E1(1, 2, 3);	std::string E2 = glm::to_string(E1);	Error += E2 != std::string("ivec3(1, 2, 3)") ? 1 : 0;		glm::ivec4 F1(1, 2, 3, 4);	std::string F2 = glm::to_string(F1);	Error += F2 != std::string("ivec4(1, 2, 3, 4)") ? 1 : 0;		glm::hvec2 G1(1, 2);	std::string G2 = glm::to_string(G1);	Error += G2 != std::string("hvec2(1.0000, 2.0000)") ? 1 : 0;		glm::hvec3 H1(1, 2, 3);	std::string H2 = glm::to_string(H1);	Error += H2 != std::string("hvec3(1.0000, 2.0000, 3.0000)") ? 1 : 0;		glm::hvec4 I1(1, 2, 3, 4);	std::string I2 = glm::to_string(I1);	Error += I2 != std::string("hvec4(1.0000, 2.0000, 3.0000, 4.0000)") ? 1 : 0;		glm::dvec2 J1(1, 2);	std::string J2 = glm::to_string(J1);	Error += J2 != std::string("dvec2(1.000000, 2.000000)") ? 1 : 0;		glm::dvec3 K1(1, 2, 3);	std::string K2 = glm::to_string(K1);	Error += K2 != std::string("dvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;		glm::dvec4 L1(1, 2, 3, 4);	std::string L2 = glm::to_string(L1);	Error += L2 != std::string("dvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;		return Error;}

double IN(int n,double z){  double i0=I0(z),i1=I1(z),in=0;  int i;  if(n==0)return i0;  if(n==1)return i1;  for(i=1;i<n;i++){    in=i0-(2./z)*i*i1;    i0=i1;    i1=in;  }  return in;}

/* decode binex mesaage 0x01-02: decoded glonass ephmemeris ------------------*/static int decode_bnx_01_02(raw_t *raw, unsigned char *buff, int len){    geph_t geph={0};    unsigned char *p=buff;    double tod,tof,tau_gps;    int prn,day,leap;        trace(4,"binex 0x01-02: len=%d/n",len);        if (len>=119) {        prn        =U1(p)+1;   p+=1;        day        =U2(p);     p+=2;        tod        =U4(p);     p+=4;        geph.taun  =-R8(p);    p+=8;        geph.gamn  =R8(p);     p+=8;        tof        =U4(p);     p+=4;        geph.pos[0]=R8(p)*1E3; p+=8;        geph.vel[0]=R8(p)*1E3; p+=8;        geph.acc[0]=R8(p)*1E3; p+=8;        geph.pos[1]=R8(p)*1E3; p+=8;        geph.vel[1]=R8(p)*1E3; p+=8;        geph.acc[1]=R8(p)*1E3; p+=8;        geph.pos[2]=R8(p)*1E3; p+=8;        geph.vel[2]=R8(p)*1E3; p+=8;        geph.acc[2]=R8(p)*1E3; p+=8;        geph.svh   =U1(p)&0x1; p+=1;        geph.frq   =I1(p);     p+=1;        geph.age   =U1(p);     p+=1;        leap       =U1(p);     p+=1;        tau_gps    =R8(p);     p+=8;        geph.dtaun =R8(p);    }    else {        trace(2,"binex 0x01-02: length error len=%d/n",len);        return -1;    }    if (!(geph.sat=satno(SYS_GLO,prn))) {        trace(2,"binex 0x01-02: satellite error prn=%d/n",prn);        return -1;    }    if (raw->time.time==0) return 0;    geph.toe=utc2gpst(adjday(raw->time,tod-10800.0));    geph.tof=utc2gpst(adjday(raw->time,tof-10800.0));    geph.iode=(int)(fmod(tod+10800.0,86400.0)/900.0+0.5);        if (!strstr(raw->opt,"-EPHALL")) {        if (fabs(timediff(geph.toe,raw->nav.geph[prn-MINPRNGLO].toe))<1.0&&            geph.svh==raw->nav.geph[prn-MINPRNGLO].svh) return 0; /* unchanged */    }    raw->nav.geph[prn-1]=geph;    raw->ephsat=geph.sat;    return 2;}

int decode_navgpstime(tUbxRawData *raw){   unsigned char *p = raw->buff + UBX_MSGSTART_SHIFT;   tExternalGNSSGPSTimePtr gpstime = Msg_Get_ExternalGnssGpsTime();   /* do not reset this struct due to week and leapsecond */   gpstime->iTow = U4(p);   gpstime->fTow = I4(p+4);   gpstime->gpsWeek = (short)(I2(p + 8));   gpstime->leapSec = (short)(I1(p + 10));   return 0; }

void bench_env_klip(Pt2di sz){     Im2D_U_INT1 I1(sz.x,sz.y);     Im2D_U_INT1 I2(sz.x,sz.y);     INT vmax = 30;     ELISE_COPY     (         I1.all_pts(),         Min         (             vmax,                1             +  frandr()*5             +  unif_noise_4(3) * 30         ),         I1.out()      );     ELISE_COPY     (         I1.border(1),         0,         I1.out()     );     ELISE_COPY     (         I1.all_pts(),         EnvKLipshcitz_32(I1.in(0),vmax),         I2.out()      );     U_INT1 ** i1 = I1.data();     U_INT1 ** i2 = I2.data();     for (INT x=0; x<sz.x ; x++)         for (INT y=0; y<sz.y ; y++)            if (i1[y][x])            {                 INT v  = std::min3                       (                          std::min3(i2[y+1][x-1]+3,i2[y+1][x]+2,i2[y+1][x+1]+3),                          std::min3(i2[y][x-1]+2,(INT)i1[y][x],i2[y][x+1]+2),                          std::min3(i2[y-1][x-1]+3,i2[y-1][x]+2,i2[y-1][x+1]+3)                      );                 BENCH_ASSERT(v==i2[y][x]);           }}

void Postprocessing::makeGuinierPlot(MultidimArray<Complex > &FT, std::vector<fit_point2D> &guinier){	MultidimArray<int> radial_count(XSIZE(FT));	MultidimArray<DOUBLE> lnF(XSIZE(FT));	fit_point2D      onepoint;	FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(FT)	{    	int r2 = kp * kp + ip * ip + jp * jp;    	int ires = ROUND(sqrt((DOUBLE)r2));		if (ires < XSIZE(radial_count))		{	        lnF(ires) += abs(DIRECT_A3D_ELEM(FT, k, i, j));	        radial_count(ires)++;		}	}	DOUBLE xsize = XSIZE(I1());	guinier.clear();	FOR_ALL_ELEMENTS_IN_ARRAY1D(radial_count)	{		DOUBLE res = (xsize * angpix)/(DOUBLE)i; // resolution in Angstrom		if (res >= angpix * 2.) // Apply B-factor sharpening until Nyquist, then low-pass filter later on (with a soft edge)        {            onepoint.x = 1. / (res * res);            if (DIRECT_A1D_ELEM(lnF, i) > 0.)            {                onepoint.y = log ( DIRECT_A1D_ELEM(lnF, i) / DIRECT_A1D_ELEM(radial_count, i) );                if (res <= fit_minres && res >= fit_maxres)                {                    onepoint.w = 1.;                }                else                {                    onepoint.w = 0.;                }            }            else            {                onepoint.y = -99.;                onepoint.w = 0.;            }            //std::cerr << " onepoint.x= " << onepoint.x << " onepoint.y= " << onepoint.y << " onepoint.w= " << onepoint.w << std::endl;            guinier.push_back(onepoint);        }	}}

bool Postprocessing::getMask(){	// A. Check whether a user-provided mask is to be used	if (do_auto_mask)	{		getAutoMask();	}	else if (fn_mask != "")	{		if (verb > 0)		{			std::cout << "== Using a user-provided mask ... " <<std::endl;			std::cout.width(35); std::cout << std::left   << "  + input mask: "; std::cout  << fn_mask <<std::endl;		}		// Read the mask in memory		Im.read(fn_mask);		Im().setXmippOrigin();		// Check values are between 0 and 1		DOUBLE avg, stddev, minval, maxval;		Im().computeStats(avg, stddev, minval, maxval);		if (minval < -1e-6 || maxval - 1. > 1.e-6)		{			std::cerr << " minval= " << minval << " maxval= " << maxval << std::endl;			REPORT_ERROR("Postprocessing::mask ERROR: mask values not in range [0,1]!");		}		// Also check the mask is the same size as the input maps		if (!Im().sameShape(I2()))		{			std::cerr << " Size of input mask: "; Im().printShape(std::cerr); std::cerr<< std::endl;			std::cerr << " Size of input maps: "; I1().printShape(std::cerr); std::cerr<< std::endl;			REPORT_ERROR("Postprocessing::mask ERROR: mask and input maps do not have the same size!");		}	}	else	{		if (verb > 0)		{			std::cout << "== Not performing any masking ... " << std::endl;		}		return false;	}	return true;}

/* decode NVS x4btime --------------------------------------------------------*/static int decode_x4btime(raw_t *raw){    unsigned char *p=raw->buff+2;        trace(4,"decode_x4btime: len=%d/n", raw->len);        raw->nav.utc_gps[1] = R8(p   );    raw->nav.utc_gps[0] = R8(p+ 8);    raw->nav.utc_gps[2] = I4(p+16);    raw->nav.utc_gps[3] = I2(p+20);    raw->nav.leaps = I1(p+22);        return 9;}

/* Hash tweak to produce single-AES-wide block */static void hashTweak (unsigned char outBlock[16],                       const unsigned char T[16], int tweakBytes,                       const unsigned char K1[], int k1Bits,					   const unsigned char K3[16]){  unsigned char K3i[16], TT[16];  int i, r;  if (tweakBytes == 0) {    aesBlock(outBlock, K1, k1Bits, K3, AES_ENCRYPT);    return;  }  r = (tweakBytes + 15) / 16;  memset (outBlock, 0, 16);  multByAlpha(K3i, K3);                          /* K3i holds shifted K3 */  for (i=1; i<=r-1; i++) {	memcpy (TT, I1(T,i), 16);                    /* Copy Ti to TT */	xorBlocks(TT, TT, K3i);                      /* TT = K3i xor Ti */    aesBlock(TT, K1, k1Bits, TT, AES_ENCRYPT);  /* AES_enc(K1; K3i xor Ti) */	xorBlocks(TT, TT, K3i);          /* TT = K3i xor AES_enc(K1; K3i xor Ti) */	xorBlocks(outBlock, outBlock, TT);           /* Xor all TT's together */    multByAlpha(K3i, K3i);  }  if ((tweakBytes % 16)) {       /* On partial final block */    padBlock(TT, I1(T,r), (tweakBytes % 16));    /* Pad partial block */    multByAlpha(K3i, K3i);                       /* And use an extra shift */  } else {    memcpy (TT, I1(T,r), 16);                    /* Copy Tr to TT */  }  xorBlocks(TT, TT, K3i);                        /* TT = K3i xor Ti */  aesBlock(TT, K1, k1Bits, TT, AES_ENCRYPT);     /* AES_enc(K1; K3i xor Ti) */  xorBlocks(TT, TT, K3i);           /* TT = K3i xor AES_enc(K1; K3i xor Ti) */  xorBlocks(outBlock, outBlock, TT);             /* Xor all TT's together */}

int main() {  Nef_polyhedron N1(Plane_3( 1, 0, 0,-1),Nef_polyhedron::INCLUDED);  Nef_polyhedron N2(Plane_3(-1, 0, 0,-1),Nef_polyhedron::INCLUDED);  Nef_polyhedron N3(Plane_3( 0, 1, 0,-1),Nef_polyhedron::INCLUDED);  Nef_polyhedron N4(Plane_3( 0,-1, 0,-1),Nef_polyhedron::INCLUDED);  Nef_polyhedron N5(Plane_3( 0, 0, 1,-1),Nef_polyhedron::INCLUDED);  Nef_polyhedron N6(Plane_3( 0, 0,-1,-1),Nef_polyhedron::INCLUDED);  Nef_polyhedron I1(!N1+!N2);  Nef_polyhedron I2(N3-!N4);  Nef_polyhedron I3(N5^N6);  Nef_polyhedron Cube1(I2 *!I1);  Cube1 *= !I3;  Nef_polyhedron Cube2 = N1 * N2 * N3 * N4 * N5 * N6;  CGAL_assertion (Cube1 == Cube2);  return 0;}

void DecoderFastRatio::decodeFrames(cv::Mat &up, cv::Mat &vp, cv::Mat &mask, cv::Mat &shading){    const float pi = M_PI;    cv::Mat_<float> I1(frames[0]);    cv::Mat_<float> I2(frames[1]);    cv::Mat_<float> I3(frames[2]);//        cvtools::writeMat(I1, "I1.mat");//        cvtools::writeMat(I2, "I2.mat");//        cvtools::writeMat(I3, "I3.mat");    up = (I3-I1)/(I2-I1);    up = (up+1.0)/2.0;//    cvtools::writeMat(frames[0], "frames[0].mat");//    cvtools::writeMat(frames[1], "frames[1].mat");//    cvtools::writeMat(frames[2], "frames[2].mat");    up *= screenCols;//    cv::Mat upCopy = up.clone();//    cv::bilateralFilter(upCopy, up, 7, 500, 400);    cv::GaussianBlur(up, up, cv::Size(0,0), 3, 3);    shading = frames[1];    // Create mask from modulation image and erode    mask.create(shading.size(), cv::DataType<bool>::type);//    mask.setTo(true);    mask = (shading > 10000) & (shading < 65000) & (up <= screenCols) & (up >= 0);//    cv::Mat edges;//    cv::Sobel(up, edges, -1, 1, 1, 7);//    edges = abs(edges) < 500;//    cv::erode(edges, edges, cv::Mat());//    mask = mask & edges;}

bool FragmentList_checkEntryExists(FragmentNode *fragmentNode, uint64 offset, uint64 length){  bool              existsFlag;  uint64            i0,i1;  FragmentEntryNode *fragmentEntryNode;  assert(fragmentNode != NULL);  i0 = I0(offset,length);  i1 = I1(offset,length);  existsFlag = FALSE;  for (fragmentEntryNode = fragmentNode->fragmentEntryList.head; (fragmentEntryNode != NULL) && !existsFlag; fragmentEntryNode = fragmentEntryNode->next)  {    if (   ((F0(fragmentEntryNode) <= i0) && (i0 <= F1(fragmentEntryNode)) )        || ((F0(fragmentEntryNode) <= i1) && (i1 <= F1(fragmentEntryNode)))       )    {      existsFlag = TRUE;    }  }  return existsFlag;}

void   amyCubeAND::Run(){	amyVariable v1=this->GetStack()->Pop();	amyVariable v2=this->GetStack()->Pop();	FETCH(amyCube,cube1,v1);	FETCH(amyCube,cube2,v2);	amyCube::tCube::Pointer cu=amyCube::tCube::New();	cu->SetSpacing(cube1.obj->GetSpacing());	cu->SetRegions(cube1.obj->GetLargestPossibleRegion());	cu->Allocate();	typedef itk::ImageRegionConstIterator<amyCube::tCube> CItrType;	typedef itk::ImageRegionIterator<amyCube::tCube>      ItrType;	CItrType I1(cube1.obj,cube1.obj->GetLargestPossibleRegion());	CItrType I2(cube2.obj,cube2.obj->GetLargestPossibleRegion());	ItrType  Ir(cu,cu->GetLargestPossibleRegion());	for(I1.GoToBegin(),I2.GoToBegin(),I2.GoToBegin();		!I1.IsAtEnd()&&!I2.IsAtEnd()&&!Ir.IsAtEnd();		++I1,++I2,++Ir)	{		if(I1.Get()>0&&I2.Get()>0)		{			Ir.Set(400);		}		else			Ir.Set(-400);	}	amyVariable ret=amyVariable::New(VTYPE_CUBE,"ret");	FETCH(amyCube,retcube,ret);	retcube.SetObj(cu);	this->GetStack()->Push(ret);}