vtk_rs/
vtkCommonTransforms.rs

1/// cylindrical to rectangular coords and back
2///
3///
4/// vtkCylindricalTransform will convert (r,theta,z) coordinates to
5/// (x,y,z) coordinates and back again.  The angles are given in radians.
6/// By default, it converts cylindrical coordinates to rectangular, but
7/// GetInverse() returns a transform that will do the opposite.  The
8/// equation that is used is x = r*cos(theta), y = r*sin(theta), z = z.
9/// @warning
10/// This transform is not well behaved along the line x=y=0 (i.e. along
11/// the z-axis)
12/// @sa
13/// vtkSphericalTransform vtkGeneralTransform
14#[allow(non_camel_case_types)]
15pub struct vtkCylindricalTransform(*mut core::ffi::c_void);
16impl vtkCylindricalTransform {
17    /// Creates a new [vtkCylindricalTransform] wrapped inside `vtkNew`
18    #[doc(alias = "vtkCylindricalTransform")]
19    pub fn new() -> Self {
20        unsafe extern "C" {
21            fn vtkCylindricalTransform_new() -> *mut core::ffi::c_void;
22        }
23        Self(unsafe { &mut *vtkCylindricalTransform_new() })
24    }
25    #[cfg(test)]
26    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
27        unsafe extern "C" {
28            fn vtkCylindricalTransform_get_ptr(
29                sself: *mut core::ffi::c_void,
30            ) -> *mut core::ffi::c_void;
31        }
32        unsafe { vtkCylindricalTransform_get_ptr(self.0) }
33    }
34}
35impl std::default::Default for vtkCylindricalTransform {
36    fn default() -> Self {
37        Self::new()
38    }
39}
40impl Drop for vtkCylindricalTransform {
41    fn drop(&mut self) {
42        unsafe extern "C" {
43            fn vtkCylindricalTransform_destructor(sself: *mut core::ffi::c_void);
44        }
45        unsafe { vtkCylindricalTransform_destructor(self.0) }
46        self.0 = core::ptr::null_mut();
47    }
48}
49#[test]
50fn test_vtkCylindricalTransform_create_drop() {
51    let obj = vtkCylindricalTransform::new();
52    let ptr = obj.0;
53    assert!(!ptr.is_null());
54    assert!(unsafe { !obj._get_ptr().is_null() });
55    drop(obj);
56    let new_obj = vtkCylindricalTransform(ptr);
57    assert!(unsafe { new_obj._get_ptr().is_null() });
58}
59/// allows operations on any transforms
60///
61///
62/// vtkGeneralTransform is like vtkTransform and vtkPerspectiveTransform,
63/// but it will work with any vtkAbstractTransform as input.  It is
64/// not as efficient as the other two, however, because arbitrary
65/// transformations cannot be concatenated by matrix multiplication.
66/// Transform concatenation is simulated by passing each input point
67/// through each transform in turn.
68/// @sa
69/// vtkTransform vtkPerspectiveTransform
70#[allow(non_camel_case_types)]
71pub struct vtkGeneralTransform(*mut core::ffi::c_void);
72impl vtkGeneralTransform {
73    /// Creates a new [vtkGeneralTransform] wrapped inside `vtkNew`
74    #[doc(alias = "vtkGeneralTransform")]
75    pub fn new() -> Self {
76        unsafe extern "C" {
77            fn vtkGeneralTransform_new() -> *mut core::ffi::c_void;
78        }
79        Self(unsafe { &mut *vtkGeneralTransform_new() })
80    }
81    #[cfg(test)]
82    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
83        unsafe extern "C" {
84            fn vtkGeneralTransform_get_ptr(
85                sself: *mut core::ffi::c_void,
86            ) -> *mut core::ffi::c_void;
87        }
88        unsafe { vtkGeneralTransform_get_ptr(self.0) }
89    }
90}
91impl std::default::Default for vtkGeneralTransform {
92    fn default() -> Self {
93        Self::new()
94    }
95}
96impl Drop for vtkGeneralTransform {
97    fn drop(&mut self) {
98        unsafe extern "C" {
99            fn vtkGeneralTransform_destructor(sself: *mut core::ffi::c_void);
100        }
101        unsafe { vtkGeneralTransform_destructor(self.0) }
102        self.0 = core::ptr::null_mut();
103    }
104}
105#[test]
106fn test_vtkGeneralTransform_create_drop() {
107    let obj = vtkGeneralTransform::new();
108    let ptr = obj.0;
109    assert!(!ptr.is_null());
110    assert!(unsafe { !obj._get_ptr().is_null() });
111    drop(obj);
112    let new_obj = vtkGeneralTransform(ptr);
113    assert!(unsafe { new_obj._get_ptr().is_null() });
114}
115/// a transform that doesn't do anything
116///
117///
118/// vtkIdentityTransform is a transformation which will simply pass coordinate
119/// data unchanged.  All other transform types can also do this, however,
120/// the vtkIdentityTransform does so with much greater efficiency.
121/// @sa
122/// vtkLinearTransform
123#[allow(non_camel_case_types)]
124pub struct vtkIdentityTransform(*mut core::ffi::c_void);
125impl vtkIdentityTransform {
126    /// Creates a new [vtkIdentityTransform] wrapped inside `vtkNew`
127    #[doc(alias = "vtkIdentityTransform")]
128    pub fn new() -> Self {
129        unsafe extern "C" {
130            fn vtkIdentityTransform_new() -> *mut core::ffi::c_void;
131        }
132        Self(unsafe { &mut *vtkIdentityTransform_new() })
133    }
134    #[cfg(test)]
135    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
136        unsafe extern "C" {
137            fn vtkIdentityTransform_get_ptr(
138                sself: *mut core::ffi::c_void,
139            ) -> *mut core::ffi::c_void;
140        }
141        unsafe { vtkIdentityTransform_get_ptr(self.0) }
142    }
143}
144impl std::default::Default for vtkIdentityTransform {
145    fn default() -> Self {
146        Self::new()
147    }
148}
149impl Drop for vtkIdentityTransform {
150    fn drop(&mut self) {
151        unsafe extern "C" {
152            fn vtkIdentityTransform_destructor(sself: *mut core::ffi::c_void);
153        }
154        unsafe { vtkIdentityTransform_destructor(self.0) }
155        self.0 = core::ptr::null_mut();
156    }
157}
158#[test]
159fn test_vtkIdentityTransform_create_drop() {
160    let obj = vtkIdentityTransform::new();
161    let ptr = obj.0;
162    assert!(!ptr.is_null());
163    assert!(unsafe { !obj._get_ptr().is_null() });
164    drop(obj);
165    let new_obj = vtkIdentityTransform(ptr);
166    assert!(unsafe { new_obj._get_ptr().is_null() });
167}
168/// a linear transform specified by two corresponding point sets
169///
170///
171/// A vtkLandmarkTransform is defined by two sets of landmarks, the
172/// transform computed gives the best fit mapping one onto the other, in a
173/// least squares sense. The indices are taken to correspond, so point 1
174/// in the first set will get mapped close to point 1 in the second set,
175/// etc. Call SetSourceLandmarks and SetTargetLandmarks to specify the two
176/// sets of landmarks, ensure they have the same number of points.
177/// @warning
178/// Whenever you add, subtract, or set points you must call Modified()
179/// on the vtkPoints object, or the transformation might not update.
180/// @sa
181/// vtkLinearTransform
182#[allow(non_camel_case_types)]
183pub struct vtkLandmarkTransform(*mut core::ffi::c_void);
184impl vtkLandmarkTransform {
185    /// Creates a new [vtkLandmarkTransform] wrapped inside `vtkNew`
186    #[doc(alias = "vtkLandmarkTransform")]
187    pub fn new() -> Self {
188        unsafe extern "C" {
189            fn vtkLandmarkTransform_new() -> *mut core::ffi::c_void;
190        }
191        Self(unsafe { &mut *vtkLandmarkTransform_new() })
192    }
193    #[cfg(test)]
194    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
195        unsafe extern "C" {
196            fn vtkLandmarkTransform_get_ptr(
197                sself: *mut core::ffi::c_void,
198            ) -> *mut core::ffi::c_void;
199        }
200        unsafe { vtkLandmarkTransform_get_ptr(self.0) }
201    }
202}
203impl std::default::Default for vtkLandmarkTransform {
204    fn default() -> Self {
205        Self::new()
206    }
207}
208impl Drop for vtkLandmarkTransform {
209    fn drop(&mut self) {
210        unsafe extern "C" {
211            fn vtkLandmarkTransform_destructor(sself: *mut core::ffi::c_void);
212        }
213        unsafe { vtkLandmarkTransform_destructor(self.0) }
214        self.0 = core::ptr::null_mut();
215    }
216}
217#[test]
218fn test_vtkLandmarkTransform_create_drop() {
219    let obj = vtkLandmarkTransform::new();
220    let ptr = obj.0;
221    assert!(!ptr.is_null());
222    assert!(unsafe { !obj._get_ptr().is_null() });
223    drop(obj);
224    let new_obj = vtkLandmarkTransform(ptr);
225    assert!(unsafe { new_obj._get_ptr().is_null() });
226}
227/// convert a matrix to a transform
228///
229///
230/// This is a very simple class which allows a vtkMatrix4x4 to be used in
231/// place of a vtkHomogeneousTransform or vtkAbstractTransform.  For example,
232/// if you use it as a proxy between a matrix and vtkTransformPolyDataFilter
233/// then any modifications to the matrix will automatically be reflected in
234/// the output of the filter.
235/// @sa
236/// vtkPerspectiveTransform vtkMatrix4x4 vtkMatrixToLinearTransform
237#[allow(non_camel_case_types)]
238pub struct vtkMatrixToHomogeneousTransform(*mut core::ffi::c_void);
239impl vtkMatrixToHomogeneousTransform {
240    /// Creates a new [vtkMatrixToHomogeneousTransform] wrapped inside `vtkNew`
241    #[doc(alias = "vtkMatrixToHomogeneousTransform")]
242    pub fn new() -> Self {
243        unsafe extern "C" {
244            fn vtkMatrixToHomogeneousTransform_new() -> *mut core::ffi::c_void;
245        }
246        Self(unsafe { &mut *vtkMatrixToHomogeneousTransform_new() })
247    }
248    #[cfg(test)]
249    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
250        unsafe extern "C" {
251            fn vtkMatrixToHomogeneousTransform_get_ptr(
252                sself: *mut core::ffi::c_void,
253            ) -> *mut core::ffi::c_void;
254        }
255        unsafe { vtkMatrixToHomogeneousTransform_get_ptr(self.0) }
256    }
257}
258impl std::default::Default for vtkMatrixToHomogeneousTransform {
259    fn default() -> Self {
260        Self::new()
261    }
262}
263impl Drop for vtkMatrixToHomogeneousTransform {
264    fn drop(&mut self) {
265        unsafe extern "C" {
266            fn vtkMatrixToHomogeneousTransform_destructor(sself: *mut core::ffi::c_void);
267        }
268        unsafe { vtkMatrixToHomogeneousTransform_destructor(self.0) }
269        self.0 = core::ptr::null_mut();
270    }
271}
272#[test]
273fn test_vtkMatrixToHomogeneousTransform_create_drop() {
274    let obj = vtkMatrixToHomogeneousTransform::new();
275    let ptr = obj.0;
276    assert!(!ptr.is_null());
277    assert!(unsafe { !obj._get_ptr().is_null() });
278    drop(obj);
279    let new_obj = vtkMatrixToHomogeneousTransform(ptr);
280    assert!(unsafe { new_obj._get_ptr().is_null() });
281}
282/// convert a matrix to a transform
283///
284///
285/// This is a very simple class which allows a vtkMatrix4x4 to be used in
286/// place of a vtkLinearTransform or vtkAbstractTransform.  For example,
287/// if you use it as a proxy between a matrix and vtkTransformPolyDataFilter
288/// then any modifications to the matrix will automatically be reflected in
289/// the output of the filter.
290/// @sa
291/// vtkTransform vtkMatrix4x4 vtkMatrixToHomogeneousTransform
292#[allow(non_camel_case_types)]
293pub struct vtkMatrixToLinearTransform(*mut core::ffi::c_void);
294impl vtkMatrixToLinearTransform {
295    /// Creates a new [vtkMatrixToLinearTransform] wrapped inside `vtkNew`
296    #[doc(alias = "vtkMatrixToLinearTransform")]
297    pub fn new() -> Self {
298        unsafe extern "C" {
299            fn vtkMatrixToLinearTransform_new() -> *mut core::ffi::c_void;
300        }
301        Self(unsafe { &mut *vtkMatrixToLinearTransform_new() })
302    }
303    #[cfg(test)]
304    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
305        unsafe extern "C" {
306            fn vtkMatrixToLinearTransform_get_ptr(
307                sself: *mut core::ffi::c_void,
308            ) -> *mut core::ffi::c_void;
309        }
310        unsafe { vtkMatrixToLinearTransform_get_ptr(self.0) }
311    }
312}
313impl std::default::Default for vtkMatrixToLinearTransform {
314    fn default() -> Self {
315        Self::new()
316    }
317}
318impl Drop for vtkMatrixToLinearTransform {
319    fn drop(&mut self) {
320        unsafe extern "C" {
321            fn vtkMatrixToLinearTransform_destructor(sself: *mut core::ffi::c_void);
322        }
323        unsafe { vtkMatrixToLinearTransform_destructor(self.0) }
324        self.0 = core::ptr::null_mut();
325    }
326}
327#[test]
328fn test_vtkMatrixToLinearTransform_create_drop() {
329    let obj = vtkMatrixToLinearTransform::new();
330    let ptr = obj.0;
331    assert!(!ptr.is_null());
332    assert!(unsafe { !obj._get_ptr().is_null() });
333    drop(obj);
334    let new_obj = vtkMatrixToLinearTransform(ptr);
335    assert!(unsafe { new_obj._get_ptr().is_null() });
336}
337/// describes a 4x4 matrix transformation
338///
339///
340/// A vtkPerspectiveTransform can be used to describe the full range of
341/// homogeneous transformations.  It was designed in particular
342/// to describe a camera-view of a scene.
343/// <P>The order in which you set up the display coordinates (via
344/// AdjustZBuffer() and AdjustViewport()), the projection (via Perspective(),
345/// Frustum(), or Ortho()) and the camera view (via SetupCamera()) are
346/// important.  If the transform is in PreMultiply mode, which is the
347/// default, set the Viewport and ZBuffer first, then the projection, and
348/// finally the camera view.  Once the view is set up, the Translate
349/// and Rotate methods can be used to move the camera around in world
350/// coordinates.  If the Oblique() or Stereo() methods are used, they
351/// should be called just before SetupCamera().
352/// <P>In PostMultiply mode, you must perform all transformations
353/// in the opposite order.  This is necessary, for example, if you
354/// already have a perspective transformation set up but must adjust
355/// the viewport.  Another example is if you have a view transformation,
356/// and wish to perform translations and rotations in the camera's
357/// coordinate system rather than in world coordinates.
358/// <P>The SetInput and Concatenate methods can be used to create
359/// a transformation pipeline with vtkPerspectiveTransform.  See vtkTransform
360/// for more information on the transformation pipeline.
361/// @sa
362/// vtkGeneralTransform vtkTransform vtkMatrix4x4 vtkCamera
363#[allow(non_camel_case_types)]
364pub struct vtkPerspectiveTransform(*mut core::ffi::c_void);
365impl vtkPerspectiveTransform {
366    /// Creates a new [vtkPerspectiveTransform] wrapped inside `vtkNew`
367    #[doc(alias = "vtkPerspectiveTransform")]
368    pub fn new() -> Self {
369        unsafe extern "C" {
370            fn vtkPerspectiveTransform_new() -> *mut core::ffi::c_void;
371        }
372        Self(unsafe { &mut *vtkPerspectiveTransform_new() })
373    }
374    #[cfg(test)]
375    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
376        unsafe extern "C" {
377            fn vtkPerspectiveTransform_get_ptr(
378                sself: *mut core::ffi::c_void,
379            ) -> *mut core::ffi::c_void;
380        }
381        unsafe { vtkPerspectiveTransform_get_ptr(self.0) }
382    }
383}
384impl std::default::Default for vtkPerspectiveTransform {
385    fn default() -> Self {
386        Self::new()
387    }
388}
389impl Drop for vtkPerspectiveTransform {
390    fn drop(&mut self) {
391        unsafe extern "C" {
392            fn vtkPerspectiveTransform_destructor(sself: *mut core::ffi::c_void);
393        }
394        unsafe { vtkPerspectiveTransform_destructor(self.0) }
395        self.0 = core::ptr::null_mut();
396    }
397}
398#[test]
399fn test_vtkPerspectiveTransform_create_drop() {
400    let obj = vtkPerspectiveTransform::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 = vtkPerspectiveTransform(ptr);
406    assert!(unsafe { new_obj._get_ptr().is_null() });
407}
408/// spherical to rectangular coords and back
409///
410///
411/// vtkSphericalTransform will convert (r,phi,theta) coordinates to
412/// (x,y,z) coordinates and back again.  The angles are given in radians.
413/// By default, it converts spherical coordinates to rectangular, but
414/// GetInverse() returns a transform that will do the opposite.  The equation
415/// that is used is x = r*sin(phi)*cos(theta), y = r*sin(phi)*sin(theta),
416/// z = r*cos(phi).
417/// @warning
418/// This transform is not well behaved along the line x=y=0 (i.e. along
419/// the z-axis)
420/// @sa
421/// vtkCylindricalTransform vtkGeneralTransform
422#[allow(non_camel_case_types)]
423pub struct vtkSphericalTransform(*mut core::ffi::c_void);
424impl vtkSphericalTransform {
425    /// Creates a new [vtkSphericalTransform] wrapped inside `vtkNew`
426    #[doc(alias = "vtkSphericalTransform")]
427    pub fn new() -> Self {
428        unsafe extern "C" {
429            fn vtkSphericalTransform_new() -> *mut core::ffi::c_void;
430        }
431        Self(unsafe { &mut *vtkSphericalTransform_new() })
432    }
433    #[cfg(test)]
434    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
435        unsafe extern "C" {
436            fn vtkSphericalTransform_get_ptr(
437                sself: *mut core::ffi::c_void,
438            ) -> *mut core::ffi::c_void;
439        }
440        unsafe { vtkSphericalTransform_get_ptr(self.0) }
441    }
442}
443impl std::default::Default for vtkSphericalTransform {
444    fn default() -> Self {
445        Self::new()
446    }
447}
448impl Drop for vtkSphericalTransform {
449    fn drop(&mut self) {
450        unsafe extern "C" {
451            fn vtkSphericalTransform_destructor(sself: *mut core::ffi::c_void);
452        }
453        unsafe { vtkSphericalTransform_destructor(self.0) }
454        self.0 = core::ptr::null_mut();
455    }
456}
457#[test]
458fn test_vtkSphericalTransform_create_drop() {
459    let obj = vtkSphericalTransform::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 = vtkSphericalTransform(ptr);
465    assert!(unsafe { new_obj._get_ptr().is_null() });
466}
467/// a nonlinear warp transformation
468///
469///
470/// vtkThinPlateSplineTransform describes a nonlinear warp transform defined
471/// by a set of source and target landmarks. Any point on the mesh close to a
472/// source landmark will be moved to a place close to the corresponding target
473/// landmark. The points in between are interpolated smoothly using
474/// Bookstein's Thin Plate Spline algorithm.
475///
476/// To obtain a correct TPS warp, use the R2LogR kernel if your data is 2D, and
477/// the R kernel if your data is 3D. Or you can specify your own RBF. (Hence this
478/// class is more general than a pure TPS transform.)
479/// @warning
480/// 1) The inverse transform is calculated using an iterative method,
481/// and is several times more expensive than the forward transform.
482/// 2) Whenever you add, subtract, or set points you must call Modified()
483/// on the vtkPoints object, or the transformation might not update.
484/// 3) Collinear point configurations (except those that lie in the XY plane)
485/// result in an unstable transformation. Forward transform can be computed
486/// for any configuration by disabling bulk transform regularization.
487/// @sa
488/// vtkGridTransform vtkGeneralTransform
489#[allow(non_camel_case_types)]
490pub struct vtkThinPlateSplineTransform(*mut core::ffi::c_void);
491impl vtkThinPlateSplineTransform {
492    /// Creates a new [vtkThinPlateSplineTransform] wrapped inside `vtkNew`
493    #[doc(alias = "vtkThinPlateSplineTransform")]
494    pub fn new() -> Self {
495        unsafe extern "C" {
496            fn vtkThinPlateSplineTransform_new() -> *mut core::ffi::c_void;
497        }
498        Self(unsafe { &mut *vtkThinPlateSplineTransform_new() })
499    }
500    #[cfg(test)]
501    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
502        unsafe extern "C" {
503            fn vtkThinPlateSplineTransform_get_ptr(
504                sself: *mut core::ffi::c_void,
505            ) -> *mut core::ffi::c_void;
506        }
507        unsafe { vtkThinPlateSplineTransform_get_ptr(self.0) }
508    }
509}
510impl std::default::Default for vtkThinPlateSplineTransform {
511    fn default() -> Self {
512        Self::new()
513    }
514}
515impl Drop for vtkThinPlateSplineTransform {
516    fn drop(&mut self) {
517        unsafe extern "C" {
518            fn vtkThinPlateSplineTransform_destructor(sself: *mut core::ffi::c_void);
519        }
520        unsafe { vtkThinPlateSplineTransform_destructor(self.0) }
521        self.0 = core::ptr::null_mut();
522    }
523}
524#[test]
525fn test_vtkThinPlateSplineTransform_create_drop() {
526    let obj = vtkThinPlateSplineTransform::new();
527    let ptr = obj.0;
528    assert!(!ptr.is_null());
529    assert!(unsafe { !obj._get_ptr().is_null() });
530    drop(obj);
531    let new_obj = vtkThinPlateSplineTransform(ptr);
532    assert!(unsafe { new_obj._get_ptr().is_null() });
533}
534/// describes linear transformations via a 4x4 matrix
535///
536///
537/// A vtkTransform can be used to describe the full range of linear (also
538/// known as affine) coordinate transformations in three dimensions,
539/// which are internally represented as a 4x4 homogeneous transformation
540/// matrix.  When you create a new vtkTransform, it is always initialized
541/// to the identity transformation.
542/// <P>The SetInput() method allows you to set another transform,
543/// instead of the identity transform, to be the base transformation.
544/// There is a pipeline mechanism to ensure that when the input is
545/// modified, the current transformation will be updated accordingly.
546/// This pipeline mechanism is also supported by the Concatenate() method.
547/// <P>Most of the methods for manipulating this transformation,
548/// e.g. Translate, Rotate, and Concatenate, can operate in either
549/// PreMultiply (the default) or PostMultiply mode.  In PreMultiply
550/// mode, the translation, concatenation, etc. will occur before any
551/// transformations which are represented by the current matrix.  In
552/// PostMultiply mode, the additional transformation will occur after
553/// any transformations represented by the current matrix.
554/// <P>This class performs all of its operations in a right handed
555/// coordinate system with right handed rotations. Some other graphics
556/// libraries use left handed coordinate systems and rotations.
557/// @sa
558/// vtkPerspectiveTransform vtkGeneralTransform vtkMatrix4x4
559/// vtkTransformCollection vtkTransformFilter vtkTransformPolyDataFilter
560/// vtkImageReslice
561#[allow(non_camel_case_types)]
562pub struct vtkTransform(*mut core::ffi::c_void);
563impl vtkTransform {
564    /// Creates a new [vtkTransform] wrapped inside `vtkNew`
565    #[doc(alias = "vtkTransform")]
566    pub fn new() -> Self {
567        unsafe extern "C" {
568            fn vtkTransform_new() -> *mut core::ffi::c_void;
569        }
570        Self(unsafe { &mut *vtkTransform_new() })
571    }
572    #[cfg(test)]
573    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
574        unsafe extern "C" {
575            fn vtkTransform_get_ptr(
576                sself: *mut core::ffi::c_void,
577            ) -> *mut core::ffi::c_void;
578        }
579        unsafe { vtkTransform_get_ptr(self.0) }
580    }
581}
582impl std::default::Default for vtkTransform {
583    fn default() -> Self {
584        Self::new()
585    }
586}
587impl Drop for vtkTransform {
588    fn drop(&mut self) {
589        unsafe extern "C" {
590            fn vtkTransform_destructor(sself: *mut core::ffi::c_void);
591        }
592        unsafe { vtkTransform_destructor(self.0) }
593        self.0 = core::ptr::null_mut();
594    }
595}
596#[test]
597fn test_vtkTransform_create_drop() {
598    let obj = vtkTransform::new();
599    let ptr = obj.0;
600    assert!(!ptr.is_null());
601    assert!(unsafe { !obj._get_ptr().is_null() });
602    drop(obj);
603    let new_obj = vtkTransform(ptr);
604    assert!(unsafe { new_obj._get_ptr().is_null() });
605}
606/// describes linear transformations via a 3x3 matrix
607///
608///
609/// A vtkTransform2D can be used to describe the full range of linear (also
610/// known as affine) coordinate transformations in two dimensions,
611/// which are internally represented as a 3x3 homogeneous transformation
612/// matrix.  When you create a new vtkTransform2D, it is always initialized
613/// to the identity transformation.
614///
615/// All multiplicitive operations (Translate, Rotate, Scale, etc) are
616/// post-multiplied in this class (i.e. add them in the reverse of the order
617/// that they should be applied).
618///
619/// This class performs all of its operations in a right handed
620/// coordinate system with right handed rotations. Some other graphics
621/// libraries use left handed coordinate systems and rotations.
622#[allow(non_camel_case_types)]
623pub struct vtkTransform2D(*mut core::ffi::c_void);
624impl vtkTransform2D {
625    /// Creates a new [vtkTransform2D] wrapped inside `vtkNew`
626    #[doc(alias = "vtkTransform2D")]
627    pub fn new() -> Self {
628        unsafe extern "C" {
629            fn vtkTransform2D_new() -> *mut core::ffi::c_void;
630        }
631        Self(unsafe { &mut *vtkTransform2D_new() })
632    }
633    #[cfg(test)]
634    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
635        unsafe extern "C" {
636            fn vtkTransform2D_get_ptr(
637                sself: *mut core::ffi::c_void,
638            ) -> *mut core::ffi::c_void;
639        }
640        unsafe { vtkTransform2D_get_ptr(self.0) }
641    }
642}
643impl std::default::Default for vtkTransform2D {
644    fn default() -> Self {
645        Self::new()
646    }
647}
648impl Drop for vtkTransform2D {
649    fn drop(&mut self) {
650        unsafe extern "C" {
651            fn vtkTransform2D_destructor(sself: *mut core::ffi::c_void);
652        }
653        unsafe { vtkTransform2D_destructor(self.0) }
654        self.0 = core::ptr::null_mut();
655    }
656}
657#[test]
658fn test_vtkTransform2D_create_drop() {
659    let obj = vtkTransform2D::new();
660    let ptr = obj.0;
661    assert!(!ptr.is_null());
662    assert!(unsafe { !obj._get_ptr().is_null() });
663    drop(obj);
664    let new_obj = vtkTransform2D(ptr);
665    assert!(unsafe { new_obj._get_ptr().is_null() });
666}
667/// maintain a list of transforms
668///
669///
670///
671/// vtkTransformCollection is an object that creates and manipulates lists of
672/// objects of type vtkTransform.
673///
674/// @sa
675/// vtkCollection vtkTransform
676#[allow(non_camel_case_types)]
677pub struct vtkTransformCollection(*mut core::ffi::c_void);
678impl vtkTransformCollection {
679    /// Creates a new [vtkTransformCollection] wrapped inside `vtkNew`
680    #[doc(alias = "vtkTransformCollection")]
681    pub fn new() -> Self {
682        unsafe extern "C" {
683            fn vtkTransformCollection_new() -> *mut core::ffi::c_void;
684        }
685        Self(unsafe { &mut *vtkTransformCollection_new() })
686    }
687    #[cfg(test)]
688    unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void {
689        unsafe extern "C" {
690            fn vtkTransformCollection_get_ptr(
691                sself: *mut core::ffi::c_void,
692            ) -> *mut core::ffi::c_void;
693        }
694        unsafe { vtkTransformCollection_get_ptr(self.0) }
695    }
696}
697impl std::default::Default for vtkTransformCollection {
698    fn default() -> Self {
699        Self::new()
700    }
701}
702impl Drop for vtkTransformCollection {
703    fn drop(&mut self) {
704        unsafe extern "C" {
705            fn vtkTransformCollection_destructor(sself: *mut core::ffi::c_void);
706        }
707        unsafe { vtkTransformCollection_destructor(self.0) }
708        self.0 = core::ptr::null_mut();
709    }
710}
711#[test]
712fn test_vtkTransformCollection_create_drop() {
713    let obj = vtkTransformCollection::new();
714    let ptr = obj.0;
715    assert!(!ptr.is_null());
716    assert!(unsafe { !obj._get_ptr().is_null() });
717    drop(obj);
718    let new_obj = vtkTransformCollection(ptr);
719    assert!(unsafe { new_obj._get_ptr().is_null() });
720}
vtk_rs/vtkCommonTransforms.rs

vtk_rs/
vtkCommonTransforms.rs
