Ocean
Optimizer4NeighborhoodHighPerformanceSkippingI1.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_SKIPPING_I_H
9 #define META_OCEAN_CV_SYNTHESIS_OPTIMIZER_4_NEIGHBORHOOD_HIGH_PERFORMANCE_SKIPPING_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 #include "ocean/base/RandomI.h"
19 
20 namespace Ocean
21 {
22 
23 namespace CV
24 {
25 
26 namespace Synthesis
27 {
28 
29 /**
30  * This class implements a high performance mapping optimizer for integer mappings.
31  * @tparam tWeightFactor Spatial weight impact, with range [0, infinity)
32  * @tparam tBorderFactor Weight factor of border pixels, with range [1, infinity)
33  * @tparam tUpdateFrame True, to update the frame pixel whenever a new mapping has been found
34  * @ingroup cvsynthesis
35  */
36 template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
37 class Optimizer4NeighborhoodHighPerformanceSkippingI1 :
38  virtual public OptimizerI,
39  virtual public OptimizerSubset,
40  virtual public Optimizer1
41 {
42  public:
43 
44  /**
45  * Creates a new optimizer object.
46  * @param layer Synthesis layer that will be optimized
47  * @param randomGenerator Random number generator
48  */
49  inline Optimizer4NeighborhoodHighPerformanceSkippingI1(LayerI1& layer, RandomGenerator& randomGenerator);
50 
51  private:
52 
53  /**
54  * Optimizes a subset of the synthesis frame.
55  * @see Optimizer1::optimizeSubset().
56  * @see optimizerSubsetChannels().
57  */
58  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;
59 
60  /**
61  * Specialization of the default subset optimization function.
62  * The template parameters specified the number of channels the synthesis frame has.<br>
63  * @param radii Number of improvement radii during one optimization iteration for each mapping position
64  * @param maxSpatialCost Maximal spatial cost
65  * @param boundingBoxTop First row of the entire synthesis area
66  * @param boundingBoxHeight Number of rows of the entire synthesis area
67  * @param downIsMain True, if the downwards direction is the main optimization direction (for all subsets with even thread indices)
68  * @param firstColumn First column to be handled in the subset
69  * @param numberColumns Number of columns to be handled in the subset
70  * @param rowOffset Offset within the entire synthesis area (boundingBoxHeight), the subset may be moved by this offset
71  * @param firstRow First row to be handled in the subset
72  * @param numberRows Number of rows to be handled in the subset
73  * @param threadIndex Index of the thread that executes the subset optimization function
74  * @tparam tChannels Number of data channels of the frame
75  * @see optimizerSubset().
76  */
77  template <unsigned int tChannels>
78  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;
79 
80  protected:
81 
82  /// Specialized layer reference.
83  LayerI1& layerI1_;
84 };
85 
86 template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
87 inline Optimizer4NeighborhoodHighPerformanceSkippingI1<tWeightFactor, tBorderFactor, tUpdateFrame>::Optimizer4NeighborhoodHighPerformanceSkippingI1(LayerI1& layer, RandomGenerator& randomGenerator) :
88  Optimizer(layer),
89  OptimizerI(layer),
90  OptimizerSubset(layer, randomGenerator),
91  Optimizer1(layer),
92  layerI1_(layer)
93 {
94  // nothing to do here
95 }
96 
97 template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
98 void Optimizer4NeighborhoodHighPerformanceSkippingI1<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
99 {
100  ocean_assert(layerI1_.frame().numberPlanes() == 1u);
101  ocean_assert(layerI1_.frame().dataType() == FrameType::DT_UNSIGNED_INTEGER_8);
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 Optimizer4NeighborhoodHighPerformanceSkippingI1<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
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 != 0xFFu && (x == 0u || y == 0u || (positionRow - 1)->east() != *positionRow || (positionRow - layerWidth)->south() != *positionRow))
187  {
188  unsigned int newPositionX = positionRow->x();
189  unsigned int newPositionY = positionRow->y();
190 
191  const unsigned int oldSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, newPositionX, newPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
192  const unsigned int oldColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, newPositionX, newPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
193  unsigned int newCost = 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  const unsigned int testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
212 
213  if (testCost < newCost)
214  {
215  newPositionX = testPositionX;
216  newPositionY = testPositionY;
217  newCost = testCost;
218  foundBetter = true;
219  }
220  }
221 
222  // second propagation from top to bottom
223  ocean_assert(y == 0u || (maskRow - layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y - 1u));
224  if (y > 0u && *(maskRow - layerMaskStrideElements) != 0xFF
225  // test only if the mapping of the left position does not match (shifted) to the mapping of the top position
226  && (positionRow - 1)->northEast() != *(positionRow - layerWidth))
227  {
228  ocean_assert(layerMapping.position(x, y - 1));
229  ocean_assert(*(positionRow - layerWidth) == layerMapping.position(x, y - 1));
230 
231  // take the next position to the top (of the current position)
232  testPositionX = (positionRow - layerWidth)->x();
233  testPositionY = (positionRow - layerWidth)->y() + 1;
234 
235  if (testPositionY < layerHeight && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
236  {
237  // the structure cost is 0 due to the neighbor condition
238  const unsigned int testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
239 
240  if (testCost < newCost)
241  {
242  newPositionX = testPositionX;
243  newPositionY = testPositionY;
244  newCost = testCost;
245  foundBetter = true;
246  }
247  }
248  }
249  }
250  else
251  {
252  // second propagation from top to bottom
253  ocean_assert(y == 0u || (maskRow - layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y - 1u));
254  if (y > 0u && *(maskRow - layerMaskStrideElements) != 0xFFu)
255  {
256  ocean_assert(layerMapping.position(x, y - 1));
257  ocean_assert(*(positionRow - layerWidth) == layerMapping.position(x, y - 1));
258 
259  // take the next position to the top (of the current position)
260  testPositionX = (positionRow - layerWidth)->x();
261  testPositionY = (positionRow - layerWidth)->y() + 1;
262 
263  if (testPositionY < layerHeight && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
264  {
265  // the structure cost is 0 due to the neighbor condition
266  const unsigned int testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
267 
268  if (testCost < newCost)
269  {
270  newPositionX = testPositionX;
271  newPositionY = testPositionY;
272  newCost = testCost;
273  foundBetter = true;
274  }
275  }
276  }
277  }
278 
279  // find a better position of the current mask pixel
280  for (unsigned int n = 0; n < radii; ++n)
281  {
282  ocean_assert(newPositionX != (unsigned int)(-1) && newPositionY != (unsigned int)(-1));
283 
284  testPositionX = newPositionX + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
285  testPositionY = newPositionY + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
286 
287  // the test position must lie inside the
288  if ((testPositionX == newPositionX && testPositionY == newPositionY)
289  || testPositionX >= layerWidth || testPositionY >= layerHeight
290  || layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] != 0xFF)
291  continue;
292 
293  const unsigned int testSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
294  const unsigned int testColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
295 
296  const unsigned int testCost = tWeightFactor * testSpatialCost + testColorCost;
297 
298  if (testCost < newCost)
299  {
300  newPositionX = testPositionX;
301  newPositionY = testPositionY;
302  newCost = testCost;
303  foundBetter = true;
304  }
305  }
306 
307  if (tUpdateFrame && foundBetter)
308  {
309  ocean_assert(layerMask.constpixel<uint8_t>(x, y)[0] != 0xFFu);
310  ocean_assert(layerMask.constpixel<uint8_t>(newPositionX, newPositionY)[0] == 0xFFu);
311 
312  positionRow->setPosition(newPositionX, newPositionY);
313  CV::CVUtilities::copyPixel<tChannels>(layerFrameData, layerFrameData, x, y, newPositionX, newPositionY, layerWidth, layerWidth, layerFramePaddingElements, layerFramePaddingElements);
314  }
315  }
316 
317  ++maskRow;
318  ++positionRow;
319  }
320  }
321  }
322  else // up
323  {
324  // find better positions for each mask pixel (bottom right to top left)
325  for (unsigned int yy = yEnd - 1; yy != yStart - 1; --yy)
326  {
327  const unsigned int y = modulo(int(yy + rowOffset - boundingBoxTop), int(boundingBoxHeight)) + boundingBoxTop;
328 
329  const uint8_t* maskRow = layerMask.constrow<uint8_t>(y) + xEnd - 1u;
330  PixelPosition* positionRow = layerMapping.row(y) + xEnd - 1u;
331 
332  for (unsigned int x = xEnd - 1; x != xStart - 1 ; --x)
333  {
334  bool foundBetter = false;
335 
336  ocean_assert(maskRow == layerMask.constpixel<uint8_t>(x, y));
337  if (*maskRow != 0xFFu && (x == layerWidth - 1u || y == layerHeight - 1u || (positionRow + 1)->west() != *positionRow || (positionRow + layerWidth)->north() != *positionRow))
338  {
339  unsigned int newPositionX = positionRow->x();
340  unsigned int newPositionY = positionRow->y();
341 
342  const unsigned int oldSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, newPositionX, newPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
343  const unsigned int oldColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, newPositionX, newPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
344  unsigned int newCost = tWeightFactor * oldSpatialCost + oldColorCost;
345 
346  unsigned int testPositionX, testPositionY;
347 
348  // first propagation from right to left
349  ocean_assert(x == layerWidth - 1u || (maskRow + 1) == layerMask.constpixel<uint8_t>(x + 1u, y));
350  if (x < layerWidth - 1u && *(maskRow + 1) != 0xFFu)
351  {
352  ocean_assert(layerMapping.position(x + 1, y));
353  ocean_assert(*(positionRow + 1) == layerMapping.position(x + 1, y));
354 
355  // take the position to the right (of the current position)
356  testPositionX = (positionRow + 1)->x() - 1;
357  testPositionY = (positionRow + 1)->y();
358 
359  if (testPositionX != (unsigned int)(-1) && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
360  {
361  // the structure cost is 0 due to the neighbor condition
362  const unsigned int testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
363 
364  if (testCost < newCost)
365  {
366  newPositionX = testPositionX;
367  newPositionY = testPositionY;
368  newCost = testCost;
369  foundBetter = true;
370  }
371  }
372 
373  // second propagation from bottom to top
374  ocean_assert(y == layerHeight - 1u || (maskRow + layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y + 1u));
375  if (y < layerHeight - 1u && *(maskRow + layerMaskStrideElements) != 0xFFu
376  // test only if the mapping of the right position does not match (shifted) to the mapping of the bottom position
377  && (positionRow + 1)->southWest() != *(positionRow + layerWidth))
378  {
379  ocean_assert(layerMapping.position(x, y + 1));
380  ocean_assert(*(positionRow + layerWidth) == layerMapping.position(x, y + 1));
381 
382  // take the next position towards the bottom (of the current position)
383  testPositionX = (positionRow + layerWidth)->x();
384  testPositionY = (positionRow + layerWidth)->y() - 1;
385 
386  if (testPositionY != (unsigned int)(-1) && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
387  {
388  // the structure cost is 0 due to the neighbor condition
389  const unsigned int testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
390 
391  if (testCost < newCost)
392  {
393  newPositionX = testPositionX;
394  newPositionY = testPositionY;
395  newCost = testCost;
396  foundBetter = true;
397  }
398  }
399  }
400  }
401  else
402  {
403  // second propagation from bottom to top
404  ocean_assert(y == layerHeight - 1u || (maskRow + layerMaskStrideElements) == layerMask.constpixel<uint8_t>(x, y + 1u));
405  if (y < layerHeight - 1 && *(maskRow + layerMaskStrideElements) != 0xFF)
406  {
407  ocean_assert(layerMapping.position(x, y + 1));
408  ocean_assert(*(positionRow + layerWidth) == layerMapping.position(x, y + 1));
409 
410  // take the next position towards the bottom (of the current position)
411  testPositionX = (positionRow + layerWidth)->x();
412  testPositionY = (positionRow + layerWidth)->y() - 1;
413 
414  if (testPositionY != (unsigned int)(-1) && layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] == 0xFF)
415  {
416  // the structure cost is 0 due to the neighbor condition
417  const unsigned int testCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
418 
419  if (testCost < newCost)
420  {
421  newPositionX = testPositionX;
422  newPositionY = testPositionY;
423  newCost = testCost;
424  foundBetter = true;
425  }
426  }
427  }
428  }
429 
430  // find a better position of the current mask pixel
431  for (unsigned int n = 0; n < radii; ++n)
432  {
433  ocean_assert(newPositionX != (unsigned int)(-1) && newPositionY != (unsigned int)(-1));
434 
435  testPositionX = newPositionX + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
436  testPositionY = newPositionY + RandomI::random(generator, -searchRadii[n], searchRadii[n]);
437 
438  if ((testPositionX == newPositionX && testPositionY == newPositionY)
439  || testPositionX >= layerWidth || testPositionY >= layerHeight
440  || layerMaskData[testPositionY * layerMaskStrideElements + testPositionX] != 0xFF)
441  continue;
442 
443  const unsigned int testSpatialCost = layerMapping.spatialCost4Neighborhood<tChannels>(x, y, testPositionX, testPositionY, layerMaskData, layerMaskPaddingElements, maxSpatialCost);
444  const unsigned int testColorCost = layerMapping.appearanceCost5x5<tChannels, tBorderFactor>(x, y, testPositionX, testPositionY, layerFrameData, layerMaskData, layerFramePaddingElements, layerMaskPaddingElements);
445 
446  const unsigned int testCost = tWeightFactor * testSpatialCost + testColorCost;
447 
448  if (testCost < newCost)
449  {
450  newPositionX = testPositionX;
451  newPositionY = testPositionY;
452  newCost = testCost;
453  foundBetter = true;
454  }
455  }
456 
457  if (tUpdateFrame && foundBetter)
458  {
459  ocean_assert(layerMask.constpixel<uint8_t>(x, y)[0] != 0xFFu);
460  ocean_assert(layerMask.constpixel<uint8_t>(newPositionX, newPositionY)[0] == 0xFFu);
461 
462  positionRow->setPosition(newPositionX, newPositionY);
463  CV::CVUtilities::copyPixel<tChannels>(layerFrameData, layerFrameData, x, y, newPositionX, newPositionY, layerWidth, layerWidth, layerFramePaddingElements, layerFramePaddingElements);
464  }
465  }
466 
467  --maskRow;
468  --positionRow;
469  }
470  }
471  }
472 }
473 
474 }
475 
476 }
477 
478 }
479 
480 #endif // META_OCEAN_CV_SYNTHESIS_OPTIMIZER_4_NEIGHBORHOOD_HIGH_PERFORMANCE_SKIPPING_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::Optimizer4NeighborhoodHighPerformanceSkippingI1
This class implements a high performance mapping optimizer for integer mappings.
Definition: Optimizer4NeighborhoodHighPerformanceSkippingI1.h:41
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceSkippingI1::Optimizer4NeighborhoodHighPerformanceSkippingI1
Optimizer4NeighborhoodHighPerformanceSkippingI1(LayerI1 &layer, RandomGenerator &randomGenerator)
Creates a new optimizer object.
Definition: Optimizer4NeighborhoodHighPerformanceSkippingI1.h:87
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceSkippingI1::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: Optimizer4NeighborhoodHighPerformanceSkippingI1.h:128
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceSkippingI1::layerI1_
LayerI1 & layerI1_
Specialized layer reference.
Definition: Optimizer4NeighborhoodHighPerformanceSkippingI1.h:83
Ocean::CV::Synthesis::Optimizer4NeighborhoodHighPerformanceSkippingI1::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: Optimizer4NeighborhoodHighPerformanceSkippingI1.h:98
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