vtk_rs/
vtkCommonComputationalGeometry.rs

1/// computes an interpolating spline using a
2///
3/// a Cardinal basis.
4///
5///
6/// vtkCardinalSpline is a concrete implementation of vtkSpline using a
7/// Cardinal basis.
8///
9/// @sa
10/// vtkSpline vtkKochanekSpline
11#[allow(non_camel_case_types)]
12pub struct vtkCardinalSpline(*mut core::ffi::c_void);
13impl vtkCardinalSpline {
14    /// Creates a new [vtkCardinalSpline] wrapped inside `vtkNew`
15    #[doc(alias = "vtkCardinalSpline")]
16    pub fn new() -> Self {
17        unsafe extern "C" {
18            fn vtkCardinalSpline_new() -> *mut core::ffi::c_void;
19        }
20        Self(unsafe { &mut *vtkCardinalSpline_new() })
21    }
22    #[cfg(test)]
23    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
24        unsafe extern "C" {
25            fn vtkCardinalSpline_get_ptr(
26                sself: *mut core::ffi::c_void,
27            ) -> *mut core::ffi::c_void;
28        }
29        unsafe { vtkCardinalSpline_get_ptr(self.0) }
30    }
31}
32impl std::default::Default for vtkCardinalSpline {
33    fn default() -> Self {
34        Self::new()
35    }
36}
37impl Drop for vtkCardinalSpline {
38    fn drop(&mut self) {
39        unsafe extern "C" {
40            fn vtkCardinalSpline_destructor(sself: *mut core::ffi::c_void);
41        }
42        unsafe { vtkCardinalSpline_destructor(self.0) }
43        self.0 = core::ptr::null_mut();
44    }
45}
46#[test]
47fn test_vtkCardinalSpline_create_drop() {
48    let obj = vtkCardinalSpline::new();
49    let ptr = obj.0;
50    assert!(!ptr.is_null());
51    assert!(unsafe { !obj._get_ptr().is_null() });
52    drop(obj);
53    let new_obj = vtkCardinalSpline(ptr);
54    assert!(unsafe { new_obj._get_ptr().is_null() });
55}
56/// computes an interpolating spline using a Kochanek basis.
57///
58///
59/// Implements the Kochanek interpolating spline described in: Kochanek, D.,
60/// Bartels, R., "Interpolating Splines with Local Tension, Continuity, and
61/// Bias Control," Computer Graphics, vol. 18, no. 3, pp. 33-41, July 1984.
62/// These splines give the user more control over the shape of the curve than
63/// the cardinal splines implemented in vtkCardinalSpline. Three parameters
64/// can be specified. All have a range from -1 to 1.
65///
66/// Tension controls how sharply the curve bends at an input point. A
67/// value of -1 produces more slack in the curve. A value of 1 tightens
68/// the curve.
69///
70/// Continuity controls the continuity of the first derivative at input
71/// points.
72///
73/// Bias controls the direction of the curve at it passes through an input
74/// point. A value of -1 undershoots the point while a value of 1
75/// overshoots the point.
76///
77/// These three parameters give the user broad control over the shape of
78/// the interpolating spline. The original Kochanek paper describes the
79/// effects nicely and is recommended reading.
80///
81/// @sa
82/// vtkSpline vtkCardinalSpline
83#[allow(non_camel_case_types)]
84pub struct vtkKochanekSpline(*mut core::ffi::c_void);
85impl vtkKochanekSpline {
86    /// Creates a new [vtkKochanekSpline] wrapped inside `vtkNew`
87    #[doc(alias = "vtkKochanekSpline")]
88    pub fn new() -> Self {
89        unsafe extern "C" {
90            fn vtkKochanekSpline_new() -> *mut core::ffi::c_void;
91        }
92        Self(unsafe { &mut *vtkKochanekSpline_new() })
93    }
94    #[cfg(test)]
95    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
96        unsafe extern "C" {
97            fn vtkKochanekSpline_get_ptr(
98                sself: *mut core::ffi::c_void,
99            ) -> *mut core::ffi::c_void;
100        }
101        unsafe { vtkKochanekSpline_get_ptr(self.0) }
102    }
103}
104impl std::default::Default for vtkKochanekSpline {
105    fn default() -> Self {
106        Self::new()
107    }
108}
109impl Drop for vtkKochanekSpline {
110    fn drop(&mut self) {
111        unsafe extern "C" {
112            fn vtkKochanekSpline_destructor(sself: *mut core::ffi::c_void);
113        }
114        unsafe { vtkKochanekSpline_destructor(self.0) }
115        self.0 = core::ptr::null_mut();
116    }
117}
118#[test]
119fn test_vtkKochanekSpline_create_drop() {
120    let obj = vtkKochanekSpline::new();
121    let ptr = obj.0;
122    assert!(!ptr.is_null());
123    assert!(unsafe { !obj._get_ptr().is_null() });
124    drop(obj);
125    let new_obj = vtkKochanekSpline(ptr);
126    assert!(unsafe { new_obj._get_ptr().is_null() });
127}
128/// Generate a Bohemian dome.
129///
130///
131/// vtkParametricBohemianDome generates a parametric Bohemian dome. The Bohemian
132/// dome is a quartic surface, and is described in much better detail at
133/// <a href="https://www.math.hmc.edu/math142-01/mellon/curves_and_surfaces/surfaces/bohdom.html">HMC
134/// page</a>.
135/// @warning
136/// I haven't set any restrictions on the A, B, or C values.
137/// @par Thanks:
138/// Tim Meehan
139#[allow(non_camel_case_types)]
140pub struct vtkParametricBohemianDome(*mut core::ffi::c_void);
141impl vtkParametricBohemianDome {
142    /// Creates a new [vtkParametricBohemianDome] wrapped inside `vtkNew`
143    #[doc(alias = "vtkParametricBohemianDome")]
144    pub fn new() -> Self {
145        unsafe extern "C" {
146            fn vtkParametricBohemianDome_new() -> *mut core::ffi::c_void;
147        }
148        Self(unsafe { &mut *vtkParametricBohemianDome_new() })
149    }
150    #[cfg(test)]
151    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
152        unsafe extern "C" {
153            fn vtkParametricBohemianDome_get_ptr(
154                sself: *mut core::ffi::c_void,
155            ) -> *mut core::ffi::c_void;
156        }
157        unsafe { vtkParametricBohemianDome_get_ptr(self.0) }
158    }
159}
160impl std::default::Default for vtkParametricBohemianDome {
161    fn default() -> Self {
162        Self::new()
163    }
164}
165impl Drop for vtkParametricBohemianDome {
166    fn drop(&mut self) {
167        unsafe extern "C" {
168            fn vtkParametricBohemianDome_destructor(sself: *mut core::ffi::c_void);
169        }
170        unsafe { vtkParametricBohemianDome_destructor(self.0) }
171        self.0 = core::ptr::null_mut();
172    }
173}
174#[test]
175fn test_vtkParametricBohemianDome_create_drop() {
176    let obj = vtkParametricBohemianDome::new();
177    let ptr = obj.0;
178    assert!(!ptr.is_null());
179    assert!(unsafe { !obj._get_ptr().is_null() });
180    drop(obj);
181    let new_obj = vtkParametricBohemianDome(ptr);
182    assert!(unsafe { new_obj._get_ptr().is_null() });
183}
184/// Generate Bour's minimal surface.
185///
186///
187/// vtkParametricBour generates Bour's minimal surface parametrically. More
188/// information can be found at
189/// <a href="http://en.wikipedia.org/wiki/Bour%27s_minimal_surface">Wikipedia</a>.
190/// @par Thanks:
191/// Tim Meehan
192#[allow(non_camel_case_types)]
193pub struct vtkParametricBour(*mut core::ffi::c_void);
194impl vtkParametricBour {
195    /// Creates a new [vtkParametricBour] wrapped inside `vtkNew`
196    #[doc(alias = "vtkParametricBour")]
197    pub fn new() -> Self {
198        unsafe extern "C" {
199            fn vtkParametricBour_new() -> *mut core::ffi::c_void;
200        }
201        Self(unsafe { &mut *vtkParametricBour_new() })
202    }
203    #[cfg(test)]
204    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
205        unsafe extern "C" {
206            fn vtkParametricBour_get_ptr(
207                sself: *mut core::ffi::c_void,
208            ) -> *mut core::ffi::c_void;
209        }
210        unsafe { vtkParametricBour_get_ptr(self.0) }
211    }
212}
213impl std::default::Default for vtkParametricBour {
214    fn default() -> Self {
215        Self::new()
216    }
217}
218impl Drop for vtkParametricBour {
219    fn drop(&mut self) {
220        unsafe extern "C" {
221            fn vtkParametricBour_destructor(sself: *mut core::ffi::c_void);
222        }
223        unsafe { vtkParametricBour_destructor(self.0) }
224        self.0 = core::ptr::null_mut();
225    }
226}
227#[test]
228fn test_vtkParametricBour_create_drop() {
229    let obj = vtkParametricBour::new();
230    let ptr = obj.0;
231    assert!(!ptr.is_null());
232    assert!(unsafe { !obj._get_ptr().is_null() });
233    drop(obj);
234    let new_obj = vtkParametricBour(ptr);
235    assert!(unsafe { new_obj._get_ptr().is_null() });
236}
237/// Generate Boy's surface.
238///
239///
240/// vtkParametricBoy generates Boy's surface.
241/// This is a Model of the projective plane without singularities.
242/// It was found by Werner Boy on assignment from David Hilbert.
243///
244/// For further information about this surface, please consult the
245/// technical description "Parametric surfaces" in http://www.vtk.org/publications
246/// in the "VTK Technical Documents" section in the VTk.org web pages.
247///
248/// @par Thanks:
249/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
250/// class.
251#[allow(non_camel_case_types)]
252pub struct vtkParametricBoy(*mut core::ffi::c_void);
253impl vtkParametricBoy {
254    /// Creates a new [vtkParametricBoy] wrapped inside `vtkNew`
255    #[doc(alias = "vtkParametricBoy")]
256    pub fn new() -> Self {
257        unsafe extern "C" {
258            fn vtkParametricBoy_new() -> *mut core::ffi::c_void;
259        }
260        Self(unsafe { &mut *vtkParametricBoy_new() })
261    }
262    #[cfg(test)]
263    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
264        unsafe extern "C" {
265            fn vtkParametricBoy_get_ptr(
266                sself: *mut core::ffi::c_void,
267            ) -> *mut core::ffi::c_void;
268        }
269        unsafe { vtkParametricBoy_get_ptr(self.0) }
270    }
271}
272impl std::default::Default for vtkParametricBoy {
273    fn default() -> Self {
274        Self::new()
275    }
276}
277impl Drop for vtkParametricBoy {
278    fn drop(&mut self) {
279        unsafe extern "C" {
280            fn vtkParametricBoy_destructor(sself: *mut core::ffi::c_void);
281        }
282        unsafe { vtkParametricBoy_destructor(self.0) }
283        self.0 = core::ptr::null_mut();
284    }
285}
286#[test]
287fn test_vtkParametricBoy_create_drop() {
288    let obj = vtkParametricBoy::new();
289    let ptr = obj.0;
290    assert!(!ptr.is_null());
291    assert!(unsafe { !obj._get_ptr().is_null() });
292    drop(obj);
293    let new_obj = vtkParametricBoy(ptr);
294    assert!(unsafe { new_obj._get_ptr().is_null() });
295}
296/// Generate Catalan's minimal surface.
297///
298///
299/// vtkParametricCatalanMinimal generates Catalan's minimal surface
300/// parametrically. This minimal surface contains the cycloid as a geodesic.
301/// More information about it can be found at
302/// <a href="https://en.wikipedia.org/wiki/Catalan%27s_minimal_surface">Wikipedia</a>.
303/// @par Thanks:
304/// Tim Meehan
305#[allow(non_camel_case_types)]
306pub struct vtkParametricCatalanMinimal(*mut core::ffi::c_void);
307impl vtkParametricCatalanMinimal {
308    /// Creates a new [vtkParametricCatalanMinimal] wrapped inside `vtkNew`
309    #[doc(alias = "vtkParametricCatalanMinimal")]
310    pub fn new() -> Self {
311        unsafe extern "C" {
312            fn vtkParametricCatalanMinimal_new() -> *mut core::ffi::c_void;
313        }
314        Self(unsafe { &mut *vtkParametricCatalanMinimal_new() })
315    }
316    #[cfg(test)]
317    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
318        unsafe extern "C" {
319            fn vtkParametricCatalanMinimal_get_ptr(
320                sself: *mut core::ffi::c_void,
321            ) -> *mut core::ffi::c_void;
322        }
323        unsafe { vtkParametricCatalanMinimal_get_ptr(self.0) }
324    }
325}
326impl std::default::Default for vtkParametricCatalanMinimal {
327    fn default() -> Self {
328        Self::new()
329    }
330}
331impl Drop for vtkParametricCatalanMinimal {
332    fn drop(&mut self) {
333        unsafe extern "C" {
334            fn vtkParametricCatalanMinimal_destructor(sself: *mut core::ffi::c_void);
335        }
336        unsafe { vtkParametricCatalanMinimal_destructor(self.0) }
337        self.0 = core::ptr::null_mut();
338    }
339}
340#[test]
341fn test_vtkParametricCatalanMinimal_create_drop() {
342    let obj = vtkParametricCatalanMinimal::new();
343    let ptr = obj.0;
344    assert!(!ptr.is_null());
345    assert!(unsafe { !obj._get_ptr().is_null() });
346    drop(obj);
347    let new_obj = vtkParametricCatalanMinimal(ptr);
348    assert!(unsafe { new_obj._get_ptr().is_null() });
349}
350/// Generate conic spiral surfaces that resemble sea-shells.
351///
352///
353/// vtkParametricConicSpiral generates conic spiral surfaces. These can resemble sea shells, or
354/// may look like a torus "eating" its own tail.
355///
356/// For further information about this surface, please consult the
357/// technical description "Parametric surfaces" in http://www.vtk.org/publications
358/// in the "VTK Technical Documents" section in the VTk.org web pages.
359///
360/// @par Thanks:
361/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
362/// class.
363#[allow(non_camel_case_types)]
364pub struct vtkParametricConicSpiral(*mut core::ffi::c_void);
365impl vtkParametricConicSpiral {
366    /// Creates a new [vtkParametricConicSpiral] wrapped inside `vtkNew`
367    #[doc(alias = "vtkParametricConicSpiral")]
368    pub fn new() -> Self {
369        unsafe extern "C" {
370            fn vtkParametricConicSpiral_new() -> *mut core::ffi::c_void;
371        }
372        Self(unsafe { &mut *vtkParametricConicSpiral_new() })
373    }
374    #[cfg(test)]
375    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
376        unsafe extern "C" {
377            fn vtkParametricConicSpiral_get_ptr(
378                sself: *mut core::ffi::c_void,
379            ) -> *mut core::ffi::c_void;
380        }
381        unsafe { vtkParametricConicSpiral_get_ptr(self.0) }
382    }
383}
384impl std::default::Default for vtkParametricConicSpiral {
385    fn default() -> Self {
386        Self::new()
387    }
388}
389impl Drop for vtkParametricConicSpiral {
390    fn drop(&mut self) {
391        unsafe extern "C" {
392            fn vtkParametricConicSpiral_destructor(sself: *mut core::ffi::c_void);
393        }
394        unsafe { vtkParametricConicSpiral_destructor(self.0) }
395        self.0 = core::ptr::null_mut();
396    }
397}
398#[test]
399fn test_vtkParametricConicSpiral_create_drop() {
400    let obj = vtkParametricConicSpiral::new();
401    let ptr = obj.0;
402    assert!(!ptr.is_null());
403    assert!(unsafe { !obj._get_ptr().is_null() });
404    drop(obj);
405    let new_obj = vtkParametricConicSpiral(ptr);
406    assert!(unsafe { new_obj._get_ptr().is_null() });
407}
408/// Generate a cross-cap.
409///
410///
411/// vtkParametricCrossCap generates a cross-cap which is a
412/// non-orientable self-intersecting single-sided surface.
413/// This is one possible image of a projective plane in three-space.
414///
415/// For further information about this surface, please consult the
416/// technical description "Parametric surfaces" in http://www.vtk.org/publications
417/// in the "VTK Technical Documents" section in the VTk.org web pages.
418///
419/// @par Thanks:
420/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
421/// class.
422#[allow(non_camel_case_types)]
423pub struct vtkParametricCrossCap(*mut core::ffi::c_void);
424impl vtkParametricCrossCap {
425    /// Creates a new [vtkParametricCrossCap] wrapped inside `vtkNew`
426    #[doc(alias = "vtkParametricCrossCap")]
427    pub fn new() -> Self {
428        unsafe extern "C" {
429            fn vtkParametricCrossCap_new() -> *mut core::ffi::c_void;
430        }
431        Self(unsafe { &mut *vtkParametricCrossCap_new() })
432    }
433    #[cfg(test)]
434    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
435        unsafe extern "C" {
436            fn vtkParametricCrossCap_get_ptr(
437                sself: *mut core::ffi::c_void,
438            ) -> *mut core::ffi::c_void;
439        }
440        unsafe { vtkParametricCrossCap_get_ptr(self.0) }
441    }
442}
443impl std::default::Default for vtkParametricCrossCap {
444    fn default() -> Self {
445        Self::new()
446    }
447}
448impl Drop for vtkParametricCrossCap {
449    fn drop(&mut self) {
450        unsafe extern "C" {
451            fn vtkParametricCrossCap_destructor(sself: *mut core::ffi::c_void);
452        }
453        unsafe { vtkParametricCrossCap_destructor(self.0) }
454        self.0 = core::ptr::null_mut();
455    }
456}
457#[test]
458fn test_vtkParametricCrossCap_create_drop() {
459    let obj = vtkParametricCrossCap::new();
460    let ptr = obj.0;
461    assert!(!ptr.is_null());
462    assert!(unsafe { !obj._get_ptr().is_null() });
463    drop(obj);
464    let new_obj = vtkParametricCrossCap(ptr);
465    assert!(unsafe { new_obj._get_ptr().is_null() });
466}
467/// Generate Dini's surface.
468///
469///
470/// vtkParametricDini generates Dini's surface.
471/// Dini's surface is a surface that possesses constant negative
472/// Gaussian curvature
473///
474/// For further information about this surface, please consult
475/// https://en.wikipedia.org/wiki/Dini%27s_surface
476///
477/// @par Thanks:
478/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
479/// class.
480#[allow(non_camel_case_types)]
481pub struct vtkParametricDini(*mut core::ffi::c_void);
482impl vtkParametricDini {
483    /// Creates a new [vtkParametricDini] wrapped inside `vtkNew`
484    #[doc(alias = "vtkParametricDini")]
485    pub fn new() -> Self {
486        unsafe extern "C" {
487            fn vtkParametricDini_new() -> *mut core::ffi::c_void;
488        }
489        Self(unsafe { &mut *vtkParametricDini_new() })
490    }
491    #[cfg(test)]
492    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
493        unsafe extern "C" {
494            fn vtkParametricDini_get_ptr(
495                sself: *mut core::ffi::c_void,
496            ) -> *mut core::ffi::c_void;
497        }
498        unsafe { vtkParametricDini_get_ptr(self.0) }
499    }
500}
501impl std::default::Default for vtkParametricDini {
502    fn default() -> Self {
503        Self::new()
504    }
505}
506impl Drop for vtkParametricDini {
507    fn drop(&mut self) {
508        unsafe extern "C" {
509            fn vtkParametricDini_destructor(sself: *mut core::ffi::c_void);
510        }
511        unsafe { vtkParametricDini_destructor(self.0) }
512        self.0 = core::ptr::null_mut();
513    }
514}
515#[test]
516fn test_vtkParametricDini_create_drop() {
517    let obj = vtkParametricDini::new();
518    let ptr = obj.0;
519    assert!(!ptr.is_null());
520    assert!(unsafe { !obj._get_ptr().is_null() });
521    drop(obj);
522    let new_obj = vtkParametricDini(ptr);
523    assert!(unsafe { new_obj._get_ptr().is_null() });
524}
525/// Generate an ellipsoid.
526///
527///
528/// vtkParametricEllipsoid generates an ellipsoid.
529/// If all the radii are the same, we have a sphere.
530/// An oblate spheroid occurs if RadiusX = RadiusY > RadiusZ.
531/// Here the Z-axis forms the symmetry axis. To a first
532/// approximation, this is the shape of the earth.
533/// A prolate spheroid occurs if RadiusX = RadiusY < RadiusZ.
534///
535/// For further information about this surface, please consult the
536/// technical description "Parametric surfaces" in http://www.vtk.org/publications
537/// in the "VTK Technical Documents" section in the VTk.org web pages.
538///
539/// @par Thanks:
540/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
541/// class.
542#[allow(non_camel_case_types)]
543pub struct vtkParametricEllipsoid(*mut core::ffi::c_void);
544impl vtkParametricEllipsoid {
545    /// Creates a new [vtkParametricEllipsoid] wrapped inside `vtkNew`
546    #[doc(alias = "vtkParametricEllipsoid")]
547    pub fn new() -> Self {
548        unsafe extern "C" {
549            fn vtkParametricEllipsoid_new() -> *mut core::ffi::c_void;
550        }
551        Self(unsafe { &mut *vtkParametricEllipsoid_new() })
552    }
553    #[cfg(test)]
554    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
555        unsafe extern "C" {
556            fn vtkParametricEllipsoid_get_ptr(
557                sself: *mut core::ffi::c_void,
558            ) -> *mut core::ffi::c_void;
559        }
560        unsafe { vtkParametricEllipsoid_get_ptr(self.0) }
561    }
562}
563impl std::default::Default for vtkParametricEllipsoid {
564    fn default() -> Self {
565        Self::new()
566    }
567}
568impl Drop for vtkParametricEllipsoid {
569    fn drop(&mut self) {
570        unsafe extern "C" {
571            fn vtkParametricEllipsoid_destructor(sself: *mut core::ffi::c_void);
572        }
573        unsafe { vtkParametricEllipsoid_destructor(self.0) }
574        self.0 = core::ptr::null_mut();
575    }
576}
577#[test]
578fn test_vtkParametricEllipsoid_create_drop() {
579    let obj = vtkParametricEllipsoid::new();
580    let ptr = obj.0;
581    assert!(!ptr.is_null());
582    assert!(unsafe { !obj._get_ptr().is_null() });
583    drop(obj);
584    let new_obj = vtkParametricEllipsoid(ptr);
585    assert!(unsafe { new_obj._get_ptr().is_null() });
586}
587/// Generate Enneper's surface.
588///
589///
590/// vtkParametricEnneper generates Enneper's surface.
591/// Enneper's surface is a self-intersecting minimal surface
592/// possessing constant negative Gaussian curvature
593///
594/// For further information about this surface, please consult the
595/// technical description "Parametric surfaces" in http://www.vtk.org/publications
596/// in the "VTK Technical Documents" section in the VTk.org web pages.
597///
598/// @par Thanks:
599/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
600/// class.
601#[allow(non_camel_case_types)]
602pub struct vtkParametricEnneper(*mut core::ffi::c_void);
603impl vtkParametricEnneper {
604    /// Creates a new [vtkParametricEnneper] wrapped inside `vtkNew`
605    #[doc(alias = "vtkParametricEnneper")]
606    pub fn new() -> Self {
607        unsafe extern "C" {
608            fn vtkParametricEnneper_new() -> *mut core::ffi::c_void;
609        }
610        Self(unsafe { &mut *vtkParametricEnneper_new() })
611    }
612    #[cfg(test)]
613    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
614        unsafe extern "C" {
615            fn vtkParametricEnneper_get_ptr(
616                sself: *mut core::ffi::c_void,
617            ) -> *mut core::ffi::c_void;
618        }
619        unsafe { vtkParametricEnneper_get_ptr(self.0) }
620    }
621}
622impl std::default::Default for vtkParametricEnneper {
623    fn default() -> Self {
624        Self::new()
625    }
626}
627impl Drop for vtkParametricEnneper {
628    fn drop(&mut self) {
629        unsafe extern "C" {
630            fn vtkParametricEnneper_destructor(sself: *mut core::ffi::c_void);
631        }
632        unsafe { vtkParametricEnneper_destructor(self.0) }
633        self.0 = core::ptr::null_mut();
634    }
635}
636#[test]
637fn test_vtkParametricEnneper_create_drop() {
638    let obj = vtkParametricEnneper::new();
639    let ptr = obj.0;
640    assert!(!ptr.is_null());
641    assert!(unsafe { !obj._get_ptr().is_null() });
642    drop(obj);
643    let new_obj = vtkParametricEnneper(ptr);
644    assert!(unsafe { new_obj._get_ptr().is_null() });
645}
646/// Generate a figure-8 Klein bottle.
647///
648///
649/// vtkParametricFigure8Klein generates a figure-8 Klein bottle.  A Klein bottle
650/// is a closed surface with no interior and only one surface.  It is
651/// unrealisable in 3 dimensions without intersecting surfaces.  It can be
652/// realised in 4 dimensions by considering the map \f$F:R^2 \rightarrow R^4\f$  given by:
653///
654/// - \f$f(u,v) = ((r*cos(v)+a)*cos(u),(r*cos(v)+a)*sin(u),r*sin(v)*cos(u/2),r*sin(v)*sin(u/2))\f$
655///
656/// This representation of the immersion in \f$R^3\f$ is formed by taking two Mobius
657/// strips and joining them along their boundaries, this is the so called
658/// "Figure-8 Klein Bottle"
659///
660/// For further information about this surface, please consult the
661/// technical description "Parametric surfaces" in http://www.vtk.org/publications
662/// in the "VTK Technical Documents" section in the VTk.org web pages.
663///
664/// @par Thanks:
665/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
666/// class.
667#[allow(non_camel_case_types)]
668pub struct vtkParametricFigure8Klein(*mut core::ffi::c_void);
669impl vtkParametricFigure8Klein {
670    /// Creates a new [vtkParametricFigure8Klein] wrapped inside `vtkNew`
671    #[doc(alias = "vtkParametricFigure8Klein")]
672    pub fn new() -> Self {
673        unsafe extern "C" {
674            fn vtkParametricFigure8Klein_new() -> *mut core::ffi::c_void;
675        }
676        Self(unsafe { &mut *vtkParametricFigure8Klein_new() })
677    }
678    #[cfg(test)]
679    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
680        unsafe extern "C" {
681            fn vtkParametricFigure8Klein_get_ptr(
682                sself: *mut core::ffi::c_void,
683            ) -> *mut core::ffi::c_void;
684        }
685        unsafe { vtkParametricFigure8Klein_get_ptr(self.0) }
686    }
687}
688impl std::default::Default for vtkParametricFigure8Klein {
689    fn default() -> Self {
690        Self::new()
691    }
692}
693impl Drop for vtkParametricFigure8Klein {
694    fn drop(&mut self) {
695        unsafe extern "C" {
696            fn vtkParametricFigure8Klein_destructor(sself: *mut core::ffi::c_void);
697        }
698        unsafe { vtkParametricFigure8Klein_destructor(self.0) }
699        self.0 = core::ptr::null_mut();
700    }
701}
702#[test]
703fn test_vtkParametricFigure8Klein_create_drop() {
704    let obj = vtkParametricFigure8Klein::new();
705    let ptr = obj.0;
706    assert!(!ptr.is_null());
707    assert!(unsafe { !obj._get_ptr().is_null() });
708    drop(obj);
709    let new_obj = vtkParametricFigure8Klein(ptr);
710    assert!(unsafe { new_obj._get_ptr().is_null() });
711}
712/// Generate Henneberg's minimal surface.
713///
714///
715/// vtkParametricHenneberg generates Henneberg's minimal surface parametrically.
716/// Henneberg's minimal surface is discussed further at
717/// <a href="http://mathworld.wolfram.com/HennebergsMinimalSurface.html">Math World</a>.
718/// @par Thanks:
719/// Tim Meehan
720#[allow(non_camel_case_types)]
721pub struct vtkParametricHenneberg(*mut core::ffi::c_void);
722impl vtkParametricHenneberg {
723    /// Creates a new [vtkParametricHenneberg] wrapped inside `vtkNew`
724    #[doc(alias = "vtkParametricHenneberg")]
725    pub fn new() -> Self {
726        unsafe extern "C" {
727            fn vtkParametricHenneberg_new() -> *mut core::ffi::c_void;
728        }
729        Self(unsafe { &mut *vtkParametricHenneberg_new() })
730    }
731    #[cfg(test)]
732    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
733        unsafe extern "C" {
734            fn vtkParametricHenneberg_get_ptr(
735                sself: *mut core::ffi::c_void,
736            ) -> *mut core::ffi::c_void;
737        }
738        unsafe { vtkParametricHenneberg_get_ptr(self.0) }
739    }
740}
741impl std::default::Default for vtkParametricHenneberg {
742    fn default() -> Self {
743        Self::new()
744    }
745}
746impl Drop for vtkParametricHenneberg {
747    fn drop(&mut self) {
748        unsafe extern "C" {
749            fn vtkParametricHenneberg_destructor(sself: *mut core::ffi::c_void);
750        }
751        unsafe { vtkParametricHenneberg_destructor(self.0) }
752        self.0 = core::ptr::null_mut();
753    }
754}
755#[test]
756fn test_vtkParametricHenneberg_create_drop() {
757    let obj = vtkParametricHenneberg::new();
758    let ptr = obj.0;
759    assert!(!ptr.is_null());
760    assert!(unsafe { !obj._get_ptr().is_null() });
761    drop(obj);
762    let new_obj = vtkParametricHenneberg(ptr);
763    assert!(unsafe { new_obj._get_ptr().is_null() });
764}
765/// Generates a "classical" representation of a Klein bottle.
766///
767///
768/// vtkParametricKlein generates a "classical" representation of a Klein
769/// bottle.  A Klein bottle is a closed surface with no interior and only one
770/// surface.  It is unrealisable in 3 dimensions without intersecting
771/// surfaces.  It can be
772/// realised in 4 dimensions by considering the map \f$F:R^2 \rightarrow R^4\f$  given by:
773///
774/// - \f$f(u,v) = ((r*cos(v)+a)*cos(u),(r*cos(v)+a)*sin(u),r*sin(v)*cos(u/2),r*sin(v)*sin(u/2))\f$
775///
776/// The classical representation of the immersion in \f$R^3\f$ is returned by this function.
777///
778///
779/// For further information about this surface, please consult the
780/// technical description "Parametric surfaces" in http://www.vtk.org/publications
781/// in the "VTK Technical Documents" section in the VTk.org web pages.
782///
783/// @par Thanks:
784/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
785/// class.
786#[allow(non_camel_case_types)]
787pub struct vtkParametricKlein(*mut core::ffi::c_void);
788impl vtkParametricKlein {
789    /// Creates a new [vtkParametricKlein] wrapped inside `vtkNew`
790    #[doc(alias = "vtkParametricKlein")]
791    pub fn new() -> Self {
792        unsafe extern "C" {
793            fn vtkParametricKlein_new() -> *mut core::ffi::c_void;
794        }
795        Self(unsafe { &mut *vtkParametricKlein_new() })
796    }
797    #[cfg(test)]
798    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
799        unsafe extern "C" {
800            fn vtkParametricKlein_get_ptr(
801                sself: *mut core::ffi::c_void,
802            ) -> *mut core::ffi::c_void;
803        }
804        unsafe { vtkParametricKlein_get_ptr(self.0) }
805    }
806}
807impl std::default::Default for vtkParametricKlein {
808    fn default() -> Self {
809        Self::new()
810    }
811}
812impl Drop for vtkParametricKlein {
813    fn drop(&mut self) {
814        unsafe extern "C" {
815            fn vtkParametricKlein_destructor(sself: *mut core::ffi::c_void);
816        }
817        unsafe { vtkParametricKlein_destructor(self.0) }
818        self.0 = core::ptr::null_mut();
819    }
820}
821#[test]
822fn test_vtkParametricKlein_create_drop() {
823    let obj = vtkParametricKlein::new();
824    let ptr = obj.0;
825    assert!(!ptr.is_null());
826    assert!(unsafe { !obj._get_ptr().is_null() });
827    drop(obj);
828    let new_obj = vtkParametricKlein(ptr);
829    assert!(unsafe { new_obj._get_ptr().is_null() });
830}
831/// Generate Kuens' surface.
832///
833///
834/// vtkParametricKuen generates Kuens' surface. This surface has a constant
835/// negative gaussian curvature. For more information about this surface, see
836/// Dr. O'Niell's page at the
837/// <a href="http://www.math.ucla.edu/~bon/kuen.html">UCLA Mathematics Department</a>.
838/// @par Thanks:
839/// Tim Meehan
840#[allow(non_camel_case_types)]
841pub struct vtkParametricKuen(*mut core::ffi::c_void);
842impl vtkParametricKuen {
843    /// Creates a new [vtkParametricKuen] wrapped inside `vtkNew`
844    #[doc(alias = "vtkParametricKuen")]
845    pub fn new() -> Self {
846        unsafe extern "C" {
847            fn vtkParametricKuen_new() -> *mut core::ffi::c_void;
848        }
849        Self(unsafe { &mut *vtkParametricKuen_new() })
850    }
851    #[cfg(test)]
852    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
853        unsafe extern "C" {
854            fn vtkParametricKuen_get_ptr(
855                sself: *mut core::ffi::c_void,
856            ) -> *mut core::ffi::c_void;
857        }
858        unsafe { vtkParametricKuen_get_ptr(self.0) }
859    }
860}
861impl std::default::Default for vtkParametricKuen {
862    fn default() -> Self {
863        Self::new()
864    }
865}
866impl Drop for vtkParametricKuen {
867    fn drop(&mut self) {
868        unsafe extern "C" {
869            fn vtkParametricKuen_destructor(sself: *mut core::ffi::c_void);
870        }
871        unsafe { vtkParametricKuen_destructor(self.0) }
872        self.0 = core::ptr::null_mut();
873    }
874}
875#[test]
876fn test_vtkParametricKuen_create_drop() {
877    let obj = vtkParametricKuen::new();
878    let ptr = obj.0;
879    assert!(!ptr.is_null());
880    assert!(unsafe { !obj._get_ptr().is_null() });
881    drop(obj);
882    let new_obj = vtkParametricKuen(ptr);
883    assert!(unsafe { new_obj._get_ptr().is_null() });
884}
885/// Generate a Mobius strip.
886///
887///
888/// vtkParametricMobius generates a Mobius strip.
889///
890/// For further information about this surface, please consult the
891/// technical description "Parametric surfaces" in http://www.vtk.org/publications
892/// in the "VTK Technical Documents" section in the VTk.org web pages.
893///
894/// @par Thanks:
895/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
896/// class.
897#[allow(non_camel_case_types)]
898pub struct vtkParametricMobius(*mut core::ffi::c_void);
899impl vtkParametricMobius {
900    /// Creates a new [vtkParametricMobius] wrapped inside `vtkNew`
901    #[doc(alias = "vtkParametricMobius")]
902    pub fn new() -> Self {
903        unsafe extern "C" {
904            fn vtkParametricMobius_new() -> *mut core::ffi::c_void;
905        }
906        Self(unsafe { &mut *vtkParametricMobius_new() })
907    }
908    #[cfg(test)]
909    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
910        unsafe extern "C" {
911            fn vtkParametricMobius_get_ptr(
912                sself: *mut core::ffi::c_void,
913            ) -> *mut core::ffi::c_void;
914        }
915        unsafe { vtkParametricMobius_get_ptr(self.0) }
916    }
917}
918impl std::default::Default for vtkParametricMobius {
919    fn default() -> Self {
920        Self::new()
921    }
922}
923impl Drop for vtkParametricMobius {
924    fn drop(&mut self) {
925        unsafe extern "C" {
926            fn vtkParametricMobius_destructor(sself: *mut core::ffi::c_void);
927        }
928        unsafe { vtkParametricMobius_destructor(self.0) }
929        self.0 = core::ptr::null_mut();
930    }
931}
932#[test]
933fn test_vtkParametricMobius_create_drop() {
934    let obj = vtkParametricMobius::new();
935    let ptr = obj.0;
936    assert!(!ptr.is_null());
937    assert!(unsafe { !obj._get_ptr().is_null() });
938    drop(obj);
939    let new_obj = vtkParametricMobius(ptr);
940    assert!(unsafe { new_obj._get_ptr().is_null() });
941}
942/// Generate Plucker's conoid surface.
943///
944///
945/// vtkParametricPluckerConoid generates Plucker's conoid surface parametrically.
946/// Plucker's conoid is a ruled surface, named after Julius Plucker. It is
947/// possible to set the number of folds in this class via the parameter 'N'.
948///
949/// For more information, see the Wikipedia page on
950/// <a href="https://en.wikipedia.org/wiki/Pl%c3%bccker%27s_conoid">Plucker's Conoid</a>.
951/// @warning
952/// I haven't done any special checking on the number of folds parameter, N.
953/// @par Thanks:
954/// Tim Meehan
955#[allow(non_camel_case_types)]
956pub struct vtkParametricPluckerConoid(*mut core::ffi::c_void);
957impl vtkParametricPluckerConoid {
958    /// Creates a new [vtkParametricPluckerConoid] wrapped inside `vtkNew`
959    #[doc(alias = "vtkParametricPluckerConoid")]
960    pub fn new() -> Self {
961        unsafe extern "C" {
962            fn vtkParametricPluckerConoid_new() -> *mut core::ffi::c_void;
963        }
964        Self(unsafe { &mut *vtkParametricPluckerConoid_new() })
965    }
966    #[cfg(test)]
967    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
968        unsafe extern "C" {
969            fn vtkParametricPluckerConoid_get_ptr(
970                sself: *mut core::ffi::c_void,
971            ) -> *mut core::ffi::c_void;
972        }
973        unsafe { vtkParametricPluckerConoid_get_ptr(self.0) }
974    }
975}
976impl std::default::Default for vtkParametricPluckerConoid {
977    fn default() -> Self {
978        Self::new()
979    }
980}
981impl Drop for vtkParametricPluckerConoid {
982    fn drop(&mut self) {
983        unsafe extern "C" {
984            fn vtkParametricPluckerConoid_destructor(sself: *mut core::ffi::c_void);
985        }
986        unsafe { vtkParametricPluckerConoid_destructor(self.0) }
987        self.0 = core::ptr::null_mut();
988    }
989}
990#[test]
991fn test_vtkParametricPluckerConoid_create_drop() {
992    let obj = vtkParametricPluckerConoid::new();
993    let ptr = obj.0;
994    assert!(!ptr.is_null());
995    assert!(unsafe { !obj._get_ptr().is_null() });
996    drop(obj);
997    let new_obj = vtkParametricPluckerConoid(ptr);
998    assert!(unsafe { new_obj._get_ptr().is_null() });
999}
1000/// Generate a pseudosphere.
1001///
1002///
1003/// vtkParametricPseudosphere generates a parametric pseudosphere. The
1004/// pseudosphere is generated as a surface of revolution of the tractrix about
1005/// it's asymptote, and is a surface of constant negative Gaussian curvature.
1006/// You can find out more about this interesting surface at
1007/// <a href="http://mathworld.wolfram.com/Pseudosphere.html">Math World</a>.
1008/// @par Thanks:
1009/// Tim Meehan
1010#[allow(non_camel_case_types)]
1011pub struct vtkParametricPseudosphere(*mut core::ffi::c_void);
1012impl vtkParametricPseudosphere {
1013    /// Creates a new [vtkParametricPseudosphere] wrapped inside `vtkNew`
1014    #[doc(alias = "vtkParametricPseudosphere")]
1015    pub fn new() -> Self {
1016        unsafe extern "C" {
1017            fn vtkParametricPseudosphere_new() -> *mut core::ffi::c_void;
1018        }
1019        Self(unsafe { &mut *vtkParametricPseudosphere_new() })
1020    }
1021    #[cfg(test)]
1022    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
1023        unsafe extern "C" {
1024            fn vtkParametricPseudosphere_get_ptr(
1025                sself: *mut core::ffi::c_void,
1026            ) -> *mut core::ffi::c_void;
1027        }
1028        unsafe { vtkParametricPseudosphere_get_ptr(self.0) }
1029    }
1030}
1031impl std::default::Default for vtkParametricPseudosphere {
1032    fn default() -> Self {
1033        Self::new()
1034    }
1035}
1036impl Drop for vtkParametricPseudosphere {
1037    fn drop(&mut self) {
1038        unsafe extern "C" {
1039            fn vtkParametricPseudosphere_destructor(sself: *mut core::ffi::c_void);
1040        }
1041        unsafe { vtkParametricPseudosphere_destructor(self.0) }
1042        self.0 = core::ptr::null_mut();
1043    }
1044}
1045#[test]
1046fn test_vtkParametricPseudosphere_create_drop() {
1047    let obj = vtkParametricPseudosphere::new();
1048    let ptr = obj.0;
1049    assert!(!ptr.is_null());
1050    assert!(unsafe { !obj._get_ptr().is_null() });
1051    drop(obj);
1052    let new_obj = vtkParametricPseudosphere(ptr);
1053    assert!(unsafe { new_obj._get_ptr().is_null() });
1054}
1055/// Generate a surface covered with randomly placed hills.
1056///
1057///
1058/// vtkParametricRandomHills generates a surface covered with randomly placed
1059/// hills. Hills will vary in shape and height since the presence
1060/// of nearby hills will contribute to the shape and height of a given hill.
1061/// An option is provided for placing hills on a regular grid on the surface.
1062/// In this case the hills will all have the same shape and height.
1063///
1064/// For further information about this surface, please consult the
1065/// technical description "Parametric surfaces" in http://www.vtk.org/publications
1066/// in the "VTK Technical Documents" section in the VTk.org web pages.
1067///
1068/// @par Thanks:
1069/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
1070/// class.
1071#[allow(non_camel_case_types)]
1072pub struct vtkParametricRandomHills(*mut core::ffi::c_void);
1073impl vtkParametricRandomHills {
1074    /// Creates a new [vtkParametricRandomHills] wrapped inside `vtkNew`
1075    #[doc(alias = "vtkParametricRandomHills")]
1076    pub fn new() -> Self {
1077        unsafe extern "C" {
1078            fn vtkParametricRandomHills_new() -> *mut core::ffi::c_void;
1079        }
1080        Self(unsafe { &mut *vtkParametricRandomHills_new() })
1081    }
1082    #[cfg(test)]
1083    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
1084        unsafe extern "C" {
1085            fn vtkParametricRandomHills_get_ptr(
1086                sself: *mut core::ffi::c_void,
1087            ) -> *mut core::ffi::c_void;
1088        }
1089        unsafe { vtkParametricRandomHills_get_ptr(self.0) }
1090    }
1091}
1092impl std::default::Default for vtkParametricRandomHills {
1093    fn default() -> Self {
1094        Self::new()
1095    }
1096}
1097impl Drop for vtkParametricRandomHills {
1098    fn drop(&mut self) {
1099        unsafe extern "C" {
1100            fn vtkParametricRandomHills_destructor(sself: *mut core::ffi::c_void);
1101        }
1102        unsafe { vtkParametricRandomHills_destructor(self.0) }
1103        self.0 = core::ptr::null_mut();
1104    }
1105}
1106#[test]
1107fn test_vtkParametricRandomHills_create_drop() {
1108    let obj = vtkParametricRandomHills::new();
1109    let ptr = obj.0;
1110    assert!(!ptr.is_null());
1111    assert!(unsafe { !obj._get_ptr().is_null() });
1112    drop(obj);
1113    let new_obj = vtkParametricRandomHills(ptr);
1114    assert!(unsafe { new_obj._get_ptr().is_null() });
1115}
1116/// Generate Steiner's Roman Surface.
1117///
1118///
1119/// vtkParametricRoman generates Steiner's Roman Surface.
1120///
1121/// For further information about this surface, please consult the
1122/// technical description "Parametric surfaces" in http://www.vtk.org/publications
1123/// in the "VTK Technical Documents" section in the VTk.org web pages.
1124///
1125/// @par Thanks:
1126/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
1127/// class.
1128#[allow(non_camel_case_types)]
1129pub struct vtkParametricRoman(*mut core::ffi::c_void);
1130impl vtkParametricRoman {
1131    /// Creates a new [vtkParametricRoman] wrapped inside `vtkNew`
1132    #[doc(alias = "vtkParametricRoman")]
1133    pub fn new() -> Self {
1134        unsafe extern "C" {
1135            fn vtkParametricRoman_new() -> *mut core::ffi::c_void;
1136        }
1137        Self(unsafe { &mut *vtkParametricRoman_new() })
1138    }
1139    #[cfg(test)]
1140    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
1141        unsafe extern "C" {
1142            fn vtkParametricRoman_get_ptr(
1143                sself: *mut core::ffi::c_void,
1144            ) -> *mut core::ffi::c_void;
1145        }
1146        unsafe { vtkParametricRoman_get_ptr(self.0) }
1147    }
1148}
1149impl std::default::Default for vtkParametricRoman {
1150    fn default() -> Self {
1151        Self::new()
1152    }
1153}
1154impl Drop for vtkParametricRoman {
1155    fn drop(&mut self) {
1156        unsafe extern "C" {
1157            fn vtkParametricRoman_destructor(sself: *mut core::ffi::c_void);
1158        }
1159        unsafe { vtkParametricRoman_destructor(self.0) }
1160        self.0 = core::ptr::null_mut();
1161    }
1162}
1163#[test]
1164fn test_vtkParametricRoman_create_drop() {
1165    let obj = vtkParametricRoman::new();
1166    let ptr = obj.0;
1167    assert!(!ptr.is_null());
1168    assert!(unsafe { !obj._get_ptr().is_null() });
1169    drop(obj);
1170    let new_obj = vtkParametricRoman(ptr);
1171    assert!(unsafe { new_obj._get_ptr().is_null() });
1172}
1173/// parametric function for 1D interpolating splines
1174///
1175///
1176/// vtkParametricSpline is a parametric function for 1D interpolating splines.
1177/// vtkParametricSpline maps the single parameter u into a 3D point (x,y,z)
1178/// using three instances of interpolating splines.  This family of 1D splines
1179/// is guaranteed to be parameterized in the interval [0,1].  Attempting to
1180/// evaluate outside this interval will cause the parameter u to be clamped in
1181/// the range [0,1].
1182///
1183/// When constructed, this class creates instances of vtkCardinalSpline for
1184/// each of the x-y-z coordinates. The user may choose to replace these with
1185/// their own instances of subclasses of vtkSpline.
1186///
1187/// @warning
1188/// If you wish to tessellate the spline, use the class
1189/// vtkParametricFunctionSource.
1190///
1191/// @sa
1192/// vtkSpline vtkKochanekSpline vtkCardinalSpline
1193#[allow(non_camel_case_types)]
1194pub struct vtkParametricSpline(*mut core::ffi::c_void);
1195impl vtkParametricSpline {
1196    /// Creates a new [vtkParametricSpline] wrapped inside `vtkNew`
1197    #[doc(alias = "vtkParametricSpline")]
1198    pub fn new() -> Self {
1199        unsafe extern "C" {
1200            fn vtkParametricSpline_new() -> *mut core::ffi::c_void;
1201        }
1202        Self(unsafe { &mut *vtkParametricSpline_new() })
1203    }
1204    #[cfg(test)]
1205    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
1206        unsafe extern "C" {
1207            fn vtkParametricSpline_get_ptr(
1208                sself: *mut core::ffi::c_void,
1209            ) -> *mut core::ffi::c_void;
1210        }
1211        unsafe { vtkParametricSpline_get_ptr(self.0) }
1212    }
1213}
1214impl std::default::Default for vtkParametricSpline {
1215    fn default() -> Self {
1216        Self::new()
1217    }
1218}
1219impl Drop for vtkParametricSpline {
1220    fn drop(&mut self) {
1221        unsafe extern "C" {
1222            fn vtkParametricSpline_destructor(sself: *mut core::ffi::c_void);
1223        }
1224        unsafe { vtkParametricSpline_destructor(self.0) }
1225        self.0 = core::ptr::null_mut();
1226    }
1227}
1228#[test]
1229fn test_vtkParametricSpline_create_drop() {
1230    let obj = vtkParametricSpline::new();
1231    let ptr = obj.0;
1232    assert!(!ptr.is_null());
1233    assert!(unsafe { !obj._get_ptr().is_null() });
1234    drop(obj);
1235    let new_obj = vtkParametricSpline(ptr);
1236    assert!(unsafe { new_obj._get_ptr().is_null() });
1237}
1238/// Generate a superellipsoid.
1239///
1240///
1241/// vtkParametricSuperEllipsoid generates a superellipsoid.  A superellipsoid
1242/// is a versatile primitive that is controlled by two parameters n1 and
1243/// n2. As special cases it can represent a sphere, square box, and closed
1244/// cylindrical can.
1245///
1246/// For further information about this surface, please consult the
1247/// technical description "Parametric surfaces" in http://www.vtk.org/publications
1248/// in the "VTK Technical Documents" section in the VTk.org web pages.
1249///
1250/// Also see: http://paulbourke.net/geometry/superellipse/
1251///
1252/// @warning
1253/// Care needs to be taken specifying the bounds correctly. You may need to
1254/// carefully adjust MinimumU, MinimumV, MaximumU, MaximumV.
1255///
1256/// @par Thanks:
1257/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
1258/// class.
1259#[allow(non_camel_case_types)]
1260pub struct vtkParametricSuperEllipsoid(*mut core::ffi::c_void);
1261impl vtkParametricSuperEllipsoid {
1262    /// Creates a new [vtkParametricSuperEllipsoid] wrapped inside `vtkNew`
1263    #[doc(alias = "vtkParametricSuperEllipsoid")]
1264    pub fn new() -> Self {
1265        unsafe extern "C" {
1266            fn vtkParametricSuperEllipsoid_new() -> *mut core::ffi::c_void;
1267        }
1268        Self(unsafe { &mut *vtkParametricSuperEllipsoid_new() })
1269    }
1270    #[cfg(test)]
1271    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
1272        unsafe extern "C" {
1273            fn vtkParametricSuperEllipsoid_get_ptr(
1274                sself: *mut core::ffi::c_void,
1275            ) -> *mut core::ffi::c_void;
1276        }
1277        unsafe { vtkParametricSuperEllipsoid_get_ptr(self.0) }
1278    }
1279}
1280impl std::default::Default for vtkParametricSuperEllipsoid {
1281    fn default() -> Self {
1282        Self::new()
1283    }
1284}
1285impl Drop for vtkParametricSuperEllipsoid {
1286    fn drop(&mut self) {
1287        unsafe extern "C" {
1288            fn vtkParametricSuperEllipsoid_destructor(sself: *mut core::ffi::c_void);
1289        }
1290        unsafe { vtkParametricSuperEllipsoid_destructor(self.0) }
1291        self.0 = core::ptr::null_mut();
1292    }
1293}
1294#[test]
1295fn test_vtkParametricSuperEllipsoid_create_drop() {
1296    let obj = vtkParametricSuperEllipsoid::new();
1297    let ptr = obj.0;
1298    assert!(!ptr.is_null());
1299    assert!(unsafe { !obj._get_ptr().is_null() });
1300    drop(obj);
1301    let new_obj = vtkParametricSuperEllipsoid(ptr);
1302    assert!(unsafe { new_obj._get_ptr().is_null() });
1303}
1304/// Generate a supertoroid.
1305///
1306///
1307/// vtkParametricSuperToroid generates a supertoroid.  Essentially a
1308/// supertoroid is a torus with the sine and cosine terms raised to a power.
1309/// A supertoroid is a versatile primitive that is controlled by four
1310/// parameters r0, r1, n1 and n2. r0, r1 determine the type of torus whilst
1311/// the value of n1 determines the shape of the torus ring and n2 determines
1312/// the shape of the cross section of the ring. It is the different values of
1313/// these powers which give rise to a family of 3D shapes that are all
1314/// basically toroidal in shape.
1315///
1316/// For further information about this surface, please consult the
1317/// technical description "Parametric surfaces" in http://www.vtk.org/publications
1318/// in the "VTK Technical Documents" section in the VTk.org web pages.
1319///
1320/// Also see: http://paulbourke.net/geometry/torus/#super.
1321///
1322/// @warning
1323/// Care needs to be taken specifying the bounds correctly. You may need to
1324/// carefully adjust MinimumU, MinimumV, MaximumU, MaximumV.
1325///
1326/// @par Thanks:
1327/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
1328/// class.
1329#[allow(non_camel_case_types)]
1330pub struct vtkParametricSuperToroid(*mut core::ffi::c_void);
1331impl vtkParametricSuperToroid {
1332    /// Creates a new [vtkParametricSuperToroid] wrapped inside `vtkNew`
1333    #[doc(alias = "vtkParametricSuperToroid")]
1334    pub fn new() -> Self {
1335        unsafe extern "C" {
1336            fn vtkParametricSuperToroid_new() -> *mut core::ffi::c_void;
1337        }
1338        Self(unsafe { &mut *vtkParametricSuperToroid_new() })
1339    }
1340    #[cfg(test)]
1341    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
1342        unsafe extern "C" {
1343            fn vtkParametricSuperToroid_get_ptr(
1344                sself: *mut core::ffi::c_void,
1345            ) -> *mut core::ffi::c_void;
1346        }
1347        unsafe { vtkParametricSuperToroid_get_ptr(self.0) }
1348    }
1349}
1350impl std::default::Default for vtkParametricSuperToroid {
1351    fn default() -> Self {
1352        Self::new()
1353    }
1354}
1355impl Drop for vtkParametricSuperToroid {
1356    fn drop(&mut self) {
1357        unsafe extern "C" {
1358            fn vtkParametricSuperToroid_destructor(sself: *mut core::ffi::c_void);
1359        }
1360        unsafe { vtkParametricSuperToroid_destructor(self.0) }
1361        self.0 = core::ptr::null_mut();
1362    }
1363}
1364#[test]
1365fn test_vtkParametricSuperToroid_create_drop() {
1366    let obj = vtkParametricSuperToroid::new();
1367    let ptr = obj.0;
1368    assert!(!ptr.is_null());
1369    assert!(unsafe { !obj._get_ptr().is_null() });
1370    drop(obj);
1371    let new_obj = vtkParametricSuperToroid(ptr);
1372    assert!(unsafe { new_obj._get_ptr().is_null() });
1373}
1374/// Generate a torus.
1375///
1376///
1377/// vtkParametricTorus generates a torus.
1378///
1379/// For further information about this surface, please consult the
1380/// technical description "Parametric surfaces" in http://www.vtk.org/publications
1381/// in the "VTK Technical Documents" section in the VTk.org web pages.
1382///
1383/// @par Thanks:
1384/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing the
1385/// class.
1386#[allow(non_camel_case_types)]
1387pub struct vtkParametricTorus(*mut core::ffi::c_void);
1388impl vtkParametricTorus {
1389    /// Creates a new [vtkParametricTorus] wrapped inside `vtkNew`
1390    #[doc(alias = "vtkParametricTorus")]
1391    pub fn new() -> Self {
1392        unsafe extern "C" {
1393            fn vtkParametricTorus_new() -> *mut core::ffi::c_void;
1394        }
1395        Self(unsafe { &mut *vtkParametricTorus_new() })
1396    }
1397    #[cfg(test)]
1398    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
1399        unsafe extern "C" {
1400            fn vtkParametricTorus_get_ptr(
1401                sself: *mut core::ffi::c_void,
1402            ) -> *mut core::ffi::c_void;
1403        }
1404        unsafe { vtkParametricTorus_get_ptr(self.0) }
1405    }
1406}
1407impl std::default::Default for vtkParametricTorus {
1408    fn default() -> Self {
1409        Self::new()
1410    }
1411}
1412impl Drop for vtkParametricTorus {
1413    fn drop(&mut self) {
1414        unsafe extern "C" {
1415            fn vtkParametricTorus_destructor(sself: *mut core::ffi::c_void);
1416        }
1417        unsafe { vtkParametricTorus_destructor(self.0) }
1418        self.0 = core::ptr::null_mut();
1419    }
1420}
1421#[test]
1422fn test_vtkParametricTorus_create_drop() {
1423    let obj = vtkParametricTorus::new();
1424    let ptr = obj.0;
1425    assert!(!ptr.is_null());
1426    assert!(unsafe { !obj._get_ptr().is_null() });
1427    drop(obj);
1428    let new_obj = vtkParametricTorus(ptr);
1429    assert!(unsafe { new_obj._get_ptr().is_null() });
1430}
vtk_rs/vtkCommonComputationalGeometry.rs

vtk_rs/
vtkCommonComputationalGeometry.rs
