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