Documentation


GeoLink.cpp

Go to the documentation of this file.
00001 
00002 #include "GeoLink.h"
00003 
00004 namespace animal
00005 {
00006 namespace octree
00007 {
00008     /*
00009      * Give us the 8 pointers to our parents
00010      * Plus the number of geo linked parents and their corresponding IDs in the "allParents" array
00011      * Also give the fact that it's a hard link (for example, that the vertex IS NOT FREE)
00012      * or soft link (free, but from multiresolution edition, it can be moved)
00013      *
00014      * If the geolink is a hard link, then the parameters should never be updated !
00015      */
00016 GeoLink::GeoLink( vector<ConstrainedVertex*> allParents, vector<unsigned short> geoParentsIds, bool isSoftLink, ConstrainedVertex *vertex ) :
00017     _parents(allParents), _geoParentsIds(geoParentsIds), 
00018     _isSoftLink(true), _vertex(vertex),
00019     _alpha(0), _beta(0), _gamma(0)
00020 {
00021     for( vector<ConstrainedVertex*>::iterator it = _parents.begin() ; it != _parents.end() ; ++it )
00022         (*it)->addChild( vertex );
00023         
00024 //  //updateParameters();
00025 
00026     _isSoftLink = isSoftLink;
00027 }
00028     
00029 GeoLink::~GeoLink()
00030 {
00031     //std::cerr << "~GeoLink()\n";
00032 
00033     for( vector<ConstrainedVertex*>::iterator it = _parents.begin() ; it != _parents.end() ; ++it )
00034     {
00035         Require( (*it)->isChild(_vertex) );
00036         if( (*it)->isChild(_vertex) )
00037             (*it)->removeChild( _vertex );
00038     }
00039     
00040     //std::cerr << "~GeoLink() end\n";
00041 }
00042 
00043     /*
00044      * Return true IFF vertex is in geoParents
00045      * Require : isParent(vertex)
00046      */
00047 bool GeoLink::isGeoLinkParent( ConstrainedVertex *vertex )
00048 {
00049     Require( isParent( vertex) );
00050     
00051     for( vector<unsigned short>::iterator itId = _geoParentsIds.begin() ; itId != _geoParentsIds.end() ; ++itId )
00052         if( _parents[*itId] == vertex )
00053             return true;
00054             
00055     return false;
00056 }
00057     
00058     
00059 unsigned short GeoLink::getNGeoParents() const
00060 {
00061     return _geoParentsIds.size();
00062 }
00063     
00064     
00065 
00066      
00067      /*
00068       * Return true if it's a soft link, and false if it's a hard link
00069         */
00070 bool GeoLink::isFree()  const
00071 {
00072     return _isSoftLink;
00073 }
00074 
00075 
00076 /*
00077         * Free it : make it a soft link and no more a hard link
00078         * Require : !isFree()
00079         * Ensure : isFree()
00080         */
00081         void GeoLink::freeIt()
00082         {
00083             Require( !isFree() );
00084             _isSoftLink = true;
00085             Ensure( isFree() );
00086         }
00087 
00088         /*
00089         * Make it a soft link :
00090         * Require : isFree()
00091         * Require : vertices are parents
00092         * Ensure : isFree()
00093         */
00094         void GeoLink::softLinkIt( ConstrainedVertex *v1, ConstrainedVertex *v2  )
00095         {
00096             // MUST PROJECT IT !
00097             Require( isFree() );
00098             Require( isParent( v1 ) );
00099             Require( isParent( v2 ) );
00100 
00101             Require( _geoParentsIds.size() == 0 );
00102 
00103             for( unsigned short i=0 ; i<8 ; ++i )
00104                 if( (_parents[i] == v1) || (_parents[i] == v2) )
00105                     _geoParentsIds.push_back(i);
00106 
00107             // Update coords !
00109 
00110             Ensure(isFree());
00111         }
00112         
00113         /*
00114         * Make it a soft link :
00115         * Require : isFree()
00116         * Require : vertices are parents
00117         * Ensure : isFree()
00118         */
00119         void GeoLink::softLinkIt( ConstrainedVertex *v1, ConstrainedVertex *v2, ConstrainedVertex *v3, ConstrainedVertex *v4  )
00120         {
00121             // MUST PROJECT IT !
00122             Require( isFree() );
00123             Require( isParent( v1 ) );
00124             Require( isParent( v2 ) );
00125             Require( isParent( v3 ) );
00126             Require( isParent( v4 ) );
00127 
00128             Require( _geoParentsIds.size() == 0 );
00129 
00130             for( unsigned short i=0 ; i<8 ; ++i )
00131                 if( (_parents[i] == v1) || (_parents[i] == v2) || (_parents[i] == v3) || (_parents[i] == v4) )
00132                     _geoParentsIds.push_back(i);
00133 
00134             // Update coords !
00135             //updateParameters();
00136 
00137             Ensure(isFree());
00138         }       
00139         /*
00140         * Make it a soft link :
00141         * Require : isFree()
00142         * Require : vertices are parents
00143         * Ensure : isFree()
00144         */
00145         void GeoLink::softLinkIt( ConstrainedVertex *v1, ConstrainedVertex *v2, ConstrainedVertex *v3, ConstrainedVertex *v4, ConstrainedVertex *v5, ConstrainedVertex *v6, ConstrainedVertex *v7, ConstrainedVertex *v8  )
00146         {
00147             // MUST PROJECT IT !
00148             Require( isFree() );
00149             Require( isParent( v1 ) );
00150             Require( isParent( v2 ) );
00151             Require( isParent( v3 ) );
00152             Require( isParent( v4 ) );
00153             Require( isParent( v5 ) );
00154             Require( isParent( v6 ) );
00155             Require( isParent( v7 ) );
00156             Require( isParent( v8 ) );
00157 
00158             Require( _geoParentsIds.size() == 0 );
00159 
00160             for( unsigned short i=0 ; i<8 ; ++i )
00161                 _geoParentsIds.push_back(i);
00162 
00163             // Update coords !
00164             //updateParameters();
00165 
00166             Ensure(isFree());
00167         }       
00168 
00169                 
00170         /*
00171         * Make it a hard link : project the point on the line
00172         * Require : isFree()
00173         * Require : vertices are parents
00174         * Ensure : ! isFree()
00175         */
00176         void GeoLink::hardLinkIt( ConstrainedVertex *v1, ConstrainedVertex *v2  )
00177         {
00178             // MUST PROJECT IT !
00179             Require( isFree() );
00180             Require( isParent( v1 ) );
00181             Require( isParent( v2 ) );
00182             
00183             Require(v1->isChild(_vertex));
00184             Require(v2->isChild(_vertex));
00185             
00186             /*
00187             if( !v1->isChild(_vertex) )
00188                 v1->addChild(_vertex);
00189             if( !v2->isChild(_vertex) )
00190                 v2->addChild(_vertex);
00191             */
00192             // _geoParentsIds are the same for hard and soft links !
00193             /*
00194             Require( _geoParentsIds.size() == 0 );
00195 
00196             for( unsigned short i=0 ; i<8 ; ++i )
00197                 if( (_parents[i] == v1) || (_parents[i] == v2) )
00198                     _geoParentsIds.push_back(i);
00199             */
00200             
00201             // Update coords !
00202             //updateParameters();
00203 
00204             _isSoftLink = false;
00205 
00206             Ensure( !isFree() );
00207         }
00208 
00209         /*
00210         * Make it a hard link : project the point on the plane
00211         * Require : isFree()
00212         * Require : vertices are parents
00213         */
00214         void GeoLink::hardLinkIt( ConstrainedVertex *v1, ConstrainedVertex *v2, ConstrainedVertex *v3, ConstrainedVertex *v4  )
00215         {
00216                     // MUST PROJECT IT !
00217             Require( isFree() );
00218             Require( isParent( v1 ) );
00219             Require( isParent( v2 ) );
00220             Require( isParent( v3 ) );
00221             Require( isParent( v4 ) );
00222 
00223             Require(v1->isChild(_vertex));
00224             Require(v2->isChild(_vertex));
00225             Require(v3->isChild(_vertex));
00226             Require(v4->isChild(_vertex));
00227 
00228             /*          
00229             if( !v1->isChild(_vertex) )
00230                 v1->addChild(_vertex);
00231             if( !v2->isChild(_vertex) )
00232                 v2->addChild(_vertex);
00233             if( !v3->isChild(_vertex) )
00234                 v3->addChild(_vertex);
00235             if( !v4->isChild(_vertex) )
00236                 v4->addChild(_vertex);
00237             */
00238             
00239             // _geoParentsIds are the same for hard and soft links !
00240             /*
00241             Require( _geoParentsIds.size() == 0 );
00242 
00243             for( unsigned short i=0 ; i<8 ; ++i )
00244                 if( (_parents[i] == v1) || (_parents[i] == v2) || (_parents[i] == v3) || (_parents[i] == v4) )
00245                     _geoParentsIds.push_back(i);
00246             */
00247             
00248             // Update coords !
00249             //updateParameters();
00250 
00251             _isSoftLink = false;
00252 
00253             Ensure( !isFree() );
00254         }
00255 
00256 
00257     /*
00258     * Return true IFF vertex is in parents list
00259     * Used only for debug
00260     */
00261     bool GeoLink::isParent(  const ConstrainedVertex *vertex ) 
00262     {
00263         for( vector<ConstrainedVertex*>::iterator it = _parents.begin() ; it != _parents.end() ; ++it )
00264             if( *it == vertex )
00265                 return true;
00266 
00267         return false;
00268     }
00269     
00270     void GeoLink::print()
00271     {
00272         std::cerr << "Parents :\n";
00273         for( vector<ConstrainedVertex*>::iterator it = _parents.begin() ; it != _parents.end() ; ++it )
00274             std::cerr << "\t" << *it << "\n";
00275         std::cerr << "Geo Parents id : ";
00276         for( vector<unsigned short>::iterator itId = _geoParentsIds.begin() ; itId != _geoParentsIds.end() ; ++itId )
00277             std::cerr << *itId << " ";
00278         std::cerr << "\n";
00279     }
00280 
00281     
00282     void GeoLink::changeCell( Cell *cell )
00283     {
00284         //std::cerr << "changeCell(" << *cell << ")\n";
00285         
00286         bool wasFree = isFree();
00287         
00288         for( vector<ConstrainedVertex*>::iterator it = _parents.begin() ; it != _parents.end() ; ++it )
00289         {
00290             Require( (*it)->isChild(_vertex) );
00291             if( (*it)->isChild(_vertex) )
00292                 (*it)->removeChild( _vertex );
00293         }
00294                         
00295         vector<ConstrainedVertex*> newParents;
00296         for( unsigned short i=0 ; i<8 ; ++i )
00297         {
00298             newParents.push_back(cell->father()->vertex(i));
00299             newParents[i]->addChild( _vertex );
00300         }
00301 
00302         //
00303         
00304         _isSoftLink = true;
00305 
00306         unsigned short ngp = getNGeoParents();
00307         
00308         ConstrainedVertex *oldP[ngp];
00309         for( unsigned int i=0 ; i<ngp ; ++i )
00310             oldP[i] = getGeoParent(getGeoParentId(i));              
00311             
00312         _parents = newParents;
00313         _geoParentsIds.clear();
00314         if( ngp == 2 )
00315         {
00316             this->softLinkIt( oldP[0], oldP[1] );
00317         }
00318         else if( ngp == 4 )
00319         {
00320             this->softLinkIt( oldP[0], oldP[1], oldP[2], oldP[3] );
00321         }
00322         else if( ngp == 8 )
00323         {
00324             this->softLinkIt( oldP[0], oldP[1], oldP[2], oldP[3], oldP[4], oldP[5], oldP[6], oldP[7] );
00325         }
00326         else
00327         {
00328             // It's completely free !
00329         }
00330 
00331         // Let it be hard linked if needed      
00332         _isSoftLink = wasFree;
00333         
00334     }
00335      
00336 }
00337 }
00338 
00339         

Generated on Thu Dec 23 13:52:25 2004 by doxygen 1.3.6