Ocean
Loading...
Searching...
No Matches
Optimizer4NeighborhoodHighPerformanceI1.h
Go to the documentation of this file.
1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
3 *
4 * This source code is licensed under the MIT license found in the
5 * LICENSE file in the root directory of this source tree.
6 */
7
8#ifndef META_OCEAN_CV_SYNTHESIS_OPTIMIZER_4_NEIGHBORHOOD_HIGH_PERFORMANCE_I_H
9#define META_OCEAN_CV_SYNTHESIS_OPTIMIZER_4_NEIGHBORHOOD_HIGH_PERFORMANCE_I_H
10
11#include "ocean/cv/synthesis/Synthesis.h"
12#include "ocean/cv/synthesis/LayerI1.h"
13#include "ocean/cv/synthesis/OptimizerI.h"
14#include "ocean/cv/synthesis/OptimizerSubset.h"
15#include "ocean/cv/synthesis/Optimizer1.h"
16
17#include "ocean/base/RandomGenerator.h"
18
19#include "ocean/cv/CVUtilities.h"
20
21namespace Ocean
22{
23
24namespace CV
25{
26
27namespace Synthesis
28{
29
30/**
31 * This class implements a high performance mapping optimizer for integer mappings that use one single frame.
32 * @tparam tWeightFactor Spatial weight impact, with range [0, infinity)
33 * @tparam tBorderFactor Weight factor of border pixels, with range [1, infinity)
34 * @tparam tUpdateFrame True, to update the frame pixel whenever a new mapping has been found
35 * @ingroup cvsynthesis
36 */
37template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
38class Optimizer4NeighborhoodHighPerformanceI1 :
39 virtual public OptimizerI,
40 virtual public OptimizerSubset,
41 virtual public Optimizer1
42{
43 public:
44
45 /**
46 * Creates a new optimizer object.
47 * @param layer The layer to be optimized
48 * @param randomGenerator Random number generator
49 */
50 inline Optimizer4NeighborhoodHighPerformanceI1(LayerI1& layer, RandomGenerator& randomGenerator);
51
52 private:
53
54 /**
55 * Optimizes a subset of the synthesis frame.
56 * @see Optimizer1::optimizeSubset().
57 * @see optimizerSubsetChannels().
58 */
59 void optimizeSubset(const unsigned int radii, const unsigned int maxSpatialCost, const unsigned int boundingBoxTop, const unsigned int boundingBoxHeight, const bool downIsMain, const unsigned int firstColumn, const unsigned int numberColumns, const unsigned int rowOffset, const unsigned int firstRow, const unsigned int numberRows, const unsigned int threadIndex) const override;
60
61 /**
62 * Specialization of the default subset optimization function.
63 * The template parameters specified the number of channels the synthesis frame has.<br>
64 * @param radii Number of improvement radii during one optimization iteration for each mapping position
65 * @param maxSpatialCost Maximal spatial cost
66 * @param boundingBoxTop First row of the entire synthesis area
67 * @param boundingBoxHeight Number of rows of the entire synthesis area
68 * @param downIsMain True, if the downwards direction is the main optimization direction (for all subsets with even thread indices)
69 * @param firstColumn First column to be handled in the subset
70 * @param numberColumns Number of columns to be handled in the subset
71 * @param rowOffset Offset within the entire synthesis area (boundingBoxHeight), the subset may be moved by this offset
72 * @param firstRow First row to be handled in the subset
73 * @param numberRows Number of rows to be handled in the subset
74 * @param threadIndex Index of the thread that executes the subset optimization function
75 * @tparam tChannels Number of data channels of the frame
76 * @see optimizerSubset().
77 */
78 template <unsigned int tChannels>
79 void optimizeSubsetChannels(const unsigned int radii, const unsigned int maxSpatialCost, const unsigned int boundingBoxTop, const unsigned int boundingBoxHeight, const bool downIsMain, const unsigned int firstColumn, const unsigned int numberColumns, const unsigned int rowOffset, const unsigned int firstRow, const unsigned int numberRows, const unsigned int threadIndex) const;
80
81 protected:
82
83 /// Specialized layer reference.
84 LayerI1& layerI1_;
85};
86
87template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
88inline Optimizer4NeighborhoodHighPerformanceI1<tWeightFactor, tBorderFactor, tUpdateFrame>::Optimizer4NeighborhoodHighPerformanceI1(LayerI1& layer, RandomGenerator& randomGenerator) :
89 Optimizer(layer),
90 OptimizerI(layer),
91 OptimizerSubset(layer, randomGenerator),
92 Optimizer1(layer),
93 layerI1_(layer)
94{
95 // nothing to do here
96}
97
98template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
99void Optimizer4NeighborhoodHighPerformanceI1<tWeightFactor, tBorderFactor, tUpdateFrame>::optimizeSubset(const unsigned int radii, const unsigned int maxSpatialCost, const unsigned int boundingBoxTop, const unsigned int boundingBoxHeight, const bool downIsMain, const unsigned int firstColumn, const unsigned int numberColumns, const unsigned int rowOffset, const unsigned int firstRow, const unsigned int numberRows, const unsigned int threadIndex) const
100{
101 ocean_assert(layerI1_.frame().numberPlanes() == 1u);
102
103 switch (layerI1_.frame().channels())
104 {
105 case 1u:
106 optimizeSubsetChannels<1u>(radii, maxSpatialCost, boundingBoxTop, boundingBoxHeight, downIsMain, firstColumn, numberColumns, rowOffset, firstRow, numberRows, threadIndex);
107 break;
108
109 case 2u:
110 optimizeSubsetChannels<2u>(radii, maxSpatialCost, boundingBoxTop, boundingBoxHeight, downIsMain, firstColumn, numberColumns, rowOffset, firstRow, numberRows, threadIndex);
111 break;
112
113 case 3u:
114 optimizeSubsetChannels<3u>(radii, maxSpatialCost, boundingBoxTop, boundingBoxHeight, downIsMain, firstColumn, numberColumns, rowOffset, firstRow, numberRows, threadIndex);
115 break;
116
117 case 4u:
118 optimizeSubsetChannels<4u>(radii, maxSpatialCost, boundingBoxTop, boundingBoxHeight, downIsMain, firstColumn, numberColumns, rowOffset, firstRow, numberRows, threadIndex);
119 break;
120
121 default:
122 ocean_assert(false && "Invalid frame type.");
123 }
124}
125
126template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
127template <unsigned int tChannels>
128void Optimizer4NeighborhoodHighPerformanceI1<tWeightFactor, tBorderFactor, tUpdateFrame>::optimizeSubsetChannels(const unsigned int radii, const unsigned int maxSpatialCost, const unsigned int boundingBoxTop, const unsigned int boundingBoxHeight, const bool downIsMain, const unsigned int firstColumn, const unsigned int numberColumns, const unsigned int rowOffset, const unsigned int firstRow, const unsigned int numberRows, const unsigned int threadIndex) const
129{
130 const unsigned int layerWidth = layerI1_.width();
131 const unsigned int layerHeight = layerI1_.height();
132 ocean_assert(layerWidth != 0 && layerHeight != 0);
133
134 const std::vector<int> searchRadii(calculateSearchRadii(radii, layerWidth, layerHeight));
135
136 Frame& layerFrame = layerI1_.frame();
137 const Frame& layerMask = layerI1_.mask();
138 MappingI1& layerMapping = layerI1_.mapping();
139
140 ocean_assert(FrameType::formatIsGeneric(layerFrame.pixelFormat(), FrameType::DT_UNSIGNED_INTEGER_8, tChannels));
141 ocean_assert(layerFrame.pixelOrigin() == layerMask.pixelOrigin());
142
143 ocean_assert(firstColumn + numberColumns <= layerFrame.width());
144 ocean_assert(firstRow + numberRows <= layerFrame.height());
145
146 RandomGenerator generator(randomGenerator_);
147
148 uint8_t* const layerFrameData = layerFrame.data<uint8_t>();
149 const uint8_t* const layerMaskData = layerMask.constdata<uint8_t>();
150
151 const unsigned int layerFramePaddingElements = layerFrame.paddingElements();
152 const unsigned int layerMaskPaddingElements = layerMask.paddingElements();
153 const unsigned int layerMaskStrideElements = layerMask.strideElements();
154
155#ifdef OCEAN_DEBUG
156 const PixelBoundingBox& debugLayerBoundingBox = layerI1_.boundingBox();
157 ocean_assert(!debugLayerBoundingBox || firstRow >= debugLayerBoundingBox.top());
158 ocean_assert(!debugLayerBoundingBox || firstRow + numberRows <= debugLayerBoundingBox.bottomEnd());
159#endif // OCEAN_DEBUG
160
161 const bool down = (downIsMain && (threadIndex % 2u) == 0u) || (!downIsMain && (threadIndex % 2u) == 1u);
162
163 const unsigned int xStart = firstColumn;
164 const unsigned int yStart = firstRow;
165 const unsigned int xEnd = firstColumn + numberColumns;
166 const unsigned int yEnd = firstRow + numberRows;
167
168 ocean_assert(xEnd - xStart <= layerWidth);
169 ocean_assert(yEnd - yStart <= layerHeight);
170
171 if (down)
172 {
173 // find better positions for each mask pixel (top left to bottom right)
174 for (unsigned int yy = yStart; yy < yEnd; ++yy)
175 {
176 const unsigned int y = modulo(int(yy + rowOffset - boundingBoxTop), int(boundingBoxHeight)) + boundingBoxTop;
177
178 const uint8_t* maskRow = layerMask.constrow<uint8_t>(y) + xStart;
179 PixelPosition* positionRow = layerMapping.row(y) + xStart;
180
181 for (unsigned int x = xStart; x < xEnd; ++x)
182 {
183 bool foundBetter = false;
184
185 ocean_assert(maskRow == layerMask.constpixel<uint8_t>(x, y));
186 if (*maskRow != 0xFF)
187 {
188 unsigned int newPositionX = positionRow->x();
189 unsigned int newPositionY = positionRow->y();
190
191 const uint64_t oldSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, newPositionX, newPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
192 const uint64_t oldColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, newPositionX, newPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
193 uint64_t newCost = uint64_t(tWeightFactor) * oldSpatialCost + oldColorCost;
194
195 unsigned int testPositionX, testPositionY;
196
197 // first propagation from left to right
198 ocean_assert(x == 0u || (maskRow - 1) == layerMask.constpixel<uint8_t>(x - 1u, y));
199 if (x > 0u && *(maskRow - 1) != 0xFFu)
200 {
201 ocean_assert(layerMapping.position(x - 1, y));
202 ocean_assert(*(positionRow - 1) == layerMapping.position(x - 1, y));
203
204 // take the position to the left (of the current position)
205 testPositionX = (positionRow - 1)->x() + 1;
206 testPositionY = (positionRow - 1)->y();
207
208 if (testPositionX < layerWidth && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
209 {
210 // the structure cost is 0 due to the neighbor condition
211 ocean_assert_accuracy(layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost) == 0u);
212
213 const uint64_t testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
214
215 if (testCost < newCost)
216 {
217 newPositionX = testPositionX;
218 newPositionY = testPositionY;
219 newCost = testCost;
220 foundBetter = true;
221 }
222 }
223
224 // second propagation from top to bottom
225 ocean_assert(y == 0u || (maskRow - layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y - 1u));
226 if (y > 0u && *(maskRow - layerMaskStrideElements) != 0xFFu
227 // test only if the mapping of the left position does not match (shifted) to the mapping of the top position
228 && (positionRow - 1)->northEast() != *(positionRow - layerWidth))
229 {
230 ocean_assert(layerMapping.position(x, y - 1));
231 ocean_assert(*(positionRow - layerWidth) == layerMapping.position(x, y - 1));
232
233 // take the next position to the top (of the current position)
234 testPositionX = (positionRow - layerWidth)->x();
235 testPositionY = (positionRow - layerWidth)->y() + 1;
236
237 if (testPositionY < layerHeight && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
238 {
239 // the structure cost is 0 due to the neighbor condition
240 ocean_assert_accuracy(layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost) == 0u);
241
242 const uint64_t testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
243
244 if (testCost < newCost)
245 {
246 newPositionX = testPositionX;
247 newPositionY = testPositionY;
248 newCost = testCost;
249 foundBetter = true;
250 }
251 }
252 }
253 }
254 else
255 {
256 // second propagation from top to bottom
257 ocean_assert(y == 0u || (maskRow - layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y - 1u));
258 if (y > 0u && *(maskRow - layerMaskStrideElements) != 0xFFu)
259 {
260 ocean_assert(layerMapping.position(x, y - 1));
261 ocean_assert(*(positionRow - layerWidth) == layerMapping.position(x, y - 1));
262
263 // take the next position to the top (of the current position)
264 testPositionX = (positionRow - layerWidth)->x();
265 testPositionY = (positionRow - layerWidth)->y() + 1;
266
267 if (testPositionY < layerHeight && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
268 {
269 // the structure cost is 0 due to the neighbor condition
270 ocean_assert_accuracy(layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost) == 0u);
271
272 const uint64_t testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
273
274 if (testCost < newCost)
275 {
276 newPositionX = testPositionX;
277 newPositionY = testPositionY;
278 newCost = testCost;
279 foundBetter = true;
280 }
281 }
282 }
283 }
284
285 // find a better position of the current mask pixel
286 for (unsigned int n = 0; n < radii; ++n)
287 {
288 ocean_assert(newPositionX != (unsigned int)(-1) && newPositionY != (unsigned int)(-1));
289
290 testPositionX = newPositionX + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
291 testPositionY = newPositionY + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
292
293 // the test position must lie inside the mask
294 if ((testPositionX == newPositionX && testPositionY == newPositionY)
295 || testPositionX >= layerWidth || testPositionY >= layerHeight
296 || layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] != 0xFF)
297 continue;
298
299 const uint64_t testSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
300 const uint64_t testColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
301
302 const uint64_t testCost = uint64_t(tWeightFactor) * testSpatialCost + testColorCost;
303
304 if (testCost < newCost)
305 {
306 newPositionX = testPositionX;
307 newPositionY = testPositionY;
308 newCost = testCost;
309 foundBetter = true;
310 }
311 }
312
313 if (tUpdateFrame && foundBetter)
314 {
315 ocean_assert(layerMaskData[y * layerWidth + x] != 0xFF);
316 ocean_assert(layerMaskData[newPositionY * layerMaskStrideElements + newPositionX] == 0xFF);
317
318 positionRow->setPosition(newPositionX, newPositionY);
319
320 CV::CVUtilities::copyPixel<tChannels>(layerFrameData, layerFrameData, x, y, newPositionX, newPositionY, layerWidth, layerWidth, layerFramePaddingElements, layerFramePaddingElements);
321 }
322 }
323
324 ++maskRow;
325 ++positionRow;
326 }
327 }
328 }
329 else // up
330 {
331 // find better positions for each mask pixel (bottom right to top left)
332 for (unsigned int yy = yEnd - 1u; yy != yStart - 1u; --yy)
333 {
334 const unsigned int y = modulo(int(yy + rowOffset - boundingBoxTop), int(boundingBoxHeight)) + boundingBoxTop;
335
336 const uint8_t* maskRow = layerMask.constrow<uint8_t>(y) + xEnd - 1u;
337 PixelPosition* positionRow = layerMapping.row(y) + xEnd - 1u;
338
339 for (unsigned int x = xEnd - 1u; x != xStart - 1u; --x)
340 {
341 bool foundBetter = false;
342
343 ocean_assert(maskRow == layerMask.constpixel<uint8_t>(x, y));
344 if (*maskRow != 0xFF)
345 {
346 unsigned int newPositionX = positionRow->x();
347 unsigned int newPositionY = positionRow->y();
348
349 const uint64_t oldSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, newPositionX, newPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
350 const uint64_t oldColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, newPositionX, newPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
351 uint64_t newCost = uint64_t(tWeightFactor) * oldSpatialCost + oldColorCost;
352
353 unsigned int testPositionX, testPositionY;
354
355 // first propagation from right to left
356 ocean_assert(x == layerWidth - 1u || (maskRow + 1) == layerMask.constpixel<uint8_t>(x + 1u, y));
357 if (x < layerWidth - 1u && *(maskRow + 1) != 0xFFu)
358 {
359 ocean_assert(layerMapping.position(x + 1, y));
360 ocean_assert(*(positionRow + 1) == layerMapping.position(x + 1, y));
361
362 // take the position to the right (of the current position)
363 testPositionX = (positionRow + 1)->x() - 1;
364 testPositionY = (positionRow + 1)->y();
365
366 if (testPositionX != (unsigned int)(-1) && layerMaskData[testPositionY * layerWidth + testPositionX] == 0xFF)
367 {
368 // the structure cost is 0 due to the neighbor condition
369 ocean_assert_accuracy(layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost) == 0u);
370
371 const uint64_t testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
372
373 if (testCost < newCost)
374 {
375 newPositionX = testPositionX;
376 newPositionY = testPositionY;
377 newCost = testCost;
378 foundBetter = true;
379 }
380 }
381
382 // second propagation from bottom to top
383 ocean_assert(y == layerHeight - 1u || (maskRow + layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y + 1u));
384 if (y < layerHeight - 1u && *(maskRow + layerMaskStrideElements) != 0xFFu
385 // test only if the mapping of the right position does not match (shifted) to the mapping of the bottom position
386 && (positionRow + 1)->southWest() != *(positionRow + layerWidth))
387 {
388 ocean_assert(layerMapping.position(x, y + 1));
389 ocean_assert(*(positionRow + layerWidth) == layerMapping.position(x, y + 1));
390
391 // take the next position towards the bottom (of the current position)
392 testPositionX = (positionRow + layerWidth)->x();
393 testPositionY = (positionRow + layerWidth)->y() - 1;
394
395 if (testPositionY != (unsigned int)(-1) && layerMaskData[testPositionY * layerWidth + testPositionX] == 0xFF)
396 {
397 // the structure cost is 0 due to the neighbor condition
398 ocean_assert_accuracy(layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost) == 0u);
399
400 const uint64_t testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
401
402 if (testCost < newCost)
403 {
404 newPositionX = testPositionX;
405 newPositionY = testPositionY;
406 newCost = testCost;
407 foundBetter = true;
408 }
409 }
410 }
411 }
412 else
413 {
414 // second propagation from bottom to top
415 ocean_assert(y == layerHeight - 1u || (maskRow + layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y + 1u));
416 if (y < layerHeight - 1u && *(maskRow + layerMaskStrideElements) != 0xFFu)
417 {
418 ocean_assert(layerMapping.position(x, y + 1));
419 ocean_assert(*(positionRow + layerWidth) == layerMapping.position(x, y + 1));
420
421 // take the next position towards the bottom (of the current position)
422 testPositionX = (positionRow + layerWidth)->x();
423 testPositionY = (positionRow + layerWidth)->y() - 1;
424
425 if (testPositionY != (unsigned int)(-1) && layerMaskData[testPositionY * layerWidth + testPositionX] == 0xFF)
426 {
427 // the structure cost is 0 due to the neighbor condition
428 ocean_assert_accuracy(layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost) == 0u);
429
430 const uint64_t testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
431
432 if (testCost < newCost)
433 {
434 newPositionX = testPositionX;
435 newPositionY = testPositionY;
436 newCost = testCost;
437 foundBetter = true;
438 }
439 }
440 }
441 }
442
443 // find a better position of the current mask pixel
444 for (unsigned int n = 0; n < radii; ++n)
445 {
446 ocean_assert(newPositionX != (unsigned int)(-1) && newPositionY != (unsigned int)(-1));
447
448 testPositionX = newPositionX + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
449 testPositionY = newPositionY + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
450
451 if ((testPositionX == newPositionX && testPositionY == newPositionY)
452 || testPositionX >= layerWidth || testPositionY >= layerHeight
453 || layerMaskData[testPositionY * layerWidth + testPositionX] != 0xFF)
454 continue;
455
456 const uint64_t testSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
457 const uint64_t testColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
458 const uint64_t testCost = uint64_t(tWeightFactor) * testSpatialCost + testColorCost;
459
460 if (testCost < newCost)
461 {
462 newPositionX = testPositionX;
463 newPositionY = testPositionY;
464 newCost = testCost;
465 foundBetter = true;
466 }
467 }
468
469 if (tUpdateFrame && foundBetter)
470 {
471 ocean_assert(layerMaskData[y * layerWidth + x] != 0xFF);
472 ocean_assert(layerMaskData[newPositionY * layerWidth + newPositionX] == 0xFF);
473
474 positionRow->setPosition(newPositionX, newPositionY);
475
476 CV::CVUtilities::copyPixel<tChannels>(layerFrameData, layerFrameData, x, y, newPositionX, newPositionY, layerWidth, layerWidth, layerFramePaddingElements, layerFramePaddingElements);
477 }
478 }
479
480 --maskRow;
481 --positionRow;
482 }
483 }
484 }
485}
486
487}
488
489}
490
491}
492
493#endif // META_OCEAN_CV_SYNTHESIS_OPTIMIZER_4_NEIGHBORHOOD_HIGH_PERFORMANCE_I_H
Ocean::CV::PixelBoundingBoxT::bottomEnd
T bottomEnd() const
Returns the bottom (excluding) pixel position of this bounding box.
Definition PixelBoundingBox.h:451
Ocean::CV::PixelBoundingBoxT::top
T top() const
Returns the top (including) pixel position of this bounding box.
Definition PixelBoundingBox.h:423
Ocean::CV::Synthesis::LayerI1
This class implements a single layer for pixel synthesis within one frame and pixel accuracy.
Definition LayerI1.h:41
Ocean::CV::Synthesis::MappingI1
This class implements the pixel mapping between source and target frames.
Definition MappingI1.h:49
Ocean::CV::Synthesis::MappingI1::spatialCost4Neighborhood
unsigned int spatialCost4Neighborhood(const unsigned int xTarget, const unsigned int yTarget, const unsigned int xSource, const unsigned int ySource, const uint8_t *targetMask, const unsigned int targetMaskPaddingElements, const unsigned int maxCost) const
Calculates the smallest/cheapest spatial cost for a given point in a four-neighborhood and normalizes...
Definition MappingI1.h:212
Ocean::CV::Synthesis::MappingI1::appearanceCost5x5
unsigned int appearanceCost5x5(const unsigned int xTarget, const unsigned int yTarget, const unsigned int xSource, const unsigned int ySource, const uint8_t *frame, const uint8_t *mask, const unsigned int framePaddingElements, const unsigned int maskPaddingElements) const
Calculates the appearance cost for a given point in a given frame.
Definition MappingI1.h:634
Ocean::CV::Synthesis::MappingI::row
const PixelPosition * row(const unsigned int y) const
Returns the pointer to a mapping row.
Definition MappingI.h:243
Ocean::CV::Synthesis::MappingI::position
const PixelPosition & position(const unsigned int x, const unsigned int y) const
Returns the mapping for a given position.
Definition MappingI.h:215
Ocean::CV::Synthesis::Optimizer1
This class implements the base class for all synthesis optimizers that use one single frame.
Definition Optimizer1.h:28
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceI1
This class implements a high performance mapping optimizer for integer mappings that use one single f...
Definition Optimizer4NeighborhoodHighPerformanceI1.h:42
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceI1::layerI1_
LayerI1 & layerI1_
Specialized layer reference.
Definition Optimizer4NeighborhoodHighPerformanceI1.h:84
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceI1::Optimizer4NeighborhoodHighPerformanceI1
Optimizer4NeighborhoodHighPerformanceI1(LayerI1 &layer, RandomGenerator &randomGenerator)
Creates a new optimizer object.
Definition Optimizer4NeighborhoodHighPerformanceI1.h:88
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceI1::optimizeSubsetChannels
void optimizeSubsetChannels(const unsigned int radii, const unsigned int maxSpatialCost, const unsigned int boundingBoxTop, const unsigned int boundingBoxHeight, const bool downIsMain, const unsigned int firstColumn, const unsigned int numberColumns, const unsigned int rowOffset, const unsigned int firstRow, const unsigned int numberRows, const unsigned int threadIndex) const
Specialization of the default subset optimization function.
Definition Optimizer4NeighborhoodHighPerformanceI1.h:128
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceI1::optimizeSubset
void optimizeSubset(const unsigned int radii, const unsigned int maxSpatialCost, const unsigned int boundingBoxTop, const unsigned int boundingBoxHeight, const bool downIsMain, const unsigned int firstColumn, const unsigned int numberColumns, const unsigned int rowOffset, const unsigned int firstRow, const unsigned int numberRows, const unsigned int threadIndex) const override
Optimizes a subset of the synthesis frame.
Definition Optimizer4NeighborhoodHighPerformanceI1.h:99
Ocean::CV::Synthesis::Optimizer
This class is the base class for all synthesis optimizers.
Definition Optimizer.h:30
Ocean::CV::Synthesis::OptimizerI
This class is the base class for all optimizers that use a mapping with integer accuracy.
Definition OptimizerI.h:29
Ocean::CV::Synthesis::OptimizerSubset
This class is the base class for all optimizers that are able to optimize seperate subsets of the syn...
Definition OptimizerSubset.h:30
Ocean::Frame
This class implements Ocean's image class.
Definition Frame.h:1808
Ocean::Frame::strideElements
unsigned int strideElements(const unsigned int planeIndex=0u) const
Returns the number of elements within one row, including optional padding at the end of a row for a s...
Definition Frame.h:4138
Ocean::Frame::constdata
const T * constdata(const unsigned int planeIndex=0u) const
Returns a pointer to the read-only pixel data of a specific plane.
Definition Frame.h:4248
Ocean::Frame::data
T * data(const unsigned int planeIndex=0u)
Returns a pointer to the pixel data of a specific plane.
Definition Frame.h:4239
Ocean::Frame::constpixel
const T * constpixel(const unsigned int x, const unsigned int y, const unsigned int planeIndex=0u) const
Returns the pointer to the constant data of a specific pixel.
Definition Frame.h:4330
Ocean::Frame::constrow
const T * constrow(const unsigned int y, const unsigned int planeIndex=0u) const
Returns the pointer to the constant data of a specific row.
Definition Frame.h:4273
Ocean::Frame::paddingElements
unsigned int paddingElements(const unsigned int planeIndex=0u) const
Returns the optional number of padding elements at the end of each row for a specific plane.
Definition Frame.h:4122
Ocean::FrameType::width
unsigned int width() const
Returns the width of the frame format in pixel.
Definition Frame.h:3170
Ocean::FrameType::pixelOrigin
PixelOrigin pixelOrigin() const
Returns the pixel origin of the frame.
Definition Frame.h:3215
Ocean::FrameType::pixelFormat
PixelFormat pixelFormat() const
Returns the pixel format of the frame.
Definition Frame.h:3180
Ocean::FrameType::DT_UNSIGNED_INTEGER_8
@ DT_UNSIGNED_INTEGER_8
Unsigned 8 bit integer data type (uint8_t).
Definition Frame.h:41
Ocean::FrameType::height
unsigned int height() const
Returns the height of the frame in pixel.
Definition Frame.h:3175
Ocean::FrameType::formatIsGeneric
static bool formatIsGeneric(const PixelFormat pixelFormat, const DataType dataType, const uint32_t channels, const uint32_t planes=1u, const uint32_t widthMultiple=1u, const uint32_t heightMultiple=1u)
Checks whether a given pixel format is a specific layout regarding data channels and data type.
Definition Frame.h:3435
Ocean::RandomGenerator
This class implements a generator for random numbers.
Definition RandomGenerator.h:42
Ocean::RandomI::random
static unsigned int random(const unsigned int maxValue)
Returns one random integer value with specified maximum value.
Ocean::modulo
T modulo(const T &value, const T &ring)
Returns the modulo value of a given parameter within a ring allowing positive and negative parameters...
Definition base/Utilities.h:924
Ocean
The namespace covering the entire Ocean framework.
Definition Accessor.h:15