nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_FACE_GRID_H
+00027 #define NL_FACE_GRID_H
+00028 
+00029 #include <vector>
+00030 #include "nel/misc/types_nl.h"
+00031 #include "nel/misc/vector.h"
+00032 #include "nel/misc/file.h"
+00033 
+00034 #include "nel/misc/aabbox.h"
+00035 
+00036 #include "pacs/vector_2s.h"
+00037 #include "pacs/surface_quad.h"
+00038 #include "pacs/chain.h"
+00039 #include "pacs/retrievable_surface.h"
+00040 #include "pacs/chain_quad.h"
+00041 #include "pacs/exterior_mesh.h"
+00042 #include "pacs/quad_grid.h"
+00043 
+00044 #include "nel/pacs/u_global_position.h"
+00045 
+00046 
+00047 
+00048 namespace NLPACS
+00049 {
+00050 
+00057 class CFaceGrid
+00058 {
+00059 public:
+00066         class CFaceGridBuild
+00067         {
+00068         public:
+00070                 std::vector< std::vector<uint32> >      Grid;
+00071 
+00073                 uint                                                            Width;
+00074 
+00076                 float                                                           Size;
+00077 
+00078         public:
+00080                 void                                                            init(uint width, float elsize);
+00081 
+00083                 void                                                            insert(const NLMISC::CVector &bmin, const NLMISC::CVector &bmax, uint32 value);
+00084         };
+00085 
+00086 protected:
+00088         uint16                                  _Width;
+00090         uint16                                  _Log2Width;
+00091 
+00093         float                                   _ElSize;
+00094 
+00096         std::vector<uint32>             _Grid;
+00098         std::vector<uint32>             _GridData;
+00099 
+00100 public:
+00102         CFaceGrid() : _Width(0), _Log2Width(0), _ElSize(0.0f) {}
+00103         
+00104         
+00106         void                                    clear();
+00107 
+00109         void                                    create(const CFaceGridBuild &fgb);
+00110 
+00112         void                                    select(const NLMISC::CVector &pos, std::vector<uint32> &selected) const;
+00113 
+00115         void                                    serial(NLMISC::IStream &f);
+00116 };
+00117 
+00118 // CFaceGrid inline
+00119 
+00120 inline void CFaceGrid::clear()
+00121 {
+00122         _Width = 0;
+00123         _Log2Width = 0;
+00124         _ElSize = 0.0f;
+00125         _Grid.clear();
+00126         _GridData.clear();
+00127 }
+00128 
+00129 inline void CFaceGrid::create(const CFaceGrid::CFaceGridBuild &fgb)
+00130 {
+00131         nlassert(fgb.Grid.size() == fgb.Width*fgb.Width);
+00132         nlassert(fgb.Width < 32768);
+00133 
+00134         // clear first
+00135         clear();
+00136 
+00137         // setup grid size
+00138         _Width = (uint16)fgb.Width;
+00139         _ElSize = fgb.Size;
+00140         _Log2Width = NLMISC::getPowerOf2(_Width);
+00141 
+00142         // and store in packed format the data of the face grid build
+00143         uint    i;
+00144         for (i=0; i<fgb.Grid.size(); ++i)
+00145         {
+00146                 _Grid.push_back(_GridData.size());
+00147                 _GridData.insert(_GridData.end(), fgb.Grid[i].begin(), fgb.Grid[i].end());
+00148         }
+00149 }
+00150 
+00151 inline void     CFaceGrid::select(const NLMISC::CVector &pos, std::vector<uint32> &selected) const
+00152 {
+00153         selected.clear();
+00154 
+00155         uint    start, stop, idx;
+00156         uint    x, y;
+00157 
+00158         x = ((sint)(pos.x/_ElSize) & (_Width-1));
+00159         y = ((sint)(pos.y/_ElSize) & (_Width-1));
+00160 
+00161         idx = x+(y<<_Log2Width);
+00162 
+00163         start = _Grid[idx++];
+00164         stop = (idx == _Grid.size()) ? _GridData.size() : _Grid[idx];
+00165 
+00166         for (; start<stop; ++start)
+00167                 selected.push_back(_GridData[start]);
+00168 }
+00169 
+00170 inline void     CFaceGrid::serial(NLMISC::IStream &f)
+00171 {
+00172         /*
+00173         Version 0:
+00174                 - base version
+00175         */
+00176         (void)f.serialVersion(0);
+00177 
+00178         f.serial(_Width, _Log2Width, _ElSize);
+00179         f.serialCont(_Grid);
+00180         f.serialCont(_GridData);
+00181 }
+00182 
+00183 
+00184 
+00185 // CFaceGridBuild inline
+00186 
+00187 inline void     CFaceGrid::CFaceGridBuild::init(uint width, float elsize)
+00188 {
+00189         nlassert(NLMISC::isPowerOf2(width));
+00190         Width = width;
+00191         Size = elsize;
+00192         Grid.clear();
+00193         Grid.resize(Width*Width);
+00194 }
+00195 
+00196 inline void     CFaceGrid::CFaceGridBuild::insert(const NLMISC::CVector &bmin, 
+00197                                                                                           const NLMISC::CVector &bmax, 
+00198                                                                                           uint32 value)
+00199 {
+00200         sint    x0 = (sint)(bmin.x/Size),
+00201                         x1 = (sint)(bmax.x/Size),
+00202                         y0 = (sint)(bmin.y/Size),
+00203                         y1 = (sint)(bmax.y/Size);
+00204 
+00205         if (x1-x0 >= (sint)Width)
+00206         {
+00207                 x0 = 0;
+00208                 x1 = Width-1;
+00209         }
+00210         else
+00211         {
+00212                 x0 &= (Width-1);
+00213                 x1 &= (Width-1);
+00214                 if (x1 < x0)
+00215                         x1 += Width;
+00216         }
+00217 
+00218         if (y1-y0 >= (sint)Width)
+00219         {
+00220                 y0 = 0;
+00221                 y1 = Width-1;
+00222         }
+00223         else
+00224         {
+00225                 y0 &= (Width-1);
+00226                 y1 &= (Width-1);
+00227                 if (y1 < y0)
+00228                         y1 += Width;
+00229         }
+00230 
+00231         sint    x, y;
+00232 
+00233         for (y=y0; y<=y1; ++y)
+00234                 for (x=x0; x<=x1; ++x)
+00235                         Grid[(x&(Width-1))+(y&(Width-1))*Width].push_back(value);
+00236 }
+00237 
+00238 
+00239 }; // NLPACS
+00240 
+00241 #endif // NL_FACE_GRID_H
+00242 
+00243 /* End of face_grid.h */
+