Ocean
Loading...
Searching...
No Matches
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
20namespace Ocean
21{
22
23namespace CV
24{
25
26namespace 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 */
36template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
37class 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
86template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
87inline 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
97template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
98void 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
126template <unsigned int tWeightFactor, unsigned int tBorderFactor, bool tUpdateFrame>
127template <unsigned int tChannels>
128void 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: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