HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
UT_VoxelArray.C
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * NAME: UT_VoxelArray.C ( UT Library, C++)
7  *
8  * COMMENTS:
9  * Tiled Voxel Array Implementation.
10  */
11 
12 #include "UT_VoxelArray.h"
13 
14 #include "UT_Array.h"
15 #include "UT_Assert.h"
16 #include "UT_BoundingBox.h"
17 #include "UT_COW.h"
18 #include "UT_Debug.h"
19 #include "UT_Filter.h"
20 #include "UT_FilterType.h"
21 #include "UT_Interrupt.h"
22 #include "UT_IStream.h"
23 #include "UT_JSONDefines.h"
24 #include "UT_JSONParser.h"
25 #include "UT_JSONWriter.h"
26 #include "UT_NTStreamUtil.h"
27 #include "UT_ParallelUtil.h"
28 #include "UT_SharedMemoryManager.h"
29 #include "UT_StackBuffer.h"
30 #include "UT_String.h"
31 #include "UT_ThreadedAlgorithm.h"
32 #include "UT_ValArray.h"
33 #include "UT_Vector2.h"
34 #include "UT_Vector3.h"
35 #include "UT_Vector4.h"
36 #include "UT_VectorTypes.h"
37 #include "UT_VoxelArrayJSON.h"
38 #include "UT_WorkBuffer.h"
39 #include <SYS/SYS_Compiler.h>
40 #include <SYS/SYS_Floor.h>
41 #include <SYS/SYS_Math.h>
42 #include <SYS/SYS_SharedMemory.h>
43 #include <SYS/SYS_Types.h>
44 
45 #include <algorithm>
46 #include <iostream>
47 
48 #include <string.h>
49 
50 ///
51 /// fpreal16 conversion functions
52 ///
53 inline fpreal16
54 UTvoxelConvertFP16(fpreal16 a) { return a; }
55 inline fpreal16
56 UTvoxelConvertFP16(fpreal32 a) { return a; }
57 inline fpreal16
58 UTvoxelConvertFP16(fpreal64 a) { return a; }
59 inline fpreal16
60 UTvoxelConvertFP16(int8 a) { return a; }
61 inline fpreal16
62 UTvoxelConvertFP16(int16 a) { return a; }
63 inline fpreal16
64 UTvoxelConvertFP16(int32 a) { return a; }
65 inline fpreal16
66 UTvoxelConvertFP16(int64 a) { return a; }
67 
68 ///
69 /// VoxelTileCompress definitions
70 ///
71 template <typename T>
72 void
73 UT_VoxelTileCompress<T>::findMinMax(const UT_VoxelTile<T> &tile,
74  T &min, T &max) const
75 {
76  int x, y, z;
77 
78  min = getValue(tile, 0, 0, 0);
79  max = min;
80 
81  // Generic approach is to just use the getValue() ability.
82  for (z = 0; z < tile.zres(); z++)
83  {
84  for (y = 0; y < tile.yres(); y++)
85  {
86  for (x = 0; x < tile.xres(); x++)
87  {
88  tile.expandMinMax(getValue(tile, x, y, z), min, max);
89  }
90  }
91  }
92  return;
93 }
94 
95 //
96 // VoxelTile definitions.
97 //
98 
99 template <typename T>
100 UT_VoxelTile<T>::UT_VoxelTile()
101 {
102  myRes[0] = 0;
103  myRes[1] = 0;
104  myRes[2] = 0;
105 
106  myCompressionType = COMPRESS_CONSTANT;
107  myForeignData = false;
108 
109  if (sizeof(T) <= sizeof(T*))
110  {
111  myData = 0;
112  }
113  else
114  {
115  myData = UT_VOXEL_ALLOC(sizeof(T));
116 
117  // It is not accidental that this is not a static_cast!
118  // There isn't a UT_Vector3(fpreal) constructor (as we have a foolish
119  // UT_Vector3(fpreal *) constructor that would cause massive problems)
120  // but there is a UT_Vector3 operator=(fpreal)!
121  ((T *)myData)[0] = 0;
122  }
123 }
124 
125 template <typename T>
126 UT_VoxelTile<T>::~UT_VoxelTile()
127 {
128  freeData();
129 }
130 
131 template <typename T>
132 UT_VoxelTile<T>::UT_VoxelTile(const UT_VoxelTile<T> &src)
133 {
134  myData = 0;
135 
136  // Use assignment operator.
137  *this = src;
138 }
139 
140 template <typename T>
141 const UT_VoxelTile<T> &
142 UT_VoxelTile<T>::operator=(const UT_VoxelTile<T> &src)
143 {
144  if (&src == this)
145  return *this;
146 
147  freeData();
148 
149  myRes[0] = src.myRes[0];
150  myRes[1] = src.myRes[1];
151  myRes[2] = src.myRes[2];
152 
153  myCompressionType = src.myCompressionType;
154  switch (myCompressionType)
155  {
156  case COMPRESS_RAW:
157  myData = UT_VOXEL_ALLOC(
158  sizeof(T) * myRes[0] * myRes[1] * myRes[2]);
159  memcpy(myData, src.myData, sizeof(T) * myRes[0] * myRes[1] * myRes[2]);
160  break;
161  case COMPRESS_CONSTANT:
162  if (inlineConstant())
163  {
164  myData = src.myData;
165  }
166  else
167  {
168  myData = UT_VOXEL_ALLOC(sizeof(T));
169  memcpy(myData, src.myData, sizeof(T));
170  }
171  break;
172  case COMPRESS_RAWFULL:
173  myData = UT_VOXEL_ALLOC(
174  sizeof(T) * TILESIZE * TILESIZE * myRes[2]);
175  memcpy(myData, src.myData,
176  sizeof(T) * TILESIZE * TILESIZE * myRes[2]);
177  break;
178  case COMPRESS_FPREAL16:
179  {
180  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
181  myData = UT_VOXEL_ALLOC(
182  sizeof(fpreal16) * myRes[0] * myRes[1] * myRes[2] * tuple_size);
183  memcpy(myData, src.myData,
184  sizeof(fpreal16) * myRes[0] * myRes[1] * myRes[2] * tuple_size);
185  break;
186  }
187  default:
188  {
189  UT_VoxelTileCompress<T> *engine;
190 
191  engine = getCompressionEngine(myCompressionType);
192  myData = UT_VOXEL_ALLOC(engine->getDataLength(src));
193  memcpy(myData, src.myData, engine->getDataLength(src));
194  break;
195  }
196  }
197 
198  return *this;
199 }
200 
201 template <typename T>
202 bool
203 UT_VoxelTile<T>::writeThrough(int x, int y, int z, T t)
204 {
205  switch (myCompressionType)
206  {
207  case COMPRESS_RAW:
208  // Do the assignment.
209  ((T *)myData)[ ((z * myRes[1]) + y) * myRes[0] + x ] = t;
210  return true;
211 
212  case COMPRESS_CONSTANT:
213  if (rawConstVal() == t)
214  {
215  // Trivially true.
216  return true;
217  }
218  return false;
219 
220  case COMPRESS_RAWFULL:
221  ((T *)myData)[ ((z * TILESIZE) + y) * TILESIZE + x ] = t;
222  return true;
223 
224  case COMPRESS_FPREAL16:
225  return false;
226  }
227 
228  // Use the compression engine.
229  UT_VoxelTileCompress<T> *engine;
230 
231  engine = getCompressionEngine(myCompressionType);
232  return engine->writeThrough(*this, x, y, z, t);
233 }
234 
235 template <typename T>
236 T
237 UT_VoxelTile<T>::operator()(int x, int y, int z) const
238 {
239  UT_ASSERT_P(x >= 0 && y >= 0 && z >= 0);
240  UT_ASSERT_P(x < myRes[0] && y < myRes[1] && z < myRes[2]);
241 
242  switch (myCompressionType)
243  {
244  case COMPRESS_RAW:
245  return ((T *)myData)[
246  ((z * myRes[1]) + y) * myRes[0] + x ];
247 
248  case COMPRESS_CONSTANT:
249  return rawConstVal();
250 
251  case COMPRESS_RAWFULL:
252  return ((T *)myData)[
253  ((z * TILESIZE) + y) * TILESIZE + x ];
254 
255  case COMPRESS_FPREAL16:
256  {
257  static constexpr UT_FromUnbounded<T> convertFromFP16{};
258 
259  fpreal16* data = (fpreal16*) myData;
260  int offset = ((z * myRes[1] + y) * myRes[0] + x)
261  * UT_FixedVectorTraits<T>::TupleSize;
262  T result = convertFromFP16(data + offset);
263  return result;
264  }
265  }
266 
267  // By default use the compression engine.
268  UT_VoxelTileCompress<T> *engine;
269 
270  engine = getCompressionEngine(myCompressionType);
271  return engine->getValue(*this, x, y, z);
272 }
273 
274 template <typename T>
275 T
276 UT_VoxelTile<T>::lerp(int x, int y, int z, fpreal32 fx, fpreal32 fy, fpreal32 fz) const
277 {
278  T vx, vx1, vy, vy1, vz;
279 
280  switch (myCompressionType)
281  {
282  case COMPRESS_RAW:
283  {
284  T *data = (T *) myData;
285  int offset = (z * myRes[1] + y) * myRes[0] + x;
286  int yinc = myRes[0];
287  int zinc = myRes[0] * myRes[1];
288 
289  // Lerp x:x+1, y, z
290  vx = lerpValues(data[offset], data[offset+1], fx);
291  // Lerp x:x+1, y+1, z
292  vx1 = lerpValues(data[offset+yinc], data[offset+yinc+1], fx);
293 
294  // Lerp x:x+1, y:y+1, z
295  vy = lerpValues(vx, vx1, fy);
296 
297  // Lerp x:x+1, y, z+1
298  vx = lerpValues(data[offset+zinc], data[offset+zinc+1], fx);
299  // Lerp x:x+1, y+1, z+1
300  vx1 = lerpValues(data[offset+zinc+yinc], data[offset+zinc+yinc+1], fx);
301 
302  // Lerp x:x+1, y:y+1, z+1
303  vy1 = lerpValues(vx, vx1, fy);
304 
305  // Lerp x:x+1, y:y+1, z:z+1
306  vz = lerpValues(vy, vy1, fz);
307  break;
308  }
309  case COMPRESS_RAWFULL:
310  {
311  T *data = (T *) myData;
312  int offset = (z * TILESIZE + y) * TILESIZE + x;
313  int yinc = TILESIZE;
314  int zinc = TILESIZE * TILESIZE;
315 
316  // Lerp x:x+1, y, z
317  vx = lerpValues(data[offset], data[offset+1], fx);
318  // Lerp x:x+1, y+1, z
319  vx1 = lerpValues(data[offset+yinc], data[offset+yinc+1], fx);
320 
321  // Lerp x:x+1, y:y+1, z
322  vy = lerpValues(vx, vx1, fy);
323 
324  // Lerp x:x+1, y, z+1
325  vx = lerpValues(data[offset+zinc], data[offset+zinc+1], fx);
326  // Lerp x:x+1, y+1, z+1
327  vx1 = lerpValues(data[offset+zinc+yinc], data[offset+zinc+yinc+1], fx);
328 
329  // Lerp x:x+1, y:y+1, z+1
330  vy1 = lerpValues(vx, vx1, fy);
331 
332  // Lerp x:x+1, y:y+1, z:z+1
333  vz = lerpValues(vy, vy1, fz);
334  break;
335  }
336  case COMPRESS_FPREAL16:
337  {
338  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
339  static constexpr UT_FromUnbounded<T> convertFromFP16{};
340 
341  fpreal16 *data = (fpreal16 *) myData;
342  int xinc = tuple_size;
343  int yinc = myRes[0] * xinc;
344  int zinc = myRes[1] * yinc;
345  int offset = z * zinc + y * yinc + x * xinc;
346  fpreal16 vx, vx1, vy, vy1;
347  fpreal16 result[tuple_size];
348 
349  for (int j = 0; j < tuple_size; j++, offset++)
350  {
351  // Lerp x:x+1, y, z
352  vx = SYSlerp(data[offset], data[offset+xinc], fx);
353  // Lerp x:x+1, y+1, z
354  vx1 = SYSlerp(data[offset+yinc], data[offset+yinc+xinc], fx);
355 
356  // Lerp x:x+1, y:y+1, z
357  vy = SYSlerp(vx, vx1, fy);
358 
359  // Lerp x:x+1, y, z+1
360  vx = SYSlerp(data[offset+zinc], data[offset+zinc+xinc], fx);
361  // Lerp x:x+1, y+1, z+1
362  vx1 = SYSlerp(data[offset+zinc+yinc], data[offset+zinc+yinc+xinc], fx);
363 
364  // Lerp x:x+1, y:y+1, z+1
365  vy1 = SYSlerp(vx, vx1, fy);
366 
367  // Lerp x:x+1, y:y+1, z:z+1
368  result[j] = SYSlerp(vy, vy1, fz);
369  }
370 
371  return convertFromFP16(result);
372  }
373  case COMPRESS_CONSTANT:
374  {
375  // This is quite trivial to do a trilerp on.
376  vz = rawConstVal();
377  break;
378  }
379 
380  default:
381  {
382  UT_VoxelTileCompress<T> *engine;
383 
384  engine = getCompressionEngine(myCompressionType);
385  // Lerp x:x+1, y, z
386  vx = lerpValues(engine->getValue(*this, x, y, z),
387  engine->getValue(*this, x+1, y, z),
388  fx);
389  // Lerp x:x+1, y+1, z
390  vx1 = lerpValues(engine->getValue(*this, x, y+1, z),
391  engine->getValue(*this, x+1, y+1, z),
392  fx);
393 
394  // Lerp x:x+1, y:y+1, z
395  vy = lerpValues(vx, vx1, fy);
396 
397  // Lerp x:x+1, y, z+1
398  vx = lerpValues(engine->getValue(*this, x, y, z+1),
399  engine->getValue(*this, x+1, y, z+1),
400  fx);
401  // Lerp x:x+1, y+1, z+1
402  vx1 = lerpValues(engine->getValue(*this, x, y+1, z+1),
403  engine->getValue(*this, x+1, y+1, z+1),
404  fx);
405 
406  // Lerp x:x+1, y:y+1, z+1
407  vy1 = lerpValues(vx, vx1, fy);
408 
409  // Lerp x:x+1, y:y+1, z:z+1
410  vz = lerpValues(vy, vy1, fz);
411  break;
412  }
413  }
414 
415  return vz;
416 }
417 
418 template <typename T>
419 template <int AXIS2D>
420 T
421 UT_VoxelTile<T>::lerpAxis(int x, int y, int z, fpreal32 fx, fpreal32 fy, fpreal32 fz) const
422 {
423  T vx, vx1, vy, vy1, vz;
424 
425  switch (myCompressionType)
426  {
427  case COMPRESS_RAW:
428  {
429  T *data = (T *) myData;
430  int offset = (z * myRes[1] + y) * myRes[0] + x;
431  int yinc = myRes[0];
432  int zinc = myRes[0] * myRes[1];
433 
434  // Lerp x:x+1, y, z
435  if (AXIS2D != 0)
436  vx = lerpValues(data[offset],
437  data[offset+1],
438  fx);
439  else
440  vx = data[offset];
441 
442  if (AXIS2D != 1)
443  {
444  // Lerp x:x+1, y+1, z
445  if (AXIS2D != 0)
446  vx1= lerpValues(data[offset+yinc],
447  data[offset+yinc+1],
448  fx);
449  else
450  vx1 = data[offset+yinc];
451  // Lerp x:x+1, y:y+1, z
452  vy = lerpValues(vx, vx1, fy);
453  }
454  else
455  vy = vx;
456 
457  if (AXIS2D != 2)
458  {
459  // Lerp x:x+1, y, z+1
460  if (AXIS2D != 0)
461  vx = lerpValues(data[offset+zinc],
462  data[offset+zinc+1],
463  fx);
464  else
465  vx = data[offset+zinc];
466 
467  if (AXIS2D != 1)
468  {
469  // Lerp x:x+1, y+1, z+1
470  if (AXIS2D != 0)
471  vx1= lerpValues(data[offset+zinc+yinc],
472  data[offset+zinc+yinc+1],
473  fx);
474  else
475  vx1 = data[offset+zinc+yinc];
476  // Lerp x:x+1, y:y+1, z+1
477  vy1 = lerpValues(vx, vx1, fy);
478  }
479  else
480  vy1 = vx;
481 
482  // Lerp x:x+1, y:y+1, z:z+1
483  vz = lerpValues(vy, vy1, fz);
484  }
485  else
486  vz = vy;
487  break;
488  }
489  case COMPRESS_RAWFULL:
490  {
491  T *data = (T *) myData;
492  int offset = (z * TILESIZE + y) * TILESIZE + x;
493  int yinc = TILESIZE;
494  int zinc = TILESIZE * TILESIZE;
495 
496  // Lerp x:x+1, y, z
497  if (AXIS2D != 0)
498  vx = lerpValues(data[offset],
499  data[offset+1],
500  fx);
501  else
502  vx = data[offset];
503 
504  if (AXIS2D != 1)
505  {
506  // Lerp x:x+1, y+1, z
507  if (AXIS2D != 0)
508  vx1= lerpValues(data[offset+yinc],
509  data[offset+yinc+1],
510  fx);
511  else
512  vx1 = data[offset+yinc];
513  // Lerp x:x+1, y:y+1, z
514  vy = lerpValues(vx, vx1, fy);
515  }
516  else
517  vy = vx;
518 
519  if (AXIS2D != 2)
520  {
521  // Lerp x:x+1, y, z+1
522  if (AXIS2D != 0)
523  vx = lerpValues(data[offset+zinc],
524  data[offset+zinc+1],
525  fx);
526  else
527  vx = data[offset+zinc];
528 
529  if (AXIS2D != 1)
530  {
531  // Lerp x:x+1, y+1, z+1
532  if (AXIS2D != 0)
533  vx1= lerpValues(data[offset+zinc+yinc],
534  data[offset+zinc+yinc+1],
535  fx);
536  else
537  vx1 = data[offset+zinc+yinc];
538  // Lerp x:x+1, y:y+1, z+1
539  vy1 = lerpValues(vx, vx1, fy);
540  }
541  else
542  vy1 = vx;
543 
544  // Lerp x:x+1, y:y+1, z:z+1
545  vz = lerpValues(vy, vy1, fz);
546  }
547  else
548  vz = vy;
549  break;
550  }
551  case COMPRESS_FPREAL16:
552  {
553  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
554  static constexpr UT_FromUnbounded<T> convertFromFP16{};
555 
556  fpreal16 *data = (fpreal16 *) myData;
557  int xinc = tuple_size;
558  int yinc = myRes[0] * xinc;
559  int zinc = myRes[1] * yinc;
560  int offset = z * zinc + y * yinc + x * xinc;
561  fpreal16 vx, vx1, vy, vy1;
562  fpreal16 result[tuple_size];
563 
564  for (int j = 0; j < tuple_size; j++, offset++)
565  {
566  // Lerp x:x+1, y, z
567  if (AXIS2D != 0)
568  vx = SYSlerp(data[offset],
569  data[offset+xinc],
570  fx);
571  else
572  vx = data[offset];
573 
574  if (AXIS2D != 1)
575  {
576  // Lerp x:x+1, y+1, z
577  if (AXIS2D != 0)
578  vx1= SYSlerp(data[offset+yinc],
579  data[offset+yinc+xinc],
580  fx);
581  else
582  vx1 = data[offset+yinc];
583  // Lerp x:x+1, y:y+1, z
584  vy = SYSlerp(vx, vx1, fy);
585  }
586  else
587  vy = vx;
588 
589  if (AXIS2D != 2)
590  {
591  // Lerp x:x+1, y, z+1
592  if (AXIS2D != 0)
593  vx = SYSlerp(data[offset+zinc],
594  data[offset+zinc+xinc],
595  fx);
596  else
597  vx = data[offset+zinc];
598 
599  if (AXIS2D != 1)
600  {
601  // Lerp x:x+1, y+1, z+1
602  if (AXIS2D != 0)
603  vx1= SYSlerp(data[offset+zinc+yinc],
604  data[offset+zinc+yinc+xinc],
605  fx);
606  else
607  vx1 = data[offset+zinc+yinc];
608  // Lerp x:x+1, y:y+1, z+1
609  vy1 = SYSlerp(vx, vx1, fy);
610  }
611  else
612  vy1 = vx;
613 
614  // Lerp x:x+1, y:y+1, z:z+1
615  result[j] = SYSlerp(vy, vy1, fz);
616  }
617  else
618  result[j] = vy;
619  }
620 
621  return convertFromFP16(result);
622  }
623  case COMPRESS_CONSTANT:
624  {
625  // This is quite trivial to do a bilerp on.
626  vz = rawConstVal();
627  break;
628  }
629 
630  default:
631  {
632  UT_VoxelTileCompress<T> *engine;
633 
634  engine = getCompressionEngine(myCompressionType);
635  // Lerp x:x+1, y, z
636  if (AXIS2D != 0)
637  vx = lerpValues(engine->getValue(*this, x, y, z),
638  engine->getValue(*this, x+1, y, z),
639  fx);
640  else
641  vx = engine->getValue(*this, x, y, z);
642 
643  if (AXIS2D != 1)
644  {
645  // Lerp x:x+1, y+1, z
646  if (AXIS2D != 0)
647  vx1= lerpValues(engine->getValue(*this, x, y+1, z),
648  engine->getValue(*this, x+1, y+1, z),
649  fx);
650  else
651  vx1 = engine->getValue(*this, x, y+1, z);
652  // Lerp x:x+1, y:y+1, z
653  vy = lerpValues(vx, vx1, fy);
654  }
655  else
656  vy = vx;
657 
658  if (AXIS2D != 2)
659  {
660  // Lerp x:x+1, y, z+1
661  if (AXIS2D != 0)
662  vx = lerpValues(engine->getValue(*this, x, y, z+1),
663  engine->getValue(*this, x+1, y, z+1),
664  fx);
665  else
666  vx = engine->getValue(*this, x, y, z+1);
667 
668  if (AXIS2D != 1)
669  {
670  // Lerp x:x+1, y+1, z+1
671  if (AXIS2D != 0)
672  vx1= lerpValues(engine->getValue(*this, x, y+1, z+1),
673  engine->getValue(*this, x+1, y+1, z+1),
674  fx);
675  else
676  vx1 = engine->getValue(*this, x, y+1, z+1);
677  // Lerp x:x+1, y:y+1, z+1
678  vy1 = lerpValues(vx, vx1, fy);
679  }
680  else
681  vy1 = vx;
682 
683  // Lerp x:x+1, y:y+1, z:z+1
684  vz = lerpValues(vy, vy1, fz);
685  }
686  else
687  vz = vy;
688  break;
689  }
690  }
691 
692  return vz;
693 }
694 
695 template <typename T>
696 bool
697 UT_VoxelTile<T>::extractSample(int x, int y, int z, T *sample) const
698 {
699  switch (myCompressionType)
700  {
701  case COMPRESS_RAW:
702  {
703  T *data = (T *) myData;
704  int offset = (z * myRes[1] + y) * myRes[0] + x;
705  int yinc = myRes[0];
706  int zinc = myRes[0] * myRes[1];
707 
708  sample[0] = data[offset];
709  sample[1] = data[offset+1];
710  sample[2+0] = data[offset+yinc];
711  sample[2+1] = data[offset+yinc+1];
712  sample[4+0] = data[offset+zinc];
713  sample[4+1] = data[offset+zinc+1];
714  sample[4+2+0] = data[offset+zinc+yinc];
715  sample[4+2+1] = data[offset+zinc+yinc+1];
716  break;
717  }
718  case COMPRESS_RAWFULL:
719  {
720  T *data = (T *) myData;
721  int offset = (z * TILESIZE + y) * TILESIZE + x;
722  int yinc = TILESIZE;
723  int zinc = TILESIZE * TILESIZE;
724 
725  sample[0] = data[offset];
726  sample[1] = data[offset+1];
727  sample[2+0] = data[offset+yinc];
728  sample[2+1] = data[offset+yinc+1];
729  sample[4+0] = data[offset+zinc];
730  sample[4+1] = data[offset+zinc+1];
731  sample[4+2+0] = data[offset+zinc+yinc];
732  sample[4+2+1] = data[offset+zinc+yinc+1];
733  break;
734  }
735  case COMPRESS_FPREAL16:
736  {
737  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
738  static constexpr UT_FromUnbounded<T> convertFromFP16{};
739 
740  fpreal16 *data = (fpreal16 *) myData;
741  int xinc = tuple_size;
742  int yinc = myRes[0] * xinc;
743  int zinc = myRes[1] * yinc;
744  int offset = z * zinc + y * yinc + x * xinc;
745 
746  data += offset;
747  sample[0] = convertFromFP16(data);
748  sample[1] = convertFromFP16(data + xinc);
749  sample[2+0] = convertFromFP16(data + yinc);
750  sample[2+1] = convertFromFP16(data + yinc + xinc);
751  sample[4+0] = convertFromFP16(data + zinc);
752  sample[4+1] = convertFromFP16(data + zinc + xinc);
753  sample[4+2+0] = convertFromFP16(data + zinc + yinc);
754  sample[4+2+1] = convertFromFP16(data + zinc + yinc + xinc);
755  break;
756  }
757  case COMPRESS_CONSTANT:
758  {
759  sample[0] = rawConstVal();
760  return true;
761  }
762 
763  default:
764  {
765  UT_VoxelTileCompress<T> *engine;
766 
767  engine = getCompressionEngine(myCompressionType);
768  // Lerp x:x+1, y, z
769  sample[0] = engine->getValue(*this, x, y, z);
770  sample[1] = engine->getValue(*this, x+1, y, z);
771  sample[2+0] = engine->getValue(*this, x, y+1, z);
772  sample[2+1] = engine->getValue(*this, x+1, y+1, z);
773  sample[4+0] = engine->getValue(*this, x, y, z+1);
774  sample[4+1] = engine->getValue(*this, x+1, y, z+1);
775  sample[4+2+0] = engine->getValue(*this, x, y+1, z+1);
776  sample[4+2+1] = engine->getValue(*this, x+1, y+1, z+1);
777  break;
778  }
779  }
780  return false;
781 }
782 
783 template <typename T>
784 bool
785 UT_VoxelTile<T>::extractSamplePlus(int x, int y, int z, T *sample) const
786 {
787  switch (myCompressionType)
788  {
789  case COMPRESS_RAW:
790  {
791  T *data = (T *) myData;
792  int offset = (z * myRes[1] + y) * myRes[0] + x;
793  int yinc = myRes[0];
794  int zinc = myRes[0] * myRes[1];
795 
796  sample[0] = data[offset-1];
797  sample[1] = data[offset+1];
798  sample[2+0] = data[offset-yinc];
799  sample[2+1] = data[offset+yinc];
800  sample[4+0] = data[offset-zinc];
801  sample[4+1] = data[offset+zinc];
802  sample[6] = data[offset];
803  break;
804  }
805  case COMPRESS_RAWFULL:
806  {
807  T *data = (T *) myData;
808  int offset = (z * TILESIZE + y) * TILESIZE + x;
809  int yinc = TILESIZE;
810  int zinc = TILESIZE * TILESIZE;
811 
812  sample[0] = data[offset-1];
813  sample[1] = data[offset+1];
814  sample[2+0] = data[offset-yinc];
815  sample[2+1] = data[offset+yinc];
816  sample[4+0] = data[offset-zinc];
817  sample[4+1] = data[offset+zinc];
818  sample[6] = data[offset];
819  break;
820  }
821  case COMPRESS_FPREAL16:
822  {
823  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
824  static constexpr UT_FromUnbounded<T> convertFromFP16{};
825 
826  fpreal16 *data = (fpreal16 *) myData;
827  int xinc = tuple_size;
828  int yinc = myRes[0] * xinc;
829  int zinc = myRes[1] * yinc;
830  int offset = z * zinc + y * yinc + x * xinc;
831 
832  data += offset;
833  sample[0] = convertFromFP16(data - xinc);
834  sample[1] = convertFromFP16(data + xinc);
835  sample[2+0] = convertFromFP16(data - yinc);
836  sample[2+1] = convertFromFP16(data + yinc);
837  sample[4+0] = convertFromFP16(data - zinc);
838  sample[4+1] = convertFromFP16(data + zinc);
839  sample[6] = convertFromFP16(data);
840  break;
841  }
842  case COMPRESS_CONSTANT:
843  {
844  sample[0] = rawConstVal();
845  return true;
846  }
847 
848  default:
849  {
850  UT_VoxelTileCompress<T> *engine;
851 
852  engine = getCompressionEngine(myCompressionType);
853  // Lerp x:x+1, y, z
854  sample[0] = engine->getValue(*this, x-1, y, z);
855  sample[1] = engine->getValue(*this, x+1, y, z);
856  sample[2+0] = engine->getValue(*this, x, y-1, z);
857  sample[2+1] = engine->getValue(*this, x, y+1, z);
858  sample[4+0] = engine->getValue(*this, x, y, z+1);
859  sample[4+1] = engine->getValue(*this, x, y, z-1);
860  sample[6] = engine->getValue(*this, x, y, z);
861  break;
862  }
863  }
864  return false;
865 }
866 
867 #if 0
868 /// Implementation of this function has an error. The outer dz loop assumes that
869 /// the incoming offset is for y=0, as it immediately subtracts yinc to get to
870 /// y=-1; it then loops over the 3 y layers, adding yinc every time. After this
871 /// dz loop, yinc is subtracted thrice, bringing us back to y=-1. On the next
872 /// iteration of the dz loop, this violates the y=0 assumption.
873 /// There aren't any users of these methods in our own code.
874 template <typename T>
875 bool
876 UT_VoxelTile<T>::extractSampleCube(int x, int y, int z, T *sample) const
877 {
878  switch (myCompressionType)
879  {
880  case COMPRESS_RAW:
881  {
882  T *data = (T *) myData;
883  int offset = (z * myRes[1] + y) * myRes[0] + x;
884  int yinc = myRes[0];
885  int zinc = myRes[0] * myRes[1];
886  int sampidx = 0;
887 
888  offset -= zinc;
889  for (int dz = -1; dz <= 1; dz++)
890  {
891  offset -= yinc;
892  for (int dy = -1; dy <= 1; dy++)
893  {
894  sample[sampidx] = data[offset-1];
895  sample[sampidx+1] = data[offset];
896  sample[sampidx+2] = data[offset+1];
897  sampidx += 3;
898  offset += yinc;
899  }
900  offset -= yinc * 3;
901  offset += zinc;
902  }
903  break;
904  }
905  case COMPRESS_RAWFULL:
906  {
907  T *data = (T *) myData;
908  int offset = (z * TILESIZE + y) * TILESIZE + x;
909  int yinc = TILESIZE;
910  int zinc = TILESIZE * TILESIZE;
911  int sampidx = 0;
912 
913  offset -= zinc;
914  for (int dz = -1; dz <= 1; dz++)
915  {
916  offset -= yinc;
917  for (int dy = -1; dy <= 1; dy++)
918  {
919  sample[sampidx] = data[offset-1];
920  sample[sampidx+1] = data[offset];
921  sample[sampidx+2] = data[offset+1];
922  sampidx += 3;
923  offset += yinc;
924  }
925  offset -= yinc * 3;
926  offset += zinc;
927  }
928  break;
929  }
930  case COMPRESS_FPREAL16:
931  {
932  fpreal16 *data = (fpreal16 *) myData;
933  int offset = (z * myRes[1] + y) * myRes[0] + x;
934  int yinc = myRes[0];
935  int zinc = myRes[0] * myRes[1];
936  int sampidx = 0;
937 
938  offset -= zinc;
939  for (int dz = -1; dz <= 1; dz++)
940  {
941  offset -= yinc;
942  for (int dy = -1; dy <= 1; dy++)
943  {
944  sample[sampidx] = data[offset-1];
945  sample[sampidx+1] = data[offset];
946  sample[sampidx+2] = data[offset+1];
947  sampidx += 3;
948  offset += yinc;
949  }
950  offset -= yinc * 3;
951  offset += zinc;
952  }
953  break;
954  }
955  case COMPRESS_CONSTANT:
956  {
957  sample[0] = rawConstVal();
958  return true;
959  }
960 
961  default:
962  {
963  UT_VoxelTileCompress<T> *engine;
964 
965  engine = getCompressionEngine(myCompressionType);
966  int sampidx = 0;
967  // Lerp x:x+1, y, z
968  for (int dz = -1; dz <= 1; dz++)
969  {
970  for (int dy = -1; dy <= 1; dy++)
971  {
972  for (int dx = -1; dx <= 1; dx++)
973  {
974  sample[sampidx++] = engine->getValue(*this, x+dx, y+dy, z+dz);
975  }
976  }
977  }
978  break;
979  }
980  }
981  return false;
982 }
983 #endif
984 
985 template <typename T>
986 template <int AXIS2D>
987 bool
988 UT_VoxelTile<T>::extractSampleAxis(int x, int y, int z, T *sample) const
989 {
990  switch (myCompressionType)
991  {
992  case COMPRESS_RAW:
993  {
994  T *data = (T *) myData;
995  int offset = (z * myRes[1] + y) * myRes[0] + x;
996  int yinc = myRes[0];
997  int zinc = myRes[0] * myRes[1];
998 
999  sample[0] = data[offset];
1000  if (AXIS2D != 0)
1001  sample[1] = data[offset+1];
1002  if (AXIS2D != 1)
1003  {
1004  sample[2+0] = data[offset+yinc];
1005  if (AXIS2D != 0)
1006  sample[2+1] = data[offset+yinc+1];
1007  }
1008  if (AXIS2D != 2)
1009  {
1010  sample[4+0] = data[offset+zinc];
1011  if (AXIS2D != 0)
1012  sample[4+1] = data[offset+zinc+1];
1013  if (AXIS2D != 1)
1014  {
1015  sample[4+2+0] = data[offset+zinc+yinc];
1016  if (AXIS2D != 0)
1017  sample[4+2+1] = data[offset+zinc+yinc+1];
1018  }
1019  }
1020  break;
1021  }
1022  case COMPRESS_RAWFULL:
1023  {
1024  T *data = (T *) myData;
1025  int offset = (z * TILESIZE + y) * TILESIZE + x;
1026  int yinc = TILESIZE;
1027  int zinc = TILESIZE * TILESIZE;
1028 
1029  sample[0] = data[offset];
1030  if (AXIS2D != 0)
1031  sample[1] = data[offset+1];
1032  if (AXIS2D != 1)
1033  {
1034  sample[2+0] = data[offset+yinc];
1035  if (AXIS2D != 0)
1036  sample[2+1] = data[offset+yinc+1];
1037  }
1038  if (AXIS2D != 2)
1039  {
1040  sample[4+0] = data[offset+zinc];
1041  if (AXIS2D != 0)
1042  sample[4+1] = data[offset+zinc+1];
1043  if (AXIS2D != 1)
1044  {
1045  sample[4+2+0] = data[offset+zinc+yinc];
1046  if (AXIS2D != 0)
1047  sample[4+2+1] = data[offset+zinc+yinc+1];
1048  }
1049  }
1050  break;
1051  }
1052  case COMPRESS_FPREAL16:
1053  {
1054  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
1055  static constexpr UT_FromUnbounded<T> convertFromFP16{};
1056 
1057  fpreal16 *data = (fpreal16 *) myData;
1058  int xinc = tuple_size;
1059  int yinc = myRes[0] * xinc;
1060  int zinc = myRes[1] * yinc;
1061  int offset = z * zinc + y * yinc + x * xinc;
1062 
1063  data += offset;
1064  sample[0] = convertFromFP16(data);
1065  if (AXIS2D != 0)
1066  sample[1] = convertFromFP16(data + xinc);
1067  if (AXIS2D != 1)
1068  {
1069  sample[2+0] = convertFromFP16(data + yinc);
1070  if (AXIS2D != 0)
1071  sample[2+1] = convertFromFP16(data + yinc + xinc);
1072  }
1073  if (AXIS2D != 2)
1074  {
1075  sample[4+0] = convertFromFP16(data + zinc);
1076  if (AXIS2D != 0)
1077  sample[4+1] = convertFromFP16(data + zinc + xinc);
1078  if (AXIS2D != 1)
1079  {
1080  sample[4+2+0] = convertFromFP16(data + zinc + yinc);
1081  if (AXIS2D != 0)
1082  sample[4+2+1] = convertFromFP16(data + zinc + yinc + xinc);
1083  }
1084  }
1085  break;
1086  }
1087  case COMPRESS_CONSTANT:
1088  {
1089  sample[0] = rawConstVal();
1090  return true;
1091  }
1092 
1093  default:
1094  {
1095  UT_VoxelTileCompress<T> *engine;
1096 
1097  engine = getCompressionEngine(myCompressionType);
1098  // Lerp x:x+1, y, z
1099  sample[0] = engine->getValue(*this, x, y, z);
1100  if (AXIS2D != 0)
1101  sample[1] = engine->getValue(*this, x+1, y, z);
1102  if (AXIS2D != 1)
1103  {
1104  sample[2+0] = engine->getValue(*this, x, y+1, z);
1105  if (AXIS2D != 0)
1106  sample[2+1] = engine->getValue(*this, x+1, y+1, z);
1107  }
1108  if (AXIS2D != 2)
1109  {
1110  sample[4+0] = engine->getValue(*this, x, y, z+1);
1111  if (AXIS2D != 0)
1112  sample[4+1] = engine->getValue(*this, x+1, y, z+1);
1113  if (AXIS2D != 1)
1114  {
1115  sample[4+2+0] = engine->getValue(*this, x, y+1, z+1);
1116  if (AXIS2D != 0)
1117  sample[4+2+1] = engine->getValue(*this, x+1, y+1, z+1);
1118  }
1119  }
1120  break;
1121  }
1122  }
1123  return false;
1124 }
1125 
1126 #if 0
1127 template <typename T>
1128 T
1129 UT_VoxelTile<T>::lerp(v4uf frac, int x, int y, int z) const
1130 {
1131  v4uf a, b;
1132 
1133  switch (myCompressionType)
1134  {
1135  case COMPRESS_RAW:
1136  case COMPRESS_RAWFULL:
1137  {
1138  T *data = (T *) myData;
1139  int offset = (z * myRes[1] + y) * myRes[0] + x;
1140  int yinc = myRes[0];
1141  int zinc = myRes[0] * myRes[1];
1142 
1143  a = v4uf( data[offset],
1144  data[offset+zinc],
1145  data[offset+yinc],
1146  data[offset+yinc+zinc] );
1147  b = v4uf( data[offset+1],
1148  data[offset+zinc+1],
1149  data[offset+yinc+1],
1150  data[offset+yinc+zinc+1] );
1151  break;
1152  }
1153 
1154  case COMPRESS_CONSTANT:
1155  {
1156  // This is quite trivial to do a trilerp on.
1157  return rawConstVal();
1158  }
1159 
1160  default:
1161  {
1162  UT_VoxelTileCompress<T> *engine;
1163 
1164  engine = getCompressionEngine(myCompressionType);
1165  // Lerp x:x+1, y, z
1166  a = v4uf( engine->getValue(*this, x, y, z),
1167  engine->getValue(*this, x, y, z+1),
1168  engine->getValue(*this, x, y+1, z),
1169  engine->getValue(*this, x, y+1, z+1) );
1170  b = v4uf( engine->getValue(*this, x+1, y, z),
1171  engine->getValue(*this, x+1, y, z+1),
1172  engine->getValue(*this, x+1, y+1, z),
1173  engine->getValue(*this, x+1, y+1, z+1) );
1174  break;
1175  }
1176  }
1177 
1178  v4uf fx, fy, fz;
1179 
1180  fx = frac.swizzle<0, 0, 0, 0>();
1181  fy = frac.swizzle<1, 1, 1, 1>();
1182  fz = frac.swizzle<2, 2, 2, 2>();
1183 
1184  b -= a;
1185  a = madd(b, fx, a);
1186 
1187  b = a.swizzle<2, 3, 0, 1>();
1188  b -= a;
1189  a = madd(b, fy, a);
1190 
1191  b = a.swizzle<1, 2, 3, 0>();
1192  b -= a;
1193  a = madd(b, fz, a);
1194 
1195  return a[0];
1196 }
1197 #endif
1198 
1199 template <typename T>
1200 T *
1201 UT_VoxelTile<T>::fillCacheLine(T *cacheline, int &stride, int x, int y, int z, bool forcecopy, bool strideofone) const
1202 {
1203  UT_ASSERT_P(x >= 0 && y >= 0 && z >= 0);
1204  UT_ASSERT_P(x < myRes[0] && y < myRes[1] && z < myRes[2]);
1205 
1206  T *src;
1207  int i, xres = myRes[0];
1208 
1209  // All the directly handled types exit directly from this switch.
1210  switch (myCompressionType)
1211  {
1212  case COMPRESS_RAW:
1213  stride = 1;
1214  src = (T *)myData + (z * myRes[1] + y) * xres;
1215  if (!forcecopy)
1216  return &src[x];
1217 
1218  for (i = 0; i < xres; i++)
1219  cacheline[i] = src[i];
1220 
1221  return &cacheline[x];
1222 
1223  case COMPRESS_FPREAL16:
1224  {
1225  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
1226  static constexpr UT_FromUnbounded<T> convertFromFP16{};
1227 
1228  fpreal16 *src = (fpreal16 *) myData;
1229  int xinc = tuple_size;
1230  int yinc = myRes[0] * xinc;
1231  int zinc = myRes[1] * yinc;
1232  int offset = z * zinc + y * yinc;
1233 
1234  stride = 1;
1235  src += offset;
1236 
1237  for (i = 0; i < xres; i++, src += xinc)
1238  cacheline[i] = convertFromFP16(src);
1239 
1240  return &cacheline[x];
1241  }
1242 
1243 
1244  case COMPRESS_CONSTANT:
1245  src = rawConstData();
1246  if (!forcecopy && !strideofone)
1247  {
1248  stride = 0;
1249  return src;
1250  }
1251  stride = 1;
1252  // Fill out a constant value
1253  for (i = 0; i < xres; i++)
1254  cacheline[i] = *src;
1255 
1256  return &cacheline[x];
1257 
1258 
1259  case COMPRESS_RAWFULL:
1260  stride = 1;
1261  src = (T *)myData + (z * TILESIZE + y) * TILESIZE;
1262  if (!forcecopy)
1263  return &src[x];
1264 
1265  for (i = 0; i < xres; i++)
1266  cacheline[i] = src[i];
1267 
1268  return &cacheline[x];
1269  }
1270 
1271  // By default use the compression engine.
1272  UT_VoxelTileCompress<T> *engine;
1273 
1274  engine = getCompressionEngine(myCompressionType);
1275 
1276  // We could add support for a direct cacheline fill to accelerate
1277  // this case as well.
1278  stride = 1;
1279  for (i = 0; i < xres; i++)
1280  cacheline[i] = engine->getValue(*this, i, y, z);
1281 
1282  return &cacheline[x];
1283 }
1284 
1285 template <typename T>
1286 void
1287 UT_VoxelTile<T>::writeCacheLine(T *cacheline, int y, int z)
1288 {
1289  UT_ASSERT_P(y >= 0 && z >= 0);
1290  UT_ASSERT_P(y < myRes[1] && z < myRes[2]);
1291 
1292  T *dst, value;
1293  int i, xres = myRes[0];
1294 
1295  // All the directly handled types exit directly from this switch.
1296  switch (myCompressionType)
1297  {
1298  case COMPRESS_RAW:
1299  dst = (T *)myData + (z * myRes[1] + y) * xres;
1300  for (i = 0; i < xres; i++)
1301  *dst++ = *cacheline++;
1302  return;
1303 
1304  case COMPRESS_CONSTANT:
1305  value = rawConstVal();
1306  for (i = 0; i < xres; i++)
1307  if (cacheline[i] != value)
1308  break;
1309  // If everything was equal, our write is trivial.
1310  if (i == xres)
1311  return;
1312 
1313  break;
1314 
1315  case COMPRESS_RAWFULL:
1316  dst = (T *)myData + (z * TILESIZE + y) * TILESIZE;
1317  for (i = 0; i < TILESIZE; i++)
1318  *dst++ = *cacheline++;
1319 
1320  return;
1321  }
1322 
1323  // Switch back to invoking writeThrough. Ideally we'd have
1324  // a version that can handle a whole cache line at once
1325  for (i = 0; i < xres; i++)
1326  if (!writeThrough(i, y, z, cacheline[i]))
1327  break;
1328 
1329  // Determine if we failed to write everything through
1330  if (i != xres)
1331  {
1332  // Uncompress and reinvoke ourselves.
1333  uncompress();
1334  writeCacheLine(cacheline, y, z);
1335  }
1336 }
1337 
1338 template <typename T>
1339 void
1340 UT_VoxelTile<T>::copyFragment(int dstx, int dsty, int dstz,
1341  const UT_VoxelTile<T> &srctile,
1342  int srcx, int srcy, int srcz)
1343 {
1344  int w = SYSmin(xres() - dstx, srctile.xres() - srcx);
1345  int h = SYSmin(yres() - dsty, srctile.yres() - srcy);
1346  int d = SYSmin(zres() - dstz, srctile.zres() - srcz);
1347 
1348 #if 1
1349  if (srctile.isSimpleCompression())
1350  {
1351  T *dst;
1352  const T *src;
1353  int srcinc;
1354 
1355  src = srctile.rawData();
1356  srcinc = srctile.isConstant() ? 0 : 1;
1357 
1358  // Ensure we are easy to write to.
1359  uncompress();
1360 
1361  dst = rawData();
1362  dst += dstx + (dsty + dstz*yres())*xres();
1363 
1364  if (srcinc)
1365  src += srcx + (srcy + srcz*srctile.yres())*srctile.xres();
1366 
1367  for (int z = 0; z < d; z++)
1368  {
1369  for (int y = 0; y < h; y++)
1370  {
1371  if (srcinc)
1372  {
1373  for (int x = 0; x < w; x++)
1374  dst[x] = src[x];
1375  }
1376  else
1377  {
1378  for (int x = 0; x < w; x++)
1379  dst[x] = *src;
1380  }
1381  dst += xres();
1382  if (srcinc)
1383  src += srctile.xres();
1384  }
1385  dst += (yres()-h) * xres();
1386  if (srcinc)
1387  src += (srctile.yres() - h) * srctile.xres();
1388  }
1389 
1390  return;
1391  }
1392 #endif
1393 
1394  // Fail safe approach.
1395  for (int z = 0; z < d; z++)
1396  for (int y = 0; y < h; y++)
1397  for (int x = 0; x < w; x++)
1398  {
1399  setValue(dstx+x, dsty+y, dstz+z,
1400  srctile(srcx+x, srcy+y, srcz+z));
1401  }
1402 }
1403 
1404 template <typename T>
1405 template <typename S>
1406 void
1407 UT_VoxelTile<T>::flatten(S *dst, int stride) const
1408 {
1409  int w = xres();
1410  int h = yres();
1411  int d = zres();
1412 
1413  if (isSimpleCompression())
1414  {
1415  const T *src;
1416  int srcinc;
1417 
1418  src = rawData();
1419  srcinc = isConstant() ? 0 : 1;
1420 
1421  if (stride == 1)
1422  {
1423  if (srcinc == 1)
1424  {
1425  // Super trivial!
1426  for (int i = 0; i < w * h * d; i++)
1427  {
1428  *dst++ = T(*src++);
1429  }
1430  }
1431  else
1432  {
1433  // Constant, also trivial!
1434  T cval = T(*src);
1435 
1436  for (int i = 0; i < w * h * d; i++)
1437  {
1438  *dst++ = cval;
1439  }
1440  }
1441  }
1442  else
1443  {
1444  for (int z = 0; z < d; z++)
1445  {
1446  for (int y = 0; y < h; y++)
1447  {
1448  if (srcinc)
1449  {
1450  for (int x = 0; x < w; x++)
1451  {
1452  *dst = S(src[x]);
1453  dst += stride;
1454  }
1455  }
1456  else
1457  {
1458  for (int x = 0; x < w; x++)
1459  {
1460  *dst = S(*src);
1461  dst += stride;
1462  }
1463  }
1464  if (srcinc)
1465  src += w;
1466  }
1467  }
1468  }
1469 
1470  return;
1471  }
1472 
1473  // Fail safe approach.
1474  for (int z = 0; z < d; z++)
1475  for (int y = 0; y < h; y++)
1476  for (int x = 0; x < w; x++)
1477  {
1478  *dst = S((*this)(x, y, z));
1479  dst += stride;
1480  }
1481 }
1482 
1483 template <typename T>
1484 template <typename S>
1485 void
1486 UT_VoxelTile<T>::writeData(const S *srcdata, int srcstride)
1487 {
1488  int w = xres();
1489  int h = yres();
1490  int d = zres();
1491  int i, n = w * h * d;
1492 
1493  // Check if src is constant
1494  S compare = srcdata[0];
1495  int srcoff = srcstride;
1496 
1497  if (srcstride == 0)
1498  {
1499  // Trivially constant
1500  makeConstant(T(compare));
1501  return;
1502  }
1503 
1504  for (i = 1; i < n; i++)
1505  {
1506  if (srcdata[srcoff] != compare)
1507  break;
1508  srcoff += srcstride;
1509  }
1510 
1511  if (i == n)
1512  {
1513  // Constant source!
1514  makeConstant(compare);
1515  return;
1516  }
1517 
1518  // Create a raw tile, expanding constants
1519  uncompress();
1520 
1521  if (srcstride == 1)
1522  {
1523  T *dst = rawData();
1524  for (i = 0; i < n; i++)
1525  {
1526  *dst++ = T(*srcdata++);
1527  }
1528  }
1529  else
1530  {
1531  T *dst = rawData();
1532 
1533  srcoff = 0;
1534  for (i = 0; i < n; i++)
1535  {
1536  dst[i] = T(srcdata[srcoff]);
1537  srcoff += srcstride;
1538  }
1539  }
1540 }
1541 
1542 template <typename T>
1543 void
1544 UT_VoxelTile<T>::setValue(int x, int y, int z, T t)
1545 {
1546  UT_ASSERT_P(x >= 0 && y >= 0 && z >= 0);
1547  UT_ASSERT_P(x < myRes[0] && y < myRes[1] && z < myRes[2]);
1548 
1549  // Determine if assignment is compatible with current
1550  // compression technique.
1551  if (writeThrough(x, y, z, t))
1552  {
1553  return;
1554  }
1555  // Can't write to our current type of tile with the
1556  // given value, so abandon.
1557  uncompress();
1558 
1559  // Attempt to write through again. This must succeed
1560  // as we should now be uncompressed.
1561  UT_VERIFY_P(writeThrough(x, y, z, t));
1562 }
1563 
1564 template <typename T>
1565 void
1566 UT_VoxelTile<T>::uncompress()
1567 {
1568  switch (myCompressionType)
1569  {
1570  case COMPRESS_RAW:
1571  // Trivial.
1572  return;
1573 
1574  case COMPRESS_CONSTANT:
1575  {
1576  // Must expand the tile!
1577  T cval;
1578  int i, n;
1579 
1580  cval = rawConstVal();
1581  freeData();
1582 
1583  myCompressionType = COMPRESS_RAW;
1584 
1585  if (myRes[0] == TILESIZE &&
1586  myRes[1] == TILESIZE)
1587  {
1588  // Flag that we can do fast lookups on this tile.
1589  myCompressionType = COMPRESS_RAWFULL;
1590  }
1591 
1592  n = myRes[0] * myRes[1] * myRes[2];
1593  myData = UT_VOXEL_ALLOC(sizeof(T) * n);
1594 
1595  for (i = 0; i < n; i++)
1596  {
1597  ((T *)myData)[i] = cval;
1598  }
1599  return;
1600  }
1601  case COMPRESS_RAWFULL:
1602  {
1603  T *raw;
1604  int x, y, z, i, n;
1605 
1606  if (myRes[0] == TILESIZE &&
1607  myRes[1] == TILESIZE)
1608  {
1609  // Trivial
1610  return;
1611  }
1612 
1613  // Need to contract to the actual compact size.
1614  n = myRes[0] * myRes[1] * myRes[2];
1615  raw = (T *)UT_VOXEL_ALLOC(sizeof(T) * n);
1616  i = 0;
1617  for (z = 0; z < myRes[2]; z++)
1618  {
1619  for (y = 0; y < myRes[1]; y++)
1620  {
1621  for (x = 0; x < myRes[0]; x++)
1622  {
1623  raw[i++] = ((T *)myData)[x+(y+z*TILESIZE)*TILESIZE];
1624  }
1625  }
1626  }
1627 
1628  freeData();
1629  myCompressionType = COMPRESS_RAW;
1630  myData = raw;
1631 
1632  return;
1633  }
1634 
1635  case COMPRESS_FPREAL16:
1636  {
1637  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
1638  static constexpr UT_FromUnbounded<T> convertFromFP16{};
1639 
1640  T *raw;
1641  int x, y, z, i, n;
1642  fpreal16 *src = (fpreal16 *) myData;
1643 
1644  n = myRes[0] * myRes[1] * myRes[2];
1645  raw = (T *)UT_VOXEL_ALLOC(sizeof(T) * n);
1646  i = 0;
1647  for (z = 0; z < myRes[2]; z++)
1648  {
1649  for (y = 0; y < myRes[1]; y++)
1650  {
1651  for (x = 0; x < myRes[0]; x++, src += tuple_size)
1652  {
1653  raw[i] = convertFromFP16(src);
1654  i++;
1655  }
1656  }
1657  }
1658  freeData();
1659  myCompressionType = COMPRESS_RAW;
1660  myData = raw;
1661  return;
1662  }
1663  }
1664 
1665  // Use the compression engine.
1666  UT_VoxelTileCompress<T> *engine;
1667 
1668  engine = getCompressionEngine(myCompressionType);
1669 
1670  // We use the read ability to set our values.
1671  int x, y, z, i;
1672  T *raw;
1673 
1674  raw = (T *) UT_VOXEL_ALLOC(sizeof(T) * myRes[0] * myRes[1] * myRes[2]);
1675  i = 0;
1676  for (z = 0; z < myRes[2]; z++)
1677  {
1678  for (y = 0; y < myRes[1]; y++)
1679  {
1680  for (x = 0; x < myRes[0]; x++)
1681  {
1682  raw[i++] = engine->getValue(*this, x, y, z);
1683  }
1684  }
1685  }
1686 
1687  freeData();
1688 
1689  // Now copy in the result
1690  myCompressionType = COMPRESS_RAW;
1691  if (myRes[0] == TILESIZE &&
1692  myRes[1] == TILESIZE)
1693  {
1694  // Flag that we can do fast lookups on this tile.
1695  myCompressionType = COMPRESS_RAWFULL;
1696  }
1697 
1698  myData = raw;
1699 }
1700 
1701 template <typename T>
1702 void
1703 UT_VoxelTile<T>::uncompressFull()
1704 {
1705  T *raw;
1706  int x, y, z, i;
1707 
1708  if (myCompressionType == COMPRESS_RAWFULL)
1709  return;
1710 
1711  uncompress();
1712 
1713  UT_ASSERT(myCompressionType == COMPRESS_RAW);
1714 
1715  // The RAWFULL format only differs from RAW when the tile dimensions
1716  // are smaller than the maximum tile size.
1717  if (myRes[0] < TILESIZE || myRes[1] < TILESIZE)
1718  {
1719  raw = (T *)UT_VOXEL_ALLOC(sizeof(T) * TILESIZE * TILESIZE * myRes[2]);
1720  i = 0;
1721  for (z = 0; z < myRes[2]; z++)
1722  {
1723  for (y = 0; y < myRes[1]; y++)
1724  {
1725  for (x = 0; x < myRes[0]; x++)
1726  {
1727  raw[x+(y+z*TILESIZE)*TILESIZE] = ((T *)myData)[i++];
1728  }
1729  }
1730  }
1731  freeData();
1732  myData = raw;
1733  }
1734  myCompressionType = COMPRESS_RAWFULL;
1735 }
1736 
1737 template <typename T>
1738 void
1739 UT_VoxelTile<T>::makeRawUninitialized()
1740 {
1741  if (isRaw() || isRawFull())
1742  return;
1743 
1744  freeData();
1745 
1746  if (myRes[0] == TILESIZE && myRes[1] == TILESIZE)
1747  myCompressionType = COMPRESS_RAWFULL;
1748  else
1749  myCompressionType = COMPRESS_RAW;
1750 
1751  myData = UT_VOXEL_ALLOC(sizeof(T) * numVoxels());
1752 }
1753 
1754 template <typename T>
1755 void
1756 UT_VoxelTile<T>::findAverage(T &avg) const
1757 {
1758  float irx, iry, irz;
1759 
1760  irx = 1.0 / myRes[0];
1761  iry = 1.0 / myRes[1];
1762  irz = 1.0 / myRes[2];
1763  switch (myCompressionType)
1764  {
1765  case COMPRESS_RAW:
1766  {
1767  int i;
1768  const T *data = (const T*) myData;
1769 
1770  i = 0;
1771  T zavg;
1772  zavg = 0;
1773  for (int z = 0; z < myRes[2]; z++)
1774  {
1775  T yavg;
1776  yavg = 0;
1777  for (int y = 0; y < myRes[1]; y++)
1778  {
1779  T xavg;
1780  xavg = 0;
1781  for (int x = 0; x < myRes[0]; x++)
1782  {
1783  xavg += data[i++];
1784  }
1785  xavg *= irx;
1786  yavg += xavg;
1787  }
1788  yavg *= iry;
1789  zavg += yavg;
1790  }
1791  zavg *= irz;
1792 
1793  avg = zavg;
1794  return;
1795  }
1796 
1797  case COMPRESS_FPREAL16:
1798  {
1799  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
1800  static constexpr UT_FromUnbounded<T> convertFromFP16{};
1801 
1802  int i;
1803  const fpreal16 *data = (fpreal16 *) myData;
1804 
1805  i = 0;
1806  // The code below uses 4-wide vectors for averaging (though only the
1807  // needed components are actually used). This needs to be increased
1808  // in size if we need to start working with voxel arrays of vectors
1809  // with more components.
1810  static_assert(tuple_size <= 4);
1811  fpreal16 zavg[] = { 0, 0, 0, 0 };
1812  for (int z = 0; z < myRes[2]; z++)
1813  {
1814  fpreal16 yavg[] = { 0, 0, 0, 0 };
1815  for (int y = 0; y < myRes[1]; y++)
1816  {
1817  fpreal16 xavg[] = { 0, 0, 0, 0 };
1818  for (int x = 0; x < myRes[0]; x++)
1819  {
1820  for (int j = 0; j < tuple_size; j++)
1821  {
1822  xavg[j] += data[i++];
1823  }
1824  }
1825  for (int j = 0; j < tuple_size; j++)
1826  {
1827  xavg[j] *= irx;
1828  yavg[j] += xavg[j];
1829  }
1830  }
1831  for (int j = 0; j < tuple_size; j++)
1832  {
1833  yavg[j] *= iry;
1834  zavg[j] += yavg[j];
1835  }
1836  }
1837  for (int j = 0; j < tuple_size; j++)
1838  {
1839  zavg[j] *= irz;
1840  }
1841 
1842  avg = convertFromFP16(zavg);
1843  return;
1844  }
1845 
1846  case COMPRESS_CONSTANT:
1847  avg = rawConstVal();
1848  return;
1849 
1850  case COMPRESS_RAWFULL:
1851  {
1852  int offset;
1853  const T *data = (const T*) myData;
1854 
1855  offset = 0;
1856  T zavg;
1857  zavg = 0;
1858  for (int z = 0; z < myRes[2]; z++)
1859  {
1860  T yavg;
1861  yavg = 0;
1862  for (int y = 0; y < myRes[1]; y++)
1863  {
1864  T xavg;
1865  xavg = 0;
1866  for (int x = 0; x < myRes[0]; x++)
1867  {
1868  xavg += data[x+offset];
1869  }
1870  xavg *= irx;
1871  yavg += xavg;
1872  offset += TILESIZE;
1873  }
1874  yavg *= iry;
1875  zavg += yavg;
1876  }
1877  zavg *= irz;
1878 
1879  avg = zavg;
1880  return;
1881  }
1882 
1883  default:
1884  {
1885  T zavg;
1886  zavg = 0;
1887  for (int z = 0; z < myRes[2]; z++)
1888  {
1889  T yavg;
1890  yavg = 0;
1891  for (int y = 0; y < myRes[1]; y++)
1892  {
1893  T xavg;
1894  xavg = 0;
1895  for (int x = 0; x < myRes[0]; x++)
1896  {
1897  xavg += (*this)(x, y, z);
1898  }
1899  xavg *= irx;
1900  yavg += xavg;
1901  }
1902  yavg *= iry;
1903  zavg += yavg;
1904  }
1905  zavg *= irz;
1906 
1907  avg = zavg;
1908  return;
1909  }
1910  }
1911 }
1912 
1913 template <typename T>
1914 void
1915 UT_VoxelTile<T>::findMinMax(T &min, T &max) const
1916 {
1917  switch (myCompressionType)
1918  {
1919  case COMPRESS_RAW:
1920  {
1921  int n = myRes[0] * myRes[1] * myRes[2];
1922  int i;
1923 
1924  min = max = *(T*)myData;
1925  for (i = 1; i < n; i++)
1926  {
1927  expandMinMax( ((T*)myData)[i], min, max );
1928  }
1929  return;
1930  }
1931 
1932  case COMPRESS_FPREAL16:
1933  {
1934  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
1935  static constexpr UT_FromUnbounded<T> convertFromFP16{};
1936 
1937  int n = myRes[0] * myRes[1] * myRes[2];
1938  int i;
1939  fpreal16 *src = (fpreal16 *)myData;
1940 
1941  min = max = *src;
1942  for (i = 1; i < n; i++, src += tuple_size)
1943  {
1944  T val = convertFromFP16(src);
1945  expandMinMax( val, min, max );
1946  }
1947  return;
1948  }
1949 
1950  case COMPRESS_CONSTANT:
1951  min = max = rawConstVal();
1952  return;
1953 
1954  case COMPRESS_RAWFULL:
1955  {
1956  int x, y, z, offset;
1957 
1958  min = max = *(T*)myData;
1959  offset = 0;
1960  for (z = 0; z < myRes[2]; z++)
1961  {
1962  for (y = 0; y < myRes[1]; y++)
1963  {
1964  for (x = 0; x < myRes[0]; x++)
1965  {
1966  expandMinMax(
1967  ((T*)myData)[x+offset],
1968  min, max );
1969  }
1970  offset += TILESIZE;
1971  }
1972  }
1973  return;
1974  }
1975 
1976  default:
1977  {
1978  // Use the compression engine.
1979  UT_VoxelTileCompress<T> *engine;
1980 
1981  engine = getCompressionEngine(myCompressionType);
1982 
1983  engine->findMinMax(*this, min, max);
1984  return;
1985  }
1986  }
1987 }
1988 
1989 template <typename T>
1990 bool
1991 UT_VoxelTile<T>::hasNan() const
1992 {
1993  switch (myCompressionType)
1994  {
1995  case COMPRESS_RAW:
1996  case COMPRESS_RAWFULL:
1997  {
1998  int n = myRes[0] * myRes[1] * myRes[2];
1999  int i;
2000 
2001  for (i = 0; i < n; i++)
2002  {
2003  if (SYSisNan( ((T*)myData)[i] ))
2004  return true;
2005  }
2006  return false;
2007  }
2008 
2009  case COMPRESS_FPREAL16:
2010  {
2011  return false;
2012  }
2013 
2014  case COMPRESS_CONSTANT:
2015  if (SYSisNan(rawConstVal()))
2016  return true;
2017  return false;
2018 
2019  default:
2020  {
2021  // Use the compression engine.
2022  UT_VoxelTileCompress<T> *engine;
2023  int x, y, z;
2024 
2025  engine = getCompressionEngine(myCompressionType);
2026 
2027  for (z = 0; z < myRes[2]; z++)
2028  for (y = 0; y < myRes[1]; y++)
2029  for (x = 0; x < myRes[0]; x++)
2030  if (SYSisNan(engine->getValue(*this, x, y, z)))
2031  {
2032  return true;
2033  }
2034 
2035  return false;
2036  }
2037  }
2038 }
2039 
2040 template <typename T>
2041 bool
2042 UT_VoxelTile<T>::tryCompress(const UT_VoxelCompressOptions &options)
2043 {
2044  T min, max;
2045  bool losslessonly = (options.myQuantizeTol == 0.0);
2046  int i;
2047  UT_VoxelTileCompress<T> *engine;
2048 
2049  // This is as easy as it gets.
2050  if (myCompressionType == COMPRESS_CONSTANT)
2051  return false;
2052 
2053  findMinMax(min, max);
2054 
2055  // See if we can be made into a constant tile.
2056  if (dist(min, max) <= options.myConstantTol)
2057  {
2058  // Ignore if we are already constant.
2059  if (myCompressionType == COMPRESS_CONSTANT)
2060  return false;
2061 
2062  // We are fully constant!
2063  if (min != max)
2064  {
2065  T avg;
2066  findAverage(avg);
2067  makeConstant(avg);
2068  }
2069  else
2070  {
2071  makeConstant(min);
2072  }
2073  return true;
2074  }
2075 
2076  bool result = false;
2077 
2078  if (options.myAllowFP16)
2079  {
2080  if (myCompressionType == COMPRESS_RAW ||
2081  myCompressionType == COMPRESS_RAWFULL)
2082  {
2083  makeFpreal16();
2084  result = true;
2085  }
2086  }
2087 
2088  for (i = 0; i < getCompressionEngines().entries(); i++)
2089  {
2090  engine = getCompressionEngines()(i);
2091 
2092  // Ignore possibly expensive lossy compressions.
2093  if (losslessonly && !engine->isLossless())
2094  continue;
2095 
2096  if (engine->tryCompress(*this, options, min, max))
2097  {
2098  myCompressionType = i + COMPRESS_ENGINE;
2099  result = true;
2100  // We keep testing in case another compression engine
2101  // can get a better number...
2102  }
2103  }
2104 
2105  // If we are RAW compress, check to see if we could become
2106  // RAWFULL for faster access.
2107  if (myCompressionType == COMPRESS_RAW)
2108  {
2109  if (myRes[0] == TILESIZE && myRes[1] == TILESIZE)
2110  {
2111  myCompressionType = COMPRESS_RAWFULL;
2112  }
2113  }
2114 
2115  // No suitable compression found.
2116  return result;
2117 }
2118 
2119 template <typename T>
2120 void
2121 UT_VoxelTile<T>::makeConstant(T t)
2122 {
2123  if (!isConstant())
2124  {
2125  freeData();
2126 
2127  if (!inlineConstant())
2128  myData = UT_VOXEL_ALLOC(sizeof(T));
2129  }
2130 
2131  myCompressionType = COMPRESS_CONSTANT;
2132  *rawConstData() = t;
2133 }
2134 
2135 template <typename T>
2136 void
2137 UT_VoxelTile<T>::makeFpreal16()
2138 {
2139  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
2140  using ScalarType = typename UT_FixedVectorTraits<T>::DataType;
2141 
2142  if (isConstant())
2143  {
2144  return;
2145  }
2146 
2147  if (myCompressionType == COMPRESS_FPREAL16)
2148  return;
2149 
2150  // Get our new data.
2151  int len = myRes[2] * myRes[1] * myRes[0] * tuple_size;
2152  fpreal16 *data = (fpreal16 *)UT_VOXEL_ALLOC(sizeof(fpreal16) * len);
2153 
2154  if (myCompressionType == COMPRESS_RAW ||
2155  myCompressionType == COMPRESS_RAWFULL)
2156  {
2157  for (int i = 0; i < len; i++)
2158  {
2159  data[i] = UTvoxelConvertFP16(((ScalarType*) myData)[i]);
2160  }
2161  }
2162  else
2163  {
2164  // Apply any converters.
2165  int i = 0;
2166 
2167  for (int z = 0; z < myRes[2]; z++)
2168  {
2169  for (int y = 0; y < myRes[1]; y++)
2170  {
2171  for (int x = 0; x < myRes[0]; x++)
2172  {
2173  if constexpr (tuple_size == 1)
2174  data[i++] = UTvoxelConvertFP16((*this)(x, y, z));
2175  else
2176  {
2177  T value = (*this)(x, y, z);
2178  for (int j = 0; j < tuple_size; j++)
2179  {
2180  data[i++] = UTvoxelConvertFP16(value(j));
2181  }
2182  }
2183  }
2184  }
2185  }
2186  }
2187 
2188  freeData();
2189  myData = data;
2190  myCompressionType = COMPRESS_FPREAL16;
2191 }
2192 
2193 template <typename T>
2194 int64
2195 UT_VoxelTile<T>::getMemoryUsage(bool inclusive) const
2196 {
2197  int64 mem = inclusive ? sizeof(*this) : 0;
2198  mem += getDataLength();
2199  return mem;
2200 }
2201 
2202 template <typename T>
2203 int64
2204 UT_VoxelTile<T>::getDataLength() const
2205 {
2206  exint usage;
2207 
2208  switch (myCompressionType)
2209  {
2210  case COMPRESS_RAW:
2211  usage = sizeof(T) * xres() * yres() * zres();
2212  break;
2213  case COMPRESS_FPREAL16:
2214  usage = sizeof(fpreal16) * xres() * yres() * zres()
2215  * UT_FixedVectorTraits<T>::TupleSize;
2216  break;
2217  case COMPRESS_CONSTANT:
2218  if (inlineConstant())
2219  usage = 0;
2220  else
2221  usage = sizeof(T);
2222  break;
2223  case COMPRESS_RAWFULL:
2224  usage = sizeof(T) * TILESIZE * TILESIZE * zres();
2225  break;
2226  default:
2227  {
2228  // Use the compression engine.
2229  UT_VoxelTileCompress<T> *engine;
2230  engine = getCompressionEngine(myCompressionType);
2231  usage = engine->getDataLength(*this);
2232  break;
2233  }
2234  }
2235  return usage;
2236 }
2237 
2238 template <typename T>
2239 void
2240 UT_VoxelTile<T>::weightedSum(int pstart[3], int pend[3],
2241  const float *weights[3], int start[3],
2242  T &result)
2243 {
2244  int ix, iy, iz, i;
2245  int px, py, pz;
2246  int ixstart, ixend;
2247  int tstart[3];
2248  fpreal w, pw;
2249  T psumx, psumy;
2250 
2251  switch (myCompressionType)
2252  {
2253  case COMPRESS_CONSTANT:
2254  {
2255  w = 1;
2256  for (i = 0; i < 3; i++)
2257  {
2258  pw = 0;
2259  for (ix = 0; ix < pend[i]-pstart[i]; ix++)
2260  pw += weights[i][ix+pstart[i]-start[i]];
2261  w *= pw;
2262  }
2263  result += w * rawConstVal();
2264  break;
2265  }
2266 
2267  case COMPRESS_RAW:
2268  {
2269  tstart[0] = pstart[0] & TILEMASK;
2270  tstart[1] = pstart[1] & TILEMASK;
2271  tstart[2] = pstart[2] & TILEMASK;
2272  ixstart = pstart[0]-start[0];
2273  ixend = pend[0]-start[0];
2274  pz = tstart[2];
2275  UT_ASSERT(pz < myRes[2]);
2276  UT_ASSERT(ixend - ixstart <= myRes[0]);
2277  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2278  {
2279  psumy = 0;
2280  py = tstart[1];
2281  UT_ASSERT(py < myRes[1]);
2282  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2283  {
2284  psumx = 0;
2285  px = ((pz * myRes[1]) + py) * myRes[0] + tstart[0];
2286  for (ix = ixstart; ix < ixend; ix++, px++)
2287  {
2288  psumx += weights[0][ix]* ((T*)myData)[px];
2289  }
2290  psumy += weights[1][iy-start[1]] * psumx;
2291  }
2292  result += weights[2][iz-start[2]] * psumy;
2293  }
2294  break;
2295  }
2296 
2297  case COMPRESS_FPREAL16:
2298  {
2299  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
2300  static constexpr UT_FromUnbounded<T> convertFromFP16{};
2301 
2302  int xinc = tuple_size;
2303  int yinc = myRes[0] * xinc;
2304  int zinc = myRes[1] * yinc;
2305 
2306  fpreal16 *src = (fpreal16 *) myData;
2307 
2308  tstart[0] = pstart[0] & TILEMASK;
2309  tstart[1] = pstart[1] & TILEMASK;
2310  tstart[2] = pstart[2] & TILEMASK;
2311  ixstart = pstart[0]-start[0];
2312  ixend = pend[0]-start[0];
2313  pz = tstart[2];
2314  UT_ASSERT(pz < myRes[2]);
2315  UT_ASSERT(ixend - ixstart <= myRes[0]);
2316  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2317  {
2318  psumy = 0;
2319  py = tstart[1];
2320  UT_ASSERT(py < myRes[1]);
2321  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2322  {
2323  psumx = 0;
2324  px = pz * zinc + py * yinc + tstart[0] * xinc;
2325  for (ix = ixstart; ix < ixend; ix++, px += xinc)
2326  {
2327  T val = convertFromFP16(src + px);
2328  psumx += weights[0][ix]* val;
2329  }
2330  psumy += weights[1][iy-start[1]] * psumx;
2331  }
2332  result += weights[2][iz-start[2]] * psumy;
2333  }
2334  break;
2335  }
2336  case COMPRESS_RAWFULL:
2337  {
2338  tstart[0] = pstart[0] & TILEMASK;
2339  tstart[1] = pstart[1] & TILEMASK;
2340  tstart[2] = pstart[2] & TILEMASK;
2341  ixstart = pstart[0]-start[0];
2342  ixend = pend[0]-start[0];
2343  pz = tstart[2];
2344  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2345  {
2346  psumy = 0;
2347  py = tstart[1];
2348  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2349  {
2350  psumx = 0;
2351  px = ((pz * TILESIZE) + py) * TILESIZE + tstart[0];
2352  for (ix = ixstart; ix < ixend; ix++, px++)
2353  {
2354  psumx += weights[0][ix]* ((T*)myData)[px];
2355  }
2356  psumy += weights[1][iy-start[1]] * psumx;
2357  }
2358  result += weights[2][iz-start[2]] * psumy;
2359  }
2360  break;
2361  }
2362 
2363  default:
2364  {
2365  // For all other compression types, we use our
2366  // getValue() accessor rather than trying to
2367  // do anything fancy.
2368  tstart[0] = pstart[0] & TILEMASK;
2369  tstart[1] = pstart[1] & TILEMASK;
2370  tstart[2] = pstart[2] & TILEMASK;
2371  ixstart = pstart[0]-start[0];
2372  ixend = pend[0]-start[0];
2373  pz = tstart[2];
2374  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2375  {
2376  psumy = 0;
2377  py = tstart[1];
2378  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2379  {
2380  psumx = 0;
2381  px = tstart[0];
2382  for (ix = ixstart; ix < ixend; ix++, px++)
2383  {
2384  psumx += weights[0][ix] *
2385  (*this)(px, py, pz);
2386  }
2387  psumy += weights[1][iy-start[1]] * psumx;
2388  }
2389  result += weights[2][iz-start[2]] * psumy;
2390  }
2391  break;
2392  }
2393  }
2394 }
2395 
2396 template <typename T>
2397 void
2398 UT_VoxelTile<T>::avgNonZero(int pstart[3], int pend[3], int start[3],
2399  T &result)
2400 {
2401  int ix, iy, iz;
2402  int px, py, pz;
2403  int ixstart, ixend;
2404  int tstart[3];
2405 
2406  #define COUNT_NONZERO(VAL, COUNT) \
2407  if constexpr (SYS_IsSame_v<T, float>) \
2408  { \
2409  if (VAL != T(0)) \
2410  COUNT++; \
2411  } \
2412  if constexpr (SYS_IsSame_v<T, UT_Vector2>) \
2413  { \
2414  if (!VAL.isZero()) \
2415  COUNT++; \
2416  } \
2417  if constexpr (SYS_IsSame_v<T, UT_Vector3>) \
2418  { \
2419  if (!VAL.isZero()) \
2420  COUNT++; \
2421  } \
2422  if constexpr (SYS_IsSame_v<T, UT_Vector4>) \
2423  { \
2424  if (!VAL.isZero()) \
2425  COUNT++; \
2426  } \
2427 
2428  switch (myCompressionType)
2429  {
2430  case COMPRESS_CONSTANT:
2431  {
2432  result += rawConstVal();
2433  break;
2434  }
2435 
2436  case COMPRESS_RAW:
2437  {
2438  tstart[0] = pstart[0] & TILEMASK;
2439  tstart[1] = pstart[1] & TILEMASK;
2440  tstart[2] = pstart[2] & TILEMASK;
2441  ixstart = pstart[0]-start[0];
2442  ixend = pend[0]-start[0];
2443  pz = tstart[2];
2444  UT_ASSERT(pz < myRes[2]);
2445  UT_ASSERT(ixend - ixstart <= myRes[0]);
2446  int count = 0;
2447  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2448  {
2449  py = tstart[1];
2450  UT_ASSERT(py < myRes[1]);
2451  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2452  {
2453  px = ((pz * myRes[1]) + py) * myRes[0] + tstart[0];
2454  for (ix = ixstart; ix < ixend; ix++, px++)
2455  {
2456  T val = ((T*)myData)[px];
2457  result += val;
2458  COUNT_NONZERO(val, count);
2459  }
2460  }
2461  }
2462  result *= SYSsaferecip(float(count));
2463  break;
2464  }
2465 
2466  case COMPRESS_FPREAL16:
2467  {
2468  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
2469  static constexpr UT_FromUnbounded<T> convertFromFP16{};
2470 
2471  int xinc = tuple_size;
2472  int yinc = myRes[0] * xinc;
2473  int zinc = myRes[1] * yinc;
2474 
2475  fpreal16 *src = (fpreal16 *) myData;
2476 
2477  tstart[0] = pstart[0] & TILEMASK;
2478  tstart[1] = pstart[1] & TILEMASK;
2479  tstart[2] = pstart[2] & TILEMASK;
2480  ixstart = pstart[0]-start[0];
2481  ixend = pend[0]-start[0];
2482  pz = tstart[2];
2483  UT_ASSERT(pz < myRes[2]);
2484  UT_ASSERT(ixend - ixstart <= myRes[0]);
2485  int count = 0;
2486  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2487  {
2488  py = tstart[1];
2489  UT_ASSERT(py < myRes[1]);
2490  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2491  {
2492  px = pz * zinc + py * yinc + tstart[0] * xinc;
2493  for (ix = ixstart; ix < ixend; ix++, px += xinc)
2494  {
2495  T val = convertFromFP16(src + px);
2496  result += val;
2497  COUNT_NONZERO(val, count);
2498  }
2499  }
2500  }
2501  result *= SYSsaferecip(float(count));
2502  break;
2503  }
2504  case COMPRESS_RAWFULL:
2505  {
2506  tstart[0] = pstart[0] & TILEMASK;
2507  tstart[1] = pstart[1] & TILEMASK;
2508  tstart[2] = pstart[2] & TILEMASK;
2509  ixstart = pstart[0]-start[0];
2510  ixend = pend[0]-start[0];
2511  pz = tstart[2];
2512  int count = 0;
2513  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2514  {
2515  py = tstart[1];
2516  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2517  {
2518  px = ((pz * TILESIZE) + py) * TILESIZE + tstart[0];
2519  for (ix = ixstart; ix < ixend; ix++, px++)
2520  {
2521  T val = ((T*)myData)[px];
2522  result += val;
2523  COUNT_NONZERO(val, count);
2524  }
2525  }
2526  }
2527  result *= SYSsaferecip(float(count));
2528  break;
2529  }
2530 
2531  default:
2532  {
2533  // For all other compression types, we use our
2534  // getValue() accessor rather than trying to
2535  // do anything fancy.
2536  tstart[0] = pstart[0] & TILEMASK;
2537  tstart[1] = pstart[1] & TILEMASK;
2538  tstart[2] = pstart[2] & TILEMASK;
2539  ixstart = pstart[0]-start[0];
2540  ixend = pend[0]-start[0];
2541  pz = tstart[2];
2542  int count = 0;
2543  for (iz = pstart[2]; iz < pend[2]; iz++, pz++)
2544  {
2545  py = tstart[1];
2546  for (iy = pstart[1]; iy < pend[1]; iy++, py++)
2547  {
2548  px = tstart[0];
2549  for (ix = ixstart; ix < ixend; ix++, px++)
2550  {
2551  T val = (*this)(px, py, pz);
2552  result += val;
2553  COUNT_NONZERO(val, count);
2554  }
2555  }
2556  }
2557  result *= SYSsaferecip(float(count));
2558  break;
2559  }
2560  }
2561 }
2562 
2563 template <typename T>
2564 void
2565 UT_VoxelTile<T>::registerCompressionEngine(UT_VoxelTileCompress<T> *engine)
2566 {
2567  int i;
2568 
2569  // Repalce old copy, if any.
2570  for (i = 0; i < getCompressionEngines().entries(); i++)
2571  {
2572  if (!strcmp(engine->getName(), getCompressionEngines()(i)->getName()))
2573  {
2574  getCompressionEngines()(i) = engine;
2575  return;
2576  }
2577  }
2578 
2579  getCompressionEngines().append(engine);
2580 }
2581 
2582 template <typename T>
2583 int
2584 UT_VoxelTile<T>::lookupCompressionEngine(const char *name)
2585 {
2586  int i;
2587 
2588  if (!name)
2589  return -1;
2590 
2591  for (i = 0; i < getCompressionEngines().entries(); i++)
2592  {
2593  if (!strcmp(name, getCompressionEngines()(i)->getName()))
2594  {
2595  return i + COMPRESS_ENGINE;
2596  }
2597  }
2598 
2599  return -1;
2600 }
2601 
2602 template <typename T>
2603 UT_VoxelTileCompress<T> *
2604 UT_VoxelTile<T>::getCompressionEngine(int index)
2605 {
2606  index -= COMPRESS_ENGINE;
2607 
2608  return getCompressionEngines()(index);
2609 }
2610 
2611 template <typename T>
2612 void
2613 UT_VoxelTile<T>::save(std::ostream &os) const
2614 {
2615  // Always save in our native format...
2616  if (myCompressionType >= COMPRESS_ENGINE)
2617  {
2618  UT_VoxelTileCompress<T> *engine = getCompressionEngine(myCompressionType);
2619 
2620  if (engine->canSave())
2621  {
2622  char type = myCompressionType;
2623 
2624  UTwrite(os, &type, 1);
2625  engine->save(os, *this);
2626  return;
2627  }
2628 
2629  // Can't save, must save as raw.
2630  char type = COMPRESS_RAW;
2631  T value;
2632 
2633  UTwrite(os, &type, 1);
2634 
2635  for (int z = 0; z < zres(); z++)
2636  for (int y = 0; y < yres(); y++)
2637  for (int x = 0; x < xres(); x++)
2638  {
2639  value = (*this)(x, y, z);
2640  UTwrite<T>(os, &value, 1);
2641  }
2642  return;
2643  }
2644 
2645  int len;
2646  char type = myCompressionType;
2647 
2648  if (type == COMPRESS_RAWFULL &&
2649  myRes[0] == TILESIZE &&
2650  myRes[1] == TILESIZE &&
2651  myRes[2] != TILESIZE)
2652  {
2653  // Forbid saving this as a raw full as that will confuse
2654  // older versions of Houdini.
2655  type = COMPRESS_RAW;
2656  }
2657 
2658  UT_ASSERT(type >= 0 && type < COMPRESS_ENGINE);
2659 
2660  UTwrite(os, &type, 1);
2661 
2662  switch ((CompressionType) type)
2663  {
2664  case COMPRESS_RAW:
2665  len = myRes[2] * myRes[1] * myRes[0];
2666  UTwrite<T>(os, (T *) myData, len);
2667  break;
2668 
2669  case COMPRESS_FPREAL16:
2670  len = myRes[2] * myRes[1] * myRes[0]
2671  * UT_FixedVectorTraits<T>::TupleSize;
2672  UTwrite(os, (int16 *) myData, len);
2673  break;
2674 
2675  case COMPRESS_RAWFULL:
2676  len = TILESIZE * TILESIZE * TILESIZE;
2677  UTwrite<T>(os, (T *) myData, len);
2678  break;
2679 
2680  case COMPRESS_CONSTANT:
2681  UTwrite<T>(os, rawConstData(), 1);
2682  break;
2683 
2684  case COMPRESS_ENGINE:
2685  UT_ASSERT(!"Invalid compression type");
2686  break;
2687  }
2688 }
2689 
2690 template <typename T>
2691 void
2692 UT_VoxelTile<T>::load(UT_IStream &is, const UT_IntArray &compress)
2693 {
2694  char type, otype;
2695  int len;
2696 
2697  is.readChar(type);
2698 
2699  // Perform the indirection to find out our native type.
2700  if (type >= 0 && type < compress.entries())
2701  {
2702  otype = type;
2703  type = compress(type);
2704  if (type == -1)
2705  {
2706  std::cerr << "Missing compression engine " << (int) otype << "\n";
2707  }
2708  }
2709 
2710  if (type >= COMPRESS_ENGINE)
2711  {
2712  freeData();
2713  myCompressionType = type;
2714 
2715  if (type - COMPRESS_ENGINE >= getCompressionEngines().entries())
2716  {
2717  // Invalid type!
2718  std::cerr << "Invalid compression engine " << (int) otype << "\n";
2719  return;
2720  }
2721 
2722  UT_VoxelTileCompress<T> *engine = getCompressionEngine(myCompressionType);
2723 
2724  engine->load(is, *this);
2725 
2726  return;
2727  }
2728 
2729  UT_ASSERT(type >= 0);
2730  if (type < 0)
2731  {
2732  return;
2733  }
2734 
2735  freeData();
2736 
2737  myCompressionType = type;
2738 
2739  switch ((CompressionType) myCompressionType)
2740  {
2741  case COMPRESS_RAW:
2742  len = myRes[2] * myRes[1] * myRes[0];
2743  myData = UT_VOXEL_ALLOC(sizeof(T) * len);
2744  is.read<T>((T *) myData, len);
2745  break;
2746 
2747  case COMPRESS_FPREAL16:
2748  len = myRes[2] * myRes[1] * myRes[0]
2749  * UT_FixedVectorTraits<T>::TupleSize;
2750  myData = UT_VOXEL_ALLOC(sizeof(fpreal16) * len);
2751  is.read((int16 *) myData, len);
2752  break;
2753 
2754  case COMPRESS_RAWFULL:
2755  len = TILESIZE * TILESIZE * TILESIZE;
2756  myData = UT_VOXEL_ALLOC(sizeof(T) * len);
2757  is.read<T>((T *) myData, len);
2758  break;
2759 
2760  case COMPRESS_CONSTANT:
2761  if (!inlineConstant())
2762  myData = UT_VOXEL_ALLOC(sizeof(T));
2763  is.read<T>(rawConstData(), 1);
2764  break;
2765 
2766  case COMPRESS_ENGINE:
2767  UT_ASSERT(!"Invalid compression type");
2768  break;
2769  }
2770 
2771  // Recompress raw full that are not complete in z
2772  if (myCompressionType == COMPRESS_RAW &&
2773  myRes[0] == TILESIZE &&
2774  myRes[1] == TILESIZE)
2775  myCompressionType = COMPRESS_RAWFULL;
2776 }
2777 
2778 template <typename T>
2779 bool
2780 UT_VoxelTile<T>::save(UT_JSONWriter &w) const
2781 {
2782  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
2783  using ScalarType = typename UT_FixedVectorTraits<T>::DataType;
2784 
2785  bool ok = true;
2786 
2787  // Always save in our native format...
2788  if (myCompressionType >= COMPRESS_ENGINE)
2789  {
2790  UT_VoxelTileCompress<T> *engine = getCompressionEngine(myCompressionType);
2791 
2792  if (engine->canSave())
2793  {
2794  char type = myCompressionType;
2795 
2796  ok = ok && w.jsonBeginArray();
2797  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
2798  UT_VoxelArrayJSON::TILE_COMPRESSION));
2799  ok = ok && w.jsonInt(type);
2800  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
2801  UT_VoxelArrayJSON::TILE_DATA));
2802  ok = ok && engine->save(w, *this);
2803  ok = ok && w.jsonEndArray();
2804  return ok;
2805  }
2806 
2807  // Can't save, must save as raw.
2808  char type = COMPRESS_RAW;
2809  T value;
2810  ScalarType dummy;
2811 
2812  ok = ok && w.jsonBeginArray();
2813  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
2814  UT_VoxelArrayJSON::TILE_COMPRESSION));
2815  ok = ok && w.jsonInt(type);
2816  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
2817  UT_VoxelArrayJSON::TILE_DATA));
2818 
2819  ok = ok && w.beginUniformArray(xres()*yres()*zres()*tuple_size,
2820  w.jidFromValue(&dummy));
2821  for (int z = 0; z < zres(); z++)
2822  for (int y = 0; y < yres(); y++)
2823  for (int x = 0; x < xres(); x++)
2824  {
2825  value = (*this)(x, y, z);
2826  if constexpr (tuple_size == 1)
2827  {
2828  ok = ok && w.uniformWrite(value);
2829  }
2830  else
2831  {
2832  for (int i = 0; i < tuple_size; i++)
2833  {
2834  ok = ok && w.uniformWrite(value(i));
2835  }
2836  }
2837  }
2838  ok = ok && w.endUniformArray();
2839  ok = ok && w.jsonEndArray();
2840  return ok;
2841  }
2842 
2843  int len;
2844  char type = myCompressionType;
2845 
2846  UT_ASSERT(type >= 0 && type < COMPRESS_ENGINE);
2847  ok = ok && w.jsonBeginArray();
2848  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
2849  UT_VoxelArrayJSON::TILE_COMPRESSION));
2850  ok = ok && w.jsonInt(type);
2851  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
2852  UT_VoxelArrayJSON::TILE_DATA));
2853 
2854  switch (myCompressionType)
2855  {
2856  case COMPRESS_RAW:
2857  len = myRes[2] * myRes[1] * myRes[0];
2858  ok = ok && w.jsonUniformArray(len * tuple_size, (ScalarType *)myData);
2859  break;
2860 
2861  case COMPRESS_FPREAL16:
2862  len = myRes[2] * myRes[1] * myRes[0] * UT_FixedVectorTraits<T>::TupleSize;
2863  ok = ok && w.jsonUniformArray(len, (fpreal16 *)myData);
2864  break;
2865 
2866  case COMPRESS_RAWFULL:
2867  len = TILESIZE * TILESIZE * myRes[2];
2868  ok = ok && w.jsonUniformArray(len * tuple_size, (ScalarType *)myData);
2869  break;
2870 
2871  case COMPRESS_CONSTANT:
2872  if constexpr (tuple_size == 1)
2873  ok = ok && w.jsonValue(rawConstVal());
2874  else
2875  ok = ok && w.jsonUniformArray(tuple_size, rawConstVal().data());
2876  break;
2877  }
2878 
2879  ok = ok && w.jsonEndArray();
2880  return ok;
2881 }
2882 
2883 template <typename T>
2884 bool
2885 UT_VoxelTile<T>::load(UT_JSONParser &p, const UT_IntArray &compress)
2886 {
2887  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
2888  using ScalarType = typename UT_FixedVectorTraits<T>::DataType;
2889 
2890  UT_JSONParser::traverser it;
2891  UT_WorkBuffer key;
2892  int8 type, otype;
2893  int len;
2894 
2895  it = p.beginArray();
2896  if (it.atEnd() || !it.getLowerKey(key))
2897  return false;
2898  if (UT_VoxelArrayJSON::getTileID(key.buffer()) !=
2899  UT_VoxelArrayJSON::TILE_COMPRESSION)
2900  return false;
2901  if (!p.parseNumber(type))
2902  return false;
2903 
2904  ++it;
2905 
2906  if (it.atEnd() || !it.getLowerKey(key))
2907  return false;
2908  if (UT_VoxelArrayJSON::getTileID(key.buffer()) !=
2909  UT_VoxelArrayJSON::TILE_DATA)
2910  return false;
2911 
2912  // Perform the indirection to find out our native type.
2913  if (type >= 0 && type < compress.entries())
2914  {
2915  otype = type;
2916  type = compress(type);
2917  if (type == -1)
2918  {
2919  std::cerr << "Missing compression engine " << (int) otype << "\n";
2920  }
2921  }
2922 
2923  if (type >= COMPRESS_ENGINE)
2924  {
2925  freeData();
2926  myCompressionType = type;
2927 
2928  if (type - COMPRESS_ENGINE >= getCompressionEngines().entries())
2929  {
2930  // Invalid type!
2931  std::cerr << "Invalid compression engine " << (int) otype << "\n";
2932  return false;
2933  }
2934 
2935  UT_VoxelTileCompress<T> *engine = getCompressionEngine(myCompressionType);
2936 
2937  bool engine_ok = engine->load(p, *this);
2938  ++it;
2939  return it.atEnd() && engine_ok;
2940  }
2941 
2942  UT_ASSERT(type >= 0);
2943  if (type < 0)
2944  {
2945  return false;
2946  }
2947 
2948  freeData();
2949 
2950  myCompressionType = type;
2951 
2952  switch (myCompressionType)
2953  {
2954  case COMPRESS_RAW:
2955  len = myRes[2] * myRes[1] * myRes[0];
2956  myData = UT_VOXEL_ALLOC(sizeof(T) * len);
2957  len *= tuple_size;
2958  if (p.parseUniformArray((ScalarType *)myData, len) != len)
2959  return false;
2960  break;
2961 
2962  case COMPRESS_FPREAL16:
2963  len = myRes[2] * myRes[1] * myRes[0] * UT_FixedVectorTraits<T>::TupleSize;
2964  myData = UT_VOXEL_ALLOC(sizeof(fpreal16) * len);
2965  if (p.parseUniformArray((fpreal16 *)myData, len) != len)
2966  return false;
2967  break;
2968 
2969  case COMPRESS_RAWFULL:
2970  len = TILESIZE * TILESIZE * myRes[2];
2971  myData = UT_VOXEL_ALLOC(sizeof(T) * len);
2972  len *= tuple_size;
2973  if (p.parseUniformArray((ScalarType *)myData, len) != len)
2974  return false;
2975  break;
2976 
2977  case COMPRESS_CONSTANT:
2978  if (!inlineConstant())
2979  myData = UT_VOXEL_ALLOC(sizeof(T));
2980  if constexpr (tuple_size == 1)
2981  {
2982  if (!p.parseNumber(*rawConstData()))
2983  return false;
2984  }
2985  else
2986  {
2987  if (!p.parseUniformArray((ScalarType *) rawConstData()->data(), tuple_size))
2988  return false;
2989  }
2990  break;
2991  }
2992 
2993  ++it;
2994  return it.atEnd();
2995 }
2996 
2997 template <typename T>
2998 void
2999 UT_VoxelTile<T>::saveCompressionTypes(std::ostream &os)
3000 {
3001  int16 ntype = getCompressionEngines().entries();
3002  int i;
3003 
3004  ntype += COMPRESS_ENGINE;
3005 
3006  UTwrite(os, &ntype);
3007 
3008  UT_ASSERT(COMPRESS_ENGINE == 4); // Change lower lines!
3009  UTsaveStringBinary(os, "raw", UT_STRING_8BIT_IO);
3010  UTsaveStringBinary(os, "rawfull", UT_STRING_8BIT_IO);
3011  UTsaveStringBinary(os, "constant", UT_STRING_8BIT_IO);
3012  UTsaveStringBinary(os, "fpreal16", UT_STRING_8BIT_IO);
3013 
3014  ntype -= COMPRESS_ENGINE;
3015  for (i = 0; i < ntype; i++)
3016  {
3017  UTsaveStringBinary(os, getCompressionEngines()(i)->getName(), UT_STRING_8BIT_IO);
3018  }
3019 }
3020 
3021 template <typename T>
3022 void
3023 UT_VoxelTile<T>::loadCompressionTypes(UT_IStream &is, UT_IntArray &compress)
3024 {
3025  int16 ntype;
3026  int i, idx;
3027 
3028  compress.entries(0);
3029 
3030  is.read(&ntype);
3031 
3032  for (i = 0; i < ntype; i++)
3033  {
3034  UT_String name;
3035 
3036  is.readBinaryString(name, UT_ISTREAM_8BIT_IO);
3037  if (name == "raw")
3038  compress.append(COMPRESS_RAW);
3039  else if (name == "rawfull")
3040  compress.append(COMPRESS_RAWFULL);
3041  else if (name == "constant")
3042  compress.append(COMPRESS_CONSTANT);
3043  else if (name == "fpreal16")
3044  compress.append(COMPRESS_FPREAL16);
3045  else
3046  {
3047  idx = lookupCompressionEngine(name);
3048 
3049  // -1 means a failure to find it in our set..
3050  // this is only a bad thing if a tile actually uses this engine.
3051 
3052  compress.append(idx);
3053  }
3054  }
3055 }
3056 
3057 template <typename T>
3058 bool
3059 UT_VoxelTile<T>::saveCompressionTypes(UT_JSONWriter &w)
3060 {
3061  int16 ntype = getCompressionEngines().entries();
3062  int i;
3063  bool ok = true;
3064 
3065  ntype += COMPRESS_ENGINE;
3066 
3067  UT_ASSERT(COMPRESS_ENGINE == 4); // Change lower lines!
3068  ok = ok && w.beginUniformArray(ntype, UT_JID_STRING);
3069  ok = ok && w.uniformWrite("raw");
3070  ok = ok && w.uniformWrite("rawfull");
3071  ok = ok && w.uniformWrite("constant");
3072  ok = ok && w.uniformWrite("fpreal16");
3073 
3074  ntype -= COMPRESS_ENGINE;
3075  for (i = 0; i < ntype; i++)
3076  {
3077  ok = ok && w.uniformWrite(getCompressionEngines()(i)->getName());
3078  }
3079 
3080  ok = ok && w.endUniformArray();
3081  return ok;
3082 }
3083 
3084 template <typename T>
3085 bool
3086 UT_VoxelTile<T>::loadCompressionTypes(UT_JSONParser &p, UT_IntArray &compress)
3087 {
3088  UT_JSONParser::traverser it;
3089  UT_WorkBuffer buffer;
3090  int idx;
3091 
3092  compress.entries(0);
3093  for (it = p.beginArray(); !it.atEnd(); ++it)
3094  {
3095  if (!p.parseString(buffer))
3096  return false;
3097 
3098  if (!buffer.strcmp("raw"))
3099  compress.append(COMPRESS_RAW);
3100  else if (!buffer.strcmp("rawfull"))
3101  compress.append(COMPRESS_RAWFULL);
3102  else if (!buffer.strcmp("constant"))
3103  compress.append(COMPRESS_CONSTANT);
3104  else if (!buffer.strcmp("fpreal16"))
3105  compress.append(COMPRESS_FPREAL16);
3106  else
3107  {
3108  idx = lookupCompressionEngine(buffer.buffer());
3109 
3110  // -1 means a failure to find it in our set..
3111  // this is only a bad thing if a tile actually uses this engine.
3112 
3113  compress.append(idx);
3114  }
3115  }
3116  return true;
3117 }
3118 
3119 
3120 
3121 //
3122 // VoxelArray definitions.
3123 //
3124 
3125 template <typename T>
3126 UT_VoxelArray<T>::UT_VoxelArray()
3127 {
3128  myRes[0] = 0;
3129  myRes[1] = 0;
3130  myRes[2] = 0;
3131  myTileRes[0] = 0;
3132  myTileRes[1] = 0;
3133  myTileRes[2] = 0;
3134 
3135  myTiles = 0;
3136 
3137  myInvRes = 1;
3138 
3139  myBorderValue = 0;
3140  myBorderScale[0] = 0;
3141  myBorderScale[1] = 0;
3142  myBorderScale[2] = 0;
3143  myBorderType = UT_VOXELBORDER_STREAK;
3144 
3145  mySharedMem = 0;
3146  mySharedMemView = 0;
3147 }
3148 
3149 template <typename T>
3150 UT_VoxelArray<T>::~UT_VoxelArray()
3151 {
3152  deleteVoxels();
3153 }
3154 
3155 template <typename T>
3156 UT_VoxelArray<T>::UT_VoxelArray(const UT_VoxelArray<T> &src)
3157 {
3158  myRes[0] = 0;
3159  myRes[1] = 0;
3160  myRes[2] = 0;
3161  myInvRes = 1;
3162  myTileRes[0] = 0;
3163  myTileRes[1] = 0;
3164  myTileRes[2] = 0;
3165 
3166  myTiles = 0;
3167 
3168  mySharedMem = 0;
3169  mySharedMemView = 0;
3170 
3171  *this = src;
3172 }
3173 
3174 template <typename T>
3175 void
3176 UT_VoxelArray<T>::copyDataPartial(const UT_VoxelArray<T> &src,
3177  const UT_JobInfo &info)
3178 {
3179  UT_ASSERT(isMatching(src));
3180  UT_VoxelArrayIterator<T> vit(this);
3181  vit.splitByTile(info);
3182  for (vit.rewind(); !vit.atEnd(); vit.advanceTile())
3183  {
3184  int i = vit.getLinearTileNum();
3185  myTiles[i] = src.myTiles[i];
3186  }
3187 }
3188 
3189 template <typename T>
3190 const UT_VoxelArray<T> &
3191 UT_VoxelArray<T>::operator=(const UT_VoxelArray<T> &src)
3192 {
3193  // Paranoid code:
3194  if (&src == this)
3195  return *this;
3196 
3197  myBorderScale[0] = src.myBorderScale[0];
3198  myBorderScale[1] = src.myBorderScale[1];
3199  myBorderScale[2] = src.myBorderScale[2];
3200  myBorderValue = src.myBorderValue;
3201  myBorderType = src.myBorderType;
3202 
3203  myCompressionOptions = src.myCompressionOptions;
3204 
3205  // Allocate proper size; don't bother setting to zero, since we'll copy the
3206  // data immediately after.
3207  size(src.myRes[0], src.myRes[1], src.myRes[2], false);
3208 
3209  copyData(src);
3210 
3211  return *this;
3212 }
3213 
3214 // If defined, construction and destruction of tiles will be multithreaded.
3215 // Otherwise, new[] and delete[] take care of calling these methods.
3216 // Unfortunately, this doesn't work at the moment...
3217 #define __MULTITHREADED_STRUCTORS__
3218 template <typename T>
3219 void
3220 UT_VoxelArray<T>::deleteVoxels()
3221 {
3222 #ifdef __MULTITHREADED_STRUCTORS__
3223  // Free up each tile's heap data, then bulk-deallocate the array.
3224  UTparallelForLightItems(UT_BlockedRange<int>(0, numTiles()),
3225  [&](const UT_BlockedRange<int>& range)
3226  {
3227  for(int i = range.begin(); i < range.end(); i++)
3228  {
3229  myTiles[i].~UT_VoxelTile<T>();
3230  }
3231  });
3232  operator delete(myTiles, std::nothrow);
3233 #else
3234  delete [] myTiles;
3235 #endif
3236  myTiles = 0;
3237 
3238  myTileRes[0] = myTileRes[1] = myTileRes[2] = 0;
3239  myRes[0] = myRes[1] = myRes[2] = 0;
3240 
3241  delete mySharedMemView;
3242  mySharedMemView = 0;
3243 
3244  delete mySharedMem;
3245  mySharedMem = 0;
3246 }
3247 
3248 template <typename T>
3249 void
3250 UT_VoxelArray<T>::size(int xres, int yres, int zres, bool zero)
3251 {
3252  // Check if the sizes are already right.
3253  if (myRes[0] == xres && myRes[1] == yres && myRes[2] == zres)
3254  {
3255  if (zero)
3256  {
3257  T tzero;
3258  tzero = 0;
3259  constant(tzero);
3260  }
3261  return;
3262  }
3263 
3264  deleteVoxels();
3265 
3266  // Initialize our tiles.
3267  int tile_res[3];
3268  tile_res[0] = (xres + TILEMASK) >> TILEBITS;
3269  tile_res[1] = (yres + TILEMASK) >> TILEBITS;
3270  tile_res[2] = (zres + TILEMASK) >> TILEBITS;
3271 
3272  exint ntiles = ((exint)tile_res[0]) * tile_res[1] * tile_res[2];
3273  if (ntiles)
3274  {
3275 #ifdef __MULTITHREADED_STRUCTORS__
3276  // Allocate the big array of the right size, then use placement new to
3277  // construct each tile.
3278  // Note that it is not guaranteed that the returned pointer is properly
3279  // aligned with raw operator new. However, we only practically need 8-byte
3280  // alignment given the current implementation, which should be respected by
3281  // operator new.
3282  // We have to wait for C++17 for version of operator new that accepts
3283  // alignment requirements...
3284  myTiles = (UT_VoxelTile<T>*) operator new(sizeof(UT_VoxelTile<T>) * ntiles,
3285  std::nothrow);
3286  UTparallelForLightItems(UT_BlockedRange<int>(0, ntiles),
3287  [&](const UT_BlockedRange<int>& range)
3288  {
3289  for(int k = range.begin(); k < range.end(); k++)
3290  {
3291  new(myTiles + k) UT_VoxelTile<T>();
3292 
3293  // Set the resolution of this tile.
3294  int tilex = k % tile_res[0];
3295  int k2 = k / tile_res[0];
3296  int tiley = k2 % tile_res[1];
3297  int tilez = k2 / tile_res[1];
3298  myTiles[k].setRes(SYSmin(TILESIZE, xres - tilex * TILESIZE),
3299  SYSmin(TILESIZE, yres - tiley * TILESIZE),
3300  SYSmin(TILESIZE, zres - tilez * TILESIZE));
3301  }
3302  });
3303 #else
3304  myTiles = new UT_VoxelTile<T>[ntiles];
3305 #endif
3306 
3307  // Only set resolutions *AFTER* we successfully allocate
3308  myRes[0] = xres;
3309  myRes[1] = yres;
3310  myRes[2] = zres;
3311 
3312  myInvRes = 1;
3313  if (xres)
3314  myInvRes.x() = 1.0f / myRes[0];
3315  if (yres)
3316  myInvRes.y() = 1.0f / myRes[1];
3317  if (zres)
3318  myInvRes.z() = 1.0f / myRes[2];
3319 
3320  myTileRes[0] = tile_res[0];
3321  myTileRes[1] = tile_res[1];
3322  myTileRes[2] = tile_res[2];
3323 
3324 #ifndef __MULTITHREADED_STRUCTORS__
3325  int i = 0;
3326  for (int tz = 0; tz < myTileRes[2]; tz++)
3327  {
3328  int zr;
3329  if (tz < myTileRes[2]-1)
3330  zr = TILESIZE;
3331  else
3332  zr = zres - tz * TILESIZE;
3333 
3334  for (int ty = 0; ty < myTileRes[1]; ty++)
3335  {
3336  int yr;
3337  if (ty < myTileRes[1]-1)
3338  yr = TILESIZE;
3339  else
3340  yr = yres - ty * TILESIZE;
3341 
3342  int tx, xr = TILESIZE;
3343  for (tx = 0; tx < myTileRes[0]-1; tx++)
3344  {
3345  myTiles[i].setRes(xr, yr, zr);
3346 
3347  i++;
3348  }
3349  xr = xres - tx * TILESIZE;
3350  myTiles[i].setRes(xr, yr, zr);
3351  i++;
3352  }
3353  }
3354 #endif
3355  }
3356  else
3357  myTiles = 0;
3358 }
3359 
3360 template <typename T>
3361 void
3362 UT_VoxelArray<T>::match(const UT_VoxelArray<T> &src)
3363 {
3364  // This call will only actually resize if the sizes are different. If it
3365  // does not resize, contents will be left alone.
3366  size(src.getXRes(), src.getYRes(), src.getZRes(), false);
3367 
3368  // Update border conditions.
3369  myBorderType = src.myBorderType;
3370  myBorderScale[0] = src.myBorderScale[0];
3371  myBorderScale[1] = src.myBorderScale[1];
3372  myBorderScale[2] = src.myBorderScale[2];
3373  myBorderValue = src.myBorderValue;
3374 
3375  // Match our compression tolerances
3376  myCompressionOptions = src.myCompressionOptions;
3377 }
3378 
3379 template <typename T>
3380 int64
3381 UT_VoxelArray<T>::getMemoryUsage(bool inclusive) const
3382 {
3383  int64 mem = inclusive ? sizeof(*this) : 0;
3384 
3385  int ntiles = numTiles();
3386  for (int i = 0; i < ntiles; i++)
3387  mem += myTiles[i].getMemoryUsage(true);
3388 
3389  if (mySharedMem)
3390  mem += mySharedMem->getMemoryUsage(true);
3391 
3392  if (mySharedMemView)
3393  mem += mySharedMemView->getMemoryUsage(true);
3394 
3395  return mem;
3396 }
3397 
3398 template <typename T>
3399 void
3400 UT_VoxelArray<T>::constantPartial(T t, const UT_JobInfo &info)
3401 {
3402  UT_VoxelArrayIterator<T> vit(this);
3403  // We don't want split tile as we update the actual tiles here
3404  // so will have false-sharing if we interleaved.
3405  vit.setPartialRange(info.job(), info.numJobs());
3406  for (vit.rewind(); !vit.atEnd(); vit.advanceTile())
3407  {
3408  int i = vit.getLinearTileNum();
3409  myTiles[i].makeConstant(t);
3410  }
3411 }
3412 
3413 template <typename T>
3414 bool
3415 UT_VoxelArray<T>::isConstant(T *t) const
3416 {
3417  int i, ntiles;
3418  T cval;
3419  cval = 0;
3420  const fpreal tol = SYS_FTOLERANCE_R;
3421 
3422  ntiles = numTiles();
3423  for (i = 0; i < ntiles; i++)
3424  {
3425  if (!myTiles[i].isConstant())
3426  {
3427  return false;
3428  }
3429 
3430  if (!i)
3431  {
3432  // First tile, get the constant value.
3433  cval = myTiles[i].rawConstVal();
3434  }
3435  else
3436  {
3437  // See if we have deviated too much.
3438  if (UT_VoxelTile<T>::dist(cval, myTiles[i].rawConstVal()) > tol)
3439  {
3440  return false;
3441  }
3442  }
3443  }
3444 
3445  // All tiles are both constant and within tolerance of each
3446  // other. Write out our constant value and return true.
3447  if (t)
3448  *t = cval;
3449 
3450  return true;
3451 }
3452 
3453 template <typename T>
3454 bool
3455 UT_VoxelArray<T>::hasNan() const
3456 {
3457  int i, ntiles;
3458 
3459  ntiles = numTiles();
3460  for (i = 0; i < ntiles; i++)
3461  {
3462  if (myTiles[i].hasNan())
3463  {
3464  return true;
3465  }
3466  }
3467 
3468  return false;
3469 }
3470 
3471 template <typename T>
3472 T
3473 UT_VoxelArray<T>::operator()(UT_Vector3F pos) const
3474 {
3475  // We go from the position in the unit cube into the index.
3476  // The center of cells must map to the exact integer indices.
3477  pos.x() *= myRes[0];
3478  pos.y() *= myRes[1];
3479  pos.z() *= myRes[2];
3480  pos.x() -= 0.5;
3481  pos.y() -= 0.5;
3482  pos.z() -= 0.5;
3483 
3484  return lerpVoxelCoord(pos);
3485 }
3486 
3487 template <typename T>
3488 T
3489 UT_VoxelArray<T>::lerpVoxelCoord(UT_Vector3F pos) const
3490 {
3491  int x, y, z;
3492  // Yes, these have to be 32 becaues split float requires 32!
3493  fpreal32 fx, fy, fz;
3494 
3495  splitVoxelCoord(pos, x, y, z, fx, fy, fz);
3496 
3497  return lerpVoxel(x, y, z, fx, fy, fz);
3498 }
3499 
3500 template <typename T>
3501 template <int AXIS2D>
3502 T
3503 UT_VoxelArray<T>::lerpVoxelCoordAxis(UT_Vector3F pos) const
3504 {
3505  int x, y, z;
3506  // Yes, these have to be 32 becaues split float requires 32!
3507  fpreal32 fx, fy, fz;
3508 
3509  splitVoxelCoordAxis<AXIS2D>(pos, x, y, z, fx, fy, fz);
3510 
3511  return lerpVoxelAxis<AXIS2D>(x, y, z, fx, fy, fz);
3512 }
3513 
3514 template <typename T>
3515 T
3516 UT_VoxelArray<T>::lerpVoxel(int x, int y, int z,
3517  float fx, float fy, float fz) const
3518 {
3519  // Do trilinear interpolation.
3520  T vx, vx1, vy, vy1, vz;
3521 
3522  // Optimization for common cases (values are within the voxel range and
3523  // are all within the same tile)
3524  if ( !((x | y | z) < 0) &&
3525  (((x - myRes[0]+1) & (y - myRes[1]+1) & (z - myRes[2]+1)) < 0))
3526 
3527  // (x > 0) && (y > 0) && (z > 0) &&
3528  // Do not use x+1 < foo as if x is MAX_INT that will falsely
3529  // report in bounds!
3530  // (x < myRes[0]-1) && (y < myRes[1]-1) && (z < myRes[2]-1) )
3531  {
3532  int xm, ym, zm;
3533 
3534  xm = x & TILEMASK;
3535  ym = y & TILEMASK;
3536  zm = z & TILEMASK;
3537 
3538  if ((xm != TILEMASK) && (ym != TILEMASK) && (zm != TILEMASK))
3539  {
3540  const UT_VoxelTile<T> *tile =
3541  getTile(x >> TILEBITS, y >> TILEBITS, z >> TILEBITS);
3542 
3543  vz = tile->lerp(xm, ym, zm, fx, fy, fz);
3544  }
3545  else
3546  {
3547  // We cross tile boundaries but we remain within
3548  // the voxel grid. We can thus avoid any bounds checking
3549  // and use operator() rather than getValue.
3550 
3551  // Lerp x:x+1, y, z
3552  vx = UT_VoxelTile<T>::lerpValues((*this)(x, y, z),
3553  (*this)(x+1, y, z),
3554  fx);
3555  // Lerp x:x+1, y+1, z
3556  vx1= UT_VoxelTile<T>::lerpValues((*this)(x, y+1, z),
3557  (*this)(x+1, y+1, z),
3558  fx);
3559  // Lerp x:x+1, y:y+1, z
3560  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3561 
3562  // Lerp x:x+1, y, z+1
3563  vx = UT_VoxelTile<T>::lerpValues((*this)(x, y, z+1),
3564  (*this)(x+1, y, z+1),
3565  fx);
3566  // Lerp x:x+1, y+1, z+1
3567  vx1= UT_VoxelTile<T>::lerpValues((*this)(x, y+1, z+1),
3568  (*this)(x+1, y+1, z+1),
3569  fx);
3570 
3571  // Lerp x:x+1, y:y+1, z+1
3572  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3573 
3574  // Lerp x:x+1, y:y+1, z:z+1
3575  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
3576  }
3577  }
3578  else
3579  {
3580  // Lerp x:x+1, y, z
3581  vx = UT_VoxelTile<T>::lerpValues(getValue(x, y, z),
3582  getValue(x+1, y, z),
3583  fx);
3584  // Lerp x:x+1, y+1, z
3585  vx1= UT_VoxelTile<T>::lerpValues(getValue(x, y+1, z),
3586  getValue(x+1, y+1, z),
3587  fx);
3588 
3589  // Lerp x:x+1, y:y+1, z
3590  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3591 
3592  // Lerp x:x+1, y, z+1
3593  vx = UT_VoxelTile<T>::lerpValues(getValue(x, y, z+1),
3594  getValue(x+1, y, z+1),
3595  fx);
3596  // Lerp x:x+1, y+1, z+1
3597  vx1= UT_VoxelTile<T>::lerpValues(getValue(x, y+1, z+1),
3598  getValue(x+1, y+1, z+1),
3599  fx);
3600 
3601  // Lerp x:x+1, y:y+1, z+1
3602  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3603 
3604  // Lerp x:x+1, y:y+1, z:z+1
3605  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
3606  }
3607 
3608  return vz;
3609 }
3610 
3611 template <typename T>
3612 template <int AXIS2D>
3613 T
3614 UT_VoxelArray<T>::lerpVoxelAxis(int x, int y, int z,
3615  float fx, float fy, float fz) const
3616 {
3617  // Do bilinear interpolation.
3618  T vx, vx1, vy, vy1, vz;
3619 
3620  int lesscomp = 0, greatercomp = -1;
3621 
3622  if (AXIS2D != 0)
3623  {
3624  lesscomp |= x;
3625  greatercomp &= (x - myRes[0]+1);
3626  }
3627  if (AXIS2D != 1)
3628  {
3629  lesscomp |= y;
3630  greatercomp &= (y - myRes[1]+1);
3631  }
3632  if (AXIS2D != 2)
3633  {
3634  lesscomp |= z;
3635  greatercomp &= (z - myRes[2]+1);
3636  }
3637 
3638  // Optimization for common cases (values are within the voxel range and
3639  // are all within the same tile)
3640  if ( !(lesscomp < 0) && (greatercomp < 0) )
3641  {
3642  int xm, ym, zm;
3643 
3644  xm = x & TILEMASK;
3645  ym = y & TILEMASK;
3646  zm = z & TILEMASK;
3647 
3648  if ((AXIS2D == 0 || xm != TILEMASK) &&
3649  (AXIS2D == 1 || ym != TILEMASK) &&
3650  (AXIS2D == 2 || zm != TILEMASK))
3651  {
3652  const UT_VoxelTile<T> *tile =
3653  getTile( (AXIS2D == 0) ? 0 : (x >> TILEBITS),
3654  (AXIS2D == 1) ? 0 : (y >> TILEBITS),
3655  (AXIS2D == 2) ? 0 : (z >> TILEBITS) );
3656 
3657  vz = tile->template lerpAxis<AXIS2D>(xm, ym, zm, fx, fy, fz);
3658  }
3659  else
3660  {
3661  // We cross tile boundaries but we remain within
3662  // the voxel grid. We can thus avoid any bounds checking
3663  // and use operator() rather than getValue.
3664 
3665  // Lerp x:x+1, y, z
3666  if (AXIS2D != 0)
3667  vx = UT_VoxelTile<T>::lerpValues((*this)(x, y, z),
3668  (*this)(x+1, y, z),
3669  fx);
3670  else
3671  vx = (*this)(x, y, z);
3672 
3673  if (AXIS2D != 1)
3674  {
3675  // Lerp x:x+1, y+1, z
3676  if (AXIS2D != 0)
3677  vx1= UT_VoxelTile<T>::lerpValues((*this)(x, y+1, z),
3678  (*this)(x+1, y+1, z),
3679  fx);
3680  else
3681  vx1 = (*this)(x, y+1, z);
3682  // Lerp x:x+1, y:y+1, z
3683  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3684  }
3685  else
3686  vy = vx;
3687 
3688  if (AXIS2D != 2)
3689  {
3690  // Lerp x:x+1, y, z+1
3691  if (AXIS2D != 0)
3692  vx = UT_VoxelTile<T>::lerpValues((*this)(x, y, z+1),
3693  (*this)(x+1, y, z+1),
3694  fx);
3695  else
3696  vx = (*this)(x, y, z+1);
3697 
3698  if (AXIS2D != 1)
3699  {
3700  // Lerp x:x+1, y+1, z+1
3701  if (AXIS2D != 0)
3702  vx1= UT_VoxelTile<T>::lerpValues((*this)(x, y+1, z+1),
3703  (*this)(x+1, y+1, z+1),
3704  fx);
3705  else
3706  vx1 = (*this)(x, y+1, z+1);
3707  // Lerp x:x+1, y:y+1, z+1
3708  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3709  }
3710  else
3711  vy1 = vx;
3712 
3713  // Lerp x:x+1, y:y+1, z:z+1
3714  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
3715  }
3716  else
3717  vz = vy;
3718  }
3719  }
3720  else
3721  {
3722  // Lerp x:x+1, y, z
3723  if (AXIS2D != 0)
3724  vx = UT_VoxelTile<T>::lerpValues(getValue(x, y, z),
3725  getValue(x+1, y, z),
3726  fx);
3727  else
3728  vx = getValue(x, y, z);
3729 
3730  if (AXIS2D != 1)
3731  {
3732  // Lerp x:x+1, y+1, z
3733  if (AXIS2D != 0)
3734  vx1= UT_VoxelTile<T>::lerpValues(getValue(x, y+1, z),
3735  getValue(x+1, y+1, z),
3736  fx);
3737  else
3738  vx1 = getValue(x, y+1, z);
3739  // Lerp x:x+1, y:y+1, z
3740  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3741  }
3742  else
3743  vy = vx;
3744 
3745  if (AXIS2D != 2)
3746  {
3747  // Lerp x:x+1, y, z+1
3748  if (AXIS2D != 0)
3749  vx = UT_VoxelTile<T>::lerpValues(getValue(x, y, z+1),
3750  getValue(x+1, y, z+1),
3751  fx);
3752  else
3753  vx = getValue(x, y, z+1);
3754 
3755  if (AXIS2D != 1)
3756  {
3757  // Lerp x:x+1, y+1, z+1
3758  if (AXIS2D != 0)
3759  vx1= UT_VoxelTile<T>::lerpValues(getValue(x, y+1, z+1),
3760  getValue(x+1, y+1, z+1),
3761  fx);
3762  else
3763  vx1 = getValue(x, y+1, z+1);
3764  // Lerp x:x+1, y:y+1, z+1
3765  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
3766  }
3767  else
3768  vy1 = vx;
3769 
3770  // Lerp x:x+1, y:y+1, z:z+1
3771  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
3772  }
3773  else
3774  vz = vy;
3775  }
3776 
3777  return vz;
3778 }
3779 
3780 template <typename T>
3781 void
3782 UT_VoxelArray<T>::evaluateMinMax(T &lerp, T &lmin, T &lmax,
3783  UT_Vector3F pos) const
3784 {
3785  // We go from the position in the unit cube into the index.
3786  // The center of cells must map to the exact integer indices.
3787  pos.x() *= myRes[0];
3788  pos.y() *= myRes[1];
3789  pos.z() *= myRes[2];
3790  pos.x() -= 0.5;
3791  pos.y() -= 0.5;
3792  pos.z() -= 0.5;
3793 
3794  lerpVoxelCoordMinMax(lerp, lmin, lmax, pos);
3795 }
3796 
3797 template <typename T>
3798 void
3799 UT_VoxelArray<T>::lerpVoxelCoordMinMax(T &lerp, T &lmin, T &lmax,
3800  UT_Vector3F pos) const
3801 {
3802  int x, y, z;
3803  // Yes, these have to be 32 becaues split float requires 32!
3804  fpreal32 fx, fy, fz;
3805 
3806  splitVoxelCoord(pos, x, y, z, fx, fy, fz);
3807 
3808  lerpVoxelMinMax(lerp, lmin, lmax, x, y, z, fx, fy, fz);
3809 }
3810 
3811 
3812 template <typename T>
3813 template <int AXIS2D>
3814 void
3815 UT_VoxelArray<T>::lerpVoxelCoordMinMaxAxis(T &lerp, T &lmin, T &lmax,
3816  UT_Vector3F pos) const
3817 {
3818  int x, y, z;
3819  // Yes, these have to be 32 becaues split float requires 32!
3820  fpreal32 fx, fy, fz;
3821 
3822  splitVoxelCoordAxis<AXIS2D>(pos, x, y, z, fx, fy, fz);
3823 
3824  lerpVoxelMinMaxAxis<AXIS2D>(lerp, lmin, lmax, x, y, z, fx, fy, fz);
3825 }
3826 
3827 
3828 template <typename T>
3829 void
3830 UT_VoxelArray<T>::lerpVoxelMinMax(
3831  T &lerp, T &smin, T &smax,
3832  int x, int y, int z,
3833  float fx, float fy, float fz) const
3834 {
3835  T samples[8];
3836 
3837  if (extractSample(x, y, z, samples))
3838  {
3839  lerp = smin = smax = samples[0];
3840  return;
3841  }
3842 
3843  lerp = lerpSample(samples, fx, fy, fz);
3844 
3845  T smin1, smax1;
3846 
3847  SYSminmax(samples[0], samples[1], samples[2], samples[3],
3848  smin, smax);
3849  SYSminmax(samples[4+0], samples[4+1], samples[4+2], samples[4+3],
3850  smin1, smax1);
3851 
3852  smin = SYSmin(smin, smin1);
3853  smax = SYSmax(smax, smax1);
3854 }
3855 
3856 template <typename T>
3857 template <int AXIS2D>
3858 void
3859 UT_VoxelArray<T>::lerpVoxelMinMaxAxis(
3860  T &lerp, T &smin, T &smax,
3861  int x, int y, int z,
3862  float fx, float fy, float fz) const
3863 {
3864  T samples[8];
3865 
3866  if (extractSampleAxis<AXIS2D>(x, y, z, samples))
3867  {
3868  lerp = smin = smax = samples[0];
3869  return;
3870  }
3871 
3872  lerp = lerpSampleAxis<AXIS2D>(samples, fx, fy, fz);
3873 
3874  if (AXIS2D == 0)
3875  SYSminmax(samples[0], samples[2], samples[4], samples[6],
3876  smin, smax);
3877  else if (AXIS2D == 1)
3878  SYSminmax(samples[0], samples[1], samples[4], samples[5],
3879  smin, smax);
3880  else if (AXIS2D == 2)
3881  SYSminmax(samples[0], samples[1], samples[2], samples[3],
3882  smin, smax);
3883  else
3884  {
3885  T smin1, smax1;
3886 
3887  SYSminmax(samples[0], samples[1], samples[2], samples[3],
3888  smin, smax);
3889  SYSminmax(samples[4+0], samples[4+1], samples[4+2], samples[4+3],
3890  smin1, smax1);
3891 
3892  smin = SYSmin(smin, smin1);
3893  smax = SYSmax(smax, smax1);
3894  }
3895 }
3896 
3897 template <typename T>
3898 bool
3899 UT_VoxelArray<T>::extractSample(int x, int y, int z,
3900  T *samples) const
3901 {
3902  // Optimization for common cases (values are within the voxel range and
3903  // are all within the same tile)
3904  if ( !((x | y | z) < 0) &&
3905  (((x - myRes[0]+1) & (y - myRes[1]+1) & (z - myRes[2]+1)) < 0))
3906 
3907  // (x > 0) && (y > 0) && (z > 0) &&
3908  // Do not use x+1 < foo as if x is MAX_INT that will falsely
3909  // report in bounds!
3910  // (x < myRes[0]-1) && (y < myRes[1]-1) && (z < myRes[2]-1) )
3911  {
3912  int xm, ym, zm;
3913 
3914  xm = x & TILEMASK;
3915  ym = y & TILEMASK;
3916  zm = z & TILEMASK;
3917 
3918  if ((xm != TILEMASK) && (ym != TILEMASK) && (zm != TILEMASK))
3919  {
3920  const UT_VoxelTile<T> *tile =
3921  getTile(x >> TILEBITS, y >> TILEBITS, z >> TILEBITS);
3922 
3923  return tile->extractSample(xm, ym, zm, samples);
3924  }
3925  else
3926  {
3927  // We cross tile boundaries but we remain within
3928  // the voxel grid. We can thus avoid any bounds checking
3929  // and use operator() rather than getValue.
3930  samples[0] = (*this)(x, y, z);
3931  samples[1] = (*this)(x+1, y, z);
3932  samples[2+0] = (*this)(x, y+1, z);
3933  samples[2+1] = (*this)(x+1, y+1, z);
3934  samples[4+0] = (*this)(x, y, z+1);
3935  samples[4+1] = (*this)(x+1, y, z+1);
3936  samples[4+2+0] = (*this)(x, y+1, z+1);
3937  samples[4+2+1] = (*this)(x+1, y+1, z+1);
3938  }
3939  }
3940  else
3941  {
3942  samples[0] = getValue(x, y, z);
3943  samples[1] = getValue(x+1, y, z);
3944  samples[2+0] = getValue(x, y+1, z);
3945  samples[2+1] = getValue(x+1, y+1, z);
3946  samples[4+0] = getValue(x, y, z+1);
3947  samples[4+1] = getValue(x+1, y, z+1);
3948  samples[4+2+0] = getValue(x, y+1, z+1);
3949  samples[4+2+1] = getValue(x+1, y+1, z+1);
3950  }
3951 
3952  return false;
3953 }
3954 
3955 
3956 template <typename T>
3957 template <int AXIS2D>
3958 bool
3959 UT_VoxelArray<T>::extractSampleAxis(int x, int y, int z,
3960  T *samples) const
3961 {
3962  // Optimization for common cases (values are within the voxel range and
3963  // are all within the same tile)
3964  int lesscomp = 0, greatercomp = -1;
3965 
3966  if (AXIS2D != 0)
3967  {
3968  lesscomp |= x;
3969  greatercomp &= (x - myRes[0]+1);
3970  }
3971  if (AXIS2D != 1)
3972  {
3973  lesscomp |= y;
3974  greatercomp &= (y - myRes[1]+1);
3975  }
3976  if (AXIS2D != 2)
3977  {
3978  lesscomp |= z;
3979  greatercomp &= (z - myRes[2]+1);
3980  }
3981 
3982  // Optimization for common cases (values are within the voxel range and
3983  // are all within the same tile)
3984  if ( !(lesscomp < 0) && (greatercomp < 0) )
3985  {
3986  int xm, ym, zm;
3987 
3988  xm = x & TILEMASK;
3989  ym = y & TILEMASK;
3990  zm = z & TILEMASK;
3991 
3992  if ((AXIS2D == 0 || xm != TILEMASK) &&
3993  (AXIS2D == 1 || ym != TILEMASK) &&
3994  (AXIS2D == 2 || zm != TILEMASK))
3995  {
3996  const UT_VoxelTile<T> *tile =
3997  getTile( (AXIS2D == 0) ? 0 : (x >> TILEBITS),
3998  (AXIS2D == 1) ? 0 : (y >> TILEBITS),
3999  (AXIS2D == 2) ? 0 : (z >> TILEBITS) );
4000 
4001  return tile->template extractSampleAxis<AXIS2D>(xm, ym, zm, samples);
4002  }
4003  else
4004  {
4005  // We cross tile boundaries but we remain within
4006  // the voxel grid. We can thus avoid any bounds checking
4007  // and use operator() rather than getValue.
4008  samples[0] = (*this)(x, y, z);
4009  if (AXIS2D != 0)
4010  samples[1] = (*this)(x+1, y, z);
4011  if (AXIS2D != 1)
4012  {
4013  samples[2+0] = (*this)(x, y+1, z);
4014  if (AXIS2D != 0)
4015  samples[2+1] = (*this)(x+1, y+1, z);
4016  }
4017  if (AXIS2D != 2)
4018  {
4019  samples[4+0] = (*this)(x, y, z+1);
4020  if (AXIS2D != 0)
4021  samples[4+1] = (*this)(x+1, y, z+1);
4022  if (AXIS2D != 1)
4023  {
4024  samples[4+2+0] = (*this)(x, y+1, z+1);
4025  if (AXIS2D != 0)
4026  samples[4+2+1] = (*this)(x+1, y+1, z+1);
4027  }
4028  }
4029  }
4030  }
4031  else
4032  {
4033  samples[0] = getValue(x, y, z);
4034  if (AXIS2D != 0)
4035  samples[1] = getValue(x+1, y, z);
4036  if (AXIS2D != 1)
4037  {
4038  samples[2+0] = getValue(x, y+1, z);
4039  if (AXIS2D != 0)
4040  samples[2+1] = getValue(x+1, y+1, z);
4041  }
4042  if (AXIS2D != 2)
4043  {
4044  samples[4+0] = getValue(x, y, z+1);
4045  if (AXIS2D != 0)
4046  samples[4+1] = getValue(x+1, y, z+1);
4047  if (AXIS2D != 1)
4048  {
4049  samples[4+2+0] = getValue(x, y+1, z+1);
4050  if (AXIS2D != 0)
4051  samples[4+2+1] = getValue(x+1, y+1, z+1);
4052  }
4053  }
4054  }
4055 
4056  return false;
4057 }
4058 
4059 template <typename T>
4060 bool
4061 UT_VoxelArray<T>::extractSamplePlus(int x, int y, int z,
4062  T *samples) const
4063 {
4064  // Optimization for common cases (values are within the voxel range and
4065  // are all within the same tile)
4066  if ( !(((x-1) | (y-1) | (z-1)) < 0) &&
4067  (((x - myRes[0]+1) & (y - myRes[1]+1) & (z - myRes[2]+1)) < 0))
4068 
4069  // (x > 0) && (y > 0) && (z > 0) &&
4070  // Do not use x+1 < foo as if x is MAX_INT that will falsely
4071  // report in bounds!
4072  // (x < myRes[0]-1) && (y < myRes[1]-1) && (z < myRes[2]-1) )
4073  {
4074  int xm, ym, zm;
4075 
4076  xm = x & TILEMASK;
4077  ym = y & TILEMASK;
4078  zm = z & TILEMASK;
4079 
4080  if (xm && ym && zm && (xm != TILEMASK) && (ym != TILEMASK) && (zm != TILEMASK))
4081  {
4082  const UT_VoxelTile<T> *tile =
4083  getTile(x >> TILEBITS, y >> TILEBITS, z >> TILEBITS);
4084 
4085  return tile->extractSamplePlus(xm, ym, zm, samples);
4086  }
4087  else
4088  {
4089  // We cross tile boundaries but we remain within
4090  // the voxel grid. We can thus avoid any bounds checking
4091  // and use operator() rather than getValue.
4092  samples[0] = (*this)(x-1, y, z);
4093  samples[1] = (*this)(x+1, y, z);
4094  samples[2+0] = (*this)(x, y-1, z);
4095  samples[2+1] = (*this)(x, y+1, z);
4096  samples[4+0] = (*this)(x, y, z-1);
4097  samples[4+1] = (*this)(x, y, z+1);
4098  samples[6] = (*this)(x, y, z);
4099  }
4100  }
4101  else
4102  {
4103  samples[0] = getValue(x-1, y, z);
4104  samples[1] = getValue(x+1, y, z);
4105  samples[2+0] = getValue(x, y-1, z);
4106  samples[2+1] = getValue(x, y+1, z);
4107  samples[4+0] = getValue(x, y, z-1);
4108  samples[4+1] = getValue(x, y, z+1);
4109  samples[6] = getValue(x, y, z);
4110  }
4111 
4112  return false;
4113 }
4114 
4115 #if 0
4116 /// Implementation of UT_VoxelTile::extractSampleCube() has an error (see the
4117 /// comments for it), which cascaded to here. Simply removing this function for
4118 /// now, as there isn't any need for it--at least in our own code.
4119 template <typename T>
4120 bool
4121 UT_VoxelArray<T>::extractSampleCube(int x, int y, int z,
4122  T *samples) const
4123 {
4124  // Optimization for common cases (values are within the voxel range and
4125  // are all within the same tile)
4126  if ( !(((x-1) | (y-1) | (z-1)) < 0) &&
4127  (((x - myRes[0]+1) & (y - myRes[1]+1) & (z - myRes[2]+1)) < 0))
4128 
4129  // (x > 0) && (y > 0) && (z > 0) &&
4130  // Do not use x+1 < foo as if x is MAX_INT that will falsely
4131  // report in bounds!
4132  // (x < myRes[0]-1) && (y < myRes[1]-1) && (z < myRes[2]-1) )
4133  {
4134  int xm, ym, zm;
4135 
4136  xm = x & TILEMASK;
4137  ym = y & TILEMASK;
4138  zm = z & TILEMASK;
4139 
4140  if (xm && ym && zm && (xm != TILEMASK) && (ym != TILEMASK) && (zm != TILEMASK))
4141  {
4142  const UT_VoxelTile<T> *tile =
4143  getTile(x >> TILEBITS, y >> TILEBITS, z >> TILEBITS);
4144 
4145  return tile->extractSampleCube(xm, ym, zm, samples);
4146  }
4147  else
4148  {
4149  // We cross tile boundaries but we remain within
4150  // the voxel grid. We can thus avoid any bounds checking
4151  // and use operator() rather than getValue.
4152  int sampidx = 0;
4153  for (int dz = -1; dz <= 1; dz++)
4154  {
4155  for (int dy = -1; dy <= 1; dy++)
4156  {
4157  for (int dx = -1; dx <= 1; dx++)
4158  {
4159  samples[sampidx++] = (*this)(x+dx, y+dy, z+dz);
4160  }
4161  }
4162  }
4163  }
4164  }
4165  else
4166  {
4167  int sampidx = 0;
4168  for (int dz = -1; dz <= 1; dz++)
4169  {
4170  for (int dy = -1; dy <= 1; dy++)
4171  {
4172  for (int dx = -1; dx <= 1; dx++)
4173  {
4174  samples[sampidx++] = getValue(x+dx, y+dy, z+dz);
4175  }
4176  }
4177  }
4178  }
4179 
4180  return false;
4181 }
4182 #endif
4183 
4184 template <typename T>
4185 T
4186 UT_VoxelArray<T>::lerpSample(T *samples,
4187  float fx, float fy, float fz) const
4188 {
4189 #if 1
4190  // Do trilinear interpolation.
4191  T vx, vx1, vy, vy1, vz;
4192 
4193  // Lerp x:x+1, y, z
4194  vx = UT_VoxelTile<T>::lerpValues(samples[0],
4195  samples[1],
4196  fx);
4197  // Lerp x:x+1, y+1, z
4198  vx1= UT_VoxelTile<T>::lerpValues(samples[2],
4199  samples[2+1],
4200  fx);
4201  // Lerp x:x+1, y:y+1, z
4202  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4203 
4204  // Lerp x:x+1, y, z+1
4205  vx = UT_VoxelTile<T>::lerpValues(samples[4],
4206  samples[4+1],
4207  fx);
4208  // Lerp x:x+1, y+1, z+1
4209  vx1= UT_VoxelTile<T>::lerpValues(samples[4+2],
4210  samples[4+2+1],
4211  fx);
4212 
4213  // Lerp x:x+1, y:y+1, z+1
4214  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4215 
4216  // Lerp x:x+1, y:y+1, z:z+1
4217  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
4218 
4219  return vz;
4220 #else
4221  v4uf a, b, vfx, vfy, vfz;
4222 
4223  a = v4uf(&samples[0]);
4224  b = v4uf(&samples[4]);
4225 
4226  vfx = v4uf(fx);
4227  vfy = v4uf(fy);
4228  vfz = v4uf(fz);
4229 
4230  b -= a;
4231  a = madd(b, fz, a);
4232 
4233  b = a.swizzle<2, 3, 0, 1>();
4234  b -= a;
4235  a = madd(b, fy, a);
4236 
4237  b = a.swizzle<1, 2, 3, 0>();
4238  b -= a;
4239  a = madd(b, fx, a);
4240 
4241  return a[0];
4242 #endif
4243 }
4244 
4245 template <typename T>
4246 template <int AXIS2D>
4247 T
4248 UT_VoxelArray<T>::lerpSampleAxis(T *samples,
4249  float fx, float fy, float fz) const
4250 {
4251  // Do trilinear interpolation.
4252  T vx, vx1, vy, vy1, vz;
4253 
4254  // Lerp x:x+1, y, z
4255  if (AXIS2D != 0)
4256  vx = UT_VoxelTile<T>::lerpValues(samples[0], samples[1], fx);
4257  else
4258  vx = samples[0];
4259 
4260  if (AXIS2D != 1)
4261  {
4262  // Lerp x:x+1, y+1, z
4263  if (AXIS2D != 0)
4264  vx1= UT_VoxelTile<T>::lerpValues(samples[2], samples[2+1], fx);
4265  else
4266  vx1= samples[2];
4267 
4268  // Lerp x:x+1, y:y+1, z
4269  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4270  }
4271  else
4272  vy = vx;
4273 
4274  if (AXIS2D != 2)
4275  {
4276  // Lerp x:x+1, y, z+1
4277  if (AXIS2D != 0)
4278  vx = UT_VoxelTile<T>::lerpValues(samples[4], samples[4+1], fx);
4279  else
4280  vx = samples[4];
4281 
4282  if (AXIS2D != 1)
4283  {
4284  // Lerp x:x+1, y+1, z+1
4285  if (AXIS2D != 0)
4286  vx1= UT_VoxelTile<T>::lerpValues(samples[4+2], samples[4+2+1], fx);
4287  else
4288  vx1= samples[4+2];
4289 
4290  // Lerp x:x+1, y:y+1, z+1
4291  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4292  }
4293  else
4294  vy1 = vx;
4295 
4296  // Lerp x:x+1, y:y+1, z:z+1
4297  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
4298  }
4299  else
4300  vz = vy;
4301 
4302  return vz;
4303 }
4304 
4305 template <typename T>
4306 T
4307 UT_VoxelArray<T>::operator()(UT_Vector3D pos) const
4308 {
4309  int x, y, z;
4310  // Yes, these have to be 32 becaues split float requires 32!
4311  fpreal32 fx, fy, fz;
4312 
4313  // We go from the position in the unit cube into the index.
4314  // The center of cells must map to the exact integer indices.
4315  pos.x() *= myRes[0];
4316  pos.y() *= myRes[1];
4317  pos.z() *= myRes[2];
4318  pos.x() -= 0.5;
4319  pos.y() -= 0.5;
4320  pos.z() -= 0.5;
4321 
4322  // Determine integer & fractional components.
4323  fx = pos.x();
4324  SYSfastSplitFloat(fx, x);
4325  fy = pos.y();
4326  SYSfastSplitFloat(fy, y);
4327  fz = pos.z();
4328  SYSfastSplitFloat(fz, z);
4329 
4330  // Do trilinear interpolation.
4331  T vx, vx1, vy, vy1, vz;
4332 
4333  // NOTE:
4334  // If you get a crash reading one of these getValues, note
4335  // that if you are reading from the same voxel array that you
4336  // are writing to, and doing so in a multi-threaded, tile-by-tile
4337  // approach, just because your positions match doesn't mean you
4338  // won't access neighbouring tiles. To avoid this, perform
4339  // the obvious optimization of checking for aligned tiles
4340  // and using direct indices.
4341  // (I have avoided using if (!fx && !fy && !fz) as the test
4342  // as that is both potentially inaccurate (round off in conversion
4343  // may mess us up) and said optimzation is a useful one anyways)
4344 
4345  // Optimization for common cases (values are within the voxel range and
4346  // are all within the same tile)
4347  if ( !((x | y | z) < 0) &&
4348  (((x - myRes[0]+1) & (y - myRes[1]+1) & (z - myRes[2]+1)) < 0))
4349  // if ( (x > 0) && (y > 0) && (z > 0) &&
4350  // Do not use x+1 < foo as if x is MAX_INT that will falsely
4351  // report in bounds!
4352  // (x < myRes[0]-1) && (y < myRes[1]-1) && (z < myRes[2]-1) )
4353  {
4354  int xm, ym, zm;
4355 
4356  xm = x & TILEMASK;
4357  ym = y & TILEMASK;
4358  zm = z & TILEMASK;
4359 
4360  if ((xm != TILEMASK) && (ym != TILEMASK) && (zm != TILEMASK))
4361  {
4362  const UT_VoxelTile<T> *tile =
4363  getTile(x >> TILEBITS, y >> TILEBITS, z >> TILEBITS);
4364 
4365  vz = tile->lerp(xm, ym, zm, fx, fy, fz);
4366  }
4367  else
4368  {
4369  // We cross tile boundaries but we remain within
4370  // the voxel grid. We can thus avoid any bounds checking
4371  // and use operator() rather than getValue.
4372 
4373  // Lerp x:x+1, y, z
4374  vx = UT_VoxelTile<T>::lerpValues((*this)(x, y, z),
4375  (*this)(x+1, y, z),
4376  fx);
4377  // Lerp x:x+1, y+1, z
4378  vx1= UT_VoxelTile<T>::lerpValues((*this)(x, y+1, z),
4379  (*this)(x+1, y+1, z),
4380  fx);
4381  // Lerp x:x+1, y:y+1, z
4382  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4383 
4384  // Lerp x:x+1, y, z+1
4385  vx = UT_VoxelTile<T>::lerpValues((*this)(x, y, z+1),
4386  (*this)(x+1, y, z+1),
4387  fx);
4388  // Lerp x:x+1, y+1, z+1
4389  vx1= UT_VoxelTile<T>::lerpValues((*this)(x, y+1, z+1),
4390  (*this)(x+1, y+1, z+1),
4391  fx);
4392 
4393  // Lerp x:x+1, y:y+1, z+1
4394  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4395 
4396  // Lerp x:x+1, y:y+1, z:z+1
4397  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
4398  }
4399  }
4400  else
4401  {
4402  // Lerp x:x+1, y, z
4403  vx = UT_VoxelTile<T>::lerpValues(getValue(x, y, z),
4404  getValue(x+1, y, z),
4405  fx);
4406  // Lerp x:x+1, y+1, z
4407  vx1= UT_VoxelTile<T>::lerpValues(getValue(x, y+1, z),
4408  getValue(x+1, y+1, z),
4409  fx);
4410 
4411  // Lerp x:x+1, y:y+1, z
4412  vy = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4413 
4414  // Lerp x:x+1, y, z+1
4415  vx = UT_VoxelTile<T>::lerpValues(getValue(x, y, z+1),
4416  getValue(x+1, y, z+1),
4417  fx);
4418  // Lerp x:x+1, y+1, z+1
4419  vx1= UT_VoxelTile<T>::lerpValues(getValue(x, y+1, z+1),
4420  getValue(x+1, y+1, z+1),
4421  fx);
4422 
4423  // Lerp x:x+1, y:y+1, z+1
4424  vy1 = UT_VoxelTile<T>::lerpValues(vx, vx1, fy);
4425 
4426  // Lerp x:x+1, y:y+1, z:z+1
4427  vz = UT_VoxelTile<T>::lerpValues(vy, vy1, fz);
4428  }
4429 
4430  return vz;
4431 }
4432 
4433 #if 0
4434 template <typename T>
4435 T
4436 UT_VoxelArray<T>::operator()(v4uf pos) const
4437 {
4438  int x, y, z;
4439 
4440  v4ui idx;
4441 
4442  // We go from the position in the unit cube into the index.
4443  // The center of cells must map to the exact integer indices.
4444  pos *= v4uf((float) myRes[0], (float) myRes[1], (float) myRes[2], 0.0f);
4445 
4446  // Because we use truncation we'll get inaccurate results
4447  // at the zero boundary, we thus bump up by two
4448  pos += 1.5;
4449 
4450  idx = pos.splitFloat();
4451 
4452  // And counteract that bump
4453  idx -= 2;
4454 
4455  x = idx[0];
4456  y = idx[1];
4457  z = idx[2];
4458 
4459  // Do trilinear interpolation.
4460  // A | B
4461  // 0 +z +y +yz | +x +xz +xy +xyz
4462 
4463  v4uf a, b, fx, fy, fz;
4464 
4465  int xm, ym, zm;
4466 
4467  xm = x & TILEMASK;
4468  ym = y & TILEMASK;
4469  zm = z & TILEMASK;
4470 
4471  // Optimization for common case (values are within the voxel range and
4472  // are all within the same tile)
4473  if ( (x > 0) & (y > 0) & (z > 0) &
4474  (x < myRes[0]-1) & (y < myRes[1]-1) & (z < myRes[2]-1) &
4475  (xm != TILEMASK) & (ym != TILEMASK) & (zm != TILEMASK) )
4476 /*
4477  if (isValidIndex(x, y, z) && isValidIndex(x+1, y+1, z+1) &&
4478  (x & TILEMASK) != TILEMASK &&
4479  (y & TILEMASK) != TILEMASK &&
4480  (z & TILEMASK) != TILEMASK)
4481 */
4482  {
4483  const UT_VoxelTile<T> *tile =
4484  getTile(x >> TILEBITS, y >> TILEBITS, z >> TILEBITS);
4485 
4486  return tile->lerp(pos, xm, ym, zm);
4487  }
4488  else
4489  {
4490  a = v4uf( getValue(x, y, z),
4491  getValue(x, y, z+1),
4492  getValue(x, y+1, z),
4493  getValue(x, y+1, z+1) );
4494  b = v4uf( getValue(x+1, y, z),
4495  getValue(x+1, y, z+1),
4496  getValue(x+1, y+1, z),
4497  getValue(x+1, y+1, z+1) );
4498  }
4499 
4500  fx = pos.swizzle<0, 0, 0, 0>();
4501  fy = pos.swizzle<1, 1, 1, 1>();
4502  fz = pos.swizzle<2, 2, 2, 2>();
4503 
4504  b -= a;
4505  a = madd(b, fx, a);
4506 
4507  b = a.swizzle<2, 3, 0, 1>();
4508  b -= a;
4509  a = madd(b, fy, a);
4510 
4511  b = a.swizzle<1, 2, 3, 0>();
4512  b -= a;
4513  a = madd(b, fz, a);
4514 
4515  return a[0];
4516 }
4517 #endif
4518 
4519 static inline int
4520 firstTile(int &start, int &end, int res)
4521 {
4522  if (start < 0)
4523  {
4524  start += res;
4525  end += res;
4526  }
4527  return start;
4528 }
4529 
4530 static inline int
4531 nextTile(int &tile, int &pstart, int &start, int &end, int res)
4532 {
4533  int pend;
4534 
4535  if (pstart >= res)
4536  {
4537  pstart -= res;
4538  start -= res;
4539  end -= res;
4540  }
4541  tile = pstart >> TILEBITS;
4542  pend = SYSmin((tile+1) * TILESIZE, end, res);
4543 
4544  UT_ASSERT(pstart >= 0 && pstart < res);
4545  UT_ASSERT(pend > 0 && pstart <= res);
4546  UT_ASSERT(pend-pstart > 0);
4547  UT_ASSERT(pend-pstart <= TILESIZE);
4548 
4549  return pend;
4550 }
4551 
4552 template <typename T>
4553 T
4554 UT_VoxelArray<T>::evaluate(const UT_Vector3 &pos, const UT_Filter &filter,
4555  fpreal radius, int clampaxis) const
4556 {
4557  UT_Vector3 tpos;
4558  UT_FilterWindow win[3];
4559  UT_FilterWrap wrap[3];
4560  UT_VoxelTile<T> *tile;
4561  const float *weights[3];
4562  fpreal visible;
4563  int start[3], end[3], size[3];
4564  int pstart[3], pend[3];
4565  int tx, ty, tz, i;
4566  T result;
4567 
4568  if (!myTiles)
4569  {
4570  // If the array is empty, just use the border value.
4571  return myBorderValue;
4572  }
4573 
4574  UT_FilterWrap basewrap;
4575  switch (myBorderType)
4576  {
4577  case UT_VOXELBORDER_CONSTANT: basewrap = UT_WRAP_BORDER; break;
4578  case UT_VOXELBORDER_REPEAT: basewrap = UT_WRAP_REPEAT; break;
4579  case UT_VOXELBORDER_STREAK: basewrap = UT_WRAP_CLAMP; break;
4580 
4581  // NOTE: These are incorrect!
4582  case UT_VOXELBORDER_MIRROR: basewrap = UT_WRAP_CLAMP; break;
4583  case UT_VOXELBORDER_EXTRAP: basewrap = UT_WRAP_CLAMP; break;
4584  default: basewrap = UT_WRAP_CLAMP; break;
4585  }
4586  for (i = 0; i < 3; i++)
4587  {
4588  if (i == clampaxis)
4589  wrap[i] = UT_WRAP_CLAMP;
4590  else
4591  wrap[i] = basewrap;
4592  }
4593 
4594  memset(&result, 0, sizeof(result));
4595 
4596  radius *= filter.getSupport();
4597 
4598  // Make a local copy of the position so that we can modify it.
4599  tpos = pos;
4600  visible = 1;
4601  for (i = 0; i < 3; i++)
4602  {
4603  tpos[i] = tpos[i]*myRes[i];
4604  if (!win[i].setWeights(filter, tpos[i], radius, myRes[i], wrap[i]))
4605  return result;
4606 
4607  weights[i] = win[i].getWeights();
4608  start[i] = win[i].getStart() % myRes[i];
4609  size[i] = win[i].getSize();
4610 
4611  UT_ASSERT(start[i] >= 0);
4612  UT_ASSERT(size[i] <= myRes[i]);
4613 
4614  end[i] = start[i] + size[i];
4615  visible *= win[i].getVisible();
4616  }
4617 
4618  // Accumulate filtered results
4619  pstart[2] = firstTile(start[2], end[2], myRes[2]);
4620  while (pstart[2] < end[2])
4621  {
4622  pend[2] = nextTile(tz, pstart[2], start[2], end[2], myRes[2]);
4623  pstart[1] = firstTile(start[1], end[1], myRes[1]);
4624  while (pstart[1] < end[1])
4625  {
4626  pend[1] = nextTile(ty, pstart[1], start[1], end[1], myRes[1]);
4627  pstart[0] = firstTile(start[0], end[0], myRes[0]);
4628  while (pstart[0] < end[0])
4629  {
4630  pend[0] = nextTile(tx, pstart[0], start[0], end[0], myRes[0]);
4631  tile = getTile(tx, ty, tz);
4632  UT_ASSERT(tile);
4633  tile->weightedSum(pstart, pend, weights, start, result);
4634  pstart[0] = pend[0];
4635  }
4636  pstart[1] = pend[1];
4637  }
4638  pstart[2] = pend[2];
4639  }
4640 
4641  if (visible < 1)
4642  {
4643  result += (1-visible)*myBorderValue;
4644  }
4645 
4646  return result;
4647 }
4648 
4649 template <typename T>
4650 T
4651 UT_VoxelArray<T>::avgNonZero(const UT_Vector3 &pos, const UT_Filter &filter,
4652  fpreal radius, int clampaxis) const
4653 {
4654  UT_Vector3 tpos;
4655  UT_FilterWindow win[3];
4656  UT_FilterWrap wrap[3];
4657  UT_VoxelTile<T> *tile;
4658  int start[3], end[3], size[3];
4659  int pstart[3], pend[3];
4660  int tx, ty, tz, i;
4661  T result;
4662 
4663  if (!myTiles)
4664  {
4665  // If the array is empty, just use the border value.
4666  return myBorderValue;
4667  }
4668 
4669  UT_FilterWrap basewrap;
4670  switch (myBorderType)
4671  {
4672  case UT_VOXELBORDER_CONSTANT: basewrap = UT_WRAP_BORDER; break;
4673  case UT_VOXELBORDER_REPEAT: basewrap = UT_WRAP_REPEAT; break;
4674  case UT_VOXELBORDER_STREAK: basewrap = UT_WRAP_CLAMP; break;
4675 
4676  // NOTE: These are incorrect!
4677  case UT_VOXELBORDER_MIRROR: basewrap = UT_WRAP_CLAMP; break;
4678  case UT_VOXELBORDER_EXTRAP: basewrap = UT_WRAP_CLAMP; break;
4679  default: basewrap = UT_WRAP_CLAMP; break;
4680  }
4681  for (i = 0; i < 3; i++)
4682  {
4683  if (i == clampaxis)
4684  wrap[i] = UT_WRAP_CLAMP;
4685  else
4686  wrap[i] = basewrap;
4687  }
4688 
4689  memset(&result, 0, sizeof(result));
4690 
4691  radius *= filter.getSupport();
4692 
4693  // Make a local copy of the position so that we can modify it.
4694  tpos = pos;
4695  for (i = 0; i < 3; i++)
4696  {
4697  tpos[i] = tpos[i]*myRes[i];
4698  if (!win[i].setWeights(filter, tpos[i], radius, myRes[i], wrap[i]))
4699  return result;
4700 
4701  start[i] = win[i].getStart() % myRes[i];
4702  size[i] = win[i].getSize();
4703 
4704  UT_ASSERT(start[i] >= 0);
4705  UT_ASSERT(size[i] <= myRes[i]);
4706 
4707  end[i] = start[i] + size[i];
4708  }
4709 
4710  // Accumulate filtered results
4711  pstart[2] = firstTile(start[2], end[2], myRes[2]);
4712  while (pstart[2] < end[2])
4713  {
4714  pend[2] = nextTile(tz, pstart[2], start[2], end[2], myRes[2]);
4715  pstart[1] = firstTile(start[1], end[1], myRes[1]);
4716  while (pstart[1] < end[1])
4717  {
4718  pend[1] = nextTile(ty, pstart[1], start[1], end[1], myRes[1]);
4719  pstart[0] = firstTile(start[0], end[0], myRes[0]);
4720  while (pstart[0] < end[0])
4721  {
4722  pend[0] = nextTile(tx, pstart[0], start[0], end[0], myRes[0]);
4723  tile = getTile(tx, ty, tz);
4724  UT_ASSERT(tile);
4725  tile->avgNonZero(pstart, pend, start, result);
4726  pstart[0] = pend[0];
4727  }
4728  pstart[1] = pend[1];
4729  }
4730  pstart[2] = pend[2];
4731  }
4732 
4733  return result;
4734 }
4735 
4736 template <typename T>
4737 void
4738 UT_VoxelArray<T>::resample(const UT_VoxelArray<T> &src,
4739  UT_FilterType filtertype,
4740  float filterwidthscale,
4741  int clampaxis)
4742 {
4743  fpreal radius;
4744  UT_Filter *filter;
4745 
4746  filter = UT_Filter::getFilter(filtertype);
4747 
4748  radius = SYSmax( src.getXRes() / (fpreal)getXRes(),
4749  src.getYRes() / (fpreal)getYRes(),
4750  src.getZRes() / (fpreal)getZRes(),
4751  1.0f );
4752  radius *= 0.5 * filterwidthscale;
4753 
4754  resamplethread(src, filter, radius, clampaxis);
4755 
4756  UT_Filter::releaseFilter(filter);
4757 }
4758 
4759 template <typename T>
4760 template <typename OP>
4761 void
4762 UT_VoxelArray<T>::forEachTile(const OP &op, bool shouldthread)
4763 {
4764  auto blockop = [&op, this](const UT_BlockedRange<int> &range)
4765  {
4766  UT_VoxelTileIterator<T> vit;
4767  for (int tileidx = range.begin(); tileidx != range.end(); tileidx++)
4768  {
4769  vit.setLinearTile(tileidx, this);
4770  op(vit);
4771  }
4772  };
4773 
4774  if (!shouldthread)
4775  {
4776  UTserialForEachNumber(numTiles(), blockop);
4777  }
4778  else
4779  {
4780  UTparallelForEachNumber(numTiles(), blockop);
4781  }
4782 }
4783 
4784 template <typename T>
4785 void
4786 UT_VoxelArray<T>::flattenPartial(T *flatarray, exint ystride, exint zstride,
4787  const UT_JobInfo &info) const
4788 {
4789  // Check to see if we are 2d, if so, we wish to use the
4790  // axis flatten.
4791  if (getXRes() == 1 && ystride == 1)
4792  {
4793  flattenPartialAxis<0>(flatarray, zstride, info);
4794  }
4795  else if (getYRes() == 1 && zstride == ystride)
4796  {
4797  flattenPartialAxis<1>(flatarray, zstride, info);
4798  }
4799  else if (getZRes() == 1)
4800  {
4801  flattenPartialAxis<2>(flatarray, ystride, info);
4802  }
4803  else
4804  {
4805  UT_VoxelArrayIterator<T> vit;
4806 
4807  // Const cast.
4808  vit.setArray((UT_VoxelArray<T> *)this);
4809  // We can't use splitByTile as then our writes will fight
4810  // over 4k pages.
4811  vit.setPartialRange(info.job(), info.numJobs());
4812 
4813  for (vit.rewind(); !vit.atEnd(); vit.advance())
4814  {
4815  flatarray[vit.x() + vit.y()*ystride + vit.z()*zstride] = vit.getValue();
4816  }
4817  }
4818 }
4819 
4820 
4821 template <typename T>
4822 template <int AXIS2D>
4823 void
4824 UT_VoxelArray<T>::flattenPartialAxis(T *flatarray, exint ystride,
4825  const UT_JobInfo &info) const
4826 {
4827  // The x/y refer to the destination x/y.
4828  // The actual source index depends on AXIS2D.
4829  const int ax = (AXIS2D == 0) ? 1 : 0;
4830  const int ay = (AXIS2D == 2) ? 1 : 2;
4831  int tileidx[3] = { 0, 0, 0 };
4832 
4833  while (1)
4834  {
4835  exint tiley = info.nextTask();
4836  exint ystart = tiley * TILESIZE;
4837  if (ystart >= getRes(ay))
4838  break;
4839 
4840  T *stripe = &flatarray[ystart * ystride];
4841 
4842  int yres = SYSmin(getRes(ay) - ystart, TILESIZE);
4843 
4844  for (int tilex = 0, ntilex = getTileRes(ax); tilex < ntilex; tilex++)
4845  {
4846  tileidx[ax] = tilex;
4847  tileidx[ay] = tiley;
4848  auto tile = getTile(tileidx[0], tileidx[1], tileidx[2]);
4849 
4850  int xres = tile->getRes(ax);
4851  T *stripey = stripe;
4852  if (tile->isConstant())
4853  {
4854  const T *srcdata = tile->rawData();
4855 
4856  for (int y = 0; y < yres; y++)
4857  {
4858  for (int x = 0; x < xres; x++)
4859  {
4860  memcpy(&stripey[x], srcdata, sizeof(T));
4861  }
4862  stripey += ystride;
4863  }
4864  }
4865  else if (tile->isSimpleCompression())
4866  {
4867  const T *srcdata = tile->rawData();
4868 
4869  if (xres != TILESIZE)
4870  {
4871  for (int y = 0; y < yres; y++)
4872  {
4873  memcpy(stripey, srcdata, sizeof(T) * xres);
4874  srcdata += xres;
4875  stripey += ystride;
4876  }
4877  }
4878  else
4879  {
4880  for (int y = 0; y < yres; y++)
4881  {
4882  memcpy(stripey, srcdata, sizeof(T) * TILESIZE);
4883  srcdata += TILESIZE;
4884  stripey += ystride;
4885  }
4886  }
4887  }
4888  else
4889  {
4890  for (int y = 0; y < yres; y++)
4891  {
4892  int idx[3] = { 0, 0, 0 };
4893  idx[ay] = y;
4894  for (int x = 0; x < xres; x++)
4895  {
4896  idx[ax] = x;
4897  stripey[x] = (*tile)(idx[0], idx[1], idx[2]);
4898  }
4899  stripey += ystride;
4900  }
4901  }
4902 
4903  stripe += TILESIZE;
4904  }
4905  }
4906 }
4907 
4908 
4909 template <>
4910 inline void
4911 UT_VoxelArray<UT_Vector4F>::flattenGLFixed8Partial(uint8 *flatarray,
4912  exint ystride, exint zstride,
4913  UT_Vector4F,
4914  const UT_JobInfo &info) const
4915 {
4916  UT_VoxelArrayIterator<UT_Vector4F> vit;
4917 
4918  // Const cast.
4919  vit.setArray(SYSconst_cast(this));
4920  // We can't use splitByTile as then our writes will fight
4921  // over 4k pages.
4922  vit.setPartialRange(info.job(), info.numJobs());
4923 
4924  for (vit.rewind(); !vit.atEnd(); vit.advance())
4925  {
4926  UT_Vector4F v = vit.getValue();
4927  int idx = (vit.x() + vit.y()*ystride + vit.z()*zstride) * 4;
4928 
4929  flatarray[idx] = (uint8) SYSclamp(v.x() * 255.0f, 0.0f, 255.0f);
4930  flatarray[idx+1] = (uint8) SYSclamp(v.y() * 255.0f, 0.0f, 255.0f);
4931  flatarray[idx+2] = (uint8) SYSclamp(v.z() * 255.0f, 0.0f, 255.0f);
4932  flatarray[idx+3] = (uint8) SYSclamp(v.w() * 255.0f, 0.0f, 255.0f);
4933  }
4934 }
4935 
4936 template <typename T>
4937 void
4938 UT_VoxelArray<T>::flattenGLFixed8Partial(uint8 *flatarray,
4939  exint ystride, exint zstride,
4940  T, const UT_JobInfo &info) const
4941 {
4942  UT_ASSERT(!"This template requires specific instantiations.");
4943 }
4944 
4945 template <>
4946 inline void
4947 UT_VoxelArray<UT_Vector4F>::flattenGL16FPartial(UT_Vector4H *flatarray,
4948  exint ystride, exint zstride,
4949  UT_Vector4F,
4950  const UT_JobInfo &info) const
4951 {
4952  UT_VoxelArrayIterator<UT_Vector4F> vit;
4953 
4954  // Const cast.
4955  vit.setArray(SYSconst_cast(this));
4956  // We can't use splitByTile as then our writes will fight
4957  // over 4k pages.
4958  vit.setPartialRange(info.job(), info.numJobs());
4959 
4960  for (vit.rewind(); !vit.atEnd(); vit.advance())
4961  flatarray[vit.x() + vit.y()*ystride + vit.z()*zstride] = vit.getValue();
4962 }
4963 
4964 template <typename T>
4965 void
4966 UT_VoxelArray<T>::flattenGL16FPartial(UT_Vector4H *flatarray,
4967  exint ystride, exint zstride,
4968  T, const UT_JobInfo &info) const
4969 {
4970  UT_ASSERT(!"This template requires specific instantiations.");
4971 }
4972 
4973 template <>
4974 inline void
4975 UT_VoxelArray<UT_Vector4F>::flattenGL32FPartial(UT_Vector4F *flatarray,
4976  exint ystride, exint zstride,
4977  UT_Vector4F,
4978  const UT_JobInfo &info) const
4979 {
4980  UT_VoxelArrayIterator<UT_Vector4F> vit;
4981 
4982  // Const cast.
4983  vit.setArray(SYSconst_cast(this));
4984  // We can't use splitByTile as then our writes will fight
4985  // over 4k pages.
4986  vit.setPartialRange(info.job(), info.numJobs());
4987 
4988  for (vit.rewind(); !vit.atEnd(); vit.advance())
4989  {
4990  UT_Vector4F v = vit.getValue();
4991 
4992  // NOTE: This works around an Nvidia driver bug on OSX, and older
4993  // Nvidia drivers on other platforms. The problem was that very
4994  // small FP values were causing huge random values to appear in
4995  // the 3D Texture.
4996  if(SYSabs(v.x()) < 1e-9)
4997  v.x() = 0.0;
4998  if(SYSabs(v.y()) < 1e-9)
4999  v.y() = 0.0;
5000  if(SYSabs(v.z()) < 1e-9)
5001  v.z() = 0.0;
5002  if(SYSabs(v.w()) < 1e-9)
5003  v.w() = 0.0;
5004 
5005  flatarray[vit.x() + vit.y()*ystride + vit.z()*zstride] = v;
5006  }
5007 }
5008 
5009 template <typename T>
5010 void
5011 UT_VoxelArray<T>::flattenGL32FPartial(UT_Vector4F *flatarray,
5012  exint ystride, exint zstride,
5013  T,const UT_JobInfo &info) const
5014 {
5015  UT_ASSERT(!"This template requires specific instantiations.");
5016 }
5017 
5018 
5019 template <typename T>
5020 void
5021 UT_VoxelArray<T>::extractFromFlattenedPartial(const T *flatarray,
5022  exint ystride, exint zstride,
5023  const UT_JobInfo &info)
5024 {
5025  UT_VoxelArrayIterator<T> vit;
5026 
5027  vit.setArray(this);
5028  vit.splitByTile(info);
5029  vit.setCompressOnExit(true);
5030 
5031  for (vit.rewind(); !vit.atEnd(); vit.advance())
5032  {
5033  vit.setValue(flatarray[vit.x() + vit.y()*ystride + vit.z()*zstride]);
5034  }
5035 }
5036 
5037 template <typename T>
5038 template <int SLICE, typename S>
5039 S *
5040 UT_VoxelArray<T>::extractSlice(S *dstdata, int slice, bool half_slice) const
5041 {
5042  int slice_res = getRes(SLICE);
5043  // Exit out early if the slice isn't inside the array proper.
5044  if (slice < 0 || slice >= slice_res ||
5045  (half_slice && slice == slice_res - 1))
5046  return nullptr;
5047 
5048  constexpr int AXIS1 = SLICE == 0 ? 2 : 0;
5049  constexpr int AXIS2 = SLICE == 1 ? 2 : 1;
5050 
5051  // Voxel resolution along the major axis of the voxel array.
5052  int a1_res = getRes(AXIS1);
5053  // Tile resolutions of the voxel array.
5054  int a1_tiles = getTileRes(AXIS1);
5055  int a2_tiles = getTileRes(AXIS2);
5056  int ntiles = a1_tiles * a2_tiles;
5057  // Strides used to figure out the starting index of each tile's voxels in
5058  // the destination array.
5059  int tile_stride2 = (a1_res << TILEBITS);
5060  int tile_stride1 = TILESIZE;
5061  // Index of the tile for the slice and the local coordinate within it.
5062  int tile_slice = (slice >> TILEBITS);
5063  int local_slice = (slice & TILEMASK);
5064  // If half_slice_st is true, we are averaging two voxel slices which lie
5065  // within the same tile slices.
5066  bool half_slice_st = half_slice && (local_slice != TILEMASK);
5067  // If half_slice_tb is true, we are averaging current value of dstdata with
5068  // the tile's values.
5069  bool half_slice_tb = false;
5070 
5071  // This functor sets the destination array value. idx might get changed
5072  // internally, but it comes out the way it went in.
5073  // Behaviour of this function is controlled by the following booleans, in
5074  // this order.
5075  // * half_slice_st: sets the value to the average of tile values at local
5076  // local idx and one offset along SLICE by 1;
5077  // * half_slice_tb: sets the value to the average between the current value
5078  // in the destination array and the tile's value at the local idx;
5079  // * when neither of the above is true, sets to tile's value at the local
5080  // idx.
5081  auto set_functor = [&](const UT_VoxelTile<T>* tile, int idx[3], int vidx)
5082  {
5083  if (half_slice_st)
5084  {
5085  dstdata[vidx] = (*tile)(idx[0], idx[1], idx[2]);
5086  idx[SLICE]++;
5087  dstdata[vidx] = 0.5f * (dstdata[vidx] +
5088  (*tile)(idx[0], idx[1], idx[2]));
5089  idx[SLICE]--;
5090  }
5091  else if (half_slice_tb)
5092  dstdata[vidx] = 0.5f * (dstdata[vidx] +
5093  (*tile)(idx[0], idx[1], idx[2]));
5094  else
5095  dstdata[vidx] = (*tile)(idx[0], idx[1], idx[2]);
5096  };
5097  // This functor will be executed by the multithreaded loop below. Uses
5098  // set_functor to write the correct value into dstdata.
5099  auto loop_functor = [&](const UT_BlockedRange<int>& range)
5100  {
5101  // Tile index array.
5102  int is[3];
5103  is[SLICE] = tile_slice;
5104  // Array of indices within the tile.
5105  int is_local[3];
5106  is_local[SLICE] = local_slice;
5107 
5108  for (int i = range.begin(); i < range.end(); i++)
5109  {
5110  // Figure out coordinates of the current tile.
5111  is[AXIS1] = i % a1_tiles;
5112  is[AXIS2] = i / a1_tiles;
5113 
5114  // Get the current tile and its size.
5115  const UT_VoxelTile<T>* tile = getTile(is[0], is[1], is[2]);
5116  int a1_tile_res = tile->getRes(AXIS1);
5117  int a2_tile_res = tile->getRes(AXIS2);
5118  // Get the index we should write this tile to.
5119  int vcounter = is[AXIS2] * tile_stride2 + is[AXIS1] * tile_stride1;
5120 
5121  for (is_local[AXIS2] = 0; is_local[AXIS2] < a2_tile_res;
5122  is_local[AXIS2]++)
5123  {
5124  for (is_local[AXIS1] = 0; is_local[AXIS1] < a1_tile_res;
5125  is_local[AXIS1]++)
5126  {
5127  set_functor(tile, is_local, vcounter);
5128  vcounter++;
5129  }
5130  // Wrap the counter to the next row.
5131  vcounter += a1_res - a1_tile_res;
5132  }
5133  }
5134  };
5135 
5136  // Run the loop.
5137  UTparallelFor(UT_BlockedRange<int>(0, ntiles), loop_functor);
5138 
5139  // If we're halfway between two voxel slices that lie in different tiles, we
5140  // need to do another sweep and modify the results.
5141  if (half_slice && !half_slice_st)
5142  {
5143  half_slice_tb = true;
5144  tile_slice++;
5145  local_slice = 0;
5146  UTparallelFor(UT_BlockedRange<int>(0, ntiles), loop_functor);
5147  }
5148 
5149  return dstdata;
5150 }
5151 
5152 template <typename T>
5153 template <typename S>
5154 S *
5155 UT_VoxelArray<T>::extractTiles(S *dstdata, int stride,
5156  const UT_IntArray &tilelist) const
5157 {
5158  for (int i = 0; i < tilelist.entries(); i++)
5159  {
5160  UT_ASSERT(tilelist(i) >= 0 && tilelist(i) < numTiles());
5161  const UT_VoxelTile<T> *tile = getLinearTile(tilelist(i));
5162 
5163  tile->flatten(dstdata, stride);
5164  dstdata += tile->numVoxels() * stride;
5165  }
5166  return dstdata;
5167 }
5168 
5169 template <typename T>
5170 template <typename S, typename IDX>
5171 S *
5172 UT_VoxelArray<T>::extractTiles(S *dstdata, int stride,
5173  const IDX *ix, const IDX *iy, const IDX *iz,
5174  const UT_Array<UT_VoxelArrayTileDataDescr> &tilelist) const
5175 {
5176  int srcidx = 0;
5177 
5178  for (auto && tiledata : tilelist)
5179  {
5180  int tileidx = tiledata.tileidx;
5181  UT_ASSERT(tileidx >= 0 && tileidx < numTiles());
5182 
5183  const UT_VoxelTile<T> *tile = getLinearTile(tileidx);
5184  int tilevoxel = tile->numVoxels();
5185 
5186  if (tilevoxel == tiledata.numvoxel)
5187  {
5188  // Full tile.
5189  tile->flatten(dstdata, stride);
5190  dstdata += tiledata.numvoxel * stride;
5191  srcidx += tiledata.numvoxel;
5192  }
5193  else
5194  {
5195  // Partial tile...
5196  int basex, basey, basez;
5197  linearTileToXYZ(tileidx, basex, basey, basez);
5198 
5199  basex <<= TILEBITS;
5200  basey <<= TILEBITS;
5201  basez <<= TILEBITS;
5202 
5203  if (tile->isSimpleCompression())
5204  {
5205  const T *src = tile->rawData();
5206  if (tile->isConstant())
5207  {
5208  S cval = *src;
5209  for (int i = 0; i < tiledata.numvoxel; i++)
5210  {
5211  *dstdata = cval;
5212  dstdata += stride;
5213  srcidx++;
5214  }
5215  }
5216  else
5217  {
5218  int w = tile->xres();
5219  int h = tile->yres();
5220  for (int i = 0; i < tiledata.numvoxel; i++)
5221  {
5222  UT_ASSERT_P(ix[srcidx] >= basex && ix[srcidx] < basex+TILESIZE);
5223  UT_ASSERT_P(iy[srcidx] >= basey && iy[srcidx] < basey+TILESIZE);
5224  UT_ASSERT_P(iz[srcidx] >= basez && iz[srcidx] < basez+TILESIZE);
5225  *dstdata = src[ (ix[srcidx] - basex)
5226  + (iy[srcidx] - basey) * w
5227  + (iz[srcidx] - basez) * w * h];
5228  dstdata += stride;
5229  srcidx++;
5230  }
5231  }
5232  }
5233  else
5234  {
5235  for (int i = 0; i < tiledata.numvoxel; i++)
5236  {
5237  UT_ASSERT_P(ix[srcidx] >= basex && ix[srcidx] < basex+TILESIZE);
5238  UT_ASSERT_P(iy[srcidx] >= basey && iy[srcidx] < basey+TILESIZE);
5239  UT_ASSERT_P(iz[srcidx] >= basez && iz[srcidx] < basez+TILESIZE);
5240  *dstdata = (*tile)(ix[srcidx] - basex,
5241  iy[srcidx] - basey,
5242  iz[srcidx] - basez);
5243  dstdata += stride;
5244  srcidx++;
5245  }
5246  }
5247  }
5248  }
5249  return dstdata;
5250 }
5251 
5252 template <typename T>
5253 template <typename S>
5254 const S *
5255 UT_VoxelArray<T>::writeTiles(const S *srcdata, int stride,
5256  const UT_IntArray &tilelist)
5257 {
5258  bool docompress = getCompressionOptions().compressionEnabled();
5259  for (int i = 0; i < tilelist.entries(); i++)
5260  {
5261  UT_ASSERT(tilelist(i) >= 0 && tilelist(i) < numTiles());
5262  UT_VoxelTile<T> *tile = getLinearTile(tilelist(i));
5263 
5264  tile->writeData(srcdata, stride);
5265  if (docompress)
5266  tile->tryCompress(getCompressionOptions());
5267  srcdata += tile->numVoxels() * stride;
5268  }
5269  return srcdata;
5270 }
5271 
5272 template <typename T>
5273 template <typename S, typename IDX>
5274 const S *
5275 UT_VoxelArray<T>::writeTiles(const S *srcdata, int stride,
5276  const IDX *ix, const IDX *iy, const IDX *iz,
5277  const UT_Array<UT_VoxelArrayTileDataDescr> &tilelist)
5278 {
5279  bool docompress = getCompressionOptions().compressionEnabled();
5280  int srcidx = 0;
5281 
5282  for (auto && tiledata : tilelist)
5283  {
5284  int tileidx = tiledata.tileidx;
5285  UT_ASSERT(tileidx >= 0 && tileidx < numTiles());
5286 
5287  UT_VoxelTile<T> *tile = getLinearTile(tileidx);
5288  int tilevoxel = tile->numVoxels();
5289 
5290  if (tilevoxel == tiledata.numvoxel)
5291  {
5292  tile->writeData(srcdata, stride);
5293  srcdata += tiledata.numvoxel * stride;
5294  srcidx += tiledata.numvoxel;
5295  }
5296  else
5297  {
5298  // Partial tile.
5299  int basex, basey, basez;
5300  linearTileToXYZ(tileidx, basex, basey, basez);
5301 
5302  basex <<= TILEBITS;
5303  basey <<= TILEBITS;
5304  basez <<= TILEBITS;
5305 
5306  for (int i = 0; i < tiledata.numvoxel; i++)
5307  {
5308  UT_ASSERT_P(ix[srcidx] >= basex && ix[srcidx] < basex+TILESIZE);
5309  UT_ASSERT_P(iy[srcidx] >= basey && iy[srcidx] < basey+TILESIZE);
5310  UT_ASSERT_P(iz[srcidx] >= basez && iz[srcidx] < basez+TILESIZE);
5311  tile->setValue(ix[srcidx] - basex,
5312  iy[srcidx] - basey,
5313  iz[srcidx] - basez,
5314  *srcdata);
5315  srcdata += stride;
5316  srcidx++;
5317  }
5318  }
5319 
5320  if (docompress)
5321  tile->tryCompress(getCompressionOptions());
5322  }
5323  return srcdata;
5324 }
5325 
5326 ///
5327 /// This helper class can be used for iterating over a voxel array in relation to another
5328 /// one. In particular, dst is the destination voxel array that is to be iterated over; its
5329 /// tile at [X, Y, Z] is taken to be coincident with tile [X + xoff, Y + yoff, Z + zoff] of
5330 /// src. Tiles of dst are partitioned into two sets:
5331 /// - BP (boundary pass): these are tiles of dst that are coincident with tiles of src that
5332 /// are at the boundary (so they affect extrapolation);
5333 /// - IP (internal pass): these tiles are coincident with internal tiles of src (those that
5334 /// are irrelevant for extrapolation).
5335 /// Once created, an object of this class can return the number of tiles in each set and
5336 /// convert from a linear 0-N index to [X, Y, Z] coordinates that identify the tile within
5337 /// dst.
5338 ///
5339 /// This class can be roughly used as follows... Main function:
5340 ///
5341 /// __linearTileIndexConverter index(dst, src, xoff, yoff, zoff);
5342 /// customFunctionBP(..., index);
5343 /// customFunctionIP(..., index);
5344 ///
5345 /// BPPartial(..., const __linearTileIndexConverter& index, const UT_JobInfo& i) function:
5346 ///
5347 /// int t0, t1;
5348 /// i.divideWork(index.getNTilesBP(), t0, t1);
5349 /// for (int j = t0; j < t1; j++)
5350 /// {
5351 /// int x, y, z;
5352 /// index.toLinearBP(j, x, y, z);
5353 /// UT_VoxerTile<T>* dtile = src.getTile(x, y, z);
5354 /// ...
5355 /// }
5356 ///
5357 /// With a similar implementation for IP. See moveTilesWithOffset() for an example.
5358 ///
5359 class __linearTileIndexConverter
5360 {
5361 public:
5362  /// Creates an index converter from the given voxel arrays. This object partitions tiles
5363  /// of dst into those that are affected by
5364  template <typename T>
5365  __linearTileIndexConverter(const UT_VoxelArray<T>* dst,
5366  const UT_VoxelArray<T>* src,
5367  int xoff, int yoff, int zoff)
5368  {
5369  myXMax = dst->getTileRes(0);
5370  myYMax = dst->getTileRes(1);
5371  myZMax = dst->getTileRes(2);
5372 
5373  // If source has a constant border, no tile affects extrapolation; so all tiles
5374  // can be put into IP. Otherwise, the outer layer of src's tiles are part of BP.
5375  int m = (src->getBorder() == UT_VOXELBORDER_CONSTANT) ? 0 : 1;
5376  myXSkipMin = SYSmax(m - xoff, 0);
5377  myXSkipLen =
5378  SYSmax(SYSmin(myXMax, src->getTileRes(0) - xoff - m) - myXSkipMin, 0);
5379  myYSkipMin = SYSmax(m - yoff, 0);
5380  myYSkipLen =
5381  SYSmax(SYSmin(myYMax, src->getTileRes(1) - yoff - m) - myYSkipMin, 0);
5382  myZSkipMin = SYSmax(m - zoff, 0);
5383  myZSkipLen =
5384  SYSmax(SYSmin(myZMax, src->getTileRes(2) - zoff - m) - myZSkipMin, 0);
5385  }
5386 
5387  /// Returns the number of tiles in each part.
5388  int getNTilesBP() const
5389  {
5390  return myXMax * myYMax * myZMax - getNTilesIP();
5391  }
5392  int getNTilesIP() const
5393  {
5394  return myXSkipLen * myYSkipLen * myZSkipLen;
5395  }
5396 
5397  /// Converts a linear index (between 0 and getNTiles*P()-1) to the [X, Y, Z] tile
5398  /// coordinate with respect to dst.
5399  void toLinearBP(int k, int& x, int& y, int& z) const
5400  {
5401  // Number of voxels before the first Z slice with a hole.
5402  const int check_0 = myXMax * myYMax * myZSkipMin;
5403  // Check if we are before the first Z slice of the hole or if there is no hole.
5404  if (myXSkipLen == 0 || myYSkipLen == 0 || myZSkipLen == 0 || k < check_0)
5405  {
5406  _toRegularLinear(k, myXMax, myYMax, x, y, z);
5407  return;
5408  }
5409  k -= check_0;
5410 
5411  // Number of voxels per Z-slice with a hole.
5412  const int check_1a = myXMax * myYMax - myXSkipLen * myYSkipLen;
5413  // Total number of voxels in Z-slices with a hole.
5414  const int check_1b = check_1a * myZSkipLen;
5415  // Check if we are past the hole...
5416  if (k >= check_1b)
5417  {
5418  _toRegularLinear(k - check_1b, myXMax, myYMax, x, y, z);
5419  z += myZSkipMin + myZSkipLen;
5420  return;
5421  }
5422 
5423  // We are in the holed slices... First, determine the Z-slice.
5424  z = k / check_1a + myZSkipMin;
5425  // The remainder (index within the slice).
5426  k = k % check_1a;
5427  // Check if we are before the first Y slice with a hole.
5428  const int check_2 = myXMax * myYSkipMin;
5429  if (k < check_2)
5430  {
5431  y = k / myXMax;
5432  x = k % myXMax;
5433  return;
5434  }
5435  k -= check_2;
5436  // Check if we are past the last Y slice with a ahole.
5437  const int check_3 = (myXMax - myXSkipLen) * myYSkipLen;
5438  if (k >= check_3)
5439  {
5440  k -= check_3;
5441  y = k / myXMax + myYSkipMin + myYSkipLen;
5442  x = k % myXMax;
5443  return;
5444  }
5445 
5446  // We are in the holed slices. Find the y coordinate.
5447  y = k / (myXMax - myXSkipLen) + myYSkipMin;
5448  x = k % (myXMax - myXSkipLen);
5449  if (x >= myXSkipMin)
5450  x += myXSkipLen;
5451  }
5452  void toLinearIP(int k, int& x, int& y, int& z) const
5453  {
5454  _toRegularLinear(k, myXSkipLen, myYSkipLen, x, y, z);
5455  x += myXSkipMin;
5456  y += myYSkipMin;
5457  z += myZSkipMin;
5458  }
5459 
5460 protected:
5461  static void _toRegularLinear(int k, int xdim, int ydim, int& x, int& y, int& z)
5462  {
5463  x = k % xdim;
5464  k = k / xdim;
5465  y = k % ydim;
5466  z = k / ydim;
5467  }
5468 
5469 protected:
5470  int myXMax, myYMax, myZMax;
5471  int myXSkipMin, myYSkipMin, myZSkipMin;
5472  int myXSkipLen, myYSkipLen, myZSkipLen;
5473 };
5474 
5475 template <typename T>
5476 void
5477 UT_VoxelArray<T>::moveTilesWithOffset(UT_VoxelArray<T> &src, int tileoffx,
5478  int tileoffy, int tileoffz)
5479 {
5480  __linearTileIndexConverter index(this, &src, tileoffx, tileoffy, tileoffz);
5481  UTparallelInvoke(true, [&]
5482  {
5483  // Divide up the work (only internal tiles). Source tiles for these guys can be
5484  // safely changed without affecting other threads.
5485  UTparallelForLightItems(UT_BlockedRange<int>(0, index.getNTilesIP()),
5486  [&](const UT_BlockedRange<int>& range)
5487  {
5488  for (int i = range.begin(); i < range.end(); i++)
5489  {
5490  // Get the location of the current tile...
5491  int xyz[3];
5492  index.toLinearIP(i, xyz[0], xyz[1], xyz[2]);
5493 
5494  // Get the tiles and exchange data.
5495  UT_VoxelTile<T>* tile = getTile(xyz[0], xyz[1], xyz[2]);
5496  UT_VoxelTile<T>* srctile = src.getTile(xyz[0] + tileoffx,
5497  xyz[1] + tileoffy,
5498  xyz[2] + tileoffz);
5499 
5500  // If tiles are of the same size, simply exchange the data. We know these
5501  // tiles do not affect results outside of src.
5502  if (tile->xres() == srctile->xres() && tile->yres() == srctile->yres()
5503  && tile->zres() == srctile->zres())
5504  {
5505  // The tiles are of the same size, so we can just exchange the data
5506  // pointers.
5507  UTswap(tile->myData, srctile->myData);
5508  UTswap(tile->myCompressionType, srctile->myCompressionType);
5509  UTswap(tile->myForeignData, srctile->myForeignData);
5510  }
5511  else
5512  {
5513  // Otherwise, manually fill in the values.
5514  int offv[] = {(xyz[0] + tileoffx) * TILESIZE,
5515  (xyz[1] + tileoffy) * TILESIZE,
5516  (xyz[2] + tileoffz) * TILESIZE};
5517  for (int z = 0; z < tile->zres(); z++)
5518  {
5519  for (int y = 0; y < tile->yres(); y++)
5520  {
5521  for (int x = 0; x < tile->xres(); x++)
5522  {
5523  tile->setValue(x, y, z, src.getValue(x + offv[0],
5524  y + offv[1],
5525  z + offv[2]));
5526  }
5527  }
5528  }
5529  }
5530  }
5531  });
5532  }, [&]
5533  {
5534  // Is the border constant?
5535  const bool const_src_border = (src.getBorder() == UT_VOXELBORDER_CONSTANT);
5536  const T border_val = src.getBorderValue();
5537 
5538  // Offsets in terms of tiles.
5539  const int off[] = {tileoffx, tileoffy, tileoffz};
5540  // Tile resolution of the source.
5541  const int src_tileres[] = {src.getTileRes(0), src.getTileRes(1), src.getTileRes(2)};
5542 
5543  // Divide up the work (only boundary tiles). Source tiles for these guys cannot be
5544  // modified safely.
5545  UTparallelForLightItems(UT_BlockedRange<int>(0, index.getNTilesBP()),
5546  [&](const UT_BlockedRange<int>& range)
5547  {
5548  for (int i = range.begin(); i < range.end(); i++)
5549  {
5550  // Get the location of the current tile...
5551  int xyz[3];
5552  index.toLinearBP(i, xyz[0], xyz[1], xyz[2]);
5553 
5554  // Get the current tile...
5555  UT_VoxelTile<T>* tile = getTile(xyz[0], xyz[1], xyz[2]);
5556  bool outside = false;
5557  for (int j = 0; j < 3; j++)
5558  {
5559  xyz[j] += off[j];
5560  outside = outside || (xyz[j] < 0 || xyz[j] >= src_tileres[j]);
5561  }
5562 
5563  // If we are completely outside, and borders are constant, we can go ahead and
5564  // make this tile constant.
5565  if (outside && const_src_border)
5566  {
5567  tile->makeConstant(border_val);
5568  }
5569  else
5570  {
5571  // Otherwise, manually fill in the values.
5572  int offv[] = {xyz[0] * TILESIZE, xyz[1] * TILESIZE, xyz[2] * TILESIZE};
5573  for (int z = 0; z < tile->zres(); z++)
5574  {
5575  for (int y = 0; y < tile->yres(); y++)
5576  {
5577  for (int x = 0; x < tile->xres(); x++)
5578  {
5579  tile->setValue(x, y, z, src.getValue(x + offv[0],
5580  y + offv[1],
5581  z + offv[2]));
5582  }
5583  }
5584  }
5585  }
5586  }
5587  });
5588  });
5589 }
5590 
5591 template <typename T>
5592 void
5593 UT_VoxelArray<T>::copyWithOffset(const UT_VoxelArray<T> &src,
5594  int offx, int offy, int offz)
5595 {
5596  UT_VoxelBorderType srcborder;
5597  T srcborderval;
5598 
5599  srcborder = src.getBorder();
5600  srcborderval = src.getBorderValue();
5601 
5602  if (srcborder != UT_VOXELBORDER_EXTRAP)
5603  {
5604  // These borders may be constant friendly
5605  T srcval;
5606 
5607  if (src.isConstant(&srcval))
5608  {
5609  if (srcborder != UT_VOXELBORDER_CONSTANT ||
5610  SYSisEqual(srcborderval, srcval))
5611  {
5612  // We can trivially make ourselves constant.
5613  constant(srcval);
5614  return;
5615  }
5616  }
5617  }
5618 
5619  copyWithOffsetInternal(src, offx, offy, offz);
5620 }
5621 
5622 template <typename T>
5623 void
5624 UT_VoxelArray<T>::copyWithOffsetInternalPartial(const UT_VoxelArray<T> &src,
5625  int offx, int offy, int offz,
5626  const UT_JobInfo &info)
5627 {
5628  UT_VoxelArrayIterator<T> vit;
5629  UT_Vector3I off(offx, offy, offz);
5630  bool can_copy_tiles = ((offx & TILEMASK) == 0) && ((offy & TILEMASK) == 0)
5631  && ((offz & TILEMASK) == 0);
5632 
5633  vit.setArray(this);
5634  vit.splitByTile(info);
5635  vit.setCompressOnExit(true);
5636 
5637  // Iterate over all tiles
5638  for (vit.rewind(); !vit.atEnd(); vit.advanceTile())
5639  {
5640  // Check out this tile
5641  UT_VoxelTile<T> *tile = vit.getTile();
5642  UT_VoxelTile<T> *srctile;
5643  int tx, ty, tz;
5644 
5645  UT_Vector3I start, end, srctileidx, srctileoff, srcend, srcendtile;
5646  vit.getTileVoxels(start, end);
5647 
5648  // If offsets are all multiples of TILESIZE, it is possible to do direct copies,
5649  // assuming source tile is inside and of the same size.
5650  if (can_copy_tiles)
5651  {
5652  // Start by getting the source tile index and ensuring it is inside the
5653  // source array.
5654  bool inside = true;
5655  for (int i = 0; i < 3; i++)
5656  {
5657  srctileidx(i) = vit.myTilePos[i] + (off(i) >> TILEBITS);
5658  inside = inside && srctileidx(i) >= 0
5659  && srctileidx(i) < src.getTileRes(i);
5660  }
5661  // If the tile is inside, we make sure the tile sizes are the same, in which
5662  // case we can do a copy and move on.
5663  if (inside)
5664  {
5665  srctile = src.getTile(srctileidx.x(), srctileidx.y(), srctileidx.z());
5666  if (tile->xres() == srctile->xres() && tile->yres() == srctile->yres()
5667  && tile->zres() == srctile->zres())
5668  {
5669  *tile = *srctile;
5670  continue;
5671  }
5672  }
5673  }
5674 
5675  srctileidx = start;
5676  srctileidx += off;
5677  srctileidx.x() >>= TILEBITS;
5678  srctileidx.y() >>= TILEBITS;
5679  srctileidx.z() >>= TILEBITS;
5680  srctileoff.x() = off.x() & TILEMASK;
5681  srctileoff.y() = off.y() & TILEMASK;
5682  srctileoff.z() = off.z() & TILEMASK;
5683 
5684  srcend = start;
5685  // We are very careful here to be inclusive, so we don't trigger
5686  // the next tile. This is the largest index we expect to index.
5687  srcend.x() += tile->xres() - 1;
5688  srcend.y() += tile->yres() - 1;
5689  srcend.z() += tile->zres() - 1;
5690  srcend += off;
5691  srcendtile = srcend;
5692  srcendtile.x() >>= TILEBITS;
5693  srcendtile.y() >>= TILEBITS;
5694  srcendtile.z() >>= TILEBITS;
5695 
5696  UT_ASSERT(srcendtile.x() == srctileidx.x() ||
5697  srcendtile.x() == srctileidx.x()+1);
5698  UT_ASSERT(srcendtile.y() == srctileidx.y() ||
5699  srcendtile.y() == srctileidx.y()+1);
5700  UT_ASSERT(srcendtile.z() == srctileidx.z() ||
5701  srcendtile.z() == srctileidx.z()+1);
5702 
5703  // Check if we are fully in bounds.
5704  if (srctileidx.x() >= 0 &&
5705  srctileidx.y() >= 0 &&
5706  srctileidx.z() >= 0 &&
5707  srcendtile.x() < src.getTileRes(0) &&
5708  srcendtile.y() < src.getTileRes(1) &&
5709  srcendtile.z() < src.getTileRes(2) &&
5710  srcend.x() < src.getXRes() &&
5711  srcend.y() < src.getYRes() &&
5712  srcend.z() < src.getZRes())
5713  {
5714  bool allconst = true, firsttile = true;
5715  T constval, cval;
5716  // Check if we are all constant...
5717  for (tz = srctileidx.z(); allconst && tz <= srcendtile.z(); tz++)
5718  for (ty = srctileidx.y(); allconst && ty <= srcendtile.y(); ty++)
5719  for (tx = srctileidx.x(); tx <= srcendtile.x(); tx++)
5720  {
5721  srctile = src.getTile(tx, ty, tz);
5722  if (!srctile->isConstant())
5723  {
5724  allconst = false;
5725  break;
5726  }
5727  cval = (*srctile)(0, 0, 0);
5728  if (firsttile)
5729  {
5730  firsttile = false;
5731  constval = cval;
5732  }
5733  if (!SYSisEqual(cval, constval))
5734  {
5735  allconst = false;
5736  break;
5737  }
5738  }
5739  if (allconst)
5740  {
5741  // Should have found at least one tile!
5742  UT_ASSERT(!firsttile);
5743  tile->makeConstant(constval);
5744 
5745  // Onto the next tile!
5746  continue;
5747  }
5748  }
5749 
5750  // All of the fragments aren't constant, or aren't all inside
5751  // our range. So we have to work fragment at a time..
5752  for (tz = srctileidx.z(); tz <= srcendtile.z(); tz++)
5753  for (ty = srctileidx.y(); ty <= srcendtile.y(); ty++)
5754  for (tx = srctileidx.x(); tx <= srcendtile.x(); tx++)
5755  {
5756  int destx, desty, destz;
5757  int srcx, srcy, srcz;
5758 
5759  destx = (tx == srctileidx.x()) ? 0 : (TILESIZE-srctileoff.x());
5760  desty = (ty == srctileidx.y()) ? 0 : (TILESIZE-srctileoff.y());
5761  destz = (tz == srctileidx.z()) ? 0 : (TILESIZE-srctileoff.z());
5762  srcx = (tx == srctileidx.x()) ? srctileoff.x() : 0;
5763  srcy = (ty == srctileidx.y()) ? srctileoff.y() : 0;
5764  srcz = (tz == srctileidx.z()) ? srctileoff.z() : 0;
5765 #if 1
5766  if (tx >= 0 &&
5767  ty >= 0 &&
5768  tz >= 0 &&
5769  tx < src.getTileRes(0) &&
5770  ty < src.getTileRes(1) &&
5771  tz < src.getTileRes(2) &&
5772  ((tx != src.getTileRes(0)-1) ||
5773  srcend.x() < src.getXRes()) &&
5774  ((ty != src.getTileRes(1)-1) ||
5775  srcend.y() < src.getYRes()) &&
5776  ((tz != src.getTileRes(2)-1) ||
5777  srcend.z() < src.getZRes())
5778  )
5779  {
5780  srctile = src.getTile(tx, ty, tz);
5781  // In bounds
5782  tile->copyFragment(
5783  destx, desty, destz,
5784  *srctile,
5785  srcx, srcy, srcz
5786  );
5787  }
5788  else
5789 #endif
5790  {
5791  // Out of bounds!
5792  int maxd = SYSmin(tile->zres(),
5793  TILESIZE-srcz);
5794  int maxh = SYSmin(tile->yres(),
5795  TILESIZE-srcy);
5796  int maxw = SYSmin(tile->xres(),
5797  TILESIZE-srcx);
5798  for (int z = destz; z < maxd; z++)
5799  {
5800  for (int y = desty; y < maxh; y++)
5801  {
5802  for (int x = destx; x < maxw; x++)
5803  {
5804  T val;
5805 
5806  val = src.getValue(x + vit.x() + offx,
5807  y + vit.y() + offy,
5808  z + vit.z() + offz);
5809  tile->setValue(x, y, z, val);
5810  }
5811  }
5812  }
5813  }
5814  }
5815  }
5816 }
5817 
5818 template <typename T>
5819 void
5820 UT_VoxelArray<T>::resamplethreadPartial(const UT_VoxelArray<T> &src,
5821  const UT_Filter *filter, float radius,
5822  int clampaxis,
5823  const UT_JobInfo &info)
5824 {
5825  UT_VoxelArrayIterator<T> vit;
5826  UT_Vector3 pos;
5827  UT_Vector3 ratio;
5828  UT_Interrupt *boss = UTgetInterrupt();
5829 
5830  vit.setArray(this);
5831  vit.splitByTile(info);
5832  vit.setCompressOnExit(true);
5833  vit.setInterrupt(boss);
5834 
5835  ratio.x() = 1.0f / getXRes();
5836  ratio.y() = 1.0f / getYRes();
5837  ratio.z() = 1.0f / getZRes();
5838 
5839  for (vit.rewind(); !vit.atEnd(); vit.advance())
5840  {
5841  pos.x() = vit.x()+0.5f;
5842  pos.y() = vit.y()+0.5f;
5843  pos.z() = vit.z()+0.5f;
5844  pos *= ratio;
5845 
5846  vit.setValue(src.evaluate(pos, *filter, radius, clampaxis));
5847  }
5848 }
5849 
5850 template <typename T>
5851 bool
5852 UT_VoxelArray<T>::posToIndex(UT_Vector3 pos, int &x, int &y, int &z) const
5853 {
5854  // We go from the position in the unit cube into the index.
5855  // The center of cells must map to the exact integer indices.
5856  pos.x() *= myRes[0];
5857  pos.y() *= myRes[1];
5858  pos.z() *= myRes[2];
5859 
5860  // The centers of cells are now mapped .5 too high. Ie, the true
5861  // center of cell index (0,0,0) would be (0.5,0.5,0.5) This, however,
5862  // is exactly what we want for rounding.
5863  x = (int) SYSfloor(pos.x());
5864  y = (int) SYSfloor(pos.y());
5865  z = (int) SYSfloor(pos.z());
5866 
5867  // Determine if out of bounds.
5868  return isValidIndex(x, y, z);
5869 }
5870 
5871 template <typename T>
5872 bool
5873 UT_VoxelArray<T>::posToIndex(UT_Vector3 pos, UT_Vector3 &ipos) const
5874 {
5875  // We go from the position in the unit cube into the index.
5876  // The center of cells must map to the exact integer indices.
5877  pos.x() *= myRes[0];
5878  pos.y() *= myRes[1];
5879  pos.z() *= myRes[2];
5880 
5881  // The centers of cells are now mapped .5 too high. Ie, the true
5882  // center of cell index (0,0,0) would be (0.5,0.5,0.5)
5883  pos.x() -= 0.5;
5884  pos.y() -= 0.5;
5885  pos.z() -= 0.5;
5886 
5887  ipos = pos;
5888 
5889  // Determine if out of bounds.
5890  if (pos.x() < 0 || pos.x() >= myRes[0] ||
5891  pos.y() < 0 || pos.y() >= myRes[1] ||
5892  pos.z() < 0 || pos.z() >= myRes[2])
5893  return false;
5894 
5895  return true;
5896 }
5897 
5898 template <typename T>
5899 bool
5900 UT_VoxelArray<T>::posToIndex(UT_Vector3D pos, exint &x, exint &y, exint &z) const
5901 {
5902  // We go from the position in the unit cube into the index.
5903  // The center of cells must map to the exact integer indices.
5904  pos.x() *= myRes[0];
5905  pos.y() *= myRes[1];
5906  pos.z() *= myRes[2];
5907 
5908  // The centers of cells are now mapped .5 too high. Ie, the true
5909  // center of cell index (0,0,0) would be (0.5,0.5,0.5) This, however,
5910  // is exactly what we want for rounding.
5911  x = (exint) SYSfloor(pos.x());
5912  y = (exint) SYSfloor(pos.y());
5913  z = (exint) SYSfloor(pos.z());
5914 
5915  // Determine if out of bounds.
5916  return isValidIndex(x, y, z);
5917 }
5918 
5919 template <typename T>
5920 bool
5921 UT_VoxelArray<T>::posToIndex(UT_Vector3D pos, UT_Vector3D &ipos) const
5922 {
5923  // We go from the position in the unit cube into the index.
5924  // The center of cells must map to the exact integer indices.
5925  pos.x() *= myRes[0];
5926  pos.y() *= myRes[1];
5927  pos.z() *= myRes[2];
5928 
5929  // The centers of cells are now mapped .5 too high. Ie, the true
5930  // center of cell index (0,0,0) would be (0.5,0.5,0.5)
5931  pos.x() -= 0.5;
5932  pos.y() -= 0.5;
5933  pos.z() -= 0.5;
5934 
5935  ipos = pos;
5936 
5937  // Determine if out of bounds.
5938  if (pos.x() < 0 || pos.x() >= myRes[0] ||
5939  pos.y() < 0 || pos.y() >= myRes[1] ||
5940  pos.z() < 0 || pos.z() >= myRes[2])
5941  return false;
5942 
5943  return true;
5944 }
5945 
5946 template <typename T>
5947 bool
5948 UT_VoxelArray<T>::indexToPos(int x, int y, int z, UT_Vector3F &pos) const
5949 {
5950  pos.x() = x;
5951  pos.y() = y;
5952  pos.z() = z;
5953 
5954  // Move the indices to the centers of the cells.
5955  pos.x() += 0.5;
5956  pos.y() += 0.5;
5957  pos.z() += 0.5;
5958 
5959  // And scale into the unit cube.
5960  pos *= myInvRes;
5961 
5962  // Return true if the original coordinates were in range.
5963  return isValidIndex(x, y, z);
5964 }
5965 
5966 template <typename T>
5967 bool
5968 UT_VoxelArray<T>::indexToPos(exint x, exint y, exint z, UT_Vector3D &pos) const
5969 {
5970  pos.x() = x;
5971  pos.y() = y;
5972  pos.z() = z;
5973 
5974  // Move the indices to the centers of the cells.
5975  pos.x() += 0.5;
5976  pos.y() += 0.5;
5977  pos.z() += 0.5;
5978 
5979  // And scale into the unit cube.
5980  pos *= myInvRes;
5981 
5982  // Return true if the original coordinates were in range.
5983  return isValidIndex(x, y, z);
5984 }
5985 
5986 template <typename T>
5987 void
5988 UT_VoxelArray<T>::findexToPos(UT_Vector3F index, UT_Vector3F &pos) const
5989 {
5990  pos = index;
5991 
5992  // Move the indices to the centers of the cells.
5993  pos.x() += 0.5;
5994  pos.y() += 0.5;
5995  pos.z() += 0.5;
5996 
5997  // And scale into the unit cube.
5998  pos *= myInvRes;
5999 }
6000 
6001 template <typename T>
6002 void
6003 UT_VoxelArray<T>::findexToPos(UT_Vector3D index, UT_Vector3D &pos) const
6004 {
6005  pos = index;
6006 
6007  // Move the indices to the centers of the cells.
6008  pos.x() += 0.5;
6009  pos.y() += 0.5;
6010  pos.z() += 0.5;
6011 
6012  // And scale into the unit cube.
6013  pos *= myInvRes;
6014 }
6015 
6016 template <typename T>
6017 void
6018 UT_VoxelArray<T>::setBorder(UT_VoxelBorderType type, T t)
6019 {
6020  myBorderType = type;
6021  myBorderValue = t;
6022 }
6023 
6024 template <typename T>
6025 void
6026 UT_VoxelArray<T>::setBorderScale(T sx, T sy, T sz)
6027 {
6028  myBorderScale[0] = sx;
6029  myBorderScale[1] = sy;
6030  myBorderScale[2] = sz;
6031 }
6032 
6033 template <typename T>
6034 void
6035 UT_VoxelArray<T>::collapseAllTilesPartial(const UT_JobInfo &info)
6036 {
6037  UT_VoxelArrayIterator<T> vit(this);
6038  vit.splitByTile(info);
6039  for (vit.rewind(); !vit.atEnd(); vit.advanceTile())
6040  {
6041  int i = vit.getLinearTileNum();
6042  myTiles[i].tryCompress(getCompressionOptions());
6043  }
6044 }
6045 
6046 template <typename T>
6047 void
6048 UT_VoxelArray<T>::expandAllTilesPartial(const UT_JobInfo &info)
6049 {
6050  UT_VoxelArrayIterator<T> vit(this);
6051  vit.splitByTile(info);
6052  for (vit.rewind(); !vit.atEnd(); vit.advanceTile())
6053  {
6054  int i = vit.getLinearTileNum();
6055  myTiles[i].uncompress();
6056  }
6057 }
6058 
6059 template <typename T>
6060 void
6061 UT_VoxelArray<T>::expandAllNonConstTilesPartial(const UT_JobInfo &info)
6062 {
6063  UT_VoxelArrayIterator<T> vit(this);
6064  vit.splitByTile(info);
6065  for (vit.rewind(); !vit.atEnd(); vit.advanceTile())
6066  {
6067  int i = vit.getLinearTileNum();
6068  if (!myTiles[i].isConstant())
6069  myTiles[i].uncompress();
6070  }
6071 }
6072 
6073 template <typename T>
6074 void
6075 UT_VoxelArray<T>::saveData(std::ostream &os) const
6076 {
6077  T cval;
6078  char version;
6079 
6080  // First determine if we are fully constant.
6081  if (isConstant(&cval))
6082  {
6083  // Save a constant array.
6084  version = 0;
6085  UTwrite(os, &version, 1);
6086  UTwrite<T>(os, &cval);
6087  return;
6088  }
6089 
6090  // Compressed tiles.
6091  version = 1;
6092  UTwrite(os, &version, 1);
6093 
6094  // Store list of compression types
6095  UT_VoxelTile<T>::saveCompressionTypes(os);
6096 
6097  int i, ntiles;
6098 
6099  ntiles = numTiles();
6100  for (i = 0; i < ntiles; i++)
6101  {
6102  myTiles[i].save(os);
6103  }
6104 }
6105 
6106 
6107 template <typename T>
6108 void
6109 UT_VoxelArray<T>::loadData(UT_IStream &is)
6110 {
6111  T cval;
6112  char version;
6113 
6114  is.readChar(version);
6115 
6116  // First determine if we are fully constant.
6117  if (version == 0)
6118  {
6119  // Save a constant array.
6120  is.read<T>(&cval);
6121 
6122  constant(cval);
6123  return;
6124  }
6125 
6126  if (version == 1)
6127  {
6128  UT_IntArray compressions;
6129 
6130  // Store list of compression types
6131  UT_VoxelTile<T>::loadCompressionTypes(is, compressions);
6132 
6133  int i, ntiles;
6134 
6135  ntiles = numTiles();
6136  for (i = 0; i < ntiles; i++)
6137  {
6138  myTiles[i].load(is, compressions);
6139  }
6140  }
6141 }
6142 
6143 template <typename T>
6144 bool
6145 UT_VoxelArray<T>::saveData(UT_JSONWriter &w, const char *shared_mem_owner) const
6146 {
6147  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
6148 
6149  bool ok = true;
6150  T cval;
6151  int8 version;
6152 
6153  // First determine if we are fully constant.
6154  if (isConstant(&cval))
6155  {
6156  ok = ok && w.jsonBeginArray();
6157  // Save a constant array.
6158  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
6159  UT_VoxelArrayJSON::ARRAY_CONSTARRAY));
6160  if constexpr (tuple_size == 1)
6161  ok = ok && w.jsonValue(cval);
6162  else
6163  ok = ok && w.jsonUniformArray(tuple_size, cval.data());
6164  ok = ok && w.jsonEndArray();
6165  return ok;
6166  }
6167 
6168  if (shared_mem_owner)
6169  {
6170  SYS_SharedMemory *shm;
6171  shm = copyToSharedMemory(shared_mem_owner);
6172  if (shm)
6173  {
6174  ok = ok && w.jsonBeginArray();
6175  // Save a shared memory array.
6176  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
6177  UT_VoxelArrayJSON::ARRAY_SHAREDARRAY));
6178  ok = ok && w.jsonString(shm->id());
6179  ok = ok && w.jsonEndArray();
6180  return ok;
6181  }
6182  // Fall back on raw write.
6183  }
6184 
6185 
6186  // Compressed tiles.
6187  ok = ok && w.jsonBeginArray();
6188  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
6189  UT_VoxelArrayJSON::ARRAY_TILEDARRAY));
6190  ok = ok && w.jsonBeginArray();
6191  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
6192  UT_VoxelArrayJSON::ARRAY_VERSION));
6193  version = 1;
6194  ok = ok && w.jsonValue(version);
6195 
6196  // Store list of compression types
6197  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
6198  UT_VoxelArrayJSON::ARRAY_COMPRESSIONTYPES));
6199  ok = ok && UT_VoxelTile<T>::saveCompressionTypes(w);
6200 
6201  ok = ok && w.jsonKey(UT_VoxelArrayJSON::getToken(
6202  UT_VoxelArrayJSON::ARRAY_TILES));
6203  ok = ok && w.jsonBeginArray();
6204  int i, ntiles;
6205 
6206  ntiles = numTiles();
6207  for (i = 0; i < ntiles; i++)
6208  {
6209  ok = ok && myTiles[i].save(w);
6210  }
6211  ok = ok && w.jsonEndArray();
6212 
6213  ok = ok && w.jsonEndArray();
6214 
6215  ok = ok && w.jsonEndArray();
6216  return ok;
6217 }
6218 
6219 template <typename T>
6220 bool
6221 UT_VoxelArray<T>::loadData(UT_JSONParser &p)
6222 {
6223  constexpr exint tuple_size = UT_FixedVectorTraits<T>::TupleSize;
6224 
6225  T cval;
6226  int8 version;
6227  UT_WorkBuffer key;
6228  int key_id;
6229  bool array_error = false;
6230 
6231  delete mySharedMemView;
6232  mySharedMemView = 0;
6233 
6234  delete mySharedMem;
6235  mySharedMem = 0;
6236 
6237  if (!p.parseBeginArray(array_error) || array_error)
6238  return false;
6239 
6240  if (!p.parseString(key))
6241  return false;
6242  key_id = UT_VoxelArrayJSON::getArrayID(key.buffer());
6243  if (key_id == UT_VoxelArrayJSON::ARRAY_CONSTARRAY)
6244  {
6245  if constexpr (tuple_size == 1)
6246  {
6247  if (!p.parseNumber(cval))
6248  return false;
6249  }
6250  else
6251  {
6252  if (!p.parseUniformArray(cval.data(), tuple_size))
6253  return false;
6254  }
6255 
6256  constant(cval);
6257  }
6258  else if (key_id == UT_VoxelArrayJSON::ARRAY_SHAREDARRAY)
6259  {
6260  UT_WorkBuffer shm_id;
6261  if (!p.parseString(shm_id))
6262  return false;
6263 
6264  if (!populateFromSharedMemory(shm_id.buffer()))
6265  {
6266  // If the shared memory disappears before we get a chance to read
6267  // it, don't abort, just set a constant value. That way Mantra has
6268  // a chance to recover. Not the most elegant solution but works for
6269  // now.
6270  T cval;
6271  cval = 0;
6272  constant(cval);
6273  }
6274  }
6275  else if (key_id == UT_VoxelArrayJSON::ARRAY_TILEDARRAY)
6276  {
6277  UT_JSONParser::traverser it, tile_it;
6278  UT_IntArray compressions;
6279  int i, ntiles;
6280 
6281 
6282  for (it = p.beginArray(); !it.atEnd(); ++it)
6283  {
6284  if (!it.getLowerKey(key))
6285  return false;
6286  switch (UT_VoxelArrayJSON::getArrayID(key.buffer()))
6287  {
6288  case UT_VoxelArrayJSON::ARRAY_VERSION:
6289  if (!p.parseNumber(version))
6290  return false;
6291  break;
6292  case UT_VoxelArrayJSON::ARRAY_COMPRESSIONTYPES:
6293  // Store list of compression types
6294  if (!UT_VoxelTile<T>::loadCompressionTypes(p, compressions))
6295  return false;
6296  break;
6297 
6298  case UT_VoxelArrayJSON::ARRAY_TILES:
6299  ntiles = numTiles();
6300  for (tile_it = p.beginArray(), i = 0; !tile_it.atEnd();
6301  ++tile_it, ++i)
6302  {
6303  if (i < ntiles)
6304  {
6305  if (!myTiles[i].load(p, compressions))
6306  return false;
6307  }
6308  else
6309  {
6310  UT_VoxelTile<T> dummy_tile;
6311  dummy_tile.setRes(TILESIZE, TILESIZE, TILESIZE);
6312  if (!dummy_tile.load(p, compressions))
6313  return false;
6314  }
6315  }
6316  if (i != ntiles)
6317  return false;
6318  break;
6319  default:
6320  p.addWarning("Unexpected key for voxel data: %s",
6321  key.buffer());
6322  if (!p.skipNextObject())
6323  return false;
6324  }
6325  }
6326  }
6327  else
6328  {
6329  p.addWarning("Unexpected voxel key: %s\n", key.buffer());
6330  p.skipNextObject();
6331  return false;
6332  }
6333 
6334  if (!p.parseEndArray(array_error) || array_error)
6335  return false;
6336 
6337  return true;
6338 }
6339 
6340 template<typename T>
6341 SYS_SharedMemory *
6342 UT_VoxelArray<T>::copyToSharedMemory(const char *shared_mem_owner) const
6343 {
6344  UT_SharedMemoryManager &shmgr = UT_SharedMemoryManager::get();
6345 
6346  int ntiles;
6347 
6348  ntiles = numTiles();
6349 
6350  // Tally up the size we need.
6351  exint total_mem_size;
6352 
6353  total_mem_size = sizeof(exint); // Tile count.
6354 
6355  UT_Array<exint> tile_sizes;
6356  UT_Array<exint> next_block_offsets;
6357 
6358  for (int i = 0; i < ntiles; i++)
6359  {
6360  exint tile_size, block_size;
6361  if (myTiles[i].isConstant())
6362  tile_size = sizeof(T);
6363  else
6364  tile_size = myTiles[i].getDataLength();
6365 
6366  tile_sizes.append(tile_size);
6367 
6368  block_size = SYSroundUpToMultipleOf<exint>(tile_size, sizeof(exint));
6369  block_size += sizeof(exint) * 2; // Offset + compression type
6370 
6371  if (i < (ntiles-1))
6372  next_block_offsets.append(block_size / sizeof(exint));
6373  else
6374  next_block_offsets.append(0);
6375 
6376  total_mem_size += block_size;
6377  }
6378 
6379  // Start with an empty shared memory.
6380  SYS_SharedMemory *shared_mem;
6381  UT_WorkBuffer shared_mem_key;
6382 
6383  shared_mem_key.sprintf("%s:%p", shared_mem_owner, this);
6384 
6385  shared_mem = shmgr.get(shared_mem_key.buffer());
6386 
6387  // Does the existing block have the same number of tiles and same
6388  // offsets? In that case we don't reset the shared memory, just write
6389  // the tiles out again. There's very little adverse effect in changing
6390  // the voxel tile data.
6391  bool same_meta_data = false;
6392  if (shared_mem->size() >= sizeof(exint))
6393  {
6394  same_meta_data = true;
6395  {
6396  SYS_SharedMemoryView sv_tc(*shared_mem, 0, sizeof(exint));
6397 
6398  exint *ptr_ds = (exint *)sv_tc.data();
6399  if (*ptr_ds != ntiles)
6400  same_meta_data = false;
6401  }
6402 
6403  if (same_meta_data)
6404  {
6405  // Check if the offsets + compression type is the same.
6406  exint offset = sizeof(exint);
6407  for (int i = 0; i < ntiles; i++)
6408  {
6409  SYS_SharedMemoryView sv_tile(*shared_mem, offset,
6410  sizeof(exint) * 2);
6411 
6412  exint *ptr_tile = (exint *)sv_tile.data();
6413  if (ptr_tile[0] != next_block_offsets(i) ||
6414  ptr_tile[1] != (exint)myTiles[i].myCompressionType)
6415  {
6416  same_meta_data = false;
6417  break;
6418  }
6419  offset += next_block_offsets(i) * sizeof(exint);
6420  }
6421  }
6422  }
6423 
6424  if (!same_meta_data)
6425  {
6426  if (!shared_mem->reset(total_mem_size) ||
6427  shared_mem->size() != total_mem_size)
6428  {
6429  return nullptr;
6430  }
6431  }
6432 
6433  {
6434  SYS_SharedMemoryView sv_tc(*shared_mem, 0, sizeof(exint));
6435 
6436  exint *ptr_ds = (exint *)sv_tc.data();
6437  *ptr_ds = ntiles;
6438  }
6439 
6440  exint offset = sizeof(exint);
6441  for (int i = 0; i < ntiles; i++)
6442  {
6443  SYS_SharedMemoryView sv_tile(*shared_mem, offset,
6444  sizeof(exint) * 2 + tile_sizes(i));
6445 
6446  exint *ptr_tile = (exint *)sv_tile.data();
6447 
6448  // Offset to next tile in exint units.
6449  ptr_tile[0] = next_block_offsets(i);
6450  ptr_tile[1] = myTiles[i].myCompressionType;
6451 
6452  ::memcpy(&ptr_tile[2], myTiles[i].rawData(), tile_sizes(i));
6453 
6454  offset += ptr_tile[0] * sizeof(exint);
6455  }
6456 
6457  return shared_mem;
6458 }
6459 
6460 template<typename T>
6461 bool
6462 UT_VoxelArray<T>::populateFromSharedMemory(const char *id)
6463 {
6464  mySharedMem = new SYS_SharedMemory(id, /*read_only=*/true);
6465  if (!mySharedMem->size())
6466  {
6467  delete mySharedMem;
6468  mySharedMem = 0;
6469  return false;
6470  }
6471 
6472  exint ntiles;
6473  {
6474  SYS_SharedMemoryView sv_tc(*mySharedMem, 0, sizeof(exint));
6475  ntiles = *(const exint *)sv_tc.data();
6476  }
6477  if (ntiles != numTiles())
6478  {
6479  delete mySharedMem;
6480  mySharedMem = 0;
6481  return false;
6482  }
6483 
6484  mySharedMemView = new SYS_SharedMemoryView(*mySharedMem, sizeof(exint));
6485 
6486  exint *data = (exint *)mySharedMemView->data();
6487 
6488  for (int i = 0; i < ntiles; i++)
6489  {
6490  exint offset = data[0];
6491  int8 ctype = (int8)data[1];
6492 
6493  myTiles[i].setForeignData(&data[2], ctype);
6494 
6495  data += offset;
6496  }
6497 
6498  return true;
6499 }
6500 
6501 
6502 
6503 
6504 //
6505 // UT_VoxelMipMap functions
6506 //
6507 template <typename T>
6508 UT_VoxelMipMap<T>::UT_VoxelMipMap()
6509 {
6510  initializePrivate();
6511 }
6512 
6513 template <typename T>
6514 UT_VoxelMipMap<T>::~UT_VoxelMipMap()
6515 {
6516  destroyPrivate();
6517 }
6518 
6519 template <typename T>
6520 UT_VoxelMipMap<T>::UT_VoxelMipMap(const UT_VoxelMipMap<T> &src)
6521 {
6522  initializePrivate();
6523 
6524  *this = src;
6525 }
6526 
6527 template <typename T>
6528 const UT_VoxelMipMap<T> &
6529 UT_VoxelMipMap<T>::operator=(const UT_VoxelMipMap<T> &src)
6530 {
6531  UT_VoxelArray<T> **levels;
6532  int level, i;
6533 
6534  if (&src == this)
6535  return *this;
6536 
6537  destroyPrivate();
6538 
6539  // We do a deep copy. We have learned from UT_String that
6540  // shallow copies will destroy us in the end.
6541  myOwnBase = true;
6542  myBaseLevel = new UT_VoxelArray<T>;
6543  *myBaseLevel = *src.myBaseLevel;
6544 
6545  myNumLevels = src.myNumLevels;
6546 
6547  for (i = 0; i < src.myLevels.entries(); i++)
6548  {
6549  levels = new UT_VoxelArray<T> *[myNumLevels];
6550  myLevels.append(levels);
6551 
6552  for (level = 0; level < myNumLevels; level++)
6553  {
6554  levels[level] = new UT_VoxelArray<T>;
6555  *levels[level] = *src.myLevels(i)[level];
6556  }
6557  }
6558  return *this;
6559 }
6560 
6561 template <typename T>
6562 void
6563 UT_VoxelMipMap<T>::build(UT_VoxelArray<T> *baselevel,
6564  mipmaptype function)
6565 {
6566  UT_Array<mipmaptype> functions;
6567 
6568  functions.append(function);
6569  build(baselevel, functions);
6570 }
6571 
6572 template <typename T>
6573 void
6574 UT_VoxelMipMap<T>::build(UT_VoxelArray<T> *baselevel,
6575  const UT_Array<mipmaptype> &functions)
6576 {
6577  destroyPrivate();
6578 
6579  // Setup our baselevel.
6580  myBaseLevel = baselevel;
6581  myOwnBase = false;
6582 
6583  // Now build from bottom up. First, calculate the number
6584  // of levels we'll need.
6585  myNumLevels = 0;
6586  int maxres, level;
6587 
6588  maxres = SYSmax(myBaseLevel->getXRes(), myBaseLevel->getYRes());
6589  maxres = SYSmax(maxres, myBaseLevel->getZRes());
6590 
6591  // std::cerr << "Max res " << maxres << std::endl;
6592 
6593  while (maxres > 1)
6594  {
6595  myNumLevels++;
6596  maxres++;
6597  maxres >>= 1;
6598  }
6599 
6600  // std::cerr << "Levels: " << myNumLevels << std::endl;
6601 
6602  // Create our desired voxel array list.
6603  for (int i = 0; i < functions.entries(); i++)
6604  {
6605  mipmaptype function = functions(i);
6606 
6607  UT_VoxelArray<T> **levels = new UT_VoxelArray<T> *[myNumLevels];
6608  myLevels.append(levels);
6609 
6610  UT_VoxelArray<T> *lastlevel = myBaseLevel;
6611  for (level = myNumLevels-1; level >= 0; level--)
6612  {
6613  // Find our resolutions.
6614  int xres = (lastlevel->getXRes() + 1) >> 1;
6615  int yres = (lastlevel->getYRes() + 1) >> 1;
6616  int zres = (lastlevel->getZRes() + 1) >> 1;
6617 
6618  levels[level] = new UT_VoxelArray<T>;
6619  levels[level]->size(xres, yres, zres);
6620 
6621  downsample(*levels[level], *lastlevel, function);
6622 
6623  lastlevel = levels[level];
6624  }
6625  }
6626 }
6627 
6628 template <typename T>
6629 void
6630 UT_VoxelMipMap<T>::downsamplePartial(
6631  UT_VoxelArray<T> &dst,
6632  const UT_VoxelArray<T> &src,
6633  mipmaptype function,
6634  const UT_JobInfo &info)
6635 {
6636  UT_VoxelArrayIterator<T> vit(&dst);
6637 
6638  vit.splitByTile(info);
6639  vit.setCompressOnExit(true);
6640 
6641  for (vit.rewind(); !vit.atEnd(); vit.advance())
6642  {
6643  int x = 2*vit.x();
6644  int y = 2*vit.y();
6645  int z = 2*vit.z();
6646  T sam[8];
6647 
6648  if (src.extractSample(x, y, z, sam))
6649  {
6650  vit.setValue(sam[0]);
6651  }
6652  else
6653  {
6654  vit.setValue(
6655  mixValues(
6656  mixValues(
6657  mixValues(sam[0], sam[1], function),
6658  mixValues(sam[2], sam[3], function), function),
6659  mixValues(
6660  mixValues(sam[4], sam[5], function),
6661  mixValues(sam[6], sam[7], function), function),
6662  function));
6663  }
6664  }
6665 }
6666 
6667 
6668 template <typename T>
6669 int64
6670 UT_VoxelMipMap<T>::getMemoryUsage(bool inclusive) const
6671 {
6672  int64 mem = inclusive ? sizeof(*this) : 0;
6673 
6674  mem += myLevels.getMemoryUsage(false);
6675  mem += myLevels.entries() * myNumLevels * sizeof(UT_VoxelArray<T>*);
6676  for (exint j = 0; j < myLevels.entries(); j++)
6677  {
6678  for (int i = 0; i < myNumLevels; i++)
6679  mem += myLevels(j)[i]->getMemoryUsage(true);
6680  }
6681 
6682  return mem;
6683 }
6684 
6685 template <typename T>
6686 void
6687 UT_VoxelMipMap<T>::traverseTopDown(Callback function, void *data) const
6688 {
6689  doTraverse(0, 0, 0, 0, function, data);
6690 }
6691 
6692 template <typename T>
6693 void
6694 UT_VoxelMipMap<T>::doTraverse(int x, int y, int z, int level,
6695  Callback function, void *data) const
6696 {
6697  UT_StackBuffer<T> tval(myLevels.entries());
6698  bool isfinal;
6699  UT_VoxelArray<T> *vox;
6700  int shift;
6701 
6702  if (level == myNumLevels)
6703  {
6704  isfinal = true;
6705  vox = myBaseLevel;
6706  tval[0] = (*vox)(x, y, z);
6707  for (int i = 1; i < myLevels.entries(); i++)
6708  tval[i] = tval[0];
6709  }
6710  else
6711  {
6712  isfinal = false;
6713  for (int i = 0; i < myLevels.entries(); i++)
6714  {
6715  vox = myLevels(i)[level];
6716  tval[i] = (*vox)(x, y, z);
6717  }
6718  }
6719 
6720  shift = myNumLevels - level;
6721 
6722  UT_BoundingBox box;
6723 
6724  box.initBounds(SYSmin(x << shift, myBaseLevel->getXRes()),
6725  SYSmin(y << shift, myBaseLevel->getYRes()),
6726  SYSmin(z << shift, myBaseLevel->getZRes()));
6727  box.enlargeBounds(SYSmin((x+1) << shift, myBaseLevel->getXRes()),
6728  SYSmin((y+1) << shift, myBaseLevel->getYRes()),
6729  SYSmin((z+1) << shift, myBaseLevel->getZRes()));
6730 
6731  if (!function(tval, box, isfinal, data))
6732  {
6733  // Function asked for an early exit.
6734  // Give it.
6735  return;
6736  }
6737 
6738  // We now want to proceed to the next level.
6739  if (isfinal)
6740  return;
6741 
6742  level++;
6743  shift--;
6744  x <<= 1;
6745  y <<= 1;
6746  z <<= 1;
6747 
6748  bool xinc, yinc, zinc;
6749 
6750  // Determine which of our children are valid.
6751  if ( ((x+1) << shift) < myBaseLevel->getXRes() )
6752  xinc = true;
6753  else
6754  xinc = false;
6755  if ( ((y+1) << shift) < myBaseLevel->getYRes() )
6756  yinc = true;
6757  else
6758  yinc = false;
6759  if ( ((z+1) << shift) < myBaseLevel->getZRes() )
6760  zinc = true;
6761  else
6762  zinc = false;
6763 
6764  //
6765  // Traverse all valid children. Note that this is deliberately a gray
6766  // order traversal for full nodes.
6767  //
6768 
6769  doTraverse(x, y, z, level, function, data);
6770 
6771  if (yinc)
6772  {
6773  doTraverse(x, y+1, z, level, function, data);
6774  if (zinc)
6775  doTraverse(x, y+1, z+1, level, function, data);
6776  }
6777  if (zinc)
6778  doTraverse(x, y, z+1, level, function, data);
6779 
6780  if (xinc)
6781  {
6782  if (zinc)
6783  doTraverse(x+1, y, z+1, level, function, data);
6784  doTraverse(x+1, y, z, level, function, data);
6785  if (yinc)
6786  {
6787  doTraverse(x+1, y+1, z, level, function, data);
6788  if (zinc)
6789  doTraverse(x+1, y+1, z+1, level, function, data);
6790  }
6791  }
6792 }
6793 
6794 template <typename T>
6795 template <typename OP>
6796 void
6797 UT_VoxelMipMap<T>::traverseTopDown(OP &op) const
6798 {
6799  doTraverse(0, 0, 0, numLevels()-1, op);
6800 }
6801 
6802 template <typename T>
6803 template <typename OP>
6804 void
6805 UT_VoxelMipMap<T>::doTraverse(int x, int y, int z, int level,
6806  OP &op) const
6807 {
6808  int shift;
6809 
6810  shift = level;
6811 
6812  UT_BoundingBoxI box;
6813 
6814  box.initBounds(SYSmin(x << shift, myBaseLevel->getXRes()),
6815  SYSmin(y << shift, myBaseLevel->getYRes()),
6816  SYSmin(z << shift, myBaseLevel->getZRes()));
6817  box.enlargeBounds(SYSmin((x+1) << shift, myBaseLevel->getXRes()),
6818  SYSmin((y+1) << shift, myBaseLevel->getYRes()),
6819  SYSmin((z+1) << shift, myBaseLevel->getZRes()));
6820 
6821  if (!op(box, level))
6822  {
6823  // Function asked for an early exit.
6824  // Give it.
6825  return;
6826  }
6827 
6828  level--;
6829  // We now want to proceed to the next level.
6830  if (level < 0)
6831  return;
6832 
6833  x <<= 1;
6834  y <<= 1;
6835  z <<= 1;
6836 
6837  bool xinc, yinc, zinc;
6838 
6839  // Determine which of our children are valid.
6840  if ( ((x+1) << level) < myBaseLevel->getXRes() )
6841  xinc = true;
6842  else
6843  xinc = false;
6844  if ( ((y+1) << level) < myBaseLevel->getYRes() )
6845  yinc = true;
6846  else
6847  yinc = false;
6848  if ( ((z+1) << level) < myBaseLevel->getZRes() )
6849  zinc = true;
6850  else
6851  zinc = false;
6852 
6853  //
6854  // Traverse all valid children. Note that this is deliberately a gray
6855  // order traversal for full nodes.
6856  //
6857 
6858  doTraverse(x, y, z, level, op);
6859 
6860  if (yinc)
6861  {
6862  doTraverse(x, y+1, z, level, op);
6863  if (zinc)
6864  doTraverse(x, y+1, z+1, level, op);
6865  }
6866  if (zinc)
6867  doTraverse(x, y, z+1, level, op);
6868 
6869  if (xinc)
6870  {
6871  if (zinc)
6872  doTraverse(x+1, y, z+1, level, op);
6873  doTraverse(x+1, y, z, level, op);
6874  if (yinc)
6875  {
6876  doTraverse(x+1, y+1, z, level, op);
6877  if (zinc)
6878  doTraverse(x+1, y+1, z+1, level, op);
6879  }
6880  }
6881 }
6882 
6883 template <typename T>
6884 template <typename OP>
6885 void
6886 UT_VoxelMipMap<T>::traverseTopDownSorted(OP &op) const
6887 {
6888  doTraverseSorted(0, 0, 0, numLevels()-1, op);
6889 }
6890 
6891 class ut_VoxelMipMapSortCompare
6892 {
6893 public:
6894  float value;
6895  int key;
6896 };
6897 
6898 inline bool operator<(const ut_VoxelMipMapSortCompare &lhs, const ut_VoxelMipMapSortCompare &rhs)
6899 {
6900  return lhs.value < rhs.value;
6901 }
6902 
6903 template <typename T>
6904 template <typename OP>
6905 void
6906 UT_VoxelMipMap<T>::doTraverseSorted(int x, int y, int z, int level,
6907  OP &op) const
6908 {
6909  UT_BoundingBoxI box;
6910 
6911  box.initBounds(SYSmin(x << level, myBaseLevel->getXRes()),
6912  SYSmin(y << level, myBaseLevel->getYRes()),
6913  SYSmin(z << level, myBaseLevel->getZRes()));
6914  box.enlargeBounds(SYSmin((x+1) << level, myBaseLevel->getXRes()),
6915  SYSmin((y+1) << level, myBaseLevel->getYRes()),
6916  SYSmin((z+1) << level, myBaseLevel->getZRes()));
6917 
6918  if (!op(box, level))
6919  {
6920  // Function asked for an early exit.
6921  // Give it.
6922  return;
6923  }
6924 
6925  level--;
6926  // We now want to proceed to the next level.
6927  if (level < 0)
6928  return;
6929 
6930  x <<= 1;
6931  y <<= 1;
6932  z <<= 1;
6933 
6934  bool xinc, yinc, zinc;
6935 
6936  // Determine which of our children are valid.
6937  if ( ((x+1) << level) < myBaseLevel->getXRes() )
6938  xinc = true;
6939  else
6940  xinc = false;
6941  if ( ((y+1) << level) < myBaseLevel->getYRes() )
6942  yinc = true;
6943  else
6944  yinc = false;
6945  if ( ((z+1) << level) < myBaseLevel->getZRes() )
6946  zinc = true;
6947  else
6948  zinc = false;
6949 
6950  UT_BoundingBoxI boxes[8];
6951  int numboxes = 0;
6952 
6953  // Build all of our bounding boxes.
6954  for (int dz = 0; dz < 2; dz++)
6955  {
6956  if (dz && !zinc)
6957  continue;
6958  for (int dy = 0; dy < 2; dy++)
6959  {
6960  if (dy && !yinc)
6961  continue;
6962  for (int dx = 0; dx < 2; dx++)
6963  {
6964  if (dx && !xinc)
6965  continue;
6966  boxes[numboxes].initBounds(
6967  SYSmin((x+dx) << level, myBaseLevel->getXRes()),
6968  SYSmin((y+dy) << level, myBaseLevel->getYRes()),
6969  SYSmin((z+dz) << level, myBaseLevel->getZRes()));
6970  boxes[numboxes].enlargeBounds(
6971  SYSmin((x+dx+1) << level, myBaseLevel->getXRes()),
6972  SYSmin((y+dy+1) << level, myBaseLevel->getYRes()),
6973  SYSmin((z+dz+1) << level, myBaseLevel->getZRes()));
6974  numboxes++;
6975  }
6976  }
6977  }
6978 
6979  ut_VoxelMipMapSortCompare sortstats[8];
6980  for (int i = 0; i < numboxes; i++)
6981  {
6982  sortstats[i].value = op.sortValue(boxes[i], level);
6983  sortstats[i].key = i;
6984  }
6985  std::stable_sort(sortstats, &sortstats[numboxes]);
6986 
6987  for (int i = 0; i < numboxes; i++)
6988  {
6989  int whichbox = sortstats[i].key;
6990  doTraverseSorted(boxes[whichbox](0,0)>>level, boxes[whichbox](1,0)>>level, boxes[whichbox](2,0)>>level, level, op);
6991  }
6992 }
6993 
6994 template <typename T>
6995 void
6996 UT_VoxelMipMap<T>::initializePrivate()
6997 {
6998  myNumLevels = 0;
6999  myBaseLevel = 0;
7000  myOwnBase = false;
7001 }
7002 
7003 template <typename T>
7004 void
7005 UT_VoxelMipMap<T>::destroyPrivate()
7006 {
7007  for (exint i = 0; i < myLevels.entries(); i++)
7008  {
7009  for (exint level = 0; level < myNumLevels; level++)
7010  delete myLevels(i)[level];
7011  delete [] myLevels(i);
7012  }
7013  myLevels.entries(0);
7014 
7015  if (myOwnBase)
7016  delete myBaseLevel;
7017 
7018  initializePrivate();
7019 }
7020 
7021 //
7022 // UT_VoxelArrayIterator implementation
7023 //
7024 template <typename T>
7025 UT_VoxelArrayIterator<T>::UT_VoxelArrayIterator()
7026 {
7027  myArray = 0;
7028  myHandle.resetHandle();
7029  myCurTile = -1;
7030  myShouldCompressOnExit = false;
7031  myUseTileList = false;
7032  myJobInfo = 0;
7033  myInterrupt = 0;
7034 }
7035 
7036 template <typename T>
7037 UT_VoxelArrayIterator<T>::UT_VoxelArrayIterator(UT_VoxelArray<T> *vox)
7038 {
7039  myShouldCompressOnExit = false;
7040  myUseTileList = false;
7041  myJobInfo = 0;
7042  setArray(vox);
7043  myInterrupt = 0;
7044 }
7045 
7046 template <typename T>
7047 UT_VoxelArrayIterator<T>::UT_VoxelArrayIterator(UT_COWReadHandle<UT_VoxelArray<T> > handle)
7048 {
7049  myShouldCompressOnExit = false;
7050  myUseTileList = false;
7051  myJobInfo = 0;
7052  setHandle(handle);
7053  myInterrupt = 0;
7054 }
7055 
7056 template <typename T>
7057 UT_VoxelArrayIterator<T>::~UT_VoxelArrayIterator()
7058 {
7059 }
7060 
7061 template <typename T>
7062 void
7063 UT_VoxelArrayIterator<T>::setPartialRange(int idx, int numranges)
7064 {
7065  int numtiles;
7066  fpreal tileperrange;
7067 
7068  // Must already have been set.
7069  UT_ASSERT(myArray);
7070  if (!myArray)
7071  return;
7072 
7073  // Divide our tiles in to num ranges groups.
7074  numtiles = myArray->numTiles();
7075 
7076  // If we are using a tile list, use it instead
7077  if (myUseTileList)
7078  numtiles = myTileList.entries();
7079 
7080  // Trivial case.
7081  if (!numtiles)
7082  {
7083  myTileStart = 0;
7084  myTileEnd = 0;
7085  return;
7086  }
7087 
7088  // Sanity check idx.
7089  if (idx < 0 || idx >= numranges)
7090  {
7091  UT_ASSERT(!"Idx out of bounds");
7092  myTileStart = -1;
7093  myTileEnd = -1;
7094  return;
7095  }
7096 
7097  // Sanity test numranges
7098  if (numranges < 1)
7099  {
7100  UT_ASSERT(!"Invalid range count!");
7101  numranges = 1;
7102  }
7103 
7104  // Compute tile per range.
7105  // We use floating point so, if you have 15 tiles and
7106  // 16 processors, you don't decide to do all 15
7107  // tiles on one processor.
7108  tileperrange = (fpreal)numtiles / (fpreal)numranges;
7109 
7110  myTileStart = (int) SYSfloor(idx * tileperrange);
7111  myTileEnd = (int) SYSfloor((idx+1) * tileperrange);
7112 
7113  // Special case to ensure we always get the last tile,
7114  // despite the evils of floating point.
7115  if (idx == numranges-1)
7116  myTileEnd = numtiles;
7117 
7118  UT_ASSERT(myTileStart >= 0);
7119  UT_ASSERT(myTileEnd <= numtiles);
7120 }
7121 
7122 template <typename T>
7123 void
7124 UT_VoxelArrayIterator<T>::splitByTile(const UT_JobInfo &info)
7125 {
7126  // Must already have been set.
7127  UT_ASSERT(myArray);
7128  if (!myArray)
7129  return;
7130 
7131  // If there is one thread, don't bother
7132  if (info.numJobs() == 1)
7133  myJobInfo = 0;
7134  else
7135  myJobInfo = &info;
7136 }
7137 
7138 template <typename T>
7139 void
7140 UT_VoxelArrayIterator<T>::restrictToBBox(const UT_BoundingBox &bbox)
7141 {
7142  UT_Vector3 pmin, pmax, vmin, vmax;
7143 
7144  pmin = bbox.minvec();
7145  pmax = bbox.maxvec();
7146 
7147  pmin.x() = SYSmax(pmin.x(), 0.0f);
7148  pmin.y() = SYSmax(pmin.y(), 0.0f);
7149  pmin.z() = SYSmax(pmin.z(), 0.0f);
7150  pmax.x() = SYSmin(pmax.x(), 1.0f);
7151  pmax.y() = SYSmin(pmax.y(), 1.0f);
7152  pmax.z() = SYSmin(pmax.z(), 1.0f);
7153 
7154  myArray->posToIndex(pmin, vmin);
7155  myArray->posToIndex(pmax, vmax);
7156 
7157  restrictToBBox(SYSfloor(vmin.x()), SYSceil(vmax.x()),
7158  SYSfloor(vmin.y()), SYSceil(vmax.y()),
7159  SYSfloor(vmin.z()), SYSceil(vmax.z()));
7160 }
7161 
7162 template <typename T>
7163 void
7164 UT_VoxelArrayIterator<T>::restrictToBBox(int xmin, int xmax,
7165  int ymin, int ymax,
7166  int zmin, int zmax)
7167 {
7168  int xres, yres, zres, x, y, z;
7169 
7170  xres = myArray->getXRes();
7171  yres = myArray->getYRes();
7172  zres = myArray->getZRes();
7173 
7174  myTileList.entries(0);
7175  myUseTileList = true;
7176  // Make sure we have any tiles that are valid.
7177  if (xmin < xres && xmax >= 0 &&
7178  ymin < yres && ymax >= 0 &&
7179  zmin < zres && zmax >= 0)
7180  {
7181  // Clamp into valid range.
7182  myArray->clampIndex(xmin, ymin, zmin);
7183  myArray->clampIndex(xmax, ymax, zmax);
7184 
7185  // Convert to tiles...
7186  xmin >>= TILEBITS;
7187  ymin >>= TILEBITS;
7188  zmin >>= TILEBITS;
7189  xmax >>= TILEBITS;
7190  ymax >>= TILEBITS;
7191  zmax >>= TILEBITS;
7192 
7193  // Check if we are all accounted for.
7194  if (myArray->numTiles() == (xmax-xmin+1)*(ymax-ymin+1)*(zmax-zmin+1))
7195  {
7196  UT_ASSERT(xmin == 0 && ymin == 0 && zmin == 0);
7197  // No need for a tile list, just run everything!
7198  myUseTileList = false;
7199  }
7200  else
7201  {
7202  // Iterate over all active tiles, adding to our list.
7203  for (z = zmin; z <= zmax; z++)
7204  {
7205  for (y = ymin; y <= ymax; y++)
7206  {
7207  for (x = xmin; x <= xmax; x++)
7208  {
7209  myTileList.append(myArray->xyzTileToLinear(x, y, z));
7210  }
7211  }
7212  }
7213  }
7214  }
7215 
7216  // Recompute our ranges.
7217  myCurTile = -1;
7218  setPartialRange(0, 1);
7219 }
7220 
7221 
7222 template <typename T>
7223 void
7224 UT_VoxelArrayIterator<T>::rewind()
7225 {
7226  // Ensure we have at least one tile in each direction
7227  if (!myArray ||
7228  !myArray->getRes(0) || !myArray->getRes(1) || !myArray->getRes(2))
7229  {
7230  myCurTile = -1;
7231  return;
7232  }
7233 
7234  if (myUseTileList)
7235  {
7236  if (myJobInfo)
7237  myCurTileListIdx = myJobInfo->nextTask();
7238  else
7239  myCurTileListIdx = myTileStart;
7240  if (myCurTileListIdx < 0 || myCurTileListIdx >= myTileEnd)
7241  {
7242  myCurTile = -1;
7243  return;
7244  }
7245  myCurTile = myTileList(myCurTileListIdx);
7246  }
7247  else
7248  {
7249  if (myJobInfo)
7250  myCurTile = myJobInfo->nextTask();
7251  else
7252  myCurTile = myTileStart;
7253  // If this is an empty range, we quit right away.
7254  if (myCurTile < 0 || myCurTile >= myTileEnd)
7255  {
7256  myCurTile = -1;
7257  return;
7258  }
7259  }
7260 
7261  UT_VoxelTile<T> *tile;
7262 
7263  tile = myArray->getLinearTile(myCurTile);
7264 
7265  // Get the tile position
7266  if (myCurTile)
7267  {
7268  myArray->linearTileToXYZ(myCurTile,
7269  myTilePos[0], myTilePos[1], myTilePos[2]);
7270  myPos[0] = TILESIZE * myTilePos[0];
7271  myPos[1] = TILESIZE * myTilePos[1];
7272  myPos[2] = TILESIZE * myTilePos[2];
7273  }
7274  else
7275  {
7276  myTilePos[0] = 0;
7277  myTilePos[1] = 0;
7278  myTilePos[2] = 0;
7279  myPos[0] = 0;
7280  myPos[1] = 0;
7281  myPos[2] = 0;
7282  }
7283 
7284  myTileLocalPos[0] = 0;
7285  myTileLocalPos[1] = 0;
7286  myTileLocalPos[2] = 0;
7287 
7288  myTileSize[0] = tile->xres();
7289  myTileSize[1] = tile->yres();
7290  myTileSize[2] = tile->zres();
7291 }
7292 
7293 template <typename T>
7294 void
7295 UT_VoxelArrayIterator<T>::advanceTile()
7296 {
7297  if (myInterrupt && myInterrupt->opInterrupt())
7298  {
7299  myCurTile = -1;
7300  return;
7301  }
7302  if (myUseTileList)
7303  {
7304  if (getCompressOnExit())
7305  {
7306  // Verify our last tile was a legitimate one.
7307  if (myCurTile >= 0 && myCurTileListIdx < myTileEnd)
7308  {
7309  myArray->getLinearTile(myCurTile)->tryCompress(myArray->getCompressionOptions());
7310  }
7311  }
7312 
7313  // Advance our myCurTileListIdx and rebuild from
7314  if (myJobInfo)
7315  myCurTileListIdx = myJobInfo->nextTask();
7316  else
7317  myCurTileListIdx++;
7318  if (myCurTileListIdx >= myTileEnd)
7319  {
7320  myCurTile = -1;
7321  return;
7322  }
7323 
7324  myCurTile = myTileList(myCurTileListIdx);
7325 
7326  myArray->linearTileToXYZ(myCurTile,
7327  myTilePos[0], myTilePos[1], myTilePos[2]);
7328 
7329  UT_VoxelTile<T> *tile;
7330 
7331  tile = myArray->getLinearTile(myCurTile);
7332  myTileLocalPos[0] = 0;
7333  myTileLocalPos[1] = 0;
7334  myTileLocalPos[2] = 0;
7335  myTileSize[0] = tile->xres();
7336  myTileSize[1] = tile->yres();
7337  myTileSize[2] = tile->zres();
7338 
7339  myPos[0] = TILESIZE * myTilePos[0];
7340  myPos[1] = TILESIZE * myTilePos[1];
7341  myPos[2] = TILESIZE * myTilePos[2];
7342  return;
7343  }
7344 
7345  // If requested, compress our last tile.
7346  if (getCompressOnExit())
7347  {
7348  // Verify our last tile was a legitimate one.
7349  if (myCurTile >= 0 && myCurTile < myTileEnd)
7350  {
7351  myArray->getLinearTile(myCurTile)->tryCompress(myArray->getCompressionOptions());
7352  }
7353  }
7354 
7355  if (myJobInfo)
7356  {
7357  myCurTile = myJobInfo->nextTask();
7358  if (myCurTile >= myTileEnd)
7359  {
7360  myCurTile = -1;
7361  return;
7362  }
7363  myArray->linearTileToXYZ(myCurTile,
7364  myTilePos[0], myTilePos[1], myTilePos[2]);
7365  }
7366  else
7367  {
7368  // Advance our myTilePos, then rebuild everything from there.
7369  myTilePos[0]++;
7370  if (myTilePos[0] >= myArray->getTileRes(0))
7371  {
7372  myTilePos[0] = 0;
7373  myTilePos[1]++;
7374  if (myTilePos[1] >= myArray->getTileRes(1))
7375  {
7376  myTilePos[1] = 0;
7377  myTilePos[2]++;
7378  if (myTilePos[2] >= myArray->getTileRes(2))
7379  {
7380  // All done!
7381  myCurTile = -1;
7382  return;
7383  }
7384  }
7385  }
7386  myCurTile = myArray->xyzTileToLinear(myTilePos[0], myTilePos[1], myTilePos[2]);
7387  }
7388 
7389  UT_VoxelTile<T> *tile;
7390 
7391  // Rebuild our settings from this tile.
7392 
7393  // See if we hit our end.
7394  if (myCurTile >= myTileEnd)
7395  {
7396  myCurTile = -1;
7397  return;
7398  }
7399 
7400  tile = myArray->getLinearTile(myCurTile);
7401  myTileLocalPos[0] = 0;
7402  myTileLocalPos[1] = 0;
7403  myTileLocalPos[2] = 0;
7404  myTileSize[0] = tile->xres();
7405  myTileSize[1] = tile->yres();
7406  myTileSize[2] = tile->zres();
7407 
7408  myPos[0] = TILESIZE * myTilePos[0];
7409  myPos[1] = TILESIZE * myTilePos[1];
7410  myPos[2] = TILESIZE * myTilePos[2];
7411 }
7412 
7413 
7414 template <typename T>
7415 void
7416 UT_VoxelArrayIterator<T>::skipToEndOfTile()
7417 {
7418  myTileLocalPos[0] = myTileSize[0];
7419  myTileLocalPos[1] = myTileSize[1];
7420  myTileLocalPos[2] = myTileSize[2];
7421 }
7422 
7423 template <typename T>
7424 template <typename OP>
7425 void
7426 UT_VoxelArrayIterator<T>::applyOperation(const OP &op, T a)
7427 {
7428  rewind();
7429 
7430  while (!atEnd())
7431  {
7432  UT_VoxelTile<T> *tile;
7433 
7434  tile = myArray->getLinearTile(myCurTile);
7435 
7436  if (!tile->isSimpleCompression())
7437  tile->uncompress();
7438 
7439  if (tile->isConstant())
7440  {
7441  T val;
7442 
7443  val = tile->rawData()[0];
7444 
7445  val = op(val, a);
7446 
7447  tile->rawData()[0] = val;
7448  }
7449  else
7450  {
7451  T *val;
7452 
7453  val = tile->rawData();
7454 
7455  int n = tile->numVoxels();
7456  for (int i = 0; i < n; i++)
7457  {
7458  val[i] = op(val[i], a);
7459  }
7460  }
7461 
7462  advanceTile();
7463  }
7464 }
7465 
7466 template <typename T>
7467 template <typename OP, typename S>
7468 void
7469 UT_VoxelArrayIterator<T>::applyOperationCheckNoop(const OP &op,
7470  const UT_VoxelArray<S> &a)
7471 {
7472  UT_ASSERT(myArray->isMatching(a));
7473 
7474  rewind();
7475 
7476  while (!atEnd())
7477  {
7478  UT_VoxelTile<S> *atile;
7479  UT_VoxelTile<T> *tile;
7480 
7481  tile = myArray->getLinearTile(myCurTile);
7482  atile = a.getLinearTile(myCurTile);
7483 
7484  if (!atile->isSimpleCompression())
7485  {
7486  // Have to use getValue...
7487  for (int z = 0; z < tile->zres(); z++)
7488  for (int y = 0; y < tile->yres(); y++)
7489  for (int x = 0; x < tile->xres(); x++)
7490  {
7491  S aval;
7492  T val;
7493 
7494  val = tile->operator()(x, y, z);
7495  aval = atile->operator()(x, y, z);
7496 
7497  val = op(val, aval);
7498 
7499  tile->setValue(x, y, z, val);
7500  }
7501  }
7502  else
7503  {
7504  int ainc = atile->isConstant() ? 0 : 1;
7505 
7506  // Check if the incoming tile is constant and is a no-op
7507  // If so, we do not want to decompress!
7508  if (!ainc)
7509  {
7510  S aval;
7511  aval = atile->rawData()[0];
7512  if (op.isNoop(aval))
7513  {
7514  advanceTile();
7515  continue;
7516  }
7517  }
7518 
7519  if (!tile->isSimpleCompression())
7520  tile->uncompress();
7521 
7522  if (tile->isConstant())
7523  {
7524  if (!ainc)
7525  {
7526  // Woohoo! Too simple!
7527  S aval;
7528  T val;
7529 
7530  val = tile->rawData()[0];
7531  aval = atile->rawData()[0];
7532 
7533  val = op(val, aval);
7534 
7535  tile->rawData()[0] = val;
7536  }
7537  else
7538  {
7539  tile->uncompress();
7540  }
7541  }
7542 
7543  // In case we uncompressed ourself above...
7544  // we have to test again
7545  if (!tile->isConstant())
7546  {
7547  const S *aval;
7548  T *val;
7549 
7550  val = tile->rawData();
7551  aval = atile->rawData();
7552  ainc = atile->isConstant() ? 0 : 1;
7553 
7554  int n = tile->numVoxels();
7555  for (int i = 0; i < n; i++)
7556  {
7557  val[i] = op(val[i], *aval);
7558  aval += ainc;
7559  }
7560  }
7561  }
7562 
7563  advanceTile();
7564  }
7565 }
7566 
7567 template <typename T>
7568 template <typename OP>
7569 void
7570 UT_VoxelArrayIterator<T>::applyOperationCheckNoop(const OP &op, T a)
7571 {
7572  rewind();
7573 
7574  if (op.isNoop(a))
7575  {
7576  while (!atEnd())
7577  advanceTile();
7578  return;
7579  }
7580 
7581  applyOperation(op, a);
7582 }
7583 
7584 template<int OPERANDS, bool USE_SELF,
7585  typename T, typename OP, typename S, typename R, typename Q>
7586 static inline T
7587 conditionalCallOperator(const OP& op, const T& a0, const S& a1, const R& a2, const Q& a3)
7588 {
7589  // Call the correct () operator, depending on how many operands there are.
7590  T val;
7591  if constexpr (OPERANDS == 0 && USE_SELF)
7592  val = op(a0);
7593  else if constexpr (OPERANDS == 1 && !USE_SELF)
7594  val = op(a1);
7595  else if constexpr (OPERANDS == 1 && USE_SELF)
7596  val = op(a0, a1);
7597  else if constexpr (OPERANDS == 2 && !USE_SELF)
7598  val = op(a1, a2);
7599  else if constexpr (OPERANDS == 2 && USE_SELF)
7600  val = op(a0, a1, a2);
7601  else if constexpr (OPERANDS == 3 && !USE_SELF)
7602  val = op(a1, a2, a3);
7603  else if constexpr (OPERANDS == 3 && USE_SELF)
7604  val = op(a0, a1, a2, a3);
7605 
7606  return val;
7607 }
7608 
7609 /// To avoid code duplication, this helper function does the
7610 /// actual assignment. Works for number of operands ranging
7611 /// from 0 to 3, and masking on or off.
7612 template<int OPERANDS, bool MASKED, bool USE_SELF,
7613  typename T, typename OP, typename S, typename R, typename Q, typename M,
7614  typename ITERATOR>
7615 static inline void
7616 assignOperationOnIterator(ITERATOR &it, const OP& op, const UT_VoxelArray<S>* a,
7617  const UT_VoxelArray<R>* b, const UT_VoxelArray<Q>* c,
7618  const UT_VoxelArray<M>* mask)
7619 {
7620  // Works with at most 3 extra operands...
7621  UT_ASSERT(OPERANDS <= 3);
7622  // If there are no extra operands, must use our own value...
7623  UT_ASSERT(OPERANDS > 0 || USE_SELF);
7624 
7625  T val;
7626  S aval = {};
7627  R bval = {};
7628  Q cval = {};
7629 
7630  it.rewind();
7631  while (!it.atEnd())
7632  {
7633  // Get the tiles for the iterator and the source values.
7634  int tileNum = it.getLinearTileNum();
7635  UT_VoxelTile<M> *mtile = MASKED ? mask->getLinearTile(tileNum) : nullptr;
7636  UT_VoxelTile<S> *atile = OPERANDS > 0 ? a->getLinearTile(tileNum) : nullptr;
7637  UT_VoxelTile<R> *btile = OPERANDS > 1 ? b->getLinearTile(tileNum) : nullptr;
7638  UT_VoxelTile<Q> *ctile = OPERANDS > 2 ? c->getLinearTile(tileNum) : nullptr;
7639  UT_VoxelTile<T> *tile = it.getTile();
7640 
7641  // Skip if the mask tile exists, is constant and masked out.
7642  if (MASKED && mtile->isConstant() && ((*mtile)(0, 0, 0) <= ((M) 0.5)))
7643  {
7644  it.advanceTile();
7645  continue;
7646  }
7647 
7648  // Check for any complex compression. These don't allow
7649  // rawData so we have to use the getValue path.
7650  if ((USE_SELF && !tile->isSimpleCompression()) ||
7651  (OPERANDS > 0 && !atile->isSimpleCompression()) ||
7652  (OPERANDS > 1 && !btile->isSimpleCompression()) ||
7653  (OPERANDS > 2 && !ctile->isSimpleCompression()) ||
7654  (MASKED && !mtile->isSimpleCompression()))
7655  {
7656  // Have to use getValue...
7657  for (int z = 0; z < tile->zres(); z++)
7658  {
7659  for (int y = 0; y < tile->yres(); y++)
7660  {
7661  for (int x = 0; x < tile->xres(); x++)
7662  {
7663  if (!MASKED || ((*mtile)(x, y, z) > ((M) 0.5)))
7664  {
7665  switch (OPERANDS)
7666  {
7667  case 3:
7668  cval = (*ctile)(x, y, z);
7669  SYS_FALLTHROUGH;
7670  case 2:
7671  bval = (*btile)(x, y, z);
7672  SYS_FALLTHROUGH;
7673  case 1:
7674  aval = (*atile)(x, y, z);
7675  break;
7676  default:
7677  break;
7678  }
7679 
7680  if (USE_SELF) val = (*tile)(x, y, z);
7681 
7682  val = conditionalCallOperator<OPERANDS, USE_SELF>(
7683  op, val, aval, bval, cval);
7684  tile->setValue(x, y, z, val);
7685  }
7686  }
7687  }
7688  }
7689  }
7690  else
7691  {
7692  int ainc = (OPERANDS < 1 || atile->isConstant()) ? 0 : 1;
7693  int binc = (OPERANDS < 2 || btile->isConstant()) ? 0 : 1;
7694  int cinc = (OPERANDS < 3 || ctile->isConstant()) ? 0 : 1;
7695  int minc = (!MASKED || mtile->isConstant()) ? 0 : 1;
7696 
7697  // Check for constant sources. The destination needs
7698  // to be constant if USE_SELF is on.
7699  if ((!USE_SELF || tile->isConstant()) &&
7700  ainc == 0 && binc == 0 && cinc == 0 && minc == 0)
7701  {
7702  switch(OPERANDS)
7703  {
7704  case 3:
7705  cval = ctile->rawData()[0];
7706  SYS_FALLTHROUGH;
7707  case 2:
7708  bval = btile->rawData()[0];
7709  SYS_FALLTHROUGH;
7710  case 1:
7711  aval = atile->rawData()[0];
7712  break;
7713  default:
7714  break;
7715  }
7716 
7717  // Note that we know that we are either not masked or
7718  // the mask is constant; in the latter case, if the
7719  // mask were constant 0, then we would not enter this
7720  // area at all, so no need to check the actual value.
7721  if (USE_SELF) val = tile->rawData()[0];
7722  val = conditionalCallOperator<OPERANDS, USE_SELF>(op,
7723  val, aval, bval, cval);
7724  tile->makeConstant(val);
7725  }
7726  else
7727  {
7728  // Output is varying, so pre-uncompress our tile so
7729  // we can write directly with rawData.
7730  tile->uncompress();
7731  // The tile we uncompressed could well be one of the other operands;
7732  // thus, the increments must be updated.
7733  ainc = (OPERANDS < 1 || atile->isConstant()) ? 0 : 1;
7734  binc = (OPERANDS < 2 || btile->isConstant()) ? 0 : 1;
7735  cinc = (OPERANDS < 3 || ctile->isConstant()) ? 0 : 1;
7736  minc = (!MASKED || mtile->isConstant()) ? 0 : 1;
7737 
7738  const S* a_array = OPERANDS > 0 ? atile->rawData() : nullptr;
7739  const R* b_array = OPERANDS > 1 ? btile->rawData() : nullptr;
7740  const Q* c_array = OPERANDS > 2 ? ctile->rawData() : nullptr;
7741  const M* m_array = MASKED ? mtile->rawData() : nullptr;
7742  T* val_array = tile->rawData();
7743 
7744  int n = tile->numVoxels();
7745  for (int i = 0; i < n; i++)
7746  {
7747  if (!MASKED || (*m_array > ((M) 0.5)))
7748  {
7749  val_array[i] = conditionalCallOperator<OPERANDS, USE_SELF>(op,
7750  val_array[i], OPERANDS > 0 ? *a_array : aval,
7751  OPERANDS > 1 ? *b_array : bval,
7752  OPERANDS > 2 ? *c_array : cval);
7753  }
7754 
7755  // Move along the arrays...
7756  switch(OPERANDS)
7757  {
7758  case 3:
7759  c_array += cinc;
7760  SYS_FALLTHROUGH;
7761  case 2:
7762  b_array += binc;
7763  SYS_FALLTHROUGH;
7764  case 1:
7765  a_array += ainc;
7766  break;
7767  default:
7768  break;
7769  }
7770  if(MASKED)
7771  m_array += minc;
7772  }
7773  }
7774  }
7775 
7776  it.advanceTile();
7777  }
7778 }
7779 
7780 template <typename T>
7781 template <typename OP>
7782 void
7783 UT_VoxelArrayIterator<T>::applyOperation(const OP &op)
7784 {
7785  assignOperationOnIterator<0, false, true, T, OP, float, float, float, float>
7786  (*this, op, nullptr, nullptr, nullptr, nullptr);
7787 }
7788 
7789 template <typename T>
7790 template <typename OP, typename S>
7791 void
7792 UT_VoxelArrayIterator<T>::applyOperation(const OP &op,
7793  const UT_VoxelArray<S> &a)
7794 {
7795  UT_ASSERT(myArray->isMatching(a));
7796 
7797  assignOperationOnIterator<1, false, true, T, OP, S, float, float, float>
7798  (*this, op, &a, nullptr, nullptr, nullptr);
7799 }
7800 
7801 template <typename T>
7802 template <typename OP, typename S, typename R>
7803 void
7804 UT_VoxelArrayIterator<T>::applyOperation(const OP &op,
7805  const UT_VoxelArray<S> &a,
7806  const UT_VoxelArray<R> &b)
7807 {
7808  UT_ASSERT(myArray->isMatching(a));
7809  UT_ASSERT(myArray->isMatching(b));
7810 
7811  assignOperationOnIterator<2, false, true, T, OP, S, R, float, float>
7812  (*this, op, &a, &b, nullptr, nullptr);
7813 }
7814 
7815 template <typename T>
7816 template <typename OP, typename S, typename R, typename Q>
7817 void
7818 UT_VoxelArrayIterator<T>::applyOperation(const OP &op,
7819  const UT_VoxelArray<S> &a,
7820  const UT_VoxelArray<R> &b,
7821  const UT_VoxelArray<Q> &c)
7822 {
7823  UT_ASSERT(myArray->isMatching(a));
7824  UT_ASSERT(myArray->isMatching(b));
7825  UT_ASSERT(myArray->isMatching(c));
7826 
7827  assignOperationOnIterator<3, false, true, T, OP, S, R, Q, float>
7828  (*this, op, &a, &b, &c, nullptr);
7829 }
7830 
7831 template <typename T>
7832 template <typename OP, typename M>
7833 void
7834 UT_VoxelArrayIterator<T>::maskedApplyOperation(const OP &op,
7835  const UT_VoxelArray<M> &mask)
7836 {
7837  UT_ASSERT(myArray->isMatching(mask));
7838 
7839  assignOperationOnIterator<0, true, true, T, OP, float, float, float, M>
7840  (*this, op, nullptr, nullptr, nullptr, &mask);
7841 }
7842 
7843 template <typename T>
7844 template <typename OP, typename S, typename M>
7845 void
7846 UT_VoxelArrayIterator<T>::maskedApplyOperation(const OP &op,
7847  const UT_VoxelArray<S> &a,
7848  const UT_VoxelArray<M> &mask)
7849 {
7850  UT_ASSERT(myArray->isMatching(a));
7851  UT_ASSERT(myArray->isMatching(mask));
7852 
7853  assignOperationOnIterator<1, true, true, T, OP, S, float, float, M>
7854  (*this, op, &a, nullptr, nullptr, &mask);
7855 }
7856 
7857 template <typename T>
7858 template <typename OP, typename S, typename R, typename M>
7859 void
7860 UT_VoxelArrayIterator<T>::maskedApplyOperation(const OP &op,
7861  const UT_VoxelArray<S> &a,
7862  const UT_VoxelArray<R> &b,
7863  const UT_VoxelArray<M> &mask)
7864 {
7865  UT_ASSERT(myArray->isMatching(a));
7866  UT_ASSERT(myArray->isMatching(b));
7867  UT_ASSERT(myArray->isMatching(mask));
7868 
7869  assignOperationOnIterator<2, true, true, T, OP, S, R, float, M>
7870  (*this, op, &a, &b, nullptr, &mask);
7871 }
7872 
7873 template <typename T>
7874 template <typename OP, typename S, typename R, typename Q, typename M>
7875 void
7876 UT_VoxelArrayIterator<T>::maskedApplyOperation(const OP &op,
7877  const UT_VoxelArray<S> &a,
7878  const UT_VoxelArray<R> &b,
7879  const UT_VoxelArray<Q> &c,
7880  const UT_VoxelArray<M> &mask)
7881 {
7882  UT_ASSERT(myArray->isMatching(a));
7883  UT_ASSERT(myArray->isMatching(b));
7884  UT_ASSERT(myArray->isMatching(c));
7885  UT_ASSERT(myArray->isMatching(mask));
7886 
7887  assignOperationOnIterator<3, true, true, T, OP, S, R, Q, M>
7888  (*this, op, &a, &b, &c, &mask);
7889 }
7890 
7891 template <typename T>
7892 template <typename OP, typename S>
7893 void
7894 UT_VoxelArrayIterator<T>::assignOperation(const OP &op,
7895  const UT_VoxelArray<S> &a)
7896 {
7897  UT_ASSERT(myArray->isMatching(a));
7898 
7899  assignOperationOnIterator<1, false, false, T, OP, S, float, float, float>
7900  (*this, op, &a, nullptr, nullptr, nullptr);
7901 }
7902 
7903 template <typename T>
7904 template <typename OP, typename S, typename R>
7905 void
7906 UT_VoxelArrayIterator<T>::assignOperation(const OP &op,
7907  const UT_VoxelArray<S> &a,
7908  const UT_VoxelArray<R> &b)
7909 {
7910  UT_ASSERT(myArray->isMatching(a));
7911  UT_ASSERT(myArray->isMatching(b));
7912 
7913  assignOperationOnIterator<2, false, false, T, OP, S, R, float, float>
7914  (*this, op, &a, &b, nullptr, nullptr);
7915 }
7916 
7917 template <typename T>
7918 template <typename OP, typename S, typename R, typename Q>
7919 void
7920 UT_VoxelArrayIterator<T>::assignOperation(const OP &op,
7921  const UT_VoxelArray<S> &a,
7922  const UT_VoxelArray<R> &b,
7923  const UT_VoxelArray<Q> &c)
7924 {
7925  UT_ASSERT(myArray->isMatching(a));
7926  UT_ASSERT(myArray->isMatching(b));
7927  UT_ASSERT(myArray->isMatching(c));
7928 
7929  assignOperationOnIterator<3, false, false, T, OP, S, R, Q, float>
7930  (*this, op, &a, &b, &c, nullptr);
7931 }
7932 
7933 template <typename T>
7934 template <typename OP, typename S, typename M>
7935 void
7936 UT_VoxelArrayIterator<T>::maskedAssignOperation(const OP &op,
7937  const UT_VoxelArray<S> &a,
7938  const UT_VoxelArray<M> &mask)
7939 {
7940  UT_ASSERT(myArray->isMatching(a));
7941  UT_ASSERT(myArray->isMatching(mask));
7942 
7943  assignOperationOnIterator<1, true, false, T, OP, S, float, float, M>
7944  (*this, op, &a, nullptr, nullptr, &mask);
7945 }
7946 
7947 template <typename T>
7948 template <typename OP, typename S, typename R, typename M>
7949 void
7950 UT_VoxelArrayIterator<T>::maskedAssignOperation(const OP &op,
7951  const UT_VoxelArray<S> &a,
7952  const UT_VoxelArray<R> &b,
7953  const UT_VoxelArray<M> &mask)
7954 {
7955  UT_ASSERT(myArray->isMatching(a));
7956  UT_ASSERT(myArray->isMatching(b));
7957  UT_ASSERT(myArray->isMatching(mask));
7958 
7959  assignOperationOnIterator<2, true, false, T, OP, S, R, float, M>
7960  (*this, op, &a, &b, nullptr, &mask);
7961 }
7962 
7963 template <typename T>
7964 template <typename OP, typename S, typename R, typename Q, typename M>
7965 void
7966 UT_VoxelArrayIterator<T>::maskedAssignOperation(const OP &op,
7967  const UT_VoxelArray<S> &a,
7968  const UT_VoxelArray<R> &b,
7969  const UT_VoxelArray<Q> &c,
7970  const UT_VoxelArray<M> &mask)
7971 {
7972  UT_ASSERT(myArray->isMatching(a));
7973  UT_ASSERT(myArray->isMatching(b));
7974  UT_ASSERT(myArray->isMatching(c));
7975  UT_ASSERT(myArray->isMatching(mask));
7976 
7977  assignOperationOnIterator<3, true, false, T, OP, S, R, Q, M>
7978  (*this, op, &a, &b, &c, &mask);
7979 }
7980 
7981 template <typename T>
7982 template <typename OP>
7983 void
7984 UT_VoxelArrayIterator<T>::reduceOperation(OP &op)
7985 {
7986  rewind();
7987 
7988  while (!atEnd())
7989  {
7990  UT_VoxelTile<T> *tile;
7991 
7992  tile = myArray->getLinearTile(myCurTile);
7993 
7994  if (!tile->isSimpleCompression())
7995  {
7996  // Have to use getValue...
7997  for (int z = 0; z < tile->zres(); z++)
7998  for (int y = 0; y < tile->yres(); y++)
7999  for (int x = 0; x < tile->xres(); x++)
8000  {
8001  T val;
8002 
8003  val = tile->operator()(x, y, z);
8004 
8005  op.reduce(val);
8006  }
8007  }
8008  else if (tile->isConstant())
8009  {
8010  // Woohoo! Too simple!
8011  T val;
8012 
8013  val = tile->rawData()[0];
8014  int n = tile->numVoxels();
8015 
8016  op.reduceMany(val, n);
8017  }
8018  else
8019  {
8020  T *val;
8021 
8022  val = tile->rawData();
8023 
8024  int n = tile->numVoxels();
8025  for (int i = 0; i < n; i++)
8026  {
8027  op.reduce(val[i]);
8028  }
8029  }
8030 
8031  advanceTile();
8032  }
8033 }
8034 
8035 //
8036 // UT_VoxelTileIterator implementation
8037 //
8038 template <typename T>
8039 UT_VoxelTileIterator<T>::UT_VoxelTileIterator()
8040 {
8041  myCurTile = 0;
8042  myLinearTileNum = -1;
8043  myArray = 0;
8044  myAtEnd = true;
8045  myShouldCompressOnExit = false;
8046 }
8047 
8048 template <typename T>
8049 UT_VoxelTileIterator<T>::UT_VoxelTileIterator(const UT_VoxelArrayIterator<T> &vit)
8050 {
8051  myCurTile = 0;
8052  myLinearTileNum = -1;
8053  myArray = 0;
8054  myAtEnd = true;
8055  myShouldCompressOnExit = false;
8056  setTile(vit);
8057 }
8058 
8059 template <typename T>
8060 template <typename S>
8061 UT_VoxelTileIterator<T>::UT_VoxelTileIterator(const UT_VoxelArrayIterator<S> &vit, UT_VoxelArray<T> *array)
8062 {
8063  myCurTile = 0;
8064  myLinearTileNum = -1;
8065  myArray = 0;
8066  myAtEnd = true;
8067  myShouldCompressOnExit = false;
8068  setTile(vit, array);
8069 }
8070 
8071 template <typename T>
8072 UT_VoxelTileIterator<T>::~UT_VoxelTileIterator()
8073 {
8074 }
8075 
8076 template <typename T>
8077 void
8078 UT_VoxelTileIterator<T>::rewind()
8079 {
8080  // Ensure we have at least one voxel in each direction
8081  if (!myCurTile ||
8082  !myCurTile->xres() || !myCurTile->yres() || !myCurTile->zres())
8083  {
8084  myCurTile = 0;
8085  return;
8086  }
8087 
8088  myPos[0] = myTileStart[0];
8089  myPos[1] = myTileStart[1];
8090  myPos[2] = myTileStart[2];
8091 
8092  myTileLocalPos[0] = 0;
8093  myTileLocalPos[1] = 0;
8094  myTileLocalPos[2] = 0;
8095 
8096  myTileSize[0] = myCurTile->xres();
8097  myTileSize[1] = myCurTile->yres();
8098  myTileSize[2] = myCurTile->zres();
8099 
8100  myAtEnd = false;
8101 }
8102 
8103 template <typename T>
8104 void
8105 UT_VoxelTileIterator<T>::advanceTile()
8106 {
8107  if (getCompressOnExit())
8108  {
8109  // Verify our last tile was a legitimate one.
8110  if (myCurTile)
8111  {
8112  myCurTile->tryCompress(myArray->getCompressionOptions());
8113  }
8114  }
8115  myAtEnd = true;
8116 }
8117 
8118 template <typename T>
8119 template <typename OP>
8120 void
8121 UT_VoxelTileIterator<T>::applyOperation(const OP &op)
8122 {
8123  assignOperationOnIterator<0, false, true, T, OP, float, float, float, float>
8124  (*this, op, nullptr, nullptr, nullptr, nullptr);
8125 }
8126 
8127 template <typename T>
8128 template <typename OP, typename S>
8129 void
8130 UT_VoxelTileIterator<T>::applyOperation(const OP &op,
8131  const UT_VoxelArray<S> &a)
8132 {
8133  UT_ASSERT(myArray->isMatching(a));
8134 
8135  assignOperationOnIterator<1, false, true, T, OP, S, float, float, float>
8136  (*this, op, &a, nullptr, nullptr, nullptr);
8137 }
8138 
8139 template <typename T>
8140 template <typename OP, typename S, typename R>
8141 void
8142 UT_VoxelTileIterator<T>::applyOperation(const OP &op,
8143  const UT_VoxelArray<S> &a,
8144  const UT_VoxelArray<R> &b)
8145 {
8146  UT_ASSERT(myArray->isMatching(a));
8147  UT_ASSERT(myArray->isMatching(b));
8148 
8149  assignOperationOnIterator<2, false, true, T, OP, S, R, float, float>
8150  (*this, op, &a, &b, nullptr, nullptr);
8151 }
8152 
8153 template <typename T>
8154 template <typename OP, typename S, typename R, typename Q>
8155 void
8156 UT_VoxelTileIterator<T>::applyOperation(const OP &op,
8157  const UT_VoxelArray<S> &a,
8158  const UT_VoxelArray<R> &b,
8159  const UT_VoxelArray<Q> &c)
8160 {
8161  UT_ASSERT(myArray->isMatching(a));
8162  UT_ASSERT(myArray->isMatching(b));
8163  UT_ASSERT(myArray->isMatching(c));
8164 
8165  assignOperationOnIterator<3, false, true, T, OP, S, R, Q, float>
8166  (*this, op, &a, &b, &c, nullptr);
8167 }
8168 
8169 template <typename T>
8170 template <typename OP, typename S>
8171 void
8172 UT_VoxelTileIterator<T>::assignOperation(const OP &op,
8173  const UT_VoxelArray<S> &a)
8174 {
8175  UT_ASSERT(myArray->isMatching(a));
8176 
8177  assignOperationOnIterator<1, false, false, T, OP, S, float, float, float>
8178  (*this, op, &a, nullptr, nullptr, nullptr);
8179 }
8180 
8181 template <typename T>
8182 template <typename OP, typename S, typename R>
8183 void
8184 UT_VoxelTileIterator<T>::assignOperation(const OP &op,
8185  const UT_VoxelArray<S> &a,
8186  const UT_VoxelArray<R> &b)
8187 {
8188  UT_ASSERT(myArray->isMatching(a));
8189  UT_ASSERT(myArray->isMatching(b));
8190 
8191  assignOperationOnIterator<2, false, false, T, OP, S, R, float, float>
8192  (*this, op, &a, &b, nullptr, nullptr);
8193 }
8194 
8195 template <typename T>
8196 template <typename OP, typename S, typename R, typename Q>
8197 void
8198 UT_VoxelTileIterator<T>::assignOperation(const OP &op,
8199  const UT_VoxelArray<S> &a,
8200  const UT_VoxelArray<R> &b,
8201  const UT_VoxelArray<Q> &c)
8202 {
8203  UT_ASSERT(myArray->isMatching(a));
8204  UT_ASSERT(myArray->isMatching(b));
8205  UT_ASSERT(myArray->isMatching(c));
8206 
8207  assignOperationOnIterator<3, false, false, T, OP, S, R, Q, float>
8208  (*this, op, &a, &b, &c, nullptr);
8209 }
8210 
8211 template <typename T>
8212 template <typename OP>
8213 bool
8214 UT_VoxelTileIterator<T>::reduceOperation(OP &op)
8215 {
8216  rewind();
8217 
8218  if (!myCurTile->isSimpleCompression())
8219  {
8220  // Have to use getValue...
8221  for (int z = 0; z < myTileSize[2]; z++)
8222  for (int y = 0; y < myTileSize[1]; y++)
8223  for (int x = 0; x < myTileSize[0]; x++)
8224  {
8225  T val;
8226 
8227  val = myCurTile->operator()(x, y, z);
8228 
8229  if (!op.reduce(val))
8230  return false;
8231  }
8232  }
8233  else if (myCurTile->isConstant())
8234  {
8235  // Woohoo! Too simple!
8236  T val;
8237 
8238  val = myCurTile->rawData()[0];
8239  int n = myCurTile->numVoxels();
8240 
8241  if (!op.reduceMany(val, n))
8242  return false;
8243  }
8244  else
8245  {
8246  T *val;
8247 
8248  val = myCurTile->rawData();
8249 
8250  int n = myCurTile->numVoxels();
8251  for (int i = 0; i < n; i++)
8252  {
8253  if (!op.reduce(val[i]))
8254  return false;
8255  }
8256  }
8257  return true;
8258 }
8259 
8260 ///
8261 /// UT_VoxelProbe methods
8262 ///
8263 
8264 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8265 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::UT_VoxelProbe()
8266 {
8267  myCurLine = 0;
8268  myAllocCacheLine = 0;
8269  myDirty = false;
8270 
8271  myArray = 0;
8272 }
8273 
8274 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8275 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::UT_VoxelProbe(UT_VoxelArray<T> *vox, int prex, int postx)
8276 {
8277  // A sure signal it hasn't been reset.
8278  myCurLine = 0;
8279  myAllocCacheLine = 0;
8280  myDirty = false;
8281 
8282  setArray(vox, prex, postx);
8283 }
8284 
8285 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8286 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::~UT_VoxelProbe()
8287 {
8288  if (DoWrite)
8289  {
8290  if (!TestForWrites || myDirty)
8291  {
8292  // Final write...
8293  writeCacheLine();
8294  }
8295  }
8296  delete [] myAllocCacheLine;
8297 }
8298 
8299 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8300 void
8301 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::setArray(UT_VoxelArray<T> *vox, int prex, int postx)
8302 {
8303  // If in write-only mode, makes no sense to have prex and postx...
8304  if (!DoRead && (prex != 0 || postx != 0))
8305  {
8306  UT_ASSERT(!"Voxel probe cannot be padded if set to not read.");
8307  prex = 0;
8308  postx = 0;
8309  }
8310 
8311  // Round up our pre and post
8312  int prepad, postpad;
8313 
8314  myCurLine = 0;
8315 
8316  prepad = (prex - 3) / 4;
8317  postpad = (postx + 3) / 4;
8318 
8319  myAllocCacheLine = new T [TILESIZE - prepad*4 + postpad*4];
8320  myCacheLine = &myAllocCacheLine[-prepad * 4];
8321 
8322  myPreX = prex;
8323  myPostX = postx;
8324 
8325  myForceCopy = false;
8326  if (myPreX || myPostX)
8327  myForceCopy = true;
8328 
8329  myDirty = false;
8330 
8331  myArray = vox;
8332 }
8333 
8334 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8335 bool
8336 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::setIndex(int x, int y, int z)
8337 {
8338  // Check if we have to reload our cache.
8339  if (myCurLine && y == myY && z == myZ)
8340  {
8341  if (x < myMaxValidX)
8342  {
8343  if (x == myX+1)
8344  {
8345  // A simple advanceX sufficies
8346  advanceX();
8347  return false;
8348  }
8349  else if (x >= myMinValidX)
8350  {
8351  // We can just recenter our search location.
8352  resetX(x);
8353  // Other functions can't just do advanceX as that
8354  // just does ++ in X.
8355  return true;
8356  }
8357  }
8358  }
8359 
8360  // Store existing cache...
8361  if (DoWrite)
8362  {
8363  if (!TestForWrites || myDirty)
8364  writeCacheLine();
8365  }
8366 
8367  // Everything failed, return to reloading the cache.
8368  reloadCache(x, y, z);
8369 
8370  if (TestForWrites)
8371  myDirty = false;
8372 
8373  return true;
8374 }
8375 
8376 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8377 void
8378 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::reloadCache(int x, int y, int z)
8379 {
8380  UT_VoxelTile<T> *tile;
8381  bool xout = false, yout = false, zout = false;
8382  bool manualbuild = false;
8383 
8384  myX = x;
8385  myY = y;
8386  myZ = z;
8387  myMinValidX = x & ~TILEMASK;
8388  myMaxValidX = myMinValidX + TILESIZE;
8389  // UT_VoxelTile::fillCacheLine will fill in our cache up to the tile size;
8390  // we always want a full cache line, so we're on our own for the remainder.
8391  // This variable holds the number of voxels that need to be manually filled
8392  // in. Note that we should never access those out-of-bound voxels if we are
8393  // not reading--so don't bother filling in in that case.
8394  int topad = DoRead ? SYSmax(0, myMaxValidX - myArray->getXRes()) : 0;
8395 
8396  // We say that x is invalid only when the entire line is outside the array
8397  // proper.
8398  if (myMaxValidX <= 0 || myMinValidX >= myArray->getXRes())
8399  xout = true;
8400  if (y < 0 || y >= myArray->getYRes())
8401  yout = true;
8402  if (z < 0 || z >= myArray->getZRes())
8403  zout = true;
8404 
8405  // If y or z are invalid, they will be invalid for every voxel
8406  if (yout || zout)
8407  {
8408  // We can often handle this by clamping...
8409  switch (myArray->getBorder())
8410  {
8411  case UT_VOXELBORDER_CONSTANT:
8412  buildConstantCache(myArray->getBorderValue());
8413 
8414  // ALL DONE
8415  return;
8416 
8417  case UT_VOXELBORDER_REPEAT:
8418  // Simply modulate our lookup.
8419  if (yout)
8420  {
8421  y %= myArray->getYRes();
8422  if (y < 0)
8423  y += myArray->getYRes();
8424  }
8425  if (zout)
8426  {
8427  z %= myArray->getZRes();
8428  if (z < 0)
8429  z += myArray->getZRes();
8430  }
8431  break;
8432 
8433  case UT_VOXELBORDER_MIRROR:
8434  if (yout)
8435  y = UT_VoxelArray<T>::mirrorCoordinates(y, myArray->getYRes());
8436  if (zout)
8437  z = UT_VoxelArray<T>::mirrorCoordinates(z, myArray->getZRes());
8438  break;
8439 
8440  case UT_VOXELBORDER_STREAK:
8441  {
8442  // Clamp
8443  int tx = 0;
8444  myArray->clampIndex(tx, y, z);
8445  break;
8446  }
8447 
8448  case UT_VOXELBORDER_EXTRAP:
8449  {
8450  // Force a manual build.
8451  manualbuild = true;
8452  break;
8453  }
8454  }
8455  }
8456 
8457  // Note y and z may no longer equal myY and myZ, this is not
8458  // a problem however as we have set up our cached versions
8459  // to the unclamped versions.
8460 
8461  if (xout || manualbuild)
8462  {
8463  // We have to manually build if we are extrap or repeat type,
8464  // not just generate a single constant!
8465  if (myArray->getBorder() == UT_VOXELBORDER_EXTRAP ||
8466  myArray->getBorder() == UT_VOXELBORDER_REPEAT ||
8467  myArray->getBorder() == UT_VOXELBORDER_MIRROR)
8468  {
8469  manualbuild = true;
8470  }
8471 
8472  // If there is no pre & post, this will always be constant.
8473  if (!myPreX && !myPostX && !manualbuild)
8474  {
8475  buildConstantCache(myArray->getValue(x, y, z));
8476 
8477  // ALL DONE
8478  return;
8479  }
8480  else
8481  {
8482  // If we are STREAK or CONSTANT, we have a constant
8483  // value in our own cache.
8484  // If we are REPEAT, we want to modulo our x value
8485  // and run the normal code path.
8486  int i;
8487 
8488  for (i = myPreX; i < 0; i++)
8489  {
8490  myCacheLine[i] = myArray->getValue(myMinValidX+i, y, z);
8491  }
8492 
8493  if ((myArray->getBorder() == UT_VOXELBORDER_EXTRAP) ||
8494  (myArray->getBorder() == UT_VOXELBORDER_REPEAT) ||
8495  (myArray->getBorder() == UT_VOXELBORDER_MIRROR))
8496  {
8497  // Explicitly load extrap values as they are not constant.
8498  for (; i < TILESIZE; i++)
8499  myCacheLine[i] = myArray->getValue(myMinValidX+i, y, z);
8500  }
8501  else
8502  {
8503  // CONSTANT and STREAK will have constant values
8504  // in this
8505  T value = myArray->getValue(x, y, z);
8506  for (; i < TILESIZE; i++)
8507  {
8508  myCacheLine[i] = value;
8509  }
8510  }
8511 
8512  for (; i < TILESIZE + myPostX; i++)
8513  {
8514  myCacheLine[i] = myArray->getValue(myMinValidX+i, y, z);
8515  }
8516 
8517  myCurLine = &myCacheLine[x & TILEMASK];
8518  myStride = 1;
8519 
8520  // ALL DONE
8521  return;
8522  }
8523  }
8524 
8525  int xtile, ytile, ztile, tileidx;
8526  int lx, ly, lz;
8527  int i;
8528 
8529  xtile = x >> TILEBITS;
8530  ytile = y >> TILEBITS;
8531  ztile = z >> TILEBITS;
8532 
8533  // Get our local indices
8534  lx = x & TILEMASK;
8535  ly = y & TILEMASK;
8536  lz = z & TILEMASK;
8537 
8538  tileidx = (ztile * myArray->getTileRes(1) + ytile) * myArray->getTileRes(0);
8539 
8540  if (myPreX)
8541  {
8542  if (xtile)
8543  {
8544  // Simple to fetch...
8545  tile = myArray->getLinearTile(tileidx+xtile-1);
8546  for (i = myPreX; i < 0; i++)
8547  {
8548  // Safe to to & TILEMASK as we know earlier tiles
8549  // are always full...
8550  myCacheLine[i] = (*tile)(i & TILEMASK, ly, lz);
8551  }
8552  }
8553  else
8554  {
8555  if (myArray->getBorder() == UT_VOXELBORDER_REPEAT)
8556  {
8557  int resx = myArray->getXRes();
8558  int xpos;
8559 
8560  xpos = myPreX;
8561  xpos %= resx;
8562  // We add resx to guarantee we are in range.
8563  xpos += resx;
8564 
8565  // Manually invoke getValue()
8566  for (i = myPreX; i < 0; i++)
8567  {
8568  myCacheLine[i] = (*myArray)(xpos, y, z);
8569  xpos++;
8570  if (xpos > resx)
8571  xpos -= resx;
8572  }
8573  }
8574  else if (myArray->getBorder() == UT_VOXELBORDER_MIRROR)
8575  {
8576  int resx = myArray->getXRes();
8577  int resx2 = resx * 2;
8578  // Send the starting X position the the index within the array
8579  // and its one reflection.
8580  int xpos = myPreX % resx2;
8581  if (xpos < 0)
8582  xpos += resx2;
8583  // This is the increment. If we're on even repetitions of the
8584  // array, we move forward, otherwise we move backwards:
8585  // 0 1 2 3 4 5 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6
8586  // \-----------/ \-----------/ \-----------/
8587  // inside decreasing increasing
8588  int dir = 1;
8589  if (xpos >= resx)
8590  {
8591  dir = -1;
8592  xpos = resx2 - xpos - 1;
8593  }
8594 
8595  for (i = myPreX; i < 0; i++)
8596  {
8597  myCacheLine[i] = (*myArray)(xpos, y, z);
8598  xpos += dir;
8599  // If we finished a reflection in the backward direction,
8600  // restart going forward.
8601  if (xpos < 0)
8602  {
8603  xpos = 0;
8604  dir = 1;
8605  }
8606  // If we finished a reflection in the forward direction,
8607  // restart going backward.
8608  else if (xpos >= resx)
8609  {
8610  xpos = resx - 1;
8611  dir = -1;
8612  }
8613  }
8614  }
8615  else
8616  {
8617  T value;
8618 
8619  if (myArray->getBorder() == UT_VOXELBORDER_STREAK)
8620  {
8621  tile = myArray->getLinearTile(tileidx+xtile);
8622  value = (*tile)(0, ly, lz);
8623  }
8624  else
8625  value = myArray->getBorderValue();
8626 
8627  // Fill in value.
8628  for (i = myPreX; i < 0; i++)
8629  myCacheLine[i] = value;
8630  }
8631  }
8632  }
8633 
8634  if (myPostX)
8635  {
8636  int cachelen = TILESIZE;
8637  int resx = myArray->getXRes();
8638 
8639  // Append our end part in.
8640  // First, determine if we read past the end...
8641  if (myMaxValidX + myPostX > myArray->getXRes())
8642  {
8643  // This can be very messy. For example, we may have
8644  // a 1 wide tile after this tile and be looking two voxels
8645  // ahead, which means we can't guarantee our lookup
8646  // is entirely within one tile.
8647  // However, we can break it into two loops.
8648  int xpos = myMaxValidX;
8649 
8650  // Portion that still fits in the next tile...
8651  i = 0;
8652  if (xpos < resx)
8653  {
8654  tile = myArray->getLinearTile(tileidx+xtile+1);
8655  for (; i < myPostX && xpos < resx; i++)
8656  {
8657  myCacheLine[i + cachelen] = (*tile)(i, ly, lz);
8658  xpos++;
8659  }
8660  }
8661  // Portion that reads past the end.
8662  if (i < myPostX)
8663  {
8664  if (myArray->getBorder() == UT_VOXELBORDER_REPEAT)
8665  {
8666  xpos = xpos % resx;
8667 
8668  // Revert to the array operator.
8669  for (; i < myPostX; i++)
8670  {
8671  myCacheLine[i + cachelen] = (*myArray)(xpos, y, z);
8672  xpos++;
8673  if (xpos > resx)
8674  xpos -= resx;
8675  }
8676  }
8677  else if (myArray->getBorder() == UT_VOXELBORDER_MIRROR)
8678  {
8679  // We've just gone past the end of the array, so start
8680  // heading in the opposite direction.
8681  xpos = resx - 1;
8682  int dir = -1;
8683  for (; i < myPostX; i++)
8684  {
8685  myCacheLine[i + cachelen] = (*myArray)(xpos, y, z);
8686  xpos += dir;
8687  // If we finished a reflection in the backward direction,
8688  // restart going forward.
8689  if (xpos < 0)
8690  {
8691  xpos = 0;
8692  dir = 1;
8693  }
8694  // If we finished a reflection in the forward direction,
8695  // restart going backward.
8696  else if (xpos >= resx)
8697  {
8698  xpos = resx - 1;
8699  dir = -1;
8700  }
8701  }
8702  }
8703  else
8704  {
8705  T value;
8706 
8707  if (myArray->getBorder() == UT_VOXELBORDER_STREAK)
8708  {
8709  tile = myArray->getLinearTile(tileidx+xtile);
8710  value = (*tile)(tile->xres()-1, ly, lz);
8711  }
8712  else
8713  value = myArray->getBorderValue();
8714 
8715  for (; i < myPostX; i++)
8716  myCacheLine[i + cachelen] = value;
8717  }
8718  }
8719  }
8720  else
8721  {
8722  // All groovy, we fit in so thus must fit in the next tile
8723  tile = myArray->getLinearTile(tileidx+xtile+1);
8724  for (i = 0; i < myPostX; i++)
8725  {
8726  // Safe to to & TILEMASK as we know earlier tiles
8727  // are always full...
8728  myCacheLine[i + cachelen] = (*tile)(i, ly, lz);
8729  }
8730  }
8731 
8732  }
8733 
8734  tile = myArray->getLinearTile(tileidx+xtile);
8735  // We'll be filling in the rest of the cache line if padding needs to be
8736  // performed; thus, force copy in that case.
8737  myCurLine = tile->fillCacheLine(myCacheLine, myStride, lx, ly, lz,
8738  myForceCopy || topad > 0, DoWrite);
8739 
8740  // Pad the remainder of the cacheline.
8741  if (topad > 0)
8742  {
8743  // Make the array do the extrapolation for us...
8744  if ((myArray->getBorder() == UT_VOXELBORDER_EXTRAP) ||
8745  (myArray->getBorder() == UT_VOXELBORDER_REPEAT) ||
8746  (myArray->getBorder() == UT_VOXELBORDER_MIRROR))
8747  {
8748  for (i = topad; i > 0; i--)
8749  {
8750  myCacheLine[TILESIZE - i]
8751  = myArray->getValue(myMaxValidX - i, y, z);
8752  }
8753  }
8754  else
8755  {
8756  // The rest of the cache line is constant in these cases...
8757  T value;
8758  if (myArray->getBorder() == UT_VOXELBORDER_STREAK)
8759  // Streak: use the last internal value from the line.
8760  value = myCacheLine[TILESIZE - topad - 1];
8761  else
8762  // Constant: use the border value.
8763  value = myArray->getBorderValue();
8764 
8765  for (i = topad; i > 0; i--)
8766  {
8767  myCacheLine[TILESIZE - i] = value;
8768  }
8769  }
8770  }
8771 }
8772 
8773 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8774 void
8775 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::buildConstantCache(T value)
8776 {
8777  if (DoWrite)
8778  {
8779  // Force a full copy.
8780  myStride = 1;
8781 
8782  int i;
8783 
8784  for (i = myPreX; i < TILESIZE+myPostX; i++)
8785  myCacheLine[i] = value;
8786  myCurLine = myCacheLine;
8787  }
8788  else
8789  {
8790  myCacheLine[0] = value;
8791  // These are to ensure our SSE is compatible.
8792  myCacheLine[1] = value;
8793  myCacheLine[2] = value;
8794  myCacheLine[3] = value;
8795 
8796  myCurLine = myCacheLine;
8797  myStride = 0;
8798  }
8799 }
8800 
8801 template <typename T, bool DoRead, bool DoWrite, bool TestForWrites>
8802 void
8803 UT_VoxelProbe<T, DoRead, DoWrite, TestForWrites>::writeCacheLine()
8804 {
8805  if (!DoWrite)
8806  {
8807  UT_ASSERT(0);
8808  return;
8809  }
8810  // Ensure we have a valid loaded line, otherwise no point
8811  // doing a write back...
8812  if (!myCurLine)
8813  return;
8814 
8815  // Reset our current line...
8816  myCurLine -= myX - myMinValidX;
8817 
8818  // Determine if we actually have to write back,
8819  // if we had a pointer inside the tile we don't have to.
8820  if (myCurLine != myCacheLine)
8821  return;
8822 
8823  // Look up our voxel
8824  int xtile, ytile, ztile, y, z;
8825  UT_VoxelTile<T> *tile;
8826 
8827  xtile = myMinValidX >> TILEBITS;
8828  ytile = myY >> TILEBITS;
8829  ztile = myZ >> TILEBITS;
8830  y = myY & TILEMASK;
8831  z = myZ & TILEMASK;
8832 
8833  tile = myArray->getTile(xtile, ytile, ztile);
8834 
8835  // Write back our results
8836  tile->writeCacheLine(myCurLine, y, z);
8837 }
8838 
8839 ///
8840 /// VoxelProbeCube functions
8841 ///
8842 template <typename T>
8843 UT_VoxelProbeCube<T>::UT_VoxelProbeCube()
8844 {
8845  myValid = false;
8846 }
8847 
8848 template <typename T>
8849 UT_VoxelProbeCube<T>::~UT_VoxelProbeCube()
8850 {
8851 }
8852 
8853 template <typename T>
8854 void
8855 UT_VoxelProbeCube<T>::setConstCubeArray(const UT_VoxelArray<T> *vox)
8856 {
8857  UT_ASSERT(vox != nullptr);
8858  myLines[0][0].setConstArray(vox, -1, 1);
8859  myLines[0][1].setConstArray(vox, -1, 1);
8860  myLines[0][2].setConstArray(vox, -1, 1);
8861 
8862  myLines[1][0].setConstArray(vox, -1, 1);
8863  myLines[1][1].setConstArray(vox, -1, 1);
8864  myLines[1][2].setConstArray(vox, -1, 1);
8865 
8866  myLines[2][0].setConstArray(vox, -1, 1);
8867  myLines[2][1].setConstArray(vox, -1, 1);
8868  myLines[2][2].setConstArray(vox, -1, 1);
8869 
8870  myValid = false;
8871 }
8872 
8873 template <typename T>
8874 void
8875 UT_VoxelProbeCube<T>::setConstPlusArray(const UT_VoxelArray<T> *vox)
8876 {
8877  UT_ASSERT(vox != nullptr);
8878  /// This coudl be 0,0, but by keeping it the full range
8879  /// we ensure it is legal to rotate when we do a +1
8880  myLines[0][1].setConstArray(vox, -1, 1);
8881 
8882  myLines[1][0].setConstArray(vox, 0, 0);
8883  myLines[1][1].setConstArray(vox, -1, 1);
8884  myLines[1][2].setConstArray(vox, 0, 0);
8885 
8886  myLines[2][1].setConstArray(vox, -1, 1);
8887 
8888  myValid = false;
8889 }
8890 
8891 template <typename T>
8892 bool
8893 UT_VoxelProbeCube<T>::setIndexCube(int x, int y, int z)
8894 {
8895  if (myValid && myZ == z)
8896  {
8897  if (myY == y)
8898  {
8899  // Potential for a simple advance...
8900  if (x < myMaxValidX && x == myX+1)
8901  {
8902  // AdvanceX.
8903  myLines[0][0].advanceX();
8904  myLines[0][1].advanceX();
8905  myLines[0][2].advanceX();
8906 
8907  myLines[1][0].advanceX();
8908  myLines[1][1].advanceX();
8909  myLines[1][2].advanceX();
8910 
8911  myLines[2][0].advanceX();
8912  myLines[2][1].advanceX();
8913  myLines[2][2].advanceX();
8914 
8915  // Update our cache.
8916  myX = x;
8917 
8918  return false;
8919  }
8920  }
8921 #if 1
8922  else if (y == myY+1 && x < myMaxValidX && x >= myMinValidX)
8923  {
8924  // We have finished our x pass and just incremented y by one
8925  // Rather than resetting all our lines we can just swap
8926  // our y+1 lines into our current lines and then run the
8927  // normal reset.
8928  rotateLines(myLines[0][0], myLines[1][0], myLines[2][0]);
8929  rotateLines(myLines[0][1], myLines[1][1], myLines[2][1]);
8930  rotateLines(myLines[0][2], myLines[1][2], myLines[2][2]);
8931 
8932  // The first 6 lines can just reset their X values
8933  // directly
8934  myLines[0][0].resetX(x);
8935  myLines[0][1].resetX(x);
8936  myLines[0][2].resetX(x);
8937 
8938  myLines[1][0].resetX(x);
8939  myLines[1][1].resetX(x);
8940  myLines[1][2].resetX(x);
8941 
8942  // Only the new lines need a reload.
8943  myLines[2][0].setIndex(x, y+1, z-1);
8944  myLines[2][1].setIndex(x, y+1, z);
8945  myLines[2][2].setIndex(x, y+1, z+1);
8946 
8947  // Update the cache values that have changed.
8948  myX = x;
8949  myY = y;
8950 
8951  return true;
8952  }
8953 #endif
8954  }
8955 
8956  // Now just invoke setIndex on all children
8957  myLines[0][0].setIndex(x, y-1, z-1);
8958  myLines[0][1].setIndex(x, y-1, z);
8959  myLines[0][2].setIndex(x, y-1, z+1);
8960 
8961  myLines[1][0].setIndex(x, y, z-1);
8962  myLines[1][1].setIndex(x, y, z);
8963  myLines[1][2].setIndex(x, y, z+1);
8964 
8965  myLines[2][0].setIndex(x, y+1, z-1);
8966  myLines[2][1].setIndex(x, y+1, z);
8967  myLines[2][2].setIndex(x, y+1, z+1);
8968 
8969  // update our cache values
8970  myX = x;
8971  myY = y;
8972  myZ = z;
8973  myValid = true;
8974  myMinValidX = myLines[1][1].myMinValidX;
8975  myMaxValidX = myLines[1][1].myMaxValidX;
8976 
8977  return true;
8978 }
8979 
8980 template <typename T>
8981 bool
8982 UT_VoxelProbeCube<T>::setIndexPlus(int x, int y, int z)
8983 {
8984  if (myValid && myZ == z)
8985  {
8986  if (myY == y)
8987  {
8988  // Potential for a simple advance...
8989  if (x < myMaxValidX && x == myX+1)
8990  {
8991  // AdvanceX.
8992  myLines[0][1].advanceX();
8993 
8994  myLines[1][0].advanceX();
8995  myLines[1][1].advanceX();
8996  myLines[1][2].advanceX();
8997 
8998  myLines[2][1].advanceX();
8999 
9000  // Update our cache.
9001  myX = x;
9002 
9003  return false;
9004  }
9005  }
9006  else if (y == myY+1 && x < myMaxValidX && x >= myMinValidX)
9007  {
9008  // We have finished our x pass and just incremented y by one
9009  // We can thus rotate the meaning of our central
9010  // cache lines and just reset their x pointers, leaving
9011  // only three real resets to be done.
9012  rotateLines(myLines[0][1], myLines[1][1], myLines[2][1]);
9013 
9014  myLines[0][1].resetX(x);
9015  myLines[1][1].resetX(x);
9016 
9017  myLines[1][0].setIndex(x, y, z-1);
9018  myLines[1][2].setIndex(x, y, z+1);
9019 
9020  myLines[2][1].setIndex(x, y+1, z);
9021 
9022  myX = x;
9023  myY = y;
9024  return true;
9025  }
9026  }
9027 
9028  // Now just invoke setIndex on all children
9029  myLines[0][1].setIndex(x, y-1, z);
9030 
9031  myLines[1][0].setIndex(x, y, z-1);
9032  myLines[1][1].setIndex(x, y, z);
9033  myLines[1][2].setIndex(x, y, z+1);
9034 
9035  myLines[2][1].setIndex(x, y+1, z);
9036 
9037  // update our cache values
9038  myX = x;
9039  myY = y;
9040  myZ = z;
9041  myValid = true;
9042  myMinValidX = myLines[1][1].myMinValidX;
9043  myMaxValidX = myLines[1][1].myMaxValidX;
9044 
9045  return true;
9046 }
9047 
9048 template <typename T>
9049 fpreal64
9050 UT_VoxelProbeCube<T>::curvature(const UT_Vector3 &invvoxelsize) const
9051 {
9052  // These are our derivatives of Phi.
9053  fpreal64 Px, Py, Pz;
9054  fpreal64 Pxx, Pyy, Pzz;
9055  fpreal64 Pxy, Pxz, Pyz;
9056  fpreal64 gradlen;
9057  fpreal64 k;
9058 
9059  // Compute first derivatives.
9060  // dPhi = (Phi+1 - Phi-1) / 2 * dx
9061 
9062  Px = getValue(1, 0, 0) - getValue(-1, 0, 0);
9063  Px *= 0.5 * invvoxelsize.x();
9064 
9065  Py = getValue(0, 1, 0) - getValue(0, -1, 0);
9066  Py *= 0.5 * invvoxelsize.y();
9067 
9068  Pz = getValue(0, 0, 1) - getValue(0, 0, -1);
9069  Pz *= 0.5 * invvoxelsize.z();
9070 
9071  // Compute second derivatives. (Note Pxy == Pyx)
9072 
9073  // d^2Phi = (Phi+1 - 2 Phi + Phi-1) / (dx*dx)
9074  Pxx = getValue(1, 0, 0)
9075  - 2 * getValue(0, 0, 0)
9076  + getValue(-1, 0, 0);
9077  Pxx *= invvoxelsize.x() * invvoxelsize.x();
9078 
9079  Pyy = getValue(0, 1, 0)
9080  - 2 * getValue(0, 0, 0)
9081  + getValue(0, -1, 0);
9082  Pyy *= invvoxelsize.y() * invvoxelsize.y();
9083 
9084  Pzz = getValue(0, 0, 1)
9085  - 2 * getValue(0, 0, 0)
9086  + getValue(0, 0, -1);
9087  Pzz *= invvoxelsize.z() * invvoxelsize.z();
9088 
9089  // A bit more complicated :>
9090  Pxy = getValue(1, 1,0) - getValue(-1, 1,0);
9091  Pxy -= getValue(1,-1,0) - getValue(-1,-1,0);
9092  Pxy *= 0.25 * invvoxelsize.x() * invvoxelsize.y();
9093 
9094  Pxz = getValue(1,0, 1) - getValue(-1,0, 1);
9095  Pxz -= getValue(1,0,-1) - getValue(-1,0,-1);
9096  Pxz *= 0.25 * invvoxelsize.x() * invvoxelsize.z();
9097 
9098  Pyz = getValue(0,1, 1) - getValue(0,-1, 1);
9099  Pyz -= getValue(0,1,-1) - getValue(0,-1,-1);
9100  Pyz *= 0.25 * invvoxelsize.y() * invvoxelsize.z();
9101 
9102  // Calculate the |grad(phi)| term;
9103  gradlen = SYSsqrt(Px * Px + Py * Py + Pz * Pz);
9104 
9105  // Finally, our curvature!
9106  // This is equation 1.8 from the holy book.
9107  // The problem is that it implies that 0 gradient means 0 curvature.
9108  // This is not true!
9109  // Even if Px,Py,Pz == 0, if Pxx != 0, we have a curved surface
9110  // consider a point at the maxima of a circle.
9111  k = Px*Px * (Pyy + Pzz) + Py*Py * (Pxx + Pzz) + Pz*Pz * (Pxx + Pyy);
9112  k -= 2 * (Pxy*Px*Py + Pyz*Py*Pz + Pxz*Px*Pz);
9113 
9114  // Avoid #IND in places with exactly zero curvature.
9115  if (!gradlen)
9116  k = 0;
9117  else
9118  k /= gradlen * gradlen * gradlen;
9119 
9120  // Clamp our curvature...
9121  fpreal64 maxk;
9122 
9123  maxk = invvoxelsize.maxComponent();
9124  if (k < -maxk)
9125  k = -maxk;
9126  if (k > maxk)
9127  k = maxk;
9128 
9129  return k;
9130 }
9131 
9132 template <typename T>
9133 fpreal64
9134 UT_VoxelProbeCube<T>::laplacian(const UT_Vector3 &invvoxelsize) const
9135 {
9136  fpreal64 Pxx, Pyy, Pzz;
9137  fpreal64 centralval;
9138 
9139  centralval = getValue(0, 0, 0);
9140 
9141  // d^2Phi = (Phi+1 - 2 Phi + Phi-1) / (dx*dx)
9142  Pxx = getValue(1, 0, 0)
9143  - 2 * centralval
9144  + getValue(-1, 0, 0);
9145  Pxx *= invvoxelsize.x() * invvoxelsize.x();
9146 
9147  Pyy = getValue(0, 1, 0)
9148  - 2 * centralval
9149  + getValue(0, -1, 0);
9150  Pyy *= invvoxelsize.y() * invvoxelsize.y();
9151 
9152  Pzz = getValue(0, 0, +1)
9153  - 2 * centralval
9154  + getValue(0, 0, -1);
9155  Pzz *= invvoxelsize.z() * invvoxelsize.z();
9156 
9157  return Pxx + Pyy + Pzz;
9158 }
9159 
9160 template <typename T>
9161 void
9162 UT_VoxelProbeCube<T>::rotateLines(UT_VoxelProbe<T, true, false, false> &ym,
9163  UT_VoxelProbe<T, true, false, false> &y0,
9164  UT_VoxelProbe<T, true, false, false> &yp)
9165 {
9166  T *tmpcache, *tmpalloc;
9167 
9168  // We take advantage of the fact we know only a small portion
9169  // of the cache lines needs to be copied.
9170  tmpcache = ym.myCacheLine;
9171  tmpalloc = ym.myAllocCacheLine;
9172  //const T *tmpcur = ym.myCurLine;
9173 
9174  ym.myCacheLine = y0.myCacheLine;
9175  ym.myAllocCacheLine = y0.myAllocCacheLine;
9176  ym.myCurLine = y0.myCurLine;
9177  ym.myStride = y0.myStride;
9178  ym.myY++;
9179 
9180  y0.myCacheLine = yp.myCacheLine;
9181  y0.myAllocCacheLine = yp.myAllocCacheLine;
9182  y0.myCurLine = yp.myCurLine;
9183  y0.myStride = yp.myStride;
9184  y0.myY++;
9185 
9186  yp.myCacheLine = tmpcache;
9187  yp.myAllocCacheLine = tmpalloc;
9188  // Setting to zero will force a rebuild.
9189  yp.myCurLine = 0;
9190 }
9191 
9192 ///
9193 /// UT_VoxelProbeFace methods
9194 ///
9195 template <typename T>
9196 UT_VoxelProbeFace<T>::UT_VoxelProbeFace()
9197 {
9198  myValid = false;
9199 }
9200 
9201 template <typename T>
9202 UT_VoxelProbeFace<T>::~UT_VoxelProbeFace()
9203 {
9204 }
9205 
9206 
9207 template <typename T>
9208 void
9209 UT_VoxelProbeFace<T>::setArray(const UT_VoxelArray<T> *vx, const UT_VoxelArray<T> *vy, const UT_VoxelArray<T> *vz)
9210 {
9211  // We need one extra to the right on the X probe
9212  myLines[0][0].setConstArray(vx, 0, 1);
9213 
9214  // The rest can be direct reads
9215  myLines[1][0].setConstArray(vy, 0, 0);
9216  myLines[1][1].setConstArray(vy, 0, 0);
9217 
9218  myLines[2][0].setConstArray(vz, 0, 0);
9219  myLines[2][1].setConstArray(vz, 0, 0);
9220 
9221  myValid = false;
9222 }
9223 
9224 template <typename T>
9225 void
9226 UT_VoxelProbeFace<T>::setVoxelSize(const UT_Vector3 &size)
9227 {
9228  myVoxelSize = size;
9229  myInvVoxelSize = 1;
9230  myInvVoxelSize /= myVoxelSize;
9231 }
9232 
9233 template <typename T>
9234 bool
9235 UT_VoxelProbeFace<T>::setIndex(int x, int y, int z)
9236 {
9237  if (myValid && myZ == z)
9238  {
9239  if (myY == y)
9240  {
9241  // Potential for a simple advance...
9242  if (x < myMaxValidX && x == myX+1)
9243  {
9244  // AdvanceX.
9245  myLines[0][0].advanceX();
9246 
9247  myLines[1][0].advanceX();
9248  myLines[1][1].advanceX();
9249 
9250  myLines[2][0].advanceX();
9251  myLines[2][1].advanceX();
9252 
9253  // Update our cache.
9254  myX = x;
9255 
9256  return false;
9257  }
9258  }
9259  else if (y == myY+1 && x < myMaxValidX && x >= myMinValidX)
9260  {
9261  // We have finished our x pass and just incremented y by one
9262  // We can swap our y lines to get to the next read for
9263  // those lines.
9264  swapLines(myLines[1][0], myLines[1][1]);
9265 
9266  myLines[1][0].resetX(x);
9267 
9268  // All the other lines need to be reloaded.
9269  myLines[0][0].setIndex(x, y, z);
9270  myLines[1][1].setIndex(x, y+1, z);
9271 
9272  myLines[2][0].setIndex(x, y, z);
9273  myLines[2][1].setIndex(x, y, z+1);
9274 
9275  myX = x;
9276  myY = y;
9277  return true;
9278  }
9279  }
9280 
9281  // Now just invoke setIndex on all children
9282  myLines[0][0].setIndex(x, y, z);
9283 
9284  myLines[1][0].setIndex(x, y, z);
9285  myLines[1][1].setIndex(x, y+1, z);
9286 
9287  myLines[2][0].setIndex(x, y, z);
9288  myLines[2][1].setIndex(x, y, z+1);
9289 
9290  // update our cache values
9291  myX = x;
9292  myY = y;
9293  myZ = z;
9294  myValid = true;
9295  myMinValidX = myLines[0][0].myMinValidX;
9296  myMaxValidX = myLines[0][0].myMaxValidX;
9297 
9298  return true;
9299 }
9300 
9301 template <typename T>
9302 void
9303 UT_VoxelProbeFace<T>::swapLines(UT_VoxelProbe<T, true, false, false> &ym,
9304  UT_VoxelProbe<T, true, false, false> &yp)
9305 {
9306  T *tmpcache, *tmpalloc;
9307 
9308  // We take advantage of the fact we know only a small portion
9309  // of the cache lines needs to be copied.
9310  tmpcache = ym.myCacheLine;
9311  tmpalloc = ym.myAllocCacheLine;
9312  //const T *tmpcur = ym.myCurLine;
9313 
9314  ym.myCacheLine = yp.myCacheLine;
9315  ym.myAllocCacheLine = yp.myAllocCacheLine;
9316  ym.myCurLine = yp.myCurLine;
9317  ym.myStride = yp.myStride;
9318  ym.myY++;
9319 
9320  yp.myCacheLine = tmpcache;
9321  yp.myAllocCacheLine = tmpalloc;
9322  // Setting to zero will force a rebuild.
9323  yp.myCurLine = 0;
9324 }
9325 
9326 ///
9327 /// VoxelProbeAverage methods
9328 ///
9329 template <typename T, int XStep, int YStep, int ZStep>
9330 void
9331 UT_VoxelProbeAverage<T, XStep, YStep, ZStep>::setArray(const UT_VoxelArray<T> *vox)
9332 {
9333  int prex = (XStep < 0) ? XStep : 0;
9334  int postx = (XStep > 0) ? XStep : 0;
9335 
9336  myLines[0][0].setArray((UT_VoxelArray<T> *)vox, prex, postx);
9337  if (YStep)
9338  {
9339  myLines[1][0].setArray((UT_VoxelArray<T> *)vox, prex, postx);
9340  if (ZStep)
9341  {
9342  myLines[1][1].setArray((UT_VoxelArray<T> *)vox, prex, postx);
9343  }
9344  }
9345  if (ZStep)
9346  myLines[0][1].setArray((UT_VoxelArray<T> *)vox, prex, postx);
9347 }
9348 
9349 template <typename T, int XStep, int YStep, int ZStep>
9350 bool
9351 UT_VoxelProbeAverage<T, XStep, YStep, ZStep>::setIndex(int x, int y, int z)
9352 {
9353  bool result = false;
9354 
9355  // Adjust x, y, and z according to our half step.
9356  // y and z negative steps require us decrementing. x steps
9357  // do not require a change as we use the pre/post to affect this,
9358  // if we adjusted the actual x we would get twice the cache misses.
9359  if (YStep < 0)
9360  y--;
9361  if (ZStep < 0)
9362  z--;
9363 
9364  result |= myLines[0][0].setIndex(x, y, z);
9365  if (YStep)
9366  {
9367  result |= myLines[1][0].setIndex(x, y+1, z);
9368  if (ZStep)
9369  result |= myLines[1][1].setIndex(x, y+1, z+1);
9370  }
9371  if (ZStep)
9372  result |= myLines[0][1].setIndex(x, y, z+1);
9373 
9374  return result;
9375 }
UT_JSONWriter::uniformWrite
bool uniformWrite(bool value)
UT_VoxelTileIterator::UT_VoxelTileIterator
UT_VoxelTileIterator()
Definition: UT_VoxelArray.C:8039
UT_IStream::readBinaryString
bool readBinaryString(UT_String &str, UT_ISTREAM_RLE_IO startbits)
UT_VoxelArrayIterator::x
int x() const
Retrieve the current location of the iterator.
Definition: UT_VoxelArray.h:1745
detail::type
type
Definition: core.h:556
UT_VoxelArrayIterator::applyOperation
void applyOperation(const OP &op)
Definition: UT_VoxelArray.C:7783
SYSmax
#define SYSmax(a, b)
Definition: SYS_Math.h:1582
UT_JSONWriter::jsonValue
bool jsonValue(bool value)
Definition: UT_JSONWriter.h:175
UT_JSONWriter::beginUniformArray
bool beginUniformArray(int64 length, UT_JID id)
UT_Filter.h
UT_VoxelArray::findexToPos
void findexToPos(UT_Vector3F ipos, UT_Vector3F &pos) const
Definition: UT_VoxelArray.C:5988
int
typedef int(APIENTRYP RE_PFNGLXSWAPINTERVALSGIPROC)(int)
GA_Names::dist
GA_API const UT_StringHolder dist
UT_VoxelArray::lerpSample
SYS_FORCE_INLINE T lerpSample(T *samples, float fx, float fy, float fz) const
Lerps the given sample using trilinear interpolation.
Definition: UT_VoxelArray.C:4186
__linearTileIndexConverter::myYSkipLen
int myYSkipLen
Definition: UT_VoxelArray.C:5472
UTparallelFor
void UTparallelFor(const Range &range, const Body &body, const int subscribe_ratio=2, const int min_grain_size=1, const bool force_use_task_scope=true)
Definition: UT_ParallelUtil.h:294
UT_VoxelTile::operator=
const UT_VoxelTile< T > & operator=(const UT_VoxelTile< T > &src)
Definition: UT_VoxelArray.C:142
ut_VoxelMipMapSortCompare
Definition: UT_VoxelArray.C:6891
UT_VoxelProbe::setArray
void setArray(UT_VoxelArray< T > *vox, int prex=0, int postx=0)
UT_VoxelArrayIterator::getTile
UT_VoxelTile< T > * getTile() const
Returns the VoxelTile we are currently processing.
Definition: UT_VoxelArray.h:1818
UT_VoxelTile::findAverage
void findAverage(T &avg) const
Determines the average value of the tile.
Definition: UT_VoxelArray.C:1756
UT_JSONParser::parseString
bool parseString(UT_WorkBuffer &v)
int32
int int32
Definition: SYS_Types.h:39
range
GLenum GLint * range
Definition: glcorearb.h:1925
UT_VoxelArrayIterator::setInterrupt
void setInterrupt(UT_Interrupt *interrupt)
Definition: UT_VoxelArray.h:1690
UT_FilterWindow::getVisible
float getVisible() const
Definition: UT_Filter.h:82
UT_VoxelArray::loadData
void loadData(UT_IStream &is)
Load an array, requires you have already size()d this array.
Definition: UT_VoxelArray.C:6109
COUNT_NONZERO
#define COUNT_NONZERO(VAL, COUNT)
UT_VoxelArray::getBorder
UT_VoxelBorderType getBorder() const
Definition: UT_VoxelArray.h:1274
UT_WorkBuffer
Definition: UT_WorkBuffer.h:74
UT_VoxelArrayIterator::splitByTile
void splitByTile(const UT_JobInfo &info)
Definition: UT_VoxelArray.C:7124
UT_VoxelTile::getDataLength
exint getDataLength() const
Returns the amount of data used by the tile myData pointer.
Definition: UT_VoxelArray.C:2204
UT_FromUnbounded
UT_FromUnbounded creates a V from an unbounded array-like type.
Definition: UT_Matrix2.h:733
UT_VoxelArrayIterator::atEnd
bool atEnd() const
Returns true if we have iterated over all of the voxels.
Definition: UT_VoxelArray.h:1709
UT_VoxelMipMap::myNumLevels
int myNumLevels
Definition: UT_VoxelArray.h:1587
UT_VoxelTileIterator
Definition: UT_VoxelArray.h:1990
UT_VoxelArray::match
void match(const UT_VoxelArray< T > &src)
Definition: UT_VoxelArray.C:3362
UT_ThreadedAlgorithm.h
UT_VoxelCompressOptions::myConstantTol
fpreal myConstantTol
Definition: UT_VoxelArray.h:119
UT_VoxelTile::UT_VoxelTile
UT_VoxelTile()
Definition: UT_VoxelArray.C:100
UT_JSONWriter::jidFromValue
static UT_JID jidFromValue(const bool *)
Returns the JID that matches the given type.
Definition: UT_JSONWriter.h:331
UT_VoxelMipMap::UT_VoxelMipMap
UT_VoxelMipMap()
Definition: UT_VoxelArray.C:6508
UT_BoundingBoxT< float >
UT_VoxelProbeCube::UT_VoxelProbeCube
UT_VoxelProbeCube()
Definition: UT_VoxelArray.C:8843
UT_VoxelTileCompress::getName
virtual const char * getName()=0
UT_VoxelArrayIterator::restrictToBBox
void restrictToBBox(const UT_BoundingBox &bbox)
Definition: UT_VoxelArray.C:7140
UT_VoxelMipMap::traverseTopDownSorted
void traverseTopDownSorted(OP &op) const
Definition: UT_VoxelArray.C:6886
UT_VoxelArray::resample
void resample(const UT_VoxelArray< T > &src, UT_FilterType filtertype=UT_FILTER_POINT, float filterwidthscale=1.0f, int clampaxis=-1)
Fills this by resampling the given voxel array.
Definition: UT_VoxelArray.C:4738
UTswap
void UTswap(T &a, T &b)
Definition: UT_Swap.h:35
UT_VoxelTile::CompressionType
CompressionType
Definition: UT_VoxelArray.h:310
UT_VoxelArray::getMemoryUsage
int64 getMemoryUsage(bool inclusive) const
Return the amount of memory used by this array.
Definition: UT_VoxelArray.C:3381
data
GLboolean * data
Definition: glcorearb.h:131
__linearTileIndexConverter::getNTilesIP
int getNTilesIP() const
Definition: UT_VoxelArray.C:5392
UT_VoxelArrayJSON::TILE_COMPRESSION
Definition: UT_VoxelArrayJSON.h:34
UT_COWReadHandle
Definition: DEP_ContextOptionsFwd.h:15
UT_Vector4T::y
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector4.h:493
UTparallelForEachNumber
void UTparallelForEachNumber(IntType nitems, const Body &body, const bool force_use_task_scope=true)
Definition: UT_ParallelUtil.h:405
v
const GLdouble * v
Definition: glcorearb.h:837
UT_VoxelArray::operator()
T operator()(UT_Vector3D pos) const
Definition: UT_VoxelArray.C:4307
UT_VOXELBORDER_MIRROR
Definition: UT_VoxelArray.h:76
UT_VoxelTile::numVoxels
int numVoxels() const
Definition: UT_VoxelArray.h:479
start
GLuint start
Definition: glcorearb.h:475
UT_VoxelTile::rawData
T * rawData()
Definition: UT_VoxelArray.h:462
value
GLsizei const GLfloat * value
Definition: glcorearb.h:824
UT_VoxelTile
Definition: UT_VoxelArray.h:79
UT_VoxelProbe::myStride
int myStride
Definition: UT_VoxelArray.h:2309
OBJ_MatchTransform::R
UT_IStream
Definition: UT_IStream.h:56
UT_VoxelArrayJSON::ARRAY_TILEDARRAY
Definition: UT_VoxelArrayJSON.h:26
UT_VoxelTileCompress::getValue
virtual T getValue(const UT_VoxelTile< T > &tile, int x, int y, int z) const =0
ImageBufAlgo::compare
CompareResults OIIO_API compare(const ImageBuf &A, const ImageBuf &B, float failthresh, float warnthresh, float failrelative, float warnrelative, ROI roi={}, int nthreads=0)
__linearTileIndexConverter
Definition: UT_VoxelArray.C:5359
UT_VoxelTile::fillCacheLine
T * fillCacheLine(T *cacheline, int &stride, int x, int y, int z, bool forcecopy, bool strideofone) const
Definition: UT_VoxelArray.C:1201
UT_VoxelTile::registerCompressionEngine
static void registerCompressionEngine(UT_VoxelTileCompress< T > *engine)
Definition: UT_VoxelArray.C:2565
UT_VoxelCompressOptions::myQuantizeTol
fpreal myQuantizeTol
Tolerance for quantizing to reduced bit depth.
Definition: UT_VoxelArray.h:121
lerp
virtual bool lerp(GA_AttributeOperand &d, GA_AttributeOperand &a, GA_AttributeOperand &b, GA_AttributeOperand &t) const
d = SYSlerp(a, b, t);
UT_JSONWriter.h
UT_VOXEL_ALLOC
#define UT_VOXEL_ALLOC(x)
Definition: UT_VoxelArray.h:52
SYSconst_cast
SYS_FORCE_INLINE T * SYSconst_cast(const T *foo)
Definition: SYS_Types.h:136
z
GLdouble GLdouble GLdouble z
Definition: glcorearb.h:848
SYS_SharedMemory::size
exint size() const
Returns the size of the shared memory, in bytes.
UT_Vector3.h
UT_VoxelMipMap::traverseTopDown
void traverseTopDown(Callback function, void *data) const
Definition: UT_VoxelArray.C:6687
UT_VoxelProbe::reloadCache
void reloadCache(int x, int y, int z)
UT_VoxelProbe::myForceCopy
bool myForceCopy
Definition: UT_VoxelArray.h:2310
UT_VOXELBORDER_CONSTANT
Definition: UT_VoxelArray.h:72
UT_VoxelMipMap::myBaseLevel
UT_VoxelArray< T > * myBaseLevel
Definition: UT_VoxelArray.h:1581
UT_Vector3T::z
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector3.h:667
exint
int64 exint
Definition: SYS_Types.h:125
UT_BoundingBoxT::maxvec
UT_Vector3T< T > maxvec() const
Definition: UT_BoundingBox.h:120
level
GLint level
Definition: glcorearb.h:108
SYSisNan
constexpr bool SYSisNan(const F f)
Definition: SYS_Math.h:184
UT_IStream.h
UT_WorkBuffer::buffer
SYS_FORCE_INLINE const char * buffer() const
Definition: UT_WorkBuffer.h:169
UT_VoxelProbe::myDirty
bool myDirty
Definition: UT_VoxelArray.h:2316
UT_VoxelArrayIterator::setValue
void setValue(T t) const
Sets the voxel we are currently pointing to the given value.
Definition: UT_VoxelArray.h:1766
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1222
UT_VoxelBorderType
UT_VoxelBorderType
Definition: UT_VoxelArray.h:70
SYSabs
#define SYSabs(a)
Definition: SYS_Math.h:1584
UT_FilterWrap
UT_FilterWrap
Definition: UT_FilterType.h:40
UT_JSONParser::beginArray
iterator beginArray()
Definition: UT_JSONParser.h:703
UT_JSONParser
JSON reader class which handles parsing of JSON or bJSON files.
Definition: UT_JSONParser.h:87
UT_VoxelArray::posToIndex
bool posToIndex(UT_Vector3 pos, int &x, int &y, int &z) const
Definition: UT_VoxelArray.C:5852
ImageBufAlgo::min
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
UT_VOXELBORDER_EXTRAP
Definition: UT_VoxelArray.h:75
UT_VoxelProbeCube::setConstPlusArray
void setConstPlusArray(const UT_VoxelArray< T > *vox)
Definition: UT_VoxelArray.C:8875
UT_VoxelProbe::myAllocCacheLine
T * myAllocCacheLine
Definition: UT_VoxelArray.h:2305
UT_VoxelProbe::myArray
UT_VoxelArray< T > * myArray
Definition: UT_VoxelArray.h:2318
UT_VoxelArrayIterator::setArray
void setArray(UT_VoxelArray< T > *vox)
Definition: UT_VoxelArray.h:1627
y
GLint y
Definition: glcorearb.h:103
UT_FilterWindow::getStart
int getStart() const
Definition: UT_Filter.h:79
UT_JSONWriter
Class which writes ASCII or binary JSON streams.
Definition: UT_JSONWriter.h:37
UT_VoxelArrayIterator::myTilePos
int myTilePos[3]
Which tile we are as per tx,ty,tz rather than linear index.
Definition: UT_VoxelArray.h:1961
UTparallelForLightItems
void UTparallelForLightItems(const Range &range, const Body &body, const bool force_use_task_scope=true)
Definition: UT_ParallelUtil.h:361
UTserialForEachNumber
void UTserialForEachNumber(IntType nitems, const Body &body, bool usetaskscope=true)
Definition: UT_ParallelUtil.h:436
UT_VoxelArray::copyWithOffset
void copyWithOffset(const UT_VoxelArray< T > &src, int offx, int offy, int offz)
Definition: UT_VoxelArray.C:5593
result
**But if you need a result
Definition: thread.h:622
UT_VoxelMipMap::mipmaptype
mipmaptype
Definition: UT_VoxelArray.h:1462
UT_VoxelMipMap
Definition: UT_VoxelArray.h:1457
UT_VoxelProbe::myZ
int myZ
Definition: UT_VoxelArray.h:2307
nanovdb::setValue
__hostdev__ void setValue(uint32_t offset, bool v)
Definition: NanoVDB.h:5750
UT_VoxelArray::isConstant
bool isConstant(T *cval=0) const
Definition: UT_VoxelArray.C:3415
UT_VoxelTile::makeConstant
void makeConstant(T t)
Turns this tile into a constant tile of the given value.
Definition: UT_VoxelArray.C:2121
UT_VoxelArray::indexToPos
bool indexToPos(int x, int y, int z, UT_Vector3F &pos) const
Definition: UT_VoxelArray.C:5948
__linearTileIndexConverter::toLinearBP
void toLinearBP(int k, int &x, int &y, int &z) const
Definition: UT_VoxelArray.C:5399
SYSlerp
UT_Matrix2T< T > SYSlerp(const UT_Matrix2T< T > &v1, const UT_Matrix2T< T > &v2, S t)
Definition: UT_Matrix2.h:675
UT_Array.h
UT_VoxelProbeFace::setIndex
bool setIndex(UT_VoxelArrayIterator< S > &vit)
Definition: UT_VoxelArray.h:2588
UT_VoxelProbe::myCacheLine
T * myCacheLine
Definition: UT_VoxelArray.h:2302
UT_VoxelProbe::UT_VoxelProbe
UT_VoxelProbe()
UT_Vector3T< fpreal32 >
UT_Vector4T< fpreal32 >
UT_FilterType
UT_FilterType
Definition: UT_FilterType.h:16
UT_ValArray< int >
fpreal32
float fpreal32
Definition: SYS_Types.h:200
UT_VoxelProbeAverage::setArray
void setArray(const UT_VoxelArray< T > *vox)
Definition: UT_VoxelArray.C:9331
UT_WRAP_CLAMP
Definition: UT_FilterType.h:42
UT_Assert.h
UT_Array
Definition: BV_KDOPTree.h:18
buffer
GLuint buffer
Definition: glcorearb.h:660
UT_VoxelProbe::myMinValidX
int myMinValidX
Half inclusive [,) range of valid x queries for current cache.
Definition: UT_VoxelArray.h:2312
UT_VoxelCompressOptions
Definition: UT_VoxelArray.h:91
UT_VoxelArrayIterator::skipToEndOfTile
void skipToEndOfTile()
Definition: UT_VoxelArray.C:7416
UT_VoxelTile::flatten
void flatten(S *dst, int dststride) const
Flattens ourself into the given destination buffer.
Definition: UT_VoxelArray.C:1407
UT_VoxelTile::makeFpreal16
void makeFpreal16()
Explicit compress to fpreal16. Lossy. No-op if already constant.
Definition: UT_VoxelArray.C:2137
UT_FilterWindow::getWeights
const float * getWeights() const
Definition: UT_Filter.h:78
UT_VoxelArray::size
void size(int xres, int yres, int zres, bool reset=true)
Definition: UT_VoxelArray.C:3250
UT_WRAP_REPEAT
Definition: UT_FilterType.h:41
UT_VoxelArray::extractSlice
S * extractSlice(S *dstdata, int slice, bool half_slice) const
Definition: UT_VoxelArray.C:5040
UT_VoxelArrayJSON::TILE_DATA
Definition: UT_VoxelArrayJSON.h:35
UT_Vector4T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector4.h:491
UT_VoxelTile::zres
int zres() const
Definition: UT_VoxelArray.h:474
UT_VoxelArrayIterator::getValue
T getValue() const
Definition: UT_VoxelArray.h:1753
UT_JSONWriter::jsonString
bool jsonString(const char *value, int64 length=0)
nanovdb::getValue
__hostdev__ float getValue(uint32_t i) const
Definition: NanoVDB.h:5578
UT_VoxelTileCompress::writeThrough
virtual bool writeThrough(UT_VoxelTile< T > &tile, int x, int y, int z, T t) const =0
UT_VoxelArrayJSON::getArrayID
static int getArrayID(const char *symbol)
UT_STRING_8BIT_IO
Definition: UT_NTStreamUtil.h:33
UT_VoxelTileIterator::rewind
void rewind()
Resets the iterator to point to the first voxel.
Definition: UT_VoxelArray.C:8078
UT_VoxelArray::extractSample
SYS_FORCE_INLINE bool extractSample(int x, int y, int z, T *sample) const
Definition: UT_VoxelArray.C:3899
SYS_Floor.h
UT_SharedMemoryManager.h
fpreal64
double fpreal64
Definition: SYS_Types.h:201
uint8
unsigned char uint8
Definition: SYS_Types.h:36
UT_VoxelTile::extractSample
SYS_NO_DISCARD_RESULT SYS_FORCE_INLINE bool extractSample(int x, int y, int z, T *sample) const
Definition: UT_VoxelArray.C:697
UT_String.h
UT_VoxelTile::writeThrough
bool writeThrough(int x, int y, int z, T t)
Definition: UT_VoxelArray.C:203
SYS_Math.h
UT_VoxelTile::yres
int yres() const
Definition: UT_VoxelArray.h:473
UT_VoxelProbeCube::setConstCubeArray
void setConstCubeArray(const UT_VoxelArray< T > *vox)
Definition: UT_VoxelArray.C:8855
UT_VoxelArray::moveTilesWithOffset
void moveTilesWithOffset(UT_VoxelArray< T > &src, int tileoffx, int tileoffy, int tileoffz)
Definition: UT_VoxelArray.C:5477
UT_VoxelArrayIterator::setPartialRange
void setPartialRange(int idx, int numranges)
Definition: UT_VoxelArray.C:7063
UT_VoxelMipMap::operator=
const UT_VoxelMipMap< T > & operator=(const UT_VoxelMipMap< T > &src)
Assignment operator:
Definition: UT_VoxelArray.C:6529
__linearTileIndexConverter::__linearTileIndexConverter
__linearTileIndexConverter(const UT_VoxelArray< T > *dst, const UT_VoxelArray< T > *src, int xoff, int yoff, int zoff)
Definition: UT_VoxelArray.C:5365
UT_Filter
Definition: UT_Filter.h:118
SYS_Types.h
n
GLdouble n
Definition: glcorearb.h:2008
UT_VoxelArray::writeTiles
const S * writeTiles(const S *srcdata, int srcstride, const UT_IntArray &tilelist)
Definition: UT_VoxelArray.C:5255
UT_FilterType.h
f
GLfloat f
Definition: glcorearb.h:1926
type
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:108
UT_VoxelProbe::myPreX
int myPreX
Definition: UT_VoxelArray.h:2308
UT_VoxelTile::hasNan
bool hasNan() const
Returns true if any NANs are in this tile.
Definition: UT_VoxelArray.C:1991
UT_JSONDefines.h
UT_VoxelArrayJSON::getToken
static const char * getToken(ArrayTokenID id)
UT_ParallelUtil.h
offset
GLintptr offset
Definition: glcorearb.h:665
UT_VoxelArray::extractSampleAxis
SYS_FORCE_INLINE bool extractSampleAxis(int x, int y, int z, T *sample) const
__linearTileIndexConverter::myZMax
int myZMax
Definition: UT_VoxelArray.C:5470
UT_VoxelProbe::resetX
void resetX(int x)
Definition: UT_VoxelArray.h:2285
UT_VoxelProbeFace::setVoxelSize
void setVoxelSize(const UT_Vector3 &voxelsize)
Definition: UT_VoxelArray.C:9226
UT_VoxelProbe::myPostX
int myPostX
Definition: UT_VoxelArray.h:2308
UT_NTStreamUtil.h
UT_Filter::getFilter
static UT_Filter * getFilter(UT_FilterType type)
openvdb::OPENVDB_VERSION_NAME::tools::else
else
Definition: ValueTransformer.h:600
UT_VoxelProbeCube::laplacian
fpreal64 laplacian(const UT_Vector3 &invvoxelsize) const
Definition: UT_VoxelArray.C:9134
UT_VoxelTile::myData
void * myData
Definition: UT_VoxelArray.h:603
UT_VoxelProbeCube::rotateLines
static void rotateLines(UT_VoxelProbe< T, true, false, false > &ym, UT_VoxelProbe< T, true, false, false > &y0, UT_VoxelProbe< T, true, false, false > &yp)
Definition: UT_VoxelArray.C:9162
UT_VoxelTileCompress::load
virtual void load(UT_IStream &is, UT_VoxelTile< T > &tile) const
Definition: UT_VoxelArray.h:174
UT_VoxelArrayIterator::rewind
void rewind()
Resets the iterator to point to the first voxel.
Definition: UT_VoxelArray.C:7224
UT_VoxelArrayIterator::UT_VoxelArrayIterator
UT_VoxelArrayIterator()
Definition: UT_VoxelArray.C:7025
UT_VoxelTile::getMemoryUsage
int64 getMemoryUsage(bool inclusive) const
Returns the amount of memory used by this tile.
Definition: UT_VoxelArray.C:2195
UT_WorkBuffer.h
UT_VoxelArray::getYRes
int getYRes() const
Definition: UT_VoxelArray.h:669
UT_VoxelTile::weightedSum
void weightedSum(int pstart[3], int pend[3], const float *weights[3], int start[3], T &result)
Definition: UT_VoxelArray.C:2240
UT_VoxelTile::lerpAxis
SYS_FORCE_INLINE T lerpAxis(int x, int y, int z, float fx, float fy, float fz) const
UT_VoxelArrayIterator::getLinearTileNum
int getLinearTileNum() const
Definition: UT_VoxelArray.h:1823
UT_Vector4T::z
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector4.h:495
UT_VoxelMipMap::build
void build(UT_VoxelArray< T > *baselevel, mipmaptype function)
Definition: UT_VoxelArray.C:6563
UT_ValArray.h
UT_VoxelArray::extractSamplePlus
SYS_FORCE_INLINE bool extractSamplePlus(int x, int y, int z, T *sample) const
Definition: UT_VoxelArray.C:4061
UT_VoxelTile::saveCompressionTypes
static void saveCompressionTypes(std::ostream &os)
Stores a list of compresson engines to os.
Definition: UT_VoxelArray.C:2999
UT_StackBuffer.h
UT_VoxelArray::getBorderValue
T getBorderValue() const
Definition: UT_VoxelArray.h:1275
PXL_OCIO::getName
PXL_API const char * getName(const ColorSpace *space)
Return the name of the color space.
v4uu
Definition: VM_SIMD.h:48
UT_ASSERT_P
#define UT_ASSERT_P(ZZ)
Definition: UT_Assert.h:155
UT_Vector4.h
UT_VoxelArray::mirrorCoordinates
static int mirrorCoordinates(int x, int res)
Definition: UT_VoxelArray.h:1055
UTsaveStringBinary
UT_API void UTsaveStringBinary(std::ostream &os, const char *str, UT_STRING_BINARY_IO minbits)
SYS_SharedMemoryView
Definition: SYS_SharedMemory.h:95
SYS_SharedMemory::reset
bool reset(exint size, const char *id=nullptr)
UT_VoxelArray
Definition: RE_Texture3DMap.h:20
UT_VoxelArray::~UT_VoxelArray
~UT_VoxelArray()
Definition: UT_VoxelArray.C:3150
__linearTileIndexConverter::getNTilesBP
int getNTilesBP() const
Returns the number of tiles in each part.
Definition: UT_VoxelArray.C:5388
UT_IStream::read
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:276
SYS_FALLTHROUGH
#define SYS_FALLTHROUGH
Definition: SYS_Compiler.h:68
end
GLuint GLuint end
Definition: glcorearb.h:475
UT_VoxelTileCompress::save
virtual void save(std::ostream &os, const UT_VoxelTile< T > &tile) const
Definition: UT_VoxelArray.h:171
UT_SharedMemoryManager::get
static UT_SharedMemoryManager & get()
UTvoxelConvertFP16
fpreal16 UTvoxelConvertFP16(fpreal16 a)
Definition: UT_VoxelArray.C:54
UT_VoxelArray::operator=
const UT_VoxelArray< T > & operator=(const UT_VoxelArray< T > &src)
Assignment operator:
Definition: UT_VoxelArray.C:3191
UT_VoxelProbeFace::setArray
void setArray(const UT_VoxelArray< T > *vx, const UT_VoxelArray< T > *vy, const UT_VoxelArray< T > *vz)
Definition: UT_VoxelArray.C:9209
SYSclamp
UT_Vector3T< T > SYSclamp(const UT_Vector3T< T > &v, const UT_Vector3T< T > &min, const UT_Vector3T< T > &max)
Definition: UT_Vector3.h:1057
UT_VoxelArrayIterator::z
int z() const
Definition: UT_VoxelArray.h:1747
UT_JSONParser::iterator
Traverse an array object in the parser.
Definition: UT_JSONParser.h:541
UT_JSONParser::skipNextObject
bool skipNextObject()
Simple convenience method to skip the next object in the stream.
stride
GLint GLenum GLboolean GLsizei stride
Definition: glcorearb.h:872
UT_VoxelArrayJSON::ARRAY_TILES
Definition: UT_VoxelArrayJSON.h:30
UT_VoxelTile::makeRawUninitialized
void makeRawUninitialized()
Definition: UT_VoxelArray.C:1739
v4uf
Definition: VM_SIMD.h:188
mask
GLint GLuint mask
Definition: glcorearb.h:124
UT_VoxelArray::getTile
UT_VoxelTile< T > * getTile(int tx, int ty, int tz) const
Definition: UT_VoxelArray.h:1304
pxr_CLI::CLI::detail::dummy
constexpr enabler dummy
An instance to use in EnableIf.
Definition: CLI11.h:985
UT_VoxelArrayIterator::~UT_VoxelArrayIterator
~UT_VoxelArrayIterator()
Definition: UT_VoxelArray.C:7057
__linearTileIndexConverter::myXMax
int myXMax
Definition: UT_VoxelArray.C:5470
UT_VoxelProbeCube::~UT_VoxelProbeCube
~UT_VoxelProbeCube()
Definition: UT_VoxelArray.C:8849
madd
OIIO_FORCEINLINE OIIO_HOSTDEVICE float madd(float a, float b, float c)
Fused multiply and add: (a*b + c)
Definition: fmath.h:421
UT_Filter::releaseFilter
static void releaseFilter(UT_Filter *filter)
UT_VoxelArrayIterator::setCompressOnExit
void setCompressOnExit(bool shouldcompress)
Definition: UT_VoxelArray.h:1842
UT_VoxelArray::evaluate
T evaluate(const UT_Vector3 &pos, const UT_Filter &filter, fpreal radius, int clampaxis=-1) const
Definition: UT_VoxelArray.C:4554
UT_FilterWindow
Definition: UT_Filter.h:29
int64
long long int64
Definition: SYS_Types.h:116
UT_VectorTypes.h
UT_VoxelMipMap::~UT_VoxelMipMap
~UT_VoxelMipMap()
Definition: UT_VoxelArray.C:6514
UT_VoxelTile::extractSampleAxis
SYS_NO_DISCARD_RESULT SYS_FORCE_INLINE bool extractSampleAxis(int x, int y, int z, T *sample) const
UT_VoxelTile::tryCompress
bool tryCompress(const UT_VoxelCompressOptions &options)
Definition: UT_VoxelArray.C:2042
UT_JSONParser::addWarning
void void addWarning(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
UT_JSONWriter::jsonKey
bool jsonKey(const char *value, int64 length=0)
UT_VoxelTileCompress::canSave
virtual bool canSave() const
Does this engine support saving and loading?
Definition: UT_VoxelArray.h:170
UT_VoxelTile::getRes
int getRes(int dim) const
Definition: UT_VoxelArray.h:476
UT_VoxelArray::getXRes
int getXRes() const
Definition: UT_VoxelArray.h:668
UT_VoxelTile::setRes
void setRes(int xr, int yr, int zr)
Definition: UT_VoxelArray.h:551
UT_VoxelProbe< T, true, false, false >
SYSfloor
SYS_API fpreal32 SYSfloor(fpreal32 val)
UT_VoxelProbe::setIndex
bool setIndex(UT_VoxelArrayIterator< S > &vit)
Definition: UT_VoxelArray.h:2267
name
GLuint const GLchar * name
Definition: glcorearb.h:786
UT_VoxelTileCompress::isLossless
virtual bool isLossless() const
Returns true if the compression type is lossless.
Definition: UT_VoxelArray.h:163
UT_Debug.h
int8
signed char int8
Definition: SYS_Types.h:35
UT_VoxelArrayIterator::y
int y() const
Definition: UT_VoxelArray.h:1746
UT_JSONWriter::jsonEndArray
bool jsonEndArray(bool newline=true)
UT_VoxelArray::UT_VoxelArray
UT_VoxelArray()
Definition: UT_VoxelArray.C:3126
ut_VoxelMipMapSortCompare::key
int key
Definition: UT_VoxelArray.C:6895
UT_Interrupt.h
b
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1222
UT_BoundingBoxT::enlargeBounds
void enlargeBounds(const UT_Vector3T< T > &min, const UT_Vector3T< T > &max)
Definition: UT_BoundingBox.h:756
__linearTileIndexConverter::myZSkipLen
int myZSkipLen
Definition: UT_VoxelArray.C:5472
UT_COW.h
x
GLint GLenum GLint x
Definition: glcorearb.h:409
OBJ_MatchTransform::T
UT_VoxelTile::writeCacheLine
void writeCacheLine(T *cacheline, int y, int z)
Fills a cache line from an external buffer into our own data.
Definition: UT_VoxelArray.C:1287
UT_JobInfo::nextTask
int32 nextTask() const
levels
GLsizei levels
Definition: glcorearb.h:2224
UT_Interrupt
Definition: UT_Interrupt.h:131
UT_VoxelProbe::advanceX
void advanceX()
Blindly advances our current pointer.
Definition: UT_VoxelArray.h:2276
__linearTileIndexConverter::_toRegularLinear
static void _toRegularLinear(int k, int xdim, int ydim, int &x, int &y, int &z)
Definition: UT_VoxelArray.C:5461
UT_VoxelTile::setValue
void setValue(int x, int y, int z, T t)
Definition: UT_VoxelArray.C:1544
UT_VoxelArray::lerpVoxelCoordAxis
SYS_FORCE_INLINE T lerpVoxelCoordAxis(UT_Vector3F pos) const
UT_StackBuffer
Definition: UT_StackBuffer.h:19
UT_Vector2.h
UT_VoxelTileCompress::getDataLength
virtual int getDataLength(const UT_VoxelTile< T > &tile) const =0
UT_Array::append
exint append()
Definition: UT_Array.h:142
UT_JSONParser::parseNumber
bool parseNumber(int8 &v)
Generic parsing of a number (int)
UT_VoxelArrayJSON::ARRAY_VERSION
Definition: UT_VoxelArrayJSON.h:28
t
GLdouble t
Definition: glad.h:2397
samples
GLsizei samples
Definition: glcorearb.h:1298
UT_FilterWindow::getSize
int getSize() const
Definition: UT_Filter.h:81
UT_WorkBuffer::sprintf
int sprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
UT_VoxelArrayIterator::getTileVoxels
void getTileVoxels(UT_Vector3I &start, UT_Vector3I &end) const
This tile will iterate over the voxels indexed [start,end).
Definition: UT_VoxelArray.h:1791
UT_VoxelCompressOptions::myAllowFP16
bool myAllowFP16
Conversion to fpreal16, only valid for scalar data.
Definition: UT_VoxelArray.h:126
UT_VoxelProbe::buildConstantCache
void buildConstantCache(T value)
GT_Names::version
GT_API const UT_StringHolder version
UT_VoxelArray::lerpVoxelCoord
SYS_FORCE_INLINE T lerpVoxelCoord(UT_Vector3F pos) const
Definition: UT_VoxelArray.C:3489
UT_VoxelProbeAverage::setIndex
bool setIndex(UT_VoxelArrayIterator< S > &vit)
Definition: UT_VoxelArray.h:2533
UT_VOXELBORDER_REPEAT
Definition: UT_VoxelArray.h:73
UT_VoxelArrayIterator::advanceTile
void advanceTile()
Definition: UT_VoxelArray.C:7295
UT_Array::entries
exint entries() const
Alias of size(). size() is preferred.
Definition: UT_Array.h:655
UT_VoxelArray::getZRes
int getZRes() const
Definition: UT_VoxelArray.h:670
UT_VoxelArrayIterator::applyOperationCheckNoop
void applyOperationCheckNoop(const OP &op, const UT_VoxelArray< S > &a)
Definition: UT_VoxelArray.C:7469
UT_JSONParser::parseUniformArray
int64 parseUniformArray(T *data, int64 len)
Definition: UT_JSONParser.h:182
py
IFDmantra py
Definition: HDK_Image.dox:266
UT_VoxelTile::getCompressionEngine
static UT_VoxelTileCompress< T > * getCompressionEngine(int index)
Definition: UT_VoxelArray.C:2604
__linearTileIndexConverter::myYSkipMin
int myYSkipMin
Definition: UT_VoxelArray.C:5471
j
GLint j
Definition: glad.h:2733
UT_WorkBuffer::strcmp
SYS_FORCE_INLINE int strcmp(const char *src) const
Definition: UT_WorkBuffer.h:479
UT_FixedVectorTraits
Definition: UT_FixedVectorTraits.h:23
size
GLsizeiptr size
Definition: glcorearb.h:664
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2002
dst
GLenum GLenum dst
Definition: glcorearb.h:1793
__linearTileIndexConverter::myZSkipMin
int myZSkipMin
Definition: UT_VoxelArray.C:5471
UT_VoxelTileCompress::findMinMax
virtual void findMinMax(const UT_VoxelTile< T > &tile, T &min, T &max) const
Definition: UT_VoxelArray.C:73
UT_VoxelTileIterator::setLinearTile
void setLinearTile(exint lineartilenum, UT_VoxelArray< T > *array)
Definition: UT_VoxelArray.h:2018
usage
GLsizeiptr const void GLenum usage
Definition: glcorearb.h:664
UT_VoxelArray::hasNan
bool hasNan() const
Returns true if any element of the voxel array is NAN.
Definition: UT_VoxelArray.C:3455
UT_VoxelArrayIterator
Definition: UT_VoxelArray.h:1619
UT_VoxelProbeFace::UT_VoxelProbeFace
UT_VoxelProbeFace()
Definition: UT_VoxelArray.C:9196
UT_JobInfo::numJobs
int numJobs() const
Definition: UT_ThreadedAlgorithm.h:108
functions
section HDK_USDHydraEventScripts USD a python event script is run This gives the render delegate the opportunity to perform any required external initialization or other renderer specific action that may be required The script is found by searching the HOUDINI_SCRIPT_PATH for a file named scene DelegateName_Events py Within this file should be two functions
Definition: HDK_USDHydra.dox:1080
UT_VoxelArray::lerpVoxelMinMaxAxis
SYS_FORCE_INLINE void lerpVoxelMinMaxAxis(T &lerp, T &lmin, T &lmax, int x, int y, int z, float fx, float fy, float fz) const
UT_VoxelTile::lerpValues
SYS_STATIC_FORCE_INLINE T lerpValues(T v1, T v2, fpreal32 bias)
Lerps two numbers, templated to work with T.
Definition: UT_VoxelArray.h:324
OBJ_MatchTransform::S
UT_FixedVectorTraits::DataType
T DataType
Definition: UT_FixedVectorTraits.h:26
UT_VoxelProbe::~UT_VoxelProbe
~UT_VoxelProbe()
UT_VoxelArray::getValue
T getValue(int x, int y, int z) const
Definition: UT_VoxelArray.h:1068
UT_VoxelProbeCube::setIndexPlus
bool setIndexPlus(UT_VoxelArrayIterator< S > &vit)
Definition: UT_VoxelArray.h:2445
UT_VoxelArray::lerpVoxel
SYS_FORCE_INLINE T lerpVoxel(int x, int y, int z, float fx, float fy, float fz) const
Definition: UT_VoxelArray.C:3516
UTparallelInvoke
void UTparallelInvoke(bool parallel, F1 &&f1, F2 &&f2)
Definition: UT_ParallelUtil.h:504
UT_VoxelTile::copyFragment
void copyFragment(int dstx, int dsty, int dstz, const UT_VoxelTile< T > &srctile, int srcx, int srcy, int srcz)
Definition: UT_VoxelArray.C:1340
UT_VoxelTile::uncompress
void uncompress()
Turns a compressed tile into a raw tile.
Definition: UT_VoxelArray.C:1566
UT_VoxelArrayIterator::reduceOperation
void reduceOperation(OP &op)
Definition: UT_VoxelArray.C:7984
UT_VoxelArrayIterator::maskedAssignOperation
void maskedAssignOperation(const OP &op, const UT_VoxelArray< S > &a, const UT_VoxelArray< M > &mask)
Definition: UT_VoxelArray.C:7936
int16
short int16
Definition: SYS_Types.h:37
UT_JSONParser::parseEndArray
bool parseEndArray(bool &error)
Definition: UT_JSONParser.h:437
fpreal
fpreal64 fpreal
Definition: SYS_Types.h:278
UT_BoundingBoxT::minvec
UT_Vector3T< T > minvec() const
Definition: UT_BoundingBox.h:118
__linearTileIndexConverter::toLinearIP
void toLinearIP(int k, int &x, int &y, int &z) const
Definition: UT_VoxelArray.C:5452
UT_VOXELBORDER_STREAK
Definition: UT_VoxelArray.h:74
UT_VoxelProbe::myMaxValidX
int myMaxValidX
Definition: UT_VoxelArray.h:2312
SYS_FTOLERANCE_R
#define SYS_FTOLERANCE_R
Definition: SYS_Types.h:284
UT_VoxelTileCompress
Definition: UT_VoxelArray.h:136
UTgetInterrupt
UT_API UT_Interrupt * UTgetInterrupt()
Obtain global UT_Interrupt singleton.
UT_VoxelArray::forEachTile
void forEachTile(const OP &op, bool shouldthread=true)
Definition: UT_VoxelArray.C:4762
index
GLuint index
Definition: glcorearb.h:786
UT_VERIFY_P
#define UT_VERIFY_P(expr)
Definition: UT_Assert.h:210
__linearTileIndexConverter::myXSkipLen
int myXSkipLen
Definition: UT_VoxelArray.C:5472
UT_Filter::getSupport
float getSupport() const
Definition: UT_Filter.h:164
UT_Vector4T::w
constexpr SYS_FORCE_INLINE T & w() noexcept
Definition: UT_Vector4.h:497
v4uf::splitFloat
v4uu splitFloat()
Definition: VM_SIMD.h:327
UT_VoxelArray::saveData
void saveData(std::ostream &os) const
Definition: UT_VoxelArray.C:6075
SYS_SharedMemory
Definition: SYS_SharedMemory.h:26
UT_VoxelMipMap::myLevels
UT_ValArray< UT_VoxelArray< T > ** > myLevels
Definition: UT_VoxelArray.h:1593
UT_VoxelTile::~UT_VoxelTile
~UT_VoxelTile()
Definition: UT_VoxelArray.C:126
val
GLuint GLfloat * val
Definition: glcorearb.h:1608
ImageBufAlgo::max
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
UT_VoxelArray::lerpVoxelCoordMinMax
SYS_FORCE_INLINE void lerpVoxelCoordMinMax(T &lerp, T &lmin, T &lmax, UT_Vector3F pos) const
Definition: UT_VoxelArray.C:3799
UT_JSONWriter::jsonBeginArray
bool jsonBeginArray()
Begin a generic array object.
UT_BoundingBoxT::initBounds
SYS_FORCE_INLINE void initBounds()
Definition: UT_BoundingBox.h:504
UT_VoxelMipMap::getMemoryUsage
int64 getMemoryUsage(bool inclusive) const
Return the amount of memory used by this mipmap.
Definition: UT_VoxelArray.C:6670
SYS_SharedMemory::id
const char * id() const
UT_VoxelProbe::myY
int myY
Definition: UT_VoxelArray.h:2307
if
if(num_boxed_items<=0)
Definition: UT_RTreeImpl.h:697
UT_JSONParser::parseBeginArray
bool parseBeginArray(bool &error)
UT_JID_STRING
Definition: UT_JSONDefines.h:148
UT_VoxelProbeFace::swapLines
static void swapLines(UT_VoxelProbe< T, true, false, false > &ym, UT_VoxelProbe< T, true, false, false > &yp)
Definition: UT_VoxelArray.C:9303
UT_VoxelTile::save
void save(std::ostream &os) const
Definition: UT_VoxelArray.C:2613
SYS_Compiler.h
UT_VoxelArrayIterator::maskedApplyOperation
void maskedApplyOperation(const OP &op, const UT_VoxelArray< M > &mask)
Definition: UT_VoxelArray.C:7834
UT_BoundingBox.h
v4uf::swizzle
SYS_FORCE_INLINE v4uf swizzle() const
Definition: VM_SIMD.h:335
UT_VoxelArrayJSON::getTileID
static int getTileID(const char *symbol)
UT_VoxelArray::getLinearTile
UT_VoxelTile< T > * getLinearTile(int idx) const
Definition: UT_VoxelArray.h:1306
UT_String
Definition: UT_String.h:73
UT_VoxelTile::load
void load(UT_IStream &is, const UT_IntArray &compression)
Definition: UT_VoxelArray.C:2692
UT_VoxelTile::lookupCompressionEngine
static int lookupCompressionEngine(const char *name)
Definition: UT_VoxelArray.C:2584
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
SYS_SharedMemory.h
UT_ASSERT
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
UT_VoxelProbeFace::~UT_VoxelProbeFace
~UT_VoxelProbeFace()
Definition: UT_VoxelArray.C:9202
UT_IStream::readChar
bool readChar(char &result)
Definition: UT_IStream.h:382
UT_VoxelArray::lerpVoxelMinMax
SYS_FORCE_INLINE void lerpVoxelMinMax(T &lerp, T &lmin, T &lmax, int x, int y, int z, float fx, float fy, float fz) const
Definition: UT_VoxelArray.C:3830
UT_VoxelProbeCube::setIndexCube
bool setIndexCube(UT_VoxelArrayIterator< S > &vit)
Definition: UT_VoxelArray.h:2437
UT_JobInfo
Definition: UT_ThreadedAlgorithm.h:92
UT_JSONWriter::jsonUniformArray
bool jsonUniformArray(int64 length, const int8 *value)
Efficent method of writing a uniform array of int8 values.
UT_VoxelTile::uncompressFull
void uncompressFull()
Turns a tile into a raw full tile.
Definition: UT_VoxelArray.C:1703
UT_JSONWriter::endUniformArray
bool endUniformArray(int64 *nwritten=0)
UT_VoxelArray::setBorder
void setBorder(UT_VoxelBorderType type, T t)
Definition: UT_VoxelArray.C:6018
UT_ISTREAM_8BIT_IO
Definition: UT_IStream.h:50
UT_VoxelTile::operator()
SYS_FORCE_INLINE T operator()(int x, int y, int z) const
Definition: UT_VoxelArray.C:237
UT_VoxelArrayIterator::assignOperation
void assignOperation(const OP &op, const UT_VoxelArray< S > &a)
Definition: UT_VoxelArray.C:7894
UT_VoxelTileCompress::tryCompress
virtual bool tryCompress(UT_VoxelTile< T > &tile, const UT_VoxelCompressOptions &options, T min, T max) const =0
UT_VoxelArray::lerpVoxelCoordMinMaxAxis
SYS_FORCE_INLINE void lerpVoxelCoordMinMaxAxis(T &lerp, T &lmin, T &lmax, UT_Vector3F pos) const
UT_VoxelArrayJSON::ARRAY_SHAREDARRAY
Definition: UT_VoxelArrayJSON.h:27
openvdb::OPENVDB_VERSION_NAME::tools::op
OutGridT XformOp & op
Definition: ValueTransformer.h:139
UT_VoxelProbe::myX
int myX
Definition: UT_VoxelArray.h:2307
UT_VoxelTile::expandMinMax
static void expandMinMax(T v, T &min, T &max)
Designed to be specialized according to T.
Definition: UT_VoxelArray.h:502
UT_VoxelTileIterator::assignOperation
void assignOperation(const OP &op, const UT_VoxelArray< S > &a)
Definition: UT_VoxelArray.C:8172
UT_WRAP_BORDER
Definition: UT_FilterType.h:43
UT_Vector3T::y
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector3.h:665
SYSisEqual
bool SYSisEqual(const UT_Vector2T< T > &a, const UT_Vector2T< T > &b, S tol=SYS_FTOLERANCE)
Componentwise equality.
Definition: UT_Vector2.h:674
UT_VoxelTile::findMinMax
void findMinMax(T &min, T &max) const
Finds the minimum and maximum T values.
Definition: UT_VoxelArray.C:1915
UT_Vector3T::maxComponent
constexpr SYS_FORCE_INLINE T maxComponent() const noexcept
Definition: UT_Vector3.h:408
UT_VoxelArray::avgNonZero
T avgNonZero(const UT_Vector3 &pos, const UT_Filter &filter, fpreal radius, int clampaxis=-1) const
average of non-zero values of the voxel array.
Definition: UT_VoxelArray.C:4651
SYSmin
#define SYSmin(a, b)
Definition: SYS_Math.h:1583
__linearTileIndexConverter::myXSkipMin
int myXSkipMin
Definition: UT_VoxelArray.C:5471
UT_VoxelArray::lerpVoxelAxis
SYS_FORCE_INLINE T lerpVoxelAxis(int x, int y, int z, float fx, float fy, float fz) const
UT_BlockedRange
Declare prior to use.
Definition: UT_ParallelUtil.h:58
UT_VoxelArray::setBorderScale
void setBorderScale(T scalex, T scaley, T scalez)
Definition: UT_VoxelArray.C:6026
UT_VoxelTile::avgNonZero
void avgNonZero(int pstart[3], int pend[3], int start[3], T &result)
Definition: UT_VoxelArray.C:2398
UT_JSONParser::iterator::atEnd
bool atEnd() const
Definition: UT_JSONParser.h:572
UT_VoxelTile::xres
int xres() const
Read the current resolution.
Definition: UT_VoxelArray.h:472
UT_VoxelProbeCube::curvature
fpreal64 curvature(const UT_Vector3 &invvoxelsize) const
Definition: UT_VoxelArray.C:9050
UT_VoxelArray::extractTiles
S * extractTiles(S *dstdata, int stride, const UT_IntArray &tilelist) const
Definition: UT_VoxelArray.C:5155
UT_VoxelArray.h
UT_JSONParser::iterator::getLowerKey
bool getLowerKey(T &key)
Get a lower case map key (for case insensitive maps)
Definition: UT_JSONParser.h:611
UT_JSONParser.h
UT_VoxelTile::writeData
void writeData(const S *src, int srcstride)
Definition: UT_VoxelArray.C:1486
UT_VoxelTile::isSimpleCompression
bool isSimpleCompression() const
Definition: UT_VoxelArray.h:423
UT_VoxelArrayJSON::ARRAY_COMPRESSIONTYPES
Definition: UT_VoxelArrayJSON.h:29
UT_VoxelTileIterator::reduceOperation
bool reduceOperation(OP &op)
Definition: UT_VoxelArray.C:8214
UT_VoxelTileIterator::~UT_VoxelTileIterator
~UT_VoxelTileIterator()
Definition: UT_VoxelArray.C:8072
UT_VoxelTile::extractSamplePlus
SYS_FORCE_INLINE bool extractSamplePlus(int x, int y, int z, T *sample) const
Definition: UT_VoxelArray.C:785
count
GLint GLsizei count
Definition: glcorearb.h:405
UT_VoxelTile::isConstant
bool isConstant() const
Returns if this tile is constant.
Definition: UT_VoxelArray.h:407
ut_VoxelMipMapSortCompare::value
float value
Definition: UT_VoxelArray.C:6894
UT_VoxelArray::lerpSampleAxis
SYS_FORCE_INLINE T lerpSampleAxis(T *samples, float fx, float fy, float fz) const
data
Definition: format.h:1821
UT_VoxelTile::loadCompressionTypes
static void loadCompressionTypes(UT_IStream &is, UT_IntArray &compressions)
Definition: UT_VoxelArray.C:3023
UT_VoxelArrayJSON::ARRAY_CONSTARRAY
Definition: UT_VoxelArrayJSON.h:25
UT_VoxelArray::getTileRes
int getTileRes(int dim) const
Definition: UT_VoxelArray.h:1363
SYSceil
SYS_API fpreal32 SYSceil(fpreal32 val)
UT_VoxelArray::evaluateMinMax
void evaluateMinMax(T &lerp, T &lmin, T &lmax, UT_Vector3F pos) const
Definition: UT_VoxelArray.C:3782
UT_JSONWriter::jsonInt
bool jsonInt(int32 value)
Write an integer value.
UT_VoxelProbe::writeCacheLine
void writeCacheLine()
operator<
bool operator<(const ut_VoxelMipMapSortCompare &lhs, const ut_VoxelMipMapSortCompare &rhs)
Definition: UT_VoxelArray.C:6898
UT_VoxelArrayJSON.h
UT_JobInfo::job
int job() const
Definition: UT_ThreadedAlgorithm.h:107
UT_VoxelArray::flattenPartialAxis
void flattenPartialAxis(T *flatarray, exint ystride, const UT_JobInfo &info) const
Definition: UT_VoxelArray.C:4824
UT_VoxelArrayIterator::advance
void advance()
Advances the iterator to point to the next voxel.
Definition: UT_VoxelArray.h:1713
__linearTileIndexConverter::myYMax
int myYMax
Definition: UT_VoxelArray.C:5470
UT_SharedMemoryManager
Definition: UT_SharedMemoryManager.h:23
UT_VoxelProbe::myCurLine
T * myCurLine
Definition: UT_VoxelArray.h:2299
UT_VoxelTileIterator::applyOperation
void applyOperation(const OP &op)
Definition: UT_VoxelArray.C:8121
UT_VoxelTile::lerp
SYS_FORCE_INLINE T lerp(int x, int y, int z, float fx, float fy, float fz) const
Definition: UT_VoxelArray.C:276
filter
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297
src
GLenum src
Definition: glcorearb.h:1793
UT_Vector3T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector3.h:663
UT_VoxelTileIterator::advanceTile
void advanceTile()
Definition: UT_VoxelArray.C:8105