C++ Matrix44f::SetRotateDeg方法代码示例

int main( )
{
  MyMesh m;
  vcg::tri::Icosahedron(m);
  vcg::tri::UpdateNormal<MyMesh>::PerVertexNormalizedPerFaceNormalized(m);
  vcg::tri::UpdateBounding<MyMesh>::Box(m);

  // As a simple test we get a few random points on a mesh,
  // we rot and trans them
  // and we fit them

  std::vector<vcg::Point3f> ExactVec;
  std::vector<vcg::Point3f> PerturbVec;
  tri::MontecarloSampling(m,ExactVec,10);
  PerturbVec=ExactVec;

  Matrix44f RotM;
  Matrix44f TraM;
  Point3f dir;
  vcg::math::MarsenneTwisterRNG rnd;

  vcg::math::GeneratePointInUnitBallUniform<float>(rnd);
  RotM.SetRotateDeg(rand()%360,dir);
  TraM.SetTranslate(1,2,3);
  Matrix44f RigidM = RotM*TraM;

  for(size_t i=0;i<ExactVec.size();++i)
    PerturbVec[i]=RigidM*ExactVec[i];

  Quaternionf q;
  Point3f tr;
  Matrix44f res;
  ComputeRigidMatchMatrix(PerturbVec,ExactVec,res);

  res.print();
  RigidM.print();

  return 0;
}

//.........这里部分代码省略.........
			{
				// obtain parameters to generate 2D Grid
				int w = par.getInt("numVertX");		 
				int h = par.getInt("numVertY");		 
				float wl = par.getFloat("absScaleX");	 
				float hl = par.getFloat("absScaleY");

				if(w <= 0 || h <= 0) {
					errorMessage = "number of vertices must be positive";
					return false;
				}

				// use Grid function to generate Grid
				std::vector<float> data(w*h,0);
				tri::Grid<CMeshO>(m.cm, w, h, wl, hl, &data[0]);

				// if "centered on origin" is checked than move generated Grid in (0,0,0)
				if(par.getBool("center")) 
				{
					// move x and y
					double halfw = double(w-1)/2;
					double halfh = double(h-1)/2;
					double wld = wl/double(w);
					double hld = hl/float(h);

					CMeshO::VertexIterator vi;
					for(vi = m.cm.vert.begin(); vi != m.cm.vert.end(); ++vi)
					{
						(*vi).P()[0] = (*vi).P()[0] - (wld * halfw);
						(*vi).P()[1] = (*vi).P()[1] - (hld * halfh);
					}
				}
				// update bounding box, normals
        Matrix44f rot; rot.SetRotateDeg(180,Point3f(0,1,0));
        tri::UpdatePosition<CMeshO>::Matrix(m.cm,rot,false);
				tri::UpdateNormals<CMeshO>::PerVertexNormalizedPerFace(m.cm);	
				tri::UpdateNormals<CMeshO>::NormalizeFace(m.cm);
				tri::UpdateBounding<CMeshO>::Box(m.cm);
				
				return true;
			}
		break;
		case FF_ISOSURFACE :
			{
					SimpleVolume<SimpleVoxel> 	volume;
		
					typedef vcg::tri::TrivialWalker<CMeshO, SimpleVolume<SimpleVoxel> >	MyWalker;
					typedef vcg::tri::MarchingCubes<CMeshO, MyWalker>	MyMarchingCubes;
					MyWalker walker;
		
					Box3d rbb;
					rbb.min[0]=par.getFloat("minX");
					rbb.min[1]=par.getFloat("minY");
					rbb.min[2]=par.getFloat("minZ");
					rbb.max[0]=par.getFloat("maxX");
					rbb.max[1]=par.getFloat("maxY");
					rbb.max[2]=par.getFloat("maxZ");
					double step=par.getFloat("voxelSize");
					Point3i siz= Point3i::Construct((rbb.max-rbb.min)*(1.0/step));
					
					Parser p;
					double x,y,z;
					p.DefineVar("x", &x);
					p.DefineVar("y", &y);
					p.DefineVar("z", &z);
					std::string expr = par.getString("expr").toStdString();

void EditArc3DPlugin::exportShotsToRasters()
{
	int subSampleVal = arc3DDialog->ui.subsampleSpinBox->value();
	float scalingFactor = arc3DDialog->ui.scaleLineEdit->text().toFloat();
	int minCountVal= arc3DDialog->ui.minCountSpinBox->value();
	MeshModel* m=md->mm();
	CMeshO mm;
	QTableWidget *qtw=arc3DDialog->ui.imageTableWidget;
	v3dImportDialog::ExportShots saveSelected=v3dImportDialog::ExportShots(arc3DDialog->ui.saveShotCombo->currentIndex());
	for(int i=0; i<er.modelList.size(); ++i)
	{
		if ((saveSelected==v3dImportDialog::EXPORT_ALL) || (qtw->isItemSelected(qtw->item(i,0))))
		{
			er.modelList[i].cam.Open(er.modelList[i].cameraName.toUtf8().data());
			mm.Clear();
			Point3f corr=er.modelList[i].TraCorrection(mm,subSampleVal*2,minCountVal,0);
			er.modelList[i].shot.Extrinsics.SetTra(er.modelList[i].shot.Extrinsics.Tra()-corr);
			md->setBusy(true);
			RasterModel* rm=md->addNewRaster();
			rm->addPlane(new Plane(er.modelList[i].textureName,Plane::RGBA));
			rm->setLabel(er.modelList[i].textureName);
			rm->shot=er.modelList[i].shot;
			rm->shot.RescalingWorld(scalingFactor, false);

			//// Undistort
			if (arc3DDialog->ui.shotDistortion->isChecked())
			{
				QImage originalImg=rm->currentPlane->image;
				//originalImg.load(imageName);
				QFileInfo qfInfo(rm->currentPlane->fullPathFileName);
				QString suffix = "." + qfInfo.completeSuffix();
				QString path = qfInfo.absoluteFilePath().remove(suffix);
				path.append("Undist" + suffix);
				qDebug(path.toLatin1());

				QImage undistImg(originalImg.width(),originalImg.height(),originalImg.format());
				undistImg.fill(qRgba(0,0,0,255));

				vcg::Camera<float> &cam = rm->shot.Intrinsics;


				QRgb value;
				for(int x=0; x<originalImg.width();x++)
					for(int y=0; y<originalImg.height();y++){
						value = originalImg.pixel(x,y);
						///////

						Point3d m_temp = er.modelList[i].cam.Kinv * Point3d(x,y,1);

						double oldx, oldy;
						er.modelList[i].cam.rd.ComputeOldXY(m_temp[0] / m_temp[2], m_temp[1] / m_temp[2], oldx, oldy);
						/////////////
						m_temp=er.modelList[i].cam.K * Point3d(oldx,oldy,1);
						vcg::Point2<float> newPoint(m_temp.X(),m_temp.Y());

						if((newPoint.X()- (int)newPoint.X())>0,5)
							newPoint.X()++;
						if((newPoint.Y()- (int)newPoint.Y())>0,5)
							newPoint.Y()++;
						if(newPoint.X()>=0 && newPoint.X()<undistImg.width() && newPoint.Y()>=0 && newPoint.Y()< undistImg.height())
							undistImg.setPixel((int)newPoint.X(),(int)newPoint.Y(),qRgba(qRed(value),qGreen(value),qBlue(value), qAlpha(value)));
					}



					PullPush(undistImg,qRgba(0,0,0,255));
					undistImg.save(path);
					rm->currentPlane->image= undistImg;
					rm->currentPlane->fullPathFileName=path;
					QString newLabel = rm->label();
					newLabel.remove(suffix);
					newLabel.append("Undist" + suffix);
					rm->setLabel(newLabel);
					md->setBusy(false);

			}
			Matrix44f transf;
			transf.SetRotateDeg(180,Point3f(1.0,0.0,0.0));
			rm->shot.ApplyRigidTransformation(transf);
			//// end undistort
		}
	}
}

void EditArc3DPlugin::ExportPly()
{
	md->setBusy(true);
	md->addNewMesh("",er.name,true);
	MeshModel* m=md->mm();

	// Options collection

	int t0=clock();

	int subSampleVal = arc3DDialog->ui.subsampleSpinBox->value();
	int minCountVal= arc3DDialog->ui.minCountSpinBox->value();
	float maxCCDiagVal= arc3DDialog->ui.maxCCDiagSpinBox->value();
	int smoothSteps=arc3DDialog->ui.smoothSpinBox->value();
	bool closeHole = arc3DDialog->ui.holeCheckBox->isChecked();
	int maxHoleSize = arc3DDialog->ui.holeSpinBox->value();

	CMeshO mm;
	QTableWidget *qtw=arc3DDialog->ui.imageTableWidget;
	float MinAngleCos=cos(vcg::math::ToRad(arc3DDialog->ui.qualitySpinBox->value()));
	bool removeSmallCC=arc3DDialog->ui.removeSmallCCCheckBox->isChecked();
	//vcg::tri::Clustering<CMeshO, vcg::tri::AverageColorCell<CMeshO> > Grid;

	int selectedNum=0,selectedCount=0;
	int i;
	 for(i=0;i<qtw->rowCount();++i) if(qtw->isItemSelected(qtw->item(i,0))) ++selectedNum;

	bool dilationFlag = arc3DDialog->ui.dilationCheckBox->isChecked();
	int dilationN = arc3DDialog->ui.dilationNumPassSpinBox->value();
	int dilationSz = arc3DDialog->ui.dilationSizeSlider->value() * 2 + 1;
	bool erosionFlag = arc3DDialog->ui.erosionCheckBox->isChecked();
	int erosionN = arc3DDialog->ui.erosionNumPassSpinBox->value();
	int erosionSz = arc3DDialog->ui.erosionSizeSlider->value() * 2 + 1;
	float scalingFactor = arc3DDialog->ui.scaleLineEdit->text().toFloat();
	std::vector<string> savedMeshVector;

// Generating a mesh for each selected image

	bool firstTime=true;
	QList<Arc3DModel>::iterator li;
	for(li=er.modelList.begin(), i=0;li!=er.modelList.end();++li,++i)
	{
			if(qtw->isItemSelected(qtw->item(i,0)))
			{
				++selectedCount;
				mm.Clear();
				int tt0=clock();
				(*li).BuildMesh(mm,subSampleVal,minCountVal,MinAngleCos,smoothSteps,
					dilationFlag, dilationN, dilationSz, erosionFlag, erosionN, erosionSz,scalingFactor);
				int tt1=clock();
				this->Log(GLLogStream::SYSTEM,"** Mesh %i : Build in %i\n",selectedCount,tt1-tt0);
				m->cm.Clear();
				tri::Append<CMeshO,CMeshO>::Mesh(m->cm,mm); // append mesh mr to ml

				int tt2=clock();
				this->Log(GLLogStream::SYSTEM,"** Mesh %i : Append in %i\n",selectedCount,tt2-tt1);
			}
	}

	int t1=clock();
	this->Log(GLLogStream::SYSTEM,"Extracted %i meshes in %i\n",selectedCount,t1-t0);

///// Removing connected components

	if(removeSmallCC)
	{
		m->updateDataMask(MeshModel::MM_FACEFACETOPO | MeshModel::MM_FACEMARK);
		tri::Clean<CMeshO>::RemoveSmallConnectedComponentsDiameter(m->cm,m->cm.bbox.Diag()*maxCCDiagVal/100.0);
	}

	int t2=clock();
	this->Log(GLLogStream::SYSTEM,"Topology and removed CC in %i\n",t2-t1);

	vcg::tri::UpdateBounding<CMeshO>::Box(m->cm);					// updates bounding box

// Hole filling

	if(closeHole)
	{
		m->updateDataMask(MeshModel::MM_FACEFACETOPO | MeshModel::MM_FACEMARK);
		tri::UpdateNormal<CMeshO>::PerVertexNormalizedPerFace(m->cm);
		vcg::tri::Hole<CMeshO>::EarCuttingFill<vcg::tri::MinimumWeightEar< CMeshO> >(m->cm,maxHoleSize,false);
	}

	m->updateDataMask(MeshModel::MM_VERTCOLOR);

	Matrix44f transf;
	transf.SetRotateDeg(180,Point3f(1.0,0.0,0.0));

	m->cm.Tr=transf;
	tri::UpdatePosition<CMeshO>::Matrix(m->cm, m->cm.Tr);
	tri::UpdateNormal<CMeshO>::PerVertexMatrix(m->cm,m->cm.Tr);
	tri::UpdateNormal<CMeshO>::PerFaceMatrix(m->cm,m->cm.Tr);
	tri::UpdateBounding<CMeshO>::Box(m->cm);
	m->cm.Tr.SetIdentity();
	m->cm.shot.ApplyRigidTransformation(transf);

	int t3=clock();
	this->Log(GLLogStream::SYSTEM,"---------- Total Processing Time%i\n\n\n",t3-t0);

//.........这里部分代码省略.........