00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #ifndef OPENMESH_VDPROGMESH_VHIERARCHYWINDOWS_HH
00033 #define OPENMESH_VDPROGMESH_VHIERARCHYWINDOWS_HH
00034
00035
00036
00037
00038 #include <OpenMesh/Tools/VDPM/VHierarchy.hh>
00039
00040
00041
00042
00043
00044
00045
00046 namespace OpenMesh {
00047 namespace VDPM {
00048
00049
00050
00051
00054 class VHierarchyWindow
00055 {
00056 private:
00057
00058
00059 VHierarchy *vhierarchy_;
00060
00061
00062 unsigned char *buffer_;
00063 int buffer_min_;
00064 int buffer_max_;
00065 int current_pos_;
00066
00067
00068 int window_min_;
00069 int window_max_;
00070
00071
00072
00073 unsigned char n_shift_;
00074
00075 unsigned char flag8(unsigned char n_shift) const
00076 { return 0x80 >> n_shift; }
00077
00078 unsigned char flag8(VHierarchyNodeHandle _node_handle) const
00079 {
00080 assert(_node_handle.idx() >= 0);
00081 return 0x80 >> (unsigned int) (_node_handle.idx() % 8);
00082 }
00083 int byte_idx(VHierarchyNodeHandle _node_handle) const
00084 {
00085 assert(_node_handle.idx() >= 0);
00086 return _node_handle.idx() / 8;
00087 }
00088 int buffer_idx(VHierarchyNodeHandle _node_handle) const
00089 { return byte_idx(_node_handle) - buffer_min_; }
00090
00091 bool before_window(VHierarchyNodeHandle _node_handle) const
00092 { return (_node_handle.idx()/8 < window_min_) ? true : false; }
00093
00094 bool after_window(VHierarchyNodeHandle _node_handle) const
00095 { return (_node_handle.idx()/8 < window_max_) ? false : true; }
00096
00097 bool underflow(VHierarchyNodeHandle _node_handle) const
00098 { return (_node_handle.idx()/8 < buffer_min_) ? true : false; }
00099
00100 bool overflow(VHierarchyNodeHandle _node_handle) const
00101 { return (_node_handle.idx()/8 < buffer_max_) ? false : true; }
00102
00103 bool update_buffer(VHierarchyNodeHandle _node_handle);
00104
00105 public:
00106 VHierarchyWindow();
00107 VHierarchyWindow(VHierarchy &_vhierarchy);
00108 ~VHierarchyWindow(void);
00109
00110 void set_vertex_hierarchy(VHierarchy &_vhierarchy)
00111 { vhierarchy_ = &_vhierarchy; }
00112
00113 void begin()
00114 {
00115 int new_window_min = window_min_;
00116 for (current_pos_=window_min_-buffer_min_;
00117 current_pos_ < window_size(); ++current_pos_)
00118 {
00119 if (buffer_[current_pos_] == 0)
00120 ++new_window_min;
00121 else
00122 {
00123 n_shift_ = 0;
00124 while ((buffer_[current_pos_] & flag8(n_shift_)) == 0)
00125 ++n_shift_;
00126 break;
00127 }
00128 }
00129 window_min_ = new_window_min;
00130 }
00131
00132 void next()
00133 {
00134 ++n_shift_;
00135 if (n_shift_ == 8)
00136 {
00137 n_shift_ = 0;
00138 ++current_pos_;
00139 }
00140
00141 while (current_pos_ < window_max_-buffer_min_)
00142 {
00143 if (buffer_[current_pos_] != 0)
00144 {
00145 while (n_shift_ != 8)
00146 {
00147 if ((buffer_[current_pos_] & flag8(n_shift_)) != 0)
00148 return;
00149 ++n_shift_;
00150 }
00151 }
00152 n_shift_ = 0;
00153 ++current_pos_;
00154 }
00155 }
00156 bool end() { return !(current_pos_ < window_max_-buffer_min_); }
00157
00158 int window_size() const { return window_max_ - window_min_; }
00159 int buffer_size() const { return buffer_max_ - buffer_min_; }
00160
00161 VHierarchyNodeHandle node_handle()
00162 {
00163 return VHierarchyNodeHandle(8*(buffer_min_+current_pos_) + (int)n_shift_);
00164 }
00165
00166 void activate(VHierarchyNodeHandle _node_handle)
00167 {
00168 update_buffer(_node_handle);
00169 buffer_[buffer_idx(_node_handle)] |= flag8(_node_handle);
00170 window_min_ = std::min(window_min_, byte_idx(_node_handle));
00171 window_max_ = std::max(window_max_, 1+byte_idx(_node_handle));
00172 }
00173
00174
00175 void inactivate(VHierarchyNodeHandle _node_handle)
00176 {
00177 if (is_active(_node_handle) != true) return;
00178 buffer_[buffer_idx(_node_handle)] ^= flag8(_node_handle);
00179 }
00180
00181
00182 bool is_active(VHierarchyNodeHandle _node_handle) const
00183 {
00184 if (before_window(_node_handle) == true ||
00185 after_window(_node_handle) == true)
00186 return false;
00187 return ((buffer_[buffer_idx(_node_handle)] & flag8(_node_handle)) > 0);
00188 }
00189
00190 void init(VHierarchyNodeHandleContainer &_roots);
00191 void update_with_vsplit(VHierarchyNodeHandle _parent_handle);
00192 void update_with_ecol(VHierarchyNodeHandle _parent_handle);
00193 };
00194
00195
00196 }
00197 }
00198
00199 #endif // OPENMESH_VDPROGMESH_VHIERARCHYWINDOWS_HH
00200
00201