ELF>w@@;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoqstuvwxyz{|}~UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5|$HtHt+HH5HPtHuH1Huff.fUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(HH[]DHt$H|$tHl$H=HtHH=uHuHc@HH=tHH=tHSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(Ht\$9\$t:H111HT$(dH+%(uUH0[fDHHuӐt1HuHcfDHHH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(Ht\$9\$t:H111HT$(dH+%(uUH0[fDHHuӐt1HuHcfDHHHH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uiH0[fDHHuӐt$ffH~HufHnDHffH~H(H;tfH~ff.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uZH0[fDHHuӐtHuHcHHH;tЉff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uuH0[fDHHuӐt,fH~HufHnfHH0H;fH~tfH~fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uuH0[fDHHuӐt,fH~HufHnfHHH;fH~tfH~fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uiH0[fDHHuӐt$ffH~HufHnDHffH~HH;tfH~ff.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(Ht\$9\$t:H111HT$(dH+%(uUH0[fDHHuӐt1HuHcfDHH(H;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uZH0[fDHHuӐtHuHcHHH;tЉff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uuH0[fDHHuӐt,fH~HufHnfHHH;fH~tfH~fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uuH0[fDHHuӐt,fH~HufHnfHHH;fH~tfH~fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uZH0[fDHHuӐtHuHcHHPH;tЉff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uZH0[fDHHuӐtHuHcHH0H;tЉff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(Ht\$9\$t:H111HT$(dH+%(uUH0[fDHHuӐt1HuHcfDHHH;tЉfUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u^H0]fDHHuӐt$HHuH@HHH;tHfUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u^H0]fDHHuӐt$HHuH@HHH;tHfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐt(HuHcfHHH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐtHuHcfHHH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u}H0[fDHHuӐt, fH~HufHnfHH8H;u fH~fDfH~f.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u}H0[fDHHuӐt,0fH~HufHnfHHH;u0fH~fDfH~f.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐtHuHcfHHXH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u}H0[fDHHuӐt,@fH~HufHnfHHH;u@fH~fDfH~f.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐtHHuHc뵐HH8H;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐtHuHcfHHH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐtLHuHcfHHXH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐtHuHcfHHxH;tЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u}H0[fDHHuӐt,fH~HufHnfHHHH;ufH~fDfH~f.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u}H0[fDHHuӐt,fH~HufHnfHHH;ufH~fDfH~f.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u}H0[fDHHuӐt,fH~HufHnfHHH;ufH~fDfH~f.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐt8HuHcfHHH;tЉfATUH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u;H(HtD$9D$t8H111HT$(dH+%(uoH8]A\fHHuՐHHuHt1HHHIHuLH@HHfDH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(unH8HHuҐHHH; u5 tLJ HuHHD f.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(ukH8HHuҐHHH; u58tLJ8HuHH@1ff.fH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(unH8HHuҐHHH; u5 tLJ HuHHD f.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(unH8HHuҐHHH; u58tLJ8HuHHDf.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(unH8HHuҐHHH; u58tLJ8HuHHDf.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ t99tHEHHuHH|@HEHpH;u;tƉHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ t99tHEHHuHH|@HEHH;u;tƉHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$H|$tD$$D$t?f.@ztHE@HHuHHt@HEHH;u$f.@zt@HDHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$H|$tD$$D$t?f.ztHEHHuHHt@HEH@H;u$f.ztHDHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ t99(tHE(HHuHH|@HEHH;u;(tƉ(HHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$H|$tD$$D$t?f.0ztHE0HHuHHt@HEHH;u$f.0zt0HDHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ t99tHEHHuHH|@HEHPH;u;tƉHHff.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtIHH;uQ(tLJ(HuHHHH;t@1ff.fH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtIHPH;uQtLJHuHHfH`H;t@f.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtIHpH;uQtLJHuHHfHH;t@f.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtIHH;uQ(tLJ(HuHHfHH;t@f.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtIHpH;uQtLJHuHHHH;t@1ff.fH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtIHPH;uQtLJHuHHHhH;t@1ff.fAWAVAUATUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ Ho(Ht!D$ +D$$t:H|$1HT$8dH+%(H@]A\A]A^A_fL|$Lt$LH5L|$ItLH5L|$ItLH5L|$HxLLHH\HHNfHH4DUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ tA1H9tHEHHuHHuDHEHH;u$1҅H9tH@Hff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ tQ9O1H98tHE8HHuHHgHEHH;u,9O1҅H98t8HfH@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ tQ9O1H9LtHELHHuHHgHEH@H;u,9O1҅H9LtLHfH@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ tQ9O1HH9tHE@HHHqHHcHEH H;u49O1҅HH9t@HHfDHff.UH@fnFdH%(HD$81HHt$HD$HGfn؉D$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(&H@]fDHHuϐHt$H|$tD$$D$to f/ ]f(f.ztHEHHXHHJf.HEHH;u\ f/w> ]f(f.ztHf(Zf(fH^UH@fnFdH%(HD$81HHt$HD$HGfn؉D$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(&H@]fDHHuϐHt$H|$tD$$D$tgff/ ]f(f.ztHEHH\HHNfDHEHH;udff/w2 ]f(f.ztHf(f.f(NHZUH@fnFdH%(HD$81HHt$HD$HGfn؉D$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(&H@]fDHHuϐHt$H|$tD$$D$tgf f/ ]f(f.ztHE HH\HHNfDHEH H;udf f/w2 ]f(f.zt Hf(f.f(NHZATH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@HHufHHRxH;IMtoI$H5LPtZHuLIHoHbL1HHP@L8fE1H"DIjfATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\HHuːHt$H|$tD$$Ld$u`HELH@H;H=tLH=u-HaHcVf.LLH=tLH=tLfDHЉfAW1AVAUATUSHXHNdH%(HD$H1HGAfnH%fnA)fbAtmAHHt$H\$T$(fD$ HHo(HD$ +D$$H|$1_fHHt$H\$L$ T$$T$(HjHo(Ht%D$ +D$$H|$1HT$HdH+%(dHX[]A\A]A^A_H5D1DHHDLd$Ht$LtHt$LyHt$ LdL$ T$Ht$HBHH4fDLd$8Ll$LL LH\$8Dt$D$@+D$DH|$01fDH5D1H$dH+%(HĘ]A\DL Ht$0LL$8L$@T$DT$HHHo(HtD$@+D$DH|$01HHaf.Ld$0HL?Ht$L*Ht$LHt$LHt$ LHt$(Ld$ T$$l$(\$L$Df(f(L$fD(fffD:HUHH;f.zBu@f.z6u4f.z*u(f.zuf.zuf.z0H@Ld$PH|$0LT$DHEf(|$Pf(t$`Hf(f(fD(fff(f(D$pH;f(f(f(ffD.zGuEf.z;u9f.z/u-f.z#u!f.zuf.z t'fHHHH@HHf.HH;uGf(|$Pf(t$`Hf(fD(ff(f(ff(fA(HgLHZf.zBu@f.z6u4f.z*u(f.zuf.zuf.zHEDHHfATL%H LHH5LuLHLA\AUATIUSHHtHH5LHu\HLk0Hc{HHtH3HLHmtHL9uH[]A\A]HfDHmuHHf.fD(f(f(fDffzHuFf.zfvfF Hf(f(f(ffHH;f(f(f(ff(usf.zIuGf.z=u;f.z1u/f.z%u#f.zuf.z u f.Df(GetParallelSplatCrossoverMinValueGetParallelSplatCrossoverMaxValuevtkCheckerboardSplatter - splat points into a volume with an elliptical, Gaussian distribution Superclass: vtkImageAlgorithm vtkCheckerboardSplatter is a filter that injects input points into a structured points (volume) dataset using a multithreaded 8-way checkerboard approach. It produces a scalar field of a specified type. As each point is injected, it "splats" or distributes values to nearby voxels. Data is distributed using an elliptical, Gaussian distribution function. The distribution function is modified using scalar values (expands distribution) or normals (creates ellipsoidal distribution rather than spherical). This algorithm is designed for scalability through multithreading. In general, the Gaussian distribution function f(x) around a given splat point p is given by f(x) = ScaleFactor * exp( ExponentFactor*((r/Radius)**2) ) where x is the current voxel sample point; r is the distance |x-p| ExponentFactor <= 0.0, and ScaleFactor can be multiplied by the scalar value of the point p that is currently being splatted. If point normals are present (and NormalWarping is on), then the splat function becomes elliptical (as compared to the spherical one described by the previous equation). The Gaussian distribution function then becomes: f(x) = ScaleFactor * exp( ExponentFactor*( ((rxy/E)**2 + z**2)/R**2) ) where E is a user-defined eccentricity factor that controls the elliptical shape of the splat; z is the distance of the current voxel sample point along normal N; and rxy is the distance of x in the direction prependicular to N. This class is typically used to convert point-valued distributions into a volume representation. The volume is then usually iso-surfaced or volume rendered to generate a visualization. It can be used to create surfaces from point distributions, or to create structure (i.e., topology) when none exists. This class makes use of vtkSMPTools to implement a parallel, shared-memory implementation. Hence performance will be significantly improved if VTK is built with VTK_SMP_IMPLEMENTATION_TYPE set to something other than "Sequential" (typically TBB). For example, on a standard laptop with four threads it is common to see a >10x speedup as compared to the serial version of vtkGaussianSplatter. In summary, the algorithm operates by dividing the volume into a 3D checkerboard, where the squares of the checkerboard overlay voxels in the volume. The checkerboard overlay is designed as a function of the splat footprint, so that when splatting occurs in a group (or color) of checkerboard squares, the splat operation will not cause write contention as the splatting proceeds in parallel. There are eight colors in this checkerboard (like an octree) and parallel splatting occurs simultaneously in one of the eight colors (e.g., octants). A single splat operation (across the given 3D footprint) may also be parallelized if the splat is large enough. @warning The input to this filter is of type vtkPointSet. Currently only real types (e.g., float, double) are supported as input, but this could easily be extended to other types. The output type is limited to real types as well. @warning Some voxels may never receive a contribution during the splatting process. The final value of these points can be specified with the "NullValue" instance variable. Note that NullValue is also the initial value of the output voxel values and will affect the accumulation process. @warning While this class is very similar to vtkGaussianSplatter, it does produce slightly different output in most cases (due to the way the footprint is computed). @sa vtkShepardMethod vtkGaussianSplatter vtkImagingHybridPython.vtkCheckerboardSplatterV.IsTypeOf(string) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. V.IsA(string) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. V.SafeDownCast(vtkObjectBase) -> vtkCheckerboardSplatter C++: static vtkCheckerboardSplatter *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkCheckerboardSplatter C++: vtkCheckerboardSplatter *NewInstance() V.SetSampleDimensions(int, int, int) C++: void SetSampleDimensions(int i, int j, int k) V.SetSampleDimensions([int, int, int]) C++: void SetSampleDimensions(int dim[3]) Set / get the dimensions of the sampling structured point set. Higher values produce better results but may be much slower. V.GetSampleDimensions() -> (int, int, int) C++: int *GetSampleDimensions() Set / get the dimensions of the sampling structured point set. Higher values produce better results but may be much slower. V.SetModelBounds(float, float, float, float, float, float) C++: void SetModelBounds(double, double, double, double, double, double) V.SetModelBounds((float, float, float, float, float, float)) C++: void SetModelBounds(double a[6]) V.GetModelBounds() -> (float, float, float, float, float, float) C++: double *GetModelBounds() Set / get the (xmin,xmax, ymin,ymax, zmin,zmax) bounding box in which the sampling is performed. If any of the (min,max) bounds values are min >= max, then the bounds will be computed automatically from the input data. Otherwise, the user-specified bounds will be used. V.SetFootprint(int) C++: virtual void SetFootprint(int _arg) Control the footprint size of the splat in terms of propagation across a voxel neighborhood. The Footprint value simply indicates the number of neigboring voxels in the i-j-k directions to extend the splat. A value of zero means that only the voxel containing the splat point is affected. A value of one means the immediate neighbors touching the affected voxel are affected as well. Larger numbers increase the splat footprint and significantly increase processing time. Note that the footprint is always 3D rectangular. V.GetFootprintMinValue() -> int C++: virtual int GetFootprintMinValue() Control the footprint size of the splat in terms of propagation across a voxel neighborhood. The Footprint value simply indicates the number of neigboring voxels in the i-j-k directions to extend the splat. A value of zero means that only the voxel containing the splat point is affected. A value of one means the immediate neighbors touching the affected voxel are affected as well. Larger numbers increase the splat footprint and significantly increase processing time. Note that the footprint is always 3D rectangular. V.GetFootprintMaxValue() -> int C++: virtual int GetFootprintMaxValue() Control the footprint size of the splat in terms of propagation across a voxel neighborhood. The Footprint value simply indicates the number of neigboring voxels in the i-j-k directions to extend the splat. A value of zero means that only the voxel containing the splat point is affected. A value of one means the immediate neighbors touching the affected voxel are affected as well. Larger numbers increase the splat footprint and significantly increase processing time. Note that the footprint is always 3D rectangular. V.GetFootprint() -> int C++: virtual int GetFootprint() Control the footprint size of the splat in terms of propagation across a voxel neighborhood. The Footprint value simply indicates the number of neigboring voxels in the i-j-k directions to extend the splat. A value of zero means that only the voxel containing the splat point is affected. A value of one means the immediate neighbors touching the affected voxel are affected as well. Larger numbers increase the splat footprint and significantly increase processing time. Note that the footprint is always 3D rectangular. V.SetRadius(float) C++: virtual void SetRadius(double _arg) Set / get the radius variable that controls the Gaussian exponential function (see equation above). If set to zero, it is automatically set to the radius of the circumsphere bounding a single voxel. (By default, the Radius is set to zero and is automatically computed.) V.GetRadiusMinValue() -> float C++: virtual double GetRadiusMinValue() Set / get the radius variable that controls the Gaussian exponential function (see equation above). If set to zero, it is automatically set to the radius of the circumsphere bounding a single voxel. (By default, the Radius is set to zero and is automatically computed.) V.GetRadiusMaxValue() -> float C++: virtual double GetRadiusMaxValue() Set / get the radius variable that controls the Gaussian exponential function (see equation above). If set to zero, it is automatically set to the radius of the circumsphere bounding a single voxel. (By default, the Radius is set to zero and is automatically computed.) V.GetRadius() -> float C++: virtual double GetRadius() Set / get the radius variable that controls the Gaussian exponential function (see equation above). If set to zero, it is automatically set to the radius of the circumsphere bounding a single voxel. (By default, the Radius is set to zero and is automatically computed.) V.SetScaleFactor(float) C++: virtual void SetScaleFactor(double _arg) Multiply Gaussian splat distribution by this value. If ScalarWarping is on, then the Scalar value will be multiplied by the ScaleFactor times the Gaussian function. V.GetScaleFactorMinValue() -> float C++: virtual double GetScaleFactorMinValue() Multiply Gaussian splat distribution by this value. If ScalarWarping is on, then the Scalar value will be multiplied by the ScaleFactor times the Gaussian function. V.GetScaleFactorMaxValue() -> float C++: virtual double GetScaleFactorMaxValue() Multiply Gaussian splat distribution by this value. If ScalarWarping is on, then the Scalar value will be multiplied by the ScaleFactor times the Gaussian function. V.GetScaleFactor() -> float C++: virtual double GetScaleFactor() Multiply Gaussian splat distribution by this value. If ScalarWarping is on, then the Scalar value will be multiplied by the ScaleFactor times the Gaussian function. V.SetExponentFactor(float) C++: virtual void SetExponentFactor(double _arg) Set / get the sharpness of decay of the splats. This is the exponent constant in the Gaussian equation described above. Normally this is a negative value. V.GetExponentFactor() -> float C++: virtual double GetExponentFactor() Set / get the sharpness of decay of the splats. This is the exponent constant in the Gaussian equation described above. Normally this is a negative value. V.SetScalarWarping(int) C++: virtual void SetScalarWarping(int _arg) Turn on/off the scaling of splats by scalar value. V.GetScalarWarping() -> int C++: virtual int GetScalarWarping() Turn on/off the scaling of splats by scalar value. V.ScalarWarpingOn() C++: virtual void ScalarWarpingOn() Turn on/off the scaling of splats by scalar value. V.ScalarWarpingOff() C++: virtual void ScalarWarpingOff() Turn on/off the scaling of splats by scalar value. V.SetNormalWarping(int) C++: virtual void SetNormalWarping(int _arg) Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar. V.GetNormalWarping() -> int C++: virtual int GetNormalWarping() Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar. V.NormalWarpingOn() C++: virtual void NormalWarpingOn() Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar. V.NormalWarpingOff() C++: virtual void NormalWarpingOff() Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar. V.SetEccentricity(float) C++: virtual void SetEccentricity(double _arg) Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity > 1 creates needles with the long axis in the direction of the normal; Eccentricity<1 creates pancakes perpendicular to the normal vector. V.GetEccentricityMinValue() -> float C++: virtual double GetEccentricityMinValue() Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity > 1 creates needles with the long axis in the direction of the normal; Eccentricity<1 creates pancakes perpendicular to the normal vector. V.GetEccentricityMaxValue() -> float C++: virtual double GetEccentricityMaxValue() Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity > 1 creates needles with the long axis in the direction of the normal; Eccentricity<1 creates pancakes perpendicular to the normal vector. V.GetEccentricity() -> float C++: virtual double GetEccentricity() Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity > 1 creates needles with the long axis in the direction of the normal; Eccentricity<1 creates pancakes perpendicular to the normal vector. V.SetAccumulationMode(int) C++: virtual void SetAccumulationMode(int _arg) Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.GetAccumulationModeMinValue() -> int C++: virtual int GetAccumulationModeMinValue() Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.GetAccumulationModeMaxValue() -> int C++: virtual int GetAccumulationModeMaxValue() Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.GetAccumulationMode() -> int C++: virtual int GetAccumulationMode() Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.SetAccumulationModeToMin() C++: void SetAccumulationModeToMin() Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.SetAccumulationModeToMax() C++: void SetAccumulationModeToMax() Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.SetAccumulationModeToSum() C++: void SetAccumulationModeToSum() Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.GetAccumulationModeAsString() -> string C++: const char *GetAccumulationModeAsString() Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats overlap one another. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird (and can potentially cause accumulation overflow in extreme cases). Note that the NullValue must be set consistent with the accumulation operation. V.SetOutputScalarType(int) C++: virtual void SetOutputScalarType(int _arg) Set what type of scalar data this source should generate. Only double and float types are supported currently due to precision requirements during accumulation. By default, float scalars are produced. V.GetOutputScalarType() -> int C++: virtual int GetOutputScalarType() Set what type of scalar data this source should generate. Only double and float types are supported currently due to precision requirements during accumulation. By default, float scalars are produced. V.SetOutputScalarTypeToDouble() C++: void SetOutputScalarTypeToDouble() Set what type of scalar data this source should generate. Only double and float types are supported currently due to precision requirements during accumulation. By default, float scalars are produced. V.SetOutputScalarTypeToFloat() C++: void SetOutputScalarTypeToFloat() Set what type of scalar data this source should generate. Only double and float types are supported currently due to precision requirements during accumulation. By default, float scalars are produced. V.SetCapping(int) C++: virtual void SetCapping(int _arg) Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-surfacing) and create other effects. V.GetCapping() -> int C++: virtual int GetCapping() Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-surfacing) and create other effects. V.CappingOn() C++: virtual void CappingOn() Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-surfacing) and create other effects. V.CappingOff() C++: virtual void CappingOff() Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-surfacing) and create other effects. V.SetCapValue(float) C++: virtual void SetCapValue(double _arg) Specify the cap value to use. (This instance variable only has effect if the ivar Capping is on.) V.GetCapValue() -> float C++: virtual double GetCapValue() Specify the cap value to use. (This instance variable only has effect if the ivar Capping is on.) V.SetNullValue(float) C++: virtual void SetNullValue(double _arg) Set the Null value for output points not receiving a contribution from the input points. (This is the initial value of the voxel samples, by default it is set to zero.) Note that the value should be consistent with the output dataset type. The NullValue also provides the initial value on which the accumulations process operates. V.GetNullValue() -> float C++: virtual double GetNullValue() Set the Null value for output points not receiving a contribution from the input points. (This is the initial value of the voxel samples, by default it is set to zero.) Note that the value should be consistent with the output dataset type. The NullValue also provides the initial value on which the accumulations process operates. V.SetMaximumDimension(int) C++: virtual void SetMaximumDimension(int _arg) Set/Get the maximum dimension of the checkerboard (i.e., the number of squares in any of the i, j, or k directions). This number also impacts the granularity of the parallel threading (since each checker square is processed separaely). Because of the internal addressing, the maximum dimension is limited to 255 (maximum value of an unsigned char). V.GetMaximumDimensionMinValue() -> int C++: virtual int GetMaximumDimensionMinValue() Set/Get the maximum dimension of the checkerboard (i.e., the number of squares in any of the i, j, or k directions). This number also impacts the granularity of the parallel threading (since each checker square is processed separaely). Because of the internal addressing, the maximum dimension is limited to 255 (maximum value of an unsigned char). V.GetMaximumDimensionMaxValue() -> int C++: virtual int GetMaximumDimensionMaxValue() Set/Get the maximum dimension of the checkerboard (i.e., the number of squares in any of the i, j, or k directions). This number also impacts the granularity of the parallel threading (since each checker square is processed separaely). Because of the internal addressing, the maximum dimension is limited to 255 (maximum value of an unsigned char). V.GetMaximumDimension() -> int C++: virtual int GetMaximumDimension() Set/Get the maximum dimension of the checkerboard (i.e., the number of squares in any of the i, j, or k directions). This number also impacts the granularity of the parallel threading (since each checker square is processed separaely). Because of the internal addressing, the maximum dimension is limited to 255 (maximum value of an unsigned char). V.SetParallelSplatCrossover(int) C++: virtual void SetParallelSplatCrossover(int _arg) Set/get the crossover point expressed in footprint size where the splatting operation is parallelized (through vtkSMPTools). By default the parallel crossover point is for splat footprints of size two or greater (i.e., at footprint=2 then splat is 5x5x5 and parallel splatting occurs). This is really meant for experimental purposes. V.GetParallelSplatCrossoverMinValue() -> int C++: virtual int GetParallelSplatCrossoverMinValue() Set/get the crossover point expressed in footprint size where the splatting operation is parallelized (through vtkSMPTools). By default the parallel crossover point is for splat footprints of size two or greater (i.e., at footprint=2 then splat is 5x5x5 and parallel splatting occurs). This is really meant for experimental purposes. V.GetParallelSplatCrossoverMaxValue() -> int C++: virtual int GetParallelSplatCrossoverMaxValue() Set/get the crossover point expressed in footprint size where the splatting operation is parallelized (through vtkSMPTools). By default the parallel crossover point is for splat footprints of size two or greater (i.e., at footprint=2 then splat is 5x5x5 and parallel splatting occurs). This is really meant for experimental purposes. V.GetParallelSplatCrossover() -> int C++: virtual int GetParallelSplatCrossover() Set/get the crossover point expressed in footprint size where the splatting operation is parallelized (through vtkSMPTools). By default the parallel crossover point is for splat footprints of size two or greater (i.e., at footprint=2 then splat is 5x5x5 and parallel splatting occurs). This is really meant for experimental purposes. V.ComputeModelBounds(vtkDataSet, vtkImageData, vtkInformation) C++: void ComputeModelBounds(vtkDataSet *input, vtkImageData *output, vtkInformation *outInfo) Compute the size of the sample bounding box automatically from the input data. This is an internal helper function. HHHD9~MbP?GCC: (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0GNUzRx  0D X)l  N   N    4 H)\ p! ! Q   1$8 L `!t ! ) )  ( <1Pd x   EDPa AE 1bEY B } ? D4?HD\?pD(EAD`n AAF  ED@ AG ED@ AG ED@ AG 0ED@ AG TED@ AG xED@ AG ED@ AG ED@ AG ED@ AG ED@ AG ,ED@ AG PED@ AG tED@ AG ED@ AG ED@ AG ED@ AG ED@ AG (ED@ AG LED@ AG pED@ AG ED@ AG ED@ AG ED@ AG ED@ AG $ED@ AG HED@ AG lED@ AG ED@ AG ED@ AG ED@ AG (FADP ABC ( H@ I D H@ I ` H@ I | H@ I  H@ I DEDP AG DEDP AG TEDP AG TEDP AG D DEDP AG h TEDP AG DEDP AG  H@ E  H@ E  H@ E  H@ E  H@ E < H@ E @X [FBB B(A0Dp 0A(B BBBC TEDP AG lEDP AG lEDP AG  tEDP AG , EDP AG P EDP AG t EDP AG gFD@ EE 0 FAA D`  AABH L FDB B(A0A8D 8A0A(B BBBH (@ FCG ABF l MFF8 FBD A(D0a (A ABBH  7;<=>?@ABDEGHJKMNOPQRSTVXZ[\]^_`abcdefghijklm7 np+7qsuwy{}c777$7f777+7h77 7 97 v7 7p 7`Q7@707 787r7777\7777pY7777O77 7! 7"d 7# 7$D 7%D# 7 'T[ 7(T 7)D 70+T 7,DA 7-w 7/ 7 0 7@1" 7`2^ 73 74[ 76T 7`7lO 78l 7@:t 7;7=C7@?}7Ag7pB7D"7F\0 pp pp3!r&r+r0p<6<pQBphHp}NSpY^pdpjpppvp|(p p<pXplp{ppppppppppp1pApKp_p{ppp pppp"$p/*pA0pL6pX<piBptHpNpTpZp`pfplprpxp~ppp5pIpYpcprp~ppP"; "<("= W">)"?"@ "A "BND"D v"E "G "HN"J 7"K n"M "N)"O "P!2"Q c"R!"S "TQ"V -"X e"Z "[1"\"] A"^ u"_!"` "a!"b 3"c)_"d "e)"f "g!"h ]"i "j1"k "l O"m "n 2A{"q1"sb "u?<R"wD"y?"{D"}? "D8Xh"(dkYk G i  7KM    7K !!+!7!J![!n!!!!!!!_ZL35PyvtkCheckerboardSplatter_StaticNewv_ZL38PyvtkCheckerboardSplatter_SafeDownCastP7_objectS0__ZL34PyvtkCheckerboardSplatter_IsTypeOfP7_objectS0__ZL46PyvtkCheckerboardSplatter_GetFootprintMinValueP7_objectS0__ZL59PyvtkCheckerboardSplatter_GetParallelSplatCrossoverMinValueP7_objectS0__ZL48PyvtkCheckerboardSplatter_GetScaleFactorMinValueP7_objectS0__ZL46PyvtkCheckerboardSplatter_GetFootprintMaxValueP7_objectS0__ZL48PyvtkCheckerboardSplatter_GetScaleFactorMaxValueP7_objectS0__ZL49PyvtkCheckerboardSplatter_GetEccentricityMinValueP7_objectS0__ZL43PyvtkCheckerboardSplatter_GetRadiusMinValueP7_objectS0__ZL53PyvtkCheckerboardSplatter_GetMaximumDimensionMinValueP7_objectS0__ZL53PyvtkCheckerboardSplatter_GetAccumulationModeMaxValueP7_objectS0__ZL49PyvtkCheckerboardSplatter_GetEccentricityMaxValueP7_objectS0__ZL43PyvtkCheckerboardSplatter_GetRadiusMaxValueP7_objectS0__ZL59PyvtkCheckerboardSplatter_GetParallelSplatCrossoverMaxValueP7_objectS0__ZL53PyvtkCheckerboardSplatter_GetMaximumDimensionMaxValueP7_objectS0__ZL53PyvtkCheckerboardSplatter_GetAccumulationModeMinValueP7_objectS0__ZL45PyvtkCheckerboardSplatter_GetSampleDimensionsP7_objectS0__ZL40PyvtkCheckerboardSplatter_GetModelBoundsP7_objectS0__ZL36PyvtkCheckerboardSplatter_GetCappingP7_objectS0__ZL38PyvtkCheckerboardSplatter_GetFootprintP7_objectS0__ZL40PyvtkCheckerboardSplatter_GetScaleFactorP7_objectS0__ZL37PyvtkCheckerboardSplatter_GetCapValueP7_objectS0__ZL42PyvtkCheckerboardSplatter_GetScalarWarpingP7_objectS0__ZL38PyvtkCheckerboardSplatter_GetNullValueP7_objectS0__ZL45PyvtkCheckerboardSplatter_GetMaximumDimensionP7_objectS0__ZL45PyvtkCheckerboardSplatter_GetOutputScalarTypeP7_objectS0__ZL51PyvtkCheckerboardSplatter_GetParallelSplatCrossoverP7_objectS0__ZL42PyvtkCheckerboardSplatter_GetNormalWarpingP7_objectS0__ZL43PyvtkCheckerboardSplatter_GetExponentFactorP7_objectS0__ZL41PyvtkCheckerboardSplatter_GetEccentricityP7_objectS0__ZL35PyvtkCheckerboardSplatter_GetRadiusP7_objectS0__ZL45PyvtkCheckerboardSplatter_GetAccumulationModeP7_objectS0__ZL53PyvtkCheckerboardSplatter_GetAccumulationModeAsStringP7_objectS0__ZL53PyvtkCheckerboardSplatter_SetOutputScalarTypeToDoubleP7_objectS0__ZL50PyvtkCheckerboardSplatter_SetAccumulationModeToMinP7_objectS0__ZL52PyvtkCheckerboardSplatter_SetOutputScalarTypeToFloatP7_objectS0__ZL50PyvtkCheckerboardSplatter_SetAccumulationModeToSumP7_objectS0__ZL50PyvtkCheckerboardSplatter_SetAccumulationModeToMaxP7_objectS0__ZL42PyvtkCheckerboardSplatter_SetNormalWarpingP7_objectS0__ZL45PyvtkCheckerboardSplatter_SetOutputScalarTypeP7_objectS0__ZL38PyvtkCheckerboardSplatter_SetNullValueP7_objectS0__ZL43PyvtkCheckerboardSplatter_SetExponentFactorP7_objectS0__ZL36PyvtkCheckerboardSplatter_SetCappingP7_objectS0__ZL37PyvtkCheckerboardSplatter_SetCapValueP7_objectS0__ZL42PyvtkCheckerboardSplatter_SetScalarWarpingP7_objectS0__ZL36PyvtkCheckerboardSplatter_CappingOffP7_objectS0__ZL41PyvtkCheckerboardSplatter_ScalarWarpingOnP7_objectS0__ZL41PyvtkCheckerboardSplatter_NormalWarpingOnP7_objectS0__ZL35PyvtkCheckerboardSplatter_CappingOnP7_objectS0__ZL42PyvtkCheckerboardSplatter_NormalWarpingOffP7_objectS0__ZL42PyvtkCheckerboardSplatter_ScalarWarpingOffP7_objectS0__ZL44PyvtkCheckerboardSplatter_ComputeModelBoundsP7_objectS0__ZL38PyvtkCheckerboardSplatter_SetFootprintP7_objectS0__ZL45PyvtkCheckerboardSplatter_SetAccumulationModeP7_objectS0__ZL51PyvtkCheckerboardSplatter_SetParallelSplatCrossoverP7_objectS0__ZL45PyvtkCheckerboardSplatter_SetMaximumDimensionP7_objectS0__ZL41PyvtkCheckerboardSplatter_SetEccentricityP7_objectS0__ZL35PyvtkCheckerboardSplatter_SetRadiusP7_objectS0__ZL40PyvtkCheckerboardSplatter_SetScaleFactorP7_objectS0__ZL37PyvtkCheckerboardSplatter_NewInstanceP7_objectS0__ZL29PyvtkCheckerboardSplatter_IsAP7_objectS0__ZL45PyvtkCheckerboardSplatter_SetSampleDimensionsP7_objectS0__ZL40PyvtkCheckerboardSplatter_SetModelBoundsP7_objectS0__ZL30PyvtkCheckerboardSplatter_Type_ZL33PyvtkCheckerboardSplatter_Methods_ZZ36PyVTKAddFile_vtkCheckerboardSplatterE9constants_GLOBAL__sub_I_vtkCheckerboardSplatterPython.cxx.LC3.LC4.LC5.LC9.LC6.LC7.LC8.LC10.LC11.LC12.LC13.LC14.LC1.LC15.LC2.LC16.LC17.LC18.LC19.LC20.LC21.LC22.LC23.LC24.LC25.LC26.LC27.LC28.LC29.LC30.LC31.LC32.LC33.LC34.LC35.LC36.LC37.LC38.LC39.LC40.LC41.LC42.LC43.LC44.LC45.LC46.LC47.LC48.LC49.LC50.LC51.LC52.LC53.LC54.LC55.LC56.LC57.LC58.LC59.LC60.LC61.LC62.LC63.LC64.LC65.LC66.LC67.LC68.LC69.LC70.LC71.LC72.LC73.LC74_ZN23vtkCheckerboardSplatter19GetSampleDimensionsEv_ZN23vtkCheckerboardSplatter14SetModelBoundsEdddddd_ZN23vtkCheckerboardSplatter14GetModelBoundsEv_ZN23vtkCheckerboardSplatter12SetFootprintEi_ZN23vtkCheckerboardSplatter20GetFootprintMinValueEv_ZN23vtkCheckerboardSplatter20GetFootprintMaxValueEv_ZN23vtkCheckerboardSplatter12GetFootprintEv_ZN23vtkCheckerboardSplatter9SetRadiusEd_ZN23vtkCheckerboardSplatter17GetRadiusMinValueEv_ZN23vtkCheckerboardSplatter17GetRadiusMaxValueEv_ZN23vtkCheckerboardSplatter9GetRadiusEv_ZN23vtkCheckerboardSplatter14SetScaleFactorEd_ZN23vtkCheckerboardSplatter22GetScaleFactorMinValueEv_ZN23vtkCheckerboardSplatter22GetScaleFactorMaxValueEv_ZN23vtkCheckerboardSplatter14GetScaleFactorEv_ZN23vtkCheckerboardSplatter17SetExponentFactorEd_ZN23vtkCheckerboardSplatter17GetExponentFactorEv_ZN23vtkCheckerboardSplatter16SetScalarWarpingEi_ZN23vtkCheckerboardSplatter16GetScalarWarpingEv_ZN23vtkCheckerboardSplatter16SetNormalWarpingEi_ZN23vtkCheckerboardSplatter16GetNormalWarpingEv_ZN23vtkCheckerboardSplatter15SetEccentricityEd_ZN23vtkCheckerboardSplatter23GetEccentricityMinValueEv_ZN23vtkCheckerboardSplatter23GetEccentricityMaxValueEv_ZN23vtkCheckerboardSplatter15GetEccentricityEv_ZN23vtkCheckerboardSplatter19SetAccumulationModeEi_ZN23vtkCheckerboardSplatter27GetAccumulationModeMinValueEv_ZN23vtkCheckerboardSplatter27GetAccumulationModeMaxValueEv_ZN23vtkCheckerboardSplatter19GetAccumulationModeEv_ZN23vtkCheckerboardSplatter19SetOutputScalarTypeEi_ZN23vtkCheckerboardSplatter19GetOutputScalarTypeEv_ZN23vtkCheckerboardSplatter10SetCappingEi_ZN23vtkCheckerboardSplatter10GetCappingEv_ZN23vtkCheckerboardSplatter11SetCapValueEd_ZN23vtkCheckerboardSplatter11GetCapValueEv_ZN23vtkCheckerboardSplatter12SetNullValueEd_ZN23vtkCheckerboardSplatter12GetNullValueEv_ZN23vtkCheckerboardSplatter27GetMaximumDimensionMinValueEv_ZN23vtkCheckerboardSplatter27GetMaximumDimensionMaxValueEv_ZN23vtkCheckerboardSplatter19GetMaximumDimensionEv_ZN23vtkCheckerboardSplatter25SetParallelSplatCrossoverEi_ZN23vtkCheckerboardSplatter33GetParallelSplatCrossoverMinValueEv_ZN23vtkCheckerboardSplatter33GetParallelSplatCrossoverMaxValueEv_ZN23vtkCheckerboardSplatter25GetParallelSplatCrossoverEv_ZN23vtkCheckerboardSplatter3NewEv_ZNK23vtkCheckerboardSplatter19NewInstanceInternalEv_ZN13vtkPythonArgs13ArgCountErrorEii_ZN13vtkPythonArgs17GetArgAsVTKObjectEPKcRbPyErr_Occurred_ZN13vtkPythonUtil20GetObjectFromPointerEP13vtkObjectBase__stack_chk_fail_ZN23vtkCheckerboardSplatter19SetMaximumDimensionEi_ZN23vtkCheckerboardSplatter3IsAEPKcstrcmp_ZN13vtkObjectBase8IsTypeOfEPKc_ZN23vtkCheckerboardSplatter15ScalarWarpingOnEv_GLOBAL_OFFSET_TABLE__ZN23vtkCheckerboardSplatter16ScalarWarpingOffEv_ZN23vtkCheckerboardSplatter15NormalWarpingOnEv_ZN23vtkCheckerboardSplatter16NormalWarpingOffEv_ZN23vtkCheckerboardSplatter9CappingOnEv_ZN23vtkCheckerboardSplatter10CappingOffEv_ZN13vtkPythonArgs8GetValueERPcPyLong_FromLong_ZN23vtkCheckerboardSplatter14SetModelBoundsEPd_ZN13vtkPythonArgs19GetSelfFromFirstArgEP7_objectS1_PyFloat_FromDouble_ZN13vtkPythonArgs10BuildTupleEPKii_ZN13vtkPythonArgs10BuildTupleEPKdi_ZN23vtkCheckerboardSplatter27GetAccumulationModeAsStringEvstrlenPyUnicode_FromStringAndSizePyErr_ClearPyBytes_FromStringAndSize_Py_NoneStruct_ZN13vtkPythonArgs8GetValueERi_ZN13vtkPythonArgs8GetValueERd_ZN23vtkCheckerboardSplatter18ComputeModelBoundsEP10vtkDataSetP12vtkImageDataP14vtkInformationPyVTKObject_CheckPyVTKObject_GetObjectPyVTKObject_SetFlag_ZN13vtkPythonArgs13ArgCountErrorEiPKc_ZN23vtkCheckerboardSplatter19SetSampleDimensionsEiii_ZN13vtkPythonArgs8GetArrayEPii_ZN23vtkCheckerboardSplatter19SetSampleDimensionsEPi_ZN13vtkPythonArgs8SetArrayEiPKii_ZN13vtkPythonArgs8GetArrayEPdiPyvtkCheckerboardSplatter_ClassNewPyVTKClass_AddPyvtkImageAlgorithm_ClassNewPyType_ReadyPyVTKAddFile_vtkCheckerboardSplatterPyDict_SetItemString_Py_DeallocPyType_TypePyVTKObject_DeletePyVTKObject_ReprPyVTKObject_StringPyObject_GenericGetAttrPyObject_GenericSetAttrPyVTKObject_AsBufferPyVTKObject_TraversePyVTKObject_GetSetPyVTKObject_NewPyObject_GC_Del,` J}  !n *Nq *.Qn}*.Qjw *AXbq*AXbq*A^m* A W d  } *   ! : G  b *o    ( 2 A W e *z    ( 2 A W e *z    * 7  R *_   ' B*O -*:a*#Q*A *!n *Nq*^*!n *Nq*^ *>a{ *A[h }*!;H ]*j"1M*r2A]*!BQm*1KX m*z!);IS^k*v - *M Y *r   !-!*N!Z!*o!!!"-"*M"Y"*r"""#-#*M#Y#*r###$-$*M$Y$*r$$$!%;%k%w%*%*%%J&q&&&&*&*'A''''((*>(*p(((!);)s))*)*)*Z******** +Q++++#,/,*N,*,, -1-K-{--*-*-.M.q..*..*.* . /m///*//*/*0@0000*00*1*21`1111*22*:2* R22223*23>3*Z3*o333414*R4^4*z4*44&5`5h5|5555555*55!6z66666*7*P77788\8l8*8*88J9q9999*9*8:a::::@;P;*n;*;;:<a<{<<<<<*=*=.={===!>;>k>>>*>*>;?a????+@U@e@*@*@@"AoAAA*AAAABB5BDBcBBB!C;C ^C*kCpC~CCCC CCCCCC`DDDECEKEYE~EEEEEE*E F!8FQFqFF"FFJG[GcGGGGH1HFH[HpHHH*I#I*oJJ*JJ* KKKKK%KK&KK'L$LL)'L4L JL)tL*L*&+9>LQ^******3*~11 1+>0,X-./012384@513> 1~(pB8>@1HX>`1rhAx>h1D>1X@>1F>1l0>16>  1<(8>p@1hHX>`1hx> 1Y=>h1> 1 >"1A>h#1c@?>$ 1Q(8>%@1}HX>&`1hx>'1/(>x(1p>h)1X,>P*1>*1t/>H+ 1(38>+@1H$X>(,`1hx>8-1 0>H.1`2>P/1I;>X01>11 >p3 11(8>5@1H`7X>6`1<h`x>p81 >h:1K>`<1 >H>1#>0@1">B 1_(8>D@1H%X>F`1hx>G1{>0H1!>HI1A)>`J1{ >HK1@1>(L 1i(-8>M@1LH0+X>M`1hx>N1" '>(O1>P15@:>HR1>S1 p >U 1(8>hW@1H8X>Y`>hx>Z>( >p\1>(^14>_ 4H\p     $8L`t(<Pd x!"#$%&'(),*@+T,h-|.0345$687L8`9t:<4X|  0 T xp `@0 ,Pt(Lpp , H  d ! " # $ %  '$ (H )l 0+ , - /  0 @1$ `2@ 3\ 4 6 `7 8 @:0 ;T =x @? A pB DD Fp K K ~.symtab.strtab.shstrtab.rela.text.data.bss.text._ZN23vtkCheckerboardSplatter19GetSampleDimensionsEv.text._ZN23vtkCheckerboardSplatter14SetModelBoundsEdddddd.text._ZN23vtkCheckerboardSplatter14GetModelBoundsEv.text._ZN23vtkCheckerboardSplatter12SetFootprintEi.text._ZN23vtkCheckerboardSplatter20GetFootprintMinValueEv.text._ZN23vtkCheckerboardSplatter20GetFootprintMaxValueEv.text._ZN23vtkCheckerboardSplatter12GetFootprintEv.rela.text._ZN23vtkCheckerboardSplatter9SetRadiusEd.text._ZN23vtkCheckerboardSplatter17GetRadiusMinValueEv.rela.text._ZN23vtkCheckerboardSplatter17GetRadiusMaxValueEv.text._ZN23vtkCheckerboardSplatter9GetRadiusEv.rela.text._ZN23vtkCheckerboardSplatter14SetScaleFactorEd.text._ZN23vtkCheckerboardSplatter22GetScaleFactorMinValueEv.rela.text._ZN23vtkCheckerboardSplatter22GetScaleFactorMaxValueEv.text._ZN23vtkCheckerboardSplatter14GetScaleFactorEv.text._ZN23vtkCheckerboardSplatter17SetExponentFactorEd.text._ZN23vtkCheckerboardSplatter17GetExponentFactorEv.text._ZN23vtkCheckerboardSplatter16SetScalarWarpingEi.text._ZN23vtkCheckerboardSplatter16GetScalarWarpingEv.text._ZN23vtkCheckerboardSplatter16SetNormalWarpingEi.text._ZN23vtkCheckerboardSplatter16GetNormalWarpingEv.rela.text._ZN23vtkCheckerboardSplatter15SetEccentricityEd.rela.text._ZN23vtkCheckerboardSplatter23GetEccentricityMinValueEv.rela.text._ZN23vtkCheckerboardSplatter23GetEccentricityMaxValueEv.text._ZN23vtkCheckerboardSplatter15GetEccentricityEv.text._ZN23vtkCheckerboardSplatter19SetAccumulationModeEi.text._ZN23vtkCheckerboardSplatter27GetAccumulationModeMinValueEv.text._ZN23vtkCheckerboardSplatter27GetAccumulationModeMaxValueEv.text._ZN23vtkCheckerboardSplatter19GetAccumulationModeEv.text._ZN23vtkCheckerboardSplatter19SetOutputScalarTypeEi.text._ZN23vtkCheckerboardSplatter19GetOutputScalarTypeEv.text._ZN23vtkCheckerboardSplatter10SetCappingEi.text._ZN23vtkCheckerboardSplatter10GetCappingEv.text._ZN23vtkCheckerboardSplatter11SetCapValueEd.text._ZN23vtkCheckerboardSplatter11GetCapValueEv.text._ZN23vtkCheckerboardSplatter12SetNullValueEd.text._ZN23vtkCheckerboardSplatter12GetNullValueEv.text._ZN23vtkCheckerboardSplatter27GetMaximumDimensionMinValueEv.text._ZN23vtkCheckerboardSplatter27GetMaximumDimensionMaxValueEv.text._ZN23vtkCheckerboardSplatter19GetMaximumDimensionEv.text._ZN23vtkCheckerboardSplatter25SetParallelSplatCrossoverEi.text._ZN23vtkCheckerboardSplatter33GetParallelSplatCrossoverMinValueEv.text._ZN23vtkCheckerboardSplatter33GetParallelSplatCrossoverMaxValueEv.text._ZN23vtkCheckerboardSplatter25GetParallelSplatCrossoverEv.rela.text._ZNK23vtkCheckerboardSplatter19NewInstanceInternalEv.rodata.str1.1.text._ZN23vtkCheckerboardSplatter19SetMaximumDimensionEi.rodata._ZN23vtkCheckerboardSplatter3IsAEPKc.str1.1.rela.text._ZN23vtkCheckerboardSplatter3IsAEPKc.rela.text._ZN23vtkCheckerboardSplatter15ScalarWarpingOnEv.rela.text._ZN23vtkCheckerboardSplatter16ScalarWarpingOffEv.rela.text._ZN23vtkCheckerboardSplatter15NormalWarpingOnEv.rela.text._ZN23vtkCheckerboardSplatter16NormalWarpingOffEv.rela.text._ZN23vtkCheckerboardSplatter9CappingOnEv.rela.text._ZN23vtkCheckerboardSplatter10CappingOffEv.rela.text._ZN23vtkCheckerboardSplatter14SetModelBoundsEPd.rodata.str1.8.rela.text.startup.rela.init_array.rela.data.rel.ro.local.rela.data.rel.rela.data.rel.local.rodata.cst8.comment.note.GNU-stack.note.gnu.property.rela.eh_frame.group\ @\ H\ P\ X\ `\ h\ p\ x \ \  \ \  \ \  \ \ \ \ \ \ \ \  \  \  \ \ $\ ,\ 4\ <\ D\ L\ T\ \\ d\ l\ t\ |\ \ \ \ \ \ \ \  \ \  \  \  \  \  \   \  \ $  0L@847&N,N1N kNpO O) OHO O ON@IB0P '@P "@IE_PP `PN@0IHP  P @HIKGP |P)Q  Q!#PQ Z`Q!Q QQ@`I0TR @IVKR F@IX R 0R1pR;R }R R!R +R!\S  S)PS `S)$S WSS S  S1U T  T  0T * @T % @Ine 2ITt @Y1 2qY) Yb @Is Z? @JuR PZDM @Jw Z? @Jy ZD @J{ 0[? @K}9 p[D4 @(Ko [j @@K 2\` p @XK0  @K 0 @KH  @K   @M ! 0,* :  R  M @^X  !jc