C++ XYZ类代码示例

char BindTriangle::set(const XY* corner, const XY& at, const XYZ* positions, const XYZ& topos, const float* distance, triangle_bind_info& res)
{
	//res.wei[0] = 1.0f;
	//res.wei[1] = res.wei[2] = 0.0f;
	
	XYZ dto = topos - positions[0];
	if(dto.length() > distance[0]*2) return 0;
	
	dto = topos - positions[1];
	if(dto.length() > distance[1]*2) return 0;
	
	dto = topos - positions[2];
	if(dto.length() > distance[2]*2) return 0;
	
	float f120 = barycentric_coord(corner[1].x, corner[1].y, corner[2].x, corner[2].y, corner[0].x, corner[0].y);
	float f201 = barycentric_coord(corner[2].x, corner[2].y, corner[0].x, corner[0].y, corner[1].x, corner[1].y);
	float f012 = barycentric_coord(corner[0].x, corner[0].y, corner[1].x, corner[1].y, corner[2].x, corner[2].y);
	
	float alpha, beta, gamma;
	
	alpha = barycentric_coord(corner[1].x,corner[1].y, corner[2].x, corner[2].y, at.x, at.y)/f120;
	if(alpha<0 || alpha>1) return 0;
	beta = barycentric_coord(corner[2].x, corner[2].y, corner[0].x, corner[0].y, at.x, at.y)/f201;
	if(beta<0 || beta>1) return 0;
	gamma = barycentric_coord(corner[0].x, corner[0].y, corner[1].x, corner[1].y, at.x, at.y)/f012;
	if(gamma<0 || gamma>1) return 0;
			
	res.wei[0] = alpha;
	res.wei[1] = beta;
	res.wei[2] = gamma;
	
	return 1;
}

void TrialMol::SetBasis(const uint p1, const uint p2)
{
   using namespace geom;
   //W is unit vec of p1->p2
   XYZ wVec = axes->MinImage(tCoords.Difference(p2, p1), box);
   wVec.Normalize();
   XYZ uVec;
   //check to make sure our W isn't in line with the standard X Axis
   if (wVec.x < 0.8) {
      //V will be W x the standard X unit vec
      uVec = XYZ(1.0, 0.0, 0.0);
   }
   else {
      //V will be W x the standard Y unit vec
      uVec = XYZ(0.0, 1.0, 0.0);
   }
   XYZ vVec = Cross(wVec, uVec);
   vVec.Normalize();
   //U is unit vec perpendicular to both V and W
   uVec = Cross(vVec, wVec);
   growthToWorld.BasisRotation(uVec, vVec, wVec);
   worldToGrowth = growthToWorld.Inverse();
   basisPoint = tCoords.Get(p1);

}

int Confo_Back::Recon_Back_WS_One(XYZ *mol,char *cle,int moln,XYZ **output,XYZ pre,XYZ nxt)
{
	if(moln!=1)return -1;
	XYZ real;
	double dist;
	//pre
	real=pre-mol[0];
	dist=pre.distance(mol[0]);
	real=real/dist;
	real=real*3.8;
	case_mol[0]=mol[0]+real;
	//nxt
	real=nxt-mol[0];
	dist=nxt.distance(mol[0]);
	real=real/dist;
	real=real*3.8;
	case_mol[2]=mol[0]+real;
	//construct
	case_mol[1]=mol[0];
	case_cle[0]='Q';
	if(cle[0]!='R')case_cle[1]=cle[0];
	else case_cle[1]='Q';
	case_cle[2]='Q';
	//build
	int retv;
	retv=Recon_Back_WS(case_mol,case_cle,3,case_mcb);
	if(retv!=1)return retv;
	//final
	int j;
	for(j=0;j<5;j++)output[0][j]=case_mcb[1][j];
	//return
	return 1;
}

void Confo_Back::Construct_Mol_II(XYZ pre,XYZ cur,XYZ nxt,double bend,double tort,double dist,XYZ &out)
{
	XYZ xyz;
	double x[3],y[3];
	double z[3];
	double cb1[3],cb2[3];
	xyz=nxt-cur;
	xyz.xyz2double(x);
	xyz=cur-pre;
	xyz.xyz2double(y);
	//check
	double angle=Vector_Angle(x,y,3);
	if(fabs(angle)<1.e-3||fabs(angle-M_PI)<1.e-3)
	{
		x[0]+=0.05;
		x[2]-=0.05;
		y[0]-=0.05;
		y[2]+=0.05;
	}
	//calc
	cross(z,x,y);
	Universal_Rotation(z,bend,Confo_Back_ROT_TOT);
	Vector_Multiply(cb1,Confo_Back_ROT_TOT,x);
	Universal_Rotation(x,tort,Confo_Back_ROT_TOT);
	Vector_Multiply(cb2,Confo_Back_ROT_TOT,cb1);
	Vector_Normalize(cb2,3);
	Vector_Dot(cb2,dist,cb2,3);
	out.double2xyz(cb2);
	out+=nxt;
}

void SensorfwGyroscope::slotDataAvailable(const XYZ& data)
{
    m_reading.setX((qreal)(data.x()*MILLI));
    m_reading.setY((qreal)(data.y()*MILLI));
    m_reading.setZ((qreal)(data.z()*MILLI));
    m_reading.setTimestamp(data.XYZData().timestamp_);
    newReadingAvailable();
}

void meegorotationsensor::slotDataAvailable(const XYZ& data)
{
    m_reading.setX(data.x());
    m_reading.setY(data.y());
    m_reading.setZ(data.z());
    m_reading.setTimestamp(data.XYZData().timestamp_);
    newReadingAvailable();
}

int main(){
XYZ X;
ABC A;
X.setValue(20);
A.setValue(12);
add(X,A);
return 0;

}

void Transform::apply_index(Model *m, ParticleIndex pi) const {
  if (!XYZ::get_is_setup(m, pi)) {
    IMP_INTERNAL_CHECK(ignore_non_xyz_,
                       "The particle does not have XYZ attributes");
    return;
  }
  XYZ xyz = XYZ(m, pi);
  xyz.set_coordinates(t_.get_transformed(xyz.get_coordinates()));
}

void TrialMol::OldThetaAndPhi(const uint atom, const uint lastAtom,
   double& theta, double& phi) const
{
   XYZ diff = tCoords.Difference(atom, lastAtom);
   diff = axes->MinImage(diff, box);
   XYZ growthCoords = worldToGrowth.Apply(diff);
   theta = acos(growthCoords.z / growthCoords.Length());
   phi = atan2(growthCoords.y, growthCoords.x);
   return;
}

void Transform::apply(Particle *p) const
{
  if (!XYZ::particle_is_instance(p)) {
    IMP_INTERNAL_CHECK(ignore_non_xyz_,
                       "The particle does not have XYZ attributes");
    return;
  }
  XYZ xyz = XYZ(p);
  xyz.set_coordinates(t_.get_transformed(xyz.get_coordinates()));
}

void FDice::create(const XYZ& p0, const XYZ& p1, const XYZ& p2)
{
	p_obj[0] = P[0] = p0;
	p_obj[1] = P[1] = p1;
	p_obj[2] = P[2] = p2;
	
	V[0] = p1 - p0;
	edge_length[0] = V[0].length();
	
	V[1] = p2 - p1;
	edge_length[1] = V[1].length();
	
	V[2] = p0 - p2;
	edge_length[2] = V[2].length();
	
	area = 0.5*sqrt(edge_length[0]*edge_length[0]*edge_length[2]*edge_length[2] - (V[0].dot(V[2]))*(V[0].dot(V[2])));
	
	V[0].normalize();
	V[1].normalize();
	V[2].normalize();
	
	int a , b;
	
	if(edge_length[0] > edge_length[1] && edge_length[0] > edge_length[2])
	{
		a = 0;
		b = 1;
	}
	else if(edge_length[1] > edge_length[2] && edge_length[1] > edge_length[0])
	{
		a = 1;
		b = 2;
	}
	else
	{
		a = 2;
		b = 0;
	}
	
	XYZ side = V[a];
	XYZ front = side^V[b]; front.normalize();
	XYZ up = front^side;
	
	m_space.setOrientations(side, up, front);
	m_space.setTranslation(P[a]);
	m_space.inverse();
	
	m_space.transform(p_obj[0]);
	m_space.transform(p_obj[1]);
	m_space.transform(p_obj[2]);
	
	f120 = barycentric_coord(p_obj[1].x, p_obj[1].y, p_obj[2].x, p_obj[2].y, p_obj[0].x, p_obj[0].y);
	f201 = barycentric_coord(p_obj[2].x, p_obj[2].y, p_obj[0].x, p_obj[0].y, p_obj[1].x, p_obj[1].y);
	f012 = barycentric_coord(p_obj[0].x, p_obj[0].y, p_obj[1].x, p_obj[1].y, p_obj[2].x, p_obj[2].y);
}

int Confo_Back::Recon_Back_WS_2nxt(XYZ *mol,char *cle,int moln,XYZ **output,XYZ nxt)
{
	if(moln!=2)return -1;
	XYZ real;
	double dist;
	real=nxt-mol[1];
	dist=nxt.distance(mol[1]);
	real=real/dist;
	real=real*3.8;
	real=mol[1]+real;
	//construct
	case_mol[0]=mol[0];
	case_mol[1]=mol[1];
	case_mol[2]=real;
	if(cle[0]!='R')case_cle[0]=cle[0];
	else case_cle[0]='Q';
	if(cle[1]!='R')case_cle[1]=cle[1];
	else case_cle[1]='Q';
	case_cle[2]='Q';
	//build
	int retv;
	retv=Recon_Back_WS(case_mol,case_cle,3,case_mcb);
	if(retv!=1)return retv;
	//final
	int i,j;
	for(i=0;i<2;i++)for(j=0;j<5;j++)output[i][j]=case_mcb[i][j];
	//return
	return 1;
}

char sphericalHarmonics::isCloseTo(const XYZ& ray, const float threshold, unsigned int id) const
{
	SHSample& s = getSample(id);
	float c = ray.dot(s.vector);
	float t = sqrt(1-c*c)/c;
	if(t >threshold) return 0;
	return 1;
}

//--------------function------------//
//given CA+CB -> return dist,bend,tort
void Confo_Beta::Confo_Beta_CACB_To_Angle(XYZ *CA,XYZ *CB,int moln,double *bend,double *tort,double *dist)
{
	int i;
	double r,b,t;
	XYZ xyz;
	//process
	for(i=1;i<moln-1;i++)
	{
		//get_point
		xyz=(CA[i]-CA[i-1]);
		xyz.xyz2double(beta_v1);
		xyz=(CA[i+1]-CA[i]);
		xyz.xyz2double(beta_v2);
		xyz=(CB[i]-CA[i]);
		xyz.xyz2double(beta_y);
		//calc
		r=dot(beta_y,beta_y);
		if(r<1.e-3)
		{
			r=0.0;
			b=0.0;
			t=0.0;
		}
		else
		{
			//calc_bend
			b=Vector_Angle(beta_v1,beta_y,3);
			//calc_tort
			cross(beta_x1,beta_v1,beta_v2);
			cross(beta_x2,beta_v1,beta_y);
			t=Vector_Angle(beta_x1,beta_x2,3);
			if(dot(beta_x1,beta_y)<0.0)t*=-1.0;
		}
		//evaluate
		if(dist!=NULL)dist[i]=r;
		if(bend!=NULL)bend[i]=b;
		if(tort!=NULL)tort[i]=t;
	}
	//assign head_tail
	if(dist!=NULL)dist[0]=-1.0;
	if(bend!=NULL)bend[0]=0.0;
	if(tort!=NULL)tort[0]=0.0;
	if(dist!=NULL)dist[moln-1]=-1.0;
	if(bend!=NULL)bend[moln-1]=0.0;
	if(tort!=NULL)tort[moln-1]=0.0;
}

void TrialMol::SetBasis(const uint p1, const uint p2, const uint p3)
{
   using namespace geom;
   //W is unit vec of p1->p2
   XYZ wVec = axes->MinImage(tCoords.Difference(p2, p1), box);
   wVec.Normalize();
   //U will be unit projection of p2->p3 onto plane normal to W
   XYZ uVec = axes->MinImage(tCoords.Difference(p3, p2), box);
   //V is unit vec perpendicular to both W and U 
   XYZ vVec = Cross(wVec, uVec);
   vVec.Normalize();
   //Finish X'
   uVec = Cross(vVec, wVec);

   growthToWorld.BasisRotation(uVec, vVec, wVec);
   worldToGrowth = growthToWorld.Inverse();
   basisPoint = tCoords.Get(p1);
}