Debian Codegraph @

plugins/core/Standard/qRANSAC_SD/extern/RANSAC_SD/BitmapPrimitiveShape.cpp

raw
1 #include "BitmapPrimitiveShape.h"
2 #include "Bitmap.h"
3 #include <iostream>
4 #include <fstream>
5 #include <sstream>
6 #include <iomanip>
7 #include "IndexIterator.h"
8 #include <MiscLib/Performance.h>
9 #include <float.h>
10 using namespace MiscLib;
11
12 void BitmapPrimitiveShape::PreWrapBitmap(
13 const GfxTL::AABox< GfxTL::Vector2Df > &bbox, float epsilon,
14 size_t uextent, size_t vextent, MiscLib::Vector< char > *bmp) const
15 {
16 // the default case is: do nothing
17 }
18
19 void BitmapPrimitiveShape::WrapComponents(
20 const GfxTL::AABox< GfxTL::Vector2Df > &bbox,
21 float epsilon, size_t uextent, size_t vextent,
22 MiscLib::Vector< int > *componentImg,
23 MiscLib::Vector< std::pair< int, size_t > > *labels) const
24 {
25 // default: do nothing
26 }
27
28 bool BitmapPrimitiveShape::Init(bool binary, std::istream *i)
29 {
30 if(binary)
31 {
32 GfxTL::AABox< GfxTL::Vector2Df > bbox;
33 size_t uextent, vextent;
34 // read number of components
35 size_t size;
36 i->read((char *)&size, sizeof(size));
37 if(size)
38 {
39 // read bbox
40 i->read((char *)&bbox, sizeof(bbox));
41 // read uextent and vextent
42 i->read((char *)&uextent, sizeof(uextent));
43 i->read((char *)&vextent, sizeof(vextent));
44 // read every component
45 for(size_t j = 0; j < size; ++j)
46 {
47 // read number of polys in component
48 size_t numPolys;
49 i->read((char *)&numPolys, sizeof(numPolys));
50 for(size_t k = 0; k < numPolys; ++k)
51 {
52 // read number of points in poly
53 size_t numPoints;
54 i->read((char *)&numPoints, sizeof(numPoints));
55 GfxTL::VectorXD< 2, size_t > pp;
56 for(size_t l = 0; l < numPoints; ++l)
57 i->read((char *)&pp, sizeof(pp));
58 }
59 }
60 }
61 }
62 else
63 {
64 GfxTL::AABox< GfxTL::Vector2Df > bbox;
65 size_t uextent, vextent;
66 // read number of components
67 size_t size;
68 (*i) >> size;
69 if(size)
70 {
71 // read bbox
72 (*i) >> bbox.Min()[0] >> bbox.Max()[0]
73 >> bbox.Min()[1] >> bbox.Max()[1];
74 // read uextent and vextent
75 (*i) >> uextent >> vextent;
76 // read every component
77 for(size_t j = 0; j < size; ++j)
78 {
79 // read number of polys in component
80 size_t numPolys;
81 (*i) >> numPolys;
82 for(size_t k = 0; k < numPolys; ++k)
83 {
84 // read number of points in poly
85 size_t numPoints;
86 (*i) >> numPoints;
87 GfxTL::VectorXD< 2, size_t > pp;
88 for(size_t l = 0; l < numPoints; ++l)
89 (*i) >> pp[0] >> pp[1];
90 }
91 }
92 }
93 }
94 return true;
95 }
96
97 size_t BitmapPrimitiveShape::AllConnectedComponents(const PointCloud &pc, float epsilon,
98 BitmapInfo& bitmapInfo, MiscLib::Vector< size_t > *indices, MiscLib::Vector< int >& componentsImg,
99 MiscLib::Vector< std::pair< int, size_t > >& labels, bool doFiltering )
100 {
101 // first find the extent in the parametrization
102 // but remember the parametrized points for projection into a bitmap
103 size_t size = indices->size();
104 if(!size)
105 return 0;
106
107 // set up bitmap
108 MiscLib::Vector< std::pair< float, float > > extParams;
109
110 BuildBitmap(pc, &epsilon, indices->begin(), indices->end(), &bitmapInfo.params,
111 &bitmapInfo.bbox, &bitmapInfo.bitmap, &bitmapInfo.uextent, &bitmapInfo.vextent, &bitmapInfo.bmpIdx);
112
113 /*static int fname_int = 0;
114 std::ostringstream fn;
115 fn << "bitmapImg" << fname_int++ << ".txt";
116 std::ofstream file;
117 file.open(fn.str().c_str(), std::ios::out);
118 for(size_t j = 0; j < vextent; ++j)
119 {
120 for(size_t i = 0; i < uextent; ++i)
121 file << bitmap[j * uextent + i];
122 file << std::endl;
123 }
124 file.close();*/
125
126 // do a wrapping by copying pixels
127 PreWrapBitmap(bitmapInfo.bbox, epsilon, bitmapInfo.uextent, bitmapInfo.vextent, &bitmapInfo.bitmap);
128
129 MiscLib::Vector< char > tempBmp(bitmapInfo.bitmap.size()); // temporary bitmap object
130 bool uwrap, vwrap;
131 WrapBitmap(bitmapInfo.bbox, epsilon, &uwrap, &vwrap);
132
133 if (doFiltering)
134 {
135 // closing
136 DilateCross(bitmapInfo.bitmap, bitmapInfo.uextent, bitmapInfo.vextent, uwrap, vwrap, &tempBmp);
137 ErodeCross(tempBmp, bitmapInfo.uextent, bitmapInfo.vextent, uwrap, vwrap, &bitmapInfo.bitmap);
138 // opening
139 //ErodeCross(bitmap, uextent, vextent, uwrap, vwrap, &tempBmp);
140 //DilateCross(tempBmp, uextent, vextent, uwrap, vwrap, &bitmap);
141 }
142
143 Components(bitmapInfo.bitmap, bitmapInfo.uextent, bitmapInfo.vextent, uwrap, vwrap, &componentsImg,
144 &labels);
145 if(labels.size() <= 1) // found no connected component!
146 {
147 return 0; // associate no points with this shape
148 }
149
150 WrapComponents(bitmapInfo.bbox, epsilon, bitmapInfo.uextent, bitmapInfo.vextent, &componentsImg, &labels);
151
152 return labels.size();
153 }
154
155 size_t BitmapPrimitiveShape::ConnectedComponent(
156 const PointCloud &pc, float epsilon,
157 MiscLib::Vector< size_t > *indices, bool doFiltering, float* borderRatio )
158 {
159 MiscLib::Vector< int > componentsImg;
160 MiscLib::Vector< std::pair< int, size_t > > labels;
161
162 BitmapInfo bitmapInfo;
163 if( AllConnectedComponents( pc, epsilon, bitmapInfo, indices, componentsImg, labels, doFiltering ) <= 1 )
164 return 0;
165
166 size_t size = indices->size();
167 MiscLib::Vector< size_t >::iterator begin = indices->begin();
168
169 // find the largest component
170 size_t maxComp = 1;
171 for(size_t i = 2; i < labels.size(); ++i)
172 if(labels[maxComp].second < labels[i].second)
173 maxComp = i;
174
175 GfxTL::AABox< GfxTL::Vector2Df > bbox;
176 bbox.Min() = GfxTL::Vector2Df(
177 std::numeric_limits< float >::infinity(),
178 std::numeric_limits< float >::infinity());
179 bbox.Max() = -bbox.Min();
180 // compute bbox and update indices
181 size_t offset = 0;
182 for(size_t i = 0; i < size; ++i)
183 {
184 if(componentsImg[bitmapInfo.bmpIdx[i]] == labels[maxComp].first)
185 {
186 std::swap(begin[offset], begin[i]);
187 offset++;
188 // update bounding box
189 if(bbox.Min()[0] > bitmapInfo.params[i].first)
190 bbox.Min()[0] = bitmapInfo.params[i].first;
191 if(bbox.Max()[0] < bitmapInfo.params[i].first)
192 bbox.Max()[0] = bitmapInfo.params[i].first;
193 if(bbox.Min()[1] > bitmapInfo.params[i].second)
194 bbox.Min()[1] = bitmapInfo.params[i].second;
195 if(bbox.Max()[1] < bitmapInfo.params[i].second)
196 bbox.Max()[1] = bitmapInfo.params[i].second;
197 }
198 }
199
200 // ratio between border and connected-comp size should be calculated if borderRatio is a valid pointer
201 if( borderRatio )
202 {
203 int borderPixels = 0;
204 int maxLabel = labels[maxComp].first;
205 size_t row = bitmapInfo.uextent;
206 size_t pos = 0;
207 char numNeighbours = 0;
208 size_t ccSize = 0;
209
210 // test neightbourhood for all bitmappixels that are not marginal
211 for( size_t v = 1; v < bitmapInfo.vextent-1; ++v )
212 {
213 for( size_t u = 1; u < bitmapInfo.uextent-1; ++u )
214 {
215 pos = row + u;
216
217 if( componentsImg[pos] == maxLabel )
218 {
219 ++ccSize;
220 numNeighbours = bitmapInfo.bitmap[pos-1] + bitmapInfo.bitmap[pos+1] +
221 bitmapInfo.bitmap[pos-bitmapInfo.uextent-1] + bitmapInfo.bitmap[pos-bitmapInfo.uextent+1] +
222 bitmapInfo.bitmap[pos+bitmapInfo.uextent-1] + bitmapInfo.bitmap[pos+bitmapInfo.uextent+1] +
223 bitmapInfo.bitmap[pos-bitmapInfo.uextent] + bitmapInfo.bitmap[pos+bitmapInfo.uextent];
224
225 if( numNeighbours != 8 )
226 ++borderPixels;
227 }
228 }
229 row += bitmapInfo.uextent;
230 }
231
232 // check left/right margins
233 row = bitmapInfo.uextent;
234 for( size_t v = 1; v < bitmapInfo.vextent-1; ++v )
235 {
236 ccSize++;
237 if( componentsImg[row] == maxLabel )
238 ++borderPixels;
239
240 ccSize++;
241 if( componentsImg[row+bitmapInfo.uextent-1] == maxLabel )
242 ++borderPixels;
243
244 row += bitmapInfo.uextent;
245 }
246
247 // check top/bottom margins
248 row = ( bitmapInfo.vextent-1 ) * bitmapInfo.uextent;
249 for( size_t u = 0; u < bitmapInfo.uextent; ++u )
250 {
251 ccSize++;
252 if( componentsImg[u] == maxLabel )
253 ++borderPixels;
254
255 ccSize++;
256 if( componentsImg[row + u] == maxLabel )
257 ++borderPixels;
258 }
259
260 *borderRatio = static_cast<float>( borderPixels ) / static_cast<float>( ccSize );
261 }
262
263 m_extBbox = bbox;
264 return offset;
265 }
266
267 void BitmapPrimitiveShape::TrimmingPolygons(const PointCloud &pc,
268 float epsilon, size_t begin, size_t end,
269 std::deque< ComponentPolygons > *polys) const
270 {
271 GfxTL::AABox< GfxTL::Vector2Df > bbox;
272 size_t uextent, vextent;
273 BuildPolygons(pc, epsilon, begin, end, &bbox, &uextent, &vextent, polys);
274 }
275
276 void BitmapPrimitiveShape::GenerateBitmapPoints(const PointCloud &pc,
277 float epsilon, size_t begin, size_t end, PointCloud *bmpPc) const
278 {
279 // constructing the bitmap is similar to ConnectedComponent
280 MiscLib::Vector< std::pair< float, float > > params, extParams;
281 MiscLib::Vector< char > bitmap;
282 MiscLib::Vector< size_t > bmpIdx;
283 GfxTL::AABox< GfxTL::Vector2Df > bbox;
284 size_t uextent, vextent;
285 BuildBitmap(pc, &epsilon, IndexIterator(begin), IndexIterator(end), &params,
286 &bbox, &bitmap, &uextent, &vextent, &bmpIdx);
287 m_extBbox = bbox;
288
289 //// do closing
290 //MiscLib::Vector< char > tempBmp(bitmap.size());
291 //DilateSquare(bitmap, uextent, vextent, false, false, &tempBmp);
292 //ErodeSquare(tempBmp, uextent, vextent, false, false, &bitmap);
293 //// do opening
294 //ErodeSquare(bitmap, uextent, vextent, false, false, &tempBmp);
295 //DilateSquare(tempBmp, uextent, vextent, false, false, &bitmap);
296
297 if(bmpPc)
298 {
299 size_t count = 0;
300 for(size_t i = 0; i < vextent * uextent; ++i)
301 {
302 // create point on surface
303 if(!bitmap[i])
304 continue;
305 if(count >= bmpPc->size())
306 bmpPc->resize(2 * count + 1);
307 if(InSpace(i % uextent, i / uextent, epsilon, bbox, uextent,
308 vextent, &(*bmpPc)[count].pos, &(*bmpPc)[count].normal))
309 ++count;
310 }
311 bmpPc->resize(count);
312 }
313 }
314
315 void BitmapPrimitiveShape::BuildPolygons(const PointCloud &pc, float epsilon,
316 size_t begin, size_t end, GfxTL::AABox< GfxTL::Vector2Df > *bbox,
317 size_t *uextent, size_t *vextent,
318 std::deque< ComponentPolygons > *polys) const
319 {
320 // curves are extracted in the following way:
321 // first the bitmap is constructed
322 // then connected components are found
323 // for each component the curves are found
324
325 // constructing the bitmap is similar to ConnectedComponent
326 // -> use the same code
327 MiscLib::Vector< std::pair< float, float > > params;
328 MiscLib::Vector< char > bitmap;
329 MiscLib::Vector< size_t > bmpIdx;
330 BuildBitmap(pc, &epsilon, IndexIterator(begin), IndexIterator(end), &params,
331 bbox, &bitmap, uextent, vextent, &bmpIdx);
332
333 // do closing
334 MiscLib::Vector< char > tempBmp(bitmap.size());
335 DilateCross(bitmap, *uextent, *vextent, false, false, &tempBmp);
336 ErodeCross(tempBmp, *uextent, *vextent, false, false, &bitmap);
337
338 // find connected components
339 MiscLib::Vector< int > componentsImg;
340 MiscLib::Vector< std::pair< int, size_t > > labels;
341 Components(bitmap, *uextent, *vextent, false, false, &componentsImg,
342 &labels);
343 if(labels.size() <= 1) // found no connected component!
344 return;
345
346 // for each component find all polygons
347 for(size_t i = 1; i < labels.size(); ++i)
348 {
349 polys->resize(polys->size() + 1);
350 ComponentLoops(componentsImg, *uextent, *vextent, labels[i].first,
351 false, false, &(*polys)[polys->size() - 1]);
352 }
353 }