Ocean
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 
21 namespace Ocean
22 {
23 
24 namespace CV
25 {
26 
27 namespace 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  */
37 template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
38 class 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 
87 template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
88 inline 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 
98 template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
99 void 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 
126 template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
127 template <unsigned int tChannels>
128 void 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:1760
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:4026
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:4136
Ocean::Frame::data
T * data(const unsigned int planeIndex=0u)
Returns a pointer to the pixel data of a specific plane.
Definition: Frame.h:4127
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:4218
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:4161
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:4010
Ocean::FrameType::width
unsigned int width() const
Returns the width of the frame format in pixel.
Definition: Frame.h:3111
Ocean::FrameType::pixelOrigin
PixelOrigin pixelOrigin() const
Returns the pixel origin of the frame.
Definition: Frame.h:3156
Ocean::FrameType::pixelFormat
PixelFormat pixelFormat() const
Returns the pixel format of the frame.
Definition: Frame.h:3121
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:3116
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:3374
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