lucaspalomodevelop/meshlab
1
0
Fork 0
mirror of https://github.com/lucaspalomodevelop/meshlab.git synced 2026-03-20 03:16:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added rigid transformation filters for cameras (or group of cameras. Preliminary testing completed.

Browse Source
This commit is contained in:
Matteo Dellepiane matteodelle 2011-05-26 12:49:25 +00:00
parent 8ef516d7b5
commit 0726ceaf3c
2 changed files with 271 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

293
src/meshlabplugins/filter_camera/filter_camera.cpp
View File

@ -36,8 +36,9 @@ FilterCameraPlugin::FilterCameraPlugin()
FP_SET_MESH_CAMERA <<
FP_SET_RASTER_CAMERA <<
FP_QUALITY_FROM_CAMERA <<
FP_MESHCAMERA_SCALE<<
FP_RASTERCAMERA_SCALE<<
FP_CAMERA_ROTATE<<
FP_CAMERA_SCALE<<
FP_CAMERA_TRANSLATE<<
FP_CAMERA_EDIT;
foreach(FilterIDType tt , types())
@ -51,8 +52,9 @@ QString FilterCameraPlugin::filterName(FilterIDType filterId) const
case FP_SET_MESH_CAMERA : return QString("Set Mesh Camera");
case FP_SET_RASTER_CAMERA : return QString("Set Raster Camera");
case FP_QUALITY_FROM_CAMERA : return QString("Vertex Quality from Camera");
case FP_MESHCAMERA_SCALE : return QString("Scale Mesh Camera");
case FP_RASTERCAMERA_SCALE : return QString("Scale Raster Camera");
case FP_CAMERA_ROTATE : return QString("Transform: Rotate Camera or set of cameras");
case FP_CAMERA_SCALE : return QString("Transform: Scale Camera or set of cameras");
case FP_CAMERA_TRANSLATE : return QString("Transform: Translate Camera or set of cameras");
case FP_CAMERA_EDIT : return QString("Edit Raster Camera");
default : assert(0);
}
@ -65,8 +67,9 @@ QString FilterCameraPlugin::filterInfo(FilterIDType filterId) const
case FP_SET_MESH_CAMERA : return QString("This filter allow to set a shot for the current mesh");
case FP_SET_RASTER_CAMERA : return QString("This filter allow to set a shot for the current mesh");
case FP_QUALITY_FROM_CAMERA : return QString("Compute vertex quality using the camera definition, according to viewing angle or distance");
case FP_MESHCAMERA_SCALE : return QString("Scale the mesh camera");
case FP_RASTERCAMERA_SCALE : return QString("Scale the raster camera, or all the raster cameras of the project");
case FP_CAMERA_ROTATE : return QString("Rotate the camera, or all the cameras of the project. The selected raster is the reference if viewpoint rotation is selected.");
case FP_CAMERA_SCALE : return QString("Scale the camera, or all the cameras of the project. The selected raster is the reference if viewpoint scaling is selected.");
case FP_CAMERA_TRANSLATE : return QString("Translate the camera, or all the cameras of the project.");
case FP_CAMERA_EDIT : return QString("Allow to edit the current raster camera allowing to tweak intrinsics.");
default : assert(0);
}
@ -81,12 +84,60 @@ void FilterCameraPlugin::initParameterSet(QAction *action, MeshDocument &/*m*/,
case FP_CAMERA_EDIT :
parlst.addParam(new RichDynamicFloat("fov_scale", 0, -3,3,"Scaling exp", "Exponent of the scaling factor. 0 means no scaling, 1 means 10 times larger, -1 means 1/10."));
break;
case FP_MESHCAMERA_SCALE :
parlst.addParam(new RichFloat("scale", 1.0, "Scale factor", "The scale factor that has to be applied to the camera"));
case FP_CAMERA_ROTATE :
{
QStringList shotType;
shotType.push_back("Raster Camera");
shotType.push_back("Mesh Camera");
parlst.addParam(new RichEnum("camera", 0, shotType, tr("Camera type"), tr("Choose the camera to scale")));
QStringList rotMethod;
rotMethod.push_back("X axis");
rotMethod.push_back("Y axis");
rotMethod.push_back("Z axis");
rotMethod.push_back("custom axis");
parlst.addParam(new RichEnum("rotAxis", 0, rotMethod, tr("Rotation on:"), tr("Choose a method")));
QStringList rotCenter;
rotCenter.push_back("origin");
rotCenter.push_back("camera viewpoint");
rotCenter.push_back("custom point");
parlst.addParam(new RichEnum("rotCenter", 0, rotCenter, tr("Center of rotation:"), tr("Choose a method")));
parlst.addParam(new RichDynamicFloat("angle",0,-360,360,"Rotation Angle","Angle of rotation (in <b>degree</b>). If snapping is enable this vaule is rounded according to the snap value"));
parlst.addParam(new RichPoint3f("customAxis",Point3f(0,0,0),"Custom axis","This rotation axis is used only if the 'custom axis' option is chosen."));
parlst.addParam(new RichPoint3f("customCenter",Point3f(0,0,0),"Custom center","This rotation center is used only if the 'custom point' option is chosen."));
parlst.addParam(new RichBool ("toallRaster", false, "Apply to all Raster layers", "Apply the same scaling to all the Raster layers: it is taken into account only if 'Raster Camera' is selected"));
parlst.addParam(new RichBool ("toall", false, "Apply to all Raster and Mesh layers", "Apply the same scaling to all the layers, including any 3D layer"));
}
break;
case FP_RASTERCAMERA_SCALE :
case FP_CAMERA_SCALE :
{
QStringList shotType;
shotType.push_back("Raster Camera");
shotType.push_back("Mesh Camera");
parlst.addParam(new RichEnum("camera", 0, shotType, tr("Camera type"), tr("Choose the camera to scale")));
QStringList scaleCenter;
scaleCenter.push_back("origin");
scaleCenter.push_back("camera viewpoint");
scaleCenter.push_back("custom point");
parlst.addParam(new RichEnum("scaleCenter", 0, scaleCenter, tr("Center of scaling:"), tr("Choose a method")));
parlst.addParam(new RichPoint3f("customCenter",Point3f(0,0,0),"Custom center","This scaling center is used only if the 'custom point' option is chosen."));
parlst.addParam(new RichFloat("scale", 1.0, "Scale factor", "The scale factor that has to be applied to the camera"));
parlst.addParam(new RichBool ("toall", false, "Apply to all Raster layers", "Apply the same scaling to all the Raster layers"));
parlst.addParam(new RichBool ("toallRaster", false, "Apply to all Raster layers", "Apply the same scaling to all the Raster layers: it is taken into account only if 'Raster Camera' is selected"));
parlst.addParam(new RichBool ("toall", false, "Apply to all Raster and Mesh layers", "Apply the same scaling to all the layers, including any 3D layer"));
}
break;
case FP_CAMERA_TRANSLATE :
{
QStringList shotType;
shotType.push_back("Raster Camera");
shotType.push_back("Mesh Camera");
parlst.addParam(new RichEnum("camera", 0, shotType, tr("Camera type"), tr("Choose the camera to scale")));
parlst.addParam(new RichDynamicFloat("axisX",0,-1000,1000,"X Axis","Absolute translation amount along the X axis"));
parlst.addParam(new RichDynamicFloat("axisY",0,-1000,1000,"Y Axis","Absolute translation amount along the Y axis"));
parlst.addParam(new RichDynamicFloat("axisZ",0,-1000,1000,"Z Axis","Absolute translation amount along the Z axis"));
parlst.addParam(new RichBool("centerFlag",false,"translate viewpoint position to the origin","If selected, the camera viewpoint is translated to the origin"));
parlst.addParam(new RichBool ("toallRaster", false, "Apply to all Raster layers", "Apply the same scaling to all the Raster layers: it is taken into account only if 'Raster Camera' is selected"));
parlst.addParam(new RichBool ("toall", false, "Apply to all Raster and Mesh layers", "Apply the same scaling to all the layers, including any 3D layer"));
}
break;
case FP_SET_RASTER_CAMERA :
parlst.addParam(new RichShotf ("Shot", defShot, "New shot", "This filter allow to set a shot for the current raster."));
@ -112,20 +163,210 @@ bool FilterCameraPlugin::applyFilter(QAction *filter, MeshDocument &md, RichPara
RasterModel *rm = md.rm();
switch(ID(filter))
{
case FP_MESHCAMERA_SCALE :
case FP_CAMERA_ROTATE :
{
float scale = par.getFloat("scale");
cm.shot.RescalingWorld(scale);
}
case FP_RASTERCAMERA_SCALE :
{
float scale = par.getFloat("scale");
if (!par.getBool("toall"))
rm->shot.RescalingWorld(scale);
else
Matrix44f trRot; trRot.SetIdentity();
Point3f axis, tranVec;
Matrix44f trTran,trTranInv;
switch(par.getEnum("rotAxis"))
{
case 0: axis=Point3f(1,0,0); break;
case 1: axis=Point3f(0,1,0);break;
case 2: axis=Point3f(0,0,1);break;
case 3: axis=par.getPoint3f("customAxis");break;
}
switch(par.getEnum("rotCenter"))
{
case 0: tranVec=Point3f(0,0,0); break;
case 1: {
switch(par.getEnum("camera"))
{
case 0: tranVec=rm->shot.Extrinsics.Tra();
break;
case 1: tranVec=cm.shot.Extrinsics.Tra();
}
}
break;
case 2: tranVec=par.getPoint3f("customCenter");break;
}
float angleDeg= par.getDynamicFloat("angle");
trRot.SetRotateDeg(angleDeg,axis);
trTran.SetTranslate(tranVec);
trTranInv.SetTranslate(-tranVec);
//cm.Tr=trTran*trRot*trTranInv;
Matrix44f transf=trTran*trRot*trTranInv;
if (par.getBool("toall"))
{
for (int i=0; i<md.meshList.size(); i++)
{
md.meshList[i]->cm.Tr=transf;
tri::UpdatePosition<CMeshO>::Matrix(md.meshList[i]->cm, md.meshList[i]->cm.Tr);
tri::UpdateNormals<CMeshO>::PerVertexMatrix(md.meshList[i]->cm,md.meshList[i]->cm.Tr);
tri::UpdateNormals<CMeshO>::PerFaceMatrix(md.meshList[i]->cm,md.meshList[i]->cm.Tr);
tri::UpdateBounding<CMeshO>::Box(md.meshList[i]->cm);
md.meshList[i]->cm.Tr.SetIdentity();
md.meshList[i]->cm.shot.ApplyRigidTransformation(transf);
}
for (int i=0; i<md.rasterList.size(); i++)
{
md.rasterList[i]->shot.ApplyRigidTransformation(transf);
}
}
else if (par.getBool("toallRaster") && (par.getEnum("camera")==0))
{
for (int i=0; i<md.rasterList.size(); i++)
md.rasterList[i]->shot.RescalingWorld(scale);
{
md.rasterList[i]->shot.ApplyRigidTransformation(transf);
}
}
else switch(par.getEnum("camera"))
{
case 0:
{
rm->shot.ApplyRigidTransformation(transf);
}
case 1:
{
cm.shot.ApplyRigidTransformation(transf);
}
}
}
break;
case FP_CAMERA_SCALE :
{
Matrix44f trScale; trScale.SetIdentity();
Point3f tranVec;
Matrix44f trTran,trTranInv;
float Scale= par.getFloat("scale");
trScale.SetScale(Scale,Scale,Scale);
switch(par.getEnum("scaleCenter"))
{
case 0: tranVec=Point3f(0,0,0); break;
case 1:
{
switch(par.getEnum("camera"))
{
case 0: tranVec=rm->shot.Extrinsics.Tra();
break;
case 1: tranVec=cm.shot.Extrinsics.Tra();
}
}
break;
case 2: tranVec=par.getPoint3f("customCenter");break;
}
trTran.SetTranslate(tranVec);
trTranInv.SetTranslate(-tranVec);
if (par.getBool("toall"))
{
for (int i=0; i<md.meshList.size(); i++)
{
md.meshList[i]->cm.Tr=trTran*trScale*trTranInv;
tri::UpdatePosition<CMeshO>::Matrix(md.meshList[i]->cm, md.meshList[i]->cm.Tr);
tri::UpdateNormals<CMeshO>::PerVertexMatrix(md.meshList[i]->cm,md.meshList[i]->cm.Tr);
tri::UpdateNormals<CMeshO>::PerFaceMatrix(md.meshList[i]->cm,md.meshList[i]->cm.Tr);
tri::UpdateBounding<CMeshO>::Box(md.meshList[i]->cm);
md.meshList[i]->cm.Tr.SetIdentity();
md.meshList[i]->cm.shot.ApplyRigidTransformation(trTran);
md.meshList[i]->cm.shot.RescalingWorld(trScale[0][0]);
md.meshList[i]->cm.shot.ApplyRigidTransformation(trTranInv);
}
for (int i=0; i<md.rasterList.size(); i++)
{
md.rasterList[i]->shot.ApplyRigidTransformation(trTran);
md.rasterList[i]->shot.RescalingWorld(trScale[0][0]);
md.rasterList[i]->shot.ApplyRigidTransformation(trTranInv);
}
}
else if (par.getBool("toallRaster") && (par.getEnum("camera")==0))
{
for (int i=0; i<md.rasterList.size(); i++)
{
md.rasterList[i]->shot.ApplyRigidTransformation(trTran);
md.rasterList[i]->shot.RescalingWorld(trScale[0][0]);
md.rasterList[i]->shot.ApplyRigidTransformation(trTranInv);
}
}
else switch(par.getEnum("camera"))
{
case 0:
{
rm->shot.ApplyRigidTransformation(trTran);
rm->shot.RescalingWorld(Scale);
rm->shot.ApplyRigidTransformation(trTranInv);
}
case 1:
{
cm.shot.ApplyRigidTransformation(trTran);
cm.shot.RescalingWorld(Scale);
cm.shot.ApplyRigidTransformation(trTranInv);
}
}
}
break;
case FP_CAMERA_TRANSLATE :
{
Matrix44f trTran; trTran.SetIdentity();
float xScale= par.getDynamicFloat("axisX");
float yScale= par.getDynamicFloat("axisY");
float zScale= par.getDynamicFloat("axisZ");
trTran.SetTranslate(xScale,yScale,zScale);
if(par.getBool("centerFlag"))
switch(par.getEnum("camera"))
{
case 0: trTran.SetTranslate(-rm->shot.Extrinsics.Tra());
break;
case 1: trTran.SetTranslate(-cm.shot.Extrinsics.Tra());
}
if (par.getBool("toall"))
{
for (int i=0; i<md.meshList.size(); i++)
{
md.meshList[i]->cm.Tr=trTran;
tri::UpdatePosition<CMeshO>::Matrix(md.meshList[i]->cm, md.meshList[i]->cm.Tr);
tri::UpdateNormals<CMeshO>::PerVertexMatrix(md.meshList[i]->cm,md.meshList[i]->cm.Tr);
tri::UpdateNormals<CMeshO>::PerFaceMatrix(md.meshList[i]->cm,md.meshList[i]->cm.Tr);
tri::UpdateBounding<CMeshO>::Box(md.meshList[i]->cm);
md.meshList[i]->cm.Tr.SetIdentity();
md.meshList[i]->cm.shot.ApplyRigidTransformation(trTran);
}
for (int i=0; i<md.rasterList.size(); i++)
{
md.rasterList[i]->shot.ApplyRigidTransformation(trTran);
}
}
else if (par.getBool("toallRaster") && (par.getEnum("camera")==0))
{
for (int i=0; i<md.rasterList.size(); i++)
{
md.rasterList[i]->shot.ApplyRigidTransformation(trTran);
}
}
else switch(par.getEnum("camera"))
{
case 0:
{
rm->shot.ApplyRigidTransformation(trTran);
}
case 1:
{
cm.shot.ApplyRigidTransformation(trTran);
}
}
}
break;
@ -191,8 +432,9 @@ int FilterCameraPlugin::postCondition(QAction * filter) const
switch (ID(filter))
{
case FP_SET_MESH_CAMERA :
case FP_MESHCAMERA_SCALE : return MeshModel::MM_CAMERA;
case FP_RASTERCAMERA_SCALE : return MeshModel::MM_CAMERA;
case FP_CAMERA_ROTATE :
case FP_CAMERA_TRANSLATE :
case FP_CAMERA_SCALE : return MeshModel::MM_CAMERA;
case FP_QUALITY_FROM_CAMERA : return MeshModel::MM_VERTQUALITY + MeshModel::MM_VERTCOLOR;
default : return MeshModel::MM_UNKNOWN;
}
@ -202,8 +444,9 @@ int FilterCameraPlugin::postCondition(QAction * filter) const
{
switch(ID(a))
{
case FP_MESHCAMERA_SCALE :
case FP_RASTERCAMERA_SCALE :
case FP_CAMERA_ROTATE :
case FP_CAMERA_SCALE :
case FP_CAMERA_TRANSLATE :
case FP_CAMERA_EDIT :
case FP_SET_MESH_CAMERA :
case FP_SET_RASTER_CAMERA :

5
src/meshlabplugins/filter_camera/filter_camera.h
View File

@ -37,8 +37,9 @@ public:
enum { FP_SET_MESH_CAMERA,
FP_SET_RASTER_CAMERA,
FP_QUALITY_FROM_CAMERA,
FP_MESHCAMERA_SCALE,
FP_RASTERCAMERA_SCALE,
FP_CAMERA_ROTATE,
FP_CAMERA_SCALE,
FP_CAMERA_TRANSLATE,
FP_CAMERA_EDIT};
FilterCameraPlugin();