Moka controler: src/lib-controler-gmap/parameter/parameter-controler/parameter-object-position.cc Source File

00001 /*
00002  * lib-controler-gmap : Le contrôleur de 3-G-cartes, surcouche de lib-controler.
00003  * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
00004  *               http://www.sic.sp2mi.univ-poitiers.fr/
00005  * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
00006  *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
00007  *
00008  * This file is part of lib-controler-gmap
00009  *
00010  * This program is free software: you can redistribute it and/or modify
00011  * it under the terms of the GNU Lesser General Public License as published by
00012  * the Free Software Foundation, either version 3 of the License, or
00013  * (at your option) any later version.
00014  *
00015  * This program is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public License
00021  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00022  */
00023 
00024 //******************************************************************************
00025 #include "controler-gmap-types.hh"
00026 #include "parameter-object-position.hh"
00027 #include "transformation-matrix.hh"
00028 #include "geometry.hh"
00029 using namespace std;
00030 using namespace GMap3d;
00031 //******************************************************************************
00032 /* Paramètres géométriques :
00033  *
00034  * C : Center
00035  * F : FirstVertex
00036  * N : Normal
00037  * R : Rotations
00038  * S : Scale
00039  * P : Proportions
00040  * D : Dimensions
00041  *
00042  * Dépendances : ("A -> B" signifie "quand on modifie A il mettre à jour B")
00043  *
00044  * C -> F
00045  * F -> NSPD
00046  * N -> FR
00047  * R -> NF
00048  * S -> FD
00049  * P -> DF
00050  * D -> F(P)  (P ssi D est différent du vecteur nul)
00051  */
00052 //******************************************************************************
00053 CParameterObjectPosition::CParameterObjectPosition(bool ANeedRotation,
00054                                                    int ANbRef) :
00055   CParameter   (ANbRef),
00056   FNeedRotation(ANeedRotation)
00057 {
00058   reinit();
00059 }
00060 //******************************************************************************
00061 CParameterObjectPosition::
00062 CParameterObjectPosition(const CParameterObjectPosition & AParam) :
00063   CParameter   (AParam),
00064   FNeedRotation(AParam.FNeedRotation)
00065 {
00066   setScale      (AParam.getScale());
00067   setProportions(AParam.getProportions());
00068   setCenter     (AParam.getCenter());
00069   setRotations  (AParam.getRotations());
00070 }
00071 //******************************************************************************
00072 CParameterObjectPosition::~CParameterObjectPosition()
00073 {}
00074 //******************************************************************************
00075 CParameter * CParameterObjectPosition::copy() const
00076 { return new CParameterObjectPosition(*this); }
00077 //******************************************************************************
00078 void CParameterObjectPosition::load(istream& /*AStream*/)
00079 {}
00080 //------------------------------------------------------------------------------
00081 void CParameterObjectPosition::save(ostream& /*AStream*/)
00082 {}
00083 //------------------------------------------------------------------------------
00084 void CParameterObjectPosition::reinit()
00085 {
00086   setScale      (1);
00087   setProportions(1, 1, 1);
00088   setCenter     (0, 0, 0);
00089   setRotations  (0, 0, 0);
00090 }
00091 //******************************************************************************
00092 float CParameterObjectPosition::getScale() const
00093 { return FScale; }
00094 //******************************************************************************
00095 void CParameterObjectPosition::setScale(float AScale)
00096 {
00097   if (FScale != AScale)
00098     {
00099       putAllNeedToUpdate();
00100 
00101       FScale = AScale;
00102 
00103       // Dimensions:
00104       FDimensions = 2 * FScale * FProportions;
00105 
00106       // First vertex:
00107       CTransformationMatrix matrix(CTransformationMatrix::IdentityMatrix);
00108       matrix.rotate(FRotations);
00109 
00110       CVertex x(OX);
00111       matrix.applyOn(x);
00112       FFirstVertex = FCenter + (getDimensionX() / 2) * x;
00113     }
00114 }
00115 //******************************************************************************
00116 float CParameterObjectPosition::getProportionX() const
00117 { return FProportions.getX(); }
00118 float CParameterObjectPosition::getProportionY() const
00119 { return FProportions.getY(); }
00120 float CParameterObjectPosition::getProportionZ() const
00121 { return FProportions.getZ(); }
00122 
00123 CVertex CParameterObjectPosition::getProportions() const
00124 { return FProportions; }
00125 //******************************************************************************
00126 void CParameterObjectPosition::setProportionX(float AX)
00127 { setProportions(AX, FProportions.getY(), FProportions.getZ()); }
00128 void CParameterObjectPosition::setProportionY(float AY)
00129 { setProportions(FProportions.getX(), AY, FProportions.getZ()); }
00130 void CParameterObjectPosition::setProportionZ(float AZ)
00131 { setProportions(FProportions.getX(), FProportions.getY(), AZ); }
00132 
00133 void CParameterObjectPosition::setProportions(float AX, float AY, float AZ)
00134 { setProportions(CVertex(AX, AY, AZ)); }
00135 
00136 void CParameterObjectPosition::setProportions(const CVertex & AValues)
00137 {
00138   if (FProportions != AValues)
00139     {
00140       putAllNeedToUpdate();
00141 
00142       FProportions = AValues;
00143 
00144       // Dimensions:
00145       FDimensions = 2 * getScale() * getProportions();
00146 
00147       // First vertex:
00148       CTransformationMatrix matrix(CTransformationMatrix::IdentityMatrix);
00149       matrix.rotate(FRotations);
00150       CVertex x(OX);
00151       matrix.applyOn(x);
00152       FFirstVertex = FCenter + (getDimensionX() / 2) * x;
00153     }
00154 }
00155 //******************************************************************************
00156 float CParameterObjectPosition::getDimensionX() const
00157 { return FDimensions.getX(); }
00158 float CParameterObjectPosition::getDimensionY() const
00159 { return FDimensions.getY(); }
00160 float CParameterObjectPosition::getDimensionZ() const
00161 { return FDimensions.getZ(); }
00162 
00163 CVertex CParameterObjectPosition::getDimensions() const
00164 { return FDimensions; }
00165 //******************************************************************************
00166 void CParameterObjectPosition::setDimensionX(float AX)
00167 { setDimensions(AX, FDimensions.getY(), FDimensions.getZ()); }
00168 void CParameterObjectPosition::setDimensionY(float AY)
00169 { setDimensions(FDimensions.getX(), AY, FDimensions.getZ()); }
00170 void CParameterObjectPosition::setDimensionZ(float AZ)
00171 { setDimensions(FDimensions.getX(), FDimensions.getY(), AZ); }
00172 
00173 void CParameterObjectPosition::setDimensions(float AX, float AY, float AZ)
00174 { setDimensions(CVertex(AX,AY,AZ)); }
00175 
00176 void CParameterObjectPosition::setDimensions(const CVertex & AValues)
00177 {
00178   if (FDimensions != AValues)
00179     {
00180       putAllNeedToUpdate();
00181 
00182       FDimensions = AValues;
00183 
00184       // Proportions:
00185       if (! FDimensions.isNull())
00186         FProportions = isZero(FScale) ? ORIGIN : FDimensions / 2 / getScale();
00187 
00188       // First vertex:
00189       CTransformationMatrix matrix(CTransformationMatrix::IdentityMatrix);
00190       matrix.rotate(getRotations());
00191       CVertex x(OX);
00192       matrix.applyOn(x);
00193       FFirstVertex = FCenter + (getDimensionX() / 2) * x;
00194     }
00195 }
00196 //******************************************************************************
00197 float CParameterObjectPosition::getCenterX() const
00198 { return FCenter.getX(); }
00199 float CParameterObjectPosition::getCenterY() const
00200 { return FCenter.getY(); }
00201 float CParameterObjectPosition::getCenterZ() const
00202 { return FCenter.getZ(); }
00203 
00204 CVertex CParameterObjectPosition::getCenter() const
00205 { return FCenter; }
00206 //******************************************************************************
00207 void CParameterObjectPosition::setCenterX(float AX)
00208 { setCenter(AX, FCenter.getY(), FCenter.getZ()); }
00209 void CParameterObjectPosition::setCenterY(float AY)
00210 { setCenter(FCenter.getX(), AY, FCenter.getZ()); }
00211 void CParameterObjectPosition::setCenterZ(float AZ)
00212 { setCenter(FCenter.getX(), FCenter.getY(), AZ); }
00213 
00214 void CParameterObjectPosition::setCenter(float AX, float AY, float AZ)
00215 { setCenter(CVertex(AX,AY,AZ)); }
00216 
00217 void CParameterObjectPosition::setCenter(const CVertex & AVertex)
00218 {
00219   if (FCenter != AVertex)
00220     {
00221       putAllNeedToUpdate();
00222 
00223       FCenter = AVertex;
00224 
00225       // First vertex:
00226       CTransformationMatrix matrix(CTransformationMatrix::IdentityMatrix);
00227       matrix.rotate(getRotations());
00228       CVertex x(OX);
00229       matrix.applyOn(x);
00230       FFirstVertex = FCenter + (getDimensionX() / 2) * x;
00231     }
00232 }
00233 //******************************************************************************
00234 float CParameterObjectPosition::getRotationX() const
00235 { return FRotations.getX(); }
00236 float CParameterObjectPosition::getRotationY() const
00237 { return FRotations.getY(); }
00238 float CParameterObjectPosition::getRotationZ() const
00239 { return FRotations.getZ(); }
00240 
00241 CVertex CParameterObjectPosition::getRotations() const
00242 {
00243   return FRotations;
00244 }
00245 //******************************************************************************
00246 void CParameterObjectPosition::setRotationX(float AAlpha)
00247 { setRotations(AAlpha, FRotations.getY(), FRotations.getZ()); }
00248 void CParameterObjectPosition::setRotationY(float ABeta)
00249 { setRotations(FRotations.getX(), ABeta, FRotations.getZ()); }
00250 void CParameterObjectPosition::setRotationZ(float AGamma)
00251 { setRotations(FRotations.getX(), FRotations.getY(), AGamma); }
00252 
00253 void CParameterObjectPosition::setRotations(float AAlpha,
00254                                             float ABeta,
00255                                             float AGamma)
00256 { setRotations(CVertex(AAlpha, ABeta, AGamma)); }
00257 
00258 void CParameterObjectPosition::setRotations(const CVertex & AAngles)
00259 {
00260   if (FRotations != AAngles)
00261     {
00262       putAllNeedToUpdate();
00263 
00264       FRotations = AAngles;
00265 
00266       CTransformationMatrix matrix(CTransformationMatrix::IdentityMatrix);
00267       matrix.rotate(AAngles);
00268 
00269       // First vertex:
00270       CVertex x(OX);
00271       matrix.applyOn(x);
00272       FFirstVertex = FCenter + (getDimensionX() / 2) * x;
00273 
00274       // Normal vector:
00275       CVertex z(OZ);
00276       matrix.applyOn(z);
00277       FNormalVector = z;
00278     }
00279 }
00280 //******************************************************************************
00281 float CParameterObjectPosition::getFirstVertexX() const
00282 { return FFirstVertex.getX(); }
00283 float CParameterObjectPosition::getFirstVertexY() const
00284 { return FFirstVertex.getY(); }
00285 float CParameterObjectPosition::getFirstVertexZ() const
00286 { return FFirstVertex.getZ(); }
00287 
00288 CVertex CParameterObjectPosition::getFirstVertex() const
00289 { return FFirstVertex; }
00290 //******************************************************************************
00291 void CParameterObjectPosition::setFirstVertexX(float AX, bool AKeepNormalVector)
00292 {
00293   setFirstVertex(AX, FFirstVertex.getY(), FFirstVertex.getZ(),
00294                  AKeepNormalVector);
00295 }
00296 void CParameterObjectPosition::setFirstVertexY(float AY, bool AKeepNormalVector)
00297 {
00298   setFirstVertex(FFirstVertex.getX(), AY, FFirstVertex.getZ(),
00299                  AKeepNormalVector);
00300 }
00301 void CParameterObjectPosition::setFirstVertexZ(float AZ, bool AKeepNormalVector)
00302 {
00303   setFirstVertex(FFirstVertex.getX(), FFirstVertex.getY(), AZ,
00304                  AKeepNormalVector);
00305 }
00306 
00307 void CParameterObjectPosition::setFirstVertex(float AX, float AY, float AZ,
00308                                               bool AKeepNormalVector)
00309 { setFirstVertex(CVertex(AX,AY,AZ), AKeepNormalVector); }
00310 
00311 void CParameterObjectPosition::setFirstVertex(const CVertex & AVertex,
00312                                               bool AKeepNormalVector)
00313 {
00314   if (FFirstVertex != AVertex)
00315     {
00316       putAllNeedToUpdate();
00317 
00318       FFirstVertex = AVertex;
00319 
00320       CVertex V(FFirstVertex - FCenter);
00321 
00322       // Proportions:
00323       if (isZero(FProportions.getX()))
00324         FProportions.setX(1);
00325 
00326       // Scale:
00327       FScale = V.norm() / FProportions.getX();
00328 
00329       // Dimensions:
00330       FDimensions = 2 * FScale * FProportions;
00331 
00332       // Normal vector: (ancien test : ! isZero(V.dot(FNormalVector)))
00333       if (! V.isNull() && ! AKeepNormalVector)
00334         FNormalVector = V * (isZero(V.getY()) ? OY : OX);
00335 
00336       // Rotations:
00337       FRotations = CGeometry::getAngles(V, FNormalVector);
00338     }
00339 }
00340 //******************************************************************************
00341 float CParameterObjectPosition::getNormalVectorX() const
00342 { return FNormalVector.getX(); }
00343 float CParameterObjectPosition::getNormalVectorY() const
00344 { return FNormalVector.getY(); }
00345 float CParameterObjectPosition::getNormalVectorZ() const
00346 { return FNormalVector.getZ(); }
00347 
00348 CVertex CParameterObjectPosition::getNormalVector() const
00349 { return FNormalVector; }
00350 //******************************************************************************
00351 void CParameterObjectPosition::setNormalVectorX(float AX)
00352 { setNormalVector(AX, FNormalVector.getY(), FNormalVector.getZ()); }
00353 void CParameterObjectPosition::setNormalVectorY(float AY)
00354 { setNormalVector(FNormalVector.getX(), AY, FNormalVector.getZ()); }
00355 void CParameterObjectPosition::setNormalVectorZ(float AZ)
00356 { setNormalVector(FNormalVector.getX(), FNormalVector.getY(), AZ); }
00357 
00358 void CParameterObjectPosition::setNormalVector(float AX, float AY, float AZ)
00359 { setNormalVector(CVertex(AX, AY, AZ)); }
00360 
00361 void CParameterObjectPosition::setNormalVector(const CVertex & AVector)
00362 {
00363   if (FNormalVector != AVector)
00364     {
00365       putAllNeedToUpdate();
00366 
00367       FNormalVector = AVector;
00368 
00369       // Rotations:
00370       FRotations = CGeometry::getAngles(FFirstVertex - FCenter, FNormalVector);
00371 
00372       // First vertex:
00373       CTransformationMatrix matrix(CTransformationMatrix::IdentityMatrix);
00374       matrix.rotate(FRotations);
00375       CVertex x(OX);
00376       matrix.applyOn(x);
00377       FFirstVertex = FCenter + (getDimensionX() / 2) * x;
00378     }
00379 }
00380 //******************************************************************************
00381 CTransformationMatrix CParameterObjectPosition::getTransformationMatrix() const
00382 {
00383   CTransformationMatrix matrix(CTransformationMatrix::IdentityMatrix);
00384 
00385   if (FNeedRotation)
00386     matrix.rotate(OY, 90);
00387 
00388   matrix.scale(FDimensions);
00389   matrix.rotate(FRotations);
00390   matrix.translate(FCenter);
00391 
00392   return matrix;
00393 }
00394 //******************************************************************************
00395 int CParameterObjectPosition::getType() const
00396 { return PARAMETER_OBJECT_POSITION; }
00397 //******************************************************************************