| 535 | // Returns the result of a 3D pad on an input matrix. |
| 536 | template <typename NativeT> |
| 537 | static Array3D<NativeT> PadArray3D(const Array3D<NativeT>& operand, |
| 538 | const PaddingConfig& padding, |
| 539 | const NativeT pad) { |
| 540 | CHECK_EQ(padding.dimensions_size(), 3); |
| 541 | |
| 542 | const int64 input_bounds[] = {operand.n1(), operand.n2(), operand.n3()}; |
| 543 | int64 pad_low[3]; |
| 544 | int64 pad_high[3]; |
| 545 | int64 pad_interior[3]; |
| 546 | int64 output_bounds[3]; |
| 547 | for (int64 i = 0; i < 3; ++i) { |
| 548 | pad_low[i] = padding.dimensions(i).edge_padding_low(); |
| 549 | pad_high[i] = padding.dimensions(i).edge_padding_high(); |
| 550 | CHECK_LE(0, pad_low[i]); |
| 551 | CHECK_LE(0, pad_high[i]); |
| 552 | CHECK_LE(0, padding.dimensions(i).interior_padding()) |
| 553 | << "not implemented"; |
| 554 | pad_interior[i] = padding.dimensions(i).interior_padding(); |
| 555 | |
| 556 | output_bounds[i] = pad_low[i] + input_bounds[i] + pad_high[i] + |
| 557 | (input_bounds[i] - 1) * pad_interior[i]; |
| 558 | } |
| 559 | |
| 560 | Array3D<NativeT> result(output_bounds[0], output_bounds[1], |
| 561 | output_bounds[2]); |
| 562 | int indices[] = {0, 0, 0}; |
| 563 | for (indices[0] = 0; indices[0] < output_bounds[0]; ++indices[0]) { |
| 564 | for (indices[1] = 0; indices[1] < output_bounds[1]; ++indices[1]) { |
| 565 | for (indices[2] = 0; indices[2] < output_bounds[2]; ++indices[2]) { |
| 566 | NativeT* value = &result(indices[0], indices[1], indices[2]); |
| 567 | bool value_padded = false; |
| 568 | for (int i = 0; i < 3; ++i) { |
| 569 | bool in_low_padding = indices[i] < pad_low[i]; |
| 570 | bool in_high_padding = indices[i] >= output_bounds[i] - pad_high[i]; |
| 571 | if (in_low_padding || in_high_padding) { |
| 572 | *value = pad; |
| 573 | value_padded = true; |
| 574 | } |
| 575 | if (pad_interior[i] && |
| 576 | (indices[i] - pad_low[i]) % (pad_interior[i] + 1)) { |
| 577 | *value = pad; |
| 578 | value_padded = true; |
| 579 | } |
| 580 | } |
| 581 | if (value_padded) { |
| 582 | continue; |
| 583 | } |
| 584 | *value = operand((indices[0] - pad_low[0]) / (pad_interior[0] + 1), |
| 585 | (indices[1] - pad_low[1]) / (pad_interior[1] + 1), |
| 586 | (indices[2] - pad_low[2]) / (pad_interior[2] + 1)); |
| 587 | } |
| 588 | } |
| 589 | } |
| 590 | return result; |
| 591 | } |
| 592 | |
| 593 | // Returns the result of a 4D pad on an input array. |
| 594 | template <typename NativeT> |
nothing calls this directly
no test coverage detected