30 #ifndef MIRTK_ForEachQuaternaryVoxelFunction_H 31 #define MIRTK_ForEachQuaternaryVoxelFunction_H 33 #include "mirtk/Stream.h" 34 #include "mirtk/VoxelFunction.h" 40 inline void _foreachquaternaryvoxelfunction_must_not_be_reduction()
42 cerr <<
"(Parallel)ForEachVoxel(If): Voxel reductions must be passed by reference!" 43 " Pass voxel functor object(s) as last argument(s) instead of first." << endl;
56 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
71 ForEachVoxelBody<VoxelFunc>(vf, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
77 ForEachVoxelBody<VoxelFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
83 ForEachVoxelBody<VoxelFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
94 const int T = (attr.
_dt ? attr.
_t : 1);
96 for (
int l = 0; l < T; ++l)
97 for (
int k = 0; k < attr.
_z; ++k)
98 for (
int j = 0; j < attr.
_y; ++j)
99 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
114 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
124 const int bi = re.cols().begin();
125 const int bj = re.rows().begin();
126 const int ei = re.cols().end();
127 const int ej = re.rows().end();
129 const int s1 = im4.
GetX() - (ei - bi);
136 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
137 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
147 const int bi = re.cols ().begin();
148 const int bj = re.rows ().begin();
149 const int bk = re.pages().begin();
150 const int ei = re.cols ().end();
151 const int ej = re.rows ().end();
152 const int ek = re.pages().end();
154 const int s1 = im4.
GetX() - (ei - bi);
155 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
162 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
163 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
164 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
176 template <
class T1,
class T2,
class T3,
class T4,
191 VoxelFunc &vf, OutsideFunc &of)
193 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(vf, of, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
199 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
205 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
216 const int T = (attr.
_dt ? attr.
_t : 1);
218 for (
int l = 0; l < T; ++l)
219 for (
int k = 0; k < attr.
_z; ++k)
220 for (
int j = 0; j < attr.
_y; ++j)
221 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
222 if (Domain::IsInside(im4, i, j, k, l, p4)) {
238 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
239 if (Domain::IsInside(im4, idx, p4)) {
250 const int bi = re.cols().begin();
251 const int bj = re.rows().begin();
252 const int ei = re.cols().end();
253 const int ej = re.rows().end();
255 const int s1 = im4.
GetX() - (ei - bi);
262 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
263 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
264 if (Domain::IsInside(im4, i, j, this->_k, this->
_l, p4)) {
275 const int bi = re.cols ().begin();
276 const int bj = re.rows ().begin();
277 const int bk = re.pages().begin();
278 const int ei = re.cols ().end();
279 const int ej = re.rows ().end();
280 const int ek = re.pages().end();
282 const int s1 = im4.
GetX() - (ei - bi);
283 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
290 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
291 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
292 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
293 if (Domain::IsInside(im4, i, j, k, this->
_l, p4)) {
311 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
317 vf.join(body._VoxelFunc);
321 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
324 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
325 ForEachScalar(*im1, *im2, *im3, *im4, vf);
329 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
333 ForEachScalar(*im1, *im2, *im3, *im4, vf);
338 vf.join(body._VoxelFunc);
343 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
346 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
347 ForEachVoxel(*im1, *im2, *im3, *im4, vf);
351 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
360 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
363 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
364 ForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
368 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
377 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
380 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
381 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
385 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
394 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
397 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
398 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
402 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
411 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
414 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
415 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
423 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
429 vf.join(body._VoxelFunc);
433 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
436 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
437 ForEachScalar(im1, im2, im3, im4, vf);
441 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
445 ForEachScalar(im1, im2, im3, im4, vf);
450 vf.join(body._VoxelFunc);
455 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
458 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
459 ForEachVoxel(im1, im2, im3, im4, vf);
463 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
472 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
475 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
476 ForEachVoxel(attr, im1, im2, im3, im4, vf);
480 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
489 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
492 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
493 ForEachVoxel(re, im1, im2, im3, im4, vf);
497 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
506 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
509 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
510 ForEachVoxel(re, im1, im2, im3, im4, vf);
514 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
523 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
526 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
527 ForEachVoxel(re, im1, im2, im3, im4, vf);
539 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
542 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
545 vf.join(body._VoxelFunc);
546 of.join(body._OutsideFunc);
550 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
553 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
554 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
558 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
562 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
566 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
569 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
570 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
574 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
578 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
580 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
583 vf.join(body._VoxelFunc);
584 of.join(body._OutsideFunc);
589 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
592 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
593 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
597 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
601 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
605 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
608 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
609 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
613 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
616 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
623 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
626 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
627 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
631 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
635 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
639 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
642 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
643 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
647 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
650 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
657 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
660 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
661 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
665 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
668 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
675 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
678 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
679 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
683 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
687 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
691 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
694 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
695 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
699 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
702 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
709 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
712 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
713 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
717 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
721 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
725 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
728 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
729 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
737 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
740 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
743 vf.join(body._VoxelFunc);
744 of.join(body._OutsideFunc);
748 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
751 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
752 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
756 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
760 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
764 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
767 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
768 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
772 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
776 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
778 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
781 vf.join(body._VoxelFunc);
782 of.join(body._OutsideFunc);
787 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
790 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
791 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
795 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
799 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
803 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
806 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
807 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
811 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
814 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
821 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
824 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
825 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
829 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
833 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
837 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
840 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
841 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
845 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
848 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
855 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
858 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
859 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
863 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
866 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
873 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
876 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
877 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
881 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
885 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
889 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
892 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
893 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
897 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
900 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
907 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
910 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
911 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
915 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
919 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
923 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
926 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
927 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
939 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
949 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
952 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
953 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
957 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
961 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
971 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
974 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
975 ParallelForEachVoxel(*im1, *im2, *im3, *im4, vf);
979 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
984 if (VoxelFunc::IsReduction()) {
1001 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1004 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1005 ParallelForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
1009 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1018 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1021 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1022 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
1026 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1035 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1038 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1039 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
1043 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1052 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1055 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1056 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
1064 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1074 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1077 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1078 ParallelForEachScalar(im1, im2, im3, im4, vf);
1082 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1086 ParallelForEachScalar(im1, im2, im3, im4, vf);
1096 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1099 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1100 ParallelForEachVoxel(im1, im2, im3, im4, vf);
1104 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1109 if (VoxelFunc::IsReduction()) {
1126 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1129 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1130 ParallelForEachVoxel(attr, im1, im2, im3, im4, vf);
1134 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1143 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1146 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1147 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
1151 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1160 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1163 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1164 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
1168 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1177 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1180 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1181 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
1193 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1196 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
1198 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1208 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1211 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1212 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
1216 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1220 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
1224 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1227 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1228 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
1232 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1236 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
1238 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
1240 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1251 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1254 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1255 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
1259 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1263 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
1267 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1270 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1271 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
1275 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1278 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
1280 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1298 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1301 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1302 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
1306 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1310 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
1314 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1317 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1318 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
1322 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1325 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
1326 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1336 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1339 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1340 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
1344 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1348 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
1352 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1355 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1356 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
1360 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1363 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
1364 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1374 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1377 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1378 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
1382 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1386 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
1390 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1393 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1394 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
1398 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1401 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
1402 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1412 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1415 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1416 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
1420 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1424 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
1428 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1431 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1432 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
1440 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1443 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
1445 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1455 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1458 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1459 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
1463 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1467 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
1471 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1474 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1475 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
1479 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1483 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
1485 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
1487 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1498 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1501 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1502 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
1506 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1510 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
1514 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1517 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1518 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
1522 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1525 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
1527 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1545 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1548 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1549 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
1553 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1557 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
1561 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1564 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1565 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
1569 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1572 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
1573 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1583 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1586 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1587 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
1591 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1595 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
1599 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1602 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1603 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
1607 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1610 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
1611 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1621 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1624 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1625 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
1629 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1633 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
1637 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1640 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1641 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
1645 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1648 QuaternaryForEachVoxelIfBody_Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
1649 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
1659 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
1662 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1663 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
1667 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1671 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
1675 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1678 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1679 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
1690 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1705 ForEachVoxelBody<VoxelFunc>(vf, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
1711 ForEachVoxelBody<VoxelFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
1717 ForEachVoxelBody<VoxelFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
1728 const int T = (attr.
_dt ? attr.
_t : 1);
1730 for (
int l = 0; l < T; ++l)
1731 for (
int k = 0; k < attr.
_z; ++k)
1732 for (
int j = 0; j < attr.
_y; ++j)
1733 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
1748 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
1758 const int bi = re.cols().begin();
1759 const int bj = re.rows().begin();
1760 const int ei = re.cols().end();
1761 const int ej = re.rows().end();
1763 const int s1 = im4.
GetX() - (ei - bi);
1770 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
1771 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
1781 const int bi = re.cols ().begin();
1782 const int bj = re.rows ().begin();
1783 const int bk = re.pages().begin();
1784 const int ei = re.cols ().end();
1785 const int ej = re.rows ().end();
1786 const int ek = re.pages().end();
1788 const int s1 = im4.
GetX() - (ei - bi);
1789 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
1796 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
1797 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
1798 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
1810 template <
class T1,
class T2,
class T3,
class T4,
1825 VoxelFunc &vf, OutsideFunc &of)
1827 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(vf, of, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
1833 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
1839 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
1850 const int T = (attr.
_dt ? attr.
_t : 1);
1852 for (
int l = 0; l < T; ++l)
1853 for (
int k = 0; k < attr.
_z; ++k)
1854 for (
int j = 0; j < attr.
_y; ++j)
1855 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
1856 if (Domain::IsInside(im4, i, j, k, l, p4)) {
1872 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
1873 if (Domain::IsInside(im4, idx, p4)) {
1884 const int bi = re.cols().begin();
1885 const int bj = re.rows().begin();
1886 const int ei = re.cols().end();
1887 const int ej = re.rows().end();
1889 const int s1 = im4.
GetX() - (ei - bi);
1896 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
1897 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
1898 if (Domain::IsInside(im4, i, j, this->_k, this->
_l, p4)) {
1909 const int bi = re.cols ().begin();
1910 const int bj = re.rows ().begin();
1911 const int bk = re.pages().begin();
1912 const int ei = re.cols ().end();
1913 const int ej = re.rows ().end();
1914 const int ek = re.pages().end();
1916 const int s1 = im4.
GetX() - (ei - bi);
1917 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
1924 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
1925 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
1926 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
1927 if (Domain::IsInside(im4, i, j, k, this->
_l, p4)) {
1945 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1951 vf.join(body._VoxelFunc);
1955 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1958 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1959 ForEachScalar(*im1, *im2, *im3, *im4, vf);
1963 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1967 ForEachScalar(*im1, *im2, *im3, *im4, vf);
1972 vf.join(body._VoxelFunc);
1977 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1980 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1981 ForEachVoxel(*im1, *im2, *im3, *im4, vf);
1985 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1994 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
1997 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
1998 ForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
2002 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2011 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2014 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2015 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
2019 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2028 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2031 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2032 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
2036 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2045 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2048 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2049 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
2057 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2063 vf.join(body._VoxelFunc);
2067 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2070 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2071 ForEachScalar(im1, im2, im3, im4, vf);
2075 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2079 ForEachScalar(im1, im2, im3, im4, vf);
2084 vf.join(body._VoxelFunc);
2089 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2092 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2093 ForEachVoxel(im1, im2, im3, im4, vf);
2097 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2106 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2109 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2110 ForEachVoxel(attr, im1, im2, im3, im4, vf);
2114 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2123 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2126 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2127 ForEachVoxel(re, im1, im2, im3, im4, vf);
2131 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2140 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2143 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2144 ForEachVoxel(re, im1, im2, im3, im4, vf);
2148 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2157 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2160 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2161 ForEachVoxel(re, im1, im2, im3, im4, vf);
2173 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2176 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2179 vf.join(body._VoxelFunc);
2180 of.join(body._OutsideFunc);
2184 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2187 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2188 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2192 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2196 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2200 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2203 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2204 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
2208 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2212 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2214 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2217 vf.join(body._VoxelFunc);
2218 of.join(body._OutsideFunc);
2223 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2226 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2227 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2231 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2235 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2239 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2242 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2243 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
2247 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2250 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2257 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2260 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2261 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
2265 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2269 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
2273 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2276 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2277 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
2281 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2284 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2291 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2294 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2295 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
2299 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2302 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2309 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2312 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2313 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
2317 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2321 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
2325 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2328 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2329 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
2333 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2336 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2343 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2346 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2347 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2351 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2355 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
2359 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2362 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2363 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
2371 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2374 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
2377 vf.join(body._VoxelFunc);
2378 of.join(body._OutsideFunc);
2382 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2385 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2386 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
2390 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2394 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
2398 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2401 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2402 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
2406 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2410 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
2412 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
2415 vf.join(body._VoxelFunc);
2416 of.join(body._OutsideFunc);
2421 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2424 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2425 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
2429 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2433 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
2437 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2440 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2441 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
2445 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2448 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
2455 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2458 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2459 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
2463 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2467 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
2471 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2474 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2475 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
2479 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2482 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
2489 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2492 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2493 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
2497 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2500 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
2507 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2510 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2511 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
2515 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2519 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
2523 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2526 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2527 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
2531 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2534 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
2541 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2544 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2545 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
2549 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2553 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
2557 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2560 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2561 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
2573 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2583 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2586 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2587 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
2591 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2595 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
2605 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2608 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2609 ParallelForEachVoxel(*im1, *im2, *im3, *im4, vf);
2613 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2618 if (VoxelFunc::IsReduction()) {
2635 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2638 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2639 ParallelForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
2643 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2652 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2655 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2656 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
2660 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2669 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2672 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2673 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
2677 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2686 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2689 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2690 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
2698 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2708 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2711 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2712 ParallelForEachScalar(im1, im2, im3, im4, vf);
2716 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2720 ParallelForEachScalar(im1, im2, im3, im4, vf);
2730 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2733 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2734 ParallelForEachVoxel(im1, im2, im3, im4, vf);
2738 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2743 if (VoxelFunc::IsReduction()) {
2760 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2763 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2764 ParallelForEachVoxel(attr, im1, im2, im3, im4, vf);
2768 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2777 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2780 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2781 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
2785 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2794 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2797 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2798 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
2802 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2811 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2814 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2815 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
2827 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2830 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2832 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
2842 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2845 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2846 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2850 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2854 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2858 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2861 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2862 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
2866 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2870 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2872 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2874 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
2885 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2888 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2889 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2893 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2897 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
2901 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2904 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2905 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
2909 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2912 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2914 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
2932 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2935 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2936 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
2940 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2944 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
2948 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2951 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2952 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
2956 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2959 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2960 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
2970 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2973 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2974 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
2978 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2982 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
2986 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
2989 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
2990 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
2994 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
2997 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
2998 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3008 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3011 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3012 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3016 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3020 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3024 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3027 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3028 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
3032 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3035 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
3036 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3046 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3049 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3050 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3054 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3058 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3062 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3065 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3066 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
3074 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3077 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
3079 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3089 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3092 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3093 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
3097 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3101 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
3105 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3108 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3109 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
3113 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3117 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
3119 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
3121 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3132 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3135 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3136 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
3140 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3144 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
3148 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3151 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3152 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
3156 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3159 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
3161 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3179 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3182 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3183 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
3187 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3191 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
3195 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3198 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3199 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
3203 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3206 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
3207 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3217 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3220 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3221 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
3225 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3229 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
3233 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3236 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3237 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
3241 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3244 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
3245 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3255 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3258 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3259 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
3263 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3267 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
3271 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3274 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3275 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
3279 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3282 QuaternaryForEachVoxelIfBody_3Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
3283 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
3293 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3296 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3297 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
3301 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3305 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
3309 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3312 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3313 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
3324 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3339 ForEachVoxelBody<VoxelFunc>(vf, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
3345 ForEachVoxelBody<VoxelFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
3351 ForEachVoxelBody<VoxelFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
3362 const int T = (attr.
_dt ? attr.
_t : 1);
3364 for (
int l = 0; l < T; ++l)
3365 for (
int k = 0; k < attr.
_z; ++k)
3366 for (
int j = 0; j < attr.
_y; ++j)
3367 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
3382 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
3392 const int bi = re.cols().begin();
3393 const int bj = re.rows().begin();
3394 const int ei = re.cols().end();
3395 const int ej = re.rows().end();
3397 const int s1 = im4.
GetX() - (ei - bi);
3404 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
3405 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
3415 const int bi = re.cols ().begin();
3416 const int bj = re.rows ().begin();
3417 const int bk = re.pages().begin();
3418 const int ei = re.cols ().end();
3419 const int ej = re.rows ().end();
3420 const int ek = re.pages().end();
3422 const int s1 = im4.
GetX() - (ei - bi);
3423 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
3430 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
3431 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
3432 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
3444 template <
class T1,
class T2,
class T3,
class T4,
3459 VoxelFunc &vf, OutsideFunc &of)
3461 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(vf, of, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
3467 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
3473 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
3484 const int T = (attr.
_dt ? attr.
_t : 1);
3486 for (
int l = 0; l < T; ++l)
3487 for (
int k = 0; k < attr.
_z; ++k)
3488 for (
int j = 0; j < attr.
_y; ++j)
3489 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
3490 if (Domain::IsInside(im4, i, j, k, l, p4)) {
3506 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
3507 if (Domain::IsInside(im4, idx, p4)) {
3518 const int bi = re.cols().begin();
3519 const int bj = re.rows().begin();
3520 const int ei = re.cols().end();
3521 const int ej = re.rows().end();
3523 const int s1 = im4.
GetX() - (ei - bi);
3530 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
3531 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
3532 if (Domain::IsInside(im4, i, j, this->_k, this->
_l, p4)) {
3543 const int bi = re.cols ().begin();
3544 const int bj = re.rows ().begin();
3545 const int bk = re.pages().begin();
3546 const int ei = re.cols ().end();
3547 const int ej = re.rows ().end();
3548 const int ek = re.pages().end();
3550 const int s1 = im4.
GetX() - (ei - bi);
3551 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
3558 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
3559 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
3560 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
3561 if (Domain::IsInside(im4, i, j, k, this->
_l, p4)) {
3579 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3585 vf.join(body._VoxelFunc);
3589 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3592 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3593 ForEachScalar(*im1, *im2, *im3, *im4, vf);
3597 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3601 ForEachScalar(*im1, *im2, *im3, *im4, vf);
3606 vf.join(body._VoxelFunc);
3611 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3614 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3615 ForEachVoxel(*im1, *im2, *im3, *im4, vf);
3619 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3628 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3631 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3632 ForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
3636 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3645 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3648 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3649 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
3653 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3662 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3665 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3666 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
3670 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3679 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3682 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3683 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
3691 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3697 vf.join(body._VoxelFunc);
3701 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3704 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3705 ForEachScalar(im1, im2, im3, im4, vf);
3709 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3713 ForEachScalar(im1, im2, im3, im4, vf);
3718 vf.join(body._VoxelFunc);
3723 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3726 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3727 ForEachVoxel(im1, im2, im3, im4, vf);
3731 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3740 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3743 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3744 ForEachVoxel(attr, im1, im2, im3, im4, vf);
3748 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3757 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3760 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3761 ForEachVoxel(re, im1, im2, im3, im4, vf);
3765 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3774 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3777 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3778 ForEachVoxel(re, im1, im2, im3, im4, vf);
3782 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3791 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3794 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3795 ForEachVoxel(re, im1, im2, im3, im4, vf);
3807 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3810 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
3813 vf.join(body._VoxelFunc);
3814 of.join(body._OutsideFunc);
3818 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3821 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3822 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
3826 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3830 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
3834 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3837 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3838 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
3842 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3846 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
3848 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
3851 vf.join(body._VoxelFunc);
3852 of.join(body._OutsideFunc);
3857 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3860 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3861 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
3865 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3869 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
3873 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3876 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3877 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
3881 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3884 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
3891 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3894 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3895 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
3899 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3903 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
3907 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3910 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3911 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
3915 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3918 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
3925 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3928 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3929 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3933 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3936 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
3943 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3946 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3947 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3951 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3955 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3959 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3962 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3963 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
3967 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3970 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
3977 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
3980 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3981 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
3985 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3989 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
3993 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
3996 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
3997 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
4005 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4008 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4011 vf.join(body._VoxelFunc);
4012 of.join(body._OutsideFunc);
4016 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4019 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4020 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
4024 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4028 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
4032 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4035 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4036 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
4040 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4044 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
4046 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4049 vf.join(body._VoxelFunc);
4050 of.join(body._OutsideFunc);
4055 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4058 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4059 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
4063 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4067 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
4071 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4074 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4075 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
4079 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4082 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4089 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4092 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4093 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
4097 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4101 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
4105 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4108 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4109 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
4113 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4116 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4123 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4126 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4127 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4131 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4134 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4141 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4144 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4145 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4149 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4153 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4157 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4160 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4161 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
4165 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4168 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4175 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4178 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4179 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4183 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4187 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4191 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4194 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4195 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
4207 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4217 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4220 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4221 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
4225 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4229 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
4239 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4242 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4243 ParallelForEachVoxel(*im1, *im2, *im3, *im4, vf);
4247 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4252 if (VoxelFunc::IsReduction()) {
4269 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4272 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4273 ParallelForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
4277 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4286 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4289 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4290 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
4294 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4303 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4306 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4307 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
4311 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4320 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4323 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4324 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
4332 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4342 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4345 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4346 ParallelForEachScalar(im1, im2, im3, im4, vf);
4350 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4354 ParallelForEachScalar(im1, im2, im3, im4, vf);
4364 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4367 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4368 ParallelForEachVoxel(im1, im2, im3, im4, vf);
4372 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4377 if (VoxelFunc::IsReduction()) {
4394 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4397 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4398 ParallelForEachVoxel(attr, im1, im2, im3, im4, vf);
4402 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4411 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4414 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4415 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
4419 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4428 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4431 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4432 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
4436 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4445 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4448 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4449 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
4461 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4464 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
4466 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4476 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4479 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4480 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
4484 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4488 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
4492 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4495 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4496 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
4500 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4504 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
4506 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
4508 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4519 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4522 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4523 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
4527 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4531 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
4535 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4538 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4539 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
4543 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4546 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
4548 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4566 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4569 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4570 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
4574 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4578 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
4582 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4585 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4586 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
4590 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4593 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
4594 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4604 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4607 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4608 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
4612 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4616 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
4620 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4623 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4624 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
4628 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4631 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
4632 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4642 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4645 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4646 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
4650 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4654 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
4658 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4661 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4662 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
4666 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4669 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
4670 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4680 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4683 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4684 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
4688 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4692 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
4696 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4699 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4700 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
4708 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4711 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4713 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4723 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4726 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4727 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
4731 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4735 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
4739 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4742 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4743 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
4747 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4751 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
4753 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4755 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4766 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4769 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4770 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
4774 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4778 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
4782 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4785 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4786 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
4790 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4793 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4795 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4813 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4816 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4817 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
4821 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4825 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
4829 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4832 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4833 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
4837 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4840 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4841 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4851 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4854 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4855 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4859 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4863 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4867 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4870 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4871 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
4875 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4878 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4879 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4889 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4892 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4893 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4897 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4901 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4905 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4908 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4909 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
4913 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4916 QuaternaryForEachVoxelIfBody_2Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
4917 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
4927 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
4930 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4931 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4935 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4939 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
4943 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4946 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
4947 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
4958 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
4973 ForEachVoxelBody<VoxelFunc>(vf, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
4979 ForEachVoxelBody<VoxelFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
4985 ForEachVoxelBody<VoxelFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
4996 const int T = (attr.
_dt ? attr.
_t : 1);
4998 for (
int l = 0; l < T; ++l)
4999 for (
int k = 0; k < attr.
_z; ++k)
5000 for (
int j = 0; j < attr.
_y; ++j)
5001 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
5016 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
5026 const int bi = re.cols().begin();
5027 const int bj = re.rows().begin();
5028 const int ei = re.cols().end();
5029 const int ej = re.rows().end();
5031 const int s1 = im4.
GetX() - (ei - bi);
5038 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
5039 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
5049 const int bi = re.cols ().begin();
5050 const int bj = re.rows ().begin();
5051 const int bk = re.pages().begin();
5052 const int ei = re.cols ().end();
5053 const int ej = re.rows ().end();
5054 const int ek = re.pages().end();
5056 const int s1 = im4.
GetX() - (ei - bi);
5057 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
5064 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
5065 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
5066 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
5078 template <
class T1,
class T2,
class T3,
class T4,
5093 VoxelFunc &vf, OutsideFunc &of)
5095 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(vf, of, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
5101 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
5107 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
5118 const int T = (attr.
_dt ? attr.
_t : 1);
5120 for (
int l = 0; l < T; ++l)
5121 for (
int k = 0; k < attr.
_z; ++k)
5122 for (
int j = 0; j < attr.
_y; ++j)
5123 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
5124 if (Domain::IsInside(im4, i, j, k, l, p4)) {
5140 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
5141 if (Domain::IsInside(im4, idx, p4)) {
5152 const int bi = re.cols().begin();
5153 const int bj = re.rows().begin();
5154 const int ei = re.cols().end();
5155 const int ej = re.rows().end();
5157 const int s1 = im4.
GetX() - (ei - bi);
5164 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
5165 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
5166 if (Domain::IsInside(im4, i, j, this->_k, this->
_l, p4)) {
5177 const int bi = re.cols ().begin();
5178 const int bj = re.rows ().begin();
5179 const int bk = re.pages().begin();
5180 const int ei = re.cols ().end();
5181 const int ej = re.rows ().end();
5182 const int ek = re.pages().end();
5184 const int s1 = im4.
GetX() - (ei - bi);
5185 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
5192 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
5193 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
5194 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
5195 if (Domain::IsInside(im4, i, j, k, this->
_l, p4)) {
5213 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5219 vf.join(body._VoxelFunc);
5223 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5226 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5227 ForEachScalar(*im1, *im2, *im3, *im4, vf);
5231 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5235 ForEachScalar(*im1, *im2, *im3, *im4, vf);
5240 vf.join(body._VoxelFunc);
5245 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5248 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5249 ForEachVoxel(*im1, *im2, *im3, *im4, vf);
5253 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5262 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5265 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5266 ForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
5270 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5279 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5282 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5283 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
5287 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5296 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5299 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5300 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
5304 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5313 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5316 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5317 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
5325 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5331 vf.join(body._VoxelFunc);
5335 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5338 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5339 ForEachScalar(im1, im2, im3, im4, vf);
5343 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5347 ForEachScalar(im1, im2, im3, im4, vf);
5352 vf.join(body._VoxelFunc);
5357 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5360 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5361 ForEachVoxel(im1, im2, im3, im4, vf);
5365 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5374 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5377 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5378 ForEachVoxel(attr, im1, im2, im3, im4, vf);
5382 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5391 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5394 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5395 ForEachVoxel(re, im1, im2, im3, im4, vf);
5399 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5408 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5411 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5412 ForEachVoxel(re, im1, im2, im3, im4, vf);
5416 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5425 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5428 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5429 ForEachVoxel(re, im1, im2, im3, im4, vf);
5441 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5444 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
5447 vf.join(body._VoxelFunc);
5448 of.join(body._OutsideFunc);
5452 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5455 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5456 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
5460 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5464 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
5468 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5471 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5472 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
5476 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5480 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
5482 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
5485 vf.join(body._VoxelFunc);
5486 of.join(body._OutsideFunc);
5491 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5494 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5495 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
5499 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5503 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
5507 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5510 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5511 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
5515 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5518 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
5525 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5528 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5529 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
5533 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5537 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
5541 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5544 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5545 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
5549 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5552 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
5559 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5562 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5563 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
5567 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5570 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
5577 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5580 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5581 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
5585 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5589 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
5593 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5596 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5597 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
5601 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5604 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
5611 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5614 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5615 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
5619 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5623 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
5627 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5630 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5631 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
5639 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5642 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
5645 vf.join(body._VoxelFunc);
5646 of.join(body._OutsideFunc);
5650 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5653 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5654 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
5658 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5662 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
5666 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5669 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5670 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
5674 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5678 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
5680 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
5683 vf.join(body._VoxelFunc);
5684 of.join(body._OutsideFunc);
5689 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5692 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5693 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
5697 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5701 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
5705 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5708 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5709 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
5713 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5716 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
5723 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5726 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5727 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
5731 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5735 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
5739 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5742 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5743 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
5747 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5750 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
5757 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5760 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5761 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
5765 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5768 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
5775 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5778 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5779 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
5783 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5787 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
5791 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5794 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5795 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
5799 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5802 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
5809 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
5812 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5813 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
5817 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5821 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
5825 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5828 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5829 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
5841 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5851 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5854 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5855 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
5859 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5863 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
5873 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5876 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5877 ParallelForEachVoxel(*im1, *im2, *im3, *im4, vf);
5881 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5886 if (VoxelFunc::IsReduction()) {
5903 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5906 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5907 ParallelForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
5911 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5920 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5923 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5924 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
5928 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5937 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5940 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5941 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
5945 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5954 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5957 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5958 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
5966 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5976 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5979 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
5980 ParallelForEachScalar(im1, im2, im3, im4, vf);
5984 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
5988 ParallelForEachScalar(im1, im2, im3, im4, vf);
5998 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6001 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6002 ParallelForEachVoxel(im1, im2, im3, im4, vf);
6006 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6011 if (VoxelFunc::IsReduction()) {
6028 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6031 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6032 ParallelForEachVoxel(attr, im1, im2, im3, im4, vf);
6036 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6045 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6048 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6049 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
6053 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6062 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6065 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6066 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
6070 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6079 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6082 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6083 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
6095 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6098 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
6100 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6110 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6113 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6114 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
6118 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6122 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
6126 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6129 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6130 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
6134 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6138 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
6140 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
6142 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6153 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6156 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6157 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
6161 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6165 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
6169 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6172 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6173 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
6177 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6180 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
6182 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6200 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6203 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6204 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
6208 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6212 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
6216 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6219 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6220 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
6224 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6227 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
6228 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6238 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6241 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6242 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
6246 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6250 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
6254 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6257 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6258 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
6262 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6265 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
6266 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6276 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6279 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6280 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
6284 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6288 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
6292 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6295 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6296 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
6300 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6303 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
6304 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6314 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6317 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6318 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
6322 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6326 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
6330 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6333 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6334 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
6342 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6345 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
6347 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6357 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6360 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6361 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
6365 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6369 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
6373 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6376 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6377 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
6381 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6385 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
6387 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
6389 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6400 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6403 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6404 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
6408 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6412 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
6416 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6419 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6420 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
6424 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6427 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
6429 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6447 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6450 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6451 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
6455 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6459 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
6463 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6466 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6467 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
6471 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6474 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
6475 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6485 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6488 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6489 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
6493 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6497 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
6501 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6504 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6505 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
6509 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6512 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
6513 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6523 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6526 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6527 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
6531 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6535 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
6539 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6542 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6543 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
6547 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6550 QuaternaryForEachVoxelIfBody_1Const<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
6551 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
6561 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
6564 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6565 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
6569 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6573 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
6577 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6580 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6581 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
6592 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6607 ForEachVoxelBody<VoxelFunc>(vf, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
6613 ForEachVoxelBody<VoxelFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
6619 ForEachVoxelBody<VoxelFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
6630 const int T = (attr.
_dt ? attr.
_t : 1);
6632 for (
int l = 0; l < T; ++l)
6633 for (
int k = 0; k < attr.
_z; ++k)
6634 for (
int j = 0; j < attr.
_y; ++j)
6635 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
6650 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
6660 const int bi = re.cols().begin();
6661 const int bj = re.rows().begin();
6662 const int ei = re.cols().end();
6663 const int ej = re.rows().end();
6665 const int s1 = im4.
GetX() - (ei - bi);
6672 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
6673 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
6683 const int bi = re.cols ().begin();
6684 const int bj = re.rows ().begin();
6685 const int bk = re.pages().begin();
6686 const int ei = re.cols ().end();
6687 const int ej = re.rows ().end();
6688 const int ek = re.pages().end();
6690 const int s1 = im4.
GetX() - (ei - bi);
6691 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
6698 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
6699 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
6700 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
6712 template <
class T1,
class T2,
class T3,
class T4,
6727 VoxelFunc &vf, OutsideFunc &of)
6729 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(vf, of, im1.Attributes()), im1(im1), im2(im2), im3(im3), im4(im4)
6735 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
6741 ForEachVoxelIfBody<VoxelFunc, OutsideFunc>(o, s), im1(o.im1), im2(o.im2), im3(o.im3), im4(o.im4)
6752 const int T = (attr.
_dt ? attr.
_t : 1);
6754 for (
int l = 0; l < T; ++l)
6755 for (
int k = 0; k < attr.
_z; ++k)
6756 for (
int j = 0; j < attr.
_y; ++j)
6757 for (
int i = 0; i < attr.
_x; ++i, ++p1, ++p2, ++p3, ++p4) {
6758 if (Domain::IsInside(im4, i, j, k, l, p4)) {
6774 for (
int idx = re.begin(); idx < re.end(); ++idx, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
6775 if (Domain::IsInside(im4, idx, p4)) {
6786 const int bi = re.cols().begin();
6787 const int bj = re.rows().begin();
6788 const int ei = re.cols().end();
6789 const int ej = re.rows().end();
6791 const int s1 = im4.
GetX() - (ei - bi);
6798 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
6799 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
6800 if (Domain::IsInside(im4, i, j, this->_k, this->
_l, p4)) {
6811 const int bi = re.cols ().begin();
6812 const int bj = re.rows ().begin();
6813 const int bk = re.pages().begin();
6814 const int ei = re.cols ().end();
6815 const int ej = re.rows ().end();
6816 const int ek = re.pages().end();
6818 const int s1 = im4.
GetX() - (ei - bi);
6819 const int s2 = (im4.
GetY() - (ej - bj)) * im4.
GetX();
6826 for (
int k = bk; k < ek; ++k, p1 += s2, p2 += s2, p3 += s2, p4 += s2)
6827 for (
int j = bj; j < ej; ++j, p1 += s1, p2 += s1, p3 += s1, p4 += s1)
6828 for (
int i = bi; i < ei; ++i, p1 += 1, p2 += 1, p3 += 1, p4 += 1) {
6829 if (Domain::IsInside(im4, i, j, k, this->
_l, p4)) {
6847 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6853 vf.join(body._VoxelFunc);
6857 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6860 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6861 ForEachScalar(*im1, *im2, *im3, *im4, vf);
6865 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6869 ForEachScalar(*im1, *im2, *im3, *im4, vf);
6874 vf.join(body._VoxelFunc);
6879 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6882 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6883 ForEachVoxel(*im1, *im2, *im3, *im4, vf);
6887 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6896 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6899 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6900 ForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
6904 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6913 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6916 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6917 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
6921 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6930 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6933 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6934 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
6938 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6947 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6950 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6951 ForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
6959 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6965 vf.join(body._VoxelFunc);
6969 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6972 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6973 ForEachScalar(im1, im2, im3, im4, vf);
6977 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6981 ForEachScalar(im1, im2, im3, im4, vf);
6986 vf.join(body._VoxelFunc);
6991 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
6994 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
6995 ForEachVoxel(im1, im2, im3, im4, vf);
6999 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7008 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7011 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7012 ForEachVoxel(attr, im1, im2, im3, im4, vf);
7016 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7025 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7028 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7029 ForEachVoxel(re, im1, im2, im3, im4, vf);
7033 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7042 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7045 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7046 ForEachVoxel(re, im1, im2, im3, im4, vf);
7050 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7059 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7062 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7063 ForEachVoxel(re, im1, im2, im3, im4, vf);
7075 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7078 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7081 vf.join(body._VoxelFunc);
7082 of.join(body._OutsideFunc);
7086 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7089 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7090 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7094 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7098 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7102 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7105 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7106 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
7110 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7114 ForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7116 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7119 vf.join(body._VoxelFunc);
7120 of.join(body._OutsideFunc);
7125 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7128 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7129 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7133 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7137 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7141 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7144 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7145 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
7149 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7152 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7159 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7162 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7163 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
7167 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7171 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
7175 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7178 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7179 ForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
7183 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7186 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7193 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7196 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7197 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7201 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7204 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7211 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7214 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7215 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7219 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7223 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7227 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7230 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7231 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
7235 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7238 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7245 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7248 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7249 ForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7253 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7257 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7261 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7264 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7265 ForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
7273 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7276 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
7279 vf.join(body._VoxelFunc);
7280 of.join(body._OutsideFunc);
7284 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7287 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7288 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
7292 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7296 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
7300 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7303 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7304 ForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
7308 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7312 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
7314 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
7317 vf.join(body._VoxelFunc);
7318 of.join(body._OutsideFunc);
7323 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7326 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7327 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
7331 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7335 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
7339 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7342 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7343 ForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
7347 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7350 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
7357 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7360 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7361 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
7365 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7369 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
7373 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7376 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7377 ForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
7381 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7384 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
7391 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7394 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7395 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
7399 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7402 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
7409 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7412 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7413 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
7417 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7421 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
7425 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7428 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7429 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
7433 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7436 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
7443 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7446 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7447 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
7451 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7455 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
7459 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7462 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7463 ForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
7475 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7485 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7488 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7489 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
7493 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7497 ParallelForEachScalar(*im1, *im2, *im3, *im4, vf);
7507 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7510 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7511 ParallelForEachVoxel(*im1, *im2, *im3, *im4, vf);
7515 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7520 if (VoxelFunc::IsReduction()) {
7537 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7540 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7541 ParallelForEachVoxel(attr, *im1, *im2, *im3, *im4, vf);
7545 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7554 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7557 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7558 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
7562 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7571 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7574 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7575 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
7579 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7588 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7591 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7592 ParallelForEachVoxel(re, *im1, *im2, *im3, *im4, vf);
7600 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7610 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7613 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7614 ParallelForEachScalar(im1, im2, im3, im4, vf);
7618 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7622 ParallelForEachScalar(im1, im2, im3, im4, vf);
7632 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7635 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7636 ParallelForEachVoxel(im1, im2, im3, im4, vf);
7640 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7645 if (VoxelFunc::IsReduction()) {
7662 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7665 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7666 ParallelForEachVoxel(attr, im1, im2, im3, im4, vf);
7670 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7679 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7682 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7683 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
7687 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7696 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7699 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7700 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
7704 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7713 template <
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7716 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7717 ParallelForEachVoxel(re, im1, im2, im3, im4, vf);
7729 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7732 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7734 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
7744 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7747 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7748 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7752 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7756 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7760 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7763 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7764 ParallelForEachScalarIf<Domain>(*im1, *im2, *im3, *im4, vf);
7768 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7772 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7774 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7776 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
7787 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7790 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7791 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7795 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7799 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf, of);
7803 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7806 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7807 ParallelForEachVoxelIf<Domain>(*im1, *im2, *im3, *im4, vf);
7811 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7814 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7816 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
7834 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7837 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7838 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
7842 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7846 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf, of);
7850 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7853 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7854 ParallelForEachVoxelIf<Domain>(attr, *im1, *im2, *im3, *im4, vf);
7858 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7861 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7862 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
7872 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7875 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7876 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7880 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7884 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7888 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7891 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7892 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
7896 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7899 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7900 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
7910 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7913 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7914 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7918 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7922 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7926 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7929 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7930 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
7934 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7937 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(*im1, *im2, *im3, *im4, vf, of);
7938 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
7948 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7951 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7952 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7956 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7960 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf, of);
7964 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
7967 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7968 ParallelForEachVoxelIf<Domain>(re, *im1, *im2, *im3, *im4, vf);
7976 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7979 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
7981 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
7991 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
7994 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
7995 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
7999 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8003 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf, of);
8007 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8010 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8011 ParallelForEachScalarIf<Domain>(im1, im2, im3, im4, vf);
8015 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8019 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
8021 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
8023 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
8034 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8037 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8038 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
8042 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8046 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf, of);
8050 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8053 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8054 ParallelForEachVoxelIf<Domain>(im1, im2, im3, im4, vf);
8058 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8061 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
8063 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
8081 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8084 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8085 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
8089 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8093 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf, of);
8097 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8100 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8101 ParallelForEachVoxelIf<Domain>(attr, im1, im2, im3, im4, vf);
8105 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8108 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
8109 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
8119 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8122 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8123 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
8127 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8131 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
8135 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8138 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8139 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
8143 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8146 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
8147 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
8157 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8160 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8161 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
8165 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8169 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
8173 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8176 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8177 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
8181 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8184 QuaternaryForEachVoxelIfBody<T1, T2, T3, T4, VoxelFunc, OutsideFunc, Domain> body(im1, im2, im3, im4, vf, of);
8185 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) {
8195 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc,
class Outs
ideFunc>
8198 if (VoxelFunc::IsReduction() || OutsideFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8199 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
8203 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8207 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf, of);
8211 template <
class Domain,
class T1,
class T2,
class T3,
class T4,
class VoxelFunc>
8214 if (VoxelFunc::IsReduction()) _foreachquaternaryvoxelfunction_must_not_be_reduction();
8215 ParallelForEachVoxelIf<Domain>(re, im1, im2, im3, im4, vf);
QuaternaryForEachVoxelBody_Const(QuaternaryForEachVoxelBody_Const &o, split s)
Split constructor.
double _dt
Voxel t-dimensions (in ms)
QuaternaryForEachVoxelBody_1Const(QuaternaryForEachVoxelBody_1Const &o, split s)
Split constructor.
QuaternaryForEachVoxelIfBody_1Const(const QuaternaryForEachVoxelIfBody_1Const &o)
Copy constructor.
QuaternaryForEachVoxelBody_1Const(const QuaternaryForEachVoxelBody_1Const &o)
Copy constructor.
QuaternaryForEachVoxelBody_2Const(QuaternaryForEachVoxelBody_2Const &o, split s)
Split constructor.
Dummy type used to distinguish split constructor from copy constructor.
QuaternaryForEachVoxelBody_2Const(const GenericImage< T1 > &im1, const GenericImage< T2 > &im2, GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf)
Constructor.
QuaternaryForEachVoxelIfBody_Const(const QuaternaryForEachVoxelIfBody_Const &o)
Copy constructor.
QuaternaryForEachVoxelBody(QuaternaryForEachVoxelBody &o, split s)
Split constructor.
bool IsEmpty() const
Whether image is uninitialized.
void operator()(const ImageAttributes &attr) const
Process entire image.
QuaternaryForEachVoxelIfBody_3Const(QuaternaryForEachVoxelIfBody_3Const &o, split s)
Split constructor.
QuaternaryForEachVoxelIfBody_Const(QuaternaryForEachVoxelIfBody_Const &o, split s)
Split constructor.
QuaternaryForEachVoxelIfBody_2Const(const GenericImage< T1 > &im1, const GenericImage< T2 > &im2, GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf, OutsideFunc &of)
Constructor.
int _y
Image y-dimension (in voxels)
QuaternaryForEachVoxelIfBody_1Const(const GenericImage< T1 > &im1, GenericImage< T2 > &im2, GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf, OutsideFunc &of)
Constructor.
VoxelFunc _VoxelFunc
Functor executed for each voxel.
QuaternaryForEachVoxelIfBody(const QuaternaryForEachVoxelIfBody &o)
Copy constructor.
QuaternaryForEachVoxelBody(GenericImage< T1 > &im1, GenericImage< T2 > &im2, GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf)
Constructor.
QuaternaryForEachVoxelBody_2Const(const QuaternaryForEachVoxelBody_2Const &o)
Copy constructor.
QuaternaryForEachVoxelIfBody_2Const(const QuaternaryForEachVoxelIfBody_2Const &o)
Copy constructor.
QuaternaryForEachVoxelIfBody_Const(const GenericImage< T1 > &im1, const GenericImage< T2 > &im2, const GenericImage< T3 > &im3, const GenericImage< T4 > &im4, VoxelFunc &vf, OutsideFunc &of)
Constructor.
VoxelType * GetPointerToVoxels(int=0, int=0, int=0, int=0)
int GetX() const
Returns the number of voxels in the x-direction.
int _z
Image z-dimension (in voxels)
int _l
Indices for fixed dimensions.
QuaternaryForEachVoxelIfBody_3Const(const QuaternaryForEachVoxelIfBody_3Const &o)
Copy constructor.
QuaternaryForEachVoxelBody_Const(const GenericImage< T1 > &im1, const GenericImage< T2 > &im2, const GenericImage< T3 > &im3, const GenericImage< T4 > &im4, VoxelFunc &vf)
Constructor.
QuaternaryForEachVoxelIfBody_3Const(const GenericImage< T1 > &im1, const GenericImage< T2 > &im2, const GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf, OutsideFunc &of)
Constructor.
int _t
Image t-dimension (in voxels)
QuaternaryForEachVoxelBody_3Const(const GenericImage< T1 > &im1, const GenericImage< T2 > &im2, const GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf)
Constructor.
int GetT() const
Returns the number of voxels in the t-direction.
int GetY() const
Returns the number of voxels in the y-direction.
QuaternaryForEachVoxelIfBody_2Const(QuaternaryForEachVoxelIfBody_2Const &o, split s)
Split constructor.
QuaternaryForEachVoxelIfBody(QuaternaryForEachVoxelIfBody &o, split s)
Split constructor.
int GetNumberOfVoxels() const
QuaternaryForEachVoxelBody_3Const(const QuaternaryForEachVoxelBody_3Const &o)
Copy constructor.
OutsideFunc _OutsideFunc
Functor executed for each background voxel.
QuaternaryForEachVoxelIfBody_1Const(QuaternaryForEachVoxelIfBody_1Const &o, split s)
Split constructor.
double GetTSize() const
Returns the size of a voxel in the t-direction.
QuaternaryForEachVoxelBody_3Const(QuaternaryForEachVoxelBody_3Const &o, split s)
Split constructor.
QuaternaryForEachVoxelBody(const QuaternaryForEachVoxelBody &o)
Copy constructor.
int _x
Image x-dimension (in voxels)
QuaternaryForEachVoxelIfBody(GenericImage< T1 > &im1, GenericImage< T2 > &im2, GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf, OutsideFunc &of)
Constructor.
void parallel_reduce(const Range &range, Body &body)
parallel_reduce dummy template function which executes the body serially
QuaternaryForEachVoxelBody_1Const(const GenericImage< T1 > &im1, GenericImage< T2 > &im2, GenericImage< T3 > &im3, GenericImage< T4 > &im4, VoxelFunc &vf)
Constructor.
QuaternaryForEachVoxelBody_Const(const QuaternaryForEachVoxelBody_Const &o)
Copy constructor.
void parallel_for(const Range &range, const Body &body)
parallel_for dummy template function which executes the body serially